RGB data, endianness - kan det gøres smartere ?

Du kunne sammenligne din metode med Array.Reverse for hver triplet.

Tak for forslaget arne. Jeg har kigget lidt på Array.Reverse; hvilket i dette tilfælde giver marginalt dårligere performance end min egen metode. Jeg antager at det skyldes at jeg skal kalde Array.Reverse for hver triplet; dvs. der er mere overhead til funktionskald.

Jeg har også kigget på Array.Reverse i Reflector, og den gør stort set det samme som min kode. Udover at den først forsøger at kalde en ekstern metode "TrySZReverse"; som i teorien kunne være en mere effektiv implementation - men jeg tvivler.

Andre forslag er velkomne, men ellers lukker jeg spørgsmålet i løbet af et par dage.
arne_v, du må gerne lægge et svar; så du kan få del i points.

Inden man begynder alt for meget at rode i bud osv... så vil det være rart at vide lidt mere om filen gennerelt...

Der må vel være noget HeaderData ect. i filen?... eller lign... for lurede lidt på om man kunne arve fra en BinaryReader og på den måde evt. spare nogle motodekald samt det at flytning af den buffer du arbejder med, og så bare arbejde direkte på den underligende Streams Buffer...

Men det vil kræve en grundig forståelse af hvordan filen er bygget op...

Jeg har eksperimenteret lidt.

Jeg tror at du skal holde dig til din eksisterende kode.

using System;

namespace E
{
    public class Program
    {
        public static void Test1(byte[] b)
        {
            byte tmp;
            for(int i = 0 ; i < b.Length; i += 3)
            {
                tmp = b[i];
                b[i] = b[i + 2];
                b[i + 2] = tmp;
            }   
        }
        public static void Test2(byte[] b)
        {
            for(int i = 0 ; i < b.Length; i += 3)
            {
                Array.Reverse(b, i, 3);
            }   
        }
        public static void Test3(byte[] b)
        {
            unsafe
            {
                fixed(byte *p = &b[0])
                {
                    byte tmp;
                    for(int i = 0 ; i < b.Length; i += 3)
                    {
                        byte *p1 = p + i;
                        byte *p2 = p1 + 2;
                        tmp = *p1;
                        *p1 = *p2;
                        *p2 = tmp;
                    }
                }
            }
        }
        public static void Test4(byte[] b)
        {
            for(int i = 0 ; i < b.Length; i += 3)
            {
                b[i] ^= b[i + 2];
                b[i + 2] ^= b[i];
                b[i] ^= b[i + 2];
            }
           
        }
        public static void Test5(byte[] b)
        {
            unsafe
            {
                fixed(byte *p = &b[0])
                {
                    for(int i = 0 ; i < b.Length; i += 3)
                    {
                        byte *p1 = p + i;
                        byte *p2 = p1 + 2;
                        *p1 ^= *p2;
                        *p2 ^= *p1;
                        *p1 ^= *p2;
                    }
                }
            }
        }
        private const int N = 10000000;
        public static void Main(string[] args)
        {
            byte[] b = new byte[30];
            DateTime dt1 = DateTime.Now;
            for(int i = 0; i < N; i++)
            {
                Test1(b);
            }
            DateTime dt2 = DateTime.Now;
            Console.WriteLine("Original: " + (dt2 - dt1).TotalSeconds);
            DateTime dt3 = DateTime.Now;
            for(int i = 0; i < N; i++)
            {
                Test2(b);
            }
            DateTime dt4 = DateTime.Now;
            Console.WriteLine("Framework: " + (dt4 - dt3).TotalSeconds);
            DateTime dt5 = DateTime.Now;
            for(int i = 0; i < N; i++)
            {
                Test3(b);
            }
            DateTime dt6 = DateTime.Now;
            Console.WriteLine("Unsafe: " + (dt6 - dt5).TotalSeconds);
            DateTime dt7 = DateTime.Now;
            for(int i = 0; i < N; i++)
            {
                Test4(b);
            }
            DateTime dt8 = DateTime.Now;
            Console.WriteLine("Xor: " + (dt8 - dt7).TotalSeconds);
            DateTime dt9 = DateTime.Now;
            for(int i = 0; i < N; i++)
            {
                Test5(b);
            }
            DateTime dt10 = DateTime.Now;
            Console.WriteLine("Unsafe + Xor: " + (dt10 - dt9).TotalSeconds);
            Console.Write("Press any key to continue . . . ");
            Console.ReadKey(true);
        }
    }
}

giver:

Original: 0,625
Framework: 8,9375
Unsafe: 0,40625
Xor: 0,8125
Unsafe + Xor: 0,625

Men jeg vil ikke anbefale brug af unsafe kode.

Og et svar.

Tak for testen, arne.

Jeg havde lidt luret på at en unsafe version ville være hurtigere, da man sparer bounds checket; men den er ikke så meget hurtigere at det kan forsvares, i mit tilfælde.

md_craig >> Godt forslag.