prj/tech/libsrc/recorder/recorder.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // $Source: x:/prj/tech/libsrc/recorder/RCS/recorder.cpp $
   3 // $Author: JAEMZ $
   4 // $Date: 1997/09/28 20:27:21 $
   5 // $Revision: 1.20 $
   6 //
   7
   8 #include <comtools.h>
   9 #include <lg.h>
  10 #include <appapi.h>
  11 #include <appagg.h>
  12 #include <aggmemb.h>
  13
  14 #include <recorder.h>
  15 #include <recprmpt.h>
  16
  17 #include <filepath.h>
  18 #include <fcntl.h>
  19 #include <io.h>
  20 #include <sys\stat.h>
  21 #include <sys\types.h>
  22 #include <time.h>    // time, localtime
  23 #include <string.h>  // strncat
  24 #include <stdlib.h>  // getenv
  25 #include <str.h>
  26
  27 ///////////////////////////////////////////////////////////////////////////////
  28
  29 #ifdef _WIN32
  30 extern "C"
  31 {
  32 __declspec(dllimport) DWORD __stdcall GetCurrentThreadId(void);
  33 };
  34 #define AssertCorrectThread() AssertMsg(GetCurrentThreadId() == m_ThreadRecordingId, "Cannot record actions in multiple threads.");
  35 #else
  36 #define AssertCorrectThread()
  37 #endif
  38
  39 const unsigned kRecVersion = 3;
  40
  41 ///////////////////////////////////////////////////////////////////////////////
  42
  43 tResult LGAPI
  44 _RecorderCreate(REFIID, IRecorder ** /* ppRecorder */ ,
  45                 IUnknown * pOuterUnknown, eRecMode mode,
  46                 const char * pszRecFilepath, const char * pszRecFileName,
  47                 enum eRecSaveOption fSaveOption)
  48 {
  49     if (new cRecorder(pOuterUnknown, mode, pszRecFilepath, pszRecFileName, fSaveOption) != 0)
  50         return S_OK;
  51     return E_FAIL;
  52 }
  53
  54 ///////////////////////////////////////////////////////////////////////////////
  55 //
  56 // CLASS: cRecorder
  57 //
  58 // Implementation of generic record/playback system
  59 //
  60
  61 ///////////////////////////////////////
  62 //
  63 // Pre-fab COM implementations
  64 //
  65 IMPLEMENT_SIMPLE_AGGREGATION_SELF_DELETE(cRecorder);
  66
  67 ///////////////////////////////////////
  68
  69 cRecorder::cRecorder(IUnknown * pOuterUnknown, eRecMode mode,
  70                      const char * pszRecFilepath, const char *pszRecFileName,
  71                      eRecSaveOption fSaveOption)
  72   : m_mode(mode),
  73     m_RecFile(-1),
  74     m_fSaveOption(fSaveOption),
  75     m_fFirstAccess(TRUE)
  76 #ifdef _WIN32
  77     , m_ThreadRecordingId(GetCurrentThreadId())
  78 #endif
  79 {
  80     // Add internal components to outer aggregate...
  81     INIT_AGGREGATION_1( pOuterUnknown,
  82                         IID_IRecorder, this,
  83                         (kPriorityLibrary - 1),
  84                         NULL );
  85
  86     // Set the file name...
  87     if (pszRecFileName && *pszRecFileName)
  88         m_RecFileSpec.SetRelativePath(pszRecFileName);
  89     else
  90     {
  91         // Build an unique string based upon the user's login name, current
  92         // date and time.
  93         char            szGeneratedFileName[13];
  94         const char *    pszUserName     = getenv("USER");
  95         time_t          lTime           = time(NULL);
  96         tm *            pTm             = localtime(&lTime);
  97
  98         if (pszUserName)
  99         {
 100             strncpy(szGeneratedFileName, pszUserName, 3);
 101             szGeneratedFileName[3] = 0;
 102         }
 103         else
 104             strcpy(szGeneratedFileName, "REC");
 105
 106         itoa((pTm->tm_yday << 11) | (pTm->tm_min + (pTm->tm_hour * 60)), szGeneratedFileName + 3, 16);
 107         strcat(szGeneratedFileName, ".rec");
 108         m_RecFileSpec.SetRelativePath(szGeneratedFileName);
 109     }
 110
 111     // Complete the file path...
 112     if (pszRecFilepath && *pszRecFilepath)
 113     {
 114         m_RecFileSpec.SetFilePath(pszRecFilepath);
 115     }
 116
 117     m_RecFileSpec.MakeFullPath();
 118
 119     // Open the recording file...
 120     if (m_RecFileSpec.FileExists())
 121     {
 122         if (m_mode == kRecRecord)
 123             m_RecFileSpec.UnlinkFile();
 124     }
 125     else
 126     {
 127         if (m_mode == kRecPlayback)
 128             m_mode = kRecInactive;
 129     }
 130
 131     if (m_mode == kRecInactive)
 132         return;
 133
 134     int access = _O_BINARY;
 135
 136     if (m_mode == kRecPlayback)
 137         access |= _O_RDONLY;
 138     else
 139         access |= _O_RDWR | _O_CREAT | _O_TRUNC;
 140
 141     m_RecFile = open(m_RecFileSpec.GetName(), access, S_IREAD | S_IWRITE);
 142
 143     if (m_RecFile == -1)
 144     {
 145         CriticalMsg1("Failed to open recording file %s", m_RecFileSpec.GetName());
 146         m_mode = kRecInactive;
 147         return;
 148     }
 149
 150     m_pszLastStreamItem = "(no previous)";
 151     m_sizeLastItem = 0;
 152
 153 }
 154
 155 ///////////////////////////////////////
 156
 157 cRecorder::~cRecorder()
 158 {
 159     // Delete the hash table entries
 160
 161     // Close the recording file
 162     if (m_RecFile != -1)
 163         close(m_RecFile);
 164
 165     switch (m_fSaveOption)
 166     {
 167         case kRecSavePrompted:
 168             if (RecPromptYesNo("Save recording file?"))
 169                 break;
 170             // else fall through
 171
 172         case kRecDiscardIfNoFailure:
 173             m_RecFileSpec.UnlinkFile();
 174     }
 175 }
 176
 177 ///////////////////////////////////////
 178
 179 const uint8 kRecTypeDesc     = 1;
 180 const uint8 kRecTypedData    = 2;
 181 const uint8 kRecRawData      = 3;
 182
 183 #pragma pack(1)
 184 struct sRecBlockHeader
 185 {
 186     tRecBlockType blockType;
 187
 188     union
 189     {
 190         // Type descriptor
 191         uint8 typeSize;
 192
 193         // Typed data
 194         uint8 typeID;
 195
 196         // Raw data
 197         uint8 rawSize;
 198     };
 199 };
 200 #pragma pack()
 201
 202 ///////////////////////////////////////
 203
 204 inline BOOL cRecorder::WriteBlock(tRecBlockType type, uint8 dataInfo, const void * pData, size_t dataSize)
 205 {
 206     write(m_RecFile, &type, sizeof(type));
 207     write(m_RecFile, &dataInfo, sizeof(dataInfo));
 208     return write(m_RecFile, pData, dataSize) == dataSize;
 209 }
 210
 211 ///////////////////////////////////////
 212
 213 inline BOOL cRecorder::ReadBlockHeader(sRecBlockHeader * pHeader)
 214 {
 215     return read(m_RecFile, pHeader, sizeof(sRecBlockHeader)) == sizeof(sRecBlockHeader);
 216 }
 217
 218 ///////////////////////////////////////
 219
 220 inline BOOL cRecorder::ReadBlockData(void * pReadTo, size_t size)
 221 {
 222     return read(m_RecFile, pReadTo, size) == size;
 223 }
 224
 225 ///////////////////////////////////////
 226 //
 227 // Query the present recorder mode
 228 //
 229
 230 STDMETHODIMP_(eRecMode) cRecorder::GetMode()
 231 {
 232     return m_mode;
 233 }
 234
 235 ///////////////////////////////////////
 236
 237 STDMETHODIMP cRecorder::StreamAddOrExtract(void * pData, size_t sizeData , const char * pszTypeTag)
 238 {
 239     // We call directly to cRecorder here to save the cost of the virtual function, remove
 240     // if these are overridden at a later date (toml 09-30-96)
 241     switch (m_mode)
 242     {
 243         case kRecRecord:
 244         {
 245             return cRecorder::AddToStream(pData, sizeData, pszTypeTag);
 246         }
 247         case kRecPlayback:
 248         {
 249             return cRecorder::ExtractFromStream(pData, sizeData, pszTypeTag);
 250         }
 251     }
 252     return S_OK;
 253 }
 254
 255 ///////////////////////////////////////
 256 //
 257 // Add arbitrary data to recording stream
 258 //
 259
 260 STDMETHODIMP cRecorder::AddToStream(void *pData, size_t sizeData, const char *pszTypeTag)
 261 {
 262     AssertCorrectThread();
 263     AssertMsg(m_mode != kRecPlayback, "Can't AddToStream() when playing back");
 264
 265     // If this is the first use...
 266     if (m_fFirstAccess)
 267     {
 268         // ... write the recording header
 269         AutoAppIPtr(Application);
 270         const char pcszRecHeader[] = "---\r\nProject: %s\r\nUser: %s\r\nDate/Time: %s\r\nLGT Recording System Version %d\r\n---\r\n\x1a";
 271
 272         const char * pszProject;
 273         if ((void *)pApplication && pApplication->GetCaption())
 274             pszProject = pApplication->GetCaption();
 275         else
 276             pszProject = "Unknown";
 277         const char *    pszUser     = (getenv("USER")) ? getenv("USER") : "Unknown";
 278         time_t          lTime       = time(NULL);
 279         tm *            pTm         = localtime(&lTime);
 280
 281         cStr recHeaderStr;
 282         recHeaderStr.FmtStr(pcszRecHeader, pszProject, pszUser, asctime(pTm), kRecVersion);
 283         write(m_RecFile, recHeaderStr.operator const char *(), recHeaderStr.GetLength() + 1);
 284         write(m_RecFile, &kRecVersion, sizeof(kRecVersion));
 285         m_fFirstAccess = FALSE;
 286     }
 287
 288     // If the stream addition is typed...
 289     if (pszTypeTag)
 290     {
 291         // Determine if this is a new type name, if not, add it
 292         sRecDataType *pDataType = m_RecDataTypeTable.Search(pszTypeTag);
 293
 294         if (!pDataType)
 295         {
 296             AssertMsg1(strlen(pszTypeTag) <= kMaxTypeNameLen, "Type name \"%s\" too long for recorder", pszTypeTag);
 297             AssertMsg1(sizeData <= kRecMaxDataSize, "Type \"%s\" too big for recorder -- record it in smaller pieces", pszTypeTag);
 298             AssertMsg1(m_RecDataTypeTable.GetCount() < kMaxTypes, "Type \"%s\" exceeds total maximum of recordable types", pszTypeTag);
 299
 300             pDataType = NewRecDataType();
 301
 302             pDataType->typeSize = (uint8)sizeData;
 303             strncpy(pDataType->typeName, pszTypeTag, kMaxTypeNameLen);
 304             pDataType->typeName[kMaxTypeNameLen] = '\0';
 305
 306             // Add the new type to the hash table.
 307             m_RecDataTypeTable.Insert(pDataType);
 308
 309             // Write out the new type block
 310             if (!WriteBlock(kRecTypeDesc, pDataType->typeSize, pDataType->typeName, kMaxTypeNameLen + 1))
 311             {
 312                 CriticalMsg("Error writing to recording");
 313                 m_mode = kRecInactive;
 314                 return E_FAIL;
 315             }
 316         }
 317
 318         // Verify type size now is same as previous add
 319         if (pDataType->typeSize != sizeData)
 320         {
 321             CriticalMsg("Invalid size for recording data");
 322             m_mode = kRecInactive;
 323             return E_FAIL;
 324         }
 325
 326         // Write the data, typed
 327         if (!WriteBlock(kRecTypedData, pDataType->typeID, pData, sizeData))
 328         {
 329             CriticalMsg("Error writing to recording");
 330             m_mode = kRecInactive;
 331             return E_FAIL;
 332         }
 333     }
 334     else
 335     {
 336         // Write the data, raw
 337         if (!WriteBlock(kRecRawData, (uint8)sizeData, pData, sizeData))
 338         {
 339             CriticalMsg("Error writing to recording");
 340             m_mode = kRecInactive;
 341             return E_FAIL;
 342         }
 343     }
 344
 345     return S_OK;
 346 }
 347
 348 ///////////////////////////////////////
 349 //
 350 // Extract arbitrary data from recording stream
 351 //
 352
 353 STDMETHODIMP cRecorder::ExtractFromStream(void *pData, size_t sizeData, const char *pszTypeTag)
 354 {
 355     AssertCorrectThread();
 356     AssertMsg(m_mode != kRecRecord, "Can't ExtractFromStream() when recording");
 357
 358     if (m_fFirstAccess)
 359     {
 360         char c;
 361         int version;
 362
 363         // Skip header text
 364         do
 365         {
 366             read(m_RecFile, &c, 1);
 367         } while (c);
 368
 369         read(m_RecFile, &version, sizeof(version));
 370         if (version != kRecVersion)
 371         {
 372             CriticalMsg2("Cannot use recording -- incompatible recorder version\nRecording is from version %d, current is %d", version, kRecVersion);
 373             m_mode = kRecInactive;
 374             return S_FALSE;
 375         }
 376         m_fFirstAccess = FALSE;
 377     }
 378
 379     ///////////////////////////////////
 380
 381     sRecBlockHeader header;
 382
 383     enum eRecReadState
 384     {
 385         kReading,
 386         kDoneSuccess,
 387         kDoneInconsistentType,
 388         kDoneExpectedTag,
 389         kDoneBadRead,
 390     };
 391
 392     const char * ppszReadErrors[] =
 393     {
 394         "Still reading",
 395         "No error",
 396         "Inconsistent type",
 397         "Expected typed data",
 398         "Bad read",
 399     };
 400
 401     const char * pszThisStreamItem = "<unknown>";
 402     size_t       sizeThisItem = 0;
 403
 404     eRecReadState   readState       = kReading;
 405     BOOL            fEndOfRecording = TRUE;
 406
 407     while (readState == kReading && ReadBlockHeader(&header))
 408     {
 409         fEndOfRecording = FALSE;
 410         switch (header.blockType)
 411         {
 412             case kRecTypeDesc:
 413             {
 414                 if (pszTypeTag)
 415                 {
 416                     sRecDataType * pNewDataType = NewRecDataType();
 417                     pNewDataType->typeSize = header.typeSize;
 418                     ReadBlockData(pNewDataType->typeName, kMaxTypeNameLen + 1);
 419
 420                     m_RecDataTypeTable.Insert(pNewDataType);
 421
 422                     pszThisStreamItem = "new data type";
 423                     sizeThisItem = header.typeSize;
 424
 425                     if (strcmp(pNewDataType->typeName, pszTypeTag) != 0 || pNewDataType->typeSize != sizeData) // New type should match client value
 426                         readState = kDoneInconsistentType;
 427
 428                     // else state continues to be kReading
 429                 }
 430                 else
 431                     readState = kDoneExpectedTag;
 432                 break;
 433             }
 434
 435             case kRecTypedData:
 436             {
 437                 if (pszTypeTag)
 438                 {
 439                     sRecDataType * pDataType = m_RecDataTypeTable.Search(pszTypeTag);
 440
 441                     pszThisStreamItem = m_RecDataTypesArray[header.typeID].typeName;
 442                     sizeThisItem = m_RecDataTypesArray[header.typeID].typeSize;
 443
 444                     if (pDataType && pDataType->typeID == header.typeID && sizeThisItem == sizeData)
 445                     {
 446                         if (ReadBlockData(pData, sizeData))
 447                             readState = kDoneSuccess;
 448                         else
 449                             readState = kDoneBadRead;
 450                     }
 451                     else
 452                         readState = kDoneInconsistentType;
 453                 }
 454                 else
 455                     readState = kDoneExpectedTag;
 456                 break;
 457             }
 458
 459             case kRecRawData:
 460             {
 461                 pszThisStreamItem = "raw data";
 462                 sizeThisItem = header.rawSize;
 463
 464                 if (header.rawSize == sizeData)
 465                 {
 466                     if (ReadBlockData(pData, sizeData))
 467                         readState = kDoneSuccess;
 468                     else
 469                         readState = kDoneBadRead;
 470                 }
 471                 else
 472                     readState = kDoneInconsistentType;
 473                 break;
 474             }
 475
 476             default:
 477                 CriticalMsg("Error in playback stream: unknown recording file block type");
 478                 readState = kDoneBadRead;
 479         }
 480     }
 481
 482     ///////////////////////////////////
 483
 484     if (readState != kDoneSuccess)
 485     {
 486         AssertMsg7(fEndOfRecording, "Playback error \"%s\".\n"
 487                                     "Expected %s sized %u,\n"
 488                                     "Got %s sized %u,\n"
 489                                     "Last was %s sized %u.\n"
 490                                     "Recording is inconsistent and/or invalid.",
 491                                     ppszReadErrors[readState],
 492                                     (pszTypeTag) ? pszTypeTag : "raw data",
 493                                     sizeData,
 494                                     pszThisStreamItem,
 495                                     sizeThisItem,
 496                                     m_pszLastStreamItem,
 497                                     m_sizeLastItem);
 498         m_mode = kRecInactive;
 499         return (fEndOfRecording) ? S_FALSE : E_FAIL;
 500     }
 501
 502     m_pszLastStreamItem = pszThisStreamItem;
 503     m_sizeLastItem      = sizeThisItem;
 504
 505     return S_OK;
 506 }
 507
 508 ///////////////////////////////////////
 509
 510 STDMETHODIMP cRecorder::Pause()
 511 {
 512     int recorderPauseMarker = 0;
 513
 514     switch (m_mode)
 515     {
 516         case kRecRecord:
 517         {
 518             m_mode = kRecPausedRecord;
 519             break;
 520         }
 521         case kRecPlayback:
 522         {
 523             m_mode = kRecPausedPlayback;
 524             break;
 525         }
 526     }
 527     StreamAddOrExtract(&recorderPauseMarker, sizeof(recorderPauseMarker), "Record pause marker");
 528     return S_OK;
 529 }
 530
 531 ///////////////////////////////////////
 532
 533 STDMETHODIMP cRecorder::Resume()
 534 {
 535     int recorderResumeMarker = 0;
 536
 537     switch (m_mode)
 538     {
 539         case kRecPausedRecord:
 540         {
 541             m_mode = kRecRecord;
 542             break;
 543         }
 544         case kRecPausedPlayback:
 545         {
 546             m_mode = kRecPlayback;
 547             break;
 548         }
 549         default:
 550             CriticalMsg("Called recorder resume when not paused");
 551     }
 552     StreamAddOrExtract(&recorderResumeMarker, sizeof(recorderResumeMarker), "Record resume marker");
 553     return S_OK;
 554 }
 555
 556 ///////////////////////////////////////////////////////////////////////////////
 557
 558 tHashSetKey cRecDataTypeTable::GetKey(tHashSetNode node) const
 559 {
 560     return (tHashSetKey) (((sRecDataType *) (node))->typeName);
 561 }
 562
 563 ///////////////////////////////////////////////////////////////////////////////