Use Daala entropy coder to code bits.

When building with --enable-daala_ec, calls to aom_write() and aom_read()
 use the daala entropy coder to write and read bits.
When the probability is exactly 0.5 (128), then raw bits are used.

ntt-short-1:

          MEDIUM (%) HIGH (%)
    PSNR -0.027556  -0.020114
 PSNRHVS -0.027401  -0.020169
    SSIM -0.027587  -0.020151
FASTSSIM -0.027592  -0.020102

subset1:

         RATE (%)  DSNR (dB)
    PSNR 0.03296  -0.00210
 PSNRHVS 0.03537  -0.00281
    SSIM 0.03299  -0.00161
FASTSSIM 0.03458  -0.00111

Change-Id: I48ad8eb40fc895d62d6e241ea8abc02820d573f7

aom_dsp/aom_dsp.mk

@@ -51,6 +51,10 @@ DSP_SRCS-yes += entdec.c
 DSP_SRCS-yes += entdec.h
 DSP_SRCS-yes += entcode.c
 DSP_SRCS-yes += entcode.h
+DSP_SRCS-yes += daalaboolreader.c
+DSP_SRCS-yes += daalaboolreader.h
+DSP_SRCS-yes += daalaboolwriter.c
+DSP_SRCS-yes += daalaboolwriter.h
 endif
 
 ifeq ($(CONFIG_USE_X86INC),yes)

aom_dsp/bitreader.h

@@ -18,31 +18,57 @@
 #include "./aom_config.h"
 #include "aom/aomdx.h"
 #include "aom/aom_integer.h"
+#if CONFIG_DAALA_EC
+#include "aom_dsp/daalaboolreader.h"
+#else
 #include "aom_dsp/dkboolreader.h"
+#endif
 #include "aom_dsp/prob.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+#if CONFIG_DAALA_EC
+typedef struct daala_reader aom_reader;
+#else
 typedef struct aom_dk_reader aom_reader;
+#endif
 
 static INLINE int aom_reader_init(aom_reader *r, const uint8_t *buffer,
                                   size_t size, aom_decrypt_cb decrypt_cb,
                                   void *decrypt_state) {
+#if CONFIG_DAALA_EC
+  (void)decrypt_cb;
+  (void)decrypt_state;
+  return aom_daala_reader_init(r, buffer, size);
+#else
   return aom_dk_reader_init(r, buffer, size, decrypt_cb, decrypt_state);
+#endif
 }
 
 static INLINE const uint8_t *aom_reader_find_end(aom_reader *r) {
+#if CONFIG_DAALA_EC
+  return aom_daala_reader_find_end(r);
+#else
   return aom_dk_reader_find_end(r);
+#endif
 }
 
 static INLINE int aom_reader_has_error(aom_reader *r) {
+#if CONFIG_DAALA_EC
+  return aom_daala_reader_has_error(r);
+#else
   return aom_dk_reader_has_error(r);
+#endif
 }
 
 static INLINE int aom_read(aom_reader *r, int prob) {
+#if CONFIG_DAALA_EC
+  return aom_daala_read(r, prob);
+#else
   return aom_dk_read(r, prob);
+#endif
 }
 
 static INLINE int aom_read_bit(aom_reader *r) {

aom_dsp/bitwriter.h

@@ -12,23 +12,46 @@
 #ifndef AOM_DSP_BITWRITER_H_
 #define AOM_DSP_BITWRITER_H_
 
+#include "./aom_config.h"
+#if CONFIG_DAALA_EC
+#include "aom_dsp/daalaboolwriter.h"
+#else
 #include "aom_dsp/dkboolwriter.h"
+#endif
 #include "aom_dsp/prob.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+#if CONFIG_DAALA_EC
+typedef struct daala_writer aom_writer;
+#else
 typedef struct aom_dk_writer aom_writer;
+#endif
 
 static INLINE void aom_start_encode(aom_writer *bc, uint8_t *buffer) {
+#if CONFIG_DAALA_EC
+  aom_daala_start_encode(bc, buffer);
+#else
   aom_dk_start_encode(bc, buffer);
+#endif
 }
 
-static INLINE void aom_stop_encode(aom_writer *bc) { aom_dk_stop_encode(bc); }
+static INLINE void aom_stop_encode(aom_writer *bc) {
+#if CONFIG_DAALA_EC
+  aom_daala_stop_encode(bc);
+#else
+  aom_dk_stop_encode(bc);
+#endif
+}
 
 static INLINE void aom_write(aom_writer *br, int bit, int probability) {
+#if CONFIG_DAALA_EC
+  aom_daala_write(br, bit, probability);
+#else
   aom_dk_write(br, bit, probability);
+#endif
 }
 
 static INLINE void aom_write_bit(aom_writer *w, int bit) {

aom_dsp/daalaboolreader.c

@@ -0,0 +1,26 @@
+/*
+ * 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.
+ */
+
+#include "aom_dsp/daalaboolreader.h"
+
+int aom_daala_reader_init(daala_reader *r, const uint8_t *buffer, int size) {
+  if (size && !buffer) {
+    return 1;
+  }
+  r->buffer_end = buffer + size;
+  r->buffer = buffer;
+  od_ec_dec_init(&r->ec, buffer, size - 1);
+  return 0;
+}
+
+const uint8_t *aom_daala_reader_find_end(daala_reader *r) {
+  return r->buffer_end;
+}

aom_dsp/daalaboolreader.h

@@ -0,0 +1,54 @@
+/*
+ * 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_DAALABOOLREADER_H_
+#define AOM_DSP_DAALABOOLREADER_H_
+
+#include "aom_dsp/entdec.h"
+#include "aom_dsp/prob.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct daala_reader {
+  const uint8_t *buffer;
+  const uint8_t *buffer_end;
+  od_ec_dec ec;
+};
+
+typedef struct daala_reader daala_reader;
+
+int aom_daala_reader_init(daala_reader *r, const uint8_t *buffer, int size);
+const uint8_t *aom_daala_reader_find_end(daala_reader *r);
+
+static INLINE int aom_daala_read(daala_reader *r, int prob) {
+  if (prob == 128) {
+    return od_ec_dec_bits(&r->ec, 1, "aom_bits");
+  } else {
+    int p = ((prob << 15) + (256 - prob)) >> 8;
+    return od_ec_decode_bool_q15(&r->ec, p, "aom");
+  }
+}
+
+static INLINE int aom_daala_read_bit(daala_reader *r) {
+  return aom_daala_read(r, 128);
+}
+
+static INLINE int aom_daala_reader_has_error(daala_reader *r) {
+  return r->ec.error;
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif

aom_dsp/daalaboolwriter.c

@@ -0,0 +1,31 @@
+/*
+ * 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.
+ */
+
+#include <string.h>
+#include "aom_dsp/daalaboolwriter.h"
+
+void aom_daala_start_encode(daala_writer *br, uint8_t *source) {
+  br->buffer = source;
+  br->pos = 0;
+  od_ec_enc_init(&br->ec, 62025);
+}
+
+void aom_daala_stop_encode(daala_writer *br) {
+  uint32_t daala_bytes;
+  unsigned char *daala_data;
+  daala_data = od_ec_enc_done(&br->ec, &daala_bytes);
+  memcpy(br->buffer, daala_data, daala_bytes);
+  br->pos = daala_bytes;
+  /* Prevent ec bitstream from being detected as a superframe marker.
+     Must always be added, so that rawbits knows the exact length of the
+      bitstream. */
+  br->buffer[br->pos++] = 0;
+}

aom_dsp/daalaboolwriter.h

@@ -0,0 +1,45 @@
+/*
+ * 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_DAALABOOLWRITER_H_
+#define AOM_DSP_DAALABOOLWRITER_H_
+
+#include "aom_dsp/entenc.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct daala_writer {
+  unsigned int pos;
+  uint8_t *buffer;
+  od_ec_enc ec;
+};
+
+typedef struct daala_writer daala_writer;
+
+void aom_daala_start_encode(daala_writer *w, uint8_t *buffer);
+void aom_daala_stop_encode(daala_writer *w);
+
+static INLINE void aom_daala_write(daala_writer *w, int bit, int prob) {
+  if (prob == 128) {
+    od_ec_enc_bits(&w->ec, bit, 1);
+  } else {
+    int p = ((prob << 15) + (256 - prob)) >> 8;
+    od_ec_encode_bool_q15(&w->ec, bit, p);
+  }
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif