Byte Array als JPG-Datei weiterverarbeiten ohne das Bild zwischenzuspeichern

doLob · 8. Juli 2023, 06:44

Ich lese mit TagLib aus einer Audiodatei ein Cover Art aus. Dieses möchte ich dann beim Umwandeln mit ffmpeg wieder in die umgewandelte Audiodatei
als metadata integrieren. ffmpeg erwartet als Parameter einen Dateinamen.
Bisher habe ich erst diese Datei erzeugt und dann in ffmpeg verarbeitet.

Quellcode

Private Sub GetPictureData(ByVal InputAudioFile As String)
Dim f As TagLib.File = TagLib.File.Create(InputAudioFile)
If f.Tag.Pictures.Length >= 1 Then
Dim bin As Byte() = DirectCast(f.Tag.Pictures(0).Data.Data, Byte())
Dim Image As Image = ConvertBytes(bin)
Image.Save("TmpCover.jpg", System.Drawing.Imaging.ImageFormat.Jpeg)
End If
f.Dispose()
End Sub
Private Function ConvertBytes(ByVal mybytes() As Byte) As Image
Dim myimage As Image
Dim ms As System.IO.MemoryStream = New System.IO.MemoryStream(mybytes)
myimage = System.Drawing.Image.FromStream(ms)
Return myimage
End Function

Geht das auch irgenwie ohne das ich die Datei immer auf der Festplatte speichern muß ?

-Franky- · 8. Juli 2023, 08:34

Zuerst: Wenn Du mit TagLib das Cover aus der einen Datei auslesen kannst, kann TagLib dann nicht auch das Cover in eine andere Datei speichern bzw. kann ffmpeg beim konvertieren nicht auch gleich die Metadaten übertragen?

Falls nicht: Es gibt hier mehre Wege das Cover von einer Datei zu einer anderen zu übertragen. Ich würde dazu das COM-Interface IPropertyStore verwenden. Damit lässt sich das Cover auslesen (-> ByteArray) und auch wieder schreiben. Ohne zwischenspeichern auf die Festplatte.

Alternativ kann man auch gleich die MediaFoundation oder WinRT zum konvertieren, lesen und schreiben von Metadaten verwenden.

doLob · 9. Juli 2023, 18:06

Jap. ffmpeg kann alle metadaten übertragen. Nur bei den Cover Arts gibt es durch die unterschiedlichen Lossless Quellen (alac,m4a,wav,...), Probleme mit der Picture Größe im flac Format, so dass ich diese exportiere, formatiere und wieder reinschreibe.
Leider mit dem Umweg, das erzeugte Bild erstmal nur auf der Festplatte zu speichern und dann in ffmpeg als Metadata Input wieder zu integrieren.
Mit der COM Welt habe ich mich noch garnicht beschäftigt. Auch ffmpeg hätte wohl die Möglichkeit über pipes zu importieren.
Beides ist aber absolutes Neuland für mich.
Ich habe nun gehofft, das man das Bild auch ohne Zwischenspeicherung auf der HDD als Parameter an FFMPEG übergeben kann. Im Endeffekt öffnet es ja auch nur die angegebene Bilddatei als STream, Object oder weiß ich nich welche Bits und Bytes und schreibt
es in die flac Datei.

-Franky- · 10. Juli 2023, 08:26

@doLob Und wie schaut es mit TagLib aus? Cover auslesen geht ja anscheinend und schreiben? Ich kenne mich mit TagLib und ffmpeg nicht aus und ich habe diese Woche viel um die Ohren so das ich kein Bsp. für IPropertyStore basteln kann. Denke das die anderen Mitstreiter hier Dir da unter die Arme greifen können. Daher nur ein grober Plan wie es mit IPropertyStore funktioniert.

API SHGetPropertyStoreFromParsingName -> IPropertyStore.

C-Quellcode

EXTERN_C const IID IID_IPropertyStore;
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("886d8eeb-8cf2-4446-8d02-cdba1dbdcf99")
IPropertyStore : public IUnknown
{
public:
virtual HRESULT STDMETHODCALLTYPE GetCount(
/* [out] */ __RPC__out DWORD *cProps) = 0;
virtual HRESULT STDMETHODCALLTYPE GetAt(
/* [in] */ DWORD iProp,
/* [out] */ __RPC__out PROPERTYKEY *pkey) = 0;
virtual HRESULT STDMETHODCALLTYPE GetValue(
/* [in] */ __RPC__in REFPROPERTYKEY key,
/* [out] */ __RPC__out PROPVARIANT *pv) = 0;
virtual HRESULT STDMETHODCALLTYPE SetValue(
/* [in] */ __RPC__in REFPROPERTYKEY key,
/* [in] */ __RPC__in REFPROPVARIANT propvar) = 0;
virtual HRESULT STDMETHODCALLTYPE Commit( void) = 0;
};

IPropertyStore.GetValue <- PROPERTYKEY (System.ThumbnailStream bzw. PKEY_ThumbnailStream ({f29f85e0-4ff9-1068-ab91-08002b27b3d9},27)) -> PROPVARIANT (müsste dann ein VT_STREAM sein, Pointer auf ein IStream)
IStream in ein ByteArray kopieren und ein Bild erstellen (ByteArray -> MemoryStream -> Bitmap). Alternativ über Reflection über GDI+-API (GdipCreateBitmapFromStream) direkt vom pIStream ein pBitmap -> .NET-Bitmap. Spart dann den Weg über einen MemoryStream und das kopiere in ein ByteArray.

Umgekerter Weg:
Bild in ein IStream kopieren (IStream per SHCreateMemStream erstellen), IPropertyStore.SetValue <- PROPERTYKEY (System.ThumbnailStream/ PKEY_ThumbnailStream), <- PROPVARIANT (VT_STREAM, Pointer auf das IStream mit dem Bild)
IPropertyStore.Commit

Bild löschen:
IPropertyStore.SetValue <- PROPERTYKEY (System.ThumbnailStream/ PKEY_ThumbnailStream), <- PROPVARIANT (VT_Empty, IntPtr.Zero)
IPropertyStore.Commit

Edit: Bissel Zeit gefunden, aber... nur auf die schnelle zusammenkopiert (alles in eine Form). Nur Auslesen des Cover. Schreiben ist halt die umgekehrte Richtung.

Spoiler anzeigen

VB.NET-Quellcode

Imports System.Runtime.InteropServices
Public Class Form1
#Region "API"
<DllImport("Shell32.dll", EntryPoint:="SHGetPropertyStoreFromParsingName")>
<PreserveSig> Private Shared Function SHGetPropertyStoreFromParsingName(<[In], MarshalAs(UnmanagedType.LPWStr)> pszPath As String,
<[In]> pbc As IntPtr,
<[In]> flags As GETPROPERTYSTOREFLAGS,
<[In]> ByRef riid As Guid,
<Out, MarshalAs(UnmanagedType.Interface)> ByRef ppv As IPropertyStore) As Integer
End Function
<DllImport("Ole32.dll", EntryPoint:="PropVariantClear")>
<PreserveSig> Private Shared Function PropVariantClear(<[In], Out> ByRef pvar As PROPVARIANT) As Integer
End Function
#End Region
#Region "Enum"
Private Enum GETPROPERTYSTOREFLAGS As Integer
GPS_DEFAULT = &H0
GPS_HANDLERPROPERTIESONLY = &H1
GPS_READWRITE = &H2
GPS_TEMPORARY = &H4
GPS_FASTPROPERTIESONLY = &H8
GPS_OPENSLOWITEM = &H10
GPS_DELAYCREATION = &H20
GPS_BESTEFFORT = &H40
GPS_NO_OPLOCK = &H80
GPS_PREFERQUERYPROPERTIES = &H100
GPS_EXTRINSICPROPERTIES = &H200
GPS_EXTRINSICPROPERTIESONLY = &H400
GPS_VOLATILEPROPERTIES = &H800
GPS_VOLATILEPROPERTIESONLY = &H1000
GPS_MASK_VALID = &H1FFF
End Enum
Private Enum STREAM_SEEK As Integer
STREAM_SEEK_SET = 0
STREAM_SEEK_CUR = 1
STREAM_SEEK_END = 2
End Enum
Private Enum STGC As Integer
STGC_DEFAULT = 0
STGC_OVERWRITE = 1
STGC_ONLYIFCURRENT = 2
STGC_DANGEROUSLYCOMMITMERELYTODISKCACHE = 4
STGC_CONSOLIDATE = 8
End Enum
Private Enum LOCKTYPE
LOCK_WRITE = 1
LOCK_EXCLUSIVE = 2
LOCK_ONLYONCE = 4
End Enum
Private Enum STATFLAG As Integer
STATFLAG_DEFAULT = 0
STATFLAG_NONAME = 1
STATFLAG_NOOPEN = 2
End Enum
Private Enum VARTYPE As UShort 'gekürzt
VT_EMPTY = 0
VT_STREAM = 66
End Enum
#End Region
#Region "Const"
Private Const S_OK As Integer = 0
Private Const IID_IStream As String = "0000000c-0000-0000-c000-000000000046"
Private Const IID_IPropertyStore As String = "886d8eeb-8cf2-4446-8d02-cdba1dbdcf99"
Private Const PKEY_ThumbnailStream_fmtid As String = "f29f85e0-4ff9-1068-ab91-08002b27b3d9"
Private Const PKEY_ThumbnailStream_pid As Integer = 27
#End Region
#Region "Structure"
Private Structure FILETIME
Dim dwLowDateTime As Integer
Dim dwHighDateTime As Integer
End Structure
Private Structure STATSTG
Dim pwcsName As IntPtr
Dim type As Integer
Dim cbSize As Long
Dim mtime As FILETIME
Dim ctime As FILETIME
Dim atime As FILETIME
Dim grfMode As Integer
Dim grfLocksSupported As Integer
Dim clsid As Guid
Dim grfStateBits As Integer
Dim reserved As Integer
End Structure
Private Structure CArray
Dim cElems As UInteger
Dim pElems As IntPtr
End Structure
<StructLayout(LayoutKind.Explicit, Size:=16)> 'gekürzt
Private Structure PROPVARIANT
<FieldOffset(0)> Dim vt As VARTYPE
<FieldOffset(2)> Dim wReserved1 As UShort
<FieldOffset(4)> Dim wReserved2 As UShort
<FieldOffset(6)> Dim wReserved3 As UShort
<FieldOffset(8)> Dim stream As IntPtr 'VT_STREAM
<FieldOffset(8)> Dim cArray As CArray 'VT_BLOB
End Structure
Private Structure PROPERTYKEY
Dim fmtid As Guid
Dim pid As Integer
Sub New(fmtid As Guid, pid As Integer)
Me.fmtid = fmtid
Me.pid = pid
End Sub
End Structure
#End Region
#Region "Interface IStream"
<ComImport>
<InterfaceType(ComInterfaceType.InterfaceIsIUnknown)>
<Guid(IID_IStream)>
Private Interface IStream
<PreserveSig> Function Read(<Out, MarshalAs(UnmanagedType.LPArray)> pv As Byte(),
<[In]> cb As Long,
<Out> ByRef pcbRead As Long) As Integer
<PreserveSig> Function Write(<[In], MarshalAs(UnmanagedType.LPArray)> pv As Byte(),
<[In]> cb As Long,
<Out> ByRef pcbWritten As Long) As Integer
<PreserveSig> Function Seek(<[In]> dlibMove As Long,
<[In]> dwOrigin As STREAM_SEEK,
<Out> ByRef plibNewPosition As Long) As Integer
<PreserveSig> Function SetSize(<[In]> libNewSize As Long) As Integer
<PreserveSig> Function CopyTo(<[In], MarshalAs(UnmanagedType.Interface)> pstm As IStream,
<[In]> cb As Long,
<Out> ByRef pcbRead As Long,
<Out> ByRef pcbWritten As Long) As Integer
<PreserveSig> Function Commit(<[In]> grfCommitFlags As STGC) As Integer
<PreserveSig> Function Revert() As Integer
<PreserveSig> Function LockRegion(<[In]> libOffset As Long,
<[In]> cb As Long,
<[In]> dwLockType As LOCKTYPE) As Integer
<PreserveSig> Function UnlockRegion(<[In]> libOffset As Long,
<[In]> cb As Long,
<[In]> dwLockType As LOCKTYPE) As Integer
<PreserveSig> Function Stat(<Out> ByRef pstatstg As STATSTG,
<[In]> grfStatFlag As STATFLAG) As Integer
<PreserveSig> Function Clone(<Out, MarshalAs(UnmanagedType.Interface)> ByRef ppstm As IStream) As Integer
End Interface
#End Region
#Region "Interface IPropertyStore"
<ComImport>
<InterfaceType(ComInterfaceType.InterfaceIsIUnknown)>
<Guid(IID_IPropertyStore)>
Private Interface IPropertyStore
<PreserveSig> Function GetCount(<Out> ByRef cProps As Integer) As Integer
<PreserveSig> Function GetAt(<[In]> iProp As Integer,
<Out> ByRef pkey As PROPERTYKEY) As Integer
<PreserveSig> Function GetValue(<[In]> ByRef key As PROPERTYKEY,
<Out> ByRef pv As PROPVARIANT) As Integer
<PreserveSig> Function SetValue(<[In]> ByRef key As PROPERTYKEY,
<[In]> ByRef pv As PROPVARIANT) As Integer
<PreserveSig> Function Commit() As Integer
End Interface
#End Region
Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
Dim PropertyStore As IPropertyStore = Nothing
' GPS_READWRITE = nur Metadaten die gelesen und geschrieben werden können
If SHGetPropertyStoreFromParsingName("D:\Downloads\VBC_Prog\VBC_MediaFoundation\test.mp3",
Nothing, GETPROPERTYSTOREFLAGS.GPS_READWRITE,
New Guid(IID_IPropertyStore), PropertyStore) = S_OK Then
Dim PropVar As New PROPVARIANT
' ThumbnailStream lesen -> PROPVARIANT
If PropertyStore.GetValue(New PROPERTYKEY(New Guid(PKEY_ThumbnailStream_fmtid), PKEY_ThumbnailStream_pid), PropVar) = S_OK Then
' ist es ein VT_STREAM?
If PropVar.vt = VARTYPE.VT_STREAM Then
' ist ein Pointer auf ein IStream vorhanden?
If PropVar.stream <> IntPtr.Zero Then
' Pointer -> IStream
Dim Stream As IStream = CType(Marshal.GetObjectForIUnknown(PropVar.stream), IStream)
Dim StreamSize As Long
' Größe des Streams ermitteln
If Stream.Seek(0, STREAM_SEEK.STREAM_SEEK_END, StreamSize) = S_OK Then
' Zurück zum Anfang des Streams
If Stream.Seek(0, STREAM_SEEK.STREAM_SEEK_SET, Nothing) = S_OK Then
If StreamSize > 0 Then
' ByteArray dimensionieren
Dim Data As Byte() = New Byte(CInt(StreamSize) - 1) {}
' Stream in das ByteArray kopieren
If Stream.Read(Data, StreamSize, Nothing) = S_OK Then
' vom ByteArray ein MemoryStream erstellen
Using MemStream As New IO.MemoryStream(Data)
' Bitmap vom MemoryStream erstellen
Me.BackgroundImage = New Bitmap(New Bitmap(MemStream))
End Using
End If
End If
End If
End If
' IStream freigeben
Marshal.ReleaseComObject(Stream)
End If
End If
' PROPVARIANT clear
PropVariantClear(PropVar)
End If
' IPropertyStore freigeben
Marshal.ReleaseComObject(PropertyStore)
End If
End Sub
End Class

Natürlich lassen sich auch andere Metadaten über IPropertyStore auslesen und beschreibbare Metadaten auch schreiben.

Edit2: Falls das Bild für die umkopiererei nicht angezeigt werden muss, dann kannst auch gleich direkt mit GDI+-APIs arbeiten. Also direkt vom IStream ein pBitmap erstellen (kein umkopieren in ein ByteArray -> MemoryStream -> usw. weil unnötig), evtl. das Bild bearbeiten und dann das Bild direkt wieder in ein IStream speichern (GdipSaveImageToStream) das dann per IPropertyStore gespeichert werden kann.

doLob · 11. Juli 2023, 20:24

Wow, Vielen Dank für diese Einführung. Das ist ja wie eine Fremdsprache für mich.
Um mich da einzuarbeiten brauche ich wohl etwas mehr Zeit. Ich werde das mal zum Anlass nehmen.
Ich habe aber inzwischen einen Weg gefunden, ffmpeg anzuweisen das Cover während des Übertragens zu skalieren.
Nun brauche ich die Metadaten garnicht auslesen und weiter bearbeiten also auch die TagLib nicht mehr.

Danke nochmal!

-Franky- · 11. Juli 2023, 22:56

Na ja. IPropertyStore verwendet Windows selber (Explorer) um bei einem Rechtsklick auf eine Datei die Eigenschaften und Metadaten auszulesen und die meisten lassen sich auch beschreiben. Die WinRT nutzt ebenfalls IPropertyStore um Metadaten zu lesen/zu schreiben. Im übrigen kann man auch ab Win10, evtl sogar schon ab Win8, die WinRT nutzen um unterstützte Audio- und Videoformate in ein anderes Format zu transcodieren. WinRT nutzt dazu die Media Foundation. Ab WinVista könnte man auch die Media Foundation direkt zum transcodieren nutzen. Ist halt alles COM basiert. Windows bietet sehr viele Schnittstellen die in NET nicht immer vorhanden oder es zB. nur in UWP/WPF gibt, aber nicht in VB. Oder man lädt sich halt irgendwelche Nuget-Pakete herunter bzw nutzt Drittanbieter-DLLs die im Endeffekt evtl auch nur das nutzen, was in Windows bereits enthalten ist. Da kann man auch gleich die COM/API Schnittstellen selbst nutzen (ohne Verweise, Nuget oder Drittanbieter). <- Das ist halt meine Meinung dazu.

Byte Array als JPG-Datei weiterverarbeiten ohne das Bild zwischenzuspeichern

Byte Array als JPG-Datei weiterverarbeiten ohne das Bild zwischenzuspeichern

Quellcode

C-Quellcode

VB.NET-Quellcode

Tags

Ähnliche Themen

2 Benutzer haben hier geschrieben