TBitmaps2Video

[Renate Schaaf]

Ich verfolge dieses Forum seit einiger Zeit passiv mit viel Vergnügen und habe nützliche Hinweise gefunden.
Jetzt möchte ich gern mein neuestes Projekt zur Diskussion stellen, eine Klasse, die es ermöglicht sequentiell Bitmaps zu einem Video zusammenzustellen. Ich kann mir vorstellen, dass die/der eine oder andere sowas gebrauchen kann. Die Klasse baut auf den Libav(ffmpeg)-dlls auf, aber mein Ziel war es, ein interface mit leicht und intuitiv verständlichen Prozeduren und Einstellungen herzustellen, ohne dass man sich um die etwas obskuren und technischen Prozeduren in den dlls kümmern muss.

Jetzt zu finden auf GitHub:
https://github.com/rmesch/Bitmaps2Video

Update:
Source code: Bitmaps2Video_3.zip
Es werden jetzt 7 Codecs unterstützt, m.E. die wichtigsten.
Das geänderte interface ist jetzt:

Delphi-Quellcode:

///<summary>Sequentially encode bitmaps to a compressed video. Uses Libav Dlls. </summary>
  TBitmapEncoder = class
.....
    /// <param name="filename"> Output filename. Extension picks the container format (.mp4 .avi .mkv ..)
    /// </param>
    /// <param name="Width"> Video size in pixels (multiples of 2)</param>
    /// <param name="Height"> Video size in pixels (multiples of 2)</param>
    /// <param name="FrameRate"> Frames per second (can be slightly off in the resulting file)</param>
    /// <param name="Quality"> Encoding quality, scale from 0 to 100. 0 gives marginally acceptable quality </param>
    /// <param name="CodecId"> (TAVCodecID see UFormats.pas) Identifier of the codec to use. AV_CODEC_ID_NONE picks the default codec for the file extension. </param>
    /// <param name="VideoScaling">Resample algo used if video size differs from bitmap size </param>
    constructor Create(const filename: string; Width, Height: integer;
      FrameRate: integer; Quality: byte; CodecId: TAVCodecId = AV_CODEC_ID_NONE;
      VideoScaling: TVideoScaling = vsFastBilinear);

    /// <summary> Turn a Bitmap into a movie frame </summary>
    /// <param name="bm"> Bitmap(TBitmap) to be fed to the video. Will be converted to pf32bit if not already </param>
    procedure AddFrame(const bm: TBitmap);

    /// <summary> Hold the last frame </summary>
    /// <param name="EffectTime"> Displaytime(integer) in ms </param>
    procedure Freeze(EffectTime: integer);

    /// <summary> Add a picture which is displayed for a certain time </summary>
    /// <param name="bm"> Bitmap(TBitmap) of the picture to be displayed </param>
    /// <param name="ShowTime"> Time(integer) in ms for the display </param>
    procedure AddStillImage(const bm: TBitmap; ShowTime: integer);

    /// <summary> Make a smooth transition from SourceR to TargetR within EffectTime.</summary>
    /// <param name="bm"> The Bitmap(TBitmap) to be animated </param>
    /// <param name="SourceR"> Beginning rectangle(TRectF) within rect(0,0,bm.width,bm.height) </param>
    /// <param name="TargetR"> End rectangle(TRectF) within rect(0,0,bm.width,bm.height) </param>
    /// <param name="EffectTime"> Duration(integer) of the animation in ms </param>
    /// <param name="ZoomOption"> Quality of the zoom (zoAAx2, zoAAx4, zoAAx6, zoResample). </param>
    /// <param name="SpeedEnvelope"> Modifies the speed during EffectTime. (zeFastSlow, zeSlowFast, zeSlowSlow, zeLinear) </param>
    procedure ZoomPan(const bm: TBitmap; SourceR, TargetR: TRectF;
      EffectTime: integer; ZoomOption: TZoomOption;
      SpeedEnvelope: TZoomSpeedEnvelope = zeLinear);

    /// <summary> Close the file and make the output file usable. </summary>
    function CloseFile: Boolean;

Audio wird jetzt rudimentär unterstützt:

Delphi-Quellcode:

  /// <summary> Combine the video stream from VideoFile with the audio from Audiofile. The streams will just be copied, not encoded.
  ///Audio is clipped to video length. Raises exception if the format of the audio file is not supported.</summary>
  /// <param name="VideoFile"> (string) File which contains a video stream. Any audio stream present will be ignored. </param>
  /// <param name="AudioFile"> (string) Genuine audio file (.wav .mp3 .aac) the audio of which shall be added to the video in VideoFile. </param>
  /// <param name="OutputFile"> (string) Name of the file containing the newly combined video and audio. </param>
procedure MuxStreams2(const VideoFile, AudioFile: string;
  const OutputFile: string);

Das Projekt benötigt die ffmpeg-dlls und die zugehörigen Pascal-Headers. Beides kann man hier bekommen:
http://www.delphiffmpeg.com/downloads/

Näheres im Readme, und in meiner Antwort unten.

Ich bin sehr an Verbesserungsvorschlägen interessiert, vor allem, wie man die Schreibgeschwindigkeit erhöhen kann, und wie man eventuell die vorhandenen Libav-Filter dafür benutzen kann, und auch an Vorschlägen, was man noch einbauen sollte.

Renate

[Renate Schaaf]

Danke für die Ideen, himitsu!
Du verstehst genau, auf was ich hinaus will. Die Beispiele leuchten mir ein (bis auf Datenbanken, die lasse ich lieber links liegen). Ich werde mal versuchen, für die Formate und Codecs, die ich bisher kapiere, etwas zusammenzustoppeln. Ich bin aber wahrscheinlich erst mal eine Woche weg, und ich traue mich nicht zu versuchen, die Delphi Community auf mein Notebook zu übertragen.

Gruß, Renate

[himitsu]

Leider gibt es das Documentation-Insigt im Delphi nicht mehr. (eine Weile war eine kostenlose "Miniversion" drin),
aber das Help-Insight an sich ist noch da, zumindestens mit den grundlegensten Attributen und leider ohne Designer/Editor.
http://www.devjetsoftware.com/produc...ation-insight/


Strg+Leertaste in einer leeren Zeile über deine Funktion
und schauen was dir die Codevorlagen anbieten (alles wo XMLDoc in der Beschreibung steht).

Beispiel:

Delphi-Quellcode:

type
  TForm2 = class(TForm)
    procedure FormCreate(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    procedure Test1(x: Integer);

    /// <summary> Die Funktion führt einen Test aus. </summary>
    procedure Test2(x: Integer);

    /// <summary> die Beschreibung <para/> xxx lll iii <br/> <c>code lll iii</c> </summary>
    /// <param name="x"> der Param </param>
    /// <returns> das Ergebnis </returns>
    /// <remarks> einige Hinweise </remarks>
    procedure Test3(x: Integer);
  end;

Und dann schau dir an was Code-Insight/Help-Insight dir im Hint anzeigen, wenn du diese Funktion irgendwo benutzt.


PS: Es ist etwas ungewohnt, denn die mehrzahl der Entwickler schreibt den Kommentar drüber ... musste auch erst Zweimal hingucken.

[TurboMagic]

Falls das mal ein OpenSource Projekt werden sollte könnten auch andere dazu beitragen. Dann müsstest du nur einen generellen mechanismus bereitstellen
und wer eine andere Container/Codec Kombination braucht kann es selber umsetzen und dann auch bitte beitragen.

Ich weiß ja nicht wei dein Plan an der Stelle ist...

[Renate Schaaf]

Ich habe versucht, Eure Vorschläge einzuarbeiten. Das ist dabei herausgekommen:

Bitmaps2Video_3

Im einzelnen (siehe neue unit UFormats.pas):

• 7 Codecs von Libav, die funktionieren. U.a.auch mjpeg
  Liste von Dateiformaten, die unterstützt werden, Liste von Codecs, die von gegebenem Dateiformat unterstützt werden
  Mechanismen zum einfachen Darstellen in Listen (Combobox.items)
  Eine Klasse TBaseCodecSetup und Nachfolger, die das set up für bestimmte Codecs übernehmen
  Mechanismus zum Registrieren eines neuen Codecs mit passender Setup-Klasse
  Rudimentäre Unterstützung von Audio

(Das use GraphicEx ist jetzt auch verschwunden)

Damit wäre der Grundstein für open source gelegt, aber ich trau mich im Moment noch nicht . Ich krieg zwar irgendwie alles von GitHub oder SourceForge, das ich will, aber der ganze Aufbau ist mir ein Rätsel.

Danke fürs feedback

Renate

[TurboMagic]

Das klingt doch schon ganz gut!
Das mit der Open-Source Veröffentlichung ist auch nicht sooo schwer,
zumindest wenn man grundsätzliche Kenntnis von Versionskontrolle hat.

1. GitHub Konto anlegen

2. Neues Repository/Projekt dort anlegen

3. Eine Lizenz für den eigenen Code raussuchen und im Header aller Units
als Verweis auf eine zentrale Lizenzdatei angeben. Populäre Lizenzen:
Apache 2.0 oder Mozilla Public License 2.0 wenn mann nicht erzwingen
will, dass Code der die Bibliothek benutzt auch zu Open Source werden
muss (das wäre ja sonst die GPL)

4. Eine kurze Readme mit Projektbeschreibung anlegen

5. Das auf Github erzeugte leere Projekt auschecken

6. Den eigenen Code in die Arbeitskopie kopieren und Commit/Push hoch damit

So ungefähr wäre der Ablauf.

Grüße
TurboMagic

[Renate Schaaf]

@Turbomagic: Danke! Das hilft mir schon enorm weiter.

Renate

[TurboMagic]

Na, schon weiter gekommen mit dem Publizieren deiner Bibliothek?

ANdere Frage: wie würde man in einer Android APp einen Video auf diese/ähnliche Weise erzeugen?

[Renate Schaaf]

Zitat:

Na, schon weiter gekommen mit dem Publizieren deiner Bibliothek?

Nöö.. Ich versuche gerade vom Handy aufgenommene Videos mit einzubinden, was mir arge Kopfschmerzen bereitet von wegen verschiedener frame rate.

Mit Android habe ich mich noch nicht befasst, und ich habe mein Smartphone verschenkt...

Aber man kann unter Windows ein Video produzieren, dass unter Android abgespielt werden kann, das spielt doch mp4 ab oder nicht?, und ganz bestimmt avis mit mjpeg, weil die Handies doch solche selber aufnehmen.

Abgesehen davon, habe ich Deinen anderen thread verfolgt. Wenn ich etwas Video-artiges in Echtzeit auf den Bildschirm bringe, mache ich das nicht mit nem timer, sondern umgekehrt:
Loop:
Zeit messen, die vergangen ist -> mittels fps umrechnen auf das Bild, das jetzt angezeigt werden muss -> das Bild anzeigen -> sleep

Damit zeigt man u.U. mehr Updates als eigentlich nötig, aber die sind normalerweise pünktlich. Meine Diaschau funktioniert so auf die Zehntelsekunde genau. Fürs Anzeigen möglichst direkt auf einen HDC zeichnen, Komponenten wie TImgage haben zu viel Overhead.

Nochmal zum Video: Ich meine gelesen zu haben, dass Libav auch unter Android etc. funktioniert, muss mal sehen, ob ich das noch finde.
Update: Unter dem Link, den ich für die Dlls angegeben habe, gibt es die entsprechenden Dlls auch für Android. Gibt es Bitmaps unter Android? Vielleicht muss man ja nur die Dlls austauschen...Wahrscheinlich zu naiv.

Gruß, Renate

[TurboMagic]

Hallo Renate,

danke für deine Antwort!

1. Wäre es nicht geschickter wenn du dass, was du inzwischen schon hast mal einfach
mutig unter open source veröffentlichst? Dann könnten andere dir einfacher helfen.

2. Wir suchen nach einer Lösung um farbige Rechtecke mit einer konstanten Frequenz
z. B. 30 Hz auszugeben. Eine Idee war, diese evtl. einfach als Video zu codieren
und das dann abzuspielen. Müsste aber auf dem Android Smartphone passieren.
Kann man deinen Lösungsansatz evtl. passend umbauen? Was braucht man dazu?
Reicht die freie Header Übersetzung der ffmpeg Webseite?
http://www.delphiffmpeg.com/headers/
Kann man die Framerate einstellen und nach wieviel Frames ein neues P-Frame kommt?
Kann man die gewünschten Frames einfach als Bitmap übergeben? Wir brauchen sicher
keine "High sophisticated" Kompression und auch kein AUdio.

Grüße
TurboMagic

[Renate Schaaf]

Das heißt, du bräuchtest nur das Create, AddFrame, CloseFile.

Das kann man alles ohne WinApi kodieren. Gut, dann werde ich mal mein Rio auf crossplatform upgraden (dann lädt es noch länger...),
aber was tut man nicht alles. Mal gucken, ob ich was hinkriege, bei dem der Compiler nicht meckert, den Rest musst du machen.

Und On-the-fly geht wirklich nicht? Wundert mich, aber wie gesagt, Android keine Erfahrung.

Zitat:

Kann man die Framerate einstellen

Kann man.

Zitat:

und nach wieviel Frames ein neues P-Frame kommt?

Sowas kann man auch einstellen, aber der encoder macht dann gern, was er für richtig hält.

Gruß!