Bevægelseskompensation er en af de vigtigste algoritmer , der bruges til at behandle og komprimere videodata . Algoritmen bruger ligheden mellem tilstødende frames i videosekvensen og finder bevægelsesvektorerne for individuelle dele af billedet (normalt blokke på 16x16 og 8x8). Brugen af kompensation gør det muligt gentagne gange at øge kompressionsforholdet under kompression på grund af fjernelse af redundans i form af matchende dele af rammer. Bruges ikke kun til komprimering, men også til videofiltrering , ændring af billedhastigheden osv.
Løsning af problemet med komprimering har været en afgørende bekymring siden fremkomsten af digital video. Til evaluering, lad os tage en videosekvens med følgende parametre:
Som et resultat vil det tage 14,8 megabyte at optage eller transmittere et sekund af sådan video uden komprimering, eksklusive lyd og serviceoplysninger. For at gemme halvanden times film vil der allerede være brug for 79.920 megabyte (78 gigabyte ).
I næsten enhver video er tilstødende rammer ens, har fælles objekter, som som regel bevæger sig parallelt. Og det er helt naturligt at ønske at kode video på en sådan måde, at objekter ikke bliver kodet mange gange, men nogle af deres forskydninger er ganske enkelt beskrevet.[ neutralitet? ]
Selv i dette eksempel, hvis vi tager og pakker den 0. ramme og alle billeder af interframe-forskellen med arkiveren, får vi en mærkbar[ hvor meget? ] kompressionsforstærkning. Men denne gevinst kan øges markant.
På grund af den høje beregningsmæssige kompleksitet af mønstergenkendelsesalgoritmer og den utilstrækkelige nøjagtighed af deres arbejde, bruges forskellige metoder til hurtigt at finde bevægelsesvektorer (naturligvis ikke uden tab).
1. Den aktuelle ramme er indlæst.
2. Rammen er opdelt i blokke (f.eks. 16×16).
3. Blokke omgås (hver blok behandles separat i dette tilfælde).
4. Når man tæller en blok, omgås et bestemt kvarter af blokken i søgen efter den maksimale overensstemmelse med billedet af blokken på den forrige ramme inden for dette kvarter.
5. Efter at søgningen er afsluttet, får vi således et sæt vektorer, der angiver "bevægelsen" af billedblokke mellem rammer. Disse vektorer kan naturligvis bruges til at skabe et billede af en kompenseret ramme, der bedre tilnærmer den ramme, for hvilken bevægelseskompensation blev udført.
Når du skriver en algoritme, kan spørgsmålet opstå - "Hvordan evalueres "ligheden" af billedfragmenter?". Nogle af mulighederne:
Den mest anvendte beregning er SAD. Det næste spørgsmål er: "Hvordan søger man efter den ønskede blok?"
Implementering af brute force-metoden i C++
void ME ( BYTE * CurrentFrame , BYTE * PreviousFrame , int Width , int Height , MV * MotionVectors ) { int BlocksPerHeight = ( Højde + 15 ) >> 4 ; //Antal blokke vertikalt int BlocksPerWidth = ( Width + 15 ) >> 4 ; //Antal blokke vandret int VerticalOffset , HorisontalOffset , TempOffset ; // Offsets int OffsetPerLine = Width + Border * 2 ; //Offset med én linje int StartOffset = OffsetPerLine * Border + Border ; //Start offset BYTE * CurrPtr , * PrevPtr ; //Pegere til forrige og næste MV -rammer ProbMV ; //Trial vektor lang MinError , Error ; //Fejlværdier for ( int i = 0 ; i < BlocksPerHeight ; i ++ ) { for ( int j = 0 ; j < BlocksPerWidth ; j ++ ) { // Beregn offsets VerticalOffset = ( i << 4 ) * OffsetPerLine + StartOffset ; HorizontalOffset = ( j << 4 ); //Sæt offsets for den aktuelle blok CurrPtr = CurrentFrame + VerticalOffset + HorizontalOffset ; PrevPtr = PreviousFrame + VerticalOffset + HorizontalOffset ; MinError = MAXLONG ; //Vi anser fejlen for at være meget stor for ( int y = - MaxMotion ; y < MaxMotion ; y ++ ) { TempOffset = y * OffsetPerLine ; //Gem på multiplikationer for ( int x = - MaxMotion ; x < MaxMotion ; x ++ ) { //GetError - bloksammenligningsfunktion, fx SAD Error = GetError ( CurrPtr , PrevPtr + TempOffset + x , OffsetPerLine ); //Ny kandidat :) if ( Error < MinError ) { probMV . x = x ; probMV . y = y _ MinError = Fejl ; } } } //Skriv den resulterende vektor :) MotionVectors [ i * BlocksPerWidth + j ] = ProbMV ; } } }I det nye[ hvornår? ] MPEG -4 AVC/H.264-standarden introducerede også ikke-kvadratiske (rektangulære) blokke, hvis størrelse kan opdeles op til 4×4 pixels . Det er således muligt at bruge ligheden mellem naborammer meget effektivt, og på grund af blokkenes mere komplekse form øges nøjagtigheden af bevægelseskompensation ved grænserne af bevægelige objekter. Ud over bevægelseskompensation bruges interframe-informationskomprimering og uafhængig blokkomprimering til yderligere billedforfining (eller for nyligt opståede områder, der ikke var i tidligere frames).
Ud over kompression bruges bevægelseskompensation aktivt[ af hvem? ] i videofiltrering, især i filtermuligheder af høj kvalitet: deinterlacing ( interlacing til progressiv ), støjreduktion , billedhastighedsændringer og andre.
| Kompressionsmetoder _ | |||||||
|---|---|---|---|---|---|---|---|
| Teori |
| ||||||
| Tabsfri |
| ||||||
| Lyd |
| ||||||
| Billeder |
| ||||||
| Video |
| ||||||