home *** CD-ROM | disk | FTP | other *** search
/ Computer Shopper 242 / Issue 242 - April 2008 - DPCS0408DVD.ISO / Software Money Savers / VirtualDub / Source / VirtualDub-1.7.7-src.7z / src / system / source / profile.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2006-11-05  |  4.0 KB  |  156 lines
  1. //    VirtualDub - Video processing and capture application
  2. //    System library component
  3. //    Copyright (C) 1998-2004 Avery Lee, All Rights Reserved.
  4. //
  5. //    Beginning with 1.6.0, the VirtualDub system library is licensed
  6. //    differently than the remainder of VirtualDub.  This particular file is
  7. //    thus licensed as follows (the "zlib" license):
  8. //
  9. //    This software is provided 'as-is', without any express or implied
  10. //    warranty.  In no event will the authors be held liable for any
  11. //    damages arising from the use of this software.
  12. //
  13. //    Permission is granted to anyone to use this software for any purpose,
  14. //    including commercial applications, and to alter it and redistribute it
  15. //    freely, subject to the following restrictions:
  16. //
  17. //    1.    The origin of this software must not be misrepresented; you must
  18. //        not claim that you wrote the original software. If you use this
  19. //        software in a product, an acknowledgment in the product
  20. //        documentation would be appreciated but is not required.
  21. //    2.    Altered source versions must be plainly marked as such, and must
  22. //        not be misrepresented as being the original software.
  23. //    3.    This notice may not be removed or altered from any source
  24. //        distribution.
  25.  
  26. #include "stdafx.h"
  27. #include <windows.h>
  28. #include <vd2/system/profile.h>
  29.  
  30. ///////////////////////////////////////////////////////////////////////////
  31.  
  32. VDRTProfiler *g_pCentralProfiler;
  33.  
  34. void VDInitProfilingSystem() {
  35.     if (!g_pCentralProfiler)
  36.         g_pCentralProfiler = new VDRTProfiler;
  37. }
  38.  
  39. void VDDeinitProfilingSystem() {
  40.     delete g_pCentralProfiler;
  41.     g_pCentralProfiler = 0;
  42. }
  43.  
  44. VDRTProfiler *VDGetRTProfiler() {
  45.     return g_pCentralProfiler;
  46. }
  47.  
  48. ///////////////////////////////////////////////////////////////////////////
  49.  
  50. VDRTProfiler::VDRTProfiler()
  51.     : mbEnableCollection(false)
  52. {
  53.     LARGE_INTEGER freq;
  54.     QueryPerformanceFrequency(&freq);
  55.     mPerfFreq = freq.QuadPart;
  56. }
  57.  
  58. VDRTProfiler::~VDRTProfiler() {
  59. }
  60.  
  61. void VDRTProfiler::BeginCollection() {
  62.     mbEnableCollection = true;
  63. }
  64.  
  65. void VDRTProfiler::EndCollection() {
  66.     mbEnableCollection = false;
  67. }
  68.  
  69. void VDRTProfiler::Swap() {
  70.     vdsynchronized(mcsChannels) {
  71.         LARGE_INTEGER tim;
  72.         QueryPerformanceCounter(&tim);
  73.  
  74.         mSnapshotTime = tim.QuadPart;
  75.  
  76.         mChannelArrayToPaint.resize(mChannelArray.size());
  77.  
  78.         for(uint32 i=0; i<mChannelArray.size(); ++i) {
  79.             Channel& src = mChannelArray[i];
  80.             Channel& dst = mChannelArrayToPaint[i];
  81.  
  82.             dst.mpName = src.mpName;
  83.  
  84.             dst.mEventList.clear();
  85.             dst.mEventList.swap(src.mEventList);
  86.             if (src.mbEventPending) {
  87.                 src.mEventList.push_back(dst.mEventList.back());
  88.                 dst.mEventList.back().mEndTime = mSnapshotTime;
  89.             }
  90.         }
  91.     }
  92. }
  93.  
  94. int VDRTProfiler::AllocChannel(const char *name) {
  95.     uint32 i;
  96.  
  97.     vdsynchronized(mcsChannels) {
  98.         const uint32 nChannels = mChannelArray.size();
  99.  
  100.         for(i=0; i<nChannels; ++i)
  101.             if (!mChannelArray[i].mpName)
  102.                 break;
  103.  
  104.         if (mChannelArray.size() <= i)
  105.             mChannelArray.resize(i + 1);
  106.  
  107.         mChannelArray[i].mpName = name;
  108.         mChannelArray[i].mbEventPending = false;
  109.     }
  110.  
  111.     return (int)i;
  112. }
  113.  
  114. void VDRTProfiler::FreeChannel(int ch) {
  115.     vdsynchronized(mcsChannels) {
  116.         mChannelArray[ch].mpName = 0;
  117.         mChannelArray[ch].mEventList.clear();
  118.     }
  119. }
  120.  
  121. void VDRTProfiler::BeginEvent(int channel, uint32 color, const char *name) {
  122.     if (mbEnableCollection) {
  123.         LARGE_INTEGER tim;
  124.         QueryPerformanceCounter(&tim);
  125.         vdsynchronized(mcsChannels) {
  126.             Channel& chan = mChannelArray[channel];
  127.  
  128.             if (!chan.mbEventPending) {
  129.                 chan.mbEventPending = true;
  130.                 chan.mEventList.push_back(Event());
  131.                 Event& ev = chan.mEventList.back();
  132.                 ev.mpName = name;
  133.                 ev.mColor = color;
  134.                 ev.mStartTime = tim.QuadPart;
  135.                 ev.mEndTime = tim.QuadPart;
  136.             }
  137.         }
  138.     }
  139. }
  140.  
  141. void VDRTProfiler::EndEvent(int channel) {
  142.     if (mbEnableCollection) {
  143.         LARGE_INTEGER tim;
  144.  
  145.         QueryPerformanceCounter(&tim);
  146.         vdsynchronized(mcsChannels) {
  147.             Channel& chan = mChannelArray[channel];
  148.  
  149.             if (chan.mbEventPending) {
  150.                 chan.mEventList.back().mEndTime = tim.QuadPart;
  151.                 chan.mbEventPending = false;
  152.             }
  153.         }
  154.     }
  155. }
  156.