dkboolreader.h 5.04 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14
/*
 * Copyright (c) 2016, Alliance for Open Media. All rights reserved
 *
 * This source code is subject to the terms of the BSD 2 Clause License and
 * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
 * was not distributed with this source code in the LICENSE file, you can
 * obtain it at www.aomedia.org/license/software. If the Alliance for Open
 * Media Patent License 1.0 was not distributed with this source code in the
 * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
 */

#ifndef AOM_DSP_DKBOOLREADER_H_
#define AOM_DSP_DKBOOLREADER_H_

15
#include <assert.h>
16 17 18 19 20 21 22
#include <stddef.h>
#include <limits.h>

#include "./aom_config.h"
#if CONFIG_BITSTREAM_DEBUG
#include <assert.h>
#include <stdio.h>
23
#include "aom_util/debug_util.h"
24 25 26 27 28 29
#endif  // CONFIG_BITSTREAM_DEBUG

#include "aom_ports/mem.h"
#include "aom/aomdx.h"
#include "aom/aom_integer.h"
#include "aom_dsp/prob.h"
Michael Bebenita's avatar
Michael Bebenita committed
30
#if CONFIG_ACCOUNTING
31
#include "av1/decoder/accounting.h"
Michael Bebenita's avatar
Michael Bebenita committed
32
#endif
33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51

#ifdef __cplusplus
extern "C" {
#endif

typedef size_t BD_VALUE;

#define BD_VALUE_SIZE ((int)sizeof(BD_VALUE) * CHAR_BIT)

// This is meant to be a large, positive constant that can still be efficiently
// loaded as an immediate (on platforms like ARM, for example).
// Even relatively modest values like 100 would work fine.
#define LOTS_OF_BITS 0x40000000

struct aom_dk_reader {
  // Be careful when reordering this struct, it may impact the cache negatively.
  BD_VALUE value;
  unsigned int range;
  int count;
52
  const uint8_t *buffer_start;
53 54 55 56 57
  const uint8_t *buffer_end;
  const uint8_t *buffer;
  aom_decrypt_cb decrypt_cb;
  void *decrypt_state;
  uint8_t clear_buffer[sizeof(BD_VALUE) + 1];
Michael Bebenita's avatar
Michael Bebenita committed
58 59 60
#if CONFIG_ACCOUNTING
  Accounting *accounting;
#endif
61 62 63 64 65 66 67 68 69 70
};

int aom_dk_reader_init(struct aom_dk_reader *r, const uint8_t *buffer,
                       size_t size, aom_decrypt_cb decrypt_cb,
                       void *decrypt_state);

void aom_dk_reader_fill(struct aom_dk_reader *r);

const uint8_t *aom_dk_reader_find_end(struct aom_dk_reader *r);

71
static INLINE uint32_t aom_dk_reader_tell(const struct aom_dk_reader *r) {
Yaowu Xu's avatar
Yaowu Xu committed
72 73
  const uint32_t bits_read =
      (uint32_t)((r->buffer - r->buffer_start) * CHAR_BIT);
74 75
  const int count =
      (r->count < LOTS_OF_BITS) ? r->count : r->count - LOTS_OF_BITS;
76
  assert(r->buffer >= r->buffer_start);
77 78 79 80 81 82 83
  return bits_read - (count + CHAR_BIT);
}

/*The resolution of fractional-precision bit usage measurements, i.e.,
   3 => 1/8th bits.*/
#define DK_BITRES (3)

84
static INLINE uint32_t aom_dk_reader_tell_frac(const struct aom_dk_reader *r) {
85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
  uint32_t num_bits;
  uint32_t range;
  int l;
  int i;
  num_bits = aom_dk_reader_tell(r) << DK_BITRES;
  range = r->range;
  l = 0;
  for (i = DK_BITRES; i-- > 0;) {
    int b;
    range = range * range >> 7;
    b = (int)(range >> 8);
    l = l << 1 | b;
    range >>= b;
  }
  return num_bits - l;
100 101
}

102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181
static INLINE int aom_dk_reader_has_error(struct aom_dk_reader *r) {
  // Check if we have reached the end of the buffer.
  //
  // Variable 'count' stores the number of bits in the 'value' buffer, minus
  // 8. The top byte is part of the algorithm, and the remainder is buffered
  // to be shifted into it. So if count == 8, the top 16 bits of 'value' are
  // occupied, 8 for the algorithm and 8 in the buffer.
  //
  // When reading a byte from the user's buffer, count is filled with 8 and
  // one byte is filled into the value buffer. When we reach the end of the
  // data, count is additionally filled with LOTS_OF_BITS. So when
  // count == LOTS_OF_BITS - 1, the user's data has been exhausted.
  //
  // 1 if we have tried to decode bits after the end of stream was encountered.
  // 0 No error.
  return r->count > BD_VALUE_SIZE && r->count < LOTS_OF_BITS;
}

static INLINE int aom_dk_read(struct aom_dk_reader *r, int prob) {
  unsigned int bit = 0;
  BD_VALUE value;
  BD_VALUE bigsplit;
  int count;
  unsigned int range;
  unsigned int split = (r->range * prob + (256 - prob)) >> CHAR_BIT;

  if (r->count < 0) aom_dk_reader_fill(r);

  value = r->value;
  count = r->count;

  bigsplit = (BD_VALUE)split << (BD_VALUE_SIZE - CHAR_BIT);

  range = split;

  if (value >= bigsplit) {
    range = r->range - split;
    value = value - bigsplit;
    bit = 1;
  }

  {
    register int shift = aom_norm[range];
    range <<= shift;
    value <<= shift;
    count -= shift;
  }
  r->value = value;
  r->count = count;
  r->range = range;

#if CONFIG_BITSTREAM_DEBUG
  {
    int ref_bit, ref_prob;
    const int queue_r = bitstream_queue_get_read();
    const int frame_idx = bitstream_queue_get_frame_read();
    bitstream_queue_pop(&ref_bit, &ref_prob);
    if (prob != ref_prob) {
      fprintf(
          stderr,
          "\n *** prob error, frame_idx_r %d prob %d ref_prob %d queue_r %d\n",
          frame_idx, prob, ref_prob, queue_r);
      assert(0);
    }
    if ((int)bit != ref_bit) {
      fprintf(stderr, "\n *** bit error, frame_idx_r %d bit %d ref_bit %d\n",
              frame_idx, bit, ref_bit);
      assert(0);
    }
  }
#endif  // CONFIG_BITSTREAM_DEBUG

  return bit;
}

#ifdef __cplusplus
}  // extern "C"
#endif

#endif  // AOM_DSP_DKBOOLREADER_H_