165 строки
5.0 KiB
C++
165 строки
5.0 KiB
C++
/*
|
|
* 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 <assert.h>
|
|
#include <math.h>
|
|
#include <stdio.h>
|
|
#include <ctime>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include "third_party/googletest/src/include/gtest/gtest.h"
|
|
|
|
#include "test/acm_random.h"
|
|
#include "aom_dsp/ansreader.h"
|
|
#include "aom_dsp/answriter.h"
|
|
|
|
namespace {
|
|
typedef std::vector<std::pair<uint8_t, bool> > PvVec;
|
|
|
|
const int kPrintStats = 0;
|
|
|
|
PvVec abs_encode_build_vals(int iters) {
|
|
PvVec ret;
|
|
libaom_test::ACMRandom gen(0x30317076);
|
|
double entropy = 0;
|
|
for (int i = 0; i < iters; ++i) {
|
|
uint8_t p;
|
|
do {
|
|
p = gen.Rand8();
|
|
} while (p == 0); // zero is not a valid coding probability
|
|
bool b = gen.Rand8() < p;
|
|
ret.push_back(std::make_pair(static_cast<uint8_t>(p), b));
|
|
if (kPrintStats) {
|
|
double d = p / 256.;
|
|
entropy += -d * log2(d) - (1 - d) * log2(1 - d);
|
|
}
|
|
}
|
|
if (kPrintStats) printf("entropy %f\n", entropy);
|
|
return ret;
|
|
}
|
|
|
|
bool check_uabs(const PvVec &pv_vec, uint8_t *buf) {
|
|
AnsCoder a;
|
|
ans_write_init(&a, buf);
|
|
|
|
std::clock_t start = std::clock();
|
|
for (PvVec::const_reverse_iterator it = pv_vec.rbegin(); it != pv_vec.rend();
|
|
++it) {
|
|
uabs_write(&a, it->second, 256 - it->first);
|
|
}
|
|
std::clock_t enc_time = std::clock() - start;
|
|
int offset = ans_write_end(&a);
|
|
bool okay = true;
|
|
AnsDecoder d;
|
|
if (ans_read_init(&d, buf, offset)) return false;
|
|
start = std::clock();
|
|
for (PvVec::const_iterator it = pv_vec.begin(); it != pv_vec.end(); ++it) {
|
|
okay &= uabs_read(&d, 256 - it->first) == it->second;
|
|
}
|
|
std::clock_t dec_time = std::clock() - start;
|
|
if (!okay) return false;
|
|
if (kPrintStats)
|
|
printf("uABS size %d enc_time %f dec_time %f\n", offset,
|
|
static_cast<float>(enc_time) / CLOCKS_PER_SEC,
|
|
static_cast<float>(dec_time) / CLOCKS_PER_SEC);
|
|
return ans_read_end(&d);
|
|
}
|
|
|
|
// TODO(aconverse@google.com): replace this with a more representative
|
|
// distribution from the codec.
|
|
const rans_sym rans_sym_tab[] = {
|
|
{ 67, 0 }, { 99, 67 }, { 575, 166 }, { 283, 741 },
|
|
};
|
|
|
|
std::vector<int> ans_encode_build_vals(const rans_sym *tab, int iters) {
|
|
std::vector<int> p_to_sym;
|
|
int i = 0;
|
|
while (p_to_sym.size() < RANS_PRECISION) {
|
|
p_to_sym.insert(p_to_sym.end(), tab[i].prob, i);
|
|
++i;
|
|
}
|
|
assert(p_to_sym.size() == RANS_PRECISION);
|
|
std::vector<int> ret;
|
|
libaom_test::ACMRandom gen(18543637);
|
|
for (int i = 0; i < iters; ++i) {
|
|
int sym = p_to_sym[gen.Rand8() * 4];
|
|
ret.push_back(sym);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
void rans_build_dec_tab(const struct rans_sym sym_tab[], rans_lut dec_tab) {
|
|
dec_tab[0] = 0;
|
|
for (int i = 1; dec_tab[i - 1] < RANS_PRECISION; ++i) {
|
|
dec_tab[i] = dec_tab[i - 1] + sym_tab[i - 1].prob;
|
|
}
|
|
}
|
|
|
|
bool check_rans(const std::vector<int> &sym_vec, const rans_sym *const tab,
|
|
uint8_t *buf) {
|
|
AnsCoder a;
|
|
ans_write_init(&a, buf);
|
|
rans_lut dec_tab;
|
|
rans_build_dec_tab(tab, dec_tab);
|
|
|
|
std::clock_t start = std::clock();
|
|
for (std::vector<int>::const_reverse_iterator it = sym_vec.rbegin();
|
|
it != sym_vec.rend(); ++it) {
|
|
rans_write(&a, &tab[*it]);
|
|
}
|
|
std::clock_t enc_time = std::clock() - start;
|
|
int offset = ans_write_end(&a);
|
|
bool okay = true;
|
|
AnsDecoder d;
|
|
if (ans_read_init(&d, buf, offset)) return false;
|
|
start = std::clock();
|
|
for (std::vector<int>::const_iterator it = sym_vec.begin();
|
|
it != sym_vec.end(); ++it) {
|
|
okay &= rans_read(&d, dec_tab) == *it;
|
|
}
|
|
std::clock_t dec_time = std::clock() - start;
|
|
if (!okay) return false;
|
|
if (kPrintStats)
|
|
printf("rANS size %d enc_time %f dec_time %f\n", offset,
|
|
static_cast<float>(enc_time) / CLOCKS_PER_SEC,
|
|
static_cast<float>(dec_time) / CLOCKS_PER_SEC);
|
|
return ans_read_end(&d);
|
|
}
|
|
|
|
class AbsTest : public ::testing::Test {
|
|
protected:
|
|
static void SetUpTestCase() { pv_vec_ = abs_encode_build_vals(kNumBools); }
|
|
virtual void SetUp() { buf_ = new uint8_t[kNumBools / 8]; }
|
|
virtual void TearDown() { delete[] buf_; }
|
|
static const int kNumBools = 100000000;
|
|
static PvVec pv_vec_;
|
|
uint8_t *buf_;
|
|
};
|
|
PvVec AbsTest::pv_vec_;
|
|
|
|
class AnsTest : public ::testing::Test {
|
|
protected:
|
|
static void SetUpTestCase() {
|
|
sym_vec_ = ans_encode_build_vals(rans_sym_tab, kNumSyms);
|
|
}
|
|
virtual void SetUp() { buf_ = new uint8_t[kNumSyms / 2]; }
|
|
virtual void TearDown() { delete[] buf_; }
|
|
static const int kNumSyms = 25000000;
|
|
static std::vector<int> sym_vec_;
|
|
uint8_t *buf_;
|
|
};
|
|
std::vector<int> AnsTest::sym_vec_;
|
|
|
|
TEST_F(AbsTest, Uabs) { EXPECT_TRUE(check_uabs(pv_vec_, buf_)); }
|
|
TEST_F(AnsTest, Rans) { EXPECT_TRUE(check_rans(sym_vec_, rans_sym_tab, buf_)); }
|
|
} // namespace
|