granicus.if.org Git - libvpx/blob - vp8/encoder/arm/armv5te/vp8_packtokens_partitions_armv5.asm

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