Google Git
Sign in
aomedia / aom / 69eab5cdf9858e8f18b1fe0d166febf88c68b74c
commit69eab5cdf9858e8f18b1fe0d166febf88c68b74c[log] [tgz]
authorJames Zern <jzern@google.com>Fri Jun 30 12:46:00 2017 -0700
committerJames Zern <jzern@google.com>Fri Jun 30 22:14:21 2017 +0000
tree6a1d57c1d24fd7603afff9f275a490bc695ae796
parente3afdd8949c55dcc84ac9f95f1b48a54fb8bb257 [diff]
roll libwebm snapshot

git log --no-merges --oneline 32d5ac4..a97c484
9096786 mkvparser: fix float conversion warning
84e8257 disable -Wdeprecated-declarations in legacy code
a98f495 AddGenericFrame: fix memory leak on failure
da131dd AddCuePoint: fix memory leak on failure
b0cea9c Add(Audio|Video)Track: fix memory leak on failure
5261a67 webm_info: check vp9 ParseUncompressedHeader return
85f7e2e webm_info,PrintVP9Info: validate alt ref sizes
9b97ca1 vp9_header_parser_tests: check parser return
300d6d8 CuePoint::Find: check Track pointer
50c44bb webm_info,OutputCues: fix indexing of tracks
a0d27f0 mkvparser,Block::Parse: remove incorrect assert
784fc1b vttdemux,CloseFiles: check file pointer before closing
b4522c1 .gitattributes: force mkv/webm to be treated as binary
a118f3d Add test for projection parse failures.
d398479 Add test for primary chromaticity parse failures.
9bbec4c Fix permissions on test file.
2cef4d5 mkvparser:Parse: s/FLT_MIN/-FLT_MAX/
35a3c88 mkvmuxer: Turn off estimate_file_duration_ by default
5a41830 mkvparser: Avoid double free when Chromaticity parse fails.
67e3ffa mkvparser: Avoid casts of values too large for float in
Projection elements.
...

Change-Id: I45acb22902ff0a46a5d339dc51181d5d141a8dcc
13 files changed
tree: 6a1d57c1d24fd7603afff9f275a490bc695ae796
  1. aom/
  2. aom_dsp/
  3. aom_mem/
  4. aom_ports/
  5. aom_scale/
  6. aom_util/
  7. av1/
  8. build/
  9. examples/
  10. test/
  11. third_party/
  12. tools/
  13. .clang-format
  14. .gitattributes
  15. .gitignore
  16. .mailmap
  17. aomdec.c
  18. aomenc.c
  19. aomenc.h
  20. aomstats.c
  21. aomstats.h
  22. args.c
  23. args.h
  24. AUTHORS
  25. CHANGELOG
  26. CMakeLists.txt
  27. codereview.settings
  28. configure
  29. docs.cmake
  30. docs.mk
  31. examples.mk
  32. ivfdec.c
  33. ivfdec.h
  34. ivfenc.c
  35. ivfenc.h
  36. keywords.dox
  37. libs.doxy_template
  38. libs.mk
  39. LICENSE
  40. mainpage.dox
  41. md5_utils.c
  42. md5_utils.h
  43. PATENTS
  44. rate_hist.c
  45. rate_hist.h
  46. README
  47. README.md
  48. solution.mk
  49. tools.mk
  50. tools_common.c
  51. tools_common.h
  52. usage.dox
  53. usage_cx.dox
  54. usage_dx.dox
  55. video_common.h
  56. video_reader.c
  57. video_reader.h
  58. video_writer.c
  59. video_writer.h
  60. warnings.c
  61. warnings.h
  62. webmdec.cc
  63. webmdec.h
  64. webmenc.cc
  65. webmenc.h
  66. y4menc.c
  67. y4menc.h
  68. y4minput.c
  69. y4minput.h
README.md

AV1 Codec Library

Building the library and applications

Prerequisites

  1. CMake version 3.5 or higher.
  2. Git.
  3. Perl.
  4. For x86 targets, yasm, which is preferred, or a recent version of nasm.
  5. Building the documentation requires doxygen.
  6. Building the unit tests requires Python.

Basic build

CMake replaces the configure step typical of many projects. Running CMake will produce configuration and build files for the currently selected CMake generator. For most systems the default generator is Unix Makefiles. The basic form of a makefile build is the following:

$ cmake path/to/aom
$ make

The above will generate a makefile build that produces the AV1 library and applications for the current host system after the make step completes successfully. The compiler chosen varies by host platform, but a general rule applies: On systems where cc and c++ are present in $PATH at the time CMake is run the generated build will use cc and c++ by default.

Configuration options

The AV1 codec library has a great many configuration options. These come in two varieties:

  1. Build system configuration options. These have the form ENABLE_FEATURE.
  2. AV1 codec configuration options. These have the form CONFIG_FEATURE.

Both types of options are set at the time CMake is run. The following example enables ccache and disables high bit depth:

$ cmake path/to/aom -DENABLE_CCACHE=1 -DCONFIG_HIGHBITDEPTH=0
$ make

The available configuration options are too numerous to list here. Build system configuration options can be found at the top of the CMakeLists.txt file found in the root of the AV1 repository, and AV1 codec configuration options can currently be found in the file build/cmake/aom_config_defaults.cmake.

Dylib builds

A dylib (shared object) build of the AV1 codec library can be enabled via the CMake built in variable BUILD_SHARED_LIBS:

$ cmake path/to/aom -D BUILD_SHARED_LIBS=1
$ make

This is currently only supported on non-Windows targets.

Cross compiling

For the purposes of building the AV1 codec and applications and relative to the scope of this guide, all builds for architectures differing from the native host architecture will be considered cross compiles. The AV1 CMake build handles cross compiling via the use of toolchain files included in the AV1 repository. The toolchain files available at the time of this writing are:

  • arm64-ios.cmake
  • arm64-linux-gcc.cmake
  • armv7-ios.cmake
  • armv7-linux-gcc.cmake
  • armv7s-ios.cmake
  • mips32-linux-gcc.cmake
  • mips64-linux-gcc.cmake
  • x86-ios-simulator.cmake
  • x86-linux.cmake
  • x86-macos.cmake
  • x86_64-ios-simulator.cmake

The following example demonstrates use of the x86-macos.cmake toolchain file on a x86_64 MacOS host:

$ cmake path/to/aom \
  -DCMAKE_TOOLCHAIN_FILE=path/to/aom/build/cmake/toolchains/x86-macos.cmake
$ make

To build for an unlisted target creation of a new toolchain file is the best solution. The existing toolchain files can be used a starting point for a new toolchain file since each one exposes the basic requirements for toolchain files as used in the AV1 codec build.

As a temporary work around an unoptimized AV1 configuration that builds only C and C++ sources can be produced using the following commands:

$ cmake path/to/aom -DAOM_TARGET_CPU=generic
$ make

In addition to the above it's important to note that the toolchain files suffixed with gcc behave differently than the others. These toolchain files attempt to obey the $CROSS environment variable.

Microsoft Visual Studio builds

Building the AV1 codec library in Microsoft Visual Studio is supported. The following example demonstrates generating projects and a solution for the Microsoft IDE:

# This does not require a bash shell; command.exe is fine.
$ cmake path/to/aom -G "Visual Studio 15 2017"

Xcode builds

Building the AV1 codec library in Xcode is supported. The following example demonstrates generating an Xcode project:

$ cmake path/to/aom -G Xcode

Testing the AV1 codec

Testing basics

Currently there are two types of tests in the AV1 codec repository:

  1. Unit tests.
  2. Example tests.

The unit tests can be run at build time:

# Before running the make command the LIBAOM_TEST_DATA_PATH environment
# variable should be set to avoid downloading the test files to the
# cmake build configuration directory.
$ cmake path/to/aom
# Note: The AV1 CMake build creates many test targets. Running make
# with multiple jobs will speed up the test run significantly.
$ make runtests

The example tests require a bash shell and can be run in the following manner:

# See the note above about LIBAOM_TEST_DATA_PATH above.
$ cmake path/to/aom
$ make
# It's best to build the testdata target using many make jobs.
# Running it like this will verify and download (if necessary)
# one at a time, which takes a while.
$ make testdata
$ path/to/aom/test/examples.sh --bin-path examples

IDE hosted tests

By default the generated projects files created by CMake will not include the runtests and testdata rules when generating for IDEs like Microsoft Visual Studio and Xcode. This is done to avoid intolerably long build cycles in the IDEs-- IDE behavior is to build all targets when selecting the build project options in MSVS and Xcode. To enable the test rules in IDEs the ENABLE_IDE_TEST_HOSTING variable must be enabled at CMake generation time:

# This example uses Xcode. To get a list of the generators
# available, run cmake with the -G argument missing its
# value.
$ cmake path/to/aom -DENABLE_IDE_TEST_HOSTING=1 -G Xcode

Downloading the test data

The fastest and easiest way to obtain the test data is to use CMake to generate a build using the Unix Makefiles generator, and then to build only the testdata rule:

$ cmake path/to/aom -G "Unix Makefiles"
# 28 is used because there are 28 test files as of this writing.
$ make -j28 testdata

The above make command will only download and verify the test data.

Coding style

The coding style used by this project is enforced with clang-format using the configuration contained in the .clang-format file in the root of the repository.

Before pushing changes for review you can format your code with:

# Apply clang-format to modified .c, .h and .cc files
$ clang-format -i --style=file \
  $(git diff --name-only --diff-filter=ACMR '*.[hc]' '*.cc')

Check the .clang-format file for the version used to generate it if there is any difference between your local formatting and the review system.

See also: http://clang.llvm.org/docs/ClangFormat.html

Support

This library is an open source project supported by its community. Please please email aomediacodec@jointdevelopment.kavi.com for help.

Bug reports

Bug reports can be filed in the Alliance for Open Media issue tracker.