Pull-Up

aus Wikipedia, der freien Enzyklopädie

Als Pull-up [pʊlˈʌp] wird die Konvertierung von Filmmaterial mit 24 bis 25 Vollbildern/Sekunde in für klassische Fernsehübertragung geeignete 50 oder 60 Halbbilder/Sekunde bezeichnet.

Die Umwandlung von 24 Hz Vollbild in 60 Hz NTSC-Halbbild nennt man NTSC 2:3 Pull-Up.

Die Umwandlung von 25 Hz Vollbild in 50 Hz PAL-Halbbild nennt man PAL 2:2 Pull-Up.

Die Umwandlung von 24 Hz Vollbild in 25 Hz Vollbild durch um ca. 4% schnelleres Abspielen bezeichnet man als PAL-Speedup, der umgekehrte Prozess als PAL-Speeddown.

Der umgekehrte Prozess zum Pull-Up nennt sich Pull-Down. Dort werden zusammengehörige Pseudohalbbilder wieder zu Vollbildern zusammengesetzt, bei NTSC werden weiterhin doppelt übertragene Halbbilder verworfen (oder zur Rauschminderung verwendet). Dieser Prozess ist vor jeglicher Nachverarbeitung von Bildern auf der Darstellungsseite notwendig.

Sauber geht ein Pull-Down nur bei einem klassischen Pull-Up, das einfach Bilder zerlegt und ggf. wiederholt. Bei der auch häufig verwendeten Verblendtechnik, bei der Bilder gemischt werden, geht das nicht mehr.

[Bearbeiten] Berechnung von Zwischenbildern bei LCDs

Da alle derzeitig verfügbaren Panels intern die Darstellung mit 60 Bildern/Sekunde auffrischen, ist für eine saubere Bewegtdarstellung ohne Doppelkonturen und Ruckeln eine Umrechnung des Bildes auf 60 Vollbilder pro Sekunde notwendig. Diese Umrechnung ist in allen Modi erforderlich, die nicht 60 Vollbilder pro Sekunde übertragen, d.h. für praktisch alle Quellen. Diese Umrechnung erfolgt durch das Generieren von Zwischenbildern, die durch Erkennen von Bewegungen im Bild berechnet werden. Die dazu verwendeten Algorithmen und die notwendigen Verarbeitungsleistungen sind für Bilder mit und ohne Zeilensprung fast identisch, bei Zeilensprung werden aber die geraden und ungerade Zeilen des intern berechneten Bildes zu unterschiedlichen Zeitpunkten mit real gesendeten Bildern aktualisiert.

Umrechnung von 25p auf 50p:

 Lies Vollbild n+0: A(n+0,x,y)    ---------------> Ausgabe von A(n+0,x,y)
   ^
   |
 Suche von Bewegungsvektoren v(n+0,x,y) ---------> Ausgabe von 0,5 * A(n+0,x,y)°0,5 v(n+0,x,y) + 0,5 * A(n+1,x,y)°-0,5 v(n+0,x,y)
   |
   v
 Lies Vollbild n+1: A(n+1,x,y)    ---------------> Ausgabe von A(n+1,x,y)
   ^
   |
 Suche von Bewegungsvektoren v(n+1,x,y) ---------> Ausgabe von 0,5 * A(n+1,x,y)°0,5 v(n+1,x,y) + 0,5 * A(n+2,x,y)°-0,5 v(n+1,x,y)
   |
   v
 Lies Vollbild n+2: A(n+2,x,y)    ---------------> Ausgabe von A(n+2,x,y)
   ^
   |

Bemerkung: Das Zeichen "°" steht für den Verschiebeoperator.

Umrechnung von 24p auf 60p:

 Lies Vollbild n+0: A(n+0,x,y)    ---------------> Ausgabe von A(n+0,x,y)
   ^
   |
 Suche von Bewegungsvektoren v(n+0,x,y) --+------> Ausgabe von 0,6 * A(n+0,x,y)°0,4 v(n+0,x,y) + 0,4 * A(n+1,x,y)°-0,6 v(n+0,x,y)
   |                                      |
   |                                      |
   |                                      +------> Ausgabe von 0,2 * A(n+0,x,y)°0,8 v(n+0,x,y) + 0,8 * A(n+1,x,y)°-0,2 v(n+0,x,y)
   v
 Lies Vollbild n+1: A(n+1,x,y)
   ^                                      +------> Ausgabe von 0,8 * A(n+0,x,y)°0,2 v(n+1,x,y) + 0,2 * A(n+2,x,y)°-0,8 v(n+1,x,y)
   |                                      |
   |                                      |
 Suche von Bewegungsvektoren v(n+1,x,y) --+------> Ausgabe von 0,4 * A(n+0,x,y)°0,6 v(n+1,x,y) + 0,6 * A(n+2,x,y)°-0,4 v(n+1,x,y)
   |
   v
 Lies Vollbild n+2: A(n+2,x,y)    ---------------> Ausgabe von A(n+2,x,y)
   ^
   |

Bemerkung: Hier wird jedes zweite Bild überhaupt nicht (unbearbeitet) ausgeben.

Wenn die Quelle mit Zeilensprung ist, werden die Funktionen "Lies Vollbild" und "Suche Bewegungsvektoren" modifiziert. Das Lesen eines Halbbildes erfolgt durch Verschieben des vorherigen Halbbildes und Ersetzen der Zeilen, die in diesem Halbbild gesendet worden. Die Such der Bewegungsvektoren erfolgt teilweise durch Mustersuche im vorherigen Halbbild, teilweise durch Mustersuche im vorvorherigen Halbbild.

Siehe auch: Bewegte Bilder