Posts mit dem Label Visual Studio werden angezeigt. Alle Posts anzeigen
Posts mit dem Label Visual Studio werden angezeigt. Alle Posts anzeigen

Montag, 1. Juni 2009

XVID-Windows-Compilierung - Teil 2: DirectShow-Treiber compilieren

Im vorherigen Post haben wir die XVID-Core-Bibliothek und den VFW-Treiber compiliert. Dieser Beitrag schließt die XVID-Compilierung unter Windows mit Visual Studio mit der Compilierung des DirectShow-Treibers ab.

DirectShow-Basisklassen compilieren

Um den DirectShow-Treiber compilieren zu können, benötigt man die DirectShow-Basisklassen. Diese waren vor einigen Jahren noch als Beispiele im DirectX SDK enthalten, sind dann aber in das Plattform SDK verlagert worden und schliesslich in das Windows SDK. Da das Windows SDK ein ziemlicher Brocken ist, greifen wir auf das DirectX SDK vom Sommer 2004 zurück:

http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=fd044a42-9912-42a3-9a9e-d857199f888e


Nach dem Aufruf der heruntergeladenen EXE wird das SDK zunächst in ein beliebiges Verzeichnis entpackt. Dies sei im Folgenden als %SDK% bezeichnet. Anschließend wird ein Installationsprogramm gestartet, welches abgebrochen werden kann. Wir benötigen nur die Dateien und die haben wir bereits nach dem Entpacken.

Nun öffnen wir das Projekt zum Compilieren der Basisklassen von DirektShow:
%SDK%\Samples\C++\DirectShow\BaseClasses\baseclasses.sln

Wir stellen wieder von "Debug" auf "Release" um.

Nun ergänzen wir die Pfade zu den Includes und Bibliotheken des DirectX-SDKs:
- Tools > Options... > Projects and Solutions > VC++ Directories
- Include Path ergänzen: %SDK%\Include
- Library Path ergänzen: %SDK%\Lib

Nun starten wir den Build. Beim Compilieren werden zunächst einige Fehler auftreten, die durch eine mangelnde Typisierung von Variablen verursacht werden. Hier genügen 4 kleine Fixes bei den Variablendeklarationen um den Build fehlerfrei zu bekommen. (Diese werden u.a. auch auf folgender Seite beschrieben).

In den Basisklassen werden folgende Änderungen vorgenommen:

ctlutil.h (278):
(LONG) operator=(LONG);

wxdebug.cpp (564):
static DWORD g_dwLastRefresh = 0;

winutil.cpp (2092):
UINT Count;
for (Count = 0;Count <>

outputq.cpp (635):
long iDone = 0;
for (iDone = 0;


Nun läuft der Build durch. Das Ergebnis der Mühen ist die Bibliothek der Basisklassen "%SDK%\Samples\C++\DirectShow\BaseClasses\Release\STRMBASE.lib" gegen den der XVID DirectShow-Filter gelinkt werden kann.

XVID-DirectShow-Treiber compilieren

Wir schließen den Workspace und öffnen das Projekt "%XVID%\dshow\dshow.dsp".

Nun ergänzen wir die Pfade zu der soben erstellten Bibliothek der DirectShow-Basisklassen.
- Tools > Options... > Projects and Solutions > VC++ Directories
- Include Path ergänzen: %SDK%\Samples\C++\DirectShow\BaseClasses
- Library Path ergänzen: %SDK%\Samples\C++\DirectShow\BaseClasses\Release

Nun den Build des Projekts "dshow" anstoßen. Er sollte problemlos durchlaufen.

XVID-DirectShow-Treiber installieren

Nach der Compilierung liegt der DirectShow-Filter im bin-Verzeichnis des dshow-Projekts:

%XVID%\dshow\bin\xvid.ax

Zum Installieren des Filters, die Datei in das Unterverzeichnis "systems32" von Windows kopieren und registrieren.

Registrieren des DirectShow-Filters am System:

regsvr32 \system32\xvid.ax

Will man den Filter wieder entfernen, dann mit folgender Kommandozeile deregistrieren und anschließend löschen:

regsvr32 /u \system32\xvid.ax

XVID-DirectShow-Treiber testen

Die Funktion des DirectShow-Filters kann man mit GraphEdit aus den SDK-Utilities überprüfen, indem man einen Verarbeitungsgraph für eine XVID-Datei aufbaut, der explizit den XVID-DirectShow-Filter beinhaltet. Zu empfehlen ist auch GraphStudio, eine Open-Source-Software, die GraphEdit erweitert:

http://blog.monogram.sk/janos/tools/monogram-graphstudio/

Ein geeigneter Graph zum Testen wäre:

[ File Source (async.) ] -> [ AVI Splitter ] -> [ XVID MPEG-4 Video Decoder ] -> [ Overlay Mixer2 ] -> [ Video Renderer ]

Mit Hilfe von GSpot (http://www.headbands.com/gspot) läßt sich zudem überprüfen, welche Graphen für Video-Dateien vom System tatsächlich verwendet werden um diese abzuspielen.

Weitere Informationen zu DirectShow findet man z.B. hier:
- Programmierung: http://tmhare.mvps.org/help.htm
- Generell: http://en.wikipedia.org/wiki/DirectShow

Sonntag, 31. Mai 2009

XVID-Windows-Compilierung - Teil 1: Core und VFW-Treiber


Hintergrund


XVID-Binaries für Windows finden sich bei normalerweise unter http://www.koepi.info/xvid.html. Allerdings kann es etwas dauern bis nach einem neuen Release die entsprechenden Binaries zur Verfügung stehen. Am 28.05.2009 wurde XVID in Version 1.2.2 freigegeben (siehe z.B. Meldung im Heise-Ticker) und ich habe dies zum Anlass genommen XVID einmal selbst unter Windows zu compilieren. Wie ich feststellen konnte, geht dies ziemlich schnell und problemlos, falls man bereits ein Visual Studio installiert hat.

Meine Erfahrungen habe ich im Folgenden in Form einer kleinen Anleitung zum Compilieren von XVID 1.2.2 zusammengestellt. Die Anleitung erhebt keinen Anspruch darauf immer und unter jeder Umgebung zu funktionieren. Aber vielleicht kann diese Anleitung für jemanden hilfreich sein, der sich auch einmal an die XVID-Compilierung wagen möchte.


Benötigt

XVID Sourcen: http://www.xvid.org/

NASM Assembler: http://www.nasm.us/

Die folgende Anleitung wurde unter folgenden Umgebungen getestet:
  • Windows XP SP3 mit Visual Studio 2005
  • Windows Vista SP2 mit Visual Studio 2008

Vorbereitung

Hinweis: Um potentielle Probleme mit Spaces im Pfad von vornherein auszuschliessen, am besten nur Pfade ohne Spaces wählen.

1. XVID Sourcen in ein beliebiges Verzeichnis entpacken. Im Folgenden sei dies als %XVID%
bezeichnet.

2. NASM Assembler in ein beliebiges Verzeichnis entpacken. Im Folgenden sei dies als %NASM% bezeichnet.


Compilieren

Die Compilierung von XVID erfolgt in zwei Schritten:
  1. XVIDCore-Bibliothek compilieren
  2. XVID VFW-Treiber compilieren

1. XVIDCore-Bibliothek compilieren

Visual Studio Workspace File "%XVID%\build\win32\xvidcore.dsw" öffnen.
  • Nachfragen, ob VCProject-Dateien (*.vcproj), die bereits im aktuellen Format vorliegen, verwendet werden sollen, mit "Ja" beantworten.
  • Nachfragen, ob Projektdateien (*.dsp), die in einem älteren Format vorliegen, in das aktuelle Format konvertiert werden sollen, mit "Ja" beantworten.
Rechts im Solution Explorer sollte das Projekt "libxvidcore" durch eine fette Schrif als aktuelles Projekt gekennzeichnet sein.

In der Symbolleiste wird als Build-Konfiguration "Debug" und "Win32" angezeigt. Hier "Debug" auf "Release" ändern.

Nun den NASM-Assembler zum Pfad der VC++ Tools hinzufügen:
  • Tools > Options... > Projects and Solutions > VC++ Directories
  • Den Pfad "%NASM%" einfügen (Position in Liste ist egal)
Die Ansicht der Ausgabe aktivieren (Menü: View > Output), um den Fortschritt des folgenden Build-Laufes verfolgen zu können.

Um den Build zu starten im Solution Explorer mit der rechten Maustaste auf das aktuelle Projekt "libxvidcore" klicken, dann "Project only > Build only libxvidcore" wählen.

Nach erfolgreichem Build sollte die Datei "%XVID%\build\win32\bin\xvidcore.dll" erzeugt worden sein.


H I N W E I S

Hat man beim Öffnen des Workspace Files nicht die bestehenden *.vcproj-Dateien übernommen, so werden nun einige ASM-Files nicht compiliert und der Build bricht mit einer entsprechenden Meldung ab:

[...]
1>Assembling %XVID%\src\image\x86_asm\colorspace_yuyv_mmx.asm

1>nasm: error: no input file specified

1>type `nasm -h' for help

1>Project : error PRJ0019: A tool returned an error code from "Assembling %XVID%\src\image\x86_asm\colorspace_yuyv_mmx.asm"


Dies läßt sich jedoch durch eine Korrektur der Custom-Build-Anweisung (Aufruf des NASM-Compilers) für die betroffenen Dateien beheben. Dazu die betroffene Datei im Solution Explorer im Projekt ansteuern. Nun rechte Maustaste > Properties > Custom Build Step > Commandline. Dort steht:

nasm -o "$(IntDir)\$(InputName).obj" -f win32 -DWINDOWS -I..\..\src\ -I"$(InputDir)"\ "$(InputPath)"

Dies korrigieren auf (Entfernen der Anführungszeichen und des Backslashs nach -I bis Ende):

nasm -o "$(IntDir)\$(InputName).obj" -f win32 -DWINDOWS -I..\..\src\ -I$(InputDir) $(InputPath)

Build neu starten. Der Build hängt nun bei einem anderen ASM-File. Nun solange die Custom Build Step Commandline betroffener ASM-Files wie oben angegeben ändern bis der Build durchläuft. Betroffen sind lediglich die folgenden drei ASM-Files:
  • colorspace_yuyv_mmx.asm
  • colorspace_yuv_mmx.asm
  • colorspace_rgb_mmx.asm
Die Custom Build Step Commandlines sind in der VS-Projektdatei "libxvidcore.dsp" zu den einzelnen ASM-Dateien hinterlegt. Eine Änderung der Commandlines kann daher auch mit einem Texteditor in dieser Datei vorgenommen werden (sofern das Projekt nicht gerade in VS geöffnet ist).

2. VFW-Treiber compilieren

Falls der Workspace aus dem vorherigen Build noch geöffnet sein sollte, dann diesen schließen (Menü: File > Close Solution).

Nun Projektdatei "%XVID%\vfw\vfw.dsp" öffnen (Nachfragen wie oben beantworten).

Sicherstellen, dass die Konfiguration auf "Release" und nicht auf "Debug" gestellt ist.

Build des Projekts "vfw" im Solution Explorer starten (rechte Maustaste > Build).

Nach dem Start des Build öffnet sich eine Dialogbox, da VS die Lösung vor dem Build noch in eine Solution-Datei (*.sln) speichern möchte. Dies kann man getrost mit "Cancel" abbrechen.

Der Build sollte problemlos durchlaufen.

Im Verzeichnis "%XVID%\vfw\bin" sollten nun die folgenden drei Dateien zu finden sein:
  • xvid.inf
  • xvidvfw.dll
  • xvidcore.dll

Um den VFW-Treiber zu installieren einfach "xvid.inf" mit der rechten Maustaste anklicken, "Installieren" wählen. Eventuelle Nachfragen, ob der Treiber tatsächlich installiert werden soll, bestätigen. (Die DLL-Dateien werden bei der Installation in das system32-Verzeichnis von Windows kopiert.)

Um den Treiber zu Deinstallieren: Systemsteuerung > Software. Dort aus der Liste der installierten Software "Xvid MPEG-4 Video Codec" auswahlen und auf "Entfernen" klicken.

Weitere nützliche Infos zur Compilierung von XVID unter Windows (wenn auch älter) finden sich hier: http://www.discdude.net/xvid/compile.html

Im nächsten Teil werden wir die Compilierung von XVID durch die Compilierung des XVID-DirectShow-Filters, dessen Installation und Test abschließen.