/*

 *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.

 *

 *  Use of this source code is governed by a BSD-style license

 *  that can be found in the LICENSE file in the root of the source

 *  tree. An additional intellectual property rights grant can be found

 *  in the file PATENTS.  All contributing project authors may

 *  be found in the AUTHORS file in the root of the source tree.

 */

#ifndef VPX_VP8_DECODER_DBOOLHUFF_H_

#define VPX_VP8_DECODER_DBOOLHUFF_H_

#include <stddef.h>

#include <limits.h>

#include "./vpx_config.h"

#include "vpx_ports/compiler_attributes.h"

#include "vpx_ports/mem.h"

#include "vpx/vp8dx.h"

#include "vpx/vpx_integer.h"

#ifdef __cplusplus

extern "C" {

#endif

typedef size_t VP8_BD_VALUE;

#define VP8_BD_VALUE_SIZE ((int)sizeof(VP8_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 VP8_LOTS_OF_BITS (0x40000000)

typedef struct {

  const unsigned char *user_buffer_end;

  const unsigned char *user_buffer;

  VP8_BD_VALUE value;

  int count;

  unsigned int range;

  vpx_decrypt_cb decrypt_cb;

  void *decrypt_state;

} BOOL_DECODER;

DECLARE_ALIGNED(16, extern const unsigned char, vp8_norm[256]);

int vp8dx_start_decode(BOOL_DECODER *br, const unsigned char *source,

                       unsigned int source_sz, vpx_decrypt_cb decrypt_cb,

                       void *decrypt_state);

void vp8dx_bool_decoder_fill(BOOL_DECODER *br);

static VPX_NO_UNSIGNED_SHIFT_CHECK int vp8dx_decode_bool(BOOL_DECODER *br,

                                                         int probability) {

  unsigned int bit = 0;

  VP8_BD_VALUE value;

  unsigned int split;

  VP8_BD_VALUE bigsplit;

  int count;

  unsigned int range;

  split = 1 + (((br->range - 1) * probability) >> 8);

  if (br->count < 0) vp8dx_bool_decoder_fill(br);

  value = br->value;

  count = br->count;

  bigsplit = (VP8_BD_VALUE)split << (VP8_BD_VALUE_SIZE - 8);

  range = split;

  if (value >= bigsplit) {

    range = br->range - split;

    value = value - bigsplit;

    bit = 1;

  }

  {

    const unsigned char shift = vp8_norm[(unsigned char)range];

    range <<= shift;

    value <<= shift;

    count -= shift;

  }

  br->value = value;

  br->count = count;

  br->range = range;

  return bit;

}

Unexecuted instantiation: vp8_dx_iface.c:vp8dx_decode_bool

Unexecuted instantiation: onyxd_if.c:vp8dx_decode_bool

Unexecuted instantiation: threading.c:vp8dx_decode_bool

decodeframe.c:vp8dx_decode_bool

Line

Count

Source

55

78.0M

                                                         int probability) {

56

78.0M

  unsigned int bit = 0;

57

78.0M

  VP8_BD_VALUE value;

58

78.0M

  unsigned int split;

59

78.0M

  VP8_BD_VALUE bigsplit;

60

78.0M

  int count;

61

78.0M

  unsigned int range;

62

63

78.0M

  split = 1 + (((br->range - 1) * probability) >> 8);

64

65

78.0M

  if (br->count < 0) vp8dx_bool_decoder_fill(br);

66

67

78.0M

  value = br->value;

68

78.0M

  count = br->count;

69

70

78.0M

  bigsplit = (VP8_BD_VALUE)split << (VP8_BD_VALUE_SIZE - 8);

71

72

78.0M

  range = split;

73

74

78.0M

  if (value >= bigsplit) {

75

6.37M

    range = br->range - split;

76

6.37M

    value = value - bigsplit;

77

6.37M

    bit = 1;

78

6.37M

  }

79

80

78.0M

  {

81

78.0M

    const unsigned char shift = vp8_norm[(unsigned char)range];

82

78.0M

    range <<= shift;

83

78.0M

    value <<= shift;

84

78.0M

    count -= shift;

85

78.0M

  }

86

78.0M

  br->value = value;

87

78.0M

  br->count = count;

88

78.0M

  br->range = range;

89

90

78.0M

  return bit;

91

78.0M

}

detokenize.c:vp8dx_decode_bool

Line

Count

Source

55

216M

                                                         int probability) {

56

216M

  unsigned int bit = 0;

57

216M

  VP8_BD_VALUE value;

58

216M

  unsigned int split;

59

216M

  VP8_BD_VALUE bigsplit;

60

216M

  int count;

61

216M

  unsigned int range;

62

63

216M

  split = 1 + (((br->range - 1) * probability) >> 8);

64

65

216M

  if (br->count < 0) vp8dx_bool_decoder_fill(br);

66

67

216M

  value = br->value;

68

216M

  count = br->count;

69

70

216M

  bigsplit = (VP8_BD_VALUE)split << (VP8_BD_VALUE_SIZE - 8);

71

72

216M

  range = split;

73

74

216M

  if (value >= bigsplit) {

75

66.3M

    range = br->range - split;

76

66.3M

    value = value - bigsplit;

77

66.3M

    bit = 1;

78

66.3M

  }

79

80

216M

  {

81

216M

    const unsigned char shift = vp8_norm[(unsigned char)range];

82

216M

    range <<= shift;

83

216M

    value <<= shift;

84

216M

    count -= shift;

85

216M

  }

86

216M

  br->value = value;

87

216M

  br->count = count;

88

216M

  br->range = range;

89

90

216M

  return bit;

91

216M

}

Unexecuted instantiation: dboolhuff.c:vp8dx_decode_bool

decodemv.c:vp8dx_decode_bool

Line

Count

Source

55

12.2G

                                                         int probability) {

56

12.2G

  unsigned int bit = 0;

57

12.2G

  VP8_BD_VALUE value;

58

12.2G

  unsigned int split;

59

12.2G

  VP8_BD_VALUE bigsplit;

60

12.2G

  int count;

61

12.2G

  unsigned int range;

62

63

12.2G

  split = 1 + (((br->range - 1) * probability) >> 8);

64

65

12.2G

  if (br->count < 0) vp8dx_bool_decoder_fill(br);

66

67

12.2G

  value = br->value;

68

12.2G

  count = br->count;

69

70

12.2G

  bigsplit = (VP8_BD_VALUE)split << (VP8_BD_VALUE_SIZE - 8);

71

72

12.2G

  range = split;

73

74

12.2G

  if (value >= bigsplit) {

75

180M

    range = br->range - split;

76

180M

    value = value - bigsplit;

77

180M

    bit = 1;

78

180M

  }

79

80

12.2G

  {

81

12.2G

    const unsigned char shift = vp8_norm[(unsigned char)range];

82

12.2G

    range <<= shift;

83

12.2G

    value <<= shift;

84

12.2G

    count -= shift;

85

12.2G

  }

86

12.2G

  br->value = value;

87

12.2G

  br->count = count;

88

12.2G

  br->range = range;

89

90

12.2G

  return bit;

91

12.2G

}

static INLINE int vp8_decode_value(BOOL_DECODER *br, int bits) {

  int z = 0;

  int bit;

  for (bit = bits - 1; bit >= 0; bit--) {

    z |= (vp8dx_decode_bool(br, 0x80) << bit);

  }

  return z;

}

Unexecuted instantiation: vp8_dx_iface.c:vp8_decode_value

Unexecuted instantiation: onyxd_if.c:vp8_decode_value

Unexecuted instantiation: threading.c:vp8_decode_value

decodeframe.c:vp8_decode_value

Line

Count

Source

93

1.37M

static INLINE int vp8_decode_value(BOOL_DECODER *br, int bits) {

94

1.37M

  int z = 0;

95

1.37M

  int bit;

96

97

9.87M

  for (bit = bits - 1; bit >= 0; bit--) {

98

8.50M

    z |= (vp8dx_decode_bool(br, 0x80) << bit);

99

8.50M

  }

100

101

1.37M

  return z;

102

1.37M

}

Unexecuted instantiation: detokenize.c:vp8_decode_value

Unexecuted instantiation: dboolhuff.c:vp8_decode_value

decodemv.c:vp8_decode_value

Line

Count

Source

93

439k

static INLINE int vp8_decode_value(BOOL_DECODER *br, int bits) {

94

439k

  int z = 0;

95

439k

  int bit;

96

97

3.90M

  for (bit = bits - 1; bit >= 0; bit--) {

98

3.46M

    z |= (vp8dx_decode_bool(br, 0x80) << bit);

99

3.46M

  }

100

101

439k

  return z;

102

439k

}

static INLINE int vp8dx_bool_error(BOOL_DECODER *br) {

  /* 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 VP8_LOTS_OF_BITS. So when

   * count == VP8_LOTS_OF_BITS - 1, the user's data has been exhausted.

   */

  if ((br->count > VP8_BD_VALUE_SIZE) && (br->count < VP8_LOTS_OF_BITS)) {

    /* We have tried to decode bits after the end of

     * stream was encountered.

     */

    return 1;

  }

  /* No error. */

  return 0;

}

Unexecuted instantiation: vp8_dx_iface.c:vp8dx_bool_error

Unexecuted instantiation: onyxd_if.c:vp8dx_bool_error

Unexecuted instantiation: threading.c:vp8dx_bool_error

decodeframe.c:vp8dx_bool_error

Line

Count

Source

104

1.72G

static INLINE int vp8dx_bool_error(BOOL_DECODER *br) {

105

  /* Check if we have reached the end of the buffer.

106

   *

107

   * Variable 'count' stores the number of bits in the 'value' buffer, minus

108

   * 8. The top byte is part of the algorithm, and the remainder is buffered

109

   * to be shifted into it. So if count == 8, the top 16 bits of 'value' are

110

   * occupied, 8 for the algorithm and 8 in the buffer.

111

   *

112

   * When reading a byte from the user's buffer, count is filled with 8 and

113

   * one byte is filled into the value buffer. When we reach the end of the

114

   * data, count is additionally filled with VP8_LOTS_OF_BITS. So when

115

   * count == VP8_LOTS_OF_BITS - 1, the user's data has been exhausted.

116

   */

117

1.72G

  if ((br->count > VP8_BD_VALUE_SIZE) && (br->count < VP8_LOTS_OF_BITS)) {

118

    /* We have tried to decode bits after the end of

119

     * stream was encountered.

120

     */

121

1.71G

    return 1;

122

1.71G

  }

123

124

  /* No error. */

125

17.1M

  return 0;

126

1.72G

}

Unexecuted instantiation: detokenize.c:vp8dx_bool_error

Unexecuted instantiation: dboolhuff.c:vp8dx_bool_error

Unexecuted instantiation: decodemv.c:vp8dx_bool_error

#ifdef __cplusplus

}  // extern "C"

#endif

#endif  // VPX_VP8_DECODER_DBOOLHUFF_H_