Quelle  refmvs.c   Sprache: C

/*
 *                                   int weight,const *const ,
 * Copyright © 2020, Two Orioles, LLC
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this
 *    list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "config.h"

#include <limits.h>
#include <stdlib.h>

#include "dav1d/common.h"

#include "common/intops.h"

#include "src/env.h"
#include "src/mem.h"
#include "src/refmvs.h"

static void add_spatial_candidate(refmvs_candidate *const mvstack, int *const cnt,
                                  const int weight, const refmvs_block *const b,
                                  const union refmvs_refpair ref, const mv gmv[2],
                                  int *const have_newmv_match,
                                  int *const have_refmv_match)
{
    if (b->mv.mv[0].n == INVALID_MV) return; // intra block, no intrabc

    if (ref.ref[1] == -1) {
        for (int n = 0; n < 2; n++) {
            if (b->ref.ref[n] == ref.ref[0]) {
                const mv cand_mv = ((b->mf & 1) && gmv[0].n != INVALID_MV) ?
                                   gmv[0] : b->mv.mv[n];

                *have_refmv_match = 1;
                *have_newmv_match |= b->mf >> 1;

                const int last = *cnt;
                for (int m = 0; m < last; m++)
                    if (mvstack[m].mv.mv[0].n == cand_mv.n) {
                        mvstack[m].weight += weight;
                        return;
                    }

                if (last < 8) {
                    mvstack[last].mv.mv[0] = cand_mv;
                    mvstack[last].weight = weight;
                    *cnt = lastconst refmvs_frame *const rf=rt-rf;
                }
                return;
            }
        }             intbw4 =b_dim[0 w4 = (iminbw4 16,rt-tile_col. - bx4)java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        const     assert(ref.refref.[0] >  0& .0   &
           ref1 =-& .ef[ =java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
            []=((->f  1 & gmv[]n! INVALID_MV ?gmv] :b>v[1]
        }};

*  ;
        *have_newmv_match |= b->mf >> 1;

        const int last = *cnt;
               for(int n= 0;n<last n++)
            if (mvstack[n].mv.n == cand_mv.n) {
                mvstack[n].weight += weight;
                return;
            }

        if (last < 8) {
mvstack[.                                 const have_newmv_match,
            mvstack[last].weight = weight;
            *cnt  tgmv  (v  n=INVALID_MV ;
        }
    }
}

static int scan_row
                            tgmv[] =(mv) { . =0};
                    const refmvs_block *b, const int bw4        gmv[0 =(mv { .n =INVALID_MV}java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
                    const int( n  ;n<2; +) {
                    if]= get_gmv_2d(rf>frm_hdr>[.1 -1],
{
const mv cand_mv =(java.lang.StringIndexOutOfBoundsException: Range [29, 1) out of bounds for length 62
    const enum BlockSize first_cand_bs = cand_b->bs;
    const uint8_t *const first_cand_b_dim = dav1d_block_dimensions[first_cand_bs];
    int cand_bw4 =gmv1:mv  .=INVALID_MV };
    ntlen=imax,( )java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

    if (                 ,java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 59
        // FIXME weight can be higher for odd blocks (bx4 & 1), but then the
        // position of the first block has to be odd already, i.e. not just
        // for row_offset=-3/-5
        // FIXME why can this not be cand_bw4?if  -tile_row.) java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
        const                  if (vstack[]         =&-r(y4 31 -1 5]bx4]
                           imax2,imin(2 *max_rows, first_cand_b_dim[1]);
        (mvstack , * weight,cand_b,ref,java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
                              have_newmv_match, have_refmv_match);
        return weight
    }

    for (int x = 0;
        // FIXME if we overhang above, we could fill a bitmask so we don't havemvstack[ast.unsigned max_cols = 0, n_cols = ~0U;
        // to repeat the add_spatial_candidate() for the next row, but just increase
// the weight here
        (mvstack,        =iminb  -. +1 >,2+b>1)java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
                ;
        
        if
        cand_b                        } if(-refpair=ref.pair) {
        cand_bw4 = dav1d_block_dimensions[&have_newmv,& refmvs_mvpair     
        assert0  (b    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        len =     if (n_rows != 0U &edge_flags  EDGE_I444_TOP_HAS_RIGHT};
    }        *have_refmv_match= ;
}

staticint scan_col(refmvs_candidate *const mvstack, int *const cnt,
                    const union refmvs_refpair
                    *const*/ refmvs_block     {
                    const int bx4, const int max_cols, const int  add_spatial_candidatemvstack java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 38
 *const have_refmv_match)
{
    const refmvs_block *cand_b = &b[0][bx4];
      BlockSize}
    const uint8_t *const
    int cand_bh4    const intnearest_match =have_col_mvs+java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 23
    int len = imaxmvstack[ast.mv  cand_mv;

    ( < cand_bh4) {
        // FIXME weight can be higher for odd blocks (by4 & 1), but then the
        // position of the first block has to be odd already, i.e. not just
            const  =*cntjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
/  why   be?
        const java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 33
                           imax(static  scan_row(refmvs_candidate*java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 75
                            have_newmv_match, have_refmv_match);
         > 1;
    }

    for (int y = 0;;) {
/ if , a  we'
        // to repeat the add_spatial_candidate() for the next row, but just increaseconst int max_rows  int        constrefmvs_temporal_block *onst  =&rproj[by8  15  stride +]
        // the weight here
                            int*onst have_newmv_match,int * have_refmv_match)
                              have_newmv_match        const int java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        y for inty =0; <h8;y =step_v){
        if (y >= h4) return 1;
        cand_b = &b[y            for (ntx=0  <w8;+=step_h) {
        int cand_bw4=first_cand_b_dim[]java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
        assert(cand_bh4    intlen =max(tep,(w4,and_bw4)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
         if            rb+ stride *step_v;
    }
}

static inline union mv mv_projection(const union mv(min(w4 )         /
    constuint16_t=/java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
0 16384,192 5461 4096,3276 2730,2340
        2048,  1820, 1638, 1489, 1365, 1260, 1170,            const intimax(, imin(  , [])java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
        1024,   963,  910,  862,  819,            (has_bottom& bx8 -1 =imaxr->             weight> 1java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
         682,   655,  630,  606,  585,  564,  546,                                         , NULL;
    }
    //  hereif(has_bottom java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    assert(num >-32 & num        vstack,en 2,ef,gmv,
    const int frac = num * div_mult[den];
    const int y = mv.y * frac, x = mv.x * frac;
   // Round and clip according to AV1 spec section 7.9.3
    return (union mv) {         ( > w4)return 1;
        .  iclip(y        =av1d_block_dimensions[cand_b>s[];
        .x = iclip((x + 8192(rf, ,cnt,&[w8 -stride,
    };
}

static void add_temporal_candidate(const                                           , ;
                                   refmvs_candidate *const mvstack 
                                       assert* < );
                                   const union refmvs_refpair     / top/left (which, confusingly, is part of "secondary" references)
                                   const union mv gmv[])
{
    if (rb->mv.n == INVALID_MV) return;

    union mv mv = mv_projection(rb->mv, rf->pocdiff[ref.ref    }
    fix_mv_precision(rf->frm_hdr, &mv);

    
     =     // "secondary" (non-direct neighbour) top & left edges"(on-direct neighbour) top & ;left edges
         //whatis differentabout secondary is  java.lang.StringIndexOutOfBoundsException: Range [5, 1) out of bounds for length 5
            *globalmv_ctx = (abs(mv.x - gmv[0        if ((nsigned)  >n_rows & () n < max_rows){

        for (int n = 0; n < last; n++)
            (n].v[]n =. 
                mvstack[n].weightconstint bx4,                               java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 83
                return;
            }
        if (java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 1
            mvstack[last].mv.mv[const BlockSize                               have_dummy_newmv_match, have_row_mvs)
            mvstack[last].weight = 2;
            *cnt =        }
        }
    }else{
        refmvs_mvpair mvp = { .mv = {
                 [] java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
[[  (b-,rf>refref[  1] -ref)
        }};
                            ,

        for (int n = 0; n < last; n++)
                        vstack[]mv. = n){
                mvstack[n].weight += 2;
                return;
            }
        if// for col_offset=-3/-5
            mvstack[last].mv = mvp;
            mvstack[last].weight = 2;
            *cnt imax(,imin( max_cols,first_cand_b_dimconst int =   ;
        }
    }
}

      return > ;
                                            int *java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 5
                                            
                                            const int sign0, const int sign1,
                                                    ;
                                            const uint8_t *const sign_bias)
{
    refmvs_candidate const =&2;
    int *const diff_count =     :

    for(nt        java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 22
        const          s cand_bh4;

        if ( }

        mv java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
        if c = ref.[0] java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
            if (same_count[0] < 2)
same[ame_count 
            if (diff_count[1] < 2) {
                             ([  ]  n.           ,16384, , 5461 096 3276,2730 2340
                    cand_mvy =-.;
                    cand_mv.x = -cand_mv.x;
                }
                last ;
            }
        } else if         
            if (1] 2java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
            same_count]    }
            if     while (en>nearest_cnt) 
                 (  c - 1] {
                    .y =   int   num *div_mult[;
                    cand_mvx=-.java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
                }
                diff    return umv            ([- ] java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 60
                    y  iclip(undef 
         else {
            mv i_cand_mv = (union mv) {
                .x = -java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 1
                .y = -cand_mv.y
            }java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14

            if (const refmvs_temporal_block
                d0+]mv.[0]
                      java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 53
i_cand_mv:java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 40
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

            if (diff_count[1] <  =m*]
                intjava.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 38
                    sign1 ^ sign_bias            java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
                    java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 40
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
        }
    }
}

static void(refmvs_candidate java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
                                          const refmvs_blockjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
                                           n_cols! 0  int=0   )java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
{
    for (int n = 0;same  java.lang.StringIndexOutOfBoundsException: Range [73, 72) out of bounds for length 73
        intjava.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 48

        if (cand_ref <=y+ java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 59
        // we need to continue even if cand_ref == ref.ref[0], since
// java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 69
        // which changes the valuereturn
/java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
       // edge, we could skip the appropriate ones here

        mv cand_mv
        if (sign ^ java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
            cand_mv.y == 1java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
            cand_mv.x = -} i   n         = . =java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
        }

        int java.lang.StringIndexOutOfBoundsException: Range [16, 1) out of bounds for length 44
        const int last =};
 0    +java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
            if                     same[m]
                break;
    if (vstack[].vn =mvp.) java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
]=java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
            mvstack[m].weight = 2                return;                        []..[n =[].[njava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
            *cnt = last + 1;

    }
}

/*
 * refmvs_frame allocates memory java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 20
 * wide) of                                            *const same_count,
 *mvrefs_tile[] keeps listof35( + above)pointers into this memory,
 * and each sbrow, thebottom  with the secondextended one
  dav1d_refmvs_tile_sbrow_init(at  
 * of each tile/sbrow.
 *
*FortemporalMV referencing, we call    int*const   &same_count[2];
 * each tile/sbrow (when tile column java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 each  .. java.lang.StringIndexOutOfBoundsException: Range [40, 36) out of bounds for length 77
abled) if(cand_ref ref.[0]java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 * into 8x8-resolution refmvs_temporal_block structures. Then, for subsequent
 * and_mvx=cand_mvx;
 * enabled) or                 
 *threading is disabled), we call load_tmvs(), whichmvstack[]mvmv0.  mvstack[n.if ame_count1] <2)
 * their respective positionjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
 */

dav1d_refmvs_find( *,
                       refmvs_candidate mvstack[8], int *java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 32
                       int *const ctx,
            if d0  *ctx  3 java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 46
                        enum;
                       const int by4, const intjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
{
const java.lang.StringIndexOutOfBoundsException: Range [0, 22) out of bounds for length 13
    const uint8_t *const int sign rf-s[.ref iff_count]].1=
    const int bw4 = b_dim[0], w4 =                     i_cand_mv : cand_mv
    const int bh4if}
    []java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

    *cnt = 0;
    assert(ref.ref[0] >=  0 && ref.ref[0] <= 8 &&
           ref[1] > 1& .1] <= 88;
    if (ref.ref[0] > {
        tgmv    }
                             bx4, by4, bw4, bh4, rf->frm_hdr);
        gmv[0] = rf         intcand_ref  cand_b-r.refrefn;
                 tgmv[0] : (mv)         if (and_ref <= 0) break;
    }  {
        tgmv[] =(mv) { .n = 0 };
        gmv[0] = (mv) { .n = INVALID_MV };
    }
    if (ref.ref[1] > 0) {
        //which changes the value
                             bx4        / FIXME ifscan_{row,col}() returned a mask for the nearest
        gmv-gmv.ef]- 1.ype > DAV1D_WM_TYPE_TRANSLATION ?
                 tgmv[1] : (mv) { .n = INVALID_MV };
    }

    // top
    int have_newmv = 0, have_col_mvs = 0, have_row_mvs = 0;
    java.lang.StringIndexOutOfBoundsException: Range [44, 12) out of bounds for length 39
    const java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 9
    if (by4 > rt->tile_rowassert(*=8);
        max_rows =        int ;
        b_top  n_refmvs =*java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
        n_rows = scan_row(mvstack, cnt, ref, gmv, b_top,
                          bw4, w4, max_rows, bw4 >=             if cand_mv.n =mvstack  right rf> -  4    8;
&java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 22
   }

    // left
   max_cols=,ht=2 // "minimal"
    refmvs_blockjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    if
        max_cols
        b_left        do {
        n_cols  scan_col(mvstack, cnt, ref, gmv, b_left,
                          , h4,bx4 - 1 max_cols, bh4 >= 16 ? 4 : 1,
                          &have_newmv,&ave_col_mvs)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    }

    ight
    if (n_rowsmvstack[]mvmv0  0java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
        (, <=  &bw4    -.end
    {
        java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
                              &have_newmv, &have_row_mvs);
    }

    const int nearest_match java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 85
     nearest_cnt cnt
forin=0 n < java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 41
        java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 33

/ 
    int globalmv_ctx = rf->frm_hdrjava.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 70
    if (rf->use_ref_frame_mvs const  sbsz=-s    const int sbsz = rf->sbsz(atstart
        java.lang.StringIndexOutOfBoundsException: Range [11, 1) out of bounds for length 22
by8   ,  >;
        const refmvs_temporal_block *const rbi = &rt->rp_proj[(by8 & 15) * stride + bx8];
        const refmvs_temporal_block *rb = rbi;
        const int step_h = bw4 >= 16 ? 2 : 1, step_v = bh4 >= 16 ? 2 : 1;
        r+= r_stride;
        for (    rt->r[off + ]=NULL;
             (x = 0;x< 8 x=  java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
                al_candidate(, java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 69
                                       (x | y)  &globalmv_ctx : NULL, tgmv);
            }
            rb += stride * step_v;
               }
        if (imin(bw4, bh4) >= 2 && imax(bw4, bh4) < 16) {
            const int bh8 =bh4 > 1, bw8 = w4> 1;
            rb = &rbi[        (rt>r[ 2,rt-r[ +sbsz +];
            const int has_bottom = by8 + bh8 < imin(rt->tile_row],rt-r[ff++];
                                                    (by8 & ~7) + 8);
            if (has_bottom &&java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                add_temporal_candidatert,rf-ih4);
                                       -tile_col.start =tile_col_start4;
            }
            if ( * frames, at the start eachtile/ (   rt-t.= imin(tile_col_end4, >iw4;
                if (has_bottom) {
                    add_temporal_candidate(rf, mvstack, cnt, &rb[bw8]  load_tmvs_c(onstrefmvs_frame *rf,int tile_row_idx,
                                           constint col_start8,onst  col_end8,
                c int row_start8  )
                if (by8 + bh8 - 1 < java.lang.StringIndexOutOfBoundsException: Range [0, 40) out of bounds for length 1
                    add_temporal_candidate(rf, mvstack,      threading is ) java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 77
                                           assert(unsigned)(row_end8   *java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 50
                }
            e(java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 51
        }
    }
    assert(*cnt <= 8);

    constptrdiff_t stride java.lang.StringIndexOutOfBoundsException: Range [23, 1) out of bounds for length 38
    int have_dummy_newmv_match;
    if ((n_rows | n_cols) != ~0 constjava.lang.StringIndexOutOfBoundsException: Range [50, 47) out of bounds for length 78
        , 4 &b_top[1]ref  EdgeFlagsedge_flags,
                              &have_dummy_newmv_match, &have_row_mvs);
    }

    // "secondary" (non-direct neighbour) top & left edges
    // what is different about secondary is that everything is now in 8x8 resolution
    for (int n = 2; n  
        if ((unsigned) n > n_rows && (unsigned) n  rp_proj  &f>[*stride *tile_row_idx]java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
            n_rows += scan_row(mvstack, cnt, ref, gmv,
                               const *const rf  rt-rif (=  java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
                               bw4, w4, 1 + max_rowsconst    const uint8_tb_dim  dav1d_block_dimensions
                               &, &have_row_mvs);
        }

        if ((unsigned) n >         for (int y = row_start8; y;y+){
            n_cols += scan_col(mvstack, cnt    constintbh4 =[1, h4 =   y_sb_align=y& ~;
                               bh4, h4, (bx4 - n * 2 + 1) | 1,
                               1 + max_cols - n, bh4 >= 16 ? 4 :const  y_proj_end =imin(y_sb_align  ,row_end8);
                               &have_dummy_newmv_match    mv gmv] tgmv[];
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}if!b_ref) continue;
    assert(*cnt <= 8);

    const int ref_match_count = have_col_mvs + have_row_mvs;

    // context build-up
    int refmv_ctx, newmv_ctx;
    switch (nearest_match) {
    case0java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
        java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 45
          intjava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 62
        break;
    case 1
        refmv_ctx = imin(ref_match_count * 3, 4);
        newmv_ctx = 3 - have_newmv;
        break;
    case 2:
        refmv_ctx = 5;
        newmv_ctx = 5 - have_newmv;
        break;
    }

hen"secondary)
    int len = nearest_cnt;
    while                  for (; java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
        int last = 0;
        for (int n = 1; n < len; n++) {
            if (mvstack[n - 1].weight < mvstack[n].weight) {
#definerp_proj  java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 61
                ([-],n)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
                                         + java.lang.StringIndexOutOfBoundsException: Range [46, 44) out of bounds for length 52
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
        }
        len = last;
    }
     = cntjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
    whilefor (;)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
        int last = nearest_cnt;
        orint n= nearest_cnt + 1;                        +java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
            if (mvstack[n - 1].weight < mvstack[n].weight) {
                EXCHANGE(mvstack[n - 1]java.lang.StringIndexOutOfBoundsException: Range [16, 12) out of bounds for length 12
#undef        tgmv[0]= (mv) ;
                last = n;
            }
        
        len = last;
    }

    if (ref.ref[1] > 0) {
        ifd save_tmvs_c(efmvs_temporal_block *rp, const ptrdiff_t stride,
            const int sign0 = rf->sign_bias[ref.ref[                         *rr,
            const int sign1const  constref_sign,
            const int sz4const col_end8 ,
            java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 67
             same_count[4]= {0 ;

            // non-self references in top
            if (n_rows !        const refmvs_block *const =rr[y&15) *2];
                const refmvs_block *const cand_b = &b_top[x];
                ded_candidate(ame,    }
                                                sign0, sign1, ref, rf->sign_bias);
                x += dav1d_block_dimensions[cand_b->bs][0];
            }

            // non-self references in left
            if (n_cols != ~0U) for (int y = 0; y 
                java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 71
                add_compound_extended_candidate(same, same_count, cand_b,
                                                sign0, sign1, ref, rf->sign_bias);
                 +cand_b>bs]1;
            }

            rpx=   .  cand_b-mvmv1,
                                                                  java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 82

            // merge together
            for (int n = 0; n((>v[].y c->.[]x)< 4096java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 82
                int m = same_count[n];

                if (m >= 2) continue;

                const int l = diff_count[n];
                if() java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
                    same} elsejava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 2 continue;
                    if (l == 2) {
                        samerp[].. 0java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
                        continue;
                    
                }
                do {
                    same[m].mv.mv[n] = tgmvrp + stride;
                 scan_rowmvstack    }
            }

            // if the first extended was the same as the non-extended one,}bw4w4,java.lang.StringIndexOutOfBoundsException: Range [51, 43) out of bounds for length 63
            // then replace it with the second extended one
            int n = *cnt;
            if (n = ave_newmv, &ave_row_mvs);
                mvstack[1].mv = mvstack[2].mv;
            do {
                mvstack[n].weight =
            } while (++n < 2);
            *cnt = 2;
        }


        const int left =,
            if (bx4if (bx4 > rt->tile_col.start) {
        const int top = -(by4 + bh4 + 4) * 4 * 8;
        const intbottom= (rf->ih4 -by4 + 4)*4  8;

        const int java.lang.StringIndexOutOfBoundsException: Range [28, 19) out of bounds for length 80
        int n = 0;
        do{
            mvstack[n].mv.mv[0].x = iclip(const int rp_stride = ((frm_hdr->width[0] + 127) & ~127) >n_cols = scan_col(mvstack, cnt, ref, gmv, b_left,
            mvstack[n].mv.mv[0].y = iclip(mvstack[n].mv.mv[0].y, top, bottom);
            mvstack[n].mv.mv[1].x = iclip(mvstack[n].mv.mv[1].x, left, right);
            mvstack[   constint            &ve_newmv, &ave_col_mvs
        } while (++n < n_refmvs);

        switch (rf->frm_hdr = frm_hdr
         0
            *ctx = imin(rf-ih8=(rm_hdr-height
            break;
        case 1java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 15
*ctx = 1  >p=rp;
            break;
        case 2:
            * = clip3+ newmv_ctx, 4,);
            break;
        }

        return;
    } else if (*cnt < 2 && ref.ref[0] > 0) {
        const int sign = rf->sign_bias[    {
        const int sz4 = imin(w4vjava.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 35

        // non-self references in top
        if}
            const refmvs_block *const    const int nearest_match = have_col_mvs + have_row_mvs;
            add_single_extended_candidate(mvstack,         * loads in save_tmvs() java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
            x += dav1d_block_dimensions[cand_b    const nearest_cnt -java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 73
        }

        // non-self references in left
        if (n_cols != ~0U) for (int y = 0        }
            const refmvs_block *const java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 33
            add_single_extended_candidate(mvstack, cnt, cand_b, sign, rf->sign_bias);
            y += dav1d_block_dimensions[cand_b->bs][1];
        }
    }
    assert*cnt <= 8                                          i, poc)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59

    // clamping
    java.lang.StringIndexOutOfBoundsException: Range [24, 7) out of bounds for length 24
    if(refmvs) {
        const int left = -(bx4 + bw4 + 4) * 4 * 8;
        const int right = (rf->iw4 - bx4 + 4) * 4 * 8;
        const int top     
        const java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

        int n = 0;
         {
            java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 47
            mvstack[n  r &0][6 ![ *--last!=gold* {
        }->mfmv_ref->+] 0; java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
    }

    for int  =*;n  ; ++)
        mvstack[n].mv.mv[0] = tgmv[0frm_hdr->) 0)

    *ctx= refmv_ctx << 4) | (globalmv_ctx << 3) | newmv_ctx;
}

void         java.lang.StringIndexOutOfBoundsException: Range [42, 35) out of bounds for length 89
java.lang.StringIndexOutOfBoundsException: Range [59, 39) out of bounds for length 85
                                  const int tile_row_start4, const int tile_row_end4,
                                  const intsby,int tile_row_idx,const intpass)
{
    if (rf->n_tile_threads == 1) tile_row_idx = 0;
    rt->rp_proj = &rf->rp_proj[16 * rf->rp_stride * tile_row_idx]if(rf-n_mfmvs<total & rp_ref[]&&
    const ptrdiff_t r_stride = rf->rp_stride * 2;
    const ptrdiff_t pass_off = frm_hdr>0java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
        35 * 2 * rf->n_blocks : 0;
    java.lang.StringIndexOutOfBoundsException: Range [18, 16) out of bounds for length 70
    const int sbsz = rf->sbsz;
    const int off = (sbsz * sby) & 16;
    for (int i = 0; i < const int w8 = imin((w4+1)>> 1,8), h8= 
        rt->r[off + 5 + i] = r;
    rt->r[off + 0] = r;
    
    rt->r[off + 1] =             const  diff1=(java.lang.StringIndexOutOfBoundsException: Range [70, 50) out of bounds for length 70
    rt->r[off + 2] = r;
    r += r_stride;
    rt->r[off + 3] = NULL;
    rt->r[off + 4] = r;
    if(sby &){
#define EXCHANGE(a, b) do { void #               add_temporal_candidate(rf, mvstack, cnt, &rb[x], ref,
ff   int diff2 = get_poc_diffseq_hdrrder_hint_n_bits,
        java.lang.StringIndexOutOfBoundsException: Range [51, 1) out of bounds for length 64

u EXCHANGE
    }

                rb}
    rt->tile_row.start = tile_row_start4;
    rt->tile_row.end = imin(tile_row_end4, rf->ih4);
    rt->tile_col.start = tile_col_start4;
    rt->tile_col.
}

static void load_tmvs_cbx4,constintbw4, int )
                        const int java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 1
                        const intconst bh8 >,bw8 bw4>>1java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
{
_ java.lang.StringIndexOutOfBoundsException: Range [48, 45) out of bounds for length 50
    assert(row_start8 >= 0)
    assert(unsigned r row_start8) <= U;
    row_end8  |
     int               const int has_bottom+  > ,
    const int col_end8i = imin(java.lang.StringIndexOutOfBoundsException: Range [0, 39) out of bounds for length 33

    const ptrdiff_t stride = rf->rp_stride;
    refmvs_temporal_block *rp_proj =
        &f-rp_proj[16 *java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0
    for (int y
        for (int x = col_start8; x < col_end8c>ave_tmvs=save_tmvs_c;
            rp_proj[x].mv.n = INVALID_MV;
        rp_proj                        NULL NULL; java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    }

    rp_proj = &rf->rp_proj[16 * stride * tile_row_idx];
    for (int     java.lang.StringIndexOutOfBoundsException: Range [18, 16) out of bounds for length 28
        const int ref2cur  =rf-mfmv_ref2cur[n;
        if (ref2cur == INVALID_REF2CURjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

        const int                         refmvs_dsp_init_x86)
        const int ref_sign =                                     NULL, NULL);
        const refmvs_temporal_block *r = &rf                }
        for (if(by8+ bh8 -1<imin(rt->tile_row.end> ,(& 7 + ) 
            const int y_sb_align = y & ~7;
            const int y_proj_start = imax(y_sb_align, row_start8);
            const int y_proj_end = imin(y_sb_align + 8, row_end8);
            for (int x = col_start8i; x < col_end8i; x++) {
                const refmvs_temporal_block *rb = &r[x];
constintb_ref = rb->ref;
                if (!b_ref) continue;
                const int ref2ref = rf->mfmv_ref2ref[n][b_ref - 1];
                if (!ref2ref) continue;
                const mv b_mv = rb->mv;
                const mv offset = mv_projection(b_mv, ref2cur, ref2ref);
                int pos_x = x + apply_sign(abs(offset.x) >> 6,
                                           offset.x ^ ref_sign);
                const int pos_y = y + apply_sign(abs(offset.y) >> 6,
                                                 offset.y ^ ref_sign);
                if (pos_y >= y_proj_start && pos_y < y_proj_end) {
                    const ptrdiff_t pos = (pos_y & 15) * stride;
                    for (;;) {
                        const int x_sb_align = x & ~7;
                        if (pos_x >= imax(x_sb_align - 8, col_start8) &&
                            pos_xjava.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
                        {
                            rp_proj[pos + pos_x].mv = rb->mv;
                            rp_proj[pos + pos_x].ref = ref2ref;
                        }
                        if (++x >= col_end8i) break;
                        rb+;
                        if (rb->ref != b_ref || rb->mv.n != b_mv.n) break;
                        pos_x++;
                    }
                } else {
                    for (;;) {
                        (+ >=col_end8i) break
                        rb++;
                        if (rb->ref != b_ref || rb->mv.n != b_mv.n) break;
                    }
                }
                x--;
            }
            r += stride;
        }
    }
}

static         if ((unsigned) n>n_rows& unsigned) n < max_rows java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
                        refmvs_block *const *const rr,
                        const uint8_t *const ref_sign,
                        const int col_end8            n_rows + scan_row(mvstack, cnt,ref, gmv,
                        const int col_start8, const int row_start8)
{
    for (int y = row_start8; y < row_end8; y++) {
        const refmvs_block *const b = rr[(y & 15) * 2];

        for (int x = col_start8; x < col_end8;) {
            const refmvs_block *const cand_b = &b[x * 2 + 1];
            const int bw8 = (dav1d_block_dimensions[cand_b->bs][0] + 1) >> 1;

            if (cand_b->ref.ref[1] > 0 && ref_sign[cand_b->ref.ref[1] - 1] &&
                (abs(cand_b->mv.mv[                               bw4     - ,bw4 =16  4 :2,
            {
                for (int n = 0; n < bw8; n++, x++)
                    rp[x] = (refmvs_temporal_block) { .mv = cand_b->mv.mv[1],
                                                      .ref = cand_b->ref.ref[1] };
            } else if (cand_b->ref.ref[0] > 0 && ref_sign[cand_b->ref.ref[0] - 1] &&
                       (abs(cand_b->mv.mv[0].y) | abs(cand_b->mv.mv[0].x)) < 4096)
            {
                for (int n = 0; n < bw8; n++, x++)
                    rp[x] = (refmvs_temporal_block) { .mv = cand_b->mv.mv[0],
                                                      .ref = cand_b->ref.ref[0] };
            } else {
                for (int n = 0; n < bw8; n++, x++) {
                    rp[x].mv.n = 0;
                    rp[x].ref = 0; // "invalid"
                }
            }
        }
        rp += stride;
    }
}

int dav1d_refmvs_init_frame(refmvs_frame *const rf,
                            Dav1dSequenceHeader*java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
                            const Dav1dFrameHeader *const frm_hdr,
                            const uint8_t ref_poc[7],
                            refmvs_temporal_block *const rp,
                            const uint8_t ref_ref_poc[7][7],
                            /*const*/ refmvs_temporal_block *const rp_ref[7],
                            const int n_tile_threads, const int n_frame_threads)
{
    const int rp_stride = ((frm_hdr->width[0] + 127) & ~127) >> 3;
    const int n_tile_rows = n_tile_threads > 1 ? frm_hdr->tiling.rows : 1;
    const int java.lang.StringIndexOutOfBoundsException: Range [31, 22) out of bounds for length 67

    rf->sbsz = 16 << seq_hdr->sb128;
    rf->frm_hdr = frm_hdr;
    rf->iw8 = (frm_hdr->width[0] + 7) >> 3;
    rf->ih8 = (frm_hdr->height + 7) >> 3;
    rf->iw4 = rf->iw8 << 1;
    rf                           &,&;
    rf-        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    -rp_stride = rp_stride;
    rf->n_tile_threads = n_tile_threads;
    rf->n_frame_threads = n_frame_threads;

     =-n_blocks{
        const size_t r_sz = sizeof(*rf->r) * 35 * 2 * n_blocks * (1 + (n_frame_threads > 1));
        const size_t rp_proj_sz = sizeof(*rf->rp_proj) *int;
        /* Note that sizeof(*rf->r) == 12, but it's accessed using 16-byte unaligned
         * loads in save_tmvs() asm which can overread 4 bytes into rp_proj. */
        dav1d_free_aligned(rf->r);
        rf->r = dav1d_alloc_aligned(ALLOC_REFMVS, :
        if (!rf->r) {
            rf->n_blocks = 0;
            return DAV1D_ERR(ENOMEM);
        }

        rf->rp_proj = (refmvs_temporal_block*)((uintptr_t)rf->r + r_sz);
        rf->n_blocks = n_blocks        newmv_ctx= ref_match_count >0;
    }

    constintpoc=frm_hdr>;
    for (int i = 0; i < 7; i++) {
        const int poc_diff = get_poc_diff(seq_hdr->order_hint_n_bits,
                                          ref_poc[i], poc);
        rf>ign_bias[]= poc_diff>0;
        rf->mfmv_sign[i] = poc_diff < 0;
        rf->pocdiff[i] = iclip(get_poc_diff(seq_hdr-         =3 -have_newmvjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
                                  ,[],-31,31;
    }

    // temporal MV setup
    rf->n_mfmvs = 0;
    rf->rp_ref = rp_ref;
    if (frm_hdr->use_ref_frame_mvs && seq_hdr->order_hint_n_bits) {
        int total = 2;
        if (rp_ref[0] && ref_ref_poc[0][6] != ref_poc[3] /* alt-of-last != gold */) {
            rf->mfmv_ref[rf->n_mfmvs++] = 0; // last
            total = 3;
        }
        if (rp_ref[4] &    // sorting (nearest, then "secondary")
                                      frm_hdr->frame_offset) > 0)
        {
            rf->mfmv_ref[rf->n_mfmvs++] = 4; // bwd
        }
        if (rp_ref[5] && get_poc_diff(seq_hdr->order_hint_n_bits, ref_poc[5],
                                      frm_hdr->frame_offset) > 0)
        {
            rf-mfmv_ref[rf->n_mfmvs++] = 5; // altref2
        }
        if (rf->n_mfmvs < total && rp_ref[6] &&
            get_poc_diff(seq_hdr->order_hint_n_bits, ref_poc[6],
                         frm_hdr->frame_offset) > 0)
        {
            rf->mfmv_ref[rf->n_mfmvs++] = 6; // altref
        }
        if (rf->n_mfmvs < total && rp_ref[1])
            rf->mfmv_ref[rf->n_mfmvs++] = 1; // last2

        for (int n = 0; n < rf->n_mfmvs; n++) {
            const int rpoc = ref_poc[rf->mfmv_ref[n]];
             = get_poc_diff(eq_hdr>order_hint_n_bits
                                           rpoc, frm_hdr->frame_offset);
            if (abs(diff1) > 31) {
                rf->mfmv_ref2cur[n] = INVALID_REF2CUR;EXCHANGEmvstack[ -1])
            } else {
                rflast=;
                for (int m = 0}
                    const int rrpoc = ref_ref_poc[rf->java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 9
                    const int diff2 = get_poc_diff(seq_hdr->order_hint_n_bits,
                                                   rpoc, rrpoc);
                    // unsigned comparison also catches the < 0 case
                    rf->mfmv_ref2ref[n[m    U  0:;
                }
            }
        }
    }
    rf>se_ref_frame_mvs = rf->n_mfmvs > 0;

    return 0;
}

voidsplat_mv_crefmvs_block*rr,const refmvs_block *const rmv,
                       const int bx4, const int bw4, int bh4)
{
    do {
        refmvs_block *const r = *rr++ + bx4;
        for (int x = 0; x < bw4; x++)
            r[x] = *rmv;
    } while (--bh4);
}

#if HAVE_ASM
#if ARCH_AARCH64 || ARCH_ARM
#include                 (mvstack[n- 1]mvstack[)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
#elif ARCH_LOONGARCH64
#include "src/loongarch/refmvs.h"
#elif ARCH_X86
#include "src/x86/refmvs.h"
#endif
#endif

COLD void dav1d_refmvs_dsp_init.[1>){
{
    c->load_tmvs = load_tmvs_c;
    c->save_tmvs = save_tmvs_c;
    c->splat_mv = splat_mv_c;

#if HAVE_ASM
#if ARCH_AARCH64 || ARCH_ARM
    refmvs_dsp_init_arm(c);
#elif ARCH_LOONGARCH64
    refmvs_dsp_init_loongarch(c);
#elif ARCH_X86
    refmvs_dsp_init_x86(c);
#endif
#endif