2009-07-08 13 views
0

Ich habe keine Erfahrung mit Low-Level-Programmierung und ich brauche dieses Stück Code, um [StructLayout (LayoutKind.Explicit)] nicht zu verwenden. Meine Site wird auf einem freigegebenen Host und in mittlerer Vertrauenswürdigkeit ausgeführt. So wird es nicht ausgeführt, wenn dieser Code dort ist.Ersetzen Sie [StructLayout] durch etwas, das System.Runtime.InteropServices nicht verwendet?

Update: Ich benutze dies in einem Octree, um eine PNG-Datei zu quantisieren.

Kennt jemand eine Arbeit herum?

aktualisieren Neue Frage hier =>Is there any way to do Image Quantization safely and with no Marshalling?

/// <summary> 
     /// Struct that defines a 32 bpp colour 
     /// </summary> 
     /// <remarks> 
     /// This struct is used to read data from a 32 bits per pixel image 
     /// in memory, and is ordered in this manner as this is the way that 
     /// the data is layed out in memory 
     /// </remarks> 
     [StructLayout(LayoutKind.Explicit)] 
     public struct Color32 
     { 

      public Color32(IntPtr pSourcePixel) 
      { 
       this = (Color32)Marshal.PtrToStructure(pSourcePixel, typeof(Color32)); 

      } 

      /// <summary> 
      /// Holds the blue component of the colour 
      /// </summary> 
      [FieldOffset(0)] 
      public byte Blue; 
      /// <summary> 
      /// Holds the green component of the colour 
      /// </summary> 
      [FieldOffset(1)] 
      public byte Green; 
      /// <summary> 
      /// Holds the red component of the colour 
      /// </summary> 
      [FieldOffset(2)] 
      public byte Red; 
      /// <summary> 
      /// Holds the alpha component of the colour 
      /// </summary> 
      [FieldOffset(3)] 
      public byte Alpha; 

      /// <summary> 
      /// Permits the color32 to be treated as an int32 
      /// </summary> 
      [FieldOffset(0)] 
      public int ARGB; 

      /// <summary> 
      /// Return the color for this Color32 object 
      /// </summary> 
      public Color Color 
      { 
       get { return Color.FromArgb(Alpha, Red, Green, Blue); } 
      } 
     } 
+0

Was möchten Sie tun? Können Sie nicht einfach die Bitmap-Klasse verwenden? –

+0

Können Sie ein wenig Hintergrundinformationen darüber geben, warum/wie Sie nicht verwalteten Code verwenden? –

+0

Es scheint, er versucht, mit Daten aus einer anderen Quelle mit einer anderen Byte-Reihenfolge zu interferieren – ShuggyCoUk

Antwort

1

Marshal.PtrToStructure Methode (IntPtr, Type) wird sowieso nicht funktionieren, da es

[SecurityPermissionAttribute(
    SecurityAction.LinkDemand, 
    Flags = SecurityPermissionFlag.UnmanagedCode)] 

erfordert könnten Sie mit den Offsets beschäftigen sich sicher, aber Sie würden es zu tun haben, ohne Marschall.
Ich schlage vor, auch für die Einfachheit zu verwenden.

public struct Color32 
{ 
    const uint BlueMask = 0xFF000000;  
    const uint GreenMask = 0x00FF0000; 
    const uint RedMask = 0x0000FF00; 
    const uint AlphaMask = 0x000000FF; 
    const int BlueShift = 24;  
    const int GreenShift = 16; 
    const int RedShift = 8; 
    const int AlphaShift = 0; 

    private byte GetComponent(uint mask, int shift) 
    { 
     var b = (this.ARGB & mask); 
     return (byte) (b >> shift);    
    } 

    private void SetComponent(int shift, byte value) 
    { 
     var b = ((uint)value) << shift 
     this.ARGB |= b; 
    } 

    public byte Blue 
    { 
     get { return GetComponent(BlueMask, BlueShift); } 
     set { SetComponent(BlueShift, value); } 
    } 

    public byte Green 
    { 
     get { return GetComponent(GreenMask, GreenShift); } 
     set { SetComponent(GreenShift, value); } 
    } 

    public byte Red 
    { 
     get { return GetComponent(RedMask, RedShift); } 
     set { SetComponent(RedShift, value); } 
    } 

    public byte Alpha 
    { 
     get { return GetComponent(AlphaMask, AlphaShift); } 
     set { SetComponent(AlphaShift, value); } 
    } 

    /// <summary> 
    /// Permits the color32 to be treated as an UInt32 
    /// </summary> 
    public uint ARGB; 

    /// <summary> 
    /// Return the color for this Color32 object 
    /// </summary> 
    public Color Color 
    { 
     get { return Color.FromArgb(Alpha, Red, Green, Blue); } 
    } 
} 

aber es scheint, dass Sie, was zu tun ist, ein int32 in einem Byte-Reihenfolge auf der Rückseite konvertieren.
Dazu Sie System.Net.IPAddress.HostToNetworkOrder haben (böse Nutzung in diesem Zusammenhang verwenden Sie einfach die Endianess eher umgekehrt als spezifisch zu sein, über die Bestellung Sie beabsichtigen)

so, wenn Sie dann Ihre Eingabedaten als einfache int32 Werte lesen konnte do:

static Color FromBgra(int bgra) 
{ 
    return Color.FromArgb(System.Net.IPAddress.HostToNetworkOrder(bgra)); 
} 

Dies wäre wahrscheinlich viel einfacher.

+0

natürlich können Sie manuell das Get und Set der Komponente inline, wenn Sie wirklich blutende Kante Geschwindigkeit wollen, obwohl es mir scheint, dass einfach die Farbe struct on the fly direkt bei der tatsächlichen Verwendung in der verknüpften Frage wird für besser sein Sie – ShuggyCoUk

+0

THANK you..this wurde der Struktur los, aber ich erkannte, dass mein wirkliches Problem der Marschall ist.Es wird nicht unter mittlerem Vertrauen laufen. –

+0

+1 Sie haben die Strukturfrage beantwortet, also haben Sie es verdient. –

0

Sie konnten die int ARGB nur speichern und verwenden Sie einen BitConverter es um die 4 Bytes für Ihre Farbe Rückkehr zu konvertieren.

Noch besser, speichern Sie einfach den Int, und verwenden Sie Color.FromArgb(Int32).

Beide dieser Ansätze beseitigen die Notwendigkeit, die einzelnen Bytes zu speichern, damit Sie das StructLayout-Attribut vollständig entfernen können.

1

Die Interoperation mit systemeigenem Code und Arbeitsspeicher ist eine inhärent unsichere Operation. Alle Anrufe in die Marshal-Klasse werden ebenfalls fehlschlagen. Sie können nicht auf den Speicher zugreifen oder Interop ausführen, wenn Sie nicht die volle Vertrauensstufe haben.

+0

Ich habe das gerade erkannt. :-( –

Verwandte Themen