vp8/encoder/arm/neon/vp8_packtokens_partitions_armv7.asm

   1 ;
   2 ;  Copyright (c) 2010 The VP8 project authors. All Rights Reserved.
   3 ;
   4 ;  Use of this source code is governed by a BSD-style license and patent
   5 ;  grant that can be found in the LICENSE file in the root of the source
   6 ;  tree. All contributing project authors may be found in the AUTHORS
   7 ;  file in the root of the source tree.
   8 ;
   9
  10
  11     EXPORT |vp8cx_pack_tokens_into_partitions_armv7|
  12
  13     INCLUDE vpx_vp8_enc_asm_offsets.asm
  14
  15     ARM
  16     REQUIRE8
  17     PRESERVE8
  18
  19     AREA    |.text|, CODE, READONLY
  20
  21 ; r0 VP8_COMP *cpi
  22 ; r1 unsigned char *cx_data
  23 ; r2 int num_part
  24 ; r3 *size
  25 ; s0 vp8_coef_encodings
  26 ; s1 vp8_extra_bits,
  27 ; s2 const vp8_tree_index *,
  28
  29 |vp8cx_pack_tokens_into_partitions_armv7| PROC
  30     push    {r4-r11, lr}
  31     sub     sp, sp, #44
  32
  33     ; Compute address of cpi->common.mb_rows
  34     ldr     r4, _VP8_COMP_common_
  35     ldr     r6, _VP8_COMMON_MBrows_
  36     add     r4, r0, r4
  37
  38     ldr     r5, [r4, r6]                ; load up mb_rows
  39
  40     str     r5, [sp, #36]               ; save mb_rows
  41     str     r1, [sp, #24]               ; save cx_data
  42     str     r2, [sp, #20]               ; save num_part
  43     str     r3, [sp, #8]                ; save *size
  44
  45     ; *size = 3*(num_part -1 );
  46     sub     r2, r2, #1                  ; num_part - 1
  47     add     r2, r2, r2, lsl #1          ; 3*(num_part - 1)
  48     str     r2, [r3]
  49
  50     add     r2, r2, r1                  ; cx_data + *size
  51     str     r2, [sp, #40]               ; ptr
  52
  53     ldr     r4, _VP8_COMP_tplist_
  54     add     r4, r0, r4
  55     ldr     r7, [r4, #0]                ; dereference cpi->tp_list
  56     str     r7, [sp, #32]               ; store start of cpi->tp_list
  57
  58     ldr     r11, _VP8_COMP_bc2_         ; load up vp8_writer out of cpi
  59     add     r0, r0, r11
  60
  61     mov     r11, #0
  62     str     r11, [sp, #28]              ; i
  63
  64 numparts_loop
  65     ldr     r10, [sp, #40]              ; ptr
  66     ldr     r5,  [sp, #36]              ; move mb_rows to the counting section
  67     str     r5,  [sp, #12]
  68
  69     ; Reset all of the VP8 Writer data for each partition that
  70     ; is processed.
  71     ; start_encode
  72     mov     r2, #0                      ; vp8_writer_lowvalue
  73     mov     r5, #255                    ; vp8_writer_range
  74     mvn     r3, #23                     ; vp8_writer_count
  75
  76     str     r2,  [r0, #vp8_writer_value]
  77     str     r2,  [r0, #vp8_writer_pos]
  78     str     r10, [r0, #vp8_writer_buffer]
  79
  80 mb_row_loop
  81
  82     ldr     r1, [r7, #tokenlist_start]
  83     ldr     r9, [r7, #tokenlist_stop]
  84     str     r9, [sp, #0]                ; save stop for later comparison
  85     str     r7, [sp, #16]               ; tokenlist address for next time
  86
  87     b       check_p_lt_stop
  88
  89     ; actual work gets done here!
  90
  91 while_p_lt_stop
  92     ldr     r6, [r1, #tokenextra_token] ; t
  93     ldr     r4, [sp, #80]               ; vp8_coef_encodings
  94     mov     lr, #0
  95     add     r4, r4, r6, lsl #3          ; a = vp8_coef_encodings + t
  96     ldr     r9, [r1, #tokenextra_context_tree]   ; pp
  97
  98     ldr     r7, [r1, #tokenextra_skip_eob_node]
  99
 100     ldr     r6, [r4, #vp8_token_value]  ; v
 101     ldr     r8, [r4, #vp8_token_len]    ; n
 102
 103     ; vp8 specific skip_eob_node
 104     cmp     r7, #0
 105     movne   lr, #2                      ; i = 2
 106     subne   r8, r8, #1                  ; --n
 107
 108     ; reverse the stream of bits to be packed.  Normally
 109     ; the most significant bit is peeled off and compared
 110     ; in the form of (v >> --n) & 1.  ARM architecture has
 111     ; the ability to set a flag based on the value of the
 112     ; bit shifted off the bottom of the register.  To make
 113     ; that happen the bitstream is reversed.
 114     rbit    r12, r6
 115     rsb     r4, r8, #32                 ; 32-n
 116     ldr     r10, [sp, #88]              ; vp8_coef_tree
 117
 118     ; v is kept in r12 during the token pack loop
 119     lsr     r12, r12, r4                ; v >>= 32 - n
 120
 121 ; loop start
 122 token_loop
 123     ldrb    r4, [r9, lr, asr #1]        ; pp [i>>1]
 124     sub     r7, r5, #1                  ; range-1
 125
 126     ; Decisions are made based on the bit value shifted
 127     ; off of v, so set a flag here based on this.
 128     ; This value is refered to as "bb"
 129     lsrs    r12, r12, #1                ; bb = v >> n
 130     mul     r4, r4, r7                  ; ((range-1) * pp[i>>1]))
 131
 132     ; bb can only be 0 or 1.  So only execute this statement
 133     ; if bb == 1, otherwise it will act like i + 0
 134     addcs   lr, lr, #1                  ; i + bb
 135
 136     mov     r7, #1
 137     ldrsb   lr, [r10, lr]               ; i = vp8_coef_tree[i+bb]
 138     add     r4, r7, r4, lsr #8          ; 1 + (((range-1) * pp[i>>1]) >> 8)
 139
 140     addcs   r2, r2, r4                  ; if  (bb) lowvalue += split
 141     subcs   r4, r5, r4                  ; if  (bb) range = range-split
 142
 143     ; Counting the leading zeros is used to normalize range.
 144     clz     r6, r4
 145     sub     r6, r6, #24                 ; shift
 146
 147     ; Flag is set on the sum of count.  This flag is used later
 148     ; to determine if count >= 0
 149     adds    r3, r3, r6                  ; count += shift
 150     lsl     r5, r4, r6                  ; range <<= shift
 151     bmi     token_count_lt_zero         ; if(count >= 0)
 152
 153     sub     r6, r6, r3                  ; offset = shift - count
 154     sub     r4, r6, #1                  ; offset-1
 155     lsls    r4, r2, r4                  ; if((lowvalue<<(offset-1)) & 0x80000000 )
 156     bpl     token_high_bit_not_set
 157
 158     ldr     r4, [r0, #vp8_writer_pos]   ; x
 159     sub     r4, r4, #1                  ; x = w->pos-1
 160     b       token_zero_while_start
 161 token_zero_while_loop
 162     mov     r10, #0
 163     strb    r10, [r7, r4]               ; w->buffer[x] =(unsigned char)0
 164     sub     r4, r4, #1                  ; x--
 165 token_zero_while_start
 166     cmp     r4, #0
 167     ldrge   r7, [r0, #vp8_writer_buffer]
 168     ldrb    r11, [r7, r4]
 169     cmpge   r11, #0xff
 170     beq     token_zero_while_loop
 171
 172     ldr     r7, [r0, #vp8_writer_buffer]
 173     ldrb    r10, [r7, r4]               ; w->buffer[x]
 174     add     r10, r10, #1
 175     strb    r10, [r7, r4]               ; w->buffer[x] + 1
 176 token_high_bit_not_set
 177     rsb     r4, r6, #24                 ; 24-offset
 178     ldr     r10, [r0, #vp8_writer_buffer]
 179     lsr     r7, r2, r4                  ; lowvalue >> (24-offset)
 180     ldr     r4, [r0, #vp8_writer_pos]   ; w->pos
 181     lsl     r2, r2, r6                  ; lowvalue <<= offset
 182     mov     r6, r3                      ; shift = count
 183     add     r11, r4, #1                 ; w->pos++
 184     bic     r2, r2, #0xff000000         ; lowvalue &= 0xffffff
 185     str     r11, [r0, #vp8_writer_pos]
 186     sub     r3, r3, #8                  ; count -= 8
 187     strb    r7, [r10, r4]               ; w->buffer[w->pos++]
 188
 189     ; r10 is used earlier in the loop, but r10 is used as
 190     ; temp variable here.  So after r10 is used, reload
 191     ; vp8_coef_tree_dcd into r10
 192     ldr     r10, [sp, #88]              ; vp8_coef_tree
 193
 194 token_count_lt_zero
 195     lsl     r2, r2, r6                  ; lowvalue <<= shift
 196
 197     subs    r8, r8, #1                  ; --n
 198     bne     token_loop
 199
 200     ldr     r6, [r1, #tokenextra_token] ; t
 201     ldr     r7, [sp, #84]                ; vp8_extra_bits
 202     ; Add t * sizeof (vp8_extra_bit_struct) to get the desired
 203     ;  element.  Here vp8_extra_bit_struct == 20
 204     add     r6, r6, r6, lsl #2          ; b = vp8_extra_bits + t
 205     add     r12, r7, r6, lsl #2         ; b = vp8_extra_bits + t
 206
 207     ldr     r4, [r12, #vp8_extra_bit_struct_base_val]
 208     cmp     r4, #0
 209     beq     skip_extra_bits
 210
 211 ;   if( b->base_val)
 212     ldr     r8, [r12, #vp8_extra_bit_struct_len] ; L
 213     ldr     lr, [r1, #tokenextra_extra] ; e = p->Extra
 214     cmp     r8, #0                      ; if( L)
 215     beq     no_extra_bits
 216
 217     ldr     r9, [r12, #vp8_extra_bit_struct_prob]
 218     asr     r7, lr, #1                  ; v=e>>1
 219
 220     ldr     r10, [r12, #vp8_extra_bit_struct_tree]
 221     str     r10, [sp, #4]               ; b->tree
 222
 223     rbit    r12, r7                     ; reverse v
 224     rsb     r4, r8, #32
 225     lsr     r12, r12, r4
 226
 227     mov     lr, #0                      ; i = 0
 228
 229 extra_bits_loop
 230     ldrb    r4, [r9, lr, asr #1]        ; pp[i>>1]
 231     sub     r7, r5, #1                  ; range-1
 232     lsrs    r12, r12, #1                ; v >> n
 233     mul     r4, r4, r7                  ; (range-1) * pp[i>>1]
 234     addcs   lr, lr, #1                  ; i + bb
 235
 236     mov     r7, #1
 237     ldrsb   lr, [r10, lr]               ; i = b->tree[i+bb]
 238     add     r4, r7, r4, lsr #8          ; split = 1 +  (((range-1) * pp[i>>1]) >> 8)
 239
 240     addcs   r2, r2, r4                  ; if  (bb) lowvalue += split
 241     subcs   r4, r5, r4                  ; if  (bb) range = range-split
 242
 243     clz     r6, r4
 244     sub     r6, r6, #24
 245
 246     adds    r3, r3, r6                  ; count += shift
 247     lsl     r5, r4, r6                  ; range <<= shift
 248     bmi     extra_count_lt_zero         ; if(count >= 0)
 249
 250     sub     r6, r6, r3                  ; offset= shift - count
 251     sub     r4, r6, #1                  ; offset-1
 252     lsls    r4, r2, r4                  ; if((lowvalue<<(offset-1)) & 0x80000000 )
 253     bpl     extra_high_bit_not_set
 254
 255     ldr     r4, [r0, #vp8_writer_pos]   ; x
 256     sub     r4, r4, #1                  ; x = w->pos - 1
 257     b       extra_zero_while_start
 258 extra_zero_while_loop
 259     mov     r10, #0
 260     strb    r10, [r7, r4]               ; w->buffer[x] =(unsigned char)0
 261     sub     r4, r4, #1                  ; x--
 262 extra_zero_while_start
 263     cmp     r4, #0
 264     ldrge   r7, [r0, #vp8_writer_buffer]
 265     ldrb    r11, [r7, r4]
 266     cmpge   r11, #0xff
 267     beq     extra_zero_while_loop
 268
 269     ldr     r7, [r0, #vp8_writer_buffer]
 270     ldrb    r10, [r7, r4]
 271     add     r10, r10, #1
 272     strb    r10, [r7, r4]
 273 extra_high_bit_not_set
 274     rsb     r4, r6, #24                 ; 24-offset
 275     ldr     r10, [r0, #vp8_writer_buffer]
 276     lsr     r7, r2, r4                  ; lowvalue >> (24-offset)
 277     ldr     r4, [r0, #vp8_writer_pos]
 278     lsl     r2, r2, r6                  ; lowvalue <<= offset
 279     mov     r6, r3                      ; shift = count
 280     add     r11, r4, #1                 ; w->pos++
 281     bic     r2, r2, #0xff000000         ; lowvalue &= 0xffffff
 282     str     r11, [r0, #vp8_writer_pos]
 283     sub     r3, r3, #8                  ; count -= 8
 284     strb    r7, [r10, r4]               ; w->buffer[w->pos++]=(lowvalue >> (24-offset))
 285     ldr     r10, [sp, #4]               ; b->tree
 286 extra_count_lt_zero
 287     lsl     r2, r2, r6
 288
 289     subs    r8, r8, #1                  ; --n
 290     bne     extra_bits_loop             ; while (n)
 291
 292 no_extra_bits
 293     ldr     lr, [r1, #4]                ; e = p->Extra
 294     add     r4, r5, #1                  ; range + 1
 295     tst     lr, #1
 296     lsr     r4, r4, #1                  ; split = (range + 1) >> 1
 297     addne   r2, r2, r4                  ; lowvalue += split
 298     subne   r4, r5, r4                  ; range = range-split
 299     tst     r2, #0x80000000             ; lowvalue & 0x80000000
 300     lsl     r5, r4, #1                  ; range <<= 1
 301     beq     end_high_bit_not_set
 302
 303     ldr     r4, [r0, #vp8_writer_pos]
 304     mov     r7, #0
 305     sub     r4, r4, #1
 306     b       end_zero_while_start
 307 end_zero_while_loop
 308     strb    r7, [r6, r4]
 309     sub     r4, r4, #1                  ; x--
 310 end_zero_while_start
 311     cmp     r4, #0
 312     ldrge   r6, [r0, #vp8_writer_buffer]
 313     ldrb    r12, [r6, r4]
 314     cmpge   r12, #0xff
 315     beq     end_zero_while_loop
 316
 317     ldr     r6, [r0, #vp8_writer_buffer]
 318     ldrb    r7, [r6, r4]
 319     add     r7, r7, #1
 320     strb    r7, [r6, r4]
 321 end_high_bit_not_set
 322     adds    r3, r3, #1                  ; ++count
 323     lsl     r2, r2, #1                  ; lowvalue  <<= 1
 324     bne     end_count_zero
 325
 326     ldr     r4, [r0, #vp8_writer_pos]
 327     mvn     r3, #7
 328     ldr     r7, [r0, #vp8_writer_buffer]
 329     lsr     r6, r2, #24                 ; lowvalue >> 24
 330     add     r12, r4, #1                 ; w->pos++
 331     bic     r2, r2, #0xff000000         ; lowvalue &= 0xffffff
 332     str     r12, [r0, #0x10]
 333     strb    r6, [r7, r4]
 334 end_count_zero
 335 skip_extra_bits
 336     add     r1, r1, #TOKENEXTRA_SZ      ; ++p
 337 check_p_lt_stop
 338     ldr     r4, [sp, #0]                ; stop
 339     cmp     r1, r4                      ; while( p < stop)
 340     bcc     while_p_lt_stop
 341
 342     ldr     r10, [sp, #20]              ; num_parts
 343     mov     r1, #TOKENLIST_SZ
 344     mul     r1, r10, r1
 345
 346     ldr     r6, [sp, #12]               ; mb_rows
 347     ldr     r7, [sp, #16]               ; tokenlist address
 348     subs    r6, r6, r10
 349     add     r7, r7, r1                  ; next element in the array
 350     str     r6, [sp, #12]
 351     bgt     mb_row_loop
 352
 353     mov     r12, #32
 354
 355 stop_encode_loop
 356     sub     r7, r5, #1                  ; range-1
 357
 358     mov     r4, r7, lsl #7              ; ((range-1) * 128)
 359
 360     mov     r7, #1
 361     add     r4, r7, r4, lsr #8          ; 1 + (((range-1) * 128) >> 8)
 362
 363     ; Counting the leading zeros is used to normalize range.
 364     clz     r6, r4
 365     sub     r6, r6, #24                 ; shift
 366
 367     ; Flag is set on the sum of count.  This flag is used later
 368     ; to determine if count >= 0
 369     adds    r3, r3, r6                  ; count += shift
 370     lsl     r5, r4, r6                  ; range <<= shift
 371     bmi     token_count_lt_zero_se      ; if(count >= 0)
 372
 373     sub     r6, r6, r3                  ; offset = shift - count
 374     sub     r4, r6, #1                  ; offset-1
 375     lsls    r4, r2, r4                  ; if((lowvalue<<(offset-1)) & 0x80000000 )
 376     bpl     token_high_bit_not_set_se
 377
 378     ldr     r4, [r0, #vp8_writer_pos]   ; x
 379     sub     r4, r4, #1                  ; x = w->pos-1
 380     b       token_zero_while_start_se
 381 token_zero_while_loop_se
 382     mov     r10, #0
 383     strb    r10, [r7, r4]               ; w->buffer[x] =(unsigned char)0
 384     sub     r4, r4, #1                  ; x--
 385 token_zero_while_start_se
 386     cmp     r4, #0
 387     ldrge   r7, [r0, #vp8_writer_buffer]
 388     ldrb    r11, [r7, r4]
 389     cmpge   r11, #0xff
 390     beq     token_zero_while_loop_se
 391
 392     ldr     r7, [r0, #vp8_writer_buffer]
 393     ldrb    r10, [r7, r4]               ; w->buffer[x]
 394     add     r10, r10, #1
 395     strb    r10, [r7, r4]               ; w->buffer[x] + 1
 396 token_high_bit_not_set_se
 397     rsb     r4, r6, #24                 ; 24-offset
 398     ldr     r10, [r0, #vp8_writer_buffer]
 399     lsr     r7, r2, r4                  ; lowvalue >> (24-offset)
 400     ldr     r4, [r0, #vp8_writer_pos]   ; w->pos
 401     lsl     r2, r2, r6                  ; lowvalue <<= offset
 402     mov     r6, r3                      ; shift = count
 403     add     r11, r4, #1                 ; w->pos++
 404     bic     r2, r2, #0xff000000         ; lowvalue &= 0xffffff
 405     str     r11, [r0, #vp8_writer_pos]
 406     sub     r3, r3, #8                  ; count -= 8
 407     strb    r7, [r10, r4]               ; w->buffer[w->pos++]
 408
 409 token_count_lt_zero_se
 410     lsl     r2, r2, r6                  ; lowvalue <<= shift
 411
 412     subs    r12, r12, #1
 413     bne     stop_encode_loop
 414
 415     ldr     r10, [sp, #8]               ; *size
 416     ldr     r11, [r10]
 417     ldr     r4,  [r0, #vp8_writer_pos]  ; w->pos
 418     add     r11, r11, r4                ; *size += w->pos
 419     str     r11, [r10]
 420
 421     ldr     r9, [sp, #20]               ; num_parts
 422     sub     r9, r9, #1
 423     ldr     r10, [sp, #28]              ; i
 424     cmp     r10, r9                     ; if(i<(num_part - 1))
 425     bge     skip_write_partition
 426
 427     ldr     r12, [sp, #40]              ; ptr
 428     add     r12, r12, r4                ; ptr += w->pos
 429     str     r12, [sp, #40]
 430
 431     ldr     r9, [sp, #24]               ; cx_data
 432     mov     r8, r4, asr #8
 433     strb    r4, [r9, #0]
 434     strb    r8, [r9, #1]
 435     mov     r4, r4, asr #16
 436     strb    r4, [r9, #2]
 437
 438     add     r9, r9, #3                  ; cx_data += 3
 439     str     r9, [sp, #24]
 440
 441 skip_write_partition
 442
 443     ldr     r11, [sp, #28]              ; i
 444     ldr     r10, [sp, #20]              ; num_parts
 445
 446     add     r11, r11, #1                ; i++
 447     str     r11, [sp, #28]
 448
 449     ldr     r7, [sp, #32]               ; cpi->tp_list[i]
 450     mov     r1, #TOKENLIST_SZ
 451     add     r7, r7, r1                  ; next element in cpi->tp_list
 452     str     r7, [sp, #32]               ; cpi->tp_list[i+1]
 453
 454     cmp     r10, r11
 455     bgt     numparts_loop
 456
 457
 458     add     sp, sp, #44
 459     pop     {r4-r11, pc}
 460     ENDP
 461
 462 _VP8_COMP_common_
 463     DCD     vp8_comp_common
 464 _VP8_COMMON_MBrows_
 465     DCD     vp8_common_mb_rows
 466 _VP8_COMP_tplist_
 467     DCD     vp8_comp_tplist
 468 _VP8_COMP_bc2_
 469     DCD     vp8_comp_bc2
 470
 471     END