MPEG için öngörülü kodlamada hareket vektörleri nasıl çalışır?

MPEG'de, bir görüntünün makro bloklara ayrıldığı ve bu makro blokların her biri için bir hareket vektörünün hesaplandığı bir işlem vardır. Daha sonra video dizisindeki bir sonraki görüntüyü yeniden oluşturmak için tahmin hatalarıyla birlikte bu vektörleri iletirsiniz.

Bunun nasıl çalıştığı konusunda sıkı bir kavrayış yapmaya çalışıyorum. Her makro bloğun kendisiyle ilişkilendirilmiş bir hareket vektörü vardır (bu, vektör [1,0] ise), all the pixels in this block move 1 in the x direction and 0 in the y direction for the next frame. tüm hareket vektörleri doğru hizalanmazsa, görüntünün alanlarının hesaba katılmadığını ( bu makroblok ilk sıradaydı)?

Örneğin, bulduğum şu soru var.

T zamanında aşağıdaki görüntüyü göz önünde bulundurun:

7   7   7   7           
7   7   5   5        
7   5   5   8         
8   8   8   8           
9   9   9   9       
9   9   9   9

Bu görüntü 2x2 makro bloklara ayrıldı ve yeniden oluşturmak için aşağıdaki hareket vektörleri gönderildi:

(0,0)  (0,0)  (0,1)  (-1,1)  (0,0)  (0,0)

Önceki zaman adımındaki görüntü, t - 1 şöyle görünüyordu:

7   7   7   7           
7   7   5   4        
7   7   7   7         
7   5   8   8           
8   9   8   9       
9   9   9   9   

Gönderilen hatalar nelerdi?

Bunu nasıl çözersiniz?

Karışıklığınızı basitleştirmek için - iki süreç var:

1. Hareket tahmini
2. Hareket telafisi

Tahmin hakkında konuşmadan önce, Hareket telafisi hakkında konuşmalıyız.

Diyelim ki, B bloğuna ayrılmıştır l o c k s t [ k ] ( x ′ , y ′ ) .$Image_{t}(x,y)$$Blocks_{t}[k](x',y')$

Hareket telafisinin görevi, I m a g e t - 1'in ( x , y ) herhangi bir bölgesinden üretmektir .$Blocks_{t}[k](x',y')$$Image_{t-1}(x,y)$

Dolayısıyla, 16x16 sınırında mutlaka hizalanmayan başka bir blok mümkün olan en iyi eşleşmedir $Blocks_{t-1}[k](x'+mx,y'+my)$

Burada hareket vektörleri olarak adlandırılır.$mx, my$

Hedef ve referans arasındaki hatayı şu şekilde hesaplayabiliriz:

Şimdi, kodlayıcı temel olarak her blok için (DCT ve nicemleme ile) ve ( m x , m y ) [ k ] iletir .$Err_{t}[k](x,y)$${( mx, my) }[k]$

Yani kodlayıcının 2 işi var:

1. Hareket Tahmin
işlemi ya da tahmin , her için k böyle e r r t [ k ] ( x , y ) en aza hareket tahmini olarak adlandırılır.${ mx, my }[k]$$k$$Err_{t}[k](x,y)$

2. Hareket Dengelemesinden sonra hata görüntüsünün
oluşturulması I t görüntü piksellerinden ve ( m x , m y ) [ k ] ' den oluşturma işlemine Hareket telafisi denir . Hata görüntüsü iletilen şeydir.$Blocks_{t}[k](x',y')$$I_{t}$${ (mx, my) }[k]$

Son olarak, kod çözücü, moiton vektörleri ve hata görüntüsünü kullanarak hareket dengelemesini kendi başına yeniden oluşturabilir.

Şimdi birkaç nokta fark ediyoruz:

1. En İyi Hareket tahmini, iletilmesi gereken enerjiyi en aza indirmeye yardımcı olur ve böylece bitleri belirli bir kalite için optimize eder.

2. Ancak, ideal olmasa veya sahnenin son resim üzerinde önemli bir değişikliği olsa bile, E r r t [ k ] ( x , y ) her zaman alıcıya iletilir - dolayısıyla yeniden yapılandırma her zaman mükemmeldir (nicemenin yarattığı kayıp modulo). Bu nedenle, yetersiz hareket vektörünüz olsa veya fazlalığınız çok olmasa da, yeniden yapılanma her zaman daha fazla bitle de olsa mükemmeldir!${ (mx, my) }[k]$$Err_{t}[k](x,y)$

3. Her blok , kendi başına hareketle dengelenir - bu nedenle, herhangi bir komşu bloğun gerçek hareket vektörlerinin yapı üzerinde bir etkisi olmasa bile. Bu nedenle, mükemmel rekonstrüksiyonun mümkün olması için hareket vektörlerinin mükemmel bir şekilde hizalanması gerekli değildir.$Blocks_{t}[k](x',y')$

4. Algoritma tahmin akıllı yeterli olan mevcut de olsa, eğer bir hareket vektörüne sahip ( m, x , m, y ) [ k ] için tahmin B l O C k s t [ k + 1 ] kudreti sadece buna daha yakın olun.$Blocks_{t}[k]$$( mx ,my )[k]$$Blocks_{t}[k+1]$

5. Son olarak, bir sonraki resmin tamamen farklı olduğunu varsayalım ki .

   $$Energy (Err_{t}[k](x,y)) > Energy ( Blocks_{t}[k](x',y') )$$

Bu gibi durumlarda, bloğu tahmin olmadan doğrudan iletmek farkı göndermekten daha tavsiye edilebilir. Bu kodlayıcıda INTRA bloğu adı verilen bir hükümle de mümkündür.

Hayır, delik bırakmaz, çünkü vektör bilinmeyen bir çerçeveden (P veya B), bilinen bir çerçeveye (I-çerçeve). Bir görüntü dönüşümünü nasıl hesapladığını biraz hatırlatıyor - deliklerden kaçınmak için geriye doğru bir dönüşüm kullanıyorsunuz /

$B(i,j)$$i = \{0,1,2\}$$j = \{0,1\}$$(2i, 2j)$

(0,0) (0,2)
(2,0) (2,2)
(4,0) (4,2)

$M(i,j)$

(0,0) (0,0)
(0,1) (-1,1)
(0,0) (0,0)

$B'(i,j)=B(i,j)+M(i,j)$

(0,0) (0,2)
(2,1) (1,3)
(4,0) (4,2)

$B'(i,j)$$B(i,j)$

Not: "Hareket halinde" herhangi bir blok üst üste binmesine karşı korunmayız (iki blok üst üste binen yerlere taşınır). Bununla başa çıkmanın yolları var, ama bu yanıtın kapsamı dışında. Şimdilik, konumlarına taşıdığımız bir blokla herhangi bir pikseli yeniden yazacağız, böylece daha önce oraya taşınan bloklar olsa bile üzerine yazılacaklar.

$B'(i,j)$$B(i,j)$$F_e$

7 7 7 7
7 7 5 7
7 7 7 8
7 5 5 8
8 9 8 9
9 9 9 9

$E$$F_e$$F$$E=F-F_e$

0 0 0 0           
0 0 0 -3        
0 0 0 -1         
0 0 3 0           
0 0 0 0       
0 0 0 0