Move aom source to a sub-directory under media/libaom

There is no damned reason to treat this differently than any other media lib given its license and there never was.

1 files changed, 0 insertions, 177 deletions

diff --git a/third_party/aom/test/aom_integer_test.cc b/third_party/aom/test/aom_integer_test.cc
deleted file mode 100644
index fe88a54e9..000000000
--- a/third_party/aom/test/aom_integer_test.cc
+++ /dev/null
@@ -1,177 +0,0 @@
-/*
- * Copyright (c) 2018, 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/aom_integer.h"
-#include "third_party/googletest/src/googletest/include/gtest/gtest.h"
-
-namespace {
-const uint64_t kMaximumLeb128CodedSize = 8;
-const uint8_t kLeb128PadByte = 0x80;  // Binary: 10000000
-const uint64_t kMaximumLeb128Value = UINT32_MAX;
-const uint32_t kSizeTestNumValues = 6;
-const uint32_t kSizeTestExpectedSizes[kSizeTestNumValues] = {
-  1, 1, 2, 3, 4, 5
-};
-const uint64_t kSizeTestInputs[kSizeTestNumValues] = {
-  0, 0x7f, 0x3fff, 0x1fffff, 0xffffff, 0x10000000
-};
-
-const uint8_t kOutOfRangeLeb128Value[5] = { 0x80, 0x80, 0x80, 0x80,
-                                            0x10 };  // UINT32_MAX + 1
-}  // namespace
-
-TEST(AomLeb128, DecodeTest) {
-  const size_t num_leb128_bytes = 3;
-  const uint8_t leb128_bytes[num_leb128_bytes] = { 0xE5, 0x8E, 0x26 };
-  const uint64_t expected_value = 0x98765;  // 624485
-  const size_t expected_length = 3;
-  uint64_t value = ~0ULL;  // make sure value is cleared by the function
-  size_t length;
-  ASSERT_EQ(
-      aom_uleb_decode(&leb128_bytes[0], num_leb128_bytes, &value, &length), 0);
-  ASSERT_EQ(expected_value, value);
-  ASSERT_EQ(expected_length, length);
-
-  // Make sure the decoder stops on the last marked LEB128 byte.
-  aom_uleb_decode(&leb128_bytes[0], num_leb128_bytes + 1, &value, &length);
-  ASSERT_EQ(expected_value, value);
-  ASSERT_EQ(expected_length, length);
-}
-
-TEST(AomLeb128, EncodeTest) {
-  const uint32_t test_value = 0x98765;  // 624485
-  const uint8_t expected_bytes[3] = { 0xE5, 0x8E, 0x26 };
-  const size_t kWriteBufferSize = 4;
-  uint8_t write_buffer[kWriteBufferSize] = { 0 };
-  size_t bytes_written = 0;
-  ASSERT_EQ(aom_uleb_encode(test_value, kWriteBufferSize, &write_buffer[0],
-                            &bytes_written),
-            0);
-  ASSERT_EQ(bytes_written, 3u);
-  for (size_t i = 0; i < bytes_written; ++i) {
-    ASSERT_EQ(write_buffer[i], expected_bytes[i]);
-  }
-}
-
-TEST(AomLeb128, EncodeDecodeTest) {
-  const uint32_t value = 0x98765;  // 624485
-  const size_t kWriteBufferSize = 4;
-  uint8_t write_buffer[kWriteBufferSize] = { 0 };
-  size_t bytes_written = 0;
-  ASSERT_EQ(aom_uleb_encode(value, kWriteBufferSize, &write_buffer[0],
-                            &bytes_written),
-            0);
-  ASSERT_EQ(bytes_written, 3u);
-  uint64_t decoded_value;
-  size_t decoded_length;
-  aom_uleb_decode(&write_buffer[0], bytes_written, &decoded_value,
-                  &decoded_length);
-  ASSERT_EQ(value, decoded_value);
-  ASSERT_EQ(bytes_written, decoded_length);
-}
-
-TEST(AomLeb128, FixedSizeEncodeTest) {
-  const uint32_t test_value = 0x123;
-  const uint8_t expected_bytes[4] = { 0xa3, 0x82, 0x80, 0x00 };
-  const size_t kWriteBufferSize = 4;
-  uint8_t write_buffer[kWriteBufferSize] = { 0 };
-  size_t bytes_written = 0;
-  ASSERT_EQ(0, aom_uleb_encode_fixed_size(test_value, kWriteBufferSize,
-                                          kWriteBufferSize, &write_buffer[0],
-                                          &bytes_written));
-  ASSERT_EQ(kWriteBufferSize, bytes_written);
-  for (size_t i = 0; i < bytes_written; ++i) {
-    ASSERT_EQ(write_buffer[i], expected_bytes[i]);
-  }
-}
-
-TEST(AomLeb128, FixedSizeEncodeDecodeTest) {
-  const uint32_t value = 0x1;
-  const size_t kWriteBufferSize = 4;
-  uint8_t write_buffer[kWriteBufferSize] = { 0 };
-  size_t bytes_written = 0;
-  ASSERT_EQ(
-      aom_uleb_encode_fixed_size(value, kWriteBufferSize, kWriteBufferSize,
-                                 &write_buffer[0], &bytes_written),
-      0);
-  ASSERT_EQ(bytes_written, 4u);
-  uint64_t decoded_value;
-  size_t decoded_length;
-  aom_uleb_decode(&write_buffer[0], bytes_written, &decoded_value,
-                  &decoded_length);
-  ASSERT_EQ(value, decoded_value);
-  ASSERT_EQ(bytes_written, decoded_length);
-}
-
-TEST(AomLeb128, SizeTest) {
-  for (size_t i = 0; i < kSizeTestNumValues; ++i) {
-    ASSERT_EQ(kSizeTestExpectedSizes[i],
-              aom_uleb_size_in_bytes(kSizeTestInputs[i]));
-  }
-}
-
-TEST(AomLeb128, DecodeFailTest) {
-  // Input buffer containing what would be a valid 9 byte LEB128 encoded
-  // unsigned integer.
-  const uint8_t kAllPadBytesBuffer[kMaximumLeb128CodedSize + 1] = {
-    kLeb128PadByte, kLeb128PadByte, kLeb128PadByte,
-    kLeb128PadByte, kLeb128PadByte, kLeb128PadByte,
-    kLeb128PadByte, kLeb128PadByte, 0
-  };
-  uint64_t decoded_value;
-
-  // Test that decode fails when result would be valid 9 byte integer.
-  ASSERT_EQ(aom_uleb_decode(&kAllPadBytesBuffer[0], kMaximumLeb128CodedSize + 1,
-                            &decoded_value, NULL),
-            -1);
-
-  // Test that encoded value missing terminator byte within available buffer
-  // range causes decode error.
-  ASSERT_EQ(aom_uleb_decode(&kAllPadBytesBuffer[0], kMaximumLeb128CodedSize,
-                            &decoded_value, NULL),
-            -1);
-
-  // Test that LEB128 input that decodes to a value larger than 32-bits fails.
-  size_t value_size = 0;
-  ASSERT_EQ(aom_uleb_decode(&kOutOfRangeLeb128Value[0],
-                            sizeof(kOutOfRangeLeb128Value), &decoded_value,
-                            &value_size),
-            -1);
-}
-
-TEST(AomLeb128, EncodeFailTest) {
-  const size_t kWriteBufferSize = 4;
-  const uint32_t kValidTestValue = 1;
-  uint8_t write_buffer[kWriteBufferSize] = { 0 };
-  size_t coded_size = 0;
-  ASSERT_EQ(
-      aom_uleb_encode(kValidTestValue, kWriteBufferSize, NULL, &coded_size),
-      -1);
-  ASSERT_EQ(aom_uleb_encode(kValidTestValue, kWriteBufferSize, &write_buffer[0],
-                            NULL),
-            -1);
-
-  const uint32_t kValueOutOfRangeForBuffer = 0xFFFFFFFF;
-  ASSERT_EQ(aom_uleb_encode(kValueOutOfRangeForBuffer, kWriteBufferSize,
-                            &write_buffer[0], &coded_size),
-            -1);
-
-  const uint64_t kValueOutOfRange = kMaximumLeb128Value + 1;
-  ASSERT_EQ(aom_uleb_encode(kValueOutOfRange, kWriteBufferSize,
-                            &write_buffer[0], &coded_size),
-            -1);
-
-  const size_t kPadSizeOutOfRange = 5;
-  ASSERT_EQ(aom_uleb_encode_fixed_size(kValidTestValue, kWriteBufferSize,
-                                       kPadSizeOutOfRange, &write_buffer[0],
-                                       &coded_size),
-            -1);
-}