Index: /trunk/AddOn/TAcq/brpaqu.cc
===================================================================
--- /trunk/AddOn/TAcq/brpaqu.cc	(revision 3625)
+++ /trunk/AddOn/TAcq/brpaqu.cc	(revision 3626)
@@ -483,6 +483,11 @@
     lostframes += (unsigned long long)delfc - 1;
     if (delfc != 1) { 
-    cnt_pb++; 
-    if (cnt_pb < 5) paq.Print();
+      cnt_pb++; 
+      if (cnt_pb < 5) { 
+        cout << "BRPaqChecker::Check([NumFrameOK=" << nframeok 
+             << ")/Debug  FrameCounter Cur=" << curfc 
+             << " Last=" << frclst << " -> delta=" << delfc << endl;  
+        paq.Print();
+      }
     }
   }
Index: /trunk/AddOn/TAcq/pciewrap.cc
===================================================================
--- /trunk/AddOn/TAcq/pciewrap.cc	(revision 3625)
+++ /trunk/AddOn/TAcq/pciewrap.cc	(revision 3626)
@@ -48,5 +48,6 @@
     bp[kk] = (Byte)(sin(0.0345*kk)*78.+127.5);
 */
-  for(UInt32 kk=0; kk<paq.DataSize(); kk++)
+  UInt32 kkmax = paq.DataSize();
+  for(UInt32 kk=0; kk<kkmax; kk++)
     bp[kk] = (Byte)(kk%200+20);
   tottransfer_ += size_;
Index: /trunk/AddOn/TAcq/racqumem.cc
===================================================================
--- /trunk/AddOn/TAcq/racqumem.cc	(revision 3625)
+++ /trunk/AddOn/TAcq/racqumem.cc	(revision 3626)
@@ -6,5 +6,5 @@
 //----------------------------------------------------------------
 
-
+/* --Methode-- */
 RAcqMemZoneMgr::RAcqMemZoneMgr(uint_4 nz, uint_4 np, uint_4 psz)
   : mex(true), nzones(nz), npaq(np), paqsz(psz), stop_(false)
@@ -12,7 +12,8 @@
   St_MemZ st;
 
+  st.serial = 0;
   st.act = (uint_4)MemZA_None;
-  st.stat = (uint_8)MemZS_Free;
-  for(int k=0; k<3; k++) st.nbact[k] = 0;
+  st.stat = (uint_4)MemZS_Free;
+  for(int k=0; k<6; k++) st.nbact[k] = 0;
   uint_8 mzsz = npaq*paqsz;
 
@@ -21,7 +22,9 @@
      states.push_back(st);
    }
-  
+  serial_ = 0;
+  SetFinalizedMask();
 }
 
+/* --Methode-- */
 RAcqMemZoneMgr::~RAcqMemZoneMgr()
 {
@@ -29,5 +32,12 @@
 }
 
+/* --Methode-- */
 int RAcqMemZoneMgr::FindMemZoneId(MemZaction act)
+// Recherche et renvoie une zone memoire compatible pour effectuer l'operation act
+// Pour act = MemZA_Fill : Zone vide ou satisfaisant la condition mask_finalized_
+// On recherche a chaque fois la zone ayant le plus petit numero de serie 
+// cad le numero d'ordre de remplissage
+// Pour ProcA/B/C on attend que la zone avec le plus petit numero soit disponible
+
 {
   int rid = -1;
@@ -35,12 +45,13 @@
   if ((act != MemZA_Fill) && (act != MemZA_Save) && (act != MemZA_Proc)) return rid;
   mex.lock();
+  uint_8 bestserial = serial_ + 5;
   while ((rid < 0)&&(!stop_)) {
-    switch (act)
-      {
+    switch (act)  {
       case MemZA_Fill:
 	if (rid < 0) for(uint_4 k=0; k<NbZones(); k++) {
 	  if ((states[k].act == MemZA_None) && 
-	      ((states[k].stat == MemZS_Free)||(states[k].stat & MemZS_Saved)) ) 
-	    { rid = k; break; } 
+	      ((states[k].stat == MemZS_Free)||(states[k].stat & mask_finalized_)) ) {
+            if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; } 
+          }
 	}
 	if (rid >= 0) { states[rid].act = MemZA_Fill; states[rid].stat = MemZS_Free; }
@@ -48,6 +59,8 @@
       case MemZA_Save:
 	for(uint_4 k=0; k<NbZones(); k++) {
-	  if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) && 
-	      !(states[k].stat & MemZS_Saved) ) { rid = k; break; } 
+	  if ((states[k].act == MemZA_None) && 
+              (states[k].stat & MemZS_Filled) && !(states[k].stat & MemZS_Saved) ) { 
+            if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; } 
+          } 
 	}
 	if (rid >= 0) states[rid].act = MemZA_Save; 
@@ -55,18 +68,48 @@
       case MemZA_Proc:
 	for(uint_4 k=0; k<NbZones(); k++) {
+	  if ((states[k].act == MemZA_None) && 
+              (states[k].stat & MemZS_Filled) && !(states[k].stat & MemZS_Proc) ) { 
+            if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; } 
+          }
+	}
+	if (rid >= 0) states[rid].act = MemZA_Proc;  
+        break; 	      	  
+      case MemZA_ProcA:
+	for(uint_4 k=0; k<NbZones(); k++) {
 	  if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) && 
-	      !(states[k].stat & MemZS_Proc) ) { rid = k; break; } 
+              !(states[k].stat & MemZS_ProcA) ) { 
+            if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; } 
+          }
 	}
-	if (rid >= 0) states[rid].act = MemZA_Proc;   	      	  
+	if (rid >= 0) states[rid].act = MemZA_ProcA;   	      	  
+	break;
+      case MemZA_ProcB:
+	for(uint_4 k=0; k<NbZones(); k++) {
+	  if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) && 
+              (states[k].stat & MemZS_ProcA) && !(states[k].stat & MemZS_ProcB) ) { 
+            if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; } 
+          }
+	}
+	if (rid >= 0) states[rid].act = MemZA_ProcB;   	      	  
+	break;
+      case MemZA_ProcC:
+	for(uint_4 k=0; k<NbZones(); k++) {
+	  if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) && 
+              (states[k].stat & MemZS_ProcB) && !(states[k].stat & MemZS_ProcC) ) { 
+            if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; } 
+          }
+	}
+	if (rid >= 0) states[rid].act = MemZA_ProcC;   	      	  
 	break;
       case MemZA_None:   // MTQ pour supprimer un warning
 	break;
-      }
+      }  // Fin de switch 
     if (rid < 0)  mex.wait();
-  }
+  }  // Fin de while 
   mex.unlock();
   return rid;
 }
 
+/* --Methode-- */
 int RAcqMemZoneMgr::FreeMemZone(int id, MemZStatus st)
 {
@@ -75,32 +118,54 @@
   mex.lock();
   switch (st) {
-  	case MemZS_Free :
-  	  states[id].stat = MemZS_Free; 
-  	  states[id].act = MemZA_None;
-  	break;
-  	case MemZS_Filled :
-  	  if (states[id].act != MemZA_Fill)  rc = 2;
-  	  else states[id].nbact[0]++;
-  	  states[id].stat |= MemZS_Filled; 
-  	  states[id].act = MemZA_None;
-  	break;
-  	case MemZS_Saved :
-  	  if (states[id].act != MemZA_Save)  rc = 4;
-  	  else states[id].nbact[1]++;  	  
-  	  states[id].stat |= MemZS_Saved; 
-  	  states[id].act = MemZA_None;
-  	break;
-  	case MemZS_Proc :
-  	  if (states[id].act != MemZA_Proc)  rc = 8;
-  	  else states[id].nbact[2]++;  	  
-  	  states[id].stat |= MemZS_Proc; 
-  	  states[id].act = MemZA_None;
-  	break;
-  	default :
-  	  rc = 16;
-  	  states[id].stat = MemZS_Free; 
-  	  states[id].act = MemZA_None;
-  	break;
-  }
+    case MemZS_Free :
+      states[id].serial = 0;
+      states[id].stat = MemZS_Free; 
+      states[id].act = MemZA_None;
+      break;
+    case MemZS_Filled :
+      if (states[id].act != MemZA_Fill)  rc = 2;
+      else states[id].nbact[0]++;
+      serial_ ++;
+      states[id].serial = serial_;
+      states[id].stat |= MemZS_Filled; 
+      states[id].act = MemZA_None;
+      break;
+    case MemZS_Saved :
+      if (states[id].act != MemZA_Save)  rc = 4;
+      else states[id].nbact[1]++;  	  
+      states[id].stat |= MemZS_Saved; 
+      states[id].act = MemZA_None;
+      break;
+    case MemZS_Proc :
+      if (states[id].act != MemZA_Proc)  rc = 8;
+      else states[id].nbact[2]++;  	  
+      states[id].stat |= MemZS_Proc; 
+      states[id].act = MemZA_None;
+      break;
+    case MemZS_ProcA :
+      if (states[id].act != MemZA_ProcA)  rc = 16;
+      else states[id].nbact[3]++;  	  
+      states[id].stat |= MemZS_ProcA; 
+      states[id].act = MemZA_None;
+      break;
+    case MemZS_ProcB :
+      if (states[id].act != MemZA_ProcB)  rc = 32;
+      else states[id].nbact[4]++;  	  
+      states[id].stat |= MemZS_ProcB; 
+      states[id].act = MemZA_None;
+      break;
+    case MemZS_ProcC :
+      if (states[id].act != MemZA_ProcC)  rc = 64;
+      else states[id].nbact[4]++;  	  
+      states[id].stat |= MemZS_ProcC; 
+      states[id].act = MemZA_None;
+      break;
+    default :
+      rc = 128;
+      states[id].serial = 0;
+      states[id].stat = MemZS_Free; 
+      states[id].act = MemZA_None;
+      break;
+  }  // Fin de switch 
   mex.unlock();
   mex.broadcast();
@@ -121,6 +186,7 @@
   for(uint_4 k=0; k<states.size(); k++) 
     os << " [" << k << "] Act=" << states[k].act << " Stat=" << states[k].stat 
-       << " NbAct[0..2]=" << states[k].nbact[0] << "," << states[k].nbact[1]
-       << "," << states[k].nbact[2] << endl; 	
+       << " NbAct[0..5]=" << states[k].nbact[0] << "," << states[k].nbact[1]
+       << "," << states[k].nbact[2] << "," << states[k].nbact[3] 
+       << "," << states[k].nbact[4] << "," << states[k].nbact[5] << endl; 	
   return os;   
 }
Index: /trunk/AddOn/TAcq/racqumem.h
===================================================================
--- /trunk/AddOn/TAcq/racqumem.h	(revision 3625)
+++ /trunk/AddOn/TAcq/racqumem.h	(revision 3626)
@@ -5,4 +5,7 @@
 // ---- classes de gestion memoire pour acquisition BAORadio -----
 // LAL -      R. Ansari - Juin/Juillet 2008 
+//       Modifs Mai 2009 
+//       - Introduction du numero d'ordre de remplissage 
+//       - Introduction de mask de recyclage et sequence de traitement procA/B/C
 //----------------------------------------------------------------
 
@@ -21,21 +24,28 @@
 // Structure de gestion utilisee par la classe RAcqMemMgr
 typedef struct {
-  uint_4 act;
-  uint_4 stat;
-  uint_4 nbact[3]; 
-//  int tid;
+  uint_8 serial;    // Numero de serie permettant d'ordonner en temps les zones memoire rempli
+  uint_4 act;       // Indique l'action en cours sur une zone Fill,Save ...
+  uint_4 stat;      // Champ de flag (bits) indiquant les operations effectuees sur la zone
+  uint_4 nbact[6];  // compteurs nb de fois ou (fill,save,proc,procA/B/C) a ete effectuee sur la zone 
+//  int tid;        Pas utilise pour le moment, permet l'identification du thread operant sur la zone
 } St_MemZ;
 
-enum MemZStatus { MemZS_Free=0, MemZS_Filled=1, MemZS_Saved=2, MemZS_Proc=4 };
-enum MemZaction { MemZA_None=0, MemZA_Fill=1, MemZA_Save=2, MemZA_Proc=4};
+// Les flags (bits) correspondant aux operations effectuees sur une zone
+// Free->libre, Filled->rempli(par DMA), Saved(ecrit sur disque), Proc(Traitement)
+// ProcA/B/C : Trois traitement qui doivent s'enchainer 
+enum MemZStatus { MemZS_Free=0, MemZS_Filled=1, MemZS_Saved=2, MemZS_Proc=4, 
+                  MemZS_ProcA=8, MemZS_ProcB=16, MemZS_ProcC=32 };
+// L'action en cours sur une zone 
+enum MemZaction { MemZA_None=0, MemZA_Fill=1, MemZA_Save=2, MemZA_Proc=4, 
+                  MemZA_ProcA=8, MemZA_ProcB=16, MemZA_ProcC=32 };
 
 // -------------------------------------------------------------------
-// Structure de gestion de zones memoire partagee (des vecteurs) entre
+// Classe de gestion de zones memoire partagee (des buffers) entre
 // threads - qui doivent operer successivement sur les vecteurs
 // -------------------------------------------------------------------
 class RAcqMemZoneMgr {
 public:
-// Constructeur, classe dma, nz=Nb de zones, np=Nb de paquets/zone , psz=taille de paquet
-  RAcqMemZoneMgr(uint_4 nz, uint_4 np=1000, uint_4 psz=4096);
+// Constructeur, nz=Nb de zones, np=Nb de paquets/zone , psz=taille de paquet
+  RAcqMemZoneMgr(uint_4 nz, uint_4 np=256, uint_4 psz=4096);
   ~RAcqMemZoneMgr();
   
@@ -49,4 +59,9 @@
   inline uint_4 ZoneSize() { return npaq*paqsz; }
   
+  // Definit l'etat des operations obligatoires avant qu'une zone 
+  // remplie ne puisse etre recyclee (re-remplie)
+  inline uint_4 SetFinalizedMask(uint_4 mask=((uint_4)MemZS_Saved))
+    { mask_finalized_ = mask; }
+  inline uint_4 GetFinalizedMask() { return mask_finalized_; }
 
   // Retourne un MemZone disponible pour une action specifique
@@ -71,4 +86,6 @@
   vector< St_MemZ > states; 
   bool stop_;
+  uint_4 mask_finalized_;
+  uint_8 serial_;  
 };
 
