Xune/UIX.RenderApi.Skia/Microsoft/Iris/Render/Protocol/BlobInfo.cs

// Decompiled with JetBrains decompiler
// Type: Microsoft.Iris.Render.Protocol.BlobInfo
// Assembly: UIX.RenderApi, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
// MVID: D47658B8-A8EA-43D6-8837-ECE823BFFFC1
// Assembly location: C:\Program Files\Zune\UIX.RenderApi.dll

using Microsoft.Iris.Render.Common;
using System;

namespace Microsoft.Iris.Render.Protocol
{
  internal struct BlobInfo
  {
    private const int c_SizeOfChar = 2;
    private const int c_SizeOfUInt = 4;
    private Vector m_data;
    private unsafe Message* m_pmsgBlob;
    private uint m_totalSize;
    private uint m_blobsOffset;
    private bool m_foreignByteOrder;
    private static object s_msgBlobSentinal = new object();
    private static Vector s_cache;

    public unsafe BlobInfo(RenderPort port, uint origTotal)
    {
      this.m_foreignByteOrder = port.ForeignByteOrder;
      this.m_data = BlobInfo.s_cache;
      BlobInfo.s_cache = (Vector) null;
      if (this.m_data == null)
        this.m_data = new Vector();
      this.m_totalSize = origTotal;
      this.m_blobsOffset = origTotal;
      this.m_pmsgBlob = (Message*) null;
    }

    public uint AdjustedTotalSize => this.m_totalSize;

    public uint BlobDataSize => this.m_totalSize - this.m_blobsOffset;

    public BLOBREF Add(RENDERHANDLE[] param)
    {
      uint cbData = param == null ? 0U : (uint) (param.Length * 4);
      return this.Add((object) param, cbData);
    }

    public BLOBREF Add(string param)
    {
      if (param == null)
        param = "";
      uint cbData = (uint) ((param.Length + 1) * 2);
      return this.Add((object) param, cbData);
    }

    public unsafe BLOBREF Add(Message* pmsg)
    {
      uint cbData = 0;
      if ((IntPtr) pmsg != IntPtr.Zero)
      {
        this.m_pmsgBlob = pmsg;
        cbData = pmsg->cbSize;
      }
      return this.Add(BlobInfo.s_msgBlobSentinal, cbData);
    }

    private BLOBREF Add(object param, uint cbData)
    {
      Debug2.Validate(cbData < (uint) ushort.MaxValue, typeof (ArgumentException), (object) "data blob too large", (object) nameof (param));
      BLOBREF blobref = BLOBREF.FromUInt32(this.m_totalSize | cbData << 16);
      if (cbData != 0U)
      {
        if (this.m_totalSize + cbData > (uint) ushort.MaxValue)
          throw new InvalidOperationException("insufficient space in message for data blob");
        this.m_totalSize += cbData;
        this.m_data.Add(param);
      }
      return blobref;
    }

    public unsafe void Attach(Message* pMessage)
    {
      byte* numPtr1 = (byte*) ((IntPtr) pMessage + (int) this.m_blobsOffset);
      foreach (object obj in this.m_data)
      {
        if (obj is string)
        {
          string str = (string) obj;
          fixed (char* chPtr1 = str)
          {
            if (!this.m_foreignByteOrder)
            {
              char* chPtr2 = (char*) numPtr1;
              char* chPtr3 = chPtr1;
              char* chPtr4 = chPtr1 + (str.Length + 1);
              while (chPtr3 < chPtr4)
                *chPtr2++ = *chPtr3++;
              numPtr1 = (byte*) chPtr2;
            }
            else
            {
              byte* numPtr2 = (byte*) chPtr1;
              for (byte* numPtr3 = numPtr2 + ((IntPtr) (str.Length + 1) * 2).ToInt64(); numPtr2 < numPtr3; numPtr2 += 2)
              {
                *numPtr1++ = numPtr2[1];
                *numPtr1++ = *numPtr2;
              }
            }
          }
        }
        else if (obj is RENDERHANDLE[])
        {
          RENDERHANDLE[] renderhandleArray = (RENDERHANDLE[]) obj;
          fixed (RENDERHANDLE* renderhandlePtr = renderhandleArray)
          {
            if (!this.m_foreignByteOrder)
            {
              uint* numPtr2 = (uint*) numPtr1;
              uint* numPtr3 = (uint*) renderhandlePtr;
              uint* numPtr4 = numPtr3 + renderhandleArray.Length;
              while (numPtr3 < numPtr4)
                *numPtr2++ = *numPtr3++;
              numPtr1 = (byte*) numPtr2;
            }
            else
            {
              byte* numPtr2 = (byte*) renderhandlePtr;
              for (byte* numPtr3 = numPtr2 + ((IntPtr) renderhandleArray.Length * 4).ToInt64(); numPtr2 < numPtr3; numPtr2 += 4)
              {
                *numPtr1++ = numPtr2[3];
                *numPtr1++ = numPtr2[2];
                *numPtr1++ = numPtr2[1];
                *numPtr1++ = *numPtr2;
              }
            }
          }
        }
        else if (obj == BlobInfo.s_msgBlobSentinal)
        {
          byte* pmsgBlob = (byte*) this.m_pmsgBlob;
          byte* numPtr2 = pmsgBlob + (int) this.m_pmsgBlob->cbSize;
          while (pmsgBlob < numPtr2)
            *numPtr1++ = *pmsgBlob++;
        }
        else
          Debug2.Throw(false, "Unexpected type.");
      }
      this.m_data.Clear();
      BlobInfo.s_cache = this.m_data;
      this.m_data = (Vector) null;
    }
  }
}