MediaComposition

Question

पर पृष्ठभूमि रंग जोड़ें I MediaComposition बनाने की कोशिश कर रहा हूं। मैं एक ही वीडियो में एकाधिक पीएनजी छवियों को संयोजित करने में सफल रहा हूं; हालांकि, बनाई गई फ़ाइलों में एक काला पृष्ठभूमि है। सबसे पहले मैंने सोचा कि ऐसा इसलिए हो सकता है क्योंकि फाइलें पीएनजी फाइलें थीं, लेकिन एक ही बीवीवीयर जेपीजी के लिए होता है। निम्नलिखित है कि मैं छवि को कैसे सहेज रहा हूं:

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; 
} 

यह छवि ठीक से बचाता है, लेकिन पृष्ठभूमि अल्फा है। इसका अर्थ यह है कि जब मैं मीडिया संरचना में इन्हें एक साथ कोशिश करता हूं और चेन करता हूं, तो कोई पृष्ठभूमि नहीं होती है, और यह काला के रूप में प्रस्तुत होती है। मैंने इसे सुधारने के लिए MediaComposition बनाते समय ओवरले का उपयोग करने का प्रयास किया है:

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); 

लेकिन इसका कोई फायदा नहीं हुआ। मेरा संदेह यह है कि मैं इस मामले में ओवरले शब्द के अर्थ को गलत समझ रहा हूं। तो, मेरे प्रश्न हैं: क्या रचना समय पर वीडियो को ओवरले करना संभव है और यदि हां, तो कैसे? वैकल्पिक रूप से, अगर इसे छवि में ही किया जाना है, तो मैं छवि को पृष्ठभूमि से कैसे सहेज सकता हूं?

संपादित करें:

मैं बनाया है प्रगति इस के साथ; (?) निम्नलिखित compiles और चलाता है, लेकिन एक ठोस काला छवि बनाता है:

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();     
     } 
    } 

संपादित करें:

मैं this जवाब है, जो एक तरह से Win2D लाइब्रेरी का उपयोग करके समस्या का हल मिल गया; हालांकि यह मेरे वास्तविक मुद्दे को संबोधित नहीं करता है, यह मुझे इसके चारों ओर जाने देता है। उम्मीद है कि वहाँ एक बेहतर समाधान है।

Answer 1

एकमात्र चीज़ जो मैं समझता हूं वह है कि आप पृष्ठभूमि के साथ एक छवि को सहेजने की कोशिश कर रहे हैं। इस को हल करने के मेरे सुझाव

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

की तरह कुछ करने के लिए पारदर्शी छवि आप को बचाने के लिए अब अगर आप छवि आपके GUI पर प्रदर्शित करने के लिए बस छिपा के लिए सेट नहीं करना चाहती है।

फिर आप अपनी पसंद की रंग पृष्ठभूमि के साथ फ़ाइल को सहेज सकते हैं।

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; 
    }