¿Cómo editar un WritableBitmap.BackBuffer en un subproceso que no sea de IU?

Question

Mi aplicación ejecuta algorythms pesado CPU para editar una imagen colocada en una ventana de WPF. Necesito que la edición se haga en un hilo de fondo. Sin embargo, intentar editar el BackBuffer de WritableBitmap en un subproceso que no sea de UI arroja InvalidOperationException.

private WriteableBitmap writeableBitmap; 

    private void button1_Click(object sender, RoutedEventArgs e) 
    { 
     // Create WritableBitmap in UI thread. 
     this.writeableBitmap = new WriteableBitmap(10, 10, 96, 96, PixelFormats.Bgr24, null); 
     this.image1.Source = this.writeableBitmap; 

     // Run code in non UI thread. 
     new Thread(
      () => 
      { 
       // 'Edit' bitmap in non UI thread. 
       this.writeableBitmap.Lock(); // Exception: The calling thread cannot access this object because a different thread owns it. 

       // ... At this place the CPU is highly loaded, we edit this.writeableBitmap.BackBuffer. 

       this.writeableBitmap.Unlock(); 
      }).Start(); 
    } 

He leído docenas de manuales, todos ellos me dice que haga la edición BackBuffer en hilo de interfaz de usuario (es decir MSDN).

Cómo editar el WritableBitmap.BackBuffer en un subproceso sin interfaz de usuario sin copia/clonación de búfer inútil?

Answer 1

MSDN suggests escribiendo en el backbuffer en un hilo de fondo. Solo ciertas operaciones previas y posteriores a la actualización deben llevarse a cabo en el hilo de la interfaz de usuario.Así, mientras que el hilo de fondo está haciendo la actualización real, el hilo de interfaz de usuario es libre para hacer otras cosas:

 //Put this code in a method that is called from the background thread 
     long pBackBuffer = 0, backBufferStride = 0; 
     Application.Current.Dispatcher.Invoke(() => 
     {//lock bitmap in ui thread 
      _bitmap.Lock(); 
      pBackBuffer = (long)_bitmap.BackBuffer;//Make pointer available to background thread 
      backBufferStride = Bitmap.BackBufferStride; 
     }); 
     //Back to the worker thread 
     unsafe 
     { 
      //Carry out updates to the backbuffer here 
      foreach (var update in updates) 
      { 
       long bufferWithOffset = pBackBuffer + GetBufferOffset(update.X, update.Y, backBufferStride); 
       *((int*)bufferWithOffset) = update.Color; 
      } 
     } 
     Application.Current.Dispatcher.Invoke(() => 
     {//UI thread does post update operations 
      _bitmap.AddDirtyRect(new System.Windows.Int32Rect(0, 0, width, height)); 
      _bitmap.Unlock(); 
     }); 

Answer 2

En WPF las llamadas de hilos cruzados se realizan utilizando la clase Dispatcher.

En su caso en el subproceso sin interfaz de usuario, necesita obtener la instancia del distribuidor de la secuencia donde se crea WritableBitmap.

En esa despachador luego llamar a Invoke (o BeginInvoke si quieres que Asynchron)

invocación a continuación, llama a una función donde el delegado BackBuffer se edita

Answer 3

Simplemente no se puede escribir en BackBuffer de un no interfaz de usuario hilo.

Además de lo que dijo Klaus78, sugeriría el siguiente enfoque:

1. Realizar asíncrono código "edición de mapa de bits" en una memoria intermedia separada (por ejemplo byte[]) en un hilo ThreadPool por medio de QueueUserWorkItem. No cree un nuevo subproceso cada vez que necesite realizar una operación asincrónica. Para eso se creó ThreadPool.

2. Copie el búfer editado por WritePixels en el despachador de WriteableBitmap. No es necesario bloquear/desbloquear.

Ejemplo:

private byte[] buffer = new buffer[...]; 

private void UpdateBuffer() 
{ 
    ThreadPool.QueueUserWorkItem(
     o => 
     { 
      // write data to buffer... 
      Dispatcher.BeginInvoke((Action)(() => writeableBitmap.WritePixels(..., buffer, ...))); 
     }); 
} 

Answer 4

Como dijo Clemens, esto es imposible.

Tiene tres opciones:

1) introducir las modificaciones en un búfer y blit cuando haya terminado como sugiere Clemens.

2) Realice la edición en porciones muy pequeñas y prográmelas con una buena prioridad en el hilo de la GUI. Si mantiene los trozos de trabajo lo suficientemente pequeños, la GUI seguirá siendo receptiva, pero obviamente esto complica el código de edición.

3) Combine 1 & 2. Edite trozos pequeños en otro subproceso, luego rellene cada trozo a medida que se completa. Esto mantiene la GUI sensible sin usar memoria para un buffer de respaldo completo.

Answer 5

he implementado el siguiente, basado en this answer:

En el modelo de vista, hay una propiedad como éste, que está unido a la fuente de la imagen en XAML:

private WriteableBitmap cameraImage; 
private IntPtr cameraBitmapPtr; 
public WriteableBitmap CameraImage 
{ 
    get { return cameraImage; } 
    set 
    { 
     cameraImage = value; 
     cameraBitmapPtr = cameraImage.BackBuffer; 
     NotifyPropertyChanged(); 
    } 
} 

el uso de una propiedad significa que si los cambios WritableBitmap, por ejemplo, debido a la resolución, se actualizará en la Vista y también se construirá un nuevo IntPtr.

La imagen se construye cuando sea apropiado:

CameraImage = new WriteableBitmap(2448, 2048, 0, 0, PixelFormats.Bgr24, null); 

En el hilo de actualización, una nueva imagen se copia en, por ejemplo, usando:

[DllImport("kernel32.dll", EntryPoint = "RtlMoveMemory")] 
public static extern void CopyMemory(IntPtr Destination, IntPtr Source, uint Length); 

que haría

CopyMemory(cameraImagePtr, newImagePtr, 2448 * 2048 * 3); 

No podría ser una mejor función para este ...

En el mismo hilo, después de la copia:

parent.Dispatcher.Invoke(new Action(() => 
{ 
    cameraImage.Lock(); 
    cameraImage.AddDirtyRect(new Int32Rect(0, 0, cameraImage.PixelWidth, cameraImage.PixelHeight)); 
    cameraImage.Unlock(); 
}), DispatcherPriority.Render); 

donde parent es el Control/Ventana con la Imagen.