Ajouter une couleur d'arrière-plan à un MediaComposition

Question

J'essaie de créer une MediaComposition. J'ai réussi à combiner plusieurs images png en une seule vidéo; cependant, les fichiers créés ont un arrière-plan noir. Au début, je pensais que cela pouvait être dû au fait que les fichiers étaient des fichiers png, mais le même problème survient pour les jpgs. Voici comment je suis en train d'enregistrer l'image:

public async Task<bool> Save(InkCanvas canvas, StorageFile file) 
{ 

    if (canvas != null && canvas.InkPresenter.StrokeContainer.GetStrokes().Count > 0) 
    { 
     if (file != null) 
     { 
      using (IRandomAccessStream stream = await file.OpenAsync(FileAccessMode.ReadWrite)) 
      { 
       await canvas.InkPresenter.StrokeContainer.SaveAsync(stream); 
      } 
     } 
     Clear(canvas); 
     return true; 
    } 
    return false; 
} 

L'image est bien enregistrée, mais l'arrière-plan est alpha. Ce que cela signifie, c'est que lorsque j'essaie de les enchaîner dans une composition multimédia, il n'y a pas d'arrière-plan et cela devient noir. J'ai essayé d'utiliser des superpositions lors de la création de MediaComposition pour corriger ceci:

MediaClip overlayVideoClip = MediaClip.CreateFromColor(Colors.White, new TimeSpan(0, 1, 0)); 
MediaOverlay mo = new MediaOverlay(overlayVideoClip); 
MediaOverlayLayer mol = new MediaOverlayLayer(); 
mol.Overlays.Add(mo); 

composition.OverlayLayers.Add(mol); 

Mais en vain. Mon soupçon est que je ne comprends pas la signification du terme superposition dans ce cas. Donc, mes questions sont: est-il possible de superposer la vidéo au moment de la composition et, si oui, comment? Sinon, si cela doit être fait dans l'image elle-même, comment puis-je sauvegarder l'image avec un arrière-plan?

EDIT:

J'ai fait des progrès avec ce (?); les pistes suivantes et compiles, mais crée une image en noir solide:

public async Task TestSave(InkCanvas canvas, StorageFile file) 
    { 
     RenderTargetBitmap rtb = 
      new RenderTargetBitmap(); 
     PixelFormats.Pbgra32); 
     await rtb.RenderAsync(canvas); 
     var pixelBuffer = await rtb.GetPixelsAsync(); 

     using (IRandomAccessStream stream = 
      await file.OpenAsync(FileAccessMode.ReadWrite)) 
     {     
      BitmapEncoder encoder = 
       await BitmapEncoder.CreateAsync(BitmapEncoder.PngEncoderId, stream); 

      encoder.SetPixelData(BitmapPixelFormat.Bgra8, 
       BitmapAlphaMode.Straight, 
       (uint)rtb.PixelWidth, 
       (uint)rtb.PixelHeight, 
       96d, 96d, 
       pixelBuffer.ToArray()); 

      await encoder.FlushAsync();     
     } 
    } 

EDIT:

J'ai trouvé this réponse, ce qui résout en quelque sorte le problème en utilisant la bibliothèque Win2D; Bien qu'il ne traite pas de mon problème, il me permet de le contourner. Espérons qu'il existe une meilleure solution.

Answer 1

La seule chose que je comprends à ce sujet est que vous essayez de sauvegarder une image avec un arrière-plan. Ma suggestion pour résoudre ce problème est d'enregistrer l'image transparente que vous avez à quelque chose comme

<StackPanel x:Name="AreaWhichWillBeSavedToImage" Background=*Some Color*> 
    <Image x:Name="theAlphaImage"> 
</StackPanel> 

Maintenant, si vous ne voulez pas l'image à afficher sur votre interface graphique vient de mettre à Masqué.

Ensuite, vous pouvez enregistrer le fichier avec l'arrière-plan de couleur de votre choix.

var bitmap = await SaveToFileAsync(AreaWhichWillBeSavedToImage, await StorageFile.GetFileFromPathAsync(Windows.ApplicationModel.Package.Current.InstalledLocation.Path + @"someimage.jpg")); 

    async Task<RenderTargetBitmap> SaveToFileAsync(FrameworkElement uielement, StorageFile file) 
    { 
     if (file != null) 
     { 
      CachedFileManager.DeferUpdates(file); 

      Guid encoderId = GetBitmapEncoder(file.FileType); 

      try 
      { 
       using (var stream = await file.OpenAsync(FileAccessMode.ReadWrite)) 
       { 
        return await CaptureToStreamAsync(uielement, stream, encoderId); 
       } 
      } 
      catch (Exception ex) 
      { 
       //DisplayMessage(ex.Message); 
      } 

      var status = await CachedFileManager.CompleteUpdatesAsync(file); 
     } 

     return null; 
    } 

    async Task<RenderTargetBitmap> CaptureToStreamAsync(FrameworkElement uielement, IRandomAccessStream stream, Guid encoderId) 
    { 
     try 
     { 
      var renderTargetBitmap = new RenderTargetBitmap(); 
      await renderTargetBitmap.RenderAsync(uielement); 

      var pixels = await renderTargetBitmap.GetPixelsAsync(); 

      var logicalDpi = DisplayInformation.GetForCurrentView().LogicalDpi; 
      var encoder = await BitmapEncoder.CreateAsync(encoderId, stream); 
      encoder.SetPixelData(
       BitmapPixelFormat.Bgra8, 
       BitmapAlphaMode.Ignore, 
       (uint)renderTargetBitmap.PixelWidth, 
       (uint)renderTargetBitmap.PixelHeight, 
       logicalDpi, 
       logicalDpi, 
       pixels.ToArray()); 

      await encoder.FlushAsync(); 

      return renderTargetBitmap; 
     } 
     catch (Exception ex) 
     { 
      //DisplayMessage(ex.Message); 
     } 

     return null; 
    } 

    Guid GetBitmapEncoder(string fileType) 
    { 
     Guid encoderId = BitmapEncoder.JpegEncoderId; 
     switch (fileType) 
     { 
      case ".bmp": 
       encoderId = BitmapEncoder.BmpEncoderId; 
       break; 
      case ".gif": 
       encoderId = BitmapEncoder.GifEncoderId; 
       break; 
      case ".png": 
       encoderId = BitmapEncoder.PngEncoderId; 
       break; 
      case ".tif": 
       encoderId = BitmapEncoder.TiffEncoderId; 
       break; 
     } 

     return encoderId; 
    }