मेरे सुरक्षित कोड से मेरा असुरक्षित कोड ब्लॉक धीमा क्यों है?

Question

मैं कुछ कोड लिखने का प्रयास कर रहा हूं जो तेजी से वीडियो फ्रेम को संसाधित करेगा। मैं फ्रेम को System.Windows.Media.Imaging.WriteableBitmap के रूप में प्राप्त कर रहा हूं। परीक्षण उद्देश्यों के लिए, मैं बस एक साधारण थ्रेसहोल्ड फ़िल्टर लागू कर रहा हूं जो बीजीआरए प्रारूप छवि को संसाधित करेगा और प्रत्येक पिक्सेल को बीजीआर पिक्सेल के औसत के आधार पर काला या सफेद रंग देने के लिए असाइन करेगा।

यहाँ मेरी "सुरक्षित" संस्करण है:

public static void ApplyFilter(WriteableBitmap Bitmap, byte Threshold) 
{ 
    // Let's just make this work for this format 
    if (Bitmap.Format != PixelFormats.Bgr24 
     && Bitmap.Format != PixelFormats.Bgr32) 
    { 
     return; 
    } 

    // Calculate the number of bytes per pixel (should be 4 for this format). 
    var bytesPerPixel = (Bitmap.Format.BitsPerPixel + 7)/8; 

    // Stride is bytes per pixel times the number of pixels. 
    // Stride is the byte width of a single rectangle row. 
    var stride = Bitmap.PixelWidth * bytesPerPixel; 

    // Create a byte array for a the entire size of bitmap. 
    var arraySize = stride * Bitmap.PixelHeight; 
    var pixelArray = new byte[arraySize]; 

    // Copy all pixels into the array 
    Bitmap.CopyPixels(pixelArray, stride, 0); 

    // Loop through array and change pixels to black/white based on threshold 
    for (int i = 0; i < pixelArray.Length; i += bytesPerPixel) 
    { 
     // i=B, i+1=G, i+2=R, i+3=A 
     var brightness = 
       (byte)((pixelArray[i] + pixelArray[i+1] + pixelArray[i+2])/3); 

     var toColor = byte.MinValue; // Black 

     if (brightness >= Threshold) 
     { 
      toColor = byte.MaxValue; // White 
     } 

     pixelArray[i] = toColor; 
     pixelArray[i + 1] = toColor; 
     pixelArray[i + 2] = toColor; 
    } 
    Bitmap.WritePixels(
     new Int32Rect(0, 0, Bitmap.PixelWidth, Bitmap.PixelHeight), 
     pixelArray, stride, 0 
    ); 
} 

यहाँ है मैं क्या सोचता एक असुरक्षित कोड ब्लॉक और forebuffer के बजाय WriteableBitmap वापस बफर का उपयोग कर एक सीधा अनुवाद है:

public static void ApplyFilterUnsafe(WriteableBitmap Bitmap, byte Threshold) 
{ 
    // Let's just make this work for this format 
    if (Bitmap.Format != PixelFormats.Bgr24 
     && Bitmap.Format != PixelFormats.Bgr32) 
    { 
     return; 
    } 

    var bytesPerPixel = (Bitmap.Format.BitsPerPixel + 7)/8; 

    Bitmap.Lock(); 

    unsafe 
    { 
     // Get a pointer to the back buffer. 
     byte* pBackBuffer = (byte*)Bitmap.BackBuffer; 

     for (int i = 0; 
      i < Bitmap.BackBufferStride*Bitmap.PixelHeight; 
      i+= bytesPerPixel) 
     { 
      var pCopy = pBackBuffer; 
      var brightness = (byte)((*pBackBuffer 
            + *++pBackBuffer 
            + *++pBackBuffer)/3); 
      pBackBuffer++; 

      var toColor = 
        brightness >= Threshold ? byte.MaxValue : byte.MinValue; 

      *pCopy = toColor; 
      *++pCopy = toColor; 
      *++pCopy = toColor;      
     } 
    } 

    // Bitmap.AddDirtyRect(
    //   new Int32Rect(0,0, Bitmap.PixelWidth, Bitmap.PixelHeight)); 
    Bitmap.Unlock(); 

} 

यह असुरक्षित कोड ब्लॉक और पॉइंटर्स में मेरा पहला प्रयास है, इसलिए शायद तर्क इष्टतम नहीं है।

मैं एक ही WriteableBitmaps के प्रयोग पर कोड के दोनों ब्लॉकों का परीक्षण किया है:

var threshold = Convert.ToByte(op.Result); 
var copy2 = copyFrame.Clone(); 
Stopwatch stopWatch = new Stopwatch(); 
stopWatch.Start(); 
BinaryFilter.ApplyFilterUnsafe(copyFrame, threshold); 
stopWatch.Stop(); 

var unsafesecs = stopWatch.ElapsedMilliseconds; 
stopWatch.Reset(); 
stopWatch.Start(); 
BinaryFilter.ApplyFilter(copy2, threshold); 
stopWatch.Stop(); 
Debug.WriteLine(string.Format("Unsafe: {1}, Safe: {0}", 
       stopWatch.ElapsedMilliseconds, unsafesecs)); 

तो मैं एक ही छवि का विश्लेषण कर रहा हूँ। वीडियो फ्रेम की आने वाली स्ट्रीम का परीक्षण रन:

Unsafe: 110, Safe: 53 
Unsafe: 136, Safe: 42 
Unsafe: 106, Safe: 36 
Unsafe: 95, Safe: 43 
Unsafe: 98, Safe: 41 
Unsafe: 88, Safe: 36 
Unsafe: 129, Safe: 65 
Unsafe: 100, Safe: 47 
Unsafe: 112, Safe: 50 
Unsafe: 91, Safe: 33 
Unsafe: 118, Safe: 42 
Unsafe: 103, Safe: 80 
Unsafe: 104, Safe: 34 
Unsafe: 101, Safe: 36 
Unsafe: 154, Safe: 83 
Unsafe: 134, Safe: 46 
Unsafe: 113, Safe: 76 
Unsafe: 117, Safe: 57 
Unsafe: 90, Safe: 41 
Unsafe: 156, Safe: 35 

मेरा असुरक्षित संस्करण हमेशा धीमा क्यों है? क्या यह बैक बफर का उपयोग करने के कारण है? या मुझ से कुछ गलत हो रहा है?

धन्यवाद

Answer 1

हो सकता है कि क्योंकि आपके असुरक्षित संस्करण एक गुणा और संपत्ति का उपयोग कर रहा है:

Bitmap.BackBufferStride*Bitmap.PixelHeight 

हर पाश यात्रा पर। परिणाम को एक चर में स्टोर करें।

Answer 2

एक और अनुकूलन, या तो सुरक्षित या असुरक्षित कोड में: अपने लूप के अंदर 3 से विभाजित करना बंद करें। लूप के बाहर, 3 बार एक बार अपनी दहलीज गुणा करें। आपको byte के अलावा किसी अन्य प्रकार का उपयोग करने की आवश्यकता होगी, लेकिन यह कोई समस्या नहीं होनी चाहिए। असल में, आप पहले से ही byte की तुलना में एक बड़ा डेटाटाइप का उपयोग कर रहे हैं :)

Answer 3

कोड को प्रोफाइलिंग के साथ कहना मुश्किल है, खासकर जब कोड बहुत अलग है (घटनाओं में यह पहली बार दिखता है) कुछ महत्वपूर्ण बिंदु (और वे हैं सब सिर्फ अटकलें तेज हो गई)

रोक हालत अगर यदि सरणी pixelArray केवल एक बार की गणना की जा सकती है eventhough वे दो बार उपयोग किया जाता है के लिए सुरक्षित

• सूचकांकों में नहीं असुरक्षित संस्करण में गणना की जाती है।
• भले ही वे "कैश की गई" नहीं कर रहे हैं जोड़कर मिलने एक साथ भंडारण उन्हें (के रूप में पी ++ के खिलाफ) के बिना अभी भी तेजी से (कम निर्देश और कम स्मृति का उपयोग) होगा
• आप ताला लगा नहीं कर रहे हैं सुरक्षित संस्करण
• pixelArray में बिटमैप [i], pixelArray [i + 1], pixelArray [i + 2] ताकि उन्हें आसानी से सूचक फिर से पुनरावृत्ति से पहुँचने के दूसरी बार संभावित बनाने के लिए स्थानीय लोगों में संग्रहीत हो सकता है।
• आप असुरक्षित कोड (pCOpy = pBackBuffer) और एक अतिरिक्त वेतन वृद्धि में एक अतिरिक्त कार्यभार है (pBackBuffer ++;)

सभी विचारों मैं के साथ आ सकता है यही कारण है कि। उम्मीद है कि यह