Bagaimana cara kerja vektor gerakan dalam pengkodean prediktif untuk MPEG?

Dalam MPEG, ada proses di mana gambar dipecah menjadi blok makro dan vektor gerak dihitung untuk masing-masing blok makro tersebut. Anda kemudian mengirimkan vektor-vektor ini, bersama dengan kesalahan prediksi, untuk merekonstruksi gambar berikutnya dalam urutan video.

Saya mencoba untuk memahami cara kerjanya. Setiap makroblok memiliki vektor gerakan yang terkait dengannya, yang (jika vektor adalah [1,0]), mengatakan all the pixels in this block move 1 in the x direction and 0 in the y direction for the next frame. Jika semua vektor gerakan tidak sejajar dengan benar, tidakkah ini meninggalkan area gambar yang tidak terhitung (seperti area di mana macroblock itu ada di tempat pertama)?

Sebagai contoh, saya memiliki pertanyaan berikut yang saya temukan.

Pertimbangkan gambar berikut pada waktu t:

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

Gambar ini dipecah menjadi blok makro 2x2 dan vektor gerakan berikut dikirim bersama untuk membuatnya kembali:

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

Gambar pada langkah waktu sebelumnya, t - 1, tampak seperti ini:

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

Apa kesalahan yang ditransmisikan?

Bagaimana Anda menyelesaikan ini?

Untuk menyederhanakan kebingungan Anda - ada dua proses:

1. Estimasi
gerak 2. Kompensasi gerak

Sebelum kita berbicara tentang estimasi, kita harus membicarakan kompensasi gerak.

Katakanlah, dibagi dalam blok B l o c k s t [ k ] ( x ′ , y ′ ) .$Image_{t}(x,y)$$Blocks_{t}[k](x',y')$

Tugas kompensasi Gerak adalah untuk menghasilkan dari kawasan manapun dari saya m sebuah g e t - 1 ( x , y ) .$Blocks_{t}[k](x',y')$$Image_{t-1}(x,y)$

Oleh karena itu blok lain belum tentu selaras pada 16x16 batas adalah yang terbaik pertandingan $Blocks_{t-1}[k](x'+mx,y'+my)$

Di sini, disebut vektor motion.$mx, my$

Kami dapat menghitung kesalahan antara target dan referensi sebagai

Jadi sekarang, encoder pada dasarnya mentransmisikan (dengan DCT dan kuantisasi) dan ( m x , m y ) [ k ] untuk setiap blok ,.$Err_{t}[k](x,y)$${( mx, my) }[k]$

Jadi encoder memiliki 2 pekerjaan yang harus dilakukan:

1. Motion Estimasi
Proses atau mengestimasi untuk setiap k sehingga E r r t [ k ] ( x , y ) diminimalkan disebut estimasi Motion.${ mx, my }[k]$$k$$Err_{t}[k](x,y)$

2. Generasi gambar kesalahan setelah Gerak Kompensasi
Proses membangun dari saya t piksel gambar dan ( m x , m y ) [ k ] disebut kompensasi Gerak . Gambar kesalahan adalah apa yang ditransmisikan.$Blocks_{t}[k](x',y')$$I_{t}$${ (mx, my) }[k]$

Akhirnya, decoder dapat melakukan kembali gerak kompensasi sendiri menggunakan vektor moiton dan gambar kesalahan untuk membuat konstruksi ulang akhir gambar.

Sekarang kami menyadari beberapa poin:

1. Estimasi Best Motion membantu meminimalkan energi yang diperlukan untuk ditransmisikan dan karenanya mengoptimalkan bit untuk kualitas yang diberikan.

2. ${ (mx, my) }[k]$$Err_{t}[k](x,y)$

3. $Blocks_{t}[k](x',y')$

4. $Blocks_{t}[k]$$( mx ,my )[k]$$Blocks_{t}[k+1]$

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

Dalam kasus seperti itu, mungkin lebih baik mengirim blok secara langsung tanpa prediksi daripada mengirim perbedaan. Ini juga dimungkinkan dalam pembuat enkode dengan ketentuan yang disebut blok INTRA.

Tidak, itu tidak akan meninggalkan lubang, karena vektor berasal dari frame yang tidak diketahui (P atau B), ke frame yang dikenal (frame-I). Ini mengingatkan sedikit tentang bagaimana menghitung transformasi gambar - Anda menggunakan transformasi mundur untuk menghindari lubang /

$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)$

Catatan: Kami tidak dilindungi dari segala jenis tumpang tindih blok "yang sedang bergerak" (dua blok dipindahkan ke lokasi yang tumpang tindih). Ada beberapa cara untuk mengatasinya, tetapi ini berada di luar cakupan respons ini. Untuk saat ini, kami hanya akan menulis ulang piksel dengan blok yang kami pindahkan ke lokasi mereka, sehingga meskipun ada blok yang dipindahkan sebelumnya, mereka akan ditimpa.

$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