¿Práctica recomendada para convertir valores de complemento de 24 bits, little endian, two en ints en C#?

Question

¿Existe una forma rápida e integrada de usar C# para convertir una matriz de tres bytes que representa un valor de 24 bits (pequeño endian, complemento de dos) en un int? ¿Cómo debo ir sobre esto?

Gracias!

Answer 1

Me sorprende que nadie haya sugerido BitConverter todavía. Suponiendo que haya los tres bytes en las variables independientes:

var data = new byte[] 
{ 
    byte0 & 0x80 == 0 ? 0 : 0xFF, byte0, byte1, byte2 
}; 
return BitConverter.ToInt32(data, 0); 

o alternativamente:

var data = new byte[] { byte0, byte1, byte2, 0x00 }; 
return BitConverter.ToInt32(data, 0) >> 8; 

Answer 2

int converted = ((bytes[2] << 24) | (bytes[1] << 16) | (bytes[0] << 8)) >> 8; 

Answer 3

que se quemó por la naturaleza poco endian de la BitConverter vez. Aquí hay un enfoque alternativo: PD: El formato no es poco endian, ¡es al revés con MSB primero !. También he intentado dar formato a la salida un poco, pero no pudo mannually

Salida:

======= de prueba de 24 bits a Int32 (MSB Primera/izquierda) ======= esperado: 8.388.607 Prueba Bit24ToInt32: 8388607 esperado: -1 Prueba Bit24ToInt32: -1 esperado: -8388607 Bit24ToInt32 prueba: -8388607 esperado: 6147053 Bit24ToInt32 prueba: 6147053

esperado: -6147053 Bit24ToInt32 prueba: -6147053

======= Prueba 16 bit a Int32 (MSB First/Left) = ====== esperado: 32767 Bit16ToInt32 prueba: 32.767 esperado: -1 Bit16ToInt32 prueba: -1 esperado: -32767 Bit16ToInt32 prueba: -32767 esperado: 24045 Bit16ToInt32 prueba: 24045

esperado: -24045 Bit16ToInt32 prueba: -24045

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Threading.Tasks; 

namespace BitExperiments 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      //Test 16bit to Int32(MSB First/Left) 
      Console.WriteLine("=======Test 24 bit to Int32 (MSB First/Left)======="); 
      Dictionary<int,byte[]> cases = new Dictionary<int,byte[]>(); 
      byte[] bytearr; 
      int expectedResult; 

      bytearr = new byte[] { 0x7F, 0xFF, 0xFF }; 
      expectedResult= 8388607;//Max 
      cases.Add(expectedResult,bytearr); 

      bytearr = new byte[] { 0xFF, 0xFF, 0xFF }; 
      expectedResult = (-1);//Mid 
      cases.Add(expectedResult,bytearr); 

      bytearr = new byte[] { 0x80, 0x00, 0x01 }; 
      expectedResult = (-8388607);//Min 
      cases.Add(expectedResult,bytearr); 

      bytearr = new byte[] { 0x5D, 0xCB, 0xED }; 
      expectedResult= 6147053;//Random 
      cases.Add(expectedResult,bytearr); 

      bytearr = new byte[] { 0xA2, 0x34, 0x13 }; 
      expectedResult= (-6147053);//Random inverted 
      cases.Add(expectedResult,bytearr); 

      foreach (var value in cases) 
      { 
       Console.WriteLine("Expected: {0} \t\t Bit24ToInt32 Test: {1}", value.Key, Bit24ToInt32(value.Value)); 
      } 

      Console.WriteLine("==================================================="); 
      Console.WriteLine(); 
      //Test 16bit to Int32(MSB First/Left) 
      Console.WriteLine("=======Test 16 bit to Int32 (MSB First/Left)======="); 
      cases.Clear(); 

      bytearr = new byte[] { 0x7F, 0xFF }; 
      expectedResult = 32767;//Max 
      cases.Add(expectedResult, bytearr); 

      bytearr = new byte[] { 0xFF, 0xFF }; 
      expectedResult = (-1);//Mid 
      cases.Add(expectedResult, bytearr); 

      bytearr = new byte[] { 0x80, 0x01 }; 
      expectedResult = (-32767);//Min 
      cases.Add(expectedResult, bytearr); 

      bytearr = new byte[] { 0x5D, 0xED }; 
      expectedResult = 24045;//Random 
      cases.Add(expectedResult, bytearr); 

      bytearr = new byte[] { 0xA2, 0x13 }; 
      expectedResult = (-24045);//Random inverted 
      cases.Add(expectedResult, bytearr); 

      foreach (var value in cases) 
      { 
       Console.WriteLine("Expected: {0} \t\t Bit16ToInt32 Test: {1}", value.Key, Bit16ToInt32(value.Value)); 
      } 
      Console.WriteLine("==================================================="); 
      Console.ReadLine(); 
     } 
     private static int Bit24ToInt32(byte[] byteArray) 
     { 
      int result = ( 
       ((0xFF & byteArray[0]) << 16) | 
       ((0xFF & byteArray[1]) << 8) | 
       (0xFF & byteArray[2]) 
       ); 
      if ((result & 0x00800000) > 0) 
      { 
       result = (int)((uint)result|(uint)0xFF000000); 
      } 
      else 
      { 
       result = (int)((uint)result & (uint)0x00FFFFFF); 
      } 
      return result; 
     } 

     private static int Bit16ToInt32(byte[] byteArray) { 
      int result = (
       ((0xFF & byteArray[0]) << 8) | 
       (0xFF & byteArray[1]) 
      ); 
      if ((result & 0x00008000) > 0) { 
        result = (int) ((uint) result | (uint) 0xFFFF0000); 

      } else { 
        result = (int) ((uint) result & (uint) 0x0000FFFF); 
      } 
      return result; 
      }   
    } 
}