เวกเตอร์การเคลื่อนไหวทำงานอย่างไรในการเข้ารหัสล่วงหน้าสำหรับ MPEG?

ใน MPEG มีกระบวนการที่ภาพแตกออกเป็น macroblocks และเวกเตอร์การเคลื่อนไหวถูกคำนวณสำหรับแต่ละบล็อกแมโครเหล่านั้น จากนั้นคุณส่งเวกเตอร์เหล่านี้พร้อมกับข้อผิดพลาดในการคาดการณ์เพื่อสร้างภาพถัดไปในลำดับวิดีโอ

ฉันกำลังพยายามที่จะเข้าใจวิธีการทำงานนี้ macroblock แต่ละตัวมีเวกเตอร์แบบเคลื่อนไหวที่เกี่ยวข้องซึ่งถ้า (เวกเตอร์คือ [1,0]) กล่าวว่าall the pixels in this block move 1 in the x direction and 0 in the y direction for the next frame. หากเวกเตอร์การเคลื่อนไหวทั้งหมดไม่ได้จัดแนวอย่างถูกต้องสิ่งนี้จะไม่ทำให้พื้นที่ของภาพที่ไม่มีการนับ (เช่นพื้นที่ที่ macroblock นั้นเริ่มแรก)?

ตัวอย่างเช่นฉันมีคำถามต่อไปนี้ที่ฉันพบ

พิจารณาภาพต่อไปนี้ในเวลา 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

ภาพนี้แบ่งออกเป็น macroblocks 2x2 และส่งเวกเตอร์เคลื่อนไหวต่อไปนี้เพื่อสร้างใหม่:

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

ภาพในขั้นตอนก่อนหน้านี้ t - 1 ดูเหมือนว่า:

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

ข้อผิดพลาดที่ส่งคืออะไร?

คุณจะแก้ปัญหานี้อย่างไร

เพื่อลดความสับสนให้ง่ายขึ้น - มีสองกระบวนการ:

1. การประมาณค่าการ
เคลื่อนไหว 2. การชดเชยการเคลื่อนไหว

ก่อนที่เราจะพูดถึงการประมาณค่าเราควรพูดถึงการชดเชยการเคลื่อนไหว

ให้พูด, คือแยกในบล็อกB L o C k s T [ k ] ( x ' , Y ' )$Image_{t}(x,y)$$Blocks_{t}[k](x',y')$

งานของการชดเชยการเคลื่อนไหวคือการผลิตจากภูมิภาคใด ๆ ของ ฉันm กรัมอีที- 1 ( x , Y )$Blocks_{t}[k](x',y')$$Image_{t-1}(x,y)$

ดังนั้นบล็อกอื่นที่ไม่จำเป็นต้องอยู่ในขอบเขต 16x16 จึงเป็นสิ่งที่ดีที่สุดที่ตรงกับความต้องการของผู้ใช้$Blocks_{t-1}[k](x'+mx,y'+my)$

ที่นี่เรียกว่าเวกเตอร์การเคลื่อนไหว$mx, my$

เราสามารถคำนวณข้อผิดพลาดระหว่างเป้าหมายและการอ้างอิงเป็น

ดังนั้นตอนนี้เข้ารหัสพื้นง (กับ DCT และควอน) และ( เมตรx , ม. Y ) [ k ] สำหรับแต่ละบล็อก ,.$Err_{t}[k](x,y)$${( mx, my) }[k]$

ดังนั้นตัวเข้ารหัสมี 2 งานที่ต้องทำ:

1. การประมาณค่าการเคลื่อนไหว
กระบวนการหรือการประมาณสำหรับทุกๆkที่E r r t [ k ] ( x , y )ถูกย่อให้เล็กสุดเรียกว่าการประมาณค่าการเคลื่อนไหว${ mx, my }[k]$$k$$Err_{t}[k](x,y)$

2. การสร้างภาพที่ผิดพลาดหลังจากที่ชดเชยการเคลื่อนไหว
กระบวนการของการสร้างจากฉันทีพิกเซลของภาพและ( เมตรx , ม. Y ) [ k ]เรียกว่าการชดเชยการเคลื่อนไหว . ภาพข้อผิดพลาดคือสิ่งที่ได้รับการส่ง$Blocks_{t}[k](x',y')$$I_{t}$${ (mx, my) }[k]$

ในที่สุดตัวถอดรหัสสามารถทำการชดเชยการเคลื่อนไหวอีกครั้งด้วยตัวเองโดยใช้เวกเตอร์ moiton และภาพข้อผิดพลาดเพื่อสร้างภาพขั้นสุดท้ายขึ้นใหม่

ตอนนี้เราตระหนักถึงจุดไม่กี่:

1. การประมาณการเคลื่อนไหวที่ดีที่สุดช่วยลดพลังงานที่ต้องใช้ในการส่งและปรับบิตให้มีคุณภาพสูงสุด

2. อย่างไรก็ตามแม้ว่าไม่เหมาะหรือหากฉากมีการเปลี่ยนแปลงอย่างมีนัยสำคัญในภาพสุดท้ายE r r t [ k ] ( ${ (mx, my) }[k]$จะถูกส่งไปยังผู้รับเสมอ - ดังนั้นการสร้างใหม่ สมบูรณ์แบบอยู่เสมอ (modulo การสูญเสียที่เกิดจากการหาปริมาณ) ดังนั้นแม้ว่าคุณจะมีเวกเตอร์การเคลื่อนไหวหรือความซ้ำซ้อนไม่มากนักการฟื้นฟูยังคงสมบูรณ์แบบเสมอแม้จะมีบิตมากกว่า!$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') )$$ .

In such cases, it might be more advisable to transmit block directly without prediction than to send the difference. This is also possible in the encoder by a provision called INTRA block.

No, it won't leave holes, because the vector is from an unknown frame (P or B), to a known frame (I-frame). It reminds a little bit of how ot compute an image transformation - you use a backward transform to avoid holes/

As is the case with many standard signal processing routines, it's quite straightforward on paper and a little tricky in practice. You separated your image into six blocks $B(i,j)$ with $i = \{0,1,2\}$ and $j = \{0,1\}$. each of this blocks has coordinates at $(2i, 2j)$ (we consider top left corner of each to identify its location). We, therefore, now have six blocks at

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

Your calculated motion vectors $M(i,j)$ for each block are

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

Now, to calculate the resulting image, we must first know where every block moved. To do that, we simply add the above coordinate matrix to its motion matrix: $B'(i,j)=B(i,j)+M(i,j)$. We get

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

In order to avoid "holes" as you said, we don't simply move blocks of the original frame around to get the new one, we take the original one as a reference and inject the newly calculated blocks. To do this, we first make a copy of the original frame. We then take every $B'(i,j)$ and replace it with pixels of corresponding $B(i,j)$.

Note: We are not protected from any kind of overlapping of block "in motion" (two blocks are moved to overlapping locations). There are ways to handle that, but it's beyond the scope of this response. For now, we're just going to rewrite any pixels with a block we're moving to their location, so that even if there were blocks moved there previously, they will get overwritten.

Now, going block by block in the order you had in your question, we replace every $B'(i,j)$ by its corresponding $B(i,j)$. We get the followinf estimated frame $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

The error $E$ is found between estimated frame $F_e$ and the one we're trying to predict $F$ is found by $E=F-F_e$ which we calculate to be

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