Encoding variable-length quanties for MIDI I was reading about the MIDI spec and I challenged myself to implement a function to convert an int32 to a variable length quantity uint32.

I didn't look it up or anything so there might be a way more efficient or tricky way to get the same result, but as far as doing what I set out to accomplish the following code works.

I'm interested to know if anyone can significantly simplify or improve the algorithm that does the conversion, public static uint CalculateEncodedQuantity(int q).

I included the whole thing in case anyone wanted to paste it in to VS.

Specification:


Tests:

using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace VariableLengthRepresentation.Test
{
    [TestClass]
    public class UnitTest1
    {
        [TestMethod]
        public void TestMethod1()
        {
            Assert.AreEqual(0u, new VariableLengthQuantity(0).EncodedQuantity);
            Assert.AreEqual(0x40u, new VariableLengthQuantity(0x40).EncodedQuantity);
            Assert.AreEqual(0x7fu, new VariableLengthQuantity(0x7f).EncodedQuantity);

            //  input:           1000 0000
            // output: 1000 0001 0000 0000
            Assert.AreEqual(0x8100u, new VariableLengthQuantity(0x80).EncodedQuantity);

            //  input: 0010 0000 0000 0000
            // output: 1100 0000 0000 0000
            Assert.AreEqual(0xc000u, new VariableLengthQuantity(0x2000).EncodedQuantity);

            Assert.AreEqual(0xff7fu, new VariableLengthQuantity(0x3fff).EncodedQuantity);
            Assert.AreEqual(0x818000u, new VariableLengthQuantity(0x4000).EncodedQuantity);
            Assert.AreEqual(0xc08000u, new VariableLengthQuantity(0x100000).EncodedQuantity);
            Assert.AreEqual(0xffff7fu, new VariableLengthQuantity(0x1fffff).EncodedQuantity);
            Assert.AreEqual(0x81808000u, new VariableLengthQuantity(0x200000).EncodedQuantity);
            Assert.AreEqual(0xc0808000u, new VariableLengthQuantity(0x8000000).EncodedQuantity);
            Assert.AreEqual(0xffffff7fu, new VariableLengthQuantity(0xfffffff).EncodedQuantity);
        }
    }
}


Implementation:

using System;

namespace VariableLengthRepresentation
{
    public struct VariableLengthQuantity
    {
        public VariableLengthQuantity(int quantity)
        {
            Quantity = quantity;
            EncodedQuantity = CalculateEncodedQuantity(quantity);
        }

        public static uint CalculateEncodedQuantity(int q)
        {
            if (q &gt; 0x0fffffff)
            {
                throw new Exception("Variable length quantity cannot exceed 0x0fffffff.");
            }

            uint n = (uint)q;

            if (n &lt; 128)
                return n;

            var result = new byte[4];

            for (int i = 3; i &gt;= 0; i--)
            {
                result[i] = (byte)(n &amp; 0x7f);

                if(i &lt; 3)
                    result[i] |= 0x80;

                n &gt;&gt;= 7;

                if (n &lt; 1)
                    break;
            }

            if(BitConverter.IsLittleEndian)
                Array.Reverse(result);

            return BitConverter.ToUInt32(result, 0);
        }

        public int Quantity { get; private set; }
        public uint EncodedQuantity { get; private set; }
    }
}
If an argument doesn't fit in the desired range an ArgumentOutOfRangeException should be thrown instead of an Exception.




    for (int i = 3; i &gt;= 0; i--)
    {
        result[i] = (byte)(n &amp; 0x7f);

        if(i &lt; 3)
            result[i] |= 0x80;

        n &gt;&gt;= 7;

        if (n &lt; 1)
            break;
    }  



This can be rewritten to remove the if(i &lt; 3) by starting the loop at 2. The check if (n &lt; 1) can be placed in the loop condition like  

result[3] = (byte)(n &amp; 0x7f);
n &gt;&gt;= 7;  

for (int i = 2; (i &gt;= 0) || (n &gt; 0); i--)
{
    result[i] = ((byte)(n &amp; 0x7f)) | 0x80;
    n &gt;&gt;= 7;
}  




You have some magic numbers in your code. The values 0x0fffffff, 128, 0x7f, 0x80 and 7 should be extracted to descriptive named constants.  



Also there isn't explicitly written anything in any guidelines about braces {} for single instruction if statements I would encourage you to always use them to make your code less error prone.  



You shouldn't shorten variables / parameter names. It is easier to read if the passed in parameter is named quantity instead of q.  



The fact that you are taking care about the Endianess of the system should be stated in a xml documentation.