Beispiel #1
0
 //template<typename BitPacker>
 public bool encodeOmegaSigned(ref BitPacker packer, int val)
 {
    if (!packer.encodeSmall((ushort)((val < 0) ? 1 : 0), 1))
       return false;
           
    if (val < 0)
       val = -val - 1;
       
    return encodeOmega(ref packer, (uint)val);
 }
Beispiel #2
0
      //template<typename BitPacker>
      public bool encodeOmega(ref BitPacker packer, uint val)
      {
         // Most of the time (94% in a few tests) val was 8 bits or less.
         if (val < OmegaCodeTableSize)
            return packer.encodeSmall(mOmegaCodeTable[val].mCode, mOmegaCodeTable[val].mLen);

         int len;
         UInt64 code = getOmegaCode(out len, val);
                           
         return packer.encode(code, len);
      }
Beispiel #3
0
        public bool DecompressFrame(BTimelineSampleCodec decomp, ref BRetiredProfileSample[] decodedSamplesBuffer)
        {
            BProfileSection[] sections = mSections;

            if (mCompressedFrame == null)
            {
                return(false);
            }
            ICoderBuffer buffer = mCompressedFrame.GetBuffer();

            decomp.resetModel();
            buffer.setPos(0);
            BitPacker             bitPacker = new BitPacker(buffer);
            bool                  success   = bitPacker.decodeStart();
            BRetiredProfileSample decodedSample;
            int i;

            try
            {
                for (i = 0; i < mNumSamples; i++)
                {
                    decodedSample = decodedSamplesBuffer[i];
                    success       = decomp.decodeSample(bitPacker, ref decodedSample, sections);
                    if (success == false)
                    {
                        ErrorHandler.Error(String.Format("Error decompressing sample {0} from frame# {1}", i, this.mFrameNumber));
                        //     return false;
                    }
                    ProcessSample(decodedSample, i);
                }
                mDutyCycle.BuildDutyCycle(ref decodedSamplesBuffer, mNumSamples, false);
                mDutyCycle.mStartTime = mStartTime;

                if (this.mbHasGPUSamples == true)
                {
                    mGpuDutyCycle.BuildDutyCycle(ref decodedSamplesBuffer, mNumSamples, true);
                    mGpuDutyCycle.mStartTime = mStartTime;
                }
                mSamples = decodedSamplesBuffer;
            }
            catch (System.Exception ex)
            {
                ErrorHandler.Error(ex.ToString());
                return(false);
            }
            return(true);
        }
Beispiel #4
0
 //template<typename BitPacker>
 public bool decodeOmegaSigned(ref BitPacker packer, out int Value)
 {
    Value = 0;
    uint signFlag;
    if (!packer.decode(out signFlag, 1))
       return false;
          
    uint uvalue;
    if (!decodeOmega(ref packer, out uvalue))
       return false;
          
    Value = (int)uvalue;
    if (signFlag != 0)
       Value = -Value - 1;
                   
    return true;
 }
Beispiel #5
0
      //template<typename BitPacker>
      public bool decodeOmega(ref BitPacker packer, out uint Value)
      {         
//         if (!(packer.decodeLookahead(1) != 0))
//         {  
//            Value = 0;
//            return packer.decodeRemoveBits(1);
//         }         
         
         uint lookaheadTableOfs = packer.decodeLookahead(LookaheadTableBits);    
         if (-1 != mLookaheadTable[lookaheadTableOfs].mCodeLen)
         {
            packer.decodeRemoveBits(mLookaheadTable[lookaheadTableOfs].mCodeLen);
            Value = mLookaheadTable[lookaheadTableOfs].mCodeVal;
            return true;
         }
         ////////////////////

         Value = 0;
         uint n;

            
         if (!packer.decode(out n, 2))
            return false;
            
         n = mReverseByteTable[n << 6];
            
         while (packer.decodeLookahead(1) != 0)
         {
            /*const*/ int len = (int)(n + 1);
            if (!packer.decode(out n, len))
               return false;

            n = reverseDWORD(n << (32 - len));
         }
            
         BDEBUG_ASSERT(n != 0);
         Value = n - 1;
         return packer.decodeRemoveBits(1);
      }
Beispiel #6
0
        // false on failure
        //template<typename BitPackerType>
        public bool decodeSample(BitPacker bitPacker, ref BRetiredProfileSample decodedSample, /*const*/ /*BAlignedArray<const BProfileSection*>&*/ BProfileSection[] sections)
        {
            if (sections == null)
            {
                ErrorHandler.Error("Can't decompress frame, sections == null!");
                return(false);
            }

            uint sectionID;

            if (-1 == mPrevLevel)
            {
                if (!mCoder.decodeOmega(ref bitPacker, out sectionID))
                {
                    return(false);
                }
            }
            else
            {
                int sectionIDDelta;
                if (!mCoder.decodeOmegaSigned(ref bitPacker, out sectionIDDelta))
                {
                    return(false);
                }
                sectionID = /*static_cast<BSectionID>*/ (ushort)(sectionIDDelta + mSectionPredDataArray[mPrevSectionID].mNextSectionID);
            }

            decodedSample.mSectionID = /*static_cast<BSectionID>*/ (ushort)(sectionID);

            // Sanity check, we should never have more than a few hundred sections!
            if (sectionID >= 512)
            {
                return(false);
            }

            if (sectionID >= size(mSectionPredDataArray))
            {
                resize(ref mSectionPredDataArray, (int)sectionID + 100);//the current resize operation is slow...
            }
            // if this fails the passed in section array wasn't completely up to date
            if (sectionID >= size(sections))
            {
                return(false);
            }

            bool cpuOnly = false;

            if (sections[sectionID] != null)
            {
                /*const*/
                cpuOnly = sections[sectionID].cpuOnly();
            }

            uint /*BCoderTime*/ cpuStartTime = 0;
            uint /*BCoderTime*/ cpuEndTime;
            uint /*BCoderTime*/ cpuDuration;
            uint /*BCoderTime*/ gpuStartTime = 0;
            uint /*BCoderTime*/ gpuEndTime   = 0;
            uint /*BCoderTime*/ gpuDuration  = 0;

            if (-1 == mPrevLevel)
            {
                uint level;
                if (!mCoder.decodeOmega(ref bitPacker, out level))
                {
                    return(false);
                }
                decodedSample.mLevel = /*static_cast<uchar>*/ (byte)(level);
                // sanity check
                if (level >= 128)
                {
                    return(false);
                }

                if (!mCoder.decodeOmega(ref bitPacker, out decodedSample.mUserID))
                {
                    return(false);
                }

                if (!bitPacker.decode(out cpuStartTime, 32))
                {
                    return(false);
                }

                if (!bitPacker.decode(out cpuEndTime, 32))
                {
                    return(false);
                }

                if (!cpuOnly)
                {
                    if (!bitPacker.decode(out gpuStartTime, 32))
                    {
                        return(false);
                    }

                    if (!bitPacker.decode(out gpuEndTime, 32))
                    {
                        return(false);
                    }
                }

                cpuDuration = cpuEndTime - cpuStartTime;
                gpuDuration = gpuEndTime - gpuStartTime;
            }
            else
            {
                int levelDelta;
                if (!mCoder.decodeOmegaSigned(ref bitPacker, out levelDelta))
                {
                    return(false);
                }

                decodedSample.mLevel = /*static_cast<uchar>*/ (byte)(levelDelta + mPrevLevel);

                // Decode user ID - almost always 0, so read a single bit to determine if we need to omega decode the delta.
                int userIDDelta = 0;

                uint userIDDeltaNonZeroFlag;
                if (!bitPacker.decode(out userIDDeltaNonZeroFlag, 1))
                {
                    return(false);
                }
                if (userIDDeltaNonZeroFlag > 0)
                {
                    if (!mCoder.decodeOmegaSigned(ref bitPacker, out userIDDelta))
                    {
                        return(false);
                    }
                }
                decodedSample.mUserID = (uint)(userIDDelta + mPrevUserID);

                // Decode the CPU start time.
                uint predStartCPUTime = mPrevCPUEndTime;
                if (decodedSample.mLevel > mPrevLevel)
                {
                    predStartCPUTime = mPrevCPUStartTime;
                }

                uint deltaStartCPUTime;
                if (!mCoder.decodeOmega(ref bitPacker, out deltaStartCPUTime))
                {
                    return(false);
                }
                cpuStartTime = deltaStartCPUTime + mPrevCPUStartTime;

                // Decode the CPU duration.
                int deltaCPUDuration;
                if (!mCoder.decodeOmegaSigned(ref bitPacker, out deltaCPUDuration))
                {
                    return(false);
                }
                cpuDuration = (uint)(deltaCPUDuration + mSectionPredDataArray[sectionID].mPrevCPUDuration);
                cpuEndTime  = cpuStartTime + cpuDuration;

                if (!cpuOnly)
                {
                    // Decode the GPU start time.
                    uint predStartGPUTime = mPrevGPUEndTime;
                    if (decodedSample.mLevel > mPrevLevel)
                    {
                        predStartGPUTime = mPrevGPUStartTime;
                    }

                    uint deltaStartGPUTime;
                    if (!mCoder.decodeOmega(ref bitPacker, out deltaStartGPUTime))
                    {
                        return(false);
                    }
                    gpuStartTime = deltaStartGPUTime + mPrevGPUStartTime;

                    // Decode the GPU end time.
                    int deltaGPUDuration;
                    if (!mCoder.decodeOmegaSigned(ref bitPacker, out deltaGPUDuration))
                    {
                        return(false);
                    }

                    gpuDuration = (uint)(deltaGPUDuration + mSectionPredDataArray[sectionID].mPrevGPUDuration);
                    gpuEndTime  = gpuStartTime + gpuDuration;
                }
            }

            // Update the model - only record those things we need for speed
            mSectionPredDataArray[sectionID].mPrevCPUDuration    = cpuDuration;
            mSectionPredDataArray[sectionID].mPrevGPUDuration    = gpuDuration;
            mSectionPredDataArray[mPrevSectionID].mNextSectionID = sectionID;

            mPrevLevel        = decodedSample.mLevel;
            mPrevUserID       = decodedSample.mUserID;
            mPrevCPUStartTime = cpuStartTime;
            mPrevCPUEndTime   = cpuEndTime;
            mPrevGPUStartTime = gpuStartTime;
            mPrevGPUEndTime   = gpuEndTime;
            mPrevSectionID    = sectionID;

            decodedSample.mCPUStartTime = cpuStartTime;
            decodedSample.mCPUEndTime   = cpuEndTime;
            decodedSample.mGPUStartTime = 0;
            decodedSample.mGPUEndTime   = 0;
            if (!cpuOnly)
            {
                decodedSample.mGPUStartTime = gpuStartTime;
                decodedSample.mGPUEndTime   = gpuEndTime;
            }

            return(true);
        }
Beispiel #7
0
        // false on failure
        //template<typename BitPackerType>
        public bool codeSample(BitPacker bitPacker, /*const*/ ref BRetiredProfileSample sample, /*const*/ ref BProfileSection pSection)
        {
            if (sample.mSectionID >= size(mSectionPredDataArray))
            {
                resize(ref mSectionPredDataArray, sample.mSectionID + 1);
            }

            /*const*/ uint /*BCoderTime*/ cpuStartTime = sample.mCPUStartTime;
            /*const*/ uint /*BCoderTime*/ cpuEndTime   = sample.mCPUEndTime;
            uint /*BCoderTime*/           gpuStartTime = 0;
            uint /*BCoderTime*/           gpuEndTime   = 0;

            if (!pSection.cpuOnly())
            {
                gpuStartTime = sample.mGPUStartTime;
                gpuEndTime   = sample.mGPUEndTime;
            }
            uint /*BCoderTime*/ cpuDuration = cpuEndTime - cpuStartTime;
            uint /*BCoderTime*/ gpuDuration = gpuEndTime - gpuStartTime;

            if (-1 == mPrevLevel)
            {
                if (!mCoder.encodeOmega(ref bitPacker, sample.mSectionID))
                {
                    return(false);
                }

                // Model is empty - send uncompressed sample
                if (!mCoder.encodeOmega(ref bitPacker, sample.mLevel))
                {
                    return(false);
                }

                if (!mCoder.encodeOmega(ref bitPacker, sample.mUserID))
                {
                    return(false);
                }

                if (!bitPacker.encode(cpuStartTime, 32))
                {
                    return(false);
                }

                if (!bitPacker.encode(cpuEndTime, 32))
                {
                    return(false);
                }

                if (!pSection.cpuOnly())
                {
                    if (!bitPacker.encode(gpuStartTime, 32))
                    {
                        return(false);
                    }

                    if (!bitPacker.encode(gpuEndTime, 32))
                    {
                        return(false);
                    }
                }
            }
            else
            {
                // Compress sample

                // Code the section ID delta
                int sectionIDDelta = (int)(sample.mSectionID - mSectionPredDataArray[mPrevSectionID].mNextSectionID);
                if (!mCoder.encodeOmegaSigned(ref bitPacker, sectionIDDelta))
                {
                    return(false);
                }

                // Code the level delta using 1 or 2 bits [-1, 0, or 1]
                /*const*/ int levelDelta = sample.mLevel - mPrevLevel;
                if (!mCoder.encodeOmegaSigned(ref bitPacker, levelDelta))
                {
                    return(false);
                }

                /*const*/ int userIDDelta = (int)(sample.mUserID - mPrevUserID);
                if (userIDDelta == 0)
                {
                    // Encode single bit to represent userIDDelta == 0.
                    if (!bitPacker.encode((uint)(0), (int)(1)))
                    {
                        return(false);
                    }
                }
                else
                {
                    if (!bitPacker.encode((uint)(1), (int)(1)))
                    {
                        return(false);
                    }

                    if (!mCoder.encodeOmegaSigned(ref bitPacker, userIDDelta))
                    {
                        return(false);
                    }
                }

                uint predStartCPUTime = mPrevCPUEndTime;
                if (sample.mLevel > mPrevLevel)
                {
                    predStartCPUTime = mPrevCPUStartTime;
                }

                //BDEBUG_ASSERT(predStartCPUTime <= cpuStartTime);

                /*const*/ uint deltaStartCPUTime = cpuStartTime - mPrevCPUStartTime;
                if (!mCoder.encodeOmega(ref bitPacker, deltaStartCPUTime))
                {
                    return(false);
                }

                /*const*/ int deltaCPUDuration = (int)(cpuDuration - mSectionPredDataArray[sample.mSectionID].mPrevCPUDuration);
                if (!mCoder.encodeOmegaSigned(ref bitPacker, deltaCPUDuration))
                {
                    return(false);
                }

                if (!pSection.cpuOnly())
                {
                    uint predStartGPUTime = mPrevGPUEndTime;
                    if (sample.mLevel > mPrevLevel)
                    {
                        predStartGPUTime = mPrevGPUStartTime;
                    }

                    if (!sample.hasGPUTimes())
                    {
                        // this should be very rare-- only when the gpu samples time out
                        // we don't want to try encoding a negative start gpu time delta
                        // instead, ensure the gpu times are both equal, which means the sample is invalid
                        gpuStartTime = predStartGPUTime;
                        gpuEndTime   = predStartGPUTime;
                        gpuDuration  = 0;
                    }

                    //BDEBUG_ASSERT(predStartGPUTime <= gpuStartTime);

                    /*const*/ uint deltaStartGPUTime = gpuStartTime - mPrevGPUStartTime;
                    if (!mCoder.encodeOmega(ref bitPacker, deltaStartGPUTime))
                    {
                        return(false);
                    }

                    /*const*/ int deltaGPUDuration = (int)(gpuDuration - mSectionPredDataArray[sample.mSectionID].mPrevGPUDuration);
                    if (!mCoder.encodeOmegaSigned(ref bitPacker, deltaGPUDuration))
                    {
                        return(false);
                    }
                }
            }

            // Update the model - only record those things we need for speed

            mSectionPredDataArray[sample.mSectionID].mPrevCPUDuration = cpuDuration;
            mSectionPredDataArray[sample.mSectionID].mPrevGPUDuration = gpuDuration;
            mSectionPredDataArray[mPrevSectionID].mNextSectionID      = sample.mSectionID;

            mPrevLevel     = sample.mLevel;
            mPrevUserID    = sample.mUserID;
            mPrevSectionID = sample.mSectionID;

            mPrevCPUStartTime = cpuStartTime;
            mPrevCPUEndTime   = cpuEndTime;
            mPrevGPUStartTime = gpuStartTime;
            mPrevGPUEndTime   = gpuEndTime;

            return(true);
        }