Line data    Source code

       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             : #include <stdlib.h>
      11             : 
      12             : #include "./vpx_config.h"
      13             : 
      14             : #include "vpx_dsp/bitreader.h"
      15             : #include "vpx_dsp/prob.h"
      16             : #include "vpx_dsp/vpx_dsp_common.h"
      17             : #include "vpx_ports/mem.h"
      18             : #include "vpx_mem/vpx_mem.h"
      19             : #include "vpx_util/endian_inl.h"
      20             : 
      21           0 : int vpx_reader_init(vpx_reader *r, const uint8_t *buffer, size_t size,
      22             :                     vpx_decrypt_cb decrypt_cb, void *decrypt_state) {
      23           0 :   if (size && !buffer) {
      24           0 :     return 1;
      25             :   } else {
      26           0 :     r->buffer_end = buffer + size;
      27           0 :     r->buffer = buffer;
      28           0 :     r->value = 0;
      29           0 :     r->count = -8;
      30           0 :     r->range = 255;
      31           0 :     r->decrypt_cb = decrypt_cb;
      32           0 :     r->decrypt_state = decrypt_state;
      33           0 :     vpx_reader_fill(r);
      34           0 :     return vpx_read_bit(r) != 0;  // marker bit
      35             :   }
      36             : }
      37             : 
      38           0 : void vpx_reader_fill(vpx_reader *r) {
      39           0 :   const uint8_t *const buffer_end = r->buffer_end;
      40           0 :   const uint8_t *buffer = r->buffer;
      41           0 :   const uint8_t *buffer_start = buffer;
      42           0 :   BD_VALUE value = r->value;
      43           0 :   int count = r->count;
      44           0 :   const size_t bytes_left = buffer_end - buffer;
      45           0 :   const size_t bits_left = bytes_left * CHAR_BIT;
      46           0 :   int shift = BD_VALUE_SIZE - CHAR_BIT - (count + CHAR_BIT);
      47             : 
      48           0 :   if (r->decrypt_cb) {
      49           0 :     size_t n = VPXMIN(sizeof(r->clear_buffer), bytes_left);
      50           0 :     r->decrypt_cb(r->decrypt_state, buffer, r->clear_buffer, (int)n);
      51           0 :     buffer = r->clear_buffer;
      52           0 :     buffer_start = r->clear_buffer;
      53             :   }
      54           0 :   if (bits_left > BD_VALUE_SIZE) {
      55           0 :     const int bits = (shift & 0xfffffff8) + CHAR_BIT;
      56             :     BD_VALUE nv;
      57             :     BD_VALUE big_endian_values;
      58           0 :     memcpy(&big_endian_values, buffer, sizeof(BD_VALUE));
      59             : #if SIZE_MAX == 0xffffffffffffffffULL
      60           0 :     big_endian_values = HToBE64(big_endian_values);
      61             : #else
      62             :     big_endian_values = HToBE32(big_endian_values);
      63             : #endif
      64           0 :     nv = big_endian_values >> (BD_VALUE_SIZE - bits);
      65           0 :     count += bits;
      66           0 :     buffer += (bits >> 3);
      67           0 :     value = r->value | (nv << (shift & 0x7));
      68             :   } else {
      69           0 :     const int bits_over = (int)(shift + CHAR_BIT - (int)bits_left);
      70           0 :     int loop_end = 0;
      71           0 :     if (bits_over >= 0) {
      72           0 :       count += LOTS_OF_BITS;
      73           0 :       loop_end = bits_over;
      74             :     }
      75             : 
      76           0 :     if (bits_over < 0 || bits_left) {
      77           0 :       while (shift >= loop_end) {
      78           0 :         count += CHAR_BIT;
      79           0 :         value |= (BD_VALUE)*buffer++ << shift;
      80           0 :         shift -= CHAR_BIT;
      81             :       }
      82             :     }
      83             :   }
      84             : 
      85             :   // NOTE: Variable 'buffer' may not relate to 'r->buffer' after decryption,
      86             :   // so we increase 'r->buffer' by the amount that 'buffer' moved, rather than
      87             :   // assign 'buffer' to 'r->buffer'.
      88           0 :   r->buffer += buffer - buffer_start;
      89           0 :   r->value = value;
      90           0 :   r->count = count;
      91           0 : }
      92             : 
      93           0 : const uint8_t *vpx_reader_find_end(vpx_reader *r) {
      94             :   // Find the end of the coded buffer
      95           0 :   while (r->count > CHAR_BIT && r->count < BD_VALUE_SIZE) {
      96           0 :     r->count -= CHAR_BIT;
      97           0 :     r->buffer--;
      98             :   }
      99           0 :   return r->buffer;
     100             : }