diff options
89 files changed, 30590 insertions, 2 deletions
diff --git a/include/common/attributes.h b/include/common/attributes.h new file mode 100644 index 0000000..b2315bc --- /dev/null +++ b/include/common/attributes.h @@ -0,0 +1,54 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_COMMON_ATTRIBUTES_H__ +#define __DAV1D_COMMON_ATTRIBUTES_H__ + +#include <stddef.h> + +/* + * API for variables, struct members (ALIGN()) like: + * uint8_t var[1][2][3][4] + * becomes: + * ALIGN(uint8_t var[1][2][3][4], alignment). + */ +#define ALIGN(line, align) \ + line __attribute__((aligned(align))) + +/* + * API for stack alignment (ALIGN_STK_$align()) of variables like: + * uint8_t var[1][2][3][4] + * becomes: + * ALIGN_STK_$align(uint8_t, var, 1, [2][3][4]) + */ +#define ALIGN_STK_32(type, var, sz1d, sznd) \ + ALIGN(type var[sz1d]sznd, 32) +// as long as stack is itself 16-byte aligned, this works (win64, gcc) +#define ALIGN_STK_16(type, var, sz1d, sznd) \ + ALIGN(type var[sz1d]sznd, 16) + +#endif /* __DAV1D_COMMON_ATTRIBUTES_H__ */ diff --git a/include/common/bitdepth.h b/include/common/bitdepth.h new file mode 100644 index 0000000..467d892 --- /dev/null +++ b/include/common/bitdepth.h @@ -0,0 +1,68 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_COMMON_BITDEPTH_H__ +#define __DAV1D_COMMON_BITDEPTH_H__ 1 + +#include <stdint.h> +#include <string.h> + +#if !defined(BITDEPTH) +typedef void pixel; +typedef void coef; +#elif BITDEPTH == 8 +typedef uint8_t pixel; +typedef int16_t coef; +#define pixel_copy memcpy +#define pixel_set memset +#define iclip_pixel iclip_u8 +#define PIX_HEX_FMT "%02x" +#define bytefn(x) x##_8bpc +#define bitfn(x) x##_8bpc +#define PXSTRIDE(x) x +#elif BITDEPTH == 10 || BITDEPTH == 12 +typedef uint16_t pixel; +typedef int32_t coef; +#define pixel_copy(a, b, c) memcpy(a, b, (c) << 1) +#define iclip_pixel(x) iclip(x, 0, ((1 << BITDEPTH) - 1)) +static inline void pixel_set(pixel *const dst, const int val, const int num) { + for (int n = 0; n < num; n++) + dst[n] = val; +} +#define PIX_HEX_FMT "%03x" +#define bytefn(x) x##_16bpc +#if BITDEPTH == 10 +#define bitfn(x) x##_10bpc +#else +#define bitfn(x) x##_12bpc +#endif +#define PXSTRIDE(x) (x >> 1) +#else +#error invalid value for bitdepth +#endif + +#endif /* __DAV1D_COMMON_BITDEPTH_H__ */ diff --git a/include/common/dump.h b/include/common/dump.h new file mode 100644 index 0000000..a73824f --- /dev/null +++ b/include/common/dump.h @@ -0,0 +1,75 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_COMMON_DUMP_H__ +#define __DAV1D_COMMON_DUMP_H__ + +#include <stddef.h> +#include <stdint.h> +#include <stdio.h> + +#include "common/bitdepth.h" + +static inline void append_plane_to_file(const pixel *buf, ptrdiff_t stride, + int w, int h, const char *const file) +{ + FILE *const f = fopen(file, "ab"); + while (h--) { + fwrite(buf, w * sizeof(pixel), 1, f); + buf += PXSTRIDE(stride); + } + fclose(f); +} + +static inline void hex_dump(const pixel *buf, ptrdiff_t stride, + int w, int h, const char *what) +{ + printf("%s\n", what); + while (h--) { + int x; + for (x = 0; x < w; x++) + printf(" " PIX_HEX_FMT, buf[x]); + buf += PXSTRIDE(stride); + printf("\n"); + } +} + +static inline void coef_dump(const coef *buf, const int w, const int h, + const int len, const char *what) +{ + int y; + printf("%s\n", what); + for (y = 0; y < h; y++) { + int x; + for (x = 0; x < w; x++) + printf(" %*d", len, buf[x]); + buf += w; + printf("\n"); + } +} + +#endif /* __DAV1D_COMMON_DUMP_H__ */ diff --git a/include/common/intops.h b/include/common/intops.h new file mode 100644 index 0000000..a739709 --- /dev/null +++ b/include/common/intops.h @@ -0,0 +1,78 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_COMMON_INTOPS_H__ +#define __DAV1D_COMMON_INTOPS_H__ + +#include <stdint.h> + +static inline int imax(const int a, const int b) { + return a > b ? a : b; +} + +static inline int imin(const int a, const int b) { + return a < b ? a : b; +} + +static inline int iclip(const int v, const int min, const int max) { + return v < min ? min : v > max ? max : v; +} + +static inline int iclip_u8(const int v) { + return iclip(v, 0, 255); +} + +static inline int apply_sign(const int v, const int s) { + return s < 0 ? -v : v; +} + +static inline int ulog2(const unsigned v) { + return 31 - __builtin_clz(v); +} + +static inline int u64log2(const uint64_t v) { + return 63 - __builtin_clzll(v); +} + +static inline unsigned rl16(const uint8_t *const ptr) { + return (ptr[1] << 8) | ptr[0]; +} + +static inline unsigned rl32(const uint8_t *const ptr) { + return (rl16(&ptr[2]) << 16) | rl16(ptr); +} + +static inline unsigned inv_recenter(const unsigned r, const unsigned v) { + if (v > (r << 1)) + return v; + else if ((v & 1) == 0) + return (v >> 1) + r; + else + return r - ((v + 1) >> 1); +} + +#endif /* __DAV1D_COMMON_INTOPS_H__ */ diff --git a/include/common/mem.h b/include/common/mem.h new file mode 100644 index 0000000..d266c5d --- /dev/null +++ b/include/common/mem.h @@ -0,0 +1,76 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_COMMON_MEM_H__ +#define __DAV1D_COMMON_MEM_H__ + +#include <assert.h> +#include <stdlib.h> +#include <malloc.h> + +/* + * Allocate 32-byte aligned memory. The return value can be released + * by calling the standard free() function. + */ +static inline void *dav1d_alloc_aligned(size_t sz, size_t align) { +#ifdef HAVE_POSIX_MEMALIGN + void *ptr; + assert(!(align & (align - 1))); + if (posix_memalign(&ptr, align, sz)) return NULL; + return ptr; +#elif defined(HAVE_ALIGNED_MALLOC) + return _aligned_malloc(sz, align); +#else +#error Missing aligned alloc implementation +#endif +} + +static inline void dav1d_free_aligned(void* ptr) { +#ifdef HAVE_POSIX_MEMALIGN + free(ptr); +#elif defined(HAVE_ALIGNED_MALLOC) + _aligned_free(ptr); +#endif +} + +static inline void dav1d_freep_aligned(void* ptr) { + void **mem = (void **) ptr; + if (*mem) { + dav1d_free_aligned(*mem); + *mem = NULL; + } +} + +static inline void freep(void *ptr) { + void **mem = (void **) ptr; + if (*mem) { + free(*mem); + *mem = NULL; + } +} + +#endif /* __DAV1D_COMMON_MEM_H__ */ diff --git a/include/common/validate.h b/include/common/validate.h new file mode 100644 index 0000000..310266d --- /dev/null +++ b/include/common/validate.h @@ -0,0 +1,59 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_COMMON_VALIDATE_H__ +#define __DAV1D_COMMON_VALIDATE_H__ + +#include <stdio.h> +#include <stdlib.h> + +#if defined(NDEBUG) +#define debug_abort() +#else +#define debug_abort abort +#endif + +#define validate_input_or_ret_with_msg(x, r, msg...) \ + if (!(x)) { \ + fprintf(stderr, "Input validation check \'%s\' failed in %s!\n", \ + #x, __PRETTY_FUNCTION__); \ + fprintf(stderr, msg); \ + debug_abort(); \ + return r; \ + } + +#define validate_input_or_ret(x, r) \ + if (!(x)) { \ + fprintf(stderr, "Input validation check \'%s\' failed in %s!\n", \ + #x, __PRETTY_FUNCTION__); \ + debug_abort(); \ + return r; \ + } + +#define validate_input(x) validate_input_or_ret(x, ) + +#endif /* __DAV1D_COMMON_VALIDATE_H__ */ diff --git a/include/dav1d/common.h b/include/dav1d/common.h new file mode 100644 index 0000000..f85f5b1 --- /dev/null +++ b/include/dav1d/common.h @@ -0,0 +1,43 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __COMMON_H__ +#define __COMMON_H__ + +#ifndef DAV1D_API + #if defined _WIN32 + #define DAV1D_API __declspec(dllexport) + #else + #if __GNUC__ >= 4 + #define DAV1D_API __attribute__ ((visibility ("default"))) + #else + #define DAV1D_API + #endif + #endif +#endif + +#endif // __COMMON_H__ diff --git a/include/dav1d/data.h b/include/dav1d/data.h new file mode 100644 index 0000000..9a351ea --- /dev/null +++ b/include/dav1d/data.h @@ -0,0 +1,52 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_DATA_H__ +#define __DAV1D_DATA_H__ + +#include <stddef.h> +#include <stdint.h> + +#include "common.h" + +typedef struct Dav1dData { + uint8_t *data; ///< data pointer + size_t sz; ///< data size + struct Dav1dRef *ref; ///< allocation origin +} Dav1dData; + +/** + * Allocate data. + */ +DAV1D_API int dav1d_data_create(Dav1dData *data, size_t sz); + +/** + * Free data. + */ +DAV1D_API void dav1d_data_unref(Dav1dData *buf); + +#endif /* __DAV1D_DATA_H__ */ diff --git a/include/dav1d/dav1d.h b/include/dav1d/dav1d.h new file mode 100644 index 0000000..9ce476d --- /dev/null +++ b/include/dav1d/dav1d.h @@ -0,0 +1,87 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_H__ +#define __DAV1D_H__ + +#include "common.h" +#include "picture.h" +#include "data.h" + +typedef struct Dav1dContext Dav1dContext; +typedef struct Dav1dRef Dav1dRef; + +typedef struct Dav1dSettings { + int n_frame_threads; + int n_tile_threads; +} Dav1dSettings; + +/* + * Init the library. + */ +DAV1D_API void dav1d_init(void); + +/** + * Get library version. + */ +DAV1D_API const char *dav1d_version(void); + +/** + * Initialize settings to default values. + */ +DAV1D_API void dav1d_default_settings(Dav1dSettings *s); + +/** + * Open/allocate decoder instance. + * + * The resulting instance context will be placed in $c_out and can be used in + * iterative calls to dav1d_decode(). + * + * You should free the context using dav1d_close() when you're done decoding. + * + * This returns < 0 (a negative errno code) on error, or 0 on success. + */ +DAV1D_API int dav1d_open(Dav1dContext **c_out, const Dav1dSettings *s); + +/** + * Decode one input frame. Library takes ownership of the passed-in reference. + * After that, it will return < 0 (a negative errno code, but not -EAGAIN) on + * failure, or 0 on success. If any decoded output frames are available, they + * will be placed in $out. The caller assumes ownership of the returned output + * picture. + * + * To flush the decoder (i.e. all input is finished), feed it NULL input data + * until it returns -EAGAIN. + */ +DAV1D_API int dav1d_decode(Dav1dContext *c, Dav1dData *in, Dav1dPicture *out); + +/** + * Close decoder instance, free all associated memory. + */ +DAV1D_API void dav1d_close(Dav1dContext *c); + +#endif /* __DAV1D_H__ */ diff --git a/include/dav1d/picture.h b/include/dav1d/picture.h new file mode 100644 index 0000000..1b3da29 --- /dev/null +++ b/include/dav1d/picture.h @@ -0,0 +1,145 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_PICTURE_H__ +#define __DAV1D_PICTURE_H__ + +#include <stddef.h> +#include <stdint.h> + +#include "common.h" + +enum Dav1dPixelLayout { + DAV1D_PIXEL_LAYOUT_I400, ///< monochrome + DAV1D_PIXEL_LAYOUT_I420, ///< 4:2:0 planar + DAV1D_PIXEL_LAYOUT_I422, ///< 4:2:2 planar + DAV1D_PIXEL_LAYOUT_I444, ///< 4:4:4 planar +}; + +enum Dav1dColorPrimaries { + DAV1D_COLOR_PRI_BT709 = 1, + DAV1D_COLOR_PRI_UNKNOWN = 2, + DAV1D_COLOR_PRI_BT470M = 4, + DAV1D_COLOR_PRI_BT470BG = 5, + DAV1D_COLOR_PRI_BT601 = 6, + DAV1D_COLOR_PRI_SMPTE240 = 7, + DAV1D_COLOR_PRI_FILM = 8, + DAV1D_COLOR_PRI_BT2020 = 9, + DAV1D_COLOR_PRI_XYZ = 10, + DAV1D_COLOR_PRI_SMPTE431 = 11, + DAV1D_COLOR_PRI_SMPTE432 = 12, + DAV1D_COLOR_PRI_EBU3213 = 22, +}; + +enum Dav1dTransferCharacteristics { + DAV1D_TRC_BT709 = 1, + DAV1D_TRC_UNKNOWN = 2, + DAV1D_TRC_BT470M = 4, + DAV1D_TRC_BT470BG = 5, + DAV1D_TRC_BT601 = 6, + DAV1D_TRC_SMPTE240 = 7, + DAV1D_TRC_LINEAR = 8, + DAV1D_TRC_LOG100 = 9, ///< logarithmic (100:1 range) + DAV1D_TRC_LOG100_SQRT10 = 10, ///< lograithmic (100*sqrt(10):1 range) + DAV1D_TRC_IEC61966 = 11, + DAV1D_TRC_BT1361 = 12, + DAV1D_TRC_SRGB = 13, + DAV1D_TRC_BT2020_10BIT = 14, + DAV1D_TRC_BT2020_12BIT = 15, + DAV1D_TRC_SMPTE2084 = 16, ///< PQ + DAV1D_TRC_SMPTE428 = 17, + DAV1D_TRC_HLG = 18, ///< hybrid log/gamma (BT.2100 / ARIB STD-B67) +}; + +enum Dav1dMatrixCoefficients { + DAV1D_MC_IDENTITY = 0, + DAV1D_MC_BT709 = 1, + DAV1D_MC_UNKNOWN = 2, + DAV1D_MC_FCC = 4, + DAV1D_MC_BT470BG = 5, + DAV1D_MC_BT601 = 6, + DAV1D_MC_SMPTE240 = 7, + DAV1D_MC_SMPTE_YCGCO = 8, + DAV1D_MC_BT2020_NCL = 9, + DAV1D_MC_BT2020_CL = 10, + DAV1D_MC_SMPTE2085 = 11, + DAV1D_MC_CHROMAT_NCL = 12, ///< Chromaticity-derived + DAV1D_MC_CHROMAT_CL = 13, + DAV1D_MC_ICTCP = 14, +}; + +enum Dav1dChromaSamplePosition { + DAV1D_CHR_UNKNOWN = 0, + DAV1D_CHR_VERTICAL = 1, ///< Horizontally co-located with luma(0, 0) + ///< sample, between two vertical samples + DAV1D_CHR_COLOCATED = 2, ///< Co-located with luma(0, 0) sample +}; + +typedef struct Dav1dPictureParameters { + int w; ///< width (in pixels) + int h; ///< height (in pixels) + enum Dav1dPixelLayout layout; ///< format of the picture + int bpc; ///< bits per pixel component (8 or 10) + + enum Dav1dColorPrimaries pri; ///< color primaries (av1) + enum Dav1dTransferCharacteristics trc; ///< transfer characteristics (av1) + enum Dav1dMatrixCoefficients mtrx; ///< matrix coefficients (av1) + enum Dav1dChromaSamplePosition chr; ///< chroma sample position (av1) + /** + * Pixel data uses JPEG pixel range ([0,255] for 8bits) instead of + * MPEG pixel range ([16,235] for 8bits luma, [16,240] for 8bits chroma). + */ + int fullrange; +} Dav1dPictureParameters; + +typedef struct Dav1dPicture { + /** + * Pointers to planar image data (Y is [0], U is [1], V is [2]). The data + * should be bytes (for 8 bpc) or words (for 10 bpc). In case of words + * containing 10 bpc image data, the pixels should be located in the LSB + * bits, so that values range between [0, 1023]; the upper bits should be + * zero'ed out. + */ + void *data[3]; + struct Dav1dRef *ref; ///< allocation origin + + /** + * Number of bytes between 2 lines in data[] for luma [0] or chroma [1]. + */ + ptrdiff_t stride[2]; + + Dav1dPictureParameters p; + + int poc; ///< frame number +} Dav1dPicture; + +/** + * Release reference to a picture. + */ +DAV1D_API void dav1d_picture_unref(Dav1dPicture *p); + +#endif /* __DAV1D_PICTURE_H__ */ diff --git a/meson.build b/meson.build index 4b66eb6..66e2f7d 100644 --- a/meson.build +++ b/meson.build @@ -37,7 +37,15 @@ else thread_dependency = cc.find_library('pthread') endif -dav1d_inc_dirs = include_directories('include') +dav1d_inc_dirs = include_directories(['include', 'include/dav1d']) + +# +# Option handling +# +dav1d_bitdepths = get_option('bitdepths') +foreach bitdepth : dav1d_bitdepths + cdata.set('CONFIG_@0@BPC'.format(bitdepth), 1) +endforeach # # OS/Compiler feature detection @@ -121,15 +129,102 @@ config_h_target = configure_file(output: 'config.h', configuration: cdata) subdir('include') +# +# dav1d library +# +libdav1d_tmpl_sources = files( + 'src/ipred.c', + 'src/itx.c', + 'src/ipred_prepare.c', + 'src/lf_apply.c', + 'src/loopfilter.c', + 'src/mc.c', + 'src/cdef_apply.c', + 'src/cdef.c', + 'src/lr_apply.c', + 'src/looprestoration.c', + 'src/recon.c' +) + +# Build a helper library for each bitdepth +bitdepth_objs = [] +foreach bitdepth : dav1d_bitdepths + bitdepth_lib = static_library( + 'dav1d_bitdepth_@0@'.format(bitdepth), + libdav1d_tmpl_sources, config_h_target, + include_directories: dav1d_inc_dirs, + c_args: ['-DBITDEPTH=@0@'.format(bitdepth), stackalign_flag], + install: false, + build_by_default: false, + ) + bitdepth_objs += bitdepth_lib.extract_all_objects() +endforeach + +entrypoints_src = files( + 'src/lib.c', + 'src/thread_task.c' +) +entrypoints_lib = static_library( + 'libdav1dentrypoint', + entrypoints_src, + include_directories: dav1d_inc_dirs, + c_args: [stackrealign_flag], + install: false, +) +entrypoints_objs = entrypoints_lib.extract_all_objects() + +libdav1d_sources = files( + 'src/picture.c', + 'src/data.c', + 'src/ref.c', + 'src/getbits.c', + 'src/obu.c', + 'src/decode.c', + 'src/cdf.c', + 'src/msac.c', + 'src/tables.c', + 'src/scan.c', + 'src/dequant_tables.c', + 'src/intra_edge.c', + 'src/lf_mask.c', + 'src/ref_mvs.c', + 'src/warpmv.c', + 'src/wedge.c', + 'src/qm.c', +) + libdav1d = library('dav1d', - rev_target, + libdav1d_sources, rev_target, version: '0.0.1', + objects: [bitdepth_objs, entrypoints_objs], include_directories: dav1d_inc_dirs, c_args: [stackalign_flag], dependencies: thread_dependency, install: true ) +install_subdir('include/dav1d/', install_dir: 'include') + +# +# dav1d cli tool +# +dav1d_sources = files( + 'tools/dav1d.c', + 'tools/dav1d_cli_parse.c', + 'tools/input/input.c', + 'tools/input/ivf.c', + 'tools/output/md5.c', + 'tools/output/output.c', + 'tools/output/y4m2.c', + 'tools/output/yuv.c' +) + +dav1d = executable('dav1d', + dav1d_sources, rev_target, + link_with: libdav1d, + include_directories: [dav1d_inc_dirs, include_directories('tools')] +) + # # pkg-config boilerplate # diff --git a/meson_options.txt b/meson_options.txt new file mode 100644 index 0000000..b9dfd26 --- /dev/null +++ b/meson_options.txt @@ -0,0 +1,6 @@ +# General options + +option('bitdepths', + type: 'array', + choices: ['8', '10'], + description: 'Enable only specified bitdepths') diff --git a/src/cdef.c b/src/cdef.c new file mode 100644 index 0000000..98736e9 --- /dev/null +++ b/src/cdef.c @@ -0,0 +1,271 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <stdlib.h> + +#include "common/intops.h" + +#include "src/cdef.h" + +static const int8_t cdef_directions[8 /* dir */][2 /* pass */][2 /* y, x */] = { + { { -1, 1 }, { -2, 2 } }, + { { 0, 1 }, { -1, 2 } }, + { { 0, 1 }, { 0, 2 } }, + { { 0, 1 }, { 1, 2 } }, + { { 1, 1 }, { 2, 2 } }, + { { 1, 0 }, { 2, 1 } }, + { { 1, 0 }, { 2, 0 } }, + { { 1, 0 }, { 2, -1 } } +}; +static const uint8_t cdef_pri_taps[2][2] = { { 4, 2 }, { 3, 3 } }; +static const uint8_t cdef_sec_taps[2][2] = { { 2, 1 }, { 2, 1 } }; + +static inline int constrain(const int diff, const int threshold, + const int damping) +{ + if (!threshold) return 0; + const int shift = imax(0, damping - ulog2(threshold)); + return apply_sign(imin(abs(diff), imax(0, threshold - (abs(diff) >> shift))), + diff); +} + +/* + * <code partially copied from libaom> + */ + +#define CDEF_VERY_LARGE (30000) + +static void fill(uint16_t *tmp, const ptrdiff_t stride, + const int w, const int h) +{ + for (int y = 0; y < h; y++) { + for (int x = 0; x < w; x++) + tmp[x] = CDEF_VERY_LARGE; + tmp += stride; + } +} + +/* Smooth in the direction detected. */ +static void cdef_filter_block_c(pixel *const dst, const ptrdiff_t dst_stride, + /*const*/ pixel *const top[2], + const int w, const int h, const int pri_strength, + const int sec_strength, const int dir, + const int damping, const enum CdefEdgeFlags edges) +{ + const ptrdiff_t tmp_stride = w + 4; + uint16_t tmp[tmp_stride * (h + 4)]; + const uint8_t *const pri_taps = cdef_pri_taps[(pri_strength >> (BITDEPTH - 8)) & 1]; + const uint8_t *const sec_taps = cdef_sec_taps[(pri_strength >> (BITDEPTH - 8)) & 1]; + + // fill extended input buffer + int x_start = -2, x_end = w + 2, y_start = -2, y_end = h + 2; + if (!(edges & HAVE_TOP)) { + fill(tmp, tmp_stride, w + 4, 2); + y_start = 0; + } + if (!(edges & HAVE_BOTTOM)) { + fill(tmp + (h + 2) * tmp_stride, tmp_stride, w + 4, 2); + y_end -= 2; + } + if (!(edges & HAVE_LEFT)) { + fill(tmp + (2 + y_start) * tmp_stride, tmp_stride, 2, y_end - y_start); + x_start = 0; + } + if (!(edges & HAVE_RIGHT)) { + fill(tmp + (2 + y_start) * tmp_stride + w + 2, tmp_stride, + 2, y_end - y_start); + x_end -= 2; + } + for (int y = y_start; y < 0; y++) + for (int x = x_start; x < x_end; x++) + tmp[(y + 2) * tmp_stride + (x + 2)] = top[y & 1][x]; + for (int y = 0; y < y_end; y++) + for (int x = x_start; x < x_end; x++) + tmp[(y + 2) * tmp_stride + (x + 2)] = dst[y * PXSTRIDE(dst_stride) + x]; + + // run actual filter + for (int y = 0; y < h; y++) { + for (int x = 0; x < w; x++) { + int sum = 0; + const int px = dst[y * PXSTRIDE(dst_stride) + x]; + int max = px, min = px; + for (int k = 0; k < 2; k++) { +#define extpx(y, x) tmp[((y) + 2) * tmp_stride + ((x) + 2)] + const int8_t *const off1 = cdef_directions[dir][k]; + const int p0 = extpx(y + off1[0], x + off1[1]); + const int p1 = extpx(y - off1[0], x - off1[1]); + sum += pri_taps[k] * constrain(p0 - px, pri_strength, damping); + sum += pri_taps[k] * constrain(p1 - px, pri_strength, damping); + if (p0 != CDEF_VERY_LARGE) max = imax(p0, max); + if (p1 != CDEF_VERY_LARGE) max = imax(p1, max); + min = imin(p0, min); + min = imin(p1, min); + const int8_t *const off2 = cdef_directions[(dir + 2) & 7][k]; + const int s0 = extpx(y + off2[0], x + off2[1]); + const int s1 = extpx(y - off2[0], x - off2[1]); + const int8_t *const off3 = cdef_directions[(dir + 6) & 7][k]; + const int s2 = extpx(y + off3[0], x + off3[1]); + const int s3 = extpx(y - off3[0], x - off3[1]); +#undef extpx + if (s0 != CDEF_VERY_LARGE) max = imax(s0, max); + if (s1 != CDEF_VERY_LARGE) max = imax(s1, max); + if (s2 != CDEF_VERY_LARGE) max = imax(s2, max); + if (s3 != CDEF_VERY_LARGE) max = imax(s3, max); + min = imin(s0, min); + min = imin(s1, min); + min = imin(s2, min); + min = imin(s3, min); + sum += sec_taps[k] * constrain(s0 - px, sec_strength, damping); + sum += sec_taps[k] * constrain(s1 - px, sec_strength, damping); + sum += sec_taps[k] * constrain(s2 - px, sec_strength, damping); + sum += sec_taps[k] * constrain(s3 - px, sec_strength, damping); + } + dst[y * PXSTRIDE(dst_stride) + x] = + iclip(px + ((8 + sum - (sum < 0)) >> 4), min, max); + } + } +} + +/* + * </code partially copied from libaom> + */ + +#define cdef_fn(w, h) \ +static void cdef_filter_block_##w##x##h##_c(pixel *const dst, \ + const ptrdiff_t stride, \ + /*const*/ pixel *const top[2], \ + const int pri_strength, \ + const int sec_strength, \ + const int dir, \ + const int damping, \ + const enum CdefEdgeFlags edges) \ +{ \ + cdef_filter_block_c(dst, stride, top, w, h, pri_strength, sec_strength, \ + dir, damping, edges); \ +} + +cdef_fn(4, 4); +cdef_fn(4, 8); +cdef_fn(8, 8); + +/* + * <code copied from libaom> + */ + +/* Detect direction. 0 means 45-degree up-right, 2 is horizontal, and so on. + The search minimizes the weighted variance along all the lines in a + particular direction, i.e. the squared error between the input and a + "predicted" block where each pixel is replaced by the average along a line + in a particular direction. Since each direction have the same sum(x^2) term, + that term is never computed. See Section 2, step 2, of: + http://jmvalin.ca/notes/intra_paint.pdf */ +static const uint16_t div_table[] = { + 0, 840, 420, 280, 210, 168, 140, 120, 105 +}; +static int cdef_find_dir_c(const pixel *img, const ptrdiff_t stride, + unsigned *const var) +{ + int i; + int32_t cost[8] = { 0 }; + int partial[8][15] = { { 0 } }; + int32_t best_cost = 0; + int best_dir = 0; + /* Instead of dividing by n between 2 and 8, we multiply by 3*5*7*8/n. + The output is then 840 times larger, but we don't care for finding + the max. */ + for (i = 0; i < 8; i++) { + int j; + for (j = 0; j < 8; j++) { + int x; + /* We subtract 128 here to reduce the maximum range of the squared + partial sums. */ + x = (img[i * PXSTRIDE(stride) + j] >> (BITDEPTH - 8)) - 128; + partial[0][i + j] += x; + partial[1][i + j / 2] += x; + partial[2][i] += x; + partial[3][3 + i - j / 2] += x; + partial[4][7 + i - j] += x; + partial[5][3 - i / 2 + j] += x; + partial[6][j] += x; + partial[7][i / 2 + j] += x; + } + } + for (i = 0; i < 8; i++) { + cost[2] += partial[2][i] * partial[2][i]; + cost[6] += partial[6][i] * partial[6][i]; + } + cost[2] *= div_table[8]; + cost[6] *= div_table[8]; + for (i = 0; i < 7; i++) { + cost[0] += (partial[0][i] * partial[0][i] + + partial[0][14 - i] * partial[0][14 - i]) * + div_table[i + 1]; + cost[4] += (partial[4][i] * partial[4][i] + + partial[4][14 - i] * partial[4][14 - i]) * + div_table[i + 1]; + } + cost[0] += partial[0][7] * partial[0][7] * div_table[8]; + cost[4] += partial[4][7] * partial[4][7] * div_table[8]; + for (i = 1; i < 8; i += 2) { + int j; + for (j = 0; j < 4 + 1; j++) { + cost[i] += partial[i][3 + j] * partial[i][3 + j]; + } + cost[i] *= div_table[8]; + for (j = 0; j < 4 - 1; j++) { + cost[i] += (partial[i][j] * partial[i][j] + + partial[i][10 - j] * partial[i][10 - j]) * + div_table[2 * j + 2]; + } + } + for (i = 0; i < 8; i++) { + if (cost[i] > best_cost) { + best_cost = cost[i]; + best_dir = i; + } + } + /* Difference between the optimal variance and the variance along the + orthogonal direction. Again, the sum(x^2) terms cancel out. */ + *var = best_cost - cost[(best_dir + 4) & 7]; + /* We'd normally divide by 840, but dividing by 1024 is close enough + for what we're going to do with this. */ + *var >>= 10; + return best_dir; +} + +/* + * </code copied from libaom> + */ + +void bitfn(dav1d_cdef_dsp_init)(Dav1dCdefDSPContext *const c) { + c->dir = cdef_find_dir_c; + c->fb[0] = cdef_filter_block_8x8_c; + c->fb[1] = cdef_filter_block_4x8_c; + c->fb[2] = cdef_filter_block_4x4_c; +} diff --git a/src/cdef.h b/src/cdef.h new file mode 100644 index 0000000..9573962 --- /dev/null +++ b/src/cdef.h @@ -0,0 +1,62 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_SRC_CDEF_H__ +#define __DAV1D_SRC_CDEF_H__ + +#include <stddef.h> +#include <stdint.h> + +#include "common/bitdepth.h" + +enum CdefEdgeFlags { + HAVE_LEFT = 1 << 0, + HAVE_RIGHT = 1 << 1, + HAVE_TOP = 1 << 2, + HAVE_BOTTOM = 1 << 3, +}; + +// CDEF operates entirely on pre-filter data; if bottom/right edges are +// present (according to $edges), then the pre-filter data is located in +// $dst. However, the edge pixels above $dst may be post-filter, so in +// order to get access to pre-filter top pixels, use $top. +typedef void (*cdef_fn)(pixel *dst, ptrdiff_t stride, + /*const*/ pixel *const top[2], + int pri_strength, int sec_strength, + int dir, int damping, enum CdefEdgeFlags edges); +typedef int (*cdef_dir_fn)(const pixel *dst, ptrdiff_t stride, + unsigned *var); + +typedef struct Dav1dCdefDSPContext { + cdef_dir_fn dir; + cdef_fn fb[3 /* 444/luma, 422, 420 */]; +} Dav1dCdefDSPContext; + +void dav1d_cdef_dsp_init_8bpc(Dav1dCdefDSPContext *c); +void dav1d_cdef_dsp_init_10bpc(Dav1dCdefDSPContext *c); + +#endif /* __DAV1D_SRC_CDEF_H__ */ diff --git a/src/cdef_apply.c b/src/cdef_apply.c new file mode 100644 index 0000000..d794da3 --- /dev/null +++ b/src/cdef_apply.c @@ -0,0 +1,237 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <string.h> + +#include "common/intops.h" + +#include "src/cdef_apply.h" + +static void backup2lines(pixel *const dst[3][2], + /*const*/ pixel *const src[3], + const ptrdiff_t src_stride[2], int y_off, int w, + const enum Dav1dPixelLayout layout) +{ + pixel_copy(dst[0][0], src[0] + (y_off - 2) * PXSTRIDE(src_stride[0]), w); + pixel_copy(dst[0][1], src[0] + (y_off - 1) * PXSTRIDE(src_stride[0]), w); + + if (layout == DAV1D_PIXEL_LAYOUT_I400) return; + const int ss_ver = layout == DAV1D_PIXEL_LAYOUT_I420; + const int ss_hor = layout != DAV1D_PIXEL_LAYOUT_I444; + + w >>= ss_hor; + y_off >>= ss_ver; + pixel_copy(dst[1][0], src[1] + (y_off - 2) * PXSTRIDE(src_stride[1]), w); + pixel_copy(dst[1][1], src[1] + (y_off - 1) * PXSTRIDE(src_stride[1]), w); + pixel_copy(dst[2][0], src[2] + (y_off - 2) * PXSTRIDE(src_stride[1]), w); + pixel_copy(dst[2][1], src[2] + (y_off - 1) * PXSTRIDE(src_stride[1]), w); +} + +static void backup2x8(pixel dst[3][8][2], + /*const*/ pixel *const src[3], + const ptrdiff_t src_stride[2], int x_off, + const enum Dav1dPixelLayout layout) +{ + for (int y = 0, y_off = 0; y < 8; y++, y_off += PXSTRIDE(src_stride[0])) + pixel_copy(dst[0][y], &src[0][y_off + x_off - 2], 2); + + if (layout == DAV1D_PIXEL_LAYOUT_I400) return; + const int ss_ver = layout == DAV1D_PIXEL_LAYOUT_I420; + const int ss_hor = layout != DAV1D_PIXEL_LAYOUT_I444; + + x_off >>= ss_hor; + for (int y = 0, y_off = 0; y < (8 >> ss_ver); y++, y_off += PXSTRIDE(src_stride[1])) { + pixel_copy(dst[1][y], &src[1][y_off + x_off - 2], 2); + pixel_copy(dst[2][y], &src[2][y_off + x_off - 2], 2); + } +} + +static void restore2x8(pixel *const dst[3], + const ptrdiff_t dst_stride[2], + const pixel src[3][8][2], const enum Dav1dPixelLayout layout) +{ + for (int y = 0, y_off = 0; y < 8; y++, y_off += PXSTRIDE(dst_stride[0])) + pixel_copy(&dst[0][y_off - 2], src[0][y], 2); + + if (layout == DAV1D_PIXEL_LAYOUT_I400) return; + const int ss_ver = layout == DAV1D_PIXEL_LAYOUT_I420; + + for (int y = 0, y_off = 0; y < (8 >> ss_ver); y++, y_off += PXSTRIDE(dst_stride[1])) { + pixel_copy(&dst[1][y_off - 2], src[1][y], 2); + pixel_copy(&dst[2][y_off - 2], src[2][y], 2); + } +} + +static int adjust_strength(const int strength, const unsigned var) { + if (!var) return 0; + const int i = var >> 6 ? imin(ulog2(var >> 6), 12) : 0; + return (strength * (4 + i) + 8) >> 4; +} + +void bytefn(dav1d_cdef_brow)(Dav1dFrameContext *const f, + pixel *const p[3], + const Av1Filter *const lflvl, + const int by_start, const int by_end) +{ + const Dav1dDSPContext *const dsp = f->dsp; + enum CdefEdgeFlags edges = HAVE_BOTTOM | (by_start > 0 ? HAVE_TOP : 0); + pixel *ptrs[3] = { p[0], p[1], p[2] }; + const int sbsz = 16; + const int sb64w = f->sb128w << 1; + const int damping = f->frame_hdr.cdef.damping + BITDEPTH - 8; + const enum Dav1dPixelLayout layout = f->cur.p.p.layout; + const int uv_idx = DAV1D_PIXEL_LAYOUT_I444 - layout; + const int has_chroma = layout != DAV1D_PIXEL_LAYOUT_I400; + const int ss_ver = layout == DAV1D_PIXEL_LAYOUT_I420; + const int ss_hor = layout != DAV1D_PIXEL_LAYOUT_I444; + + // FIXME a design improvement that could be made here is to keep a set of + // flags for each block position on whether the block was filtered; if not, + // the backup of pre-filter data is empty, and the restore is therefore + // unnecessary as well. + + for (int by = by_start; by < by_end; by += 2, edges |= HAVE_TOP) { + const int tf = f->lf.top_pre_cdef_toggle; + if (by + 2 >= f->bh) edges &= ~HAVE_BOTTOM; + + if (edges & HAVE_BOTTOM) { + // backup pre-filter data for next iteration + backup2lines(f->lf.cdef_line_ptr[!tf], ptrs, f->cur.p.stride, + 8, f->bw * 4, layout); + } + + pixel lr_bak[2 /* idx */][3 /* plane */][8 /* y */][2 /* x */]; + pixel *iptrs[3] = { ptrs[0], ptrs[1], ptrs[2] }; + edges &= ~HAVE_LEFT; + edges |= HAVE_RIGHT; + for (int sbx = 0, last_skip = 1; sbx < sb64w; sbx++, edges |= HAVE_LEFT) { + const int sb128x = sbx >>1; + const int sb64_idx = ((by & sbsz) >> 3) + (sbx & 1); + const int cdef_idx = lflvl[sb128x].cdef_idx[sb64_idx]; + if (cdef_idx == -1 || + (!f->frame_hdr.cdef.y_strength[cdef_idx] && + !f->frame_hdr.cdef.uv_strength[cdef_idx])) + { + last_skip = 1; + goto next_sb; + } + + const int y_lvl = f->frame_hdr.cdef.y_strength[cdef_idx]; + const int uv_lvl = f->frame_hdr.cdef.uv_strength[cdef_idx]; + pixel *bptrs[3] = { iptrs[0], iptrs[1], iptrs[2] }; + for (int bx = sbx * sbsz; bx < imin((sbx + 1) * sbsz, f->bw); + bx += 2, edges |= HAVE_LEFT) + { + if (bx + 2 >= f->bw) edges &= ~HAVE_RIGHT; + + // check if this 8x8 block had any coded coefficients; if not, + // go to the next block + const unsigned bx_mask = 3U << (bx & 30); + const int by_idx = by & 30; + if (!((lflvl[sb128x].noskip_mask[by_idx + 0] | + lflvl[sb128x].noskip_mask[by_idx + 1]) & bx_mask)) + { + last_skip = 1; + goto next_b; + } + + if (!last_skip) { + // backup post-filter data (will be restored at the end) + backup2x8(lr_bak[1], bptrs, f->cur.p.stride, 0, layout); + + // restore pre-filter data from last iteration + restore2x8(bptrs, f->cur.p.stride, lr_bak[0], layout); + } + if (edges & HAVE_RIGHT) { + // backup pre-filter data for next iteration + backup2x8(lr_bak[0], bptrs, f->cur.p.stride, 8, layout); + } + + // the actual filter + const int y_pri_lvl = (y_lvl >> 2) << (BITDEPTH - 8); + int y_sec_lvl = y_lvl & 3; + y_sec_lvl += y_sec_lvl == 3; + y_sec_lvl <<= BITDEPTH - 8; + const int uv_pri_lvl = (uv_lvl >> 2) << (BITDEPTH - 8); + int uv_sec_lvl = uv_lvl & 3; + uv_sec_lvl += uv_sec_lvl == 3; + uv_sec_lvl <<= BITDEPTH - 8; + unsigned variance; + const int dir = dsp->cdef.dir(bptrs[0], f->cur.p.stride[0], + &variance); + if (y_lvl) { + dsp->cdef.fb[0](bptrs[0], f->cur.p.stride[0], + (pixel *const [2]) { + &f->lf.cdef_line_ptr[tf][0][0][bx * 4], + &f->lf.cdef_line_ptr[tf][0][1][bx * 4], + }, + adjust_strength(y_pri_lvl, variance), + y_sec_lvl, y_pri_lvl ? dir : 0, + damping, edges); + } + if (uv_lvl && has_chroma) { + const int uvdir = + f->cur.p.p.layout != DAV1D_PIXEL_LAYOUT_I422 ? dir : + ((uint8_t[]) { 7, 0, 2, 4, 5, 6, 6, 6 })[dir]; + for (int pl = 1; pl <= 2; pl++) { + dsp->cdef.fb[uv_idx](bptrs[pl], f->cur.p.stride[1], + (pixel *const [2]) { + &f->lf.cdef_line_ptr[tf][pl][0][bx * 4 >> ss_hor], + &f->lf.cdef_line_ptr[tf][pl][1][bx * 4 >> ss_hor], + }, + uv_pri_lvl, uv_sec_lvl, + uv_pri_lvl ? uvdir : 0, + damping - 1, edges); + } + } + + if (!last_skip) { + // restore post-filter data from the beginning of this loop + restore2x8(bptrs, f->cur.p.stride, lr_bak[1], layout); + } + last_skip = 0; + + next_b: + bptrs[0] += 8; + bptrs[1] += 8 >> ss_hor; + bptrs[2] += 8 >> ss_hor; + } + + next_sb: + iptrs[0] += sbsz * 4; + iptrs[1] += sbsz * 4 >> ss_hor; + iptrs[2] += sbsz * 4 >> ss_hor; + } + + ptrs[0] += 8 * PXSTRIDE(f->cur.p.stride[0]); + ptrs[1] += 8 * PXSTRIDE(f->cur.p.stride[1]) >> ss_ver; + ptrs[2] += 8 * PXSTRIDE(f->cur.p.stride[1]) >> ss_ver; + f->lf.top_pre_cdef_toggle ^= 1; + } +} diff --git a/src/cdef_apply.h b/src/cdef_apply.h new file mode 100644 index 0000000..912812d --- /dev/null +++ b/src/cdef_apply.h @@ -0,0 +1,38 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_SRC_CDEF_APPLY_H__ +#define __DAV1D_SRC_CDEF_APPLY_H__ + +#include "common/bitdepth.h" + +#include "src/internal.h" + +void bytefn(dav1d_cdef_brow)(Dav1dFrameContext *f, pixel *const p[3], + const Av1Filter *lflvl, int by_start, int by_end); + +#endif /* __DAV1D_SRC_CDEF_APPLY_H__ */ diff --git a/src/cdf.c b/src/cdf.c new file mode 100644 index 0000000..71bc237 --- /dev/null +++ b/src/cdf.c @@ -0,0 +1,4251 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <assert.h> +#include <pthread.h> +#include <string.h> + +#include "common/intops.h" + +#include "src/cdf.h" + +#define AOM_ICDF(x) (32768-(x)) + +#define AOM_CDF2(a) \ + AOM_ICDF(a) +#define AOM_CDF3(a,b) \ + AOM_ICDF(a), AOM_ICDF(b) +#define AOM_CDF4(a,b,c) \ + AOM_ICDF(a), AOM_CDF3(b,c) +#define AOM_CDF5(a,b,c,d) \ + AOM_ICDF(a), AOM_CDF4(b,c,d) +#define AOM_CDF6(a,b,c,d,e) \ + AOM_ICDF(a), AOM_CDF5(b,c,d,e) +#define AOM_CDF7(a,b,c,d,e,f) \ + AOM_ICDF(a), AOM_CDF6(b,c,d,e,f) +#define AOM_CDF8(a,b,c,d,e,f,g) \ + AOM_ICDF(a), AOM_CDF7(b,c,d,e,f,g) +#define AOM_CDF9(a,b,c,d,e,f,g,h) \ + AOM_ICDF(a), AOM_CDF8(b,c,d,e,f,g,h) +#define AOM_CDF10(a,b,c,d,e,f,g,h,i) \ + AOM_ICDF(a), AOM_CDF9(b,c,d,e,f,g,h,i) +#define AOM_CDF11(a,b,c,d,e,f,g,h,i,j) \ + AOM_ICDF(a), AOM_CDF10(b,c,d,e,f,g,h,i,j) +#define AOM_CDF12(a,b,c,d,e,f,g,h,i,j,k) \ + AOM_ICDF(a), AOM_CDF11(b,c,d,e,f,g,h,i,j,k) +#define AOM_CDF13(a,b,c,d,e,f,g,h,i,j,k,l) \ + AOM_ICDF(a), AOM_CDF12(b,c,d,e,f,g,h,i,j,k,l) +#define AOM_CDF14(a,b,c,d,e,f,g,h,i,j,k,l,m) \ + AOM_ICDF(a), AOM_CDF13(b,c,d,e,f,g,h,i,j,k,l,m) +#define AOM_CDF15(a,b,c,d,e,f,g,h,i,j,k,l,m,n) \ + AOM_ICDF(a), AOM_CDF14(b,c,d,e,f,g,h,i,j,k,l,m,n) +#define AOM_CDF16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) \ + AOM_ICDF(a), AOM_CDF15(b,c,d,e,f,g,h,i,j,k,l,m,n,o) + +static const CdfModeContext av1_default_cdf = { + .y_mode = { + { AOM_CDF13(22801, 23489, 24293, 24756, 25601, 26123, + 26606, 27418, 27945, 29228, 29685, 30349) }, + { AOM_CDF13(18673, 19845, 22631, 23318, 23950, 24649, + 25527, 27364, 28152, 29701, 29984, 30852) }, + { AOM_CDF13(19770, 20979, 23396, 23939, 24241, 24654, + 25136, 27073, 27830, 29360, 29730, 30659) }, + { AOM_CDF13(20155, 21301, 22838, 23178, 23261, 23533, + 23703, 24804, 25352, 26575, 27016, 28049) }, + }, .use_filter_intra = { + [BS_4x4] = { AOM_CDF2(4621) }, + [BS_4x8] = { AOM_CDF2(6743) }, + [BS_8x4] = { AOM_CDF2(5893) }, + [BS_8x8] = { AOM_CDF2(7866) }, + [BS_8x16] = { AOM_CDF2(12551) }, + [BS_16x8] = { AOM_CDF2(9394) }, + [BS_16x16] = { AOM_CDF2(12408) }, + [BS_16x32] = { AOM_CDF2(14301) }, + [BS_32x16] = { AOM_CDF2(12756) }, + [BS_32x32] = { AOM_CDF2(22343) }, + [BS_32x64] = { AOM_CDF2(16384) }, + [BS_64x32] = { AOM_CDF2(16384) }, + [BS_64x64] = { AOM_CDF2(16384) }, + [BS_64x128] = { AOM_CDF2(16384) }, + [BS_128x64] = { AOM_CDF2(16384) }, + [BS_128x128] = { AOM_CDF2(16384) }, + [BS_4x16] = { AOM_CDF2(12770) }, + [BS_16x4] = { AOM_CDF2(10368) }, + [BS_8x32] = { AOM_CDF2(20229) }, + [BS_32x8] = { AOM_CDF2(18101) }, + [BS_16x64] = { AOM_CDF2(16384) }, + [BS_64x16] = { AOM_CDF2(16384) }, + }, .filter_intra = { + AOM_CDF5(8949, 12776, 17211, 29558), + }, .uv_mode = { + { + { AOM_CDF13(22631, 24152, 25378, 25661, 25986, 26520, 27055, 27923, + 28244, 30059, 30941, 31961) }, + { AOM_CDF13(9513, 26881, 26973, 27046, 27118, 27664, 27739, 27824, + 28359, 29505, 29800, 31796) }, + { AOM_CDF13(9845, 9915, 28663, 28704, 28757, 28780, 29198, 29822, + 29854, 30764, 31777, 32029) }, + { AOM_CDF13(13639, 13897, 14171, 25331, 25606, 25727, 25953, 27148, + 28577, 30612, 31355, 32493) }, + { AOM_CDF13(9764, 9835, 9930, 9954, 25386, 27053, 27958, 28148, + 28243, 31101, 31744, 32363) }, + { AOM_CDF13(11825, 13589, 13677, 13720, 15048, 29213, 29301, 29458, + 29711, 31161, 31441, 32550) }, + { AOM_CDF13(14175, 14399, 16608, 16821, 17718, 17775, 28551, 30200, + 30245, 31837, 32342, 32667) }, + { AOM_CDF13(12885, 13038, 14978, 15590, 15673, 15748, 16176, 29128, + 29267, 30643, 31961, 32461) }, + { AOM_CDF13(12026, 13661, 13874, 15305, 15490, 15726, 15995, 16273, + 28443, 30388, 30767, 32416) }, + { AOM_CDF13(19052, 19840, 20579, 20916, 21150, 21467, 21885, 22719, + 23174, 28861, 30379, 32175) }, + { AOM_CDF13(18627, 19649, 20974, 21219, 21492, 21816, 22199, 23119, + 23527, 27053, 31397, 32148) }, + { AOM_CDF13(17026, 19004, 19997, 20339, 20586, 21103, 21349, 21907, + 22482, 25896, 26541, 31819) }, + { AOM_CDF13(12124, 13759, 14959, 14992, 15007, 15051, 15078, 15166, + 15255, 15753, 16039, 16606) } + }, { + { AOM_CDF14(10407, 11208, 12900, 13181, 13823, 14175, 14899, 15656, + 15986, 20086, 20995, 22455, 24212) }, + { AOM_CDF14(4532, 19780, 20057, 20215, 20428, 21071, 21199, 21451, + 22099, 24228, 24693, 27032, 29472) }, + { AOM_CDF14(5273, 5379, 20177, 20270, 20385, 20439, 20949, 21695, + 21774, 23138, 24256, 24703, 26679) }, + { AOM_CDF14(6740, 7167, 7662, 14152, 14536, 14785, 15034, 16741, + 18371, 21520, 22206, 23389, 24182) }, + { AOM_CDF14(4987, 5368, 5928, 6068, 19114, 20315, 21857, 22253, + 22411, 24911, 25380, 26027, 26376) }, + { AOM_CDF14(5370, 6889, 7247, 7393, 9498, 21114, 21402, 21753, + 21981, 24780, 25386, 26517, 27176) }, + { AOM_CDF14(4816, 4961, 7204, 7326, 8765, 8930, 20169, 20682, + 20803, 23188, 23763, 24455, 24940) }, + { AOM_CDF14(6608, 6740, 8529, 9049, 9257, 9356, 9735, 18827, + 19059, 22336, 23204, 23964, 24793) }, + { AOM_CDF14(5998, 7419, 7781, 8933, 9255, 9549, 9753, 10417, + 18898, 22494, 23139, 24764, 25989) }, + { AOM_CDF14(10660, 11298, 12550, 12957, 13322, 13624, 14040, 15004, + 15534, 20714, 21789, 23443, 24861) }, + { AOM_CDF14(10522, 11530, 12552, 12963, 13378, 13779, 14245, 15235, + 15902, 20102, 22696, 23774, 25838) }, + { AOM_CDF14(10099, 10691, 12639, 13049, 13386, 13665, 14125, 15163, + 15636, 19676, 20474, 23519, 25208) }, + { AOM_CDF14(3144, 5087, 7382, 7504, 7593, 7690, 7801, 8064, + 8232, 9248, 9875, 10521, 29048) } + } + }, .angle_delta = { + { AOM_CDF7(2180, 5032, 7567, 22776, 26989, 30217) }, + { AOM_CDF7(2301, 5608, 8801, 23487, 26974, 30330) }, + { AOM_CDF7(3780, 11018, 13699, 19354, 23083, 31286) }, + { AOM_CDF7(4581, 11226, 15147, 17138, 21834, 28397) }, + { AOM_CDF7(1737, 10927, 14509, 19588, 22745, 28823) }, + { AOM_CDF7(2664, 10176, 12485, 17650, 21600, 30495) }, + { AOM_CDF7(2240, 11096, 15453, 20341, 22561, 28917) }, + { AOM_CDF7(3605, 10428, 12459, 17676, 21244, 30655) } + }, .filter = { + { + { AOM_CDF3(31935, 32720) }, + { AOM_CDF3(5568, 32719) }, + { AOM_CDF3(422, 2938) }, + { AOM_CDF3(28244, 32608) }, + { AOM_CDF3(31206, 31953) }, + { AOM_CDF3(4862, 32121) }, + { AOM_CDF3(770, 1152) }, + { AOM_CDF3(20889, 25637) }, + }, { + { AOM_CDF3(31910, 32724) }, + { AOM_CDF3(4120, 32712) }, + { AOM_CDF3(305, 2247) }, + { AOM_CDF3(27403, 32636) }, + { AOM_CDF3(31022, 32009) }, + { AOM_CDF3(2963, 32093) }, + { AOM_CDF3(601, 943) }, + { AOM_CDF3(14969, 21398) } + } + }, .newmv_mode = { + { AOM_CDF2(24035) }, + { AOM_CDF2(16630) }, + { AOM_CDF2(15339) }, + { AOM_CDF2(8386) }, + { AOM_CDF2(12222) }, + { AOM_CDF2(4676) }, + }, .globalmv_mode = { + { AOM_CDF2(2175) }, + { AOM_CDF2(1054) } + }, .refmv_mode = { + { AOM_CDF2(23974) }, + { AOM_CDF2(24188) }, + { AOM_CDF2(17848) }, + { AOM_CDF2(28622) }, + { AOM_CDF2(24312) }, + { AOM_CDF2(19923) } + }, .drl_bit = { + { AOM_CDF2(13104) }, + { AOM_CDF2(24560) }, + { AOM_CDF2(18945) } + }, .comp_inter_mode = { + { AOM_CDF8(7760, 13823, 15808, 17641, 19156, 20666, 26891) }, + { AOM_CDF8(10730, 19452, 21145, 22749, 24039, 25131, 28724) }, + { AOM_CDF8(10664, 20221, 21588, 22906, 24295, 25387, 28436) }, + { AOM_CDF8(13298, 16984, 20471, 24182, 25067, 25736, 26422) }, + { AOM_CDF8(18904, 23325, 25242, 27432, 27898, 28258, 30758) }, + { AOM_CDF8(10725, 17454, 20124, 22820, 24195, 25168, 26046) }, + { AOM_CDF8(17125, 24273, 25814, 27492, 28214, 28704, 30592) }, + { AOM_CDF8(13046, 23214, 24505, 25942, 27435, 28442, 29330) } + }, .intra = { + { AOM_CDF2(806) }, + { AOM_CDF2(16662) }, + { AOM_CDF2(20186) }, + { AOM_CDF2(26538) } + }, .comp = { + { AOM_CDF2(26828) }, + { AOM_CDF2(24035) }, + { AOM_CDF2(12031) }, + { AOM_CDF2(10640) }, + { AOM_CDF2(2901) } + }, .comp_dir = { + { AOM_CDF2(1198) }, + { AOM_CDF2(2070) }, + { AOM_CDF2(9166) }, + { AOM_CDF2(7499) }, + { AOM_CDF2(22475) } + }, .jnt_comp = { + { AOM_CDF2(18244) }, + { AOM_CDF2(12865) }, + { AOM_CDF2(7053) }, + { AOM_CDF2(13259) }, + { AOM_CDF2(9334) }, + { AOM_CDF2(4644) } + }, .mask_comp = { + { AOM_CDF2(26607) }, + { AOM_CDF2(22891) }, + { AOM_CDF2(18840) }, + { AOM_CDF2(24594) }, + { AOM_CDF2(19934) }, + { AOM_CDF2(22674) } + }, .wedge_comp = { + { AOM_CDF2(23431) }, + { AOM_CDF2(13171) }, + { AOM_CDF2(11470) }, + { AOM_CDF2(9770) }, + { AOM_CDF2(9100) }, + { AOM_CDF2(8233) }, + { AOM_CDF2(6172) }, + { AOM_CDF2(11820) }, + { AOM_CDF2(7701) }, + }, .wedge_idx = { + { AOM_CDF16(2438, 4440, 6599, 8663, 11005, 12874, 15751, 18094, + 20359, 22362, 24127, 25702, 27752, 29450, 31171) }, + { AOM_CDF16(806, 3266, 6005, 6738, 7218, 7367, 7771, 14588, + 16323, 17367, 18452, 19422, 22839, 26127, 29629) }, + { AOM_CDF16(2779, 3738, 4683, 7213, 7775, 8017, 8655, 14357, + 17939, 21332, 24520, 27470, 29456, 30529, 31656) }, + { AOM_CDF16(1684, 3625, 5675, 7108, 9302, 11274, 14429, 17144, + 19163, 20961, 22884, 24471, 26719, 28714, 30877) }, + { AOM_CDF16(1142, 3491, 6277, 7314, 8089, 8355, 9023, 13624, + 15369, 16730, 18114, 19313, 22521, 26012, 29550) }, + { AOM_CDF16(2742, 4195, 5727, 8035, 8980, 9336, 10146, 14124, + 17270, 20533, 23434, 25972, 27944, 29570, 31416) }, + { AOM_CDF16(1727, 3948, 6101, 7796, 9841, 12344, 15766, 18944, + 20638, 22038, 23963, 25311, 26988, 28766, 31012) }, + { AOM_CDF16(154, 987, 1925, 2051, 2088, 2111, 2151, 23033, + 23703, 24284, 24985, 25684, 27259, 28883, 30911) }, + { AOM_CDF16(1135, 1322, 1493, 2635, 2696, 2737, 2770, 21016, + 22935, 25057, 27251, 29173, 30089, 30960, 31933) }, + }, .interintra = { + { AOM_CDF2(16384) }, + { AOM_CDF2(26887) }, + { AOM_CDF2(27597) }, + { AOM_CDF2(30237) } + }, .interintra_mode = { + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(1875, 11082, 27332) }, + { AOM_CDF4(2473, 9996, 26388) }, + { AOM_CDF4(4238, 11537, 25926) } + }, .interintra_wedge = { + { AOM_CDF2(20036) }, + { AOM_CDF2(24957) }, + { AOM_CDF2(26704) }, + { AOM_CDF2(27530) }, + { AOM_CDF2(29564) }, + { AOM_CDF2(29444) }, + { AOM_CDF2(26872) }, + }, .ref = { + { + { AOM_CDF2(4897) }, + { AOM_CDF2(16973) }, + { AOM_CDF2(29744) }, + }, { + { AOM_CDF2(1555) }, + { AOM_CDF2(16751) }, + { AOM_CDF2(30279) }, + }, { + { AOM_CDF2(4236) }, + { AOM_CDF2(19647) }, + { AOM_CDF2(31194) }, + }, { + { AOM_CDF2(8650) }, + { AOM_CDF2(24773) }, + { AOM_CDF2(31895) }, + }, { + { AOM_CDF2(904) }, + { AOM_CDF2(11014) }, + { AOM_CDF2(26875) }, + }, { + { AOM_CDF2(1444) }, + { AOM_CDF2(15087) }, + { AOM_CDF2(30304) }, + } + }, .comp_fwd_ref = { + { + { AOM_CDF2(4946) }, + { AOM_CDF2(19891) }, + { AOM_CDF2(30731) }, + }, { + { AOM_CDF2(9468) }, + { AOM_CDF2(22441) }, + { AOM_CDF2(31059) }, + }, { + { AOM_CDF2(1503) }, + { AOM_CDF2(15160) }, + { AOM_CDF2(27544) }, + } + }, .comp_bwd_ref = { + { + { AOM_CDF2(2235) }, + { AOM_CDF2(17182) }, + { AOM_CDF2(30606) }, + }, { + { AOM_CDF2(1423) }, + { AOM_CDF2(15175) }, + { AOM_CDF2(30489) }, + } + }, .comp_uni_ref = { + { + { AOM_CDF2(5284) }, + { AOM_CDF2(23152) }, + { AOM_CDF2(31774) }, + }, { + { AOM_CDF2(3865) }, + { AOM_CDF2(14173) }, + { AOM_CDF2(25120) }, + }, { + { AOM_CDF2(3128) }, + { AOM_CDF2(15270) }, + { AOM_CDF2(26710) }, + } + }, .txsz = { + { + { AOM_CDF2(19968) }, + { AOM_CDF2(19968) }, + { AOM_CDF2(24320) } + }, { + { AOM_CDF3(12272, 30172) }, + { AOM_CDF3(12272, 30172) }, + { AOM_CDF3(18677, 30848) } + }, { + { AOM_CDF3(12986, 15180) }, + { AOM_CDF3(12986, 15180) }, + { AOM_CDF3(24302, 25602) } + }, { + { AOM_CDF3(5782, 11475) }, + { AOM_CDF3(5782, 11475) }, + { AOM_CDF3(16803, 22759) } + } + }, .txpart = { + { { AOM_CDF2(28581) }, { AOM_CDF2(23846) }, { AOM_CDF2(20847) }, }, + { { AOM_CDF2(24315) }, { AOM_CDF2(18196) }, { AOM_CDF2(12133) }, }, + { { AOM_CDF2(18791) }, { AOM_CDF2(10887) }, { AOM_CDF2(11005) }, }, + { { AOM_CDF2(27179) }, { AOM_CDF2(20004) }, { AOM_CDF2(11281) }, }, + { { AOM_CDF2(26549) }, { AOM_CDF2(19308) }, { AOM_CDF2(14224) }, }, + { { AOM_CDF2(28015) }, { AOM_CDF2(21546) }, { AOM_CDF2(14400) }, }, + { { AOM_CDF2(28165) }, { AOM_CDF2(22401) }, { AOM_CDF2(16088) }, }, + }, .txtp_inter = { + {}, { + { AOM_CDF16(4458, 5560, 7695, 9709, 13330, 14789, 17537, 20266, + 21504, 22848, 23934, 25474, 27727, 28915, 30631) }, + { AOM_CDF16(1645, 2573, 4778, 5711, 7807, 8622, 10522, 15357, + 17674, 20408, 22517, 25010, 27116, 28856, 30749) }, + { AOM_CDF16(2048, 4096, 6144, 8192, 10240, 12288, 14336, 16384, + 18432, 20480, 22528, 24576, 26624, 28672, 30720) }, + { AOM_CDF16(2048, 4096, 6144, 8192, 10240, 12288, 14336, 16384, + 18432, 20480, 22528, 24576, 26624, 28672, 30720) }, + }, { + { AOM_CDF12(2731, 5461, 8192, 10923, 13653, 16384, 19115, 21845, + 24576, 27307, 30037) }, + { AOM_CDF12(2731, 5461, 8192, 10923, 13653, 16384, 19115, 21845, + 24576, 27307, 30037) }, + { AOM_CDF12(770, 2421, 5225, 12907, 15819, 18927, 21561, 24089, + 26595, 28526, 30529) }, + { AOM_CDF12(2731, 5461, 8192, 10923, 13653, 16384, 19115, 21845, + 24576, 27307, 30037) }, + }, { + { AOM_CDF2(16384) }, + { AOM_CDF2(4167) }, + { AOM_CDF2(1998) }, + { AOM_CDF2(748) }, + }, + }, .txtp_intra = { + {}, { + { + { AOM_CDF7(1535, 8035, 9461, 12751, 23467, 27825) }, + { AOM_CDF7(564, 3335, 9709, 10870, 18143, 28094) }, + { AOM_CDF7(672, 3247, 3676, 11982, 19415, 23127) }, + { AOM_CDF7(5279, 13885, 15487, 18044, 23527, 30252) }, + { AOM_CDF7(4423, 6074, 7985, 10416, 25693, 29298) }, + { AOM_CDF7(1486, 4241, 9460, 10662, 16456, 27694) }, + { AOM_CDF7(439, 2838, 3522, 6737, 18058, 23754) }, + { AOM_CDF7(1190, 4233, 4855, 11670, 20281, 24377) }, + { AOM_CDF7(1045, 4312, 8647, 10159, 18644, 29335) }, + { AOM_CDF7(202, 3734, 4747, 7298, 17127, 24016) }, + { AOM_CDF7(447, 4312, 6819, 8884, 16010, 23858) }, + { AOM_CDF7(277, 4369, 5255, 8905, 16465, 22271) }, + { AOM_CDF7(3409, 5436, 10599, 15599, 19687, 24040) }, + }, { + { AOM_CDF7(1870, 13742, 14530, 16498, 23770, 27698) }, + { AOM_CDF7(326, 8796, 14632, 15079, 19272, 27486) }, + { AOM_CDF7(484, 7576, 7712, 14443, 19159, 22591) }, + { AOM_CDF7(1126, 15340, 15895, 17023, 20896, 30279) }, + { AOM_CDF7(655, 4854, 5249, 5913, 22099, 27138) }, + { AOM_CDF7(1299, 6458, 8885, 9290, 14851, 25497) }, + { AOM_CDF7(311, 5295, 5552, 6885, 16107, 22672) }, + { AOM_CDF7(883, 8059, 8270, 11258, 17289, 21549) }, + { AOM_CDF7(741, 7580, 9318, 10345, 16688, 29046) }, + { AOM_CDF7(110, 7406, 7915, 9195, 16041, 23329) }, + { AOM_CDF7(363, 7974, 9357, 10673, 15629, 24474) }, + { AOM_CDF7(153, 7647, 8112, 9936, 15307, 19996) }, + { AOM_CDF7(3511, 6332, 11165, 15335, 19323, 23594) }, + }, { + { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) }, + { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) }, + { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) }, + { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) }, + { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) }, + { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) }, + { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) }, + { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) }, + { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) }, + { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) }, + { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) }, + { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) }, + { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) }, + }, { + { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) }, + { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) }, + { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) }, + { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) }, + { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) }, + { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) }, + { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) }, + { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) }, + { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) }, + { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) }, + { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) }, + { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) }, + { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) }, + }, + }, { + { + { AOM_CDF5(6554, 13107, 19661, 26214) }, + { AOM_CDF5(6554, 13107, 19661, 26214) }, + { AOM_CDF5(6554, 13107, 19661, 26214) }, + { AOM_CDF5(6554, 13107, 19661, 26214) }, + { AOM_CDF5(6554, 13107, 19661, 26214) }, + { AOM_CDF5(6554, 13107, 19661, 26214) }, + { AOM_CDF5(6554, 13107, 19661, 26214) }, + { AOM_CDF5(6554, 13107, 19661, 26214) }, + { AOM_CDF5(6554, 13107, 19661, 26214) }, + { AOM_CDF5(6554, 13107, 19661, 26214) }, + { AOM_CDF5(6554, 13107, 19661, 26214) }, + { AOM_CDF5(6554, 13107, 19661, 26214) }, + { AOM_CDF5(6554, 13107, 19661, 26214) }, + }, { + { AOM_CDF5(6554, 13107, 19661, 26214) }, + { AOM_CDF5(6554, 13107, 19661, 26214) }, + { AOM_CDF5(6554, 13107, 19661, 26214) }, + { AOM_CDF5(6554, 13107, 19661, 26214) }, + { AOM_CDF5(6554, 13107, 19661, 26214) }, + { AOM_CDF5(6554, 13107, 19661, 26214) }, + { AOM_CDF5(6554, 13107, 19661, 26214) }, + { AOM_CDF5(6554, 13107, 19661, 26214) }, + { AOM_CDF5(6554, 13107, 19661, 26214) }, + { AOM_CDF5(6554, 13107, 19661, 26214) }, + { AOM_CDF5(6554, 13107, 19661, 26214) }, + { AOM_CDF5(6554, 13107, 19661, 26214) }, + { AOM_CDF5(6554, 13107, 19661, 26214) }, + }, { + { AOM_CDF5(1127, 12814, 22772, 27483) }, + { AOM_CDF5(145, 6761, 11980, 26667) }, + { AOM_CDF5(362, 5887, 11678, 16725) }, + { AOM_CDF5(385, 15213, 18587, 30693) }, + { AOM_CDF5(25, 2914, 23134, 27903) }, + { AOM_CDF5(60, 4470, 11749, 23991) }, + { AOM_CDF5(37, 3332, 14511, 21448) }, + { AOM_CDF5(157, 6320, 13036, 17439) }, + { AOM_CDF5(119, 6719, 12906, 29396) }, + { AOM_CDF5(47, 5537, 12576, 21499) }, + { AOM_CDF5(269, 6076, 11258, 23115) }, + { AOM_CDF5(83, 5615, 12001, 17228) }, + { AOM_CDF5(1968, 5556, 12023, 18547) }, + }, { + { AOM_CDF5(6554, 13107, 19661, 26214) }, + { AOM_CDF5(6554, 13107, 19661, 26214) }, + { AOM_CDF5(6554, 13107, 19661, 26214) }, + { AOM_CDF5(6554, 13107, 19661, 26214) }, + { AOM_CDF5(6554, 13107, 19661, 26214) }, + { AOM_CDF5(6554, 13107, 19661, 26214) }, + { AOM_CDF5(6554, 13107, 19661, 26214) }, + { AOM_CDF5(6554, 13107, 19661, 26214) }, + { AOM_CDF5(6554, 13107, 19661, 26214) }, + { AOM_CDF5(6554, 13107, 19661, 26214) }, + { AOM_CDF5(6554, 13107, 19661, 26214) }, + { AOM_CDF5(6554, 13107, 19661, 26214) }, + { AOM_CDF5(6554, 13107, 19661, 26214) }, + }, + }, + }, .skip = { + { AOM_CDF2(31671) }, + { AOM_CDF2(16515) }, + { AOM_CDF2(4576) } + }, .skip_mode = { + { AOM_CDF2(32621) }, + { AOM_CDF2(20708) }, + { AOM_CDF2(8127) } + }, .partition = { + { + // 128x128 -> 64x64 + { AOM_CDF8(27899, 28219, 28529, 32484, 32539, 32619, 32639) }, + { AOM_CDF8(6607, 6990, 8268, 32060, 32219, 32338, 32371) }, + { AOM_CDF8(5429, 6676, 7122, 32027, 32227, 32531, 32582) }, + { AOM_CDF8(711, 966, 1172, 32448, 32538, 32617, 32664) }, + }, { + // 64x64 -> 32x32 + { AOM_CDF10(20137, 21547, 23078, 29566, 29837, 30261, 30524, 30892, + 31724) }, + { AOM_CDF10(6732, 7490, 9497, 27944, 28250, 28515, 28969, 29630, + 30104) }, + { AOM_CDF10(5945, 7663, 8348, 28683, 29117, 29749, 30064, 30298, + 32238) }, + { AOM_CDF10(870, 1212, 1487, 31198, 31394, 31574, 31743, 31881, + 32332) }, + }, { + // 32x32 -> 16x16 + { AOM_CDF10(18462, 20920, 23124, 27647, 28227, 29049, 29519, 30178, + 31544) }, + { AOM_CDF10(7689, 9060, 12056, 24992, 25660, 26182, 26951, 28041, + 29052) }, + { AOM_CDF10(6015, 9009, 10062, 24544, 25409, 26545, 27071, 27526, + 32047) }, + { AOM_CDF10(1394, 2208, 2796, 28614, 29061, 29466, 29840, 30185, + 31899) }, + }, { + // 16x16 -> 8x8 + { AOM_CDF10(15597, 20929, 24571, 26706, 27664, 28821, 29601, 30571, + 31902) }, + { AOM_CDF10(7925, 11043, 16785, 22470, 23971, 25043, 26651, 28701, + 29834) }, + { AOM_CDF10(5414, 13269, 15111, 20488, 22360, 24500, 25537, 26336, + 32117) }, + { AOM_CDF10(2662, 6362, 8614, 20860, 23053, 24778, 26436, 27829, + 31171) }, + }, { + // 8x8 -> 4x4 only supports the four legacy partition types + { AOM_CDF4(19132, 25510, 30392) }, + { AOM_CDF4(13928, 19855, 28540) }, + { AOM_CDF4(12522, 23679, 28629) }, + { AOM_CDF4(9896, 18783, 25853) }, + } + }, .seg_pred = { + { AOM_CDF2(128 * 128) }, + { AOM_CDF2(128 * 128) }, + { AOM_CDF2(128 * 128) } + }, .seg_id = { + { AOM_CDF8(5622, 7893, 16093, 18233, 27809, 28373, 32533), }, + { AOM_CDF8(14274, 18230, 22557, 24935, 29980, 30851, 32344), }, + { AOM_CDF8(27527, 28487, 28723, 28890, 32397, 32647, 32679), }, + }, .cfl_sign = { + AOM_CDF8(1418, 2123, 13340, 18405, 26972, 28343, 32294) + }, .cfl_alpha = { + { AOM_CDF16(7637, 20719, 31401, 32481, 32657, 32688, 32692, 32696, + 32700, 32704, 32708, 32712, 32716, 32720, 32724) }, + { AOM_CDF16(14365, 23603, 28135, 31168, 32167, 32395, 32487, 32573, + 32620, 32647, 32668, 32672, 32676, 32680, 32684) }, + { AOM_CDF16(11532, 22380, 28445, 31360, 32349, 32523, 32584, 32649, + 32673, 32677, 32681, 32685, 32689, 32693, 32697) }, + { AOM_CDF16(26990, 31402, 32282, 32571, 32692, 32696, 32700, 32704, + 32708, 32712, 32716, 32720, 32724, 32728, 32732) }, + { AOM_CDF16(17248, 26058, 28904, 30608, 31305, 31877, 32126, 32321, + 32394, 32464, 32516, 32560, 32576, 32593, 32622) }, + { AOM_CDF16(14738, 21678, 25779, 27901, 29024, 30302, 30980, 31843, + 32144, 32413, 32520, 32594, 32622, 32656, 32660) } + }, .restore_wiener = { + AOM_CDF2(11570) + }, .restore_sgrproj = { + AOM_CDF2(16855) + }, .restore_switchable = { + AOM_CDF3(9413, 22581) + }, .delta_q = { + AOM_CDF4(28160, 32120, 32677) + }, .delta_lf = { + { AOM_CDF4(28160, 32120, 32677) }, + { AOM_CDF4(28160, 32120, 32677) }, + { AOM_CDF4(28160, 32120, 32677) }, + { AOM_CDF4(28160, 32120, 32677) }, + { AOM_CDF4(28160, 32120, 32677) }, + }, .motion_mode = { + [BS_8x8] = { AOM_CDF3(7651, 24760) }, + [BS_8x16] = { AOM_CDF3(4738, 24765) }, + [BS_8x32] = { AOM_CDF3(28799, 31390) }, + [BS_16x8] = { AOM_CDF3(5391, 25528) }, + [BS_16x16] = { AOM_CDF3(19419, 26810) }, + [BS_16x32] = { AOM_CDF3(5123, 23606) }, + [BS_16x64] = { AOM_CDF3(28973, 31594) }, + [BS_32x8] = { AOM_CDF3(26431, 30774) }, + [BS_32x16] = { AOM_CDF3(11606, 24308) }, + [BS_32x32] = { AOM_CDF3(26260, 29116) }, + [BS_32x64] = { AOM_CDF3(20360, 28062) }, + [BS_64x16] = { AOM_CDF3(29742, 31203) }, + [BS_64x32] = { AOM_CDF3(21679, 26830) }, + [BS_64x64] = { AOM_CDF3(29516, 30701) }, + [BS_64x128] = { AOM_CDF3(28898, 30397) }, + [BS_128x64] = { AOM_CDF3(30878, 31335) }, + [BS_128x128] = { AOM_CDF3(32507, 32558) }, + }, .obmc = { + [BS_8x8] = { AOM_CDF2(10437) }, + [BS_8x16] = { AOM_CDF2(9371) }, + [BS_8x32] = { AOM_CDF2(23664) }, + [BS_16x8] = { AOM_CDF2(9301) }, + [BS_16x16] = { AOM_CDF2(17432) }, + [BS_16x32] = { AOM_CDF2(14423) }, + [BS_16x64] = { AOM_CDF2(24008) }, + [BS_32x8] = { AOM_CDF2(20901) }, + [BS_32x16] = { AOM_CDF2(15142) }, + [BS_32x32] = { AOM_CDF2(25817) }, + [BS_32x64] = { AOM_CDF2(22823) }, + [BS_64x16] = { AOM_CDF2(26879) }, + [BS_64x32] = { AOM_CDF2(22083) }, + [BS_64x64] = { AOM_CDF2(30128) }, + [BS_64x128] = { AOM_CDF2(31014) }, + [BS_128x64] = { AOM_CDF2(31560) }, + [BS_128x128] = { AOM_CDF2(32638) }, + }, .pal_y = { + { { AOM_CDF2(31676) }, { AOM_CDF2(3419) }, { AOM_CDF2(1261) } }, + { { AOM_CDF2(31912) }, { AOM_CDF2(2859) }, { AOM_CDF2(980) } }, + { { AOM_CDF2(31823) }, { AOM_CDF2(3400) }, { AOM_CDF2(781) } }, + { { AOM_CDF2(32030) }, { AOM_CDF2(3561) }, { AOM_CDF2(904) } }, + { { AOM_CDF2(32309) }, { AOM_CDF2(7337) }, { AOM_CDF2(1462) } }, + { { AOM_CDF2(32265) }, { AOM_CDF2(4015) }, { AOM_CDF2(1521) } }, + { { AOM_CDF2(32450) }, { AOM_CDF2(7946) }, { AOM_CDF2(129) } }, + }, .pal_sz = { + { + { AOM_CDF7(7952, 13000, 18149, 21478, 25527, 29241) }, + { AOM_CDF7(7139, 11421, 16195, 19544, 23666, 28073) }, + { AOM_CDF7(7788, 12741, 17325, 20500, 24315, 28530) }, + { AOM_CDF7(8271, 14064, 18246, 21564, 25071, 28533) }, + { AOM_CDF7(12725, 19180, 21863, 24839, 27535, 30120) }, + { AOM_CDF7(9711, 14888, 16923, 21052, 25661, 27875) }, + { AOM_CDF7(14940, 20797, 21678, 24186, 27033, 28999) }, + }, { + { AOM_CDF7(8713, 19979, 27128, 29609, 31331, 32272) }, + { AOM_CDF7(5839, 15573, 23581, 26947, 29848, 31700) }, + { AOM_CDF7(4426, 11260, 17999, 21483, 25863, 29430) }, + { AOM_CDF7(3228, 9464, 14993, 18089, 22523, 27420) }, + { AOM_CDF7(3768, 8886, 13091, 17852, 22495, 27207) }, + { AOM_CDF7(2464, 8451, 12861, 21632, 25525, 28555) }, + { AOM_CDF7(1269, 5435, 10433, 18963, 21700, 25865) }, + } + }, .pal_uv = { + { AOM_CDF2(32461) }, { AOM_CDF2(21488) }, + }, .color_map = { + { /* y */ + { + { AOM_CDF2(28710) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(10553) }, + { AOM_CDF2(27036) }, + { AOM_CDF2(31603) }, + }, { + { AOM_CDF3(27877, 30490) }, + { AOM_CDF3(11532, 25697) }, + { AOM_CDF3(6544, 30234) }, + { AOM_CDF3(23018, 28072) }, + { AOM_CDF3(31915, 32385) }, + }, { + { AOM_CDF4(25572, 28046, 30045) }, + { AOM_CDF4(9478, 21590, 27256) }, + { AOM_CDF4(7248, 26837, 29824) }, + { AOM_CDF4(19167, 24486, 28349) }, + { AOM_CDF4(31400, 31825, 32250) }, + }, { + { AOM_CDF5(24779, 26955, 28576, 30282) }, + { AOM_CDF5(8669, 20364, 24073, 28093) }, + { AOM_CDF5(4255, 27565, 29377, 31067) }, + { AOM_CDF5(19864, 23674, 26716, 29530) }, + { AOM_CDF5(31646, 31893, 32147, 32426) }, + }, { + { AOM_CDF6(23132, 25407, 26970, 28435, 30073) }, + { AOM_CDF6(7443, 17242, 20717, 24762, 27982) }, + { AOM_CDF6(6300, 24862, 26944, 28784, 30671) }, + { AOM_CDF6(18916, 22895, 25267, 27435, 29652) }, + { AOM_CDF6(31270, 31550, 31808, 32059, 32353) }, + }, { + { AOM_CDF7(23105, 25199, 26464, 27684, 28931, 30318) }, + { AOM_CDF7(6950, 15447, 18952, 22681, 25567, 28563) }, + { AOM_CDF7(7560, 23474, 25490, 27203, 28921, 30708) }, + { AOM_CDF7(18544, 22373, 24457, 26195, 28119, 30045) }, + { AOM_CDF7(31198, 31451, 31670, 31882, 32123, 32391) }, + }, { + { AOM_CDF8(21689, 23883, 25163, 26352, 27506, 28827, 30195) }, + { AOM_CDF8(6892, 15385, 17840, 21606, 24287, 26753, 29204) }, + { AOM_CDF8(5651, 23182, 25042, 26518, 27982, 29392, 30900) }, + { AOM_CDF8(19349, 22578, 24418, 25994, 27524, 29031, 30448) }, + { AOM_CDF8(31028, 31270, 31504, 31705, 31927, 32153, 32392) }, + }, + }, { /* uv */ + { + { AOM_CDF2(29089) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(8713) }, + { AOM_CDF2(29257) }, + { AOM_CDF2(31610) }, + }, { + { AOM_CDF3(25257, 29145) }, + { AOM_CDF3(12287, 27293) }, + { AOM_CDF3(7033, 27960) }, + { AOM_CDF3(20145, 25405) }, + { AOM_CDF3(30608, 31639) }, + }, { + { AOM_CDF4(24210, 27175, 29903) }, + { AOM_CDF4(9888, 22386, 27214) }, + { AOM_CDF4(5901, 26053, 29293) }, + { AOM_CDF4(18318, 22152, 28333) }, + { AOM_CDF4(30459, 31136, 31926) }, + }, { + { AOM_CDF5(22980, 25479, 27781, 29986) }, + { AOM_CDF5(8413, 21408, 24859, 28874) }, + { AOM_CDF5(2257, 29449, 30594, 31598) }, + { AOM_CDF5(19189, 21202, 25915, 28620) }, + { AOM_CDF5(31844, 32044, 32281, 32518) }, + }, { + { AOM_CDF6(22217, 24567, 26637, 28683, 30548) }, + { AOM_CDF6(7307, 16406, 19636, 24632, 28424) }, + { AOM_CDF6(4441, 25064, 26879, 28942, 30919) }, + { AOM_CDF6(17210, 20528, 23319, 26750, 29582) }, + { AOM_CDF6(30674, 30953, 31396, 31735, 32207) }, + }, { + { AOM_CDF7(21239, 23168, 25044, 26962, 28705, 30506) }, + { AOM_CDF7(6545, 15012, 18004, 21817, 25503, 28701) }, + { AOM_CDF7(3448, 26295, 27437, 28704, 30126, 31442) }, + { AOM_CDF7(15889, 18323, 21704, 24698, 26976, 29690) }, + { AOM_CDF7(30988, 31204, 31479, 31734, 31983, 32325) }, + }, { + { AOM_CDF8(21442, 23288, 24758, 26246, 27649, 28980, 30563) }, + { AOM_CDF8(5863, 14933, 17552, 20668, 23683, 26411, 29273) }, + { AOM_CDF8(3415, 25810, 26877, 27990, 29223, 30394, 31618) }, + { AOM_CDF8(17965, 20084, 22232, 23974, 26274, 28402, 30390) }, + { AOM_CDF8(31190, 31329, 31516, 31679, 31825, 32026, 32322) }, + }, + }, + }, .intrabc = { + AOM_CDF2(30531) + }, +}; + +static const CdfMvContext default_mv_cdf = { + .comp = { + { /* mv vertical component */ + .classes = { + AOM_CDF11(28672, 30976, 31858, 32320, 32551, 32656, 32740, + 32757, 32762, 32767) + }, .class0 = { + AOM_CDF2(216 * 128) + }, .classN = { + { AOM_CDF2(128 * 136) }, + { AOM_CDF2(128 * 140) }, + { AOM_CDF2(128 * 148) }, + { AOM_CDF2(128 * 160) }, + { AOM_CDF2(128 * 176) }, + { AOM_CDF2(128 * 192) }, + { AOM_CDF2(128 * 224) }, + { AOM_CDF2(128 * 234) }, + { AOM_CDF2(128 * 234) }, + { AOM_CDF2(128 * 240) } + }, .class0_fp = { + { AOM_CDF4(16384, 24576, 26624) }, + { AOM_CDF4(12288, 21248, 24128) } + }, .classN_fp = { + AOM_CDF4(8192, 17408, 21248) + }, .class0_hp = { + AOM_CDF2(160 * 128) + }, .classN_hp = { + AOM_CDF2(128 * 128) + }, .sign = { + AOM_CDF2(128 * 128) + } + }, { /* mv horizontal component */ + .classes = { + AOM_CDF11(28672, 30976, 31858, 32320, 32551, 32656, 32740, + 32757, 32762, 32767) + }, .class0 = { + AOM_CDF2(216 * 128) + }, .classN = { + { AOM_CDF2(128 * 136) }, + { AOM_CDF2(128 * 140) }, + { AOM_CDF2(128 * 148) }, + { AOM_CDF2(128 * 160) }, + { AOM_CDF2(128 * 176) }, + { AOM_CDF2(128 * 192) }, + { AOM_CDF2(128 * 224) }, + { AOM_CDF2(128 * 234) }, + { AOM_CDF2(128 * 234) }, + { AOM_CDF2(128 * 240) } + }, .class0_fp = { + { AOM_CDF4(16384, 24576, 26624) }, + { AOM_CDF4(12288, 21248, 24128) } + }, .classN_fp = { + AOM_CDF4(8192, 17408, 21248) + }, .class0_hp = { + AOM_CDF2(160 * 128) + }, .classN_hp = { + AOM_CDF2(128 * 128) + }, .sign = { + AOM_CDF2(128 * 128) + }, + } + }, .joint = { + AOM_CDF4(4096, 11264, 19328) + } +}; + +static const uint16_t default_kf_y_mode_cdf[5][5][N_INTRA_PRED_MODES + 1] = { + { + { AOM_CDF13(15588, 17027, 19338, 20218, 20682, 21110, 21825, 23244, + 24189, 28165, 29093, 30466) }, + { AOM_CDF13(12016, 18066, 19516, 20303, 20719, 21444, 21888, 23032, + 24434, 28658, 30172, 31409) }, + { AOM_CDF13(10052, 10771, 22296, 22788, 23055, 23239, 24133, 25620, + 26160, 29336, 29929, 31567) }, + { AOM_CDF13(14091, 15406, 16442, 18808, 19136, 19546, 19998, 22096, + 24746, 29585, 30958, 32462) }, + { AOM_CDF13(12122, 13265, 15603, 16501, 18609, 20033, 22391, 25583, + 26437, 30261, 31073, 32475) } + }, { + { AOM_CDF13(10023, 19585, 20848, 21440, 21832, 22760, 23089, 24023, + 25381, 29014, 30482, 31436) }, + { AOM_CDF13(5983, 24099, 24560, 24886, 25066, 25795, 25913, 26423, + 27610, 29905, 31276, 31794) }, + { AOM_CDF13(7444, 12781, 20177, 20728, 21077, 21607, 22170, 23405, + 24469, 27915, 29090, 30492) }, + { AOM_CDF13(8537, 14689, 15432, 17087, 17408, 18172, 18408, 19825, + 24649, 29153, 31096, 32210) }, + { AOM_CDF13(7543, 14231, 15496, 16195, 17905, 20717, 21984, 24516, + 26001, 29675, 30981, 31994) } + }, { + { AOM_CDF13(12613, 13591, 21383, 22004, 22312, 22577, 23401, 25055, + 25729, 29538, 30305, 32077) }, + { AOM_CDF13(9687, 13470, 18506, 19230, 19604, 20147, 20695, 22062, + 23219, 27743, 29211, 30907) }, + { AOM_CDF13(6183, 6505, 26024, 26252, 26366, 26434, 27082, 28354, + 28555, 30467, 30794, 32086) }, + { AOM_CDF13(10718, 11734, 14954, 17224, 17565, 17924, 18561, 21523, + 23878, 28975, 30287, 32252) }, + { AOM_CDF13(9194, 9858, 16501, 17263, 18424, 19171, 21563, 25961, + 26561, 30072, 30737, 32463) } + }, { + { AOM_CDF13(12602, 14399, 15488, 18381, 18778, 19315, 19724, 21419, + 25060, 29696, 30917, 32409) }, + { AOM_CDF13(8203, 13821, 14524, 17105, 17439, 18131, 18404, 19468, + 25225, 29485, 31158, 32342) }, + { AOM_CDF13(8451, 9731, 15004, 17643, 18012, 18425, 19070, 21538, + 24605, 29118, 30078, 32018) }, + { AOM_CDF13(7714, 9048, 9516, 16667, 16817, 16994, 17153, 18767, + 26743, 30389, 31536, 32528) }, + { AOM_CDF13(8843, 10280, 11496, 15317, 16652, 17943, 19108, 22718, + 25769, 29953, 30983, 32485) } + }, { + { AOM_CDF13(12578, 13671, 15979, 16834, 19075, 20913, 22989, 25449, + 26219, 30214, 31150, 32477) }, + { AOM_CDF13(9563, 13626, 15080, 15892, 17756, 20863, 22207, 24236, + 25380, 29653, 31143, 32277) }, + { AOM_CDF13(8356, 8901, 17616, 18256, 19350, 20106, 22598, 25947, + 26466, 29900, 30523, 32261) }, + { AOM_CDF13(10835, 11815, 13124, 16042, 17018, 18039, 18947, 22753, + 24615, 29489, 30883, 32482) }, + { AOM_CDF13(7618, 8288, 9859, 10509, 15386, 18657, 22903, 28776, + 29180, 31355, 31802, 32593) } + } +}; + +static const CdfCoefContext av1_default_coef_cdf[4] = { + [0] = { + .skip = { + { { AOM_CDF2(31849) }, + { AOM_CDF2(5892) }, + { AOM_CDF2(12112) }, + { AOM_CDF2(21935) }, + { AOM_CDF2(20289) }, + { AOM_CDF2(27473) }, + { AOM_CDF2(32487) }, + { AOM_CDF2(7654) }, + { AOM_CDF2(19473) }, + { AOM_CDF2(29984) }, + { AOM_CDF2(9961) }, + { AOM_CDF2(30242) }, + { AOM_CDF2(32117) } }, + { { AOM_CDF2(31548) }, + { AOM_CDF2(1549) }, + { AOM_CDF2(10130) }, + { AOM_CDF2(16656) }, + { AOM_CDF2(18591) }, + { AOM_CDF2(26308) }, + { AOM_CDF2(32537) }, + { AOM_CDF2(5403) }, + { AOM_CDF2(18096) }, + { AOM_CDF2(30003) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) } }, + { { AOM_CDF2(29957) }, + { AOM_CDF2(5391) }, + { AOM_CDF2(18039) }, + { AOM_CDF2(23566) }, + { AOM_CDF2(22431) }, + { AOM_CDF2(25822) }, + { AOM_CDF2(32197) }, + { AOM_CDF2(3778) }, + { AOM_CDF2(15336) }, + { AOM_CDF2(28981) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) } }, + { { AOM_CDF2(17920) }, + { AOM_CDF2(1818) }, + { AOM_CDF2(7282) }, + { AOM_CDF2(25273) }, + { AOM_CDF2(10923) }, + { AOM_CDF2(31554) }, + { AOM_CDF2(32624) }, + { AOM_CDF2(1366) }, + { AOM_CDF2(15628) }, + { AOM_CDF2(30462) }, + { AOM_CDF2(146) }, + { AOM_CDF2(5132) }, + { AOM_CDF2(31657) } }, + { { AOM_CDF2(6308) }, + { AOM_CDF2(117) }, + { AOM_CDF2(1638) }, + { AOM_CDF2(2161) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(10923) }, + { AOM_CDF2(30247) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) } } + }, .eob_bin_16 = { + { { AOM_CDF5(840, 1039, 1980, 4895) }, + { AOM_CDF5(370, 671, 1883, 4471) } }, + { { AOM_CDF5(3247, 4950, 9688, 14563) }, + { AOM_CDF5(1904, 3354, 7763, 14647) } } + }, .eob_bin_32 = { + { { AOM_CDF6(400, 520, 977, 2102, 6542) }, + { AOM_CDF6(210, 405, 1315, 3326, 7537) } }, + { { AOM_CDF6(2636, 4273, 7588, 11794, 20401) }, + { AOM_CDF6(1786, 3179, 6902, 11357, 19054) } } + }, .eob_bin_64 = { + { { AOM_CDF7(329, 498, 1101, 1784, 3265, 7758) }, + { AOM_CDF7(335, 730, 1459, 5494, 8755, 12997) } }, + { { AOM_CDF7(3505, 5304, 10086, 13814, 17684, 23370) }, + { AOM_CDF7(1563, 2700, 4876, 10911, 14706, 22480) } } + }, .eob_bin_128 = { + { { AOM_CDF8(219, 482, 1140, 2091, 3680, 6028, 12586) }, + { AOM_CDF8(371, 699, 1254, 4830, 9479, 12562, 17497) } }, + { { AOM_CDF8(5245, 7456, 12880, 15852, 20033, 23932, 27608) }, + { AOM_CDF8(2054, 3472, 5869, 14232, 18242, 20590, 26752) } } + }, .eob_bin_256 = { + { { AOM_CDF9(310, 584, 1887, 3589, 6168, 8611, 11352, 15652) }, + { AOM_CDF9(998, 1850, 2998, 5604, 17341, 19888, 22899, 25583) } }, + { { AOM_CDF9(2520, 3240, 5952, 8870, 12577, 17558, 19954, 24168) }, + { AOM_CDF9(2203, 4130, 7435, 10739, 20652, 23681, 25609, 27261) } } + }, .eob_bin_512 = { + { { AOM_CDF10(641, 983, 3707, 5430, 10234, 14958, 18788, + 23412, 26061) }, + { AOM_CDF10(3277, 6554, 9830, 13107, 16384, 19661, 22938, + 26214, 29491) } }, + { { AOM_CDF10(5095, 6446, 9996, 13354, 16017, 17986, 20919, + 26129, 29140) }, + { AOM_CDF10(3277, 6554, 9830, 13107, 16384, 19661, 22938, + 26214, 29491) } } + }, .eob_bin_1024 = { + { { AOM_CDF11(393, 421, 751, 1623, 3160, 6352, 13345, 18047, + 22571, 25830) }, + { AOM_CDF11(2979, 5958, 8937, 11916, 14895, 17873, 20852, + 23831, 26810, 29789) } }, + { { AOM_CDF11(1865, 1988, 2930, 4242, 10533, 16538, 21354, + 27255, 28546, 31784) }, + { AOM_CDF11(2979, 5958, 8937, 11916, 14895, 17873, 20852, + 23831, 26810, 29789) } } + }, .eob_hi_bit = { + { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(16961) }, { AOM_CDF2(17223) }, { AOM_CDF2(7621) }, + { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } }, + { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(19069) }, { AOM_CDF2(22525) }, { AOM_CDF2(13377) }, + { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } } }, + { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(20401) }, { AOM_CDF2(17025) }, { AOM_CDF2(12845) }, + { AOM_CDF2(12873) }, { AOM_CDF2(14094) }, { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } }, + { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(20681) }, { AOM_CDF2(20701) }, { AOM_CDF2(15250) }, + { AOM_CDF2(15017) }, { AOM_CDF2(14928) }, { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } } }, + { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(23905) }, { AOM_CDF2(17194) }, { AOM_CDF2(16170) }, + { AOM_CDF2(17695) }, { AOM_CDF2(13826) }, { AOM_CDF2(15810) }, + { AOM_CDF2(12036) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } }, + { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(23959) }, { AOM_CDF2(20799) }, { AOM_CDF2(19021) }, + { AOM_CDF2(16203) }, { AOM_CDF2(17886) }, { AOM_CDF2(14144) }, + { AOM_CDF2(12010) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } } }, + { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(27399) }, { AOM_CDF2(16327) }, { AOM_CDF2(18071) }, + { AOM_CDF2(19584) }, { AOM_CDF2(20721) }, { AOM_CDF2(18432) }, + { AOM_CDF2(19560) }, { AOM_CDF2(10150) }, { AOM_CDF2(8805) } }, + { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(24932) }, { AOM_CDF2(20833) }, { AOM_CDF2(12027) }, + { AOM_CDF2(16670) }, { AOM_CDF2(19914) }, { AOM_CDF2(15106) }, + { AOM_CDF2(17662) }, { AOM_CDF2(13783) }, { AOM_CDF2(28756) } } }, + { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(23406) }, { AOM_CDF2(21845) }, { AOM_CDF2(18432) }, + { AOM_CDF2(16384) }, { AOM_CDF2(17096) }, { AOM_CDF2(12561) }, + { AOM_CDF2(17320) }, { AOM_CDF2(22395) }, { AOM_CDF2(21370) } }, + { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } } } + }, .eob_base_tok = { + { { { AOM_CDF3(17837, 29055) }, + { AOM_CDF3(29600, 31446) }, + { AOM_CDF3(30844, 31878) }, + { AOM_CDF3(24926, 28948) } }, + { { AOM_CDF3(21365, 30026) }, + { AOM_CDF3(30512, 32423) }, + { AOM_CDF3(31658, 32621) }, + { AOM_CDF3(29630, 31881) } } }, + { { { AOM_CDF3(5717, 26477) }, + { AOM_CDF3(30491, 31703) }, + { AOM_CDF3(31550, 32158) }, + { AOM_CDF3(29648, 31491) } }, + { { AOM_CDF3(12608, 27820) }, + { AOM_CDF3(30680, 32225) }, + { AOM_CDF3(30809, 32335) }, + { AOM_CDF3(31299, 32423) } } }, + { { { AOM_CDF3(1786, 12612) }, + { AOM_CDF3(30663, 31625) }, + { AOM_CDF3(32339, 32468) }, + { AOM_CDF3(31148, 31833) } }, + { { AOM_CDF3(18857, 23865) }, + { AOM_CDF3(31428, 32428) }, + { AOM_CDF3(31744, 32373) }, + { AOM_CDF3(31775, 32526) } } }, + { { { AOM_CDF3(1787, 2532) }, + { AOM_CDF3(30832, 31662) }, + { AOM_CDF3(31824, 32682) }, + { AOM_CDF3(32133, 32569) } }, + { { AOM_CDF3(13751, 22235) }, + { AOM_CDF3(32089, 32409) }, + { AOM_CDF3(27084, 27920) }, + { AOM_CDF3(29291, 32594) } } }, + { { { AOM_CDF3(1725, 3449) }, + { AOM_CDF3(31102, 31935) }, + { AOM_CDF3(32457, 32613) }, + { AOM_CDF3(32412, 32649) } }, + { { AOM_CDF3(10923, 21845) }, + { AOM_CDF3(10923, 21845) }, + { AOM_CDF3(10923, 21845) }, + { AOM_CDF3(10923, 21845) } } } + }, .base_tok = { + { { { AOM_CDF4(4034, 8930, 12727) }, + { AOM_CDF4(18082, 29741, 31877) }, + { AOM_CDF4(12596, 26124, 30493) }, + { AOM_CDF4(9446, 21118, 27005) }, + { AOM_CDF4(6308, 15141, 21279) }, + { AOM_CDF4(2463, 6357, 9783) }, + { AOM_CDF4(20667, 30546, 31929) }, + { AOM_CDF4(13043, 26123, 30134) }, + { AOM_CDF4(8151, 18757, 24778) }, + { AOM_CDF4(5255, 12839, 18632) }, + { AOM_CDF4(2820, 7206, 11161) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(15736, 27553, 30604) }, + { AOM_CDF4(11210, 23794, 28787) }, + { AOM_CDF4(5947, 13874, 19701) }, + { AOM_CDF4(4215, 9323, 13891) }, + { AOM_CDF4(2833, 6462, 10059) }, + { AOM_CDF4(19605, 30393, 31582) }, + { AOM_CDF4(13523, 26252, 30248) }, + { AOM_CDF4(8446, 18622, 24512) }, + { AOM_CDF4(3818, 10343, 15974) }, + { AOM_CDF4(1481, 4117, 6796) }, + { AOM_CDF4(22649, 31302, 32190) }, + { AOM_CDF4(14829, 27127, 30449) }, + { AOM_CDF4(8313, 17702, 23304) }, + { AOM_CDF4(3022, 8301, 12786) }, + { AOM_CDF4(1536, 4412, 7184) }, + { AOM_CDF4(22354, 29774, 31372) }, + { AOM_CDF4(14723, 25472, 29214) }, + { AOM_CDF4(6673, 13745, 18662) }, + { AOM_CDF4(2068, 5766, 9322) }, + { AOM_CDF4(8192, 16384, 24576) } }, + { { AOM_CDF4(6302, 16444, 21761) }, + { AOM_CDF4(23040, 31538, 32475) }, + { AOM_CDF4(15196, 28452, 31496) }, + { AOM_CDF4(10020, 22946, 28514) }, + { AOM_CDF4(6533, 16862, 23501) }, + { AOM_CDF4(3538, 9816, 15076) }, + { AOM_CDF4(24444, 31875, 32525) }, + { AOM_CDF4(15881, 28924, 31635) }, + { AOM_CDF4(9922, 22873, 28466) }, + { AOM_CDF4(6527, 16966, 23691) }, + { AOM_CDF4(4114, 11303, 17220) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(20201, 30770, 32209) }, + { AOM_CDF4(14754, 28071, 31258) }, + { AOM_CDF4(8378, 20186, 26517) }, + { AOM_CDF4(5916, 15299, 21978) }, + { AOM_CDF4(4268, 11583, 17901) }, + { AOM_CDF4(24361, 32025, 32581) }, + { AOM_CDF4(18673, 30105, 31943) }, + { AOM_CDF4(10196, 22244, 27576) }, + { AOM_CDF4(5495, 14349, 20417) }, + { AOM_CDF4(2676, 7415, 11498) }, + { AOM_CDF4(24678, 31958, 32585) }, + { AOM_CDF4(18629, 29906, 31831) }, + { AOM_CDF4(9364, 20724, 26315) }, + { AOM_CDF4(4641, 12318, 18094) }, + { AOM_CDF4(2758, 7387, 11579) }, + { AOM_CDF4(25433, 31842, 32469) }, + { AOM_CDF4(18795, 29289, 31411) }, + { AOM_CDF4(7644, 17584, 23592) }, + { AOM_CDF4(3408, 9014, 15047) }, + { AOM_CDF4(8192, 16384, 24576) } } }, + { { { AOM_CDF4(4536, 10072, 14001) }, + { AOM_CDF4(25459, 31416, 32206) }, + { AOM_CDF4(16605, 28048, 30818) }, + { AOM_CDF4(11008, 22857, 27719) }, + { AOM_CDF4(6915, 16268, 22315) }, + { AOM_CDF4(2625, 6812, 10537) }, + { AOM_CDF4(24257, 31788, 32499) }, + { AOM_CDF4(16880, 29454, 31879) }, + { AOM_CDF4(11958, 25054, 29778) }, + { AOM_CDF4(7916, 18718, 25084) }, + { AOM_CDF4(3383, 8777, 13446) }, + { AOM_CDF4(22720, 31603, 32393) }, + { AOM_CDF4(14960, 28125, 31335) }, + { AOM_CDF4(9731, 22210, 27928) }, + { AOM_CDF4(6304, 15832, 22277) }, + { AOM_CDF4(2910, 7818, 12166) }, + { AOM_CDF4(20375, 30627, 32131) }, + { AOM_CDF4(13904, 27284, 30887) }, + { AOM_CDF4(9368, 21558, 27144) }, + { AOM_CDF4(5937, 14966, 21119) }, + { AOM_CDF4(2667, 7225, 11319) }, + { AOM_CDF4(23970, 31470, 32378) }, + { AOM_CDF4(17173, 29734, 32018) }, + { AOM_CDF4(12795, 25441, 29965) }, + { AOM_CDF4(8981, 19680, 25893) }, + { AOM_CDF4(4728, 11372, 16902) }, + { AOM_CDF4(24287, 31797, 32439) }, + { AOM_CDF4(16703, 29145, 31696) }, + { AOM_CDF4(10833, 23554, 28725) }, + { AOM_CDF4(6468, 16566, 23057) }, + { AOM_CDF4(2415, 6562, 10278) }, + { AOM_CDF4(26610, 32395, 32659) }, + { AOM_CDF4(18590, 30498, 32117) }, + { AOM_CDF4(12420, 25756, 29950) }, + { AOM_CDF4(7639, 18746, 24710) }, + { AOM_CDF4(3001, 8086, 12347) }, + { AOM_CDF4(25076, 32064, 32580) }, + { AOM_CDF4(17946, 30128, 32028) }, + { AOM_CDF4(12024, 24985, 29378) }, + { AOM_CDF4(7517, 18390, 24304) }, + { AOM_CDF4(3243, 8781, 13331) } }, + { { AOM_CDF4(6037, 16771, 21957) }, + { AOM_CDF4(24774, 31704, 32426) }, + { AOM_CDF4(16830, 28589, 31056) }, + { AOM_CDF4(10602, 22828, 27760) }, + { AOM_CDF4(6733, 16829, 23071) }, + { AOM_CDF4(3250, 8914, 13556) }, + { AOM_CDF4(25582, 32220, 32668) }, + { AOM_CDF4(18659, 30342, 32223) }, + { AOM_CDF4(12546, 26149, 30515) }, + { AOM_CDF4(8420, 20451, 26801) }, + { AOM_CDF4(4636, 12420, 18344) }, + { AOM_CDF4(27581, 32362, 32639) }, + { AOM_CDF4(18987, 30083, 31978) }, + { AOM_CDF4(11327, 24248, 29084) }, + { AOM_CDF4(7264, 17719, 24120) }, + { AOM_CDF4(3995, 10768, 16169) }, + { AOM_CDF4(25893, 31831, 32487) }, + { AOM_CDF4(16577, 28587, 31379) }, + { AOM_CDF4(10189, 22748, 28182) }, + { AOM_CDF4(6832, 17094, 23556) }, + { AOM_CDF4(3708, 10110, 15334) }, + { AOM_CDF4(25904, 32282, 32656) }, + { AOM_CDF4(19721, 30792, 32276) }, + { AOM_CDF4(12819, 26243, 30411) }, + { AOM_CDF4(8572, 20614, 26891) }, + { AOM_CDF4(5364, 14059, 20467) }, + { AOM_CDF4(26580, 32438, 32677) }, + { AOM_CDF4(20852, 31225, 32340) }, + { AOM_CDF4(12435, 25700, 29967) }, + { AOM_CDF4(8691, 20825, 26976) }, + { AOM_CDF4(4446, 12209, 17269) }, + { AOM_CDF4(27350, 32429, 32696) }, + { AOM_CDF4(21372, 30977, 32272) }, + { AOM_CDF4(12673, 25270, 29853) }, + { AOM_CDF4(9208, 20925, 26640) }, + { AOM_CDF4(5018, 13351, 18732) }, + { AOM_CDF4(27351, 32479, 32713) }, + { AOM_CDF4(21398, 31209, 32387) }, + { AOM_CDF4(12162, 25047, 29842) }, + { AOM_CDF4(7896, 18691, 25319) }, + { AOM_CDF4(4670, 12882, 18881) } } }, + { { { AOM_CDF4(5487, 10460, 13708) }, + { AOM_CDF4(21597, 28303, 30674) }, + { AOM_CDF4(11037, 21953, 26476) }, + { AOM_CDF4(8147, 17962, 22952) }, + { AOM_CDF4(5242, 13061, 18532) }, + { AOM_CDF4(1889, 5208, 8182) }, + { AOM_CDF4(26774, 32133, 32590) }, + { AOM_CDF4(17844, 29564, 31767) }, + { AOM_CDF4(11690, 24438, 29171) }, + { AOM_CDF4(7542, 18215, 24459) }, + { AOM_CDF4(2993, 8050, 12319) }, + { AOM_CDF4(28023, 32328, 32591) }, + { AOM_CDF4(18651, 30126, 31954) }, + { AOM_CDF4(12164, 25146, 29589) }, + { AOM_CDF4(7762, 18530, 24771) }, + { AOM_CDF4(3492, 9183, 13920) }, + { AOM_CDF4(27591, 32008, 32491) }, + { AOM_CDF4(17149, 28853, 31510) }, + { AOM_CDF4(11485, 24003, 28860) }, + { AOM_CDF4(7697, 18086, 24210) }, + { AOM_CDF4(3075, 7999, 12218) }, + { AOM_CDF4(28268, 32482, 32654) }, + { AOM_CDF4(19631, 31051, 32404) }, + { AOM_CDF4(13860, 27260, 31020) }, + { AOM_CDF4(9605, 21613, 27594) }, + { AOM_CDF4(4876, 12162, 17908) }, + { AOM_CDF4(27248, 32316, 32576) }, + { AOM_CDF4(18955, 30457, 32075) }, + { AOM_CDF4(11824, 23997, 28795) }, + { AOM_CDF4(7346, 18196, 24647) }, + { AOM_CDF4(3403, 9247, 14111) }, + { AOM_CDF4(29711, 32655, 32735) }, + { AOM_CDF4(21169, 31394, 32417) }, + { AOM_CDF4(13487, 27198, 30957) }, + { AOM_CDF4(8828, 21683, 27614) }, + { AOM_CDF4(4270, 11451, 17038) }, + { AOM_CDF4(28708, 32578, 32731) }, + { AOM_CDF4(20120, 31241, 32482) }, + { AOM_CDF4(13692, 27550, 31321) }, + { AOM_CDF4(9418, 22514, 28439) }, + { AOM_CDF4(4999, 13283, 19462) } }, + { { AOM_CDF4(5673, 14302, 19711) }, + { AOM_CDF4(26251, 30701, 31834) }, + { AOM_CDF4(12782, 23783, 27803) }, + { AOM_CDF4(9127, 20657, 25808) }, + { AOM_CDF4(6368, 16208, 21462) }, + { AOM_CDF4(2465, 7177, 10822) }, + { AOM_CDF4(29961, 32563, 32719) }, + { AOM_CDF4(18318, 29891, 31949) }, + { AOM_CDF4(11361, 24514, 29357) }, + { AOM_CDF4(7900, 19603, 25607) }, + { AOM_CDF4(4002, 10590, 15546) }, + { AOM_CDF4(29637, 32310, 32595) }, + { AOM_CDF4(18296, 29913, 31809) }, + { AOM_CDF4(10144, 21515, 26871) }, + { AOM_CDF4(5358, 14322, 20394) }, + { AOM_CDF4(3067, 8362, 13346) }, + { AOM_CDF4(28652, 32470, 32676) }, + { AOM_CDF4(17538, 30771, 32209) }, + { AOM_CDF4(13924, 26882, 30494) }, + { AOM_CDF4(10496, 22837, 27869) }, + { AOM_CDF4(7236, 16396, 21621) }, + { AOM_CDF4(30743, 32687, 32746) }, + { AOM_CDF4(23006, 31676, 32489) }, + { AOM_CDF4(14494, 27828, 31120) }, + { AOM_CDF4(10174, 22801, 28352) }, + { AOM_CDF4(6242, 15281, 21043) }, + { AOM_CDF4(25817, 32243, 32720) }, + { AOM_CDF4(18618, 31367, 32325) }, + { AOM_CDF4(13997, 28318, 31878) }, + { AOM_CDF4(12255, 26534, 31383) }, + { AOM_CDF4(9561, 21588, 28450) }, + { AOM_CDF4(28188, 32635, 32724) }, + { AOM_CDF4(22060, 32365, 32728) }, + { AOM_CDF4(18102, 30690, 32528) }, + { AOM_CDF4(14196, 28864, 31999) }, + { AOM_CDF4(12262, 25792, 30865) }, + { AOM_CDF4(24176, 32109, 32628) }, + { AOM_CDF4(18280, 29681, 31963) }, + { AOM_CDF4(10205, 23703, 29664) }, + { AOM_CDF4(7889, 20025, 27676) }, + { AOM_CDF4(6060, 16743, 23970) } } }, + { { { AOM_CDF4(5141, 7096, 8260) }, + { AOM_CDF4(27186, 29022, 29789) }, + { AOM_CDF4(6668, 12568, 15682) }, + { AOM_CDF4(2172, 6181, 8638) }, + { AOM_CDF4(1126, 3379, 4531) }, + { AOM_CDF4(443, 1361, 2254) }, + { AOM_CDF4(26083, 31153, 32436) }, + { AOM_CDF4(13486, 24603, 28483) }, + { AOM_CDF4(6508, 14840, 19910) }, + { AOM_CDF4(3386, 8800, 13286) }, + { AOM_CDF4(1530, 4322, 7054) }, + { AOM_CDF4(29639, 32080, 32548) }, + { AOM_CDF4(15897, 27552, 30290) }, + { AOM_CDF4(8588, 20047, 25383) }, + { AOM_CDF4(4889, 13339, 19269) }, + { AOM_CDF4(2240, 6871, 10498) }, + { AOM_CDF4(28165, 32197, 32517) }, + { AOM_CDF4(20735, 30427, 31568) }, + { AOM_CDF4(14325, 24671, 27692) }, + { AOM_CDF4(5119, 12554, 17805) }, + { AOM_CDF4(1810, 5441, 8261) }, + { AOM_CDF4(31212, 32724, 32748) }, + { AOM_CDF4(23352, 31766, 32545) }, + { AOM_CDF4(14669, 27570, 31059) }, + { AOM_CDF4(8492, 20894, 27272) }, + { AOM_CDF4(3644, 10194, 15204) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) } }, + { { AOM_CDF4(2461, 7013, 9371) }, + { AOM_CDF4(24749, 29600, 30986) }, + { AOM_CDF4(9466, 19037, 22417) }, + { AOM_CDF4(3584, 9280, 14400) }, + { AOM_CDF4(1505, 3929, 5433) }, + { AOM_CDF4(677, 1500, 2736) }, + { AOM_CDF4(23987, 30702, 32117) }, + { AOM_CDF4(13554, 24571, 29263) }, + { AOM_CDF4(6211, 14556, 21155) }, + { AOM_CDF4(3135, 10972, 15625) }, + { AOM_CDF4(2435, 7127, 11427) }, + { AOM_CDF4(31300, 32532, 32550) }, + { AOM_CDF4(14757, 30365, 31954) }, + { AOM_CDF4(4405, 11612, 18553) }, + { AOM_CDF4(580, 4132, 7322) }, + { AOM_CDF4(1695, 10169, 14124) }, + { AOM_CDF4(30008, 32282, 32591) }, + { AOM_CDF4(19244, 30108, 31748) }, + { AOM_CDF4(11180, 24158, 29555) }, + { AOM_CDF4(5650, 14972, 19209) }, + { AOM_CDF4(2114, 5109, 8456) }, + { AOM_CDF4(31856, 32716, 32748) }, + { AOM_CDF4(23012, 31664, 32572) }, + { AOM_CDF4(13694, 26656, 30636) }, + { AOM_CDF4(8142, 19508, 26093) }, + { AOM_CDF4(4253, 10955, 16724) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) } } }, + { { { AOM_CDF4(601, 983, 1311) }, + { AOM_CDF4(18725, 23406, 28087) }, + { AOM_CDF4(5461, 8192, 10923) }, + { AOM_CDF4(3781, 15124, 21425) }, + { AOM_CDF4(2587, 7761, 12072) }, + { AOM_CDF4(106, 458, 810) }, + { AOM_CDF4(22282, 29710, 31894) }, + { AOM_CDF4(8508, 20926, 25984) }, + { AOM_CDF4(3726, 12713, 18083) }, + { AOM_CDF4(1620, 7112, 10893) }, + { AOM_CDF4(729, 2236, 3495) }, + { AOM_CDF4(30163, 32474, 32684) }, + { AOM_CDF4(18304, 30464, 32000) }, + { AOM_CDF4(11443, 26526, 29647) }, + { AOM_CDF4(6007, 15292, 21299) }, + { AOM_CDF4(2234, 6703, 8937) }, + { AOM_CDF4(30954, 32177, 32571) }, + { AOM_CDF4(17363, 29562, 31076) }, + { AOM_CDF4(9686, 22464, 27410) }, + { AOM_CDF4(8192, 16384, 21390) }, + { AOM_CDF4(1755, 8046, 11264) }, + { AOM_CDF4(31168, 32734, 32748) }, + { AOM_CDF4(22486, 31441, 32471) }, + { AOM_CDF4(12833, 25627, 29738) }, + { AOM_CDF4(6980, 17379, 23122) }, + { AOM_CDF4(3111, 8887, 13479) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) } }, + { { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) } } } + }, .dc_sign = { + { + { AOM_CDF2(128 * 125) }, + { AOM_CDF2(128 * 102) }, + { AOM_CDF2(128 * 147) }, + }, { + { AOM_CDF2(128 * 119) }, + { AOM_CDF2(128 * 101) }, + { AOM_CDF2(128 * 135) }, + } + }, .br_tok = { + { { { AOM_CDF4(14298, 20718, 24174) }, + { AOM_CDF4(12536, 19601, 23789) }, + { AOM_CDF4(8712, 15051, 19503) }, + { AOM_CDF4(6170, 11327, 15434) }, + { AOM_CDF4(4742, 8926, 12538) }, + { AOM_CDF4(3803, 7317, 10546) }, + { AOM_CDF4(1696, 3317, 4871) }, + { AOM_CDF4(14392, 19951, 22756) }, + { AOM_CDF4(15978, 23218, 26818) }, + { AOM_CDF4(12187, 19474, 23889) }, + { AOM_CDF4(9176, 15640, 20259) }, + { AOM_CDF4(7068, 12655, 17028) }, + { AOM_CDF4(5656, 10442, 14472) }, + { AOM_CDF4(2580, 4992, 7244) }, + { AOM_CDF4(12136, 18049, 21426) }, + { AOM_CDF4(13784, 20721, 24481) }, + { AOM_CDF4(10836, 17621, 21900) }, + { AOM_CDF4(8372, 14444, 18847) }, + { AOM_CDF4(6523, 11779, 16000) }, + { AOM_CDF4(5337, 9898, 13760) }, + { AOM_CDF4(3034, 5860, 8462) } }, + { { AOM_CDF4(15967, 22905, 26286) }, + { AOM_CDF4(13534, 20654, 24579) }, + { AOM_CDF4(9504, 16092, 20535) }, + { AOM_CDF4(6975, 12568, 16903) }, + { AOM_CDF4(5364, 10091, 14020) }, + { AOM_CDF4(4357, 8370, 11857) }, + { AOM_CDF4(2506, 4934, 7218) }, + { AOM_CDF4(23032, 28815, 30936) }, + { AOM_CDF4(19540, 26704, 29719) }, + { AOM_CDF4(15158, 22969, 27097) }, + { AOM_CDF4(11408, 18865, 23650) }, + { AOM_CDF4(8885, 15448, 20250) }, + { AOM_CDF4(7108, 12853, 17416) }, + { AOM_CDF4(4231, 8041, 11480) }, + { AOM_CDF4(19823, 26490, 29156) }, + { AOM_CDF4(18890, 25929, 28932) }, + { AOM_CDF4(15660, 23491, 27433) }, + { AOM_CDF4(12147, 19776, 24488) }, + { AOM_CDF4(9728, 16774, 21649) }, + { AOM_CDF4(7919, 14277, 19066) }, + { AOM_CDF4(5440, 10170, 14185) } } }, + { { { AOM_CDF4(14406, 20862, 24414) }, + { AOM_CDF4(11824, 18907, 23109) }, + { AOM_CDF4(8257, 14393, 18803) }, + { AOM_CDF4(5860, 10747, 14778) }, + { AOM_CDF4(4475, 8486, 11984) }, + { AOM_CDF4(3606, 6954, 10043) }, + { AOM_CDF4(1736, 3410, 5048) }, + { AOM_CDF4(14430, 20046, 22882) }, + { AOM_CDF4(15593, 22899, 26709) }, + { AOM_CDF4(12102, 19368, 23811) }, + { AOM_CDF4(9059, 15584, 20262) }, + { AOM_CDF4(6999, 12603, 17048) }, + { AOM_CDF4(5684, 10497, 14553) }, + { AOM_CDF4(2822, 5438, 7862) }, + { AOM_CDF4(15785, 21585, 24359) }, + { AOM_CDF4(18347, 25229, 28266) }, + { AOM_CDF4(14974, 22487, 26389) }, + { AOM_CDF4(11423, 18681, 23271) }, + { AOM_CDF4(8863, 15350, 20008) }, + { AOM_CDF4(7153, 12852, 17278) }, + { AOM_CDF4(3707, 7036, 9982) } }, + { { AOM_CDF4(15460, 21696, 25469) }, + { AOM_CDF4(12170, 19249, 23191) }, + { AOM_CDF4(8723, 15027, 19332) }, + { AOM_CDF4(6428, 11704, 15874) }, + { AOM_CDF4(4922, 9292, 13052) }, + { AOM_CDF4(4139, 7695, 11010) }, + { AOM_CDF4(2291, 4508, 6598) }, + { AOM_CDF4(19856, 26920, 29828) }, + { AOM_CDF4(17923, 25289, 28792) }, + { AOM_CDF4(14278, 21968, 26297) }, + { AOM_CDF4(10910, 18136, 22950) }, + { AOM_CDF4(8423, 14815, 19627) }, + { AOM_CDF4(6771, 12283, 16774) }, + { AOM_CDF4(4074, 7750, 11081) }, + { AOM_CDF4(19852, 26074, 28672) }, + { AOM_CDF4(19371, 26110, 28989) }, + { AOM_CDF4(16265, 23873, 27663) }, + { AOM_CDF4(12758, 20378, 24952) }, + { AOM_CDF4(10095, 17098, 21961) }, + { AOM_CDF4(8250, 14628, 19451) }, + { AOM_CDF4(5205, 9745, 13622) } } }, + { { { AOM_CDF4(10563, 16233, 19763) }, + { AOM_CDF4(9794, 16022, 19804) }, + { AOM_CDF4(6750, 11945, 15759) }, + { AOM_CDF4(4963, 9186, 12752) }, + { AOM_CDF4(3845, 7435, 10627) }, + { AOM_CDF4(3051, 6085, 8834) }, + { AOM_CDF4(1311, 2596, 3830) }, + { AOM_CDF4(11246, 16404, 19689) }, + { AOM_CDF4(12315, 18911, 22731) }, + { AOM_CDF4(10557, 17095, 21289) }, + { AOM_CDF4(8136, 14006, 18249) }, + { AOM_CDF4(6348, 11474, 15565) }, + { AOM_CDF4(5196, 9655, 13400) }, + { AOM_CDF4(2349, 4526, 6587) }, + { AOM_CDF4(13337, 18730, 21569) }, + { AOM_CDF4(19306, 26071, 28882) }, + { AOM_CDF4(15952, 23540, 27254) }, + { AOM_CDF4(12409, 19934, 24430) }, + { AOM_CDF4(9760, 16706, 21389) }, + { AOM_CDF4(8004, 14220, 18818) }, + { AOM_CDF4(4138, 7794, 10961) } }, + { { AOM_CDF4(10870, 16684, 20949) }, + { AOM_CDF4(9664, 15230, 18680) }, + { AOM_CDF4(6886, 12109, 15408) }, + { AOM_CDF4(4825, 8900, 12305) }, + { AOM_CDF4(3630, 7162, 10314) }, + { AOM_CDF4(3036, 6429, 9387) }, + { AOM_CDF4(1671, 3296, 4940) }, + { AOM_CDF4(13819, 19159, 23026) }, + { AOM_CDF4(11984, 19108, 23120) }, + { AOM_CDF4(10690, 17210, 21663) }, + { AOM_CDF4(7984, 14154, 18333) }, + { AOM_CDF4(6868, 12294, 16124) }, + { AOM_CDF4(5274, 8994, 12868) }, + { AOM_CDF4(2988, 5771, 8424) }, + { AOM_CDF4(19736, 26647, 29141) }, + { AOM_CDF4(18933, 26070, 28984) }, + { AOM_CDF4(15779, 23048, 27200) }, + { AOM_CDF4(12638, 20061, 24532) }, + { AOM_CDF4(10692, 17545, 22220) }, + { AOM_CDF4(9217, 15251, 20054) }, + { AOM_CDF4(5078, 9284, 12594) } } }, + { { { AOM_CDF4(2331, 3662, 5244) }, + { AOM_CDF4(2891, 4771, 6145) }, + { AOM_CDF4(4598, 7623, 9729) }, + { AOM_CDF4(3520, 6845, 9199) }, + { AOM_CDF4(3417, 6119, 9324) }, + { AOM_CDF4(2601, 5412, 7385) }, + { AOM_CDF4(600, 1173, 1744) }, + { AOM_CDF4(7672, 13286, 17469) }, + { AOM_CDF4(4232, 7792, 10793) }, + { AOM_CDF4(2915, 5317, 7397) }, + { AOM_CDF4(2318, 4356, 6152) }, + { AOM_CDF4(2127, 4000, 5554) }, + { AOM_CDF4(1850, 3478, 5275) }, + { AOM_CDF4(977, 1933, 2843) }, + { AOM_CDF4(18280, 24387, 27989) }, + { AOM_CDF4(15852, 22671, 26185) }, + { AOM_CDF4(13845, 20951, 24789) }, + { AOM_CDF4(11055, 17966, 22129) }, + { AOM_CDF4(9138, 15422, 19801) }, + { AOM_CDF4(7454, 13145, 17456) }, + { AOM_CDF4(3370, 6393, 9013) } }, + { { AOM_CDF4(5842, 9229, 10838) }, + { AOM_CDF4(2313, 3491, 4276) }, + { AOM_CDF4(2998, 6104, 7496) }, + { AOM_CDF4(2420, 7447, 9868) }, + { AOM_CDF4(3034, 8495, 10923) }, + { AOM_CDF4(4076, 8937, 10975) }, + { AOM_CDF4(1086, 2370, 3299) }, + { AOM_CDF4(9714, 17254, 20444) }, + { AOM_CDF4(8543, 13698, 17123) }, + { AOM_CDF4(4918, 9007, 11910) }, + { AOM_CDF4(4129, 7532, 10553) }, + { AOM_CDF4(2364, 5533, 8058) }, + { AOM_CDF4(1834, 3546, 5563) }, + { AOM_CDF4(1473, 2908, 4133) }, + { AOM_CDF4(15405, 21193, 25619) }, + { AOM_CDF4(15691, 21952, 26561) }, + { AOM_CDF4(12962, 19194, 24165) }, + { AOM_CDF4(10272, 17855, 22129) }, + { AOM_CDF4(8588, 15270, 20718) }, + { AOM_CDF4(8682, 14669, 19500) }, + { AOM_CDF4(4870, 9636, 13205) } } } + }, + }, [1] = { + .skip = { + { { AOM_CDF2(30371) }, + { AOM_CDF2(7570) }, + { AOM_CDF2(13155) }, + { AOM_CDF2(20751) }, + { AOM_CDF2(20969) }, + { AOM_CDF2(27067) }, + { AOM_CDF2(32013) }, + { AOM_CDF2(5495) }, + { AOM_CDF2(17942) }, + { AOM_CDF2(28280) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) } }, + { { AOM_CDF2(31782) }, + { AOM_CDF2(1836) }, + { AOM_CDF2(10689) }, + { AOM_CDF2(17604) }, + { AOM_CDF2(21622) }, + { AOM_CDF2(27518) }, + { AOM_CDF2(32399) }, + { AOM_CDF2(4419) }, + { AOM_CDF2(16294) }, + { AOM_CDF2(28345) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) } }, + { { AOM_CDF2(31901) }, + { AOM_CDF2(10311) }, + { AOM_CDF2(18047) }, + { AOM_CDF2(24806) }, + { AOM_CDF2(23288) }, + { AOM_CDF2(27914) }, + { AOM_CDF2(32296) }, + { AOM_CDF2(4215) }, + { AOM_CDF2(15756) }, + { AOM_CDF2(28341) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) } }, + { { AOM_CDF2(26726) }, + { AOM_CDF2(1045) }, + { AOM_CDF2(11703) }, + { AOM_CDF2(20590) }, + { AOM_CDF2(18554) }, + { AOM_CDF2(25970) }, + { AOM_CDF2(31938) }, + { AOM_CDF2(5583) }, + { AOM_CDF2(21313) }, + { AOM_CDF2(29390) }, + { AOM_CDF2(641) }, + { AOM_CDF2(22265) }, + { AOM_CDF2(31452) } }, + { { AOM_CDF2(26584) }, + { AOM_CDF2(188) }, + { AOM_CDF2(8847) }, + { AOM_CDF2(24519) }, + { AOM_CDF2(22938) }, + { AOM_CDF2(30583) }, + { AOM_CDF2(32608) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) } } + }, .eob_bin_16 = { + { { AOM_CDF5(2125, 2551, 5165, 8946) }, + { AOM_CDF5(513, 765, 1859, 6339) } }, + { { AOM_CDF5(7637, 9498, 14259, 19108) }, + { AOM_CDF5(2497, 4096, 8866, 16993) } } + }, .eob_bin_32 = { + { { AOM_CDF6(989, 1249, 2019, 4151, 10785) }, + { AOM_CDF6(313, 441, 1099, 2917, 8562) } }, + { { AOM_CDF6(8394, 10352, 13932, 18855, 26014) }, + { AOM_CDF6(2578, 4124, 8181, 13670, 24234) } } + }, .eob_bin_64 = { + { { AOM_CDF7(1260, 1446, 2253, 3712, 6652, 13369) }, + { AOM_CDF7(401, 605, 1029, 2563, 5845, 12626) } }, + { { AOM_CDF7(8609, 10612, 14624, 18714, 22614, 29024) }, + { AOM_CDF7(1923, 3127, 5867, 9703, 14277, 27100) } } + }, .eob_bin_128 = { + { { AOM_CDF8(685, 933, 1488, 2714, 4766, 8562, 19254) }, + { AOM_CDF8(217, 352, 618, 2303, 5261, 9969, 17472) } }, + { { AOM_CDF8(8045, 11200, 15497, 19595, 23948, 27408, 30938) }, + { AOM_CDF8(2310, 4160, 7471, 14997, 17931, 20768, 30240) } } + }, .eob_bin_256 = { + { { AOM_CDF9(1448, 2109, 4151, 6263, 9329, 13260, 17944, 23300) }, + { AOM_CDF9(399, 1019, 1749, 3038, 10444, 15546, 22739, 27294) } }, + { { AOM_CDF9(6402, 8148, 12623, 15072, 18728, 22847, 26447, 29377) }, + { AOM_CDF9(1674, 3252, 5734, 10159, 22397, 23802, 24821, 30940) } } + }, .eob_bin_512 = { + { { AOM_CDF10(1230, 2278, 5035, 7776, 11871, 15346, 19590, + 24584, 28749) }, + { AOM_CDF10(3277, 6554, 9830, 13107, 16384, 19661, 22938, + 26214, 29491) } }, + { { AOM_CDF10(7265, 9979, 15819, 19250, 21780, 23846, 26478, + 28396, 31811) }, + { AOM_CDF10(3277, 6554, 9830, 13107, 16384, 19661, 22938, + 26214, 29491) } } + }, .eob_bin_1024 = { + { { AOM_CDF11(696, 948, 3145, 5702, 9706, 13217, 17851, + 21856, 25692, 28034) }, + { AOM_CDF11(2979, 5958, 8937, 11916, 14895, 17873, 20852, + 23831, 26810, 29789) } }, + { { AOM_CDF11(2672, 3591, 9330, 17084, 22725, 24284, 26527, + 28027, 28377, 30876) }, + { AOM_CDF11(2979, 5958, 8937, 11916, 14895, 17873, 20852, + 23831, 26810, 29789) } } + }, .eob_hi_bit = { + { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(17471) }, { AOM_CDF2(20223) }, { AOM_CDF2(11357) }, + { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } }, + { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(20335) }, { AOM_CDF2(21667) }, { AOM_CDF2(14818) }, + { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } } }, + { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(20430) }, { AOM_CDF2(20662) }, { AOM_CDF2(15367) }, + { AOM_CDF2(16970) }, { AOM_CDF2(14657) }, { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } }, + { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(22117) }, { AOM_CDF2(22028) }, { AOM_CDF2(18650) }, + { AOM_CDF2(16042) }, { AOM_CDF2(15885) }, { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } } }, + { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(22409) }, { AOM_CDF2(21012) }, { AOM_CDF2(15650) }, + { AOM_CDF2(17395) }, { AOM_CDF2(15469) }, { AOM_CDF2(20205) }, + { AOM_CDF2(19511) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } }, + { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(24220) }, { AOM_CDF2(22480) }, { AOM_CDF2(17737) }, + { AOM_CDF2(18916) }, { AOM_CDF2(19268) }, { AOM_CDF2(18412) }, + { AOM_CDF2(18844) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } } }, + { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(25991) }, { AOM_CDF2(20314) }, { AOM_CDF2(17731) }, + { AOM_CDF2(19678) }, { AOM_CDF2(18649) }, { AOM_CDF2(17307) }, + { AOM_CDF2(21798) }, { AOM_CDF2(17549) }, { AOM_CDF2(15630) } }, + { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(26585) }, { AOM_CDF2(21469) }, { AOM_CDF2(20432) }, + { AOM_CDF2(17735) }, { AOM_CDF2(19280) }, { AOM_CDF2(15235) }, + { AOM_CDF2(20297) }, { AOM_CDF2(22471) }, { AOM_CDF2(28997) } } }, + { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(26605) }, { AOM_CDF2(11304) }, { AOM_CDF2(16726) }, + { AOM_CDF2(16560) }, { AOM_CDF2(20866) }, { AOM_CDF2(23524) }, + { AOM_CDF2(19878) }, { AOM_CDF2(13469) }, { AOM_CDF2(23084) } }, + { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } } } + }, .eob_base_tok = { + { { { AOM_CDF3(17560, 29888) }, + { AOM_CDF3(29671, 31549) }, + { AOM_CDF3(31007, 32056) }, + { AOM_CDF3(27286, 30006) } }, + { { AOM_CDF3(26594, 31212) }, + { AOM_CDF3(31208, 32582) }, + { AOM_CDF3(31835, 32637) }, + { AOM_CDF3(30595, 32206) } } }, + { { { AOM_CDF3(15239, 29932) }, + { AOM_CDF3(31315, 32095) }, + { AOM_CDF3(32130, 32434) }, + { AOM_CDF3(30864, 31996) } }, + { { AOM_CDF3(26279, 30968) }, + { AOM_CDF3(31142, 32495) }, + { AOM_CDF3(31713, 32540) }, + { AOM_CDF3(31929, 32594) } } }, + { { { AOM_CDF3(2644, 25198) }, + { AOM_CDF3(32038, 32451) }, + { AOM_CDF3(32639, 32695) }, + { AOM_CDF3(32166, 32518) } }, + { { AOM_CDF3(17187, 27668) }, + { AOM_CDF3(31714, 32550) }, + { AOM_CDF3(32283, 32678) }, + { AOM_CDF3(31930, 32563) } } }, + { { { AOM_CDF3(1044, 2257) }, + { AOM_CDF3(30755, 31923) }, + { AOM_CDF3(32208, 32693) }, + { AOM_CDF3(32244, 32615) } }, + { { AOM_CDF3(21317, 26207) }, + { AOM_CDF3(29133, 30868) }, + { AOM_CDF3(29311, 31231) }, + { AOM_CDF3(29657, 31087) } } }, + { { { AOM_CDF3(478, 1834) }, + { AOM_CDF3(31005, 31987) }, + { AOM_CDF3(32317, 32724) }, + { AOM_CDF3(30865, 32648) } }, + { { AOM_CDF3(10923, 21845) }, + { AOM_CDF3(10923, 21845) }, + { AOM_CDF3(10923, 21845) }, + { AOM_CDF3(10923, 21845) } } } + }, .base_tok = { + { { { AOM_CDF4(6041, 11854, 15927) }, + { AOM_CDF4(20326, 30905, 32251) }, + { AOM_CDF4(14164, 26831, 30725) }, + { AOM_CDF4(9760, 20647, 26585) }, + { AOM_CDF4(6416, 14953, 21219) }, + { AOM_CDF4(2966, 7151, 10891) }, + { AOM_CDF4(23567, 31374, 32254) }, + { AOM_CDF4(14978, 27416, 30946) }, + { AOM_CDF4(9434, 20225, 26254) }, + { AOM_CDF4(6658, 14558, 20535) }, + { AOM_CDF4(3916, 8677, 12989) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(18088, 29545, 31587) }, + { AOM_CDF4(13062, 25843, 30073) }, + { AOM_CDF4(8940, 16827, 22251) }, + { AOM_CDF4(7654, 13220, 17973) }, + { AOM_CDF4(5733, 10316, 14456) }, + { AOM_CDF4(22879, 31388, 32114) }, + { AOM_CDF4(15215, 27993, 30955) }, + { AOM_CDF4(9397, 19445, 24978) }, + { AOM_CDF4(3442, 9813, 15344) }, + { AOM_CDF4(1368, 3936, 6532) }, + { AOM_CDF4(25494, 32033, 32406) }, + { AOM_CDF4(16772, 27963, 30718) }, + { AOM_CDF4(9419, 18165, 23260) }, + { AOM_CDF4(2677, 7501, 11797) }, + { AOM_CDF4(1516, 4344, 7170) }, + { AOM_CDF4(26556, 31454, 32101) }, + { AOM_CDF4(17128, 27035, 30108) }, + { AOM_CDF4(8324, 15344, 20249) }, + { AOM_CDF4(1903, 5696, 9469) }, + { AOM_CDF4(8192, 16384, 24576) } }, + { { AOM_CDF4(8455, 19003, 24368) }, + { AOM_CDF4(23563, 32021, 32604) }, + { AOM_CDF4(16237, 29446, 31935) }, + { AOM_CDF4(10724, 23999, 29358) }, + { AOM_CDF4(6725, 17528, 24416) }, + { AOM_CDF4(3927, 10927, 16825) }, + { AOM_CDF4(26313, 32288, 32634) }, + { AOM_CDF4(17430, 30095, 32095) }, + { AOM_CDF4(11116, 24606, 29679) }, + { AOM_CDF4(7195, 18384, 25269) }, + { AOM_CDF4(4726, 12852, 19315) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(22822, 31648, 32483) }, + { AOM_CDF4(16724, 29633, 31929) }, + { AOM_CDF4(10261, 23033, 28725) }, + { AOM_CDF4(7029, 17840, 24528) }, + { AOM_CDF4(4867, 13886, 21502) }, + { AOM_CDF4(25298, 31892, 32491) }, + { AOM_CDF4(17809, 29330, 31512) }, + { AOM_CDF4(9668, 21329, 26579) }, + { AOM_CDF4(4774, 12956, 18976) }, + { AOM_CDF4(2322, 7030, 11540) }, + { AOM_CDF4(25472, 31920, 32543) }, + { AOM_CDF4(17957, 29387, 31632) }, + { AOM_CDF4(9196, 20593, 26400) }, + { AOM_CDF4(4680, 12705, 19202) }, + { AOM_CDF4(2917, 8456, 13436) }, + { AOM_CDF4(26471, 32059, 32574) }, + { AOM_CDF4(18458, 29783, 31909) }, + { AOM_CDF4(8400, 19464, 25956) }, + { AOM_CDF4(3812, 10973, 17206) }, + { AOM_CDF4(8192, 16384, 24576) } } }, + { { { AOM_CDF4(6779, 13743, 17678) }, + { AOM_CDF4(24806, 31797, 32457) }, + { AOM_CDF4(17616, 29047, 31372) }, + { AOM_CDF4(11063, 23175, 28003) }, + { AOM_CDF4(6521, 16110, 22324) }, + { AOM_CDF4(2764, 7504, 11654) }, + { AOM_CDF4(25266, 32367, 32637) }, + { AOM_CDF4(19054, 30553, 32175) }, + { AOM_CDF4(12139, 25212, 29807) }, + { AOM_CDF4(7311, 18162, 24704) }, + { AOM_CDF4(3397, 9164, 14074) }, + { AOM_CDF4(25988, 32208, 32522) }, + { AOM_CDF4(16253, 28912, 31526) }, + { AOM_CDF4(9151, 21387, 27372) }, + { AOM_CDF4(5688, 14915, 21496) }, + { AOM_CDF4(2717, 7627, 12004) }, + { AOM_CDF4(23144, 31855, 32443) }, + { AOM_CDF4(16070, 28491, 31325) }, + { AOM_CDF4(8702, 20467, 26517) }, + { AOM_CDF4(5243, 13956, 20367) }, + { AOM_CDF4(2621, 7335, 11567) }, + { AOM_CDF4(26636, 32340, 32630) }, + { AOM_CDF4(19990, 31050, 32341) }, + { AOM_CDF4(13243, 26105, 30315) }, + { AOM_CDF4(8588, 19521, 25918) }, + { AOM_CDF4(4717, 11585, 17304) }, + { AOM_CDF4(25844, 32292, 32582) }, + { AOM_CDF4(19090, 30635, 32097) }, + { AOM_CDF4(11963, 24546, 28939) }, + { AOM_CDF4(6218, 16087, 22354) }, + { AOM_CDF4(2340, 6608, 10426) }, + { AOM_CDF4(28046, 32576, 32694) }, + { AOM_CDF4(21178, 31313, 32296) }, + { AOM_CDF4(13486, 26184, 29870) }, + { AOM_CDF4(7149, 17871, 23723) }, + { AOM_CDF4(2833, 7958, 12259) }, + { AOM_CDF4(27710, 32528, 32686) }, + { AOM_CDF4(20674, 31076, 32268) }, + { AOM_CDF4(12413, 24955, 29243) }, + { AOM_CDF4(6676, 16927, 23097) }, + { AOM_CDF4(2966, 8333, 12919) } }, + { { AOM_CDF4(8639, 19339, 24429) }, + { AOM_CDF4(24404, 31837, 32525) }, + { AOM_CDF4(16997, 29425, 31784) }, + { AOM_CDF4(11253, 24234, 29149) }, + { AOM_CDF4(6751, 17394, 24028) }, + { AOM_CDF4(3490, 9830, 15191) }, + { AOM_CDF4(26283, 32471, 32714) }, + { AOM_CDF4(19599, 31168, 32442) }, + { AOM_CDF4(13146, 26954, 30893) }, + { AOM_CDF4(8214, 20588, 26890) }, + { AOM_CDF4(4699, 13081, 19300) }, + { AOM_CDF4(28212, 32458, 32669) }, + { AOM_CDF4(18594, 30316, 32100) }, + { AOM_CDF4(11219, 24408, 29234) }, + { AOM_CDF4(6865, 17656, 24149) }, + { AOM_CDF4(3678, 10362, 16006) }, + { AOM_CDF4(25825, 32136, 32616) }, + { AOM_CDF4(17313, 29853, 32021) }, + { AOM_CDF4(11197, 24471, 29472) }, + { AOM_CDF4(6947, 17781, 24405) }, + { AOM_CDF4(3768, 10660, 16261) }, + { AOM_CDF4(27352, 32500, 32706) }, + { AOM_CDF4(20850, 31468, 32469) }, + { AOM_CDF4(14021, 27707, 31133) }, + { AOM_CDF4(8964, 21748, 27838) }, + { AOM_CDF4(5437, 14665, 21187) }, + { AOM_CDF4(26304, 32492, 32698) }, + { AOM_CDF4(20409, 31380, 32385) }, + { AOM_CDF4(13682, 27222, 30632) }, + { AOM_CDF4(8974, 21236, 26685) }, + { AOM_CDF4(4234, 11665, 16934) }, + { AOM_CDF4(26273, 32357, 32711) }, + { AOM_CDF4(20672, 31242, 32441) }, + { AOM_CDF4(14172, 27254, 30902) }, + { AOM_CDF4(9870, 21898, 27275) }, + { AOM_CDF4(5164, 13506, 19270) }, + { AOM_CDF4(26725, 32459, 32728) }, + { AOM_CDF4(20991, 31442, 32527) }, + { AOM_CDF4(13071, 26434, 30811) }, + { AOM_CDF4(8184, 20090, 26742) }, + { AOM_CDF4(4803, 13255, 19895) } } }, + { { { AOM_CDF4(7555, 14942, 18501) }, + { AOM_CDF4(24410, 31178, 32287) }, + { AOM_CDF4(14394, 26738, 30253) }, + { AOM_CDF4(8413, 19554, 25195) }, + { AOM_CDF4(4766, 12924, 18785) }, + { AOM_CDF4(2029, 5806, 9207) }, + { AOM_CDF4(26776, 32364, 32663) }, + { AOM_CDF4(18732, 29967, 31931) }, + { AOM_CDF4(11005, 23786, 28852) }, + { AOM_CDF4(6466, 16909, 23510) }, + { AOM_CDF4(3044, 8638, 13419) }, + { AOM_CDF4(29208, 32582, 32704) }, + { AOM_CDF4(20068, 30857, 32208) }, + { AOM_CDF4(12003, 25085, 29595) }, + { AOM_CDF4(6947, 17750, 24189) }, + { AOM_CDF4(3245, 9103, 14007) }, + { AOM_CDF4(27359, 32465, 32669) }, + { AOM_CDF4(19421, 30614, 32174) }, + { AOM_CDF4(11915, 25010, 29579) }, + { AOM_CDF4(6950, 17676, 24074) }, + { AOM_CDF4(3007, 8473, 13096) }, + { AOM_CDF4(29002, 32676, 32735) }, + { AOM_CDF4(22102, 31849, 32576) }, + { AOM_CDF4(14408, 28009, 31405) }, + { AOM_CDF4(9027, 21679, 27931) }, + { AOM_CDF4(4694, 12678, 18748) }, + { AOM_CDF4(28216, 32528, 32682) }, + { AOM_CDF4(20849, 31264, 32318) }, + { AOM_CDF4(12756, 25815, 29751) }, + { AOM_CDF4(7565, 18801, 24923) }, + { AOM_CDF4(3509, 9533, 14477) }, + { AOM_CDF4(30133, 32687, 32739) }, + { AOM_CDF4(23063, 31910, 32515) }, + { AOM_CDF4(14588, 28051, 31132) }, + { AOM_CDF4(9085, 21649, 27457) }, + { AOM_CDF4(4261, 11654, 17264) }, + { AOM_CDF4(29518, 32691, 32748) }, + { AOM_CDF4(22451, 31959, 32613) }, + { AOM_CDF4(14864, 28722, 31700) }, + { AOM_CDF4(9695, 22964, 28716) }, + { AOM_CDF4(4932, 13358, 19502) } }, + { { AOM_CDF4(6465, 16958, 21688) }, + { AOM_CDF4(25199, 31514, 32360) }, + { AOM_CDF4(14774, 27149, 30607) }, + { AOM_CDF4(9257, 21438, 26972) }, + { AOM_CDF4(5723, 15183, 21882) }, + { AOM_CDF4(3150, 8879, 13731) }, + { AOM_CDF4(26989, 32262, 32682) }, + { AOM_CDF4(17396, 29937, 32085) }, + { AOM_CDF4(11387, 24901, 29784) }, + { AOM_CDF4(7289, 18821, 25548) }, + { AOM_CDF4(3734, 10577, 16086) }, + { AOM_CDF4(29728, 32501, 32695) }, + { AOM_CDF4(17431, 29701, 31903) }, + { AOM_CDF4(9921, 22826, 28300) }, + { AOM_CDF4(5896, 15434, 22068) }, + { AOM_CDF4(3430, 9646, 14757) }, + { AOM_CDF4(28614, 32511, 32705) }, + { AOM_CDF4(19364, 30638, 32263) }, + { AOM_CDF4(13129, 26254, 30402) }, + { AOM_CDF4(8754, 20484, 26440) }, + { AOM_CDF4(4378, 11607, 17110) }, + { AOM_CDF4(30292, 32671, 32744) }, + { AOM_CDF4(21780, 31603, 32501) }, + { AOM_CDF4(14314, 27829, 31291) }, + { AOM_CDF4(9611, 22327, 28263) }, + { AOM_CDF4(4890, 13087, 19065) }, + { AOM_CDF4(25862, 32567, 32733) }, + { AOM_CDF4(20794, 32050, 32567) }, + { AOM_CDF4(17243, 30625, 32254) }, + { AOM_CDF4(13283, 27628, 31474) }, + { AOM_CDF4(9669, 22532, 28918) }, + { AOM_CDF4(27435, 32697, 32748) }, + { AOM_CDF4(24922, 32390, 32714) }, + { AOM_CDF4(21449, 31504, 32536) }, + { AOM_CDF4(16392, 29729, 31832) }, + { AOM_CDF4(11692, 24884, 29076) }, + { AOM_CDF4(24193, 32290, 32735) }, + { AOM_CDF4(18909, 31104, 32563) }, + { AOM_CDF4(12236, 26841, 31403) }, + { AOM_CDF4(8171, 21840, 29082) }, + { AOM_CDF4(7224, 17280, 25275) } } }, + { { { AOM_CDF4(3078, 6839, 9890) }, + { AOM_CDF4(13837, 20450, 24479) }, + { AOM_CDF4(5914, 14222, 19328) }, + { AOM_CDF4(3866, 10267, 14762) }, + { AOM_CDF4(2612, 7208, 11042) }, + { AOM_CDF4(1067, 2991, 4776) }, + { AOM_CDF4(25817, 31646, 32529) }, + { AOM_CDF4(13708, 26338, 30385) }, + { AOM_CDF4(7328, 18585, 24870) }, + { AOM_CDF4(4691, 13080, 19276) }, + { AOM_CDF4(1825, 5253, 8352) }, + { AOM_CDF4(29386, 32315, 32624) }, + { AOM_CDF4(17160, 29001, 31360) }, + { AOM_CDF4(9602, 21862, 27396) }, + { AOM_CDF4(5915, 15772, 22148) }, + { AOM_CDF4(2786, 7779, 12047) }, + { AOM_CDF4(29246, 32450, 32663) }, + { AOM_CDF4(18696, 29929, 31818) }, + { AOM_CDF4(10510, 23369, 28560) }, + { AOM_CDF4(6229, 16499, 23125) }, + { AOM_CDF4(2608, 7448, 11705) }, + { AOM_CDF4(30753, 32710, 32748) }, + { AOM_CDF4(21638, 31487, 32503) }, + { AOM_CDF4(12937, 26854, 30870) }, + { AOM_CDF4(8182, 20596, 26970) }, + { AOM_CDF4(3637, 10269, 15497) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) } }, + { { AOM_CDF4(5244, 12150, 16906) }, + { AOM_CDF4(20486, 26858, 29701) }, + { AOM_CDF4(7756, 18317, 23735) }, + { AOM_CDF4(3452, 9256, 13146) }, + { AOM_CDF4(2020, 5206, 8229) }, + { AOM_CDF4(1801, 4993, 7903) }, + { AOM_CDF4(27051, 31858, 32531) }, + { AOM_CDF4(15988, 27531, 30619) }, + { AOM_CDF4(9188, 21484, 26719) }, + { AOM_CDF4(6273, 17186, 23800) }, + { AOM_CDF4(3108, 9355, 14764) }, + { AOM_CDF4(31076, 32520, 32680) }, + { AOM_CDF4(18119, 30037, 31850) }, + { AOM_CDF4(10244, 22969, 27472) }, + { AOM_CDF4(4692, 14077, 19273) }, + { AOM_CDF4(3694, 11677, 17556) }, + { AOM_CDF4(30060, 32581, 32720) }, + { AOM_CDF4(21011, 30775, 32120) }, + { AOM_CDF4(11931, 24820, 29289) }, + { AOM_CDF4(7119, 17662, 24356) }, + { AOM_CDF4(3833, 10706, 16304) }, + { AOM_CDF4(31954, 32731, 32748) }, + { AOM_CDF4(23913, 31724, 32489) }, + { AOM_CDF4(15520, 28060, 31286) }, + { AOM_CDF4(11517, 23008, 28571) }, + { AOM_CDF4(6193, 14508, 20629) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) } } }, + { { { AOM_CDF4(1035, 2807, 4156) }, + { AOM_CDF4(13162, 18138, 20939) }, + { AOM_CDF4(2696, 6633, 8755) }, + { AOM_CDF4(1373, 4161, 6853) }, + { AOM_CDF4(1099, 2746, 4716) }, + { AOM_CDF4(340, 1021, 1599) }, + { AOM_CDF4(22826, 30419, 32135) }, + { AOM_CDF4(10395, 21762, 26942) }, + { AOM_CDF4(4726, 12407, 17361) }, + { AOM_CDF4(2447, 7080, 10593) }, + { AOM_CDF4(1227, 3717, 6011) }, + { AOM_CDF4(28156, 31424, 31934) }, + { AOM_CDF4(16915, 27754, 30373) }, + { AOM_CDF4(9148, 20990, 26431) }, + { AOM_CDF4(5950, 15515, 21148) }, + { AOM_CDF4(2492, 7327, 11526) }, + { AOM_CDF4(30602, 32477, 32670) }, + { AOM_CDF4(20026, 29955, 31568) }, + { AOM_CDF4(11220, 23628, 28105) }, + { AOM_CDF4(6652, 17019, 22973) }, + { AOM_CDF4(3064, 8536, 13043) }, + { AOM_CDF4(31769, 32724, 32748) }, + { AOM_CDF4(22230, 30887, 32373) }, + { AOM_CDF4(12234, 25079, 29731) }, + { AOM_CDF4(7326, 18816, 25353) }, + { AOM_CDF4(3933, 10907, 16616) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) } }, + { { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) } } } + }, .dc_sign = { + { + { AOM_CDF2(128 * 125) }, + { AOM_CDF2(128 * 102) }, + { AOM_CDF2(128 * 147) }, + }, + { + { AOM_CDF2(128 * 119) }, + { AOM_CDF2(128 * 101) }, + { AOM_CDF2(128 * 135) }, + } + }, .br_tok = { + { { { AOM_CDF4(14995, 21341, 24749) }, + { AOM_CDF4(13158, 20289, 24601) }, + { AOM_CDF4(8941, 15326, 19876) }, + { AOM_CDF4(6297, 11541, 15807) }, + { AOM_CDF4(4817, 9029, 12776) }, + { AOM_CDF4(3731, 7273, 10627) }, + { AOM_CDF4(1847, 3617, 5354) }, + { AOM_CDF4(14472, 19659, 22343) }, + { AOM_CDF4(16806, 24162, 27533) }, + { AOM_CDF4(12900, 20404, 24713) }, + { AOM_CDF4(9411, 16112, 20797) }, + { AOM_CDF4(7056, 12697, 17148) }, + { AOM_CDF4(5544, 10339, 14460) }, + { AOM_CDF4(2954, 5704, 8319) }, + { AOM_CDF4(12464, 18071, 21354) }, + { AOM_CDF4(15482, 22528, 26034) }, + { AOM_CDF4(12070, 19269, 23624) }, + { AOM_CDF4(8953, 15406, 20106) }, + { AOM_CDF4(7027, 12730, 17220) }, + { AOM_CDF4(5887, 10913, 15140) }, + { AOM_CDF4(3793, 7278, 10447) } }, + { { AOM_CDF4(15571, 22232, 25749) }, + { AOM_CDF4(14506, 21575, 25374) }, + { AOM_CDF4(10189, 17089, 21569) }, + { AOM_CDF4(7316, 13301, 17915) }, + { AOM_CDF4(5783, 10912, 15190) }, + { AOM_CDF4(4760, 9155, 13088) }, + { AOM_CDF4(2993, 5966, 8774) }, + { AOM_CDF4(23424, 28903, 30778) }, + { AOM_CDF4(20775, 27666, 30290) }, + { AOM_CDF4(16474, 24410, 28299) }, + { AOM_CDF4(12471, 20180, 24987) }, + { AOM_CDF4(9410, 16487, 21439) }, + { AOM_CDF4(7536, 13614, 18529) }, + { AOM_CDF4(5048, 9586, 13549) }, + { AOM_CDF4(21090, 27290, 29756) }, + { AOM_CDF4(20796, 27402, 30026) }, + { AOM_CDF4(17819, 25485, 28969) }, + { AOM_CDF4(13860, 21909, 26462) }, + { AOM_CDF4(11002, 18494, 23529) }, + { AOM_CDF4(8953, 15929, 20897) }, + { AOM_CDF4(6448, 11918, 16454) } } }, + { { { AOM_CDF4(15999, 22208, 25449) }, + { AOM_CDF4(13050, 19988, 24122) }, + { AOM_CDF4(8594, 14864, 19378) }, + { AOM_CDF4(6033, 11079, 15238) }, + { AOM_CDF4(4554, 8683, 12347) }, + { AOM_CDF4(3672, 7139, 10337) }, + { AOM_CDF4(1900, 3771, 5576) }, + { AOM_CDF4(15788, 21340, 23949) }, + { AOM_CDF4(16825, 24235, 27758) }, + { AOM_CDF4(12873, 20402, 24810) }, + { AOM_CDF4(9590, 16363, 21094) }, + { AOM_CDF4(7352, 13209, 17733) }, + { AOM_CDF4(5960, 10989, 15184) }, + { AOM_CDF4(3232, 6234, 9007) }, + { AOM_CDF4(15761, 20716, 23224) }, + { AOM_CDF4(19318, 25989, 28759) }, + { AOM_CDF4(15529, 23094, 26929) }, + { AOM_CDF4(11662, 18989, 23641) }, + { AOM_CDF4(8955, 15568, 20366) }, + { AOM_CDF4(7281, 13106, 17708) }, + { AOM_CDF4(4248, 8059, 11440) } }, + { { AOM_CDF4(14899, 21217, 24503) }, + { AOM_CDF4(13519, 20283, 24047) }, + { AOM_CDF4(9429, 15966, 20365) }, + { AOM_CDF4(6700, 12355, 16652) }, + { AOM_CDF4(5088, 9704, 13716) }, + { AOM_CDF4(4243, 8154, 11731) }, + { AOM_CDF4(2702, 5364, 7861) }, + { AOM_CDF4(22745, 28388, 30454) }, + { AOM_CDF4(20235, 27146, 29922) }, + { AOM_CDF4(15896, 23715, 27637) }, + { AOM_CDF4(11840, 19350, 24131) }, + { AOM_CDF4(9122, 15932, 20880) }, + { AOM_CDF4(7488, 13581, 18362) }, + { AOM_CDF4(5114, 9568, 13370) }, + { AOM_CDF4(20845, 26553, 28932) }, + { AOM_CDF4(20981, 27372, 29884) }, + { AOM_CDF4(17781, 25335, 28785) }, + { AOM_CDF4(13760, 21708, 26297) }, + { AOM_CDF4(10975, 18415, 23365) }, + { AOM_CDF4(9045, 15789, 20686) }, + { AOM_CDF4(6130, 11199, 15423) } } }, + { { { AOM_CDF4(13549, 19724, 23158) }, + { AOM_CDF4(11844, 18382, 22246) }, + { AOM_CDF4(7919, 13619, 17773) }, + { AOM_CDF4(5486, 10143, 13946) }, + { AOM_CDF4(4166, 7983, 11324) }, + { AOM_CDF4(3364, 6506, 9427) }, + { AOM_CDF4(1598, 3160, 4674) }, + { AOM_CDF4(15281, 20979, 23781) }, + { AOM_CDF4(14939, 22119, 25952) }, + { AOM_CDF4(11363, 18407, 22812) }, + { AOM_CDF4(8609, 14857, 19370) }, + { AOM_CDF4(6737, 12184, 16480) }, + { AOM_CDF4(5506, 10263, 14262) }, + { AOM_CDF4(2990, 5786, 8380) }, + { AOM_CDF4(20249, 25253, 27417) }, + { AOM_CDF4(21070, 27518, 30001) }, + { AOM_CDF4(16854, 24469, 28074) }, + { AOM_CDF4(12864, 20486, 25000) }, + { AOM_CDF4(9962, 16978, 21778) }, + { AOM_CDF4(8074, 14338, 19048) }, + { AOM_CDF4(4494, 8479, 11906) } }, + { { AOM_CDF4(13960, 19617, 22829) }, + { AOM_CDF4(11150, 17341, 21228) }, + { AOM_CDF4(7150, 12964, 17190) }, + { AOM_CDF4(5331, 10002, 13867) }, + { AOM_CDF4(4167, 7744, 11057) }, + { AOM_CDF4(3480, 6629, 9646) }, + { AOM_CDF4(1883, 3784, 5686) }, + { AOM_CDF4(18752, 25660, 28912) }, + { AOM_CDF4(16968, 24586, 28030) }, + { AOM_CDF4(13520, 21055, 25313) }, + { AOM_CDF4(10453, 17626, 22280) }, + { AOM_CDF4(8386, 14505, 19116) }, + { AOM_CDF4(6742, 12595, 17008) }, + { AOM_CDF4(4273, 8140, 11499) }, + { AOM_CDF4(22120, 27827, 30233) }, + { AOM_CDF4(20563, 27358, 29895) }, + { AOM_CDF4(17076, 24644, 28153) }, + { AOM_CDF4(13362, 20942, 25309) }, + { AOM_CDF4(10794, 17965, 22695) }, + { AOM_CDF4(9014, 15652, 20319) }, + { AOM_CDF4(5708, 10512, 14497) } } }, + { { { AOM_CDF4(5705, 10930, 15725) }, + { AOM_CDF4(7946, 12765, 16115) }, + { AOM_CDF4(6801, 12123, 16226) }, + { AOM_CDF4(5462, 10135, 14200) }, + { AOM_CDF4(4189, 8011, 11507) }, + { AOM_CDF4(3191, 6229, 9408) }, + { AOM_CDF4(1057, 2137, 3212) }, + { AOM_CDF4(10018, 17067, 21491) }, + { AOM_CDF4(7380, 12582, 16453) }, + { AOM_CDF4(6068, 10845, 14339) }, + { AOM_CDF4(5098, 9198, 12555) }, + { AOM_CDF4(4312, 8010, 11119) }, + { AOM_CDF4(3700, 6966, 9781) }, + { AOM_CDF4(1693, 3326, 4887) }, + { AOM_CDF4(18757, 24930, 27774) }, + { AOM_CDF4(17648, 24596, 27817) }, + { AOM_CDF4(14707, 22052, 26026) }, + { AOM_CDF4(11720, 18852, 23292) }, + { AOM_CDF4(9357, 15952, 20525) }, + { AOM_CDF4(7810, 13753, 18210) }, + { AOM_CDF4(3879, 7333, 10328) } }, + { { AOM_CDF4(8278, 13242, 15922) }, + { AOM_CDF4(10547, 15867, 18919) }, + { AOM_CDF4(9106, 15842, 20609) }, + { AOM_CDF4(6833, 13007, 17218) }, + { AOM_CDF4(4811, 9712, 13923) }, + { AOM_CDF4(3985, 7352, 11128) }, + { AOM_CDF4(1688, 3458, 5262) }, + { AOM_CDF4(12951, 21861, 26510) }, + { AOM_CDF4(9788, 16044, 20276) }, + { AOM_CDF4(6309, 11244, 14870) }, + { AOM_CDF4(5183, 9349, 12566) }, + { AOM_CDF4(4389, 8229, 11492) }, + { AOM_CDF4(3633, 6945, 10620) }, + { AOM_CDF4(3600, 6847, 9907) }, + { AOM_CDF4(21748, 28137, 30255) }, + { AOM_CDF4(19436, 26581, 29560) }, + { AOM_CDF4(16359, 24201, 27953) }, + { AOM_CDF4(13961, 21693, 25871) }, + { AOM_CDF4(11544, 18686, 23322) }, + { AOM_CDF4(9372, 16462, 20952) }, + { AOM_CDF4(6138, 11210, 15390) } } } + }, + }, [2] = { + .skip = { + { { AOM_CDF2(29614) }, + { AOM_CDF2(9068) }, + { AOM_CDF2(12924) }, + { AOM_CDF2(19538) }, + { AOM_CDF2(17737) }, + { AOM_CDF2(24619) }, + { AOM_CDF2(30642) }, + { AOM_CDF2(4119) }, + { AOM_CDF2(16026) }, + { AOM_CDF2(25657) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) } }, + { { AOM_CDF2(31957) }, + { AOM_CDF2(3230) }, + { AOM_CDF2(11153) }, + { AOM_CDF2(18123) }, + { AOM_CDF2(20143) }, + { AOM_CDF2(26536) }, + { AOM_CDF2(31986) }, + { AOM_CDF2(3050) }, + { AOM_CDF2(14603) }, + { AOM_CDF2(25155) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) } }, + { { AOM_CDF2(32363) }, + { AOM_CDF2(10692) }, + { AOM_CDF2(19090) }, + { AOM_CDF2(24357) }, + { AOM_CDF2(24442) }, + { AOM_CDF2(28312) }, + { AOM_CDF2(32169) }, + { AOM_CDF2(3648) }, + { AOM_CDF2(15690) }, + { AOM_CDF2(26815) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) } }, + { { AOM_CDF2(30669) }, + { AOM_CDF2(3832) }, + { AOM_CDF2(11663) }, + { AOM_CDF2(18889) }, + { AOM_CDF2(19782) }, + { AOM_CDF2(23313) }, + { AOM_CDF2(31330) }, + { AOM_CDF2(5124) }, + { AOM_CDF2(18719) }, + { AOM_CDF2(28468) }, + { AOM_CDF2(3082) }, + { AOM_CDF2(20982) }, + { AOM_CDF2(29443) } }, + { { AOM_CDF2(28573) }, + { AOM_CDF2(3183) }, + { AOM_CDF2(17802) }, + { AOM_CDF2(25977) }, + { AOM_CDF2(26677) }, + { AOM_CDF2(27832) }, + { AOM_CDF2(32387) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) } } + }, .eob_bin_16 = { + { { AOM_CDF5(4016, 4897, 8881, 14968) }, + { AOM_CDF5(716, 1105, 2646, 10056) } }, + { { AOM_CDF5(11139, 13270, 18241, 23566) }, + { AOM_CDF5(3192, 5032, 10297, 19755) } } + }, .eob_bin_32 = { + { { AOM_CDF6(2515, 3003, 4452, 8162, 16041) }, + { AOM_CDF6(574, 821, 1836, 5089, 13128) } }, + { { AOM_CDF6(13468, 16303, 20361, 25105, 29281) }, + { AOM_CDF6(3542, 5502, 10415, 16760, 25644) } } + }, .eob_bin_64 = { + { { AOM_CDF7(2374, 2772, 4583, 7276, 12288, 19706) }, + { AOM_CDF7(497, 810, 1315, 3000, 7004, 15641) } }, + { { AOM_CDF7(15050, 17126, 21410, 24886, 28156, 30726) }, + { AOM_CDF7(4034, 6290, 10235, 14982, 21214, 28491) } } + }, .eob_bin_128 = { + { { AOM_CDF8(1366, 1738, 2527, 5016, 9355, 15797, 24643) }, + { AOM_CDF8(354, 558, 944, 2760, 7287, 14037, 21779) } }, + { { AOM_CDF8(13627, 16246, 20173, 24429, 27948, 30415, 31863) }, + { AOM_CDF8(6275, 9889, 14769, 23164, 27988, 30493, 32272) } } + }, .eob_bin_256 = { + { { AOM_CDF9(3089, 3920, 6038, 9460, 14266, 19881, 25766, 29176) }, + { AOM_CDF9(1084, 2358, 3488, 5122, 11483, 18103, 26023, 29799) } }, + { { AOM_CDF9(11514, 13794, 17480, 20754, 24361, 27378, 29492, 31277) }, + { AOM_CDF9(6571, 9610, 15516, 21826, 29092, 30829, 31842, 32708) } } + }, .eob_bin_512 = { + { { AOM_CDF10(2624, 3936, 6480, 9686, 13979, 17726, 23267, + 28410, 31078) }, + { AOM_CDF10(3277, 6554, 9830, 13107, 16384, 19661, 22938, + 26214, 29491) } }, + { { AOM_CDF10(12015, 14769, 19588, 22052, 24222, 25812, + 27300, 29219, 32114) }, + { AOM_CDF10(3277, 6554, 9830, 13107, 16384, 19661, 22938, + 26214, 29491) } } + }, .eob_bin_1024 = { + { { AOM_CDF11(2784, 3831, 7041, 10521, 14847, 18844, 23155, + 26682, 29229, 31045) }, + { AOM_CDF11(2979, 5958, 8937, 11916, 14895, 17873, 20852, + 23831, 26810, 29789) } }, + { { AOM_CDF11(9577, 12466, 17739, 20750, 22061, 23215, 24601, + 25483, 25843, 32056) }, + { AOM_CDF11(2979, 5958, 8937, 11916, 14895, 17873, 20852, + 23831, 26810, 29789) } } + }, .eob_hi_bit = { + { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(18983) }, { AOM_CDF2(20512) }, { AOM_CDF2(14885) }, + { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } }, + { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(20090) }, { AOM_CDF2(19444) }, { AOM_CDF2(17286) }, + { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } } }, + { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(19139) }, { AOM_CDF2(21487) }, { AOM_CDF2(18959) }, + { AOM_CDF2(20910) }, { AOM_CDF2(19089) }, { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } }, + { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(20536) }, { AOM_CDF2(20664) }, { AOM_CDF2(20625) }, + { AOM_CDF2(19123) }, { AOM_CDF2(14862) }, { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } } }, + { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(19833) }, { AOM_CDF2(21502) }, { AOM_CDF2(17485) }, + { AOM_CDF2(20267) }, { AOM_CDF2(18353) }, { AOM_CDF2(23329) }, + { AOM_CDF2(21478) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } }, + { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(22041) }, { AOM_CDF2(23434) }, { AOM_CDF2(20001) }, + { AOM_CDF2(20554) }, { AOM_CDF2(20951) }, { AOM_CDF2(20145) }, + { AOM_CDF2(15562) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } } }, + { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(23312) }, { AOM_CDF2(21607) }, { AOM_CDF2(16526) }, + { AOM_CDF2(18957) }, { AOM_CDF2(18034) }, { AOM_CDF2(18934) }, + { AOM_CDF2(24247) }, { AOM_CDF2(16921) }, { AOM_CDF2(17080) } }, + { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(26579) }, { AOM_CDF2(24910) }, { AOM_CDF2(18637) }, + { AOM_CDF2(19800) }, { AOM_CDF2(20388) }, { AOM_CDF2(9887) }, + { AOM_CDF2(15642) }, { AOM_CDF2(30198) }, { AOM_CDF2(24721) } } }, + { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(26998) }, { AOM_CDF2(16737) }, { AOM_CDF2(17838) }, + { AOM_CDF2(18922) }, { AOM_CDF2(19515) }, { AOM_CDF2(18636) }, + { AOM_CDF2(17333) }, { AOM_CDF2(15776) }, { AOM_CDF2(22658) } }, + { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } } } + }, .eob_base_tok = { + { { { AOM_CDF3(20092, 30774) }, + { AOM_CDF3(30695, 32020) }, + { AOM_CDF3(31131, 32103) }, + { AOM_CDF3(28666, 30870) } }, + { { AOM_CDF3(27258, 31095) }, + { AOM_CDF3(31804, 32623) }, + { AOM_CDF3(31763, 32528) }, + { AOM_CDF3(31438, 32506) } } }, + { { { AOM_CDF3(18049, 30489) }, + { AOM_CDF3(31706, 32286) }, + { AOM_CDF3(32163, 32473) }, + { AOM_CDF3(31550, 32184) } }, + { { AOM_CDF3(27116, 30842) }, + { AOM_CDF3(31971, 32598) }, + { AOM_CDF3(32088, 32576) }, + { AOM_CDF3(32067, 32664) } } }, + { { { AOM_CDF3(12854, 29093) }, + { AOM_CDF3(32272, 32558) }, + { AOM_CDF3(32667, 32729) }, + { AOM_CDF3(32306, 32585) } }, + { { AOM_CDF3(25476, 30366) }, + { AOM_CDF3(32169, 32687) }, + { AOM_CDF3(32479, 32689) }, + { AOM_CDF3(31673, 32634) } } }, + { { { AOM_CDF3(2809, 19301) }, + { AOM_CDF3(32205, 32622) }, + { AOM_CDF3(32338, 32730) }, + { AOM_CDF3(31786, 32616) } }, + { { AOM_CDF3(22737, 29105) }, + { AOM_CDF3(30810, 32362) }, + { AOM_CDF3(30014, 32627) }, + { AOM_CDF3(30528, 32574) } } }, + { { { AOM_CDF3(935, 3382) }, + { AOM_CDF3(30789, 31909) }, + { AOM_CDF3(32466, 32756) }, + { AOM_CDF3(30860, 32513) } }, + { { AOM_CDF3(10923, 21845) }, + { AOM_CDF3(10923, 21845) }, + { AOM_CDF3(10923, 21845) }, + { AOM_CDF3(10923, 21845) } } } + }, .base_tok = { + { { { AOM_CDF4(8896, 16227, 20630) }, + { AOM_CDF4(23629, 31782, 32527) }, + { AOM_CDF4(15173, 27755, 31321) }, + { AOM_CDF4(10158, 21233, 27382) }, + { AOM_CDF4(6420, 14857, 21558) }, + { AOM_CDF4(3269, 8155, 12646) }, + { AOM_CDF4(24835, 32009, 32496) }, + { AOM_CDF4(16509, 28421, 31579) }, + { AOM_CDF4(10957, 21514, 27418) }, + { AOM_CDF4(7881, 15930, 22096) }, + { AOM_CDF4(5388, 10960, 15918) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(20745, 30773, 32093) }, + { AOM_CDF4(15200, 27221, 30861) }, + { AOM_CDF4(13032, 20873, 25667) }, + { AOM_CDF4(12285, 18663, 23494) }, + { AOM_CDF4(11563, 17481, 21489) }, + { AOM_CDF4(26260, 31982, 32320) }, + { AOM_CDF4(15397, 28083, 31100) }, + { AOM_CDF4(9742, 19217, 24824) }, + { AOM_CDF4(3261, 9629, 15362) }, + { AOM_CDF4(1480, 4322, 7499) }, + { AOM_CDF4(27599, 32256, 32460) }, + { AOM_CDF4(16857, 27659, 30774) }, + { AOM_CDF4(9551, 18290, 23748) }, + { AOM_CDF4(3052, 8933, 14103) }, + { AOM_CDF4(2021, 5910, 9787) }, + { AOM_CDF4(29005, 32015, 32392) }, + { AOM_CDF4(17677, 27694, 30863) }, + { AOM_CDF4(9204, 17356, 23219) }, + { AOM_CDF4(2403, 7516, 12814) }, + { AOM_CDF4(8192, 16384, 24576) } }, + { { AOM_CDF4(10808, 22056, 26896) }, + { AOM_CDF4(25739, 32313, 32676) }, + { AOM_CDF4(17288, 30203, 32221) }, + { AOM_CDF4(11359, 24878, 29896) }, + { AOM_CDF4(6949, 17767, 24893) }, + { AOM_CDF4(4287, 11796, 18071) }, + { AOM_CDF4(27880, 32521, 32705) }, + { AOM_CDF4(19038, 31004, 32414) }, + { AOM_CDF4(12564, 26345, 30768) }, + { AOM_CDF4(8269, 19947, 26779) }, + { AOM_CDF4(5674, 14657, 21674) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(25742, 32319, 32671) }, + { AOM_CDF4(19557, 31164, 32454) }, + { AOM_CDF4(13381, 26381, 30755) }, + { AOM_CDF4(10101, 21466, 26722) }, + { AOM_CDF4(9209, 19650, 26825) }, + { AOM_CDF4(27107, 31917, 32432) }, + { AOM_CDF4(18056, 28893, 31203) }, + { AOM_CDF4(10200, 21434, 26764) }, + { AOM_CDF4(4660, 12913, 19502) }, + { AOM_CDF4(2368, 6930, 12504) }, + { AOM_CDF4(26960, 32158, 32613) }, + { AOM_CDF4(18628, 30005, 32031) }, + { AOM_CDF4(10233, 22442, 28232) }, + { AOM_CDF4(5471, 14630, 21516) }, + { AOM_CDF4(3235, 10767, 17109) }, + { AOM_CDF4(27696, 32440, 32692) }, + { AOM_CDF4(20032, 31167, 32438) }, + { AOM_CDF4(8700, 21341, 28442) }, + { AOM_CDF4(5662, 14831, 21795) }, + { AOM_CDF4(8192, 16384, 24576) } } }, + { { { AOM_CDF4(9704, 17294, 21132) }, + { AOM_CDF4(26762, 32278, 32633) }, + { AOM_CDF4(18382, 29620, 31819) }, + { AOM_CDF4(10891, 23475, 28723) }, + { AOM_CDF4(6358, 16583, 23309) }, + { AOM_CDF4(3248, 9118, 14141) }, + { AOM_CDF4(27204, 32573, 32699) }, + { AOM_CDF4(19818, 30824, 32329) }, + { AOM_CDF4(11772, 25120, 30041) }, + { AOM_CDF4(6995, 18033, 25039) }, + { AOM_CDF4(3752, 10442, 16098) }, + { AOM_CDF4(27222, 32256, 32559) }, + { AOM_CDF4(15356, 28399, 31475) }, + { AOM_CDF4(8821, 20635, 27057) }, + { AOM_CDF4(5511, 14404, 21239) }, + { AOM_CDF4(2935, 8222, 13051) }, + { AOM_CDF4(24875, 32120, 32529) }, + { AOM_CDF4(15233, 28265, 31445) }, + { AOM_CDF4(8605, 20570, 26932) }, + { AOM_CDF4(5431, 14413, 21196) }, + { AOM_CDF4(2994, 8341, 13223) }, + { AOM_CDF4(28201, 32604, 32700) }, + { AOM_CDF4(21041, 31446, 32456) }, + { AOM_CDF4(13221, 26213, 30475) }, + { AOM_CDF4(8255, 19385, 26037) }, + { AOM_CDF4(4930, 12585, 18830) }, + { AOM_CDF4(28768, 32448, 32627) }, + { AOM_CDF4(19705, 30561, 32021) }, + { AOM_CDF4(11572, 23589, 28220) }, + { AOM_CDF4(5532, 15034, 21446) }, + { AOM_CDF4(2460, 7150, 11456) }, + { AOM_CDF4(29874, 32619, 32699) }, + { AOM_CDF4(21621, 31071, 32201) }, + { AOM_CDF4(12511, 24747, 28992) }, + { AOM_CDF4(6281, 16395, 22748) }, + { AOM_CDF4(3246, 9278, 14497) }, + { AOM_CDF4(29715, 32625, 32712) }, + { AOM_CDF4(20958, 31011, 32283) }, + { AOM_CDF4(11233, 23671, 28806) }, + { AOM_CDF4(6012, 16128, 22868) }, + { AOM_CDF4(3427, 9851, 15414) } }, + { { AOM_CDF4(11016, 22111, 26794) }, + { AOM_CDF4(25946, 32357, 32677) }, + { AOM_CDF4(17890, 30452, 32252) }, + { AOM_CDF4(11678, 25142, 29816) }, + { AOM_CDF4(6720, 17534, 24584) }, + { AOM_CDF4(4230, 11665, 17820) }, + { AOM_CDF4(28400, 32623, 32747) }, + { AOM_CDF4(21164, 31668, 32575) }, + { AOM_CDF4(13572, 27388, 31182) }, + { AOM_CDF4(8234, 20750, 27358) }, + { AOM_CDF4(5065, 14055, 20897) }, + { AOM_CDF4(28981, 32547, 32705) }, + { AOM_CDF4(18681, 30543, 32239) }, + { AOM_CDF4(10919, 24075, 29286) }, + { AOM_CDF4(6431, 17199, 24077) }, + { AOM_CDF4(3819, 10464, 16618) }, + { AOM_CDF4(26870, 32467, 32693) }, + { AOM_CDF4(19041, 30831, 32347) }, + { AOM_CDF4(11794, 25211, 30016) }, + { AOM_CDF4(6888, 18019, 24970) }, + { AOM_CDF4(4370, 12363, 18992) }, + { AOM_CDF4(29578, 32670, 32744) }, + { AOM_CDF4(23159, 32007, 32613) }, + { AOM_CDF4(15315, 28669, 31676) }, + { AOM_CDF4(9298, 22607, 28782) }, + { AOM_CDF4(6144, 15913, 22968) }, + { AOM_CDF4(28110, 32499, 32669) }, + { AOM_CDF4(21574, 30937, 32015) }, + { AOM_CDF4(12759, 24818, 28727) }, + { AOM_CDF4(6545, 16761, 23042) }, + { AOM_CDF4(3649, 10597, 16833) }, + { AOM_CDF4(28163, 32552, 32728) }, + { AOM_CDF4(22101, 31469, 32464) }, + { AOM_CDF4(13160, 25472, 30143) }, + { AOM_CDF4(7303, 18684, 25468) }, + { AOM_CDF4(5241, 13975, 20955) }, + { AOM_CDF4(28400, 32631, 32744) }, + { AOM_CDF4(22104, 31793, 32603) }, + { AOM_CDF4(13557, 26571, 30846) }, + { AOM_CDF4(7749, 19861, 26675) }, + { AOM_CDF4(4873, 14030, 21234) } } }, + { { { AOM_CDF4(9800, 17635, 21073) }, + { AOM_CDF4(26153, 31885, 32527) }, + { AOM_CDF4(15038, 27852, 31006) }, + { AOM_CDF4(8718, 20564, 26486) }, + { AOM_CDF4(5128, 14076, 20514) }, + { AOM_CDF4(2636, 7566, 11925) }, + { AOM_CDF4(27551, 32504, 32701) }, + { AOM_CDF4(18310, 30054, 32100) }, + { AOM_CDF4(10211, 23420, 29082) }, + { AOM_CDF4(6222, 16876, 23916) }, + { AOM_CDF4(3462, 9954, 15498) }, + { AOM_CDF4(29991, 32633, 32721) }, + { AOM_CDF4(19883, 30751, 32201) }, + { AOM_CDF4(11141, 24184, 29285) }, + { AOM_CDF4(6420, 16940, 23774) }, + { AOM_CDF4(3392, 9753, 15118) }, + { AOM_CDF4(28465, 32616, 32712) }, + { AOM_CDF4(19850, 30702, 32244) }, + { AOM_CDF4(10983, 24024, 29223) }, + { AOM_CDF4(6294, 16770, 23582) }, + { AOM_CDF4(3244, 9283, 14509) }, + { AOM_CDF4(30023, 32717, 32748) }, + { AOM_CDF4(22940, 32032, 32626) }, + { AOM_CDF4(14282, 27928, 31473) }, + { AOM_CDF4(8562, 21327, 27914) }, + { AOM_CDF4(4846, 13393, 19919) }, + { AOM_CDF4(29981, 32590, 32695) }, + { AOM_CDF4(20465, 30963, 32166) }, + { AOM_CDF4(11479, 23579, 28195) }, + { AOM_CDF4(5916, 15648, 22073) }, + { AOM_CDF4(3031, 8605, 13398) }, + { AOM_CDF4(31146, 32691, 32739) }, + { AOM_CDF4(23106, 31724, 32444) }, + { AOM_CDF4(13783, 26738, 30439) }, + { AOM_CDF4(7852, 19468, 25807) }, + { AOM_CDF4(3860, 11124, 16853) }, + { AOM_CDF4(31014, 32724, 32748) }, + { AOM_CDF4(23629, 32109, 32628) }, + { AOM_CDF4(14747, 28115, 31403) }, + { AOM_CDF4(8545, 21242, 27478) }, + { AOM_CDF4(4574, 12781, 19067) } }, + { { AOM_CDF4(9185, 19694, 24688) }, + { AOM_CDF4(26081, 31985, 32621) }, + { AOM_CDF4(16015, 29000, 31787) }, + { AOM_CDF4(10542, 23690, 29206) }, + { AOM_CDF4(6732, 17945, 24677) }, + { AOM_CDF4(3916, 11039, 16722) }, + { AOM_CDF4(28224, 32566, 32744) }, + { AOM_CDF4(19100, 31138, 32485) }, + { AOM_CDF4(12528, 26620, 30879) }, + { AOM_CDF4(7741, 20277, 26885) }, + { AOM_CDF4(4566, 12845, 18990) }, + { AOM_CDF4(29933, 32593, 32718) }, + { AOM_CDF4(17670, 30333, 32155) }, + { AOM_CDF4(10385, 23600, 28909) }, + { AOM_CDF4(6243, 16236, 22407) }, + { AOM_CDF4(3976, 10389, 16017) }, + { AOM_CDF4(28377, 32561, 32738) }, + { AOM_CDF4(19366, 31175, 32482) }, + { AOM_CDF4(13327, 27175, 31094) }, + { AOM_CDF4(8258, 20769, 27143) }, + { AOM_CDF4(4703, 13198, 19527) }, + { AOM_CDF4(31086, 32706, 32748) }, + { AOM_CDF4(22853, 31902, 32583) }, + { AOM_CDF4(14759, 28186, 31419) }, + { AOM_CDF4(9284, 22382, 28348) }, + { AOM_CDF4(5585, 15192, 21868) }, + { AOM_CDF4(28291, 32652, 32746) }, + { AOM_CDF4(19849, 32107, 32571) }, + { AOM_CDF4(14834, 26818, 29214) }, + { AOM_CDF4(10306, 22594, 28672) }, + { AOM_CDF4(6615, 17384, 23384) }, + { AOM_CDF4(28947, 32604, 32745) }, + { AOM_CDF4(25625, 32289, 32646) }, + { AOM_CDF4(18758, 28672, 31403) }, + { AOM_CDF4(10017, 23430, 28523) }, + { AOM_CDF4(6862, 15269, 22131) }, + { AOM_CDF4(23933, 32509, 32739) }, + { AOM_CDF4(19927, 31495, 32631) }, + { AOM_CDF4(11903, 26023, 30621) }, + { AOM_CDF4(7026, 20094, 27252) }, + { AOM_CDF4(5998, 18106, 24437) } } }, + { { { AOM_CDF4(4456, 11274, 15533) }, + { AOM_CDF4(21219, 29079, 31616) }, + { AOM_CDF4(11173, 23774, 28567) }, + { AOM_CDF4(7282, 18293, 24263) }, + { AOM_CDF4(4890, 13286, 19115) }, + { AOM_CDF4(1890, 5508, 8659) }, + { AOM_CDF4(26651, 32136, 32647) }, + { AOM_CDF4(14630, 28254, 31455) }, + { AOM_CDF4(8716, 21287, 27395) }, + { AOM_CDF4(5615, 15331, 22008) }, + { AOM_CDF4(2675, 7700, 12150) }, + { AOM_CDF4(29954, 32526, 32690) }, + { AOM_CDF4(16126, 28982, 31633) }, + { AOM_CDF4(9030, 21361, 27352) }, + { AOM_CDF4(5411, 14793, 21271) }, + { AOM_CDF4(2943, 8422, 13163) }, + { AOM_CDF4(29539, 32601, 32730) }, + { AOM_CDF4(18125, 30385, 32201) }, + { AOM_CDF4(10422, 24090, 29468) }, + { AOM_CDF4(6468, 17487, 24438) }, + { AOM_CDF4(2970, 8653, 13531) }, + { AOM_CDF4(30912, 32715, 32748) }, + { AOM_CDF4(20666, 31373, 32497) }, + { AOM_CDF4(12509, 26640, 30917) }, + { AOM_CDF4(8058, 20629, 27290) }, + { AOM_CDF4(4231, 12006, 18052) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) } }, + { { AOM_CDF4(10202, 20633, 25484) }, + { AOM_CDF4(27336, 31445, 32352) }, + { AOM_CDF4(12420, 24384, 28552) }, + { AOM_CDF4(7648, 18115, 23856) }, + { AOM_CDF4(5662, 14341, 19902) }, + { AOM_CDF4(3611, 10328, 15390) }, + { AOM_CDF4(30945, 32616, 32736) }, + { AOM_CDF4(18682, 30505, 32253) }, + { AOM_CDF4(11513, 25336, 30203) }, + { AOM_CDF4(7449, 19452, 26148) }, + { AOM_CDF4(4482, 13051, 18886) }, + { AOM_CDF4(32022, 32690, 32747) }, + { AOM_CDF4(18578, 30501, 32146) }, + { AOM_CDF4(11249, 23368, 28631) }, + { AOM_CDF4(5645, 16958, 22158) }, + { AOM_CDF4(5009, 11444, 16637) }, + { AOM_CDF4(31357, 32710, 32748) }, + { AOM_CDF4(21552, 31494, 32504) }, + { AOM_CDF4(13891, 27677, 31340) }, + { AOM_CDF4(9051, 22098, 28172) }, + { AOM_CDF4(5190, 13377, 19486) }, + { AOM_CDF4(32364, 32740, 32748) }, + { AOM_CDF4(24839, 31907, 32551) }, + { AOM_CDF4(17160, 28779, 31696) }, + { AOM_CDF4(12452, 24137, 29602) }, + { AOM_CDF4(6165, 15389, 22477) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) } } }, + { { { AOM_CDF4(2575, 7281, 11077) }, + { AOM_CDF4(14002, 20866, 25402) }, + { AOM_CDF4(6343, 15056, 19658) }, + { AOM_CDF4(4474, 11858, 17041) }, + { AOM_CDF4(2865, 8299, 12534) }, + { AOM_CDF4(1344, 3949, 6391) }, + { AOM_CDF4(24720, 31239, 32459) }, + { AOM_CDF4(12585, 25356, 29968) }, + { AOM_CDF4(7181, 18246, 24444) }, + { AOM_CDF4(5025, 13667, 19885) }, + { AOM_CDF4(2521, 7304, 11605) }, + { AOM_CDF4(29908, 32252, 32584) }, + { AOM_CDF4(17421, 29156, 31575) }, + { AOM_CDF4(9889, 22188, 27782) }, + { AOM_CDF4(5878, 15647, 22123) }, + { AOM_CDF4(2814, 8665, 13323) }, + { AOM_CDF4(30183, 32568, 32713) }, + { AOM_CDF4(18528, 30195, 32049) }, + { AOM_CDF4(10982, 24606, 29657) }, + { AOM_CDF4(6957, 18165, 25231) }, + { AOM_CDF4(3508, 10118, 15468) }, + { AOM_CDF4(31761, 32736, 32748) }, + { AOM_CDF4(21041, 31328, 32546) }, + { AOM_CDF4(12568, 26732, 31166) }, + { AOM_CDF4(8052, 20720, 27733) }, + { AOM_CDF4(4336, 12192, 18396) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) } }, + { { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) } } } + }, .dc_sign = { + { + { AOM_CDF2(128 * 125) }, + { AOM_CDF2(128 * 102) }, + { AOM_CDF2(128 * 147) }, + }, + { + { AOM_CDF2(128 * 119) }, + { AOM_CDF2(128 * 101) }, + { AOM_CDF2(128 * 135) }, + } + }, .br_tok = { + { { { AOM_CDF4(16138, 22223, 25509) }, + { AOM_CDF4(15347, 22430, 26332) }, + { AOM_CDF4(9614, 16736, 21332) }, + { AOM_CDF4(6600, 12275, 16907) }, + { AOM_CDF4(4811, 9424, 13547) }, + { AOM_CDF4(3748, 7809, 11420) }, + { AOM_CDF4(2254, 4587, 6890) }, + { AOM_CDF4(15196, 20284, 23177) }, + { AOM_CDF4(18317, 25469, 28451) }, + { AOM_CDF4(13918, 21651, 25842) }, + { AOM_CDF4(10052, 17150, 21995) }, + { AOM_CDF4(7499, 13630, 18587) }, + { AOM_CDF4(6158, 11417, 16003) }, + { AOM_CDF4(4014, 7785, 11252) }, + { AOM_CDF4(15048, 21067, 24384) }, + { AOM_CDF4(18202, 25346, 28553) }, + { AOM_CDF4(14302, 22019, 26356) }, + { AOM_CDF4(10839, 18139, 23166) }, + { AOM_CDF4(8715, 15744, 20806) }, + { AOM_CDF4(7536, 13576, 18544) }, + { AOM_CDF4(5413, 10335, 14498) } }, + { { AOM_CDF4(17394, 24501, 27895) }, + { AOM_CDF4(15889, 23420, 27185) }, + { AOM_CDF4(11561, 19133, 23870) }, + { AOM_CDF4(8285, 14812, 19844) }, + { AOM_CDF4(6496, 12043, 16550) }, + { AOM_CDF4(4771, 9574, 13677) }, + { AOM_CDF4(3603, 6830, 10144) }, + { AOM_CDF4(21656, 27704, 30200) }, + { AOM_CDF4(21324, 27915, 30511) }, + { AOM_CDF4(17327, 25336, 28997) }, + { AOM_CDF4(13417, 21381, 26033) }, + { AOM_CDF4(10132, 17425, 22338) }, + { AOM_CDF4(8580, 15016, 19633) }, + { AOM_CDF4(5694, 11477, 16411) }, + { AOM_CDF4(24116, 29780, 31450) }, + { AOM_CDF4(23853, 29695, 31591) }, + { AOM_CDF4(20085, 27614, 30428) }, + { AOM_CDF4(15326, 24335, 28575) }, + { AOM_CDF4(11814, 19472, 24810) }, + { AOM_CDF4(10221, 18611, 24767) }, + { AOM_CDF4(7689, 14558, 20321) } } }, + { { { AOM_CDF4(16214, 22380, 25770) }, + { AOM_CDF4(14213, 21304, 25295) }, + { AOM_CDF4(9213, 15823, 20455) }, + { AOM_CDF4(6395, 11758, 16139) }, + { AOM_CDF4(4779, 9187, 13066) }, + { AOM_CDF4(3821, 7501, 10953) }, + { AOM_CDF4(2293, 4567, 6795) }, + { AOM_CDF4(15859, 21283, 23820) }, + { AOM_CDF4(18404, 25602, 28726) }, + { AOM_CDF4(14325, 21980, 26206) }, + { AOM_CDF4(10669, 17937, 22720) }, + { AOM_CDF4(8297, 14642, 19447) }, + { AOM_CDF4(6746, 12389, 16893) }, + { AOM_CDF4(4324, 8251, 11770) }, + { AOM_CDF4(16532, 21631, 24475) }, + { AOM_CDF4(20667, 27150, 29668) }, + { AOM_CDF4(16728, 24510, 28175) }, + { AOM_CDF4(12861, 20645, 25332) }, + { AOM_CDF4(10076, 17361, 22417) }, + { AOM_CDF4(8395, 14940, 19963) }, + { AOM_CDF4(5731, 10683, 14912) } }, + { { AOM_CDF4(14433, 21155, 24938) }, + { AOM_CDF4(14658, 21716, 25545) }, + { AOM_CDF4(9923, 16824, 21557) }, + { AOM_CDF4(6982, 13052, 17721) }, + { AOM_CDF4(5419, 10503, 15050) }, + { AOM_CDF4(4852, 9162, 13014) }, + { AOM_CDF4(3271, 6395, 9630) }, + { AOM_CDF4(22210, 27833, 30109) }, + { AOM_CDF4(20750, 27368, 29821) }, + { AOM_CDF4(16894, 24828, 28573) }, + { AOM_CDF4(13247, 21276, 25757) }, + { AOM_CDF4(10038, 17265, 22563) }, + { AOM_CDF4(8587, 14947, 20327) }, + { AOM_CDF4(5645, 11371, 15252) }, + { AOM_CDF4(22027, 27526, 29714) }, + { AOM_CDF4(23098, 29146, 31221) }, + { AOM_CDF4(19886, 27341, 30272) }, + { AOM_CDF4(15609, 23747, 28046) }, + { AOM_CDF4(11993, 20065, 24939) }, + { AOM_CDF4(9637, 18267, 23671) }, + { AOM_CDF4(7625, 13801, 19144) } } }, + { { { AOM_CDF4(14438, 20798, 24089) }, + { AOM_CDF4(12621, 19203, 23097) }, + { AOM_CDF4(8177, 14125, 18402) }, + { AOM_CDF4(5674, 10501, 14456) }, + { AOM_CDF4(4236, 8239, 11733) }, + { AOM_CDF4(3447, 6750, 9806) }, + { AOM_CDF4(1986, 3950, 5864) }, + { AOM_CDF4(16208, 22099, 24930) }, + { AOM_CDF4(16537, 24025, 27585) }, + { AOM_CDF4(12780, 20381, 24867) }, + { AOM_CDF4(9767, 16612, 21416) }, + { AOM_CDF4(7686, 13738, 18398) }, + { AOM_CDF4(6333, 11614, 15964) }, + { AOM_CDF4(3941, 7571, 10836) }, + { AOM_CDF4(22819, 27422, 29202) }, + { AOM_CDF4(22224, 28514, 30721) }, + { AOM_CDF4(17660, 25433, 28913) }, + { AOM_CDF4(13574, 21482, 26002) }, + { AOM_CDF4(10629, 17977, 22938) }, + { AOM_CDF4(8612, 15298, 20265) }, + { AOM_CDF4(5607, 10491, 14596) } }, + { { AOM_CDF4(13569, 19800, 23206) }, + { AOM_CDF4(13128, 19924, 23869) }, + { AOM_CDF4(8329, 14841, 19403) }, + { AOM_CDF4(6130, 10976, 15057) }, + { AOM_CDF4(4682, 8839, 12518) }, + { AOM_CDF4(3656, 7409, 10588) }, + { AOM_CDF4(2577, 5099, 7412) }, + { AOM_CDF4(22427, 28684, 30585) }, + { AOM_CDF4(20913, 27750, 30139) }, + { AOM_CDF4(15840, 24109, 27834) }, + { AOM_CDF4(12308, 20029, 24569) }, + { AOM_CDF4(10216, 16785, 21458) }, + { AOM_CDF4(8309, 14203, 19113) }, + { AOM_CDF4(6043, 11168, 15307) }, + { AOM_CDF4(23166, 28901, 30998) }, + { AOM_CDF4(21899, 28405, 30751) }, + { AOM_CDF4(18413, 26091, 29443) }, + { AOM_CDF4(15233, 23114, 27352) }, + { AOM_CDF4(12683, 20472, 25288) }, + { AOM_CDF4(10702, 18259, 23409) }, + { AOM_CDF4(8125, 14464, 19226) } } }, + { { { AOM_CDF4(9040, 14786, 18360) }, + { AOM_CDF4(9979, 15718, 19415) }, + { AOM_CDF4(7913, 13918, 18311) }, + { AOM_CDF4(5859, 10889, 15184) }, + { AOM_CDF4(4593, 8677, 12510) }, + { AOM_CDF4(3820, 7396, 10791) }, + { AOM_CDF4(1730, 3471, 5192) }, + { AOM_CDF4(11803, 18365, 22709) }, + { AOM_CDF4(11419, 18058, 22225) }, + { AOM_CDF4(9418, 15774, 20243) }, + { AOM_CDF4(7539, 13325, 17657) }, + { AOM_CDF4(6233, 11317, 15384) }, + { AOM_CDF4(5137, 9656, 13545) }, + { AOM_CDF4(2977, 5774, 8349) }, + { AOM_CDF4(21207, 27246, 29640) }, + { AOM_CDF4(19547, 26578, 29497) }, + { AOM_CDF4(16169, 23871, 27690) }, + { AOM_CDF4(12820, 20458, 25018) }, + { AOM_CDF4(10224, 17332, 22214) }, + { AOM_CDF4(8526, 15048, 19884) }, + { AOM_CDF4(5037, 9410, 13118) } }, + { { AOM_CDF4(12339, 17329, 20140) }, + { AOM_CDF4(13505, 19895, 23225) }, + { AOM_CDF4(9847, 16944, 21564) }, + { AOM_CDF4(7280, 13256, 18348) }, + { AOM_CDF4(4712, 10009, 14454) }, + { AOM_CDF4(4361, 7914, 12477) }, + { AOM_CDF4(2870, 5628, 7995) }, + { AOM_CDF4(20061, 25504, 28526) }, + { AOM_CDF4(15235, 22878, 26145) }, + { AOM_CDF4(12985, 19958, 24155) }, + { AOM_CDF4(9782, 16641, 21403) }, + { AOM_CDF4(9456, 16360, 20760) }, + { AOM_CDF4(6855, 12940, 18557) }, + { AOM_CDF4(5661, 10564, 15002) }, + { AOM_CDF4(25656, 30602, 31894) }, + { AOM_CDF4(22570, 29107, 31092) }, + { AOM_CDF4(18917, 26423, 29541) }, + { AOM_CDF4(15940, 23649, 27754) }, + { AOM_CDF4(12803, 20581, 25219) }, + { AOM_CDF4(11082, 18695, 23376) }, + { AOM_CDF4(7939, 14373, 19005) } } } + }, + }, [3] = { + .skip = { + { { AOM_CDF2(26887) }, + { AOM_CDF2(6729) }, + { AOM_CDF2(10361) }, + { AOM_CDF2(17442) }, + { AOM_CDF2(15045) }, + { AOM_CDF2(22478) }, + { AOM_CDF2(29072) }, + { AOM_CDF2(2713) }, + { AOM_CDF2(11861) }, + { AOM_CDF2(20773) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) } }, + { { AOM_CDF2(31903) }, + { AOM_CDF2(2044) }, + { AOM_CDF2(7528) }, + { AOM_CDF2(14618) }, + { AOM_CDF2(16182) }, + { AOM_CDF2(24168) }, + { AOM_CDF2(31037) }, + { AOM_CDF2(2786) }, + { AOM_CDF2(11194) }, + { AOM_CDF2(20155) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) } }, + { { AOM_CDF2(32510) }, + { AOM_CDF2(8430) }, + { AOM_CDF2(17318) }, + { AOM_CDF2(24154) }, + { AOM_CDF2(23674) }, + { AOM_CDF2(28789) }, + { AOM_CDF2(32139) }, + { AOM_CDF2(3440) }, + { AOM_CDF2(13117) }, + { AOM_CDF2(22702) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) } }, + { { AOM_CDF2(31671) }, + { AOM_CDF2(2056) }, + { AOM_CDF2(11746) }, + { AOM_CDF2(16852) }, + { AOM_CDF2(18635) }, + { AOM_CDF2(24715) }, + { AOM_CDF2(31484) }, + { AOM_CDF2(4656) }, + { AOM_CDF2(16074) }, + { AOM_CDF2(24704) }, + { AOM_CDF2(1806) }, + { AOM_CDF2(14645) }, + { AOM_CDF2(25336) } }, + { { AOM_CDF2(31539) }, + { AOM_CDF2(8433) }, + { AOM_CDF2(20576) }, + { AOM_CDF2(27904) }, + { AOM_CDF2(27852) }, + { AOM_CDF2(30026) }, + { AOM_CDF2(32441) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, + { AOM_CDF2(16384) } } + }, .eob_bin_16 = { + { { AOM_CDF5(6708, 8958, 14746, 22133) }, + { AOM_CDF5(1222, 2074, 4783, 15410) } }, + { { AOM_CDF5(19575, 21766, 26044, 29709) }, + { AOM_CDF5(7297, 10767, 19273, 28194) } } + }, .eob_bin_32 = { + { { AOM_CDF6(4617, 5709, 8446, 13584, 23135) }, + { AOM_CDF6(1156, 1702, 3675, 9274, 20539) } }, + { { AOM_CDF6(22086, 24282, 27010, 29770, 31743) }, + { AOM_CDF6(7699, 10897, 20891, 26926, 31628) } } + }, .eob_bin_64 = { + { { AOM_CDF7(6307, 7541, 12060, 16358, 22553, 27865) }, + { AOM_CDF7(1289, 2320, 3971, 7926, 14153, 24291) } }, + { { AOM_CDF7(24212, 25708, 28268, 30035, 31307, 32049) }, + { AOM_CDF7(8726, 12378, 19409, 26450, 30038, 32462) } } + }, .eob_bin_128 = { + { { AOM_CDF8(3472, 4885, 7489, 12481, 18517, 24536, 29635) }, + { AOM_CDF8(886, 1731, 3271, 8469, 15569, 22126, 28383) } }, + { { AOM_CDF8(24313, 26062, 28385, 30107, 31217, 31898, 32345) }, + { AOM_CDF8(9165, 13282, 21150, 30286, 31894, 32571, 32712) } } + }, .eob_bin_256 = { + { { AOM_CDF9(5348, 7113, 11820, 15924, 22106, 26777, 30334, 31757) }, + { AOM_CDF9(2453, 4474, 6307, 8777, 16474, 22975, 29000, 31547) } }, + { { AOM_CDF9(23110, 24597, 27140, 28894, 30167, 30927, 31392, 32094) }, + { AOM_CDF9(9998, 17661, 25178, 28097, 31308, 32038, 32403, 32695) } } + }, .eob_bin_512 = { + { { AOM_CDF10(5927, 7809, 10923, 14597, 19439, 24135, 28456, + 31142, 32060) }, + { AOM_CDF10(3277, 6554, 9830, 13107, 16384, 19661, 22938, + 26214, 29491) } }, + { { AOM_CDF10(21093, 23043, 25742, 27658, 29097, 29716, + 30073, 30820, 31956) }, + { AOM_CDF10(3277, 6554, 9830, 13107, 16384, 19661, 22938, + 26214, 29491) } } + }, .eob_bin_1024 = { + { { AOM_CDF11(6698, 8334, 11961, 15762, 20186, 23862, 27434, + 29326, 31082, 32050) }, + { AOM_CDF11(2979, 5958, 8937, 11916, 14895, 17873, 20852, + 23831, 26810, 29789) } }, + { { AOM_CDF11(20569, 22426, 25569, 26859, 28053, 28913, + 29486, 29724, 29807, 32570) }, + { AOM_CDF11(2979, 5958, 8937, 11916, 14895, 17873, 20852, + 23831, 26810, 29789) } } + }, .eob_hi_bit = { + { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(20177) }, { AOM_CDF2(20789) }, { AOM_CDF2(20262) }, + { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } }, + { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(21416) }, { AOM_CDF2(20855) }, { AOM_CDF2(23410) }, + { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } } }, + { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(20238) }, { AOM_CDF2(21057) }, { AOM_CDF2(19159) }, + { AOM_CDF2(22337) }, { AOM_CDF2(20159) }, { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } }, + { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(20125) }, { AOM_CDF2(20559) }, { AOM_CDF2(21707) }, + { AOM_CDF2(22296) }, { AOM_CDF2(17333) }, { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } } }, + { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(19941) }, { AOM_CDF2(20527) }, { AOM_CDF2(21470) }, + { AOM_CDF2(22487) }, { AOM_CDF2(19558) }, { AOM_CDF2(22354) }, + { AOM_CDF2(20331) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } }, + { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(22752) }, { AOM_CDF2(25006) }, { AOM_CDF2(22075) }, + { AOM_CDF2(21576) }, { AOM_CDF2(17740) }, { AOM_CDF2(21690) }, + { AOM_CDF2(19211) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } } }, + { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(21442) }, { AOM_CDF2(22358) }, { AOM_CDF2(18503) }, + { AOM_CDF2(20291) }, { AOM_CDF2(19945) }, { AOM_CDF2(21294) }, + { AOM_CDF2(21178) }, { AOM_CDF2(19400) }, { AOM_CDF2(10556) } }, + { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(24648) }, { AOM_CDF2(24949) }, { AOM_CDF2(20708) }, + { AOM_CDF2(23905) }, { AOM_CDF2(20501) }, { AOM_CDF2(9558) }, + { AOM_CDF2(9423) }, { AOM_CDF2(30365) }, { AOM_CDF2(19253) } } }, + { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(26064) }, { AOM_CDF2(22098) }, { AOM_CDF2(19613) }, + { AOM_CDF2(20525) }, { AOM_CDF2(17595) }, { AOM_CDF2(16618) }, + { AOM_CDF2(20497) }, { AOM_CDF2(18989) }, { AOM_CDF2(15513) } }, + { { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, + { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } } } + }, .eob_base_tok = { + { { { AOM_CDF3(22497, 31198) }, + { AOM_CDF3(31715, 32495) }, + { AOM_CDF3(31606, 32337) }, + { AOM_CDF3(30388, 31990) } }, + { { AOM_CDF3(27877, 31584) }, + { AOM_CDF3(32170, 32728) }, + { AOM_CDF3(32155, 32688) }, + { AOM_CDF3(32219, 32702) } } }, + { { { AOM_CDF3(21457, 31043) }, + { AOM_CDF3(31951, 32483) }, + { AOM_CDF3(32153, 32562) }, + { AOM_CDF3(31473, 32215) } }, + { { AOM_CDF3(27558, 31151) }, + { AOM_CDF3(32020, 32640) }, + { AOM_CDF3(32097, 32575) }, + { AOM_CDF3(32242, 32719) } } }, + { { { AOM_CDF3(19980, 30591) }, + { AOM_CDF3(32219, 32597) }, + { AOM_CDF3(32581, 32706) }, + { AOM_CDF3(31803, 32287) } }, + { { AOM_CDF3(26473, 30507) }, + { AOM_CDF3(32431, 32723) }, + { AOM_CDF3(32196, 32611) }, + { AOM_CDF3(31588, 32528) } } }, + { { { AOM_CDF3(24647, 30463) }, + { AOM_CDF3(32412, 32695) }, + { AOM_CDF3(32468, 32720) }, + { AOM_CDF3(31269, 32523) } }, + { { AOM_CDF3(28482, 31505) }, + { AOM_CDF3(32152, 32701) }, + { AOM_CDF3(31732, 32598) }, + { AOM_CDF3(31767, 32712) } } }, + { { { AOM_CDF3(12358, 24977) }, + { AOM_CDF3(31331, 32385) }, + { AOM_CDF3(32634, 32756) }, + { AOM_CDF3(30411, 32548) } }, + { { AOM_CDF3(10923, 21845) }, + { AOM_CDF3(10923, 21845) }, + { AOM_CDF3(10923, 21845) }, + { AOM_CDF3(10923, 21845) } } } + }, .base_tok = { + { { { AOM_CDF4(7062, 16472, 22319) }, + { AOM_CDF4(24538, 32261, 32674) }, + { AOM_CDF4(13675, 28041, 31779) }, + { AOM_CDF4(8590, 20674, 27631) }, + { AOM_CDF4(5685, 14675, 22013) }, + { AOM_CDF4(3655, 9898, 15731) }, + { AOM_CDF4(26493, 32418, 32658) }, + { AOM_CDF4(16376, 29342, 32090) }, + { AOM_CDF4(10594, 22649, 28970) }, + { AOM_CDF4(8176, 17170, 24303) }, + { AOM_CDF4(5605, 12694, 19139) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(23888, 31902, 32542) }, + { AOM_CDF4(18612, 29687, 31987) }, + { AOM_CDF4(16245, 24852, 29249) }, + { AOM_CDF4(15765, 22608, 27559) }, + { AOM_CDF4(19895, 24699, 27510) }, + { AOM_CDF4(28401, 32212, 32457) }, + { AOM_CDF4(15274, 27825, 30980) }, + { AOM_CDF4(9364, 18128, 24332) }, + { AOM_CDF4(2283, 8193, 15082) }, + { AOM_CDF4(1228, 3972, 7881) }, + { AOM_CDF4(29455, 32469, 32620) }, + { AOM_CDF4(17981, 28245, 31388) }, + { AOM_CDF4(10921, 20098, 26240) }, + { AOM_CDF4(3743, 11829, 18657) }, + { AOM_CDF4(2374, 9593, 15715) }, + { AOM_CDF4(31068, 32466, 32635) }, + { AOM_CDF4(20321, 29572, 31971) }, + { AOM_CDF4(10771, 20255, 27119) }, + { AOM_CDF4(2795, 10410, 17361) }, + { AOM_CDF4(8192, 16384, 24576) } }, + { { AOM_CDF4(9320, 22102, 27840) }, + { AOM_CDF4(27057, 32464, 32724) }, + { AOM_CDF4(16331, 30268, 32309) }, + { AOM_CDF4(10319, 23935, 29720) }, + { AOM_CDF4(6189, 16448, 24106) }, + { AOM_CDF4(3589, 10884, 18808) }, + { AOM_CDF4(29026, 32624, 32748) }, + { AOM_CDF4(19226, 31507, 32587) }, + { AOM_CDF4(12692, 26921, 31203) }, + { AOM_CDF4(7049, 19532, 27635) }, + { AOM_CDF4(7727, 15669, 23252) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(28056, 32625, 32748) }, + { AOM_CDF4(22383, 32075, 32669) }, + { AOM_CDF4(15417, 27098, 31749) }, + { AOM_CDF4(18127, 26493, 27190) }, + { AOM_CDF4(5461, 16384, 21845) }, + { AOM_CDF4(27982, 32091, 32584) }, + { AOM_CDF4(19045, 29868, 31972) }, + { AOM_CDF4(10397, 22266, 27932) }, + { AOM_CDF4(5990, 13697, 21500) }, + { AOM_CDF4(1792, 6912, 15104) }, + { AOM_CDF4(28198, 32501, 32718) }, + { AOM_CDF4(21534, 31521, 32569) }, + { AOM_CDF4(11109, 25217, 30017) }, + { AOM_CDF4(5671, 15124, 26151) }, + { AOM_CDF4(4681, 14043, 18725) }, + { AOM_CDF4(28688, 32580, 32741) }, + { AOM_CDF4(22576, 32079, 32661) }, + { AOM_CDF4(10627, 22141, 28340) }, + { AOM_CDF4(9362, 14043, 28087) }, + { AOM_CDF4(8192, 16384, 24576) } } }, + { { { AOM_CDF4(7754, 16948, 22142) }, + { AOM_CDF4(25670, 32330, 32691) }, + { AOM_CDF4(15663, 29225, 31994) }, + { AOM_CDF4(9878, 23288, 29158) }, + { AOM_CDF4(6419, 17088, 24336) }, + { AOM_CDF4(3859, 11003, 17039) }, + { AOM_CDF4(27562, 32595, 32725) }, + { AOM_CDF4(17575, 30588, 32399) }, + { AOM_CDF4(10819, 24838, 30309) }, + { AOM_CDF4(7124, 18686, 25916) }, + { AOM_CDF4(4479, 12688, 19340) }, + { AOM_CDF4(28385, 32476, 32673) }, + { AOM_CDF4(15306, 29005, 31938) }, + { AOM_CDF4(8937, 21615, 28322) }, + { AOM_CDF4(5982, 15603, 22786) }, + { AOM_CDF4(3620, 10267, 16136) }, + { AOM_CDF4(27280, 32464, 32667) }, + { AOM_CDF4(15607, 29160, 32004) }, + { AOM_CDF4(9091, 22135, 28740) }, + { AOM_CDF4(6232, 16632, 24020) }, + { AOM_CDF4(4047, 11377, 17672) }, + { AOM_CDF4(29220, 32630, 32718) }, + { AOM_CDF4(19650, 31220, 32462) }, + { AOM_CDF4(13050, 26312, 30827) }, + { AOM_CDF4(9228, 20870, 27468) }, + { AOM_CDF4(6146, 15149, 21971) }, + { AOM_CDF4(30169, 32481, 32623) }, + { AOM_CDF4(17212, 29311, 31554) }, + { AOM_CDF4(9911, 21311, 26882) }, + { AOM_CDF4(4487, 13314, 20372) }, + { AOM_CDF4(2570, 7772, 12889) }, + { AOM_CDF4(30924, 32613, 32708) }, + { AOM_CDF4(19490, 30206, 32107) }, + { AOM_CDF4(11232, 23998, 29276) }, + { AOM_CDF4(6769, 17955, 25035) }, + { AOM_CDF4(4398, 12623, 19214) }, + { AOM_CDF4(30609, 32627, 32722) }, + { AOM_CDF4(19370, 30582, 32287) }, + { AOM_CDF4(10457, 23619, 29409) }, + { AOM_CDF4(6443, 17637, 24834) }, + { AOM_CDF4(4645, 13236, 20106) } }, + { { AOM_CDF4(8626, 20271, 26216) }, + { AOM_CDF4(26707, 32406, 32711) }, + { AOM_CDF4(16999, 30329, 32286) }, + { AOM_CDF4(11445, 25123, 30286) }, + { AOM_CDF4(6411, 18828, 25601) }, + { AOM_CDF4(6801, 12458, 20248) }, + { AOM_CDF4(29918, 32682, 32748) }, + { AOM_CDF4(20649, 31739, 32618) }, + { AOM_CDF4(12879, 27773, 31581) }, + { AOM_CDF4(7896, 21751, 28244) }, + { AOM_CDF4(5260, 14870, 23698) }, + { AOM_CDF4(29252, 32593, 32731) }, + { AOM_CDF4(17072, 30460, 32294) }, + { AOM_CDF4(10653, 24143, 29365) }, + { AOM_CDF4(6536, 17490, 23983) }, + { AOM_CDF4(4929, 13170, 20085) }, + { AOM_CDF4(28137, 32518, 32715) }, + { AOM_CDF4(18171, 30784, 32407) }, + { AOM_CDF4(11437, 25436, 30459) }, + { AOM_CDF4(7252, 18534, 26176) }, + { AOM_CDF4(4126, 13353, 20978) }, + { AOM_CDF4(31162, 32726, 32748) }, + { AOM_CDF4(23017, 32222, 32701) }, + { AOM_CDF4(15629, 29233, 32046) }, + { AOM_CDF4(9387, 22621, 29480) }, + { AOM_CDF4(6922, 17616, 25010) }, + { AOM_CDF4(28838, 32265, 32614) }, + { AOM_CDF4(19701, 30206, 31920) }, + { AOM_CDF4(11214, 22410, 27933) }, + { AOM_CDF4(5320, 14177, 23034) }, + { AOM_CDF4(5049, 12881, 17827) }, + { AOM_CDF4(27484, 32471, 32734) }, + { AOM_CDF4(21076, 31526, 32561) }, + { AOM_CDF4(12707, 26303, 31211) }, + { AOM_CDF4(8169, 21722, 28219) }, + { AOM_CDF4(6045, 19406, 27042) }, + { AOM_CDF4(27753, 32572, 32745) }, + { AOM_CDF4(20832, 31878, 32653) }, + { AOM_CDF4(13250, 27356, 31674) }, + { AOM_CDF4(7718, 21508, 29858) }, + { AOM_CDF4(7209, 18350, 25559) } } }, + { { { AOM_CDF4(7876, 16901, 21741) }, + { AOM_CDF4(24001, 31898, 32625) }, + { AOM_CDF4(14529, 27959, 31451) }, + { AOM_CDF4(8273, 20818, 27258) }, + { AOM_CDF4(5278, 14673, 21510) }, + { AOM_CDF4(2983, 8843, 14039) }, + { AOM_CDF4(28016, 32574, 32732) }, + { AOM_CDF4(17471, 30306, 32301) }, + { AOM_CDF4(10224, 24063, 29728) }, + { AOM_CDF4(6602, 17954, 25052) }, + { AOM_CDF4(4002, 11585, 17759) }, + { AOM_CDF4(30190, 32634, 32739) }, + { AOM_CDF4(17497, 30282, 32270) }, + { AOM_CDF4(10229, 23729, 29538) }, + { AOM_CDF4(6344, 17211, 24440) }, + { AOM_CDF4(3849, 11189, 17108) }, + { AOM_CDF4(28570, 32583, 32726) }, + { AOM_CDF4(17521, 30161, 32238) }, + { AOM_CDF4(10153, 23565, 29378) }, + { AOM_CDF4(6455, 17341, 24443) }, + { AOM_CDF4(3907, 11042, 17024) }, + { AOM_CDF4(30689, 32715, 32748) }, + { AOM_CDF4(21546, 31840, 32610) }, + { AOM_CDF4(13547, 27581, 31459) }, + { AOM_CDF4(8912, 21757, 28309) }, + { AOM_CDF4(5548, 15080, 22046) }, + { AOM_CDF4(30783, 32540, 32685) }, + { AOM_CDF4(17540, 29528, 31668) }, + { AOM_CDF4(10160, 21468, 26783) }, + { AOM_CDF4(4724, 13393, 20054) }, + { AOM_CDF4(2702, 8174, 13102) }, + { AOM_CDF4(31648, 32686, 32742) }, + { AOM_CDF4(20954, 31094, 32337) }, + { AOM_CDF4(12420, 25698, 30179) }, + { AOM_CDF4(7304, 19320, 26248) }, + { AOM_CDF4(4366, 12261, 18864) }, + { AOM_CDF4(31581, 32723, 32748) }, + { AOM_CDF4(21373, 31586, 32525) }, + { AOM_CDF4(12744, 26625, 30885) }, + { AOM_CDF4(7431, 20322, 26950) }, + { AOM_CDF4(4692, 13323, 20111) } }, + { { AOM_CDF4(7833, 18369, 24095) }, + { AOM_CDF4(26650, 32273, 32702) }, + { AOM_CDF4(16371, 29961, 32191) }, + { AOM_CDF4(11055, 24082, 29629) }, + { AOM_CDF4(6892, 18644, 25400) }, + { AOM_CDF4(5006, 13057, 19240) }, + { AOM_CDF4(29834, 32666, 32748) }, + { AOM_CDF4(19577, 31335, 32570) }, + { AOM_CDF4(12253, 26509, 31122) }, + { AOM_CDF4(7991, 20772, 27711) }, + { AOM_CDF4(5677, 15910, 23059) }, + { AOM_CDF4(30109, 32532, 32720) }, + { AOM_CDF4(16747, 30166, 32252) }, + { AOM_CDF4(10134, 23542, 29184) }, + { AOM_CDF4(5791, 16176, 23556) }, + { AOM_CDF4(4362, 10414, 17284) }, + { AOM_CDF4(29492, 32626, 32748) }, + { AOM_CDF4(19894, 31402, 32525) }, + { AOM_CDF4(12942, 27071, 30869) }, + { AOM_CDF4(8346, 21216, 27405) }, + { AOM_CDF4(6572, 17087, 23859) }, + { AOM_CDF4(32035, 32735, 32748) }, + { AOM_CDF4(22957, 31838, 32618) }, + { AOM_CDF4(14724, 28572, 31772) }, + { AOM_CDF4(10364, 23999, 29553) }, + { AOM_CDF4(7004, 18433, 25655) }, + { AOM_CDF4(27528, 32277, 32681) }, + { AOM_CDF4(16959, 31171, 32096) }, + { AOM_CDF4(10486, 23593, 27962) }, + { AOM_CDF4(8192, 16384, 23211) }, + { AOM_CDF4(8937, 17873, 20852) }, + { AOM_CDF4(27715, 32002, 32615) }, + { AOM_CDF4(15073, 29491, 31676) }, + { AOM_CDF4(11264, 24576, 28672) }, + { AOM_CDF4(2341, 18725, 23406) }, + { AOM_CDF4(7282, 18204, 25486) }, + { AOM_CDF4(28547, 32213, 32657) }, + { AOM_CDF4(20788, 29773, 32239) }, + { AOM_CDF4(6780, 21469, 30508) }, + { AOM_CDF4(5958, 14895, 23831) }, + { AOM_CDF4(16384, 21845, 27307) } } }, + { { { AOM_CDF4(5992, 14304, 19765) }, + { AOM_CDF4(22612, 31238, 32456) }, + { AOM_CDF4(13456, 27162, 31087) }, + { AOM_CDF4(8001, 20062, 26504) }, + { AOM_CDF4(5168, 14105, 20764) }, + { AOM_CDF4(2632, 7771, 12385) }, + { AOM_CDF4(27034, 32344, 32709) }, + { AOM_CDF4(15850, 29415, 31997) }, + { AOM_CDF4(9494, 22776, 28841) }, + { AOM_CDF4(6151, 16830, 23969) }, + { AOM_CDF4(3461, 10039, 15722) }, + { AOM_CDF4(30134, 32569, 32731) }, + { AOM_CDF4(15638, 29422, 31945) }, + { AOM_CDF4(9150, 21865, 28218) }, + { AOM_CDF4(5647, 15719, 22676) }, + { AOM_CDF4(3402, 9772, 15477) }, + { AOM_CDF4(28530, 32586, 32735) }, + { AOM_CDF4(17139, 30298, 32292) }, + { AOM_CDF4(10200, 24039, 29685) }, + { AOM_CDF4(6419, 17674, 24786) }, + { AOM_CDF4(3544, 10225, 15824) }, + { AOM_CDF4(31333, 32726, 32748) }, + { AOM_CDF4(20618, 31487, 32544) }, + { AOM_CDF4(12901, 27217, 31232) }, + { AOM_CDF4(8624, 21734, 28171) }, + { AOM_CDF4(5104, 14191, 20748) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) } }, + { { AOM_CDF4(11206, 21090, 26561) }, + { AOM_CDF4(28759, 32279, 32671) }, + { AOM_CDF4(14171, 27952, 31569) }, + { AOM_CDF4(9743, 22907, 29141) }, + { AOM_CDF4(6871, 17886, 24868) }, + { AOM_CDF4(4960, 13152, 19315) }, + { AOM_CDF4(31077, 32661, 32748) }, + { AOM_CDF4(19400, 31195, 32515) }, + { AOM_CDF4(12752, 26858, 31040) }, + { AOM_CDF4(8370, 22098, 28591) }, + { AOM_CDF4(5457, 15373, 22298) }, + { AOM_CDF4(31697, 32706, 32748) }, + { AOM_CDF4(17860, 30657, 32333) }, + { AOM_CDF4(12510, 24812, 29261) }, + { AOM_CDF4(6180, 19124, 24722) }, + { AOM_CDF4(5041, 13548, 17959) }, + { AOM_CDF4(31552, 32716, 32748) }, + { AOM_CDF4(21908, 31769, 32623) }, + { AOM_CDF4(14470, 28201, 31565) }, + { AOM_CDF4(9493, 22982, 28608) }, + { AOM_CDF4(6858, 17240, 24137) }, + { AOM_CDF4(32543, 32752, 32756) }, + { AOM_CDF4(24286, 32097, 32666) }, + { AOM_CDF4(15958, 29217, 32024) }, + { AOM_CDF4(10207, 24234, 29958) }, + { AOM_CDF4(6929, 18305, 25652) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) } } }, + { { { AOM_CDF4(4137, 10847, 15682) }, + { AOM_CDF4(17824, 27001, 30058) }, + { AOM_CDF4(10204, 22796, 28291) }, + { AOM_CDF4(6076, 15935, 22125) }, + { AOM_CDF4(3852, 10937, 16816) }, + { AOM_CDF4(2252, 6324, 10131) }, + { AOM_CDF4(25840, 32016, 32662) }, + { AOM_CDF4(15109, 28268, 31531) }, + { AOM_CDF4(9385, 22231, 28340) }, + { AOM_CDF4(6082, 16672, 23479) }, + { AOM_CDF4(3318, 9427, 14681) }, + { AOM_CDF4(30594, 32574, 32718) }, + { AOM_CDF4(16836, 29552, 31859) }, + { AOM_CDF4(9556, 22542, 28356) }, + { AOM_CDF4(6305, 16725, 23540) }, + { AOM_CDF4(3376, 9895, 15184) }, + { AOM_CDF4(29383, 32617, 32745) }, + { AOM_CDF4(18891, 30809, 32401) }, + { AOM_CDF4(11688, 25942, 30687) }, + { AOM_CDF4(7468, 19469, 26651) }, + { AOM_CDF4(3909, 11358, 17012) }, + { AOM_CDF4(31564, 32736, 32748) }, + { AOM_CDF4(20906, 31611, 32600) }, + { AOM_CDF4(13191, 27621, 31537) }, + { AOM_CDF4(8768, 22029, 28676) }, + { AOM_CDF4(5079, 14109, 20906) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) } }, + { { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) }, + { AOM_CDF4(8192, 16384, 24576) } } } + }, .dc_sign = { + { + { AOM_CDF2(128 * 125) }, + { AOM_CDF2(128 * 102) }, + { AOM_CDF2(128 * 147) }, + }, + { + { AOM_CDF2(128 * 119) }, + { AOM_CDF2(128 * 101) }, + { AOM_CDF2(128 * 135) }, + } + }, .br_tok = { + { { { AOM_CDF4(18315, 24289, 27551) }, + { AOM_CDF4(16854, 24068, 27835) }, + { AOM_CDF4(10140, 17927, 23173) }, + { AOM_CDF4(6722, 12982, 18267) }, + { AOM_CDF4(4661, 9826, 14706) }, + { AOM_CDF4(3832, 8165, 12294) }, + { AOM_CDF4(2795, 6098, 9245) }, + { AOM_CDF4(17145, 23326, 26672) }, + { AOM_CDF4(20733, 27680, 30308) }, + { AOM_CDF4(16032, 24461, 28546) }, + { AOM_CDF4(11653, 20093, 25081) }, + { AOM_CDF4(9290, 16429, 22086) }, + { AOM_CDF4(7796, 14598, 19982) }, + { AOM_CDF4(6502, 12378, 17441) }, + { AOM_CDF4(21681, 27732, 30320) }, + { AOM_CDF4(22389, 29044, 31261) }, + { AOM_CDF4(19027, 26731, 30087) }, + { AOM_CDF4(14739, 23755, 28624) }, + { AOM_CDF4(11358, 20778, 25511) }, + { AOM_CDF4(10995, 18073, 24190) }, + { AOM_CDF4(9162, 14990, 20617) } }, + { { AOM_CDF4(21425, 27952, 30388) }, + { AOM_CDF4(18062, 25838, 29034) }, + { AOM_CDF4(11956, 19881, 24808) }, + { AOM_CDF4(7718, 15000, 20980) }, + { AOM_CDF4(5702, 11254, 16143) }, + { AOM_CDF4(4898, 9088, 16864) }, + { AOM_CDF4(3679, 6776, 11907) }, + { AOM_CDF4(23294, 30160, 31663) }, + { AOM_CDF4(24397, 29896, 31836) }, + { AOM_CDF4(19245, 27128, 30593) }, + { AOM_CDF4(13202, 19825, 26404) }, + { AOM_CDF4(11578, 19297, 23957) }, + { AOM_CDF4(8073, 13297, 21370) }, + { AOM_CDF4(5461, 10923, 19745) }, + { AOM_CDF4(27367, 30521, 31934) }, + { AOM_CDF4(24904, 30671, 31940) }, + { AOM_CDF4(23075, 28460, 31299) }, + { AOM_CDF4(14400, 23658, 30417) }, + { AOM_CDF4(13885, 23882, 28325) }, + { AOM_CDF4(14746, 22938, 27853) }, + { AOM_CDF4(5461, 16384, 27307) } } }, + { { { AOM_CDF4(18274, 24813, 27890) }, + { AOM_CDF4(15537, 23149, 27003) }, + { AOM_CDF4(9449, 16740, 21827) }, + { AOM_CDF4(6700, 12498, 17261) }, + { AOM_CDF4(4988, 9866, 14198) }, + { AOM_CDF4(4236, 8147, 11902) }, + { AOM_CDF4(2867, 5860, 8654) }, + { AOM_CDF4(17124, 23171, 26101) }, + { AOM_CDF4(20396, 27477, 30148) }, + { AOM_CDF4(16573, 24629, 28492) }, + { AOM_CDF4(12749, 20846, 25674) }, + { AOM_CDF4(10233, 17878, 22818) }, + { AOM_CDF4(8525, 15332, 20363) }, + { AOM_CDF4(6283, 11632, 16255) }, + { AOM_CDF4(20466, 26511, 29286) }, + { AOM_CDF4(23059, 29174, 31191) }, + { AOM_CDF4(19481, 27263, 30241) }, + { AOM_CDF4(15458, 23631, 28137) }, + { AOM_CDF4(12416, 20608, 25693) }, + { AOM_CDF4(10261, 18011, 23261) }, + { AOM_CDF4(8016, 14655, 19666) } }, + { { AOM_CDF4(17616, 24586, 28112) }, + { AOM_CDF4(15809, 23299, 27155) }, + { AOM_CDF4(10767, 18890, 23793) }, + { AOM_CDF4(7727, 14255, 18865) }, + { AOM_CDF4(6129, 11926, 16882) }, + { AOM_CDF4(4482, 9704, 14861) }, + { AOM_CDF4(3277, 7452, 11522) }, + { AOM_CDF4(22956, 28551, 30730) }, + { AOM_CDF4(22724, 28937, 30961) }, + { AOM_CDF4(18467, 26324, 29580) }, + { AOM_CDF4(13234, 20713, 25649) }, + { AOM_CDF4(11181, 17592, 22481) }, + { AOM_CDF4(8291, 18358, 24576) }, + { AOM_CDF4(7568, 11881, 14984) }, + { AOM_CDF4(24948, 29001, 31147) }, + { AOM_CDF4(25674, 30619, 32151) }, + { AOM_CDF4(20841, 26793, 29603) }, + { AOM_CDF4(14669, 24356, 28666) }, + { AOM_CDF4(11334, 23593, 28219) }, + { AOM_CDF4(8922, 14762, 22873) }, + { AOM_CDF4(8301, 13544, 20535) } } }, + { { { AOM_CDF4(17113, 23733, 27081) }, + { AOM_CDF4(14139, 21406, 25452) }, + { AOM_CDF4(8552, 15002, 19776) }, + { AOM_CDF4(5871, 11120, 15378) }, + { AOM_CDF4(4455, 8616, 12253) }, + { AOM_CDF4(3469, 6910, 10386) }, + { AOM_CDF4(2255, 4553, 6782) }, + { AOM_CDF4(18224, 24376, 27053) }, + { AOM_CDF4(19290, 26710, 29614) }, + { AOM_CDF4(14936, 22991, 27184) }, + { AOM_CDF4(11238, 18951, 23762) }, + { AOM_CDF4(8786, 15617, 20588) }, + { AOM_CDF4(7317, 13228, 18003) }, + { AOM_CDF4(5101, 9512, 13493) }, + { AOM_CDF4(22639, 28222, 30210) }, + { AOM_CDF4(23216, 29331, 31307) }, + { AOM_CDF4(19075, 26762, 29895) }, + { AOM_CDF4(15014, 23113, 27457) }, + { AOM_CDF4(11938, 19857, 24752) }, + { AOM_CDF4(9942, 17280, 22282) }, + { AOM_CDF4(7167, 13144, 17752) } }, + { { AOM_CDF4(15820, 22738, 26488) }, + { AOM_CDF4(13530, 20885, 25216) }, + { AOM_CDF4(8395, 15530, 20452) }, + { AOM_CDF4(6574, 12321, 16380) }, + { AOM_CDF4(5353, 10419, 14568) }, + { AOM_CDF4(4613, 8446, 12381) }, + { AOM_CDF4(3440, 7158, 9903) }, + { AOM_CDF4(24247, 29051, 31224) }, + { AOM_CDF4(22118, 28058, 30369) }, + { AOM_CDF4(16498, 24768, 28389) }, + { AOM_CDF4(12920, 21175, 26137) }, + { AOM_CDF4(10730, 18619, 25352) }, + { AOM_CDF4(10187, 16279, 22791) }, + { AOM_CDF4(9310, 14631, 22127) }, + { AOM_CDF4(24970, 30558, 32057) }, + { AOM_CDF4(24801, 29942, 31698) }, + { AOM_CDF4(22432, 28453, 30855) }, + { AOM_CDF4(19054, 25680, 29580) }, + { AOM_CDF4(14392, 23036, 28109) }, + { AOM_CDF4(12495, 20947, 26650) }, + { AOM_CDF4(12442, 20326, 26214) } } }, + { { { AOM_CDF4(12162, 18785, 22648) }, + { AOM_CDF4(12749, 19697, 23806) }, + { AOM_CDF4(8580, 15297, 20346) }, + { AOM_CDF4(6169, 11749, 16543) }, + { AOM_CDF4(4836, 9391, 13448) }, + { AOM_CDF4(3821, 7711, 11613) }, + { AOM_CDF4(2228, 4601, 7070) }, + { AOM_CDF4(16319, 24725, 28280) }, + { AOM_CDF4(15698, 23277, 27168) }, + { AOM_CDF4(12726, 20368, 25047) }, + { AOM_CDF4(9912, 17015, 21976) }, + { AOM_CDF4(7888, 14220, 19179) }, + { AOM_CDF4(6777, 12284, 17018) }, + { AOM_CDF4(4492, 8590, 12252) }, + { AOM_CDF4(23249, 28904, 30947) }, + { AOM_CDF4(21050, 27908, 30512) }, + { AOM_CDF4(17440, 25340, 28949) }, + { AOM_CDF4(14059, 22018, 26541) }, + { AOM_CDF4(11288, 18903, 23898) }, + { AOM_CDF4(9411, 16342, 21428) }, + { AOM_CDF4(6278, 11588, 15944) } }, + { { AOM_CDF4(13981, 20067, 23226) }, + { AOM_CDF4(16922, 23580, 26783) }, + { AOM_CDF4(11005, 19039, 24487) }, + { AOM_CDF4(7389, 14218, 19798) }, + { AOM_CDF4(5598, 11505, 17206) }, + { AOM_CDF4(6090, 11213, 15659) }, + { AOM_CDF4(3820, 7371, 10119) }, + { AOM_CDF4(21082, 26925, 29675) }, + { AOM_CDF4(21262, 28627, 31128) }, + { AOM_CDF4(18392, 26454, 30437) }, + { AOM_CDF4(14870, 22910, 27096) }, + { AOM_CDF4(12620, 19484, 24908) }, + { AOM_CDF4(9290, 16553, 22802) }, + { AOM_CDF4(6668, 14288, 20004) }, + { AOM_CDF4(27704, 31055, 31949) }, + { AOM_CDF4(24709, 29978, 31788) }, + { AOM_CDF4(21668, 29264, 31657) }, + { AOM_CDF4(18295, 26968, 30074) }, + { AOM_CDF4(16399, 24422, 29313) }, + { AOM_CDF4(14347, 23026, 28104) }, + { AOM_CDF4(12370, 19806, 24477) } } } + }, + } +}; + +static inline int get_qcat_idx(int q) { + if (q <= 20) return 0; + if (q <= 60) return 1; + if (q <= 120) return 2; + return 3; +} + +static CdfThreadContext cdf_init[4] = { + [0] = { .cdf = NULL }, + [1] = { .cdf = NULL }, + [2] = { .cdf = NULL }, + [3] = { .cdf = NULL }, +}; + +void av1_init_states(CdfThreadContext *const cdf, const int qidx) { + const int qcat = get_qcat_idx(qidx); + if (cdf_init[qcat].cdf) { + cdf_thread_ref(cdf, &cdf_init[qcat]); + return; + } + + cdf_thread_alloc(&cdf_init[qcat], NULL); + cdf_init[qcat].cdf->m = av1_default_cdf; + memcpy(cdf_init[qcat].cdf->kfym, default_kf_y_mode_cdf, + sizeof(default_kf_y_mode_cdf)); + cdf_init[qcat].cdf->coef = av1_default_coef_cdf[qcat]; + cdf_init[qcat].cdf->mv = default_mv_cdf; + cdf_init[qcat].cdf->dmv = default_mv_cdf; + cdf_thread_ref(cdf, &cdf_init[qcat]); +} + +void av1_update_tile_cdf(const Av1FrameHeader *const hdr, + CdfContext *const dst, + const CdfContext *const src) +{ + int i, j, k, l; + +#define update_cdf_1d(n1d, name) \ + do { \ + memcpy(dst->name, src->name, sizeof(*dst->name) * n1d); \ + assert(!dst->name[n1d - 1]); \ + dst->name[n1d] = 0; \ + } while (0) + +#define update_cdf_2d(n1d, n2d, name) \ + for (j = 0; j < (n1d); j++) update_cdf_1d(n2d, name[j]) +#define update_cdf_3d(n1d, n2d, n3d, name) \ + for (k = 0; k < (n1d); k++) update_cdf_2d(n2d, n3d, name[k]) +#define update_cdf_4d(n1d, n2d, n3d, n4d, name) \ + for (l = 0; l < (n1d); l++) update_cdf_3d(n2d, n3d, n4d, name[l]) +#define update_cdf_6d(n1d, n2d, n3d, n4d, n5d, n6d, name) \ + for (n = 0; n < (n1d); n++) \ + for (m = 0; m < (n2d); m++) \ + update_cdf_4d(n3d, n4d, n5d, n6d, name[n][m]) + +#define update_bit_0d(name) \ + do { \ + dst->name[0] = src->name[0]; \ + dst->name[1] = 0; \ + } while (0) + +#define update_bit_1d(n1d, name) \ + for (i = 0; i < (n1d); i++) update_bit_0d(name[i]) +#define update_bit_2d(n1d, n2d, name) \ + for (j = 0; j < (n1d); j++) update_bit_1d(n2d, name[j]) +#define update_bit_3d(n1d, n2d, n3d, name) \ + for (k = 0; k < (n1d); k++) update_bit_2d(n2d, n3d, name[k]) + + update_bit_1d(N_BS_SIZES, m.use_filter_intra); + update_cdf_1d(5, m.filter_intra); + update_cdf_3d(2, N_INTRA_PRED_MODES, N_UV_INTRA_PRED_MODES - !k, m.uv_mode); + update_cdf_2d(8, 7, m.angle_delta); + update_cdf_3d(N_TX_SIZES - 1, 3, imin(k + 2, 3), m.txsz); + update_cdf_3d(N_TX_SIZES - 1, N_INTRA_PRED_MODES, 7, m.txtp_intra[1]); + update_cdf_3d(N_TX_SIZES - 1, N_INTRA_PRED_MODES, 5, m.txtp_intra[2]); + update_bit_1d(3, m.skip); + static const uint8_t n_partitions[N_BL_LEVELS] = { + [BL_128X128] = N_PARTITIONS - 2, + [BL_64X64] = N_PARTITIONS, + [BL_32X32] = N_PARTITIONS, + [BL_16X16] = N_PARTITIONS, + [BL_8X8] = N_SUB8X8_PARTITIONS, + }; + update_cdf_3d(N_BL_LEVELS, 4, n_partitions[k], m.partition); + update_bit_2d(N_TX_SIZES, 13, coef.skip); + update_cdf_3d(2, 2, 5, coef.eob_bin_16); + update_cdf_3d(2, 2, 6, coef.eob_bin_32); + update_cdf_3d(2, 2, 7, coef.eob_bin_64); + update_cdf_3d(2, 2, 8, coef.eob_bin_128); + update_cdf_3d(2, 2, 9, coef.eob_bin_256); + update_cdf_3d(2, 2, 10, coef.eob_bin_512); + update_cdf_3d(2, 2, 11, coef.eob_bin_1024); + update_bit_3d(N_TX_SIZES, 2, 11 /*22*/, coef.eob_hi_bit); + update_cdf_4d(N_TX_SIZES, 2, 4, 3, coef.eob_base_tok); + update_cdf_4d(N_TX_SIZES, 2, 41 /*42*/, 4, coef.base_tok); + update_bit_2d(2, 3, coef.dc_sign); + update_cdf_4d(4, 2, 21, 4, coef.br_tok); + update_cdf_2d(3, NUM_SEGMENTS, m.seg_id); + update_cdf_1d(8, m.cfl_sign); + update_cdf_2d(6, 16, m.cfl_alpha); + update_bit_0d(m.restore_wiener); + update_bit_0d(m.restore_sgrproj); + update_cdf_1d(3, m.restore_switchable); + update_cdf_1d(4, m.delta_q); + update_cdf_2d(5, 4, m.delta_lf); + update_bit_2d(7, 3, m.pal_y); + update_bit_1d(2, m.pal_uv); + update_cdf_3d(2, 7, 7, m.pal_sz); + update_cdf_4d(2, 7, 5, k + 2, m.color_map); + + if (!(hdr->frame_type & 1)) { + update_bit_0d(m.intrabc); + + update_cdf_1d(N_MV_JOINTS, dmv.joint); + for (k = 0; k < 2; k++) { + update_cdf_1d(11, dmv.comp[k].classes); + update_bit_0d(dmv.comp[k].class0); + update_bit_1d(10, dmv.comp[k].classN); + update_bit_0d(dmv.comp[k].sign); + } + return; + } + + update_bit_1d(3, m.skip_mode); + update_cdf_2d(4, N_INTRA_PRED_MODES, m.y_mode); + update_cdf_3d(2, 8, N_SWITCHABLE_FILTERS, m.filter); + update_bit_1d(6, m.newmv_mode); + update_bit_1d(2, m.globalmv_mode); + update_bit_1d(6, m.refmv_mode); + update_bit_1d(3, m.drl_bit); + update_cdf_2d(8, N_COMP_INTER_PRED_MODES, m.comp_inter_mode); + update_bit_1d(4, m.intra); + update_bit_1d(5, m.comp); + update_bit_1d(5, m.comp_dir); + update_bit_1d(6, m.jnt_comp); + update_bit_1d(6, m.mask_comp); + update_bit_1d(9, m.wedge_comp); + update_cdf_2d(9, 16, m.wedge_idx); + update_bit_2d(6, 3, m.ref); + update_bit_2d(3, 3, m.comp_fwd_ref); + update_bit_2d(2, 3, m.comp_bwd_ref); + update_bit_2d(3, 3, m.comp_uni_ref); + update_bit_2d(7, 3, m.txpart); + update_cdf_2d(N_TX_SIZES - 1, 16, m.txtp_inter[1]); + update_cdf_2d(N_TX_SIZES - 1, 12, m.txtp_inter[2]); + update_cdf_2d(N_TX_SIZES - 1, 2, m.txtp_inter[3]); + update_bit_1d(3, m.seg_pred); + update_bit_1d(4, m.interintra); + update_bit_1d(7, m.interintra_wedge); + update_cdf_2d(4, 4, m.interintra_mode); + update_cdf_2d(N_BS_SIZES, 3, m.motion_mode); + update_bit_1d(N_BS_SIZES, m.obmc); + + update_cdf_1d(N_MV_JOINTS, mv.joint); + for (k = 0; k < 2; k++) { + update_cdf_1d(11, mv.comp[k].classes); + update_bit_0d(mv.comp[k].class0); + update_bit_1d(10, mv.comp[k].classN); + update_cdf_2d(2, 4, mv.comp[k].class0_fp); + update_cdf_1d(4, mv.comp[k].classN_fp); + update_bit_0d(mv.comp[k].class0_hp); + update_bit_0d(mv.comp[k].classN_hp); + update_bit_0d(mv.comp[k].sign); + } +} + +/* + * CDF threading wrappers. + */ +void cdf_thread_alloc(CdfThreadContext *const cdf, struct thread_data *const t) { + cdf->ref = dav1d_ref_create(sizeof(CdfContext) + + (t != NULL) * sizeof(atomic_uint)); + cdf->cdf = cdf->ref->data; + if (t) { + cdf->progress = (atomic_uint *) &cdf->cdf[1]; + atomic_init(cdf->progress, 0); + cdf->t = t; + } +} + +void cdf_thread_ref(CdfThreadContext *const dst, CdfThreadContext *const src) { + dav1d_ref_inc(src->ref); + *dst = *src; +} + +void cdf_thread_unref(CdfThreadContext *const cdf) { + dav1d_ref_dec(cdf->ref); + memset(cdf, 0, sizeof(*cdf)); +} + +void cdf_thread_wait(CdfThreadContext *const cdf) { + if (!cdf->t) return; + + if (atomic_load(cdf->progress)) return; + pthread_mutex_lock(&cdf->t->lock); + while (!atomic_load(cdf->progress)) + pthread_cond_wait(&cdf->t->cond, &cdf->t->lock); + pthread_mutex_unlock(&cdf->t->lock); +} + +void cdf_thread_signal(CdfThreadContext *const cdf) { + if (!cdf->t) return; + + pthread_mutex_lock(&cdf->t->lock); + atomic_store(cdf->progress, 1); + pthread_cond_broadcast(&cdf->t->cond); + pthread_mutex_unlock(&cdf->t->lock); +} diff --git a/src/cdf.h b/src/cdf.h new file mode 100644 index 0000000..014f36b --- /dev/null +++ b/src/cdf.h @@ -0,0 +1,148 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __AV1_CDF_H__ +#define __AV1_CDF_H__ + +#include <stdint.h> + +#include "src/levels.h" +#include "src/ref.h" +#include "src/thread_data.h" + +typedef struct CdfModeContext { + uint16_t y_mode[4][N_INTRA_PRED_MODES + 1]; + uint16_t use_filter_intra[N_BS_SIZES][2]; + uint16_t filter_intra[5 + 1]; + uint16_t uv_mode[2][N_INTRA_PRED_MODES][N_UV_INTRA_PRED_MODES + 1]; + uint16_t angle_delta[8][8]; + uint16_t filter[2][8][N_SWITCHABLE_FILTERS + 1]; + uint16_t newmv_mode[6][2]; + uint16_t globalmv_mode[2][2]; + uint16_t refmv_mode[6][2]; + uint16_t drl_bit[3][2]; + uint16_t comp_inter_mode[8][N_COMP_INTER_PRED_MODES + 1]; + uint16_t intra[4][2]; + uint16_t comp[5][2]; + uint16_t comp_dir[5][2]; + uint16_t jnt_comp[6][2]; + uint16_t mask_comp[6][2]; + uint16_t wedge_comp[9][2]; + uint16_t wedge_idx[9][16 + 1]; + uint16_t interintra[7][2]; + uint16_t interintra_mode[4][5]; + uint16_t interintra_wedge[7][2]; + uint16_t ref[6][3][2]; + uint16_t comp_fwd_ref[3][3][2]; + uint16_t comp_bwd_ref[2][3][2]; + uint16_t comp_uni_ref[3][3][2]; + uint16_t txsz[N_TX_SIZES - 1][3][4]; + uint16_t txpart[7][3][2]; + uint16_t txtp_inter[4][N_TX_SIZES][N_TX_TYPES + 1]; + uint16_t txtp_intra[3][N_TX_SIZES][N_INTRA_PRED_MODES][N_TX_TYPES + 1]; + uint16_t skip[3][2]; + uint16_t skip_mode[3][2]; + uint16_t partition[N_BL_LEVELS][4][N_PARTITIONS + 1]; + uint16_t seg_pred[3][2]; + uint16_t seg_id[3][NUM_SEGMENTS + 1]; + uint16_t cfl_sign[8 + 1]; + uint16_t cfl_alpha[6][16 + 1]; + uint16_t restore_wiener[2]; + uint16_t restore_sgrproj[2]; + uint16_t restore_switchable[3 + 1]; + uint16_t delta_q[4 + 1]; + uint16_t delta_lf[5][4 + 1]; + uint16_t obmc[N_BS_SIZES][2]; + uint16_t motion_mode[N_BS_SIZES][3 + 1]; + uint16_t pal_y[7][3][2]; + uint16_t pal_uv[2][2]; + uint16_t pal_sz[2][7][7 + 1]; + uint16_t color_map[2][7][5][8 + 1]; + uint16_t intrabc[2]; +} CdfModeContext; + +typedef struct CdfCoefContext { + uint16_t skip[N_TX_SIZES][13][2]; + uint16_t eob_bin_16[2][2][6]; + uint16_t eob_bin_32[2][2][7]; + uint16_t eob_bin_64[2][2][8]; + uint16_t eob_bin_128[2][2][9]; + uint16_t eob_bin_256[2][2][10]; + uint16_t eob_bin_512[2][2][11]; + uint16_t eob_bin_1024[2][2][12]; + uint16_t eob_hi_bit[N_TX_SIZES][2][11 /*22*/][2]; + uint16_t eob_base_tok[N_TX_SIZES][2][4][4]; + uint16_t base_tok[N_TX_SIZES][2][41][5]; + uint16_t dc_sign[2][3][2]; + uint16_t br_tok[4 /*5*/][2][21][5]; +} CdfCoefContext; + +typedef struct CdfMvComponent { + uint16_t classes[11 + 1]; + uint16_t class0[2]; + uint16_t classN[10][2]; + uint16_t class0_fp[2][4 + 1]; + uint16_t classN_fp[4 + 1]; + uint16_t class0_hp[2]; + uint16_t classN_hp[2]; + uint16_t sign[2]; +} CdfMvComponent; + +typedef struct CdfMvContext { + CdfMvComponent comp[2]; + uint16_t joint[N_MV_JOINTS + 1]; +} CdfMvContext; + +typedef struct CdfContext { + CdfModeContext m; + uint16_t kfym[5][5][N_INTRA_PRED_MODES + 1]; + CdfCoefContext coef; + CdfMvContext mv, dmv; +} CdfContext; + +typedef struct CdfThreadContext { + CdfContext *cdf; + Dav1dRef *ref; ///< allocation origin + struct thread_data *t; + atomic_uint *progress; +} CdfThreadContext; + +void av1_init_states(CdfThreadContext *cdf, int qidx); +void av1_update_tile_cdf(const Av1FrameHeader *hdr, CdfContext *dst, + const CdfContext *src); + +void cdf_thread_alloc(CdfThreadContext *cdf, struct thread_data *t); +void cdf_thread_ref(CdfThreadContext *dst, CdfThreadContext *src); +void cdf_thread_unref(CdfThreadContext *cdf); + +/* + * These are binary signals (so a signal is either "done" or "not done"). + */ +void cdf_thread_wait(CdfThreadContext *cdf); +void cdf_thread_signal(CdfThreadContext *cdf); + +#endif /* __AV1_CDF_H__ */ diff --git a/src/data.c b/src/data.c new file mode 100644 index 0000000..343e1f8 --- /dev/null +++ b/src/data.c @@ -0,0 +1,54 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <errno.h> +#include <stdlib.h> +#include <string.h> + +#include "dav1d/data.h" + +#include "common/validate.h" + +#include "src/ref.h" + +int dav1d_data_create(Dav1dData *const buf, const size_t sz) { + validate_input_or_ret(buf != NULL, -EINVAL); + + buf->ref = dav1d_ref_create(sz); + if (!buf->ref) return -ENOMEM; + buf->data = buf->ref->data; + buf->sz = sz; + + return 0; +} + +void dav1d_data_unref(Dav1dData *const buf) { + dav1d_ref_dec(buf->ref); + memset(buf, 0, sizeof(*buf)); +} diff --git a/src/data.h b/src/data.h new file mode 100644 index 0000000..8f13030 --- /dev/null +++ b/src/data.h @@ -0,0 +1,35 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_SRC_DATA_H__ +#define __DAV1D_SRC_DATA_H__ + +#include "dav1d/data.h" + +void dav1d_data_unref(Dav1dData *buf); + +#endif /* __DAV1D_SRC_DATA_H__ */ diff --git a/src/decode.c b/src/decode.c new file mode 100644 index 0000000..2cc1d4b --- /dev/null +++ b/src/decode.c @@ -0,0 +1,2908 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <errno.h> +#include <limits.h> +#include <string.h> +#include <stdio.h> +#include <inttypes.h> + +#include "dav1d/data.h" + +#include "common/intops.h" +#include "common/mem.h" + +#include "src/decode.h" +#include "src/dequant_tables.h" +#include "src/env.h" +#include "src/qm.h" +#include "src/recon.h" +#include "src/ref.h" +#include "src/tables.h" +#include "src/thread_task.h" +#include "src/warpmv.h" + +static void init_quant_tables(const Av1SequenceHeader *const seq_hdr, + const Av1FrameHeader *const frame_hdr, + const int qidx, uint16_t (*dq)[3][2]) +{ + for (int i = 0; i < (frame_hdr->segmentation.enabled ? 8 : 1); i++) { + const int yac = frame_hdr->segmentation.enabled ? + iclip_u8(qidx + frame_hdr->segmentation.seg_data.d[i].delta_q) : qidx; + const int ydc = iclip_u8(yac + frame_hdr->quant.ydc_delta); + const int uac = iclip_u8(yac + frame_hdr->quant.uac_delta); + const int udc = iclip_u8(yac + frame_hdr->quant.udc_delta); + const int vac = iclip_u8(yac + frame_hdr->quant.vac_delta); + const int vdc = iclip_u8(yac + frame_hdr->quant.vdc_delta); + + dq[i][0][0] = dav1d_dq_tbl[seq_hdr->bpc > 8][ydc][0]; + dq[i][0][1] = dav1d_dq_tbl[seq_hdr->bpc > 8][yac][1]; + dq[i][1][0] = dav1d_dq_tbl[seq_hdr->bpc > 8][udc][0]; + dq[i][1][1] = dav1d_dq_tbl[seq_hdr->bpc > 8][uac][1]; + dq[i][2][0] = dav1d_dq_tbl[seq_hdr->bpc > 8][vdc][0]; + dq[i][2][1] = dav1d_dq_tbl[seq_hdr->bpc > 8][vac][1]; + } +} + +static int read_mv_component_diff(Dav1dTileContext *const t, + CdfMvComponent *const mv_comp, + const int have_fp) +{ + Dav1dTileState *const ts = t->ts; + const Dav1dFrameContext *const f = t->f; + const int have_hp = f->frame_hdr.hp; + const int sign = msac_decode_bool_adapt(&ts->msac, mv_comp->sign); + const int cl = msac_decode_symbol_adapt(&ts->msac, mv_comp->classes, 11); + int up, fp, hp; + + if (!cl) { + up = msac_decode_bool_adapt(&ts->msac, mv_comp->class0); + if (have_fp) { + fp = msac_decode_symbol_adapt(&ts->msac, mv_comp->class0_fp[up], 4); + hp = have_hp ? msac_decode_bool_adapt(&ts->msac, mv_comp->class0_hp) : 1; + } else { + fp = 3; + hp = 1; + } + } else { + up = 1 << cl; + for (int n = 0; n < cl; n++) + up |= msac_decode_bool_adapt(&ts->msac, mv_comp->classN[n]) << n; + if (have_fp) { + fp = msac_decode_symbol_adapt(&ts->msac, mv_comp->classN_fp, 4); + hp = have_hp ? msac_decode_bool_adapt(&ts->msac, mv_comp->classN_hp) : 1; + } else { + fp = 3; + hp = 1; + } + } + + const int diff = ((up << 3) | (fp << 1) | hp) + 1; + + return sign ? -diff : diff; +} + +static void read_mv_residual(Dav1dTileContext *const t, mv *const ref_mv, + CdfMvContext *const mv_cdf, const int have_fp) +{ + switch (msac_decode_symbol_adapt(&t->ts->msac, t->ts->cdf.mv.joint, N_MV_JOINTS)) { + case MV_JOINT_HV: + ref_mv->y += read_mv_component_diff(t, &mv_cdf->comp[0], have_fp); + ref_mv->x += read_mv_component_diff(t, &mv_cdf->comp[1], have_fp); + break; + case MV_JOINT_H: + ref_mv->x += read_mv_component_diff(t, &mv_cdf->comp[1], have_fp); + break; + case MV_JOINT_V: + ref_mv->y += read_mv_component_diff(t, &mv_cdf->comp[0], have_fp); + break; + default: + break; + } +} + +static void read_tx_tree(Dav1dTileContext *const t, + const enum RectTxfmSize from, + const int depth, uint16_t *const masks, + const int x_off, const int y_off) +{ + const Dav1dFrameContext *const f = t->f; + const int bx4 = t->bx & 31, by4 = t->by & 31; + const TxfmInfo *const t_dim = &av1_txfm_dimensions[from]; + const int txw = t_dim->lw, txh = t_dim->lh; + int is_split; + + if (depth < 2 && from > (int) TX_4X4) { + const int cat = 2 * (TX_64X64 - t_dim->max) - depth; + const int a = t->a->tx[bx4] < txw; + const int l = t->l.tx[by4] < txh; + + is_split = msac_decode_bool_adapt(&t->ts->msac, t->ts->cdf.m.txpart[cat][a + l]); + if (is_split) + masks[depth] |= 1 << (y_off * 4 + x_off); + } else { + is_split = 0; + } + + if (is_split && t_dim->max > TX_8X8) { + const enum RectTxfmSize sub = t_dim->sub; + const TxfmInfo *const sub_t_dim = &av1_txfm_dimensions[sub]; + const int txsw = sub_t_dim->w, txsh = sub_t_dim->h; + + read_tx_tree(t, sub, depth + 1, masks, x_off * 2 + 0, y_off * 2 + 0); + t->bx += txsw; + if (txw >= txh && t->bx < f->bw) + read_tx_tree(t, sub, depth + 1, masks, x_off * 2 + 1, y_off * 2 + 0); + t->bx -= txsw; + t->by += txsh; + if (txh >= txw && t->by < f->bh) { + read_tx_tree(t, sub, depth + 1, masks, x_off * 2 + 0, y_off * 2 + 1); + t->bx += txsw; + if (txw >= txh && t->bx < f->bw) + read_tx_tree(t, sub, depth + 1, masks, + x_off * 2 + 1, y_off * 2 + 1); + t->bx -= txsw; + } + t->by -= txsh; + } else { + memset(&t->a->tx[bx4], is_split ? TX_4X4 : txw, t_dim->w); + memset(&t->l.tx[by4], is_split ? TX_4X4 : txh, t_dim->h); + } +} + +int av1_neg_deinterleave(int diff, int ref, int max) { + if (!ref) return diff; + if (ref >= (max - 1)) return max - diff - 1; + if (2 * ref < max) { + if (diff <= 2 * ref) { + if (diff & 1) + return ref + ((diff + 1) >> 1); + else + return ref - (diff >> 1); + } + return diff; + } else { + if (diff <= 2 * (max - ref - 1)) { + if (diff & 1) + return ref + ((diff + 1) >> 1); + else + return ref - (diff >> 1); + } + return max - (diff + 1); + } +} + +static void find_matching_ref(const Dav1dTileContext *const t, + const enum EdgeFlags intra_edge_flags, + const int bw4, const int bh4, + const int w4, const int h4, + const int have_left, const int have_top, + const int ref, uint64_t masks[2]) +{ + const Dav1dFrameContext *const f = t->f; + const ptrdiff_t b4_stride = f->b4_stride; + const refmvs *const r = &f->mvs[t->by * b4_stride + t->bx]; + int count = 0; + int have_topleft = have_top && have_left; + int have_topright = imax(bw4, bh4) < 32 && + have_top && t->bx + bw4 < t->ts->tiling.col_end && + (intra_edge_flags & EDGE_I444_TOP_HAS_RIGHT); + +#define bs(rp) av1_block_dimensions[sbtype_to_bs[(rp)->sb_type]] +#define matches(rp) ((rp)->ref[0] == ref + 1 && (rp)->ref[1] == -1) + + if (have_top) { + const refmvs *r2 = &r[-b4_stride]; + if (matches(r2)) { + masks[0] |= 1; + count = 1; + } + int aw4 = bs(r2)[0]; + if (aw4 >= bw4) { + const int off = t->bx & (aw4 - 1); + if (off) have_topleft = 0; + if (aw4 - off > bw4) have_topright = 0; + } else { + unsigned mask = 1 << aw4; + for (int x = aw4; x < w4; x += aw4) { + r2 += aw4; + if (matches(r2)) { + masks[0] |= mask; + if (++count >= 8) return; + } + aw4 = bs(r2)[0]; + mask <<= aw4; + } + } + } + if (have_left) { + const refmvs *r2 = &r[-1]; + if (matches(r2)) { + masks[1] |= 1; + if (++count >= 8) return; + } + int lh4 = bs(r2)[1]; + if (lh4 >= bh4) { + if (t->by & (lh4 - 1)) have_topleft = 0; + } else { + unsigned mask = 1 << lh4; + for (int y = lh4; y < h4; y += lh4) { + r2 += lh4 * b4_stride; + if (matches(r2)) { + masks[1] |= mask; + if (++count >= 8) return; + } + lh4 = bs(r2)[1]; + mask <<= lh4; + } + } + } + if (have_topleft && matches(&r[-(1 + b4_stride)])) { + masks[1] |= 1ULL << 32; + if (++count >= 8) return; + } + if (have_topright && matches(&r[bw4 - b4_stride])) { + masks[0] |= 1ULL << 32; + } +#undef matches +} + +static void derive_warpmv(const Dav1dTileContext *const t, + const int bw4, const int bh4, + const uint64_t masks[2], const struct mv mv, + WarpedMotionParams *const wmp) +{ + int pts[8][2 /* in, out */][2 /* x, y */], np = 0; + const Dav1dFrameContext *const f = t->f; + const ptrdiff_t b4_stride = f->b4_stride; + const refmvs *const r = &f->mvs[t->by * b4_stride + t->bx]; + +#define add_sample(dx, dy, sx, sy, rp) do { \ + pts[np][0][0] = 16 * (2 * dx + sx * bs(rp)[0]) - 8; \ + pts[np][0][1] = 16 * (2 * dy + sy * bs(rp)[1]) - 8; \ + pts[np][1][0] = pts[np][0][0] + (rp)->mv[0].x; \ + pts[np][1][1] = pts[np][0][1] + (rp)->mv[0].y; \ + np++; \ +} while (0) + + // use masks[] to find the projectable motion vectors in the edges + if ((unsigned) masks[0] == 1 && !(masks[1] >> 32)) { + const int off = t->bx & (bs(&r[-b4_stride])[0] - 1); + add_sample(-off, 0, 1, -1, &r[-b4_stride]); + } else for (unsigned off = 0, xmask = masks[0]; np < 8 && xmask;) { // top + const int tz = __builtin_ctz(xmask); + off += tz; + add_sample(off, 0, 1, -1, &r[off - b4_stride]); + xmask >>= tz + 1; + off += 1; + } + if (np < 8 && masks[1] == 1) { + const int off = t->by & (bs(&r[-1])[1] - 1); + add_sample(0, -off, -1, 1, &r[-1 - off * b4_stride]); + } else for (unsigned off = 0, ymask = masks[1]; np < 8 && ymask;) { // left + const int tz = __builtin_ctz(ymask); + off += tz; + add_sample(0, off, -1, 1, &r[off * b4_stride - 1]); + ymask >>= tz + 1; + off += 1; + } + if (np < 8 && masks[1] >> 32) // top/left + add_sample(0, 0, -1, -1, &r[-(1 + b4_stride)]); + if (np < 8 && masks[0] >> 32) // top/right + add_sample(bw4, 0, 1, -1, &r[bw4 - b4_stride]); + assert(np > 0 && np <= 8); +#undef bs + + // select according to motion vector difference against a threshold + int mvd[8], ret = 0; + const int thresh = 4 * iclip(imax(bw4, bh4), 4, 28); + for (int i = 0; i < np; i++) { + mvd[i] = labs(pts[i][1][0] - pts[i][0][0] - mv.x) + + labs(pts[i][1][1] - pts[i][0][1] - mv.y); + if (mvd[i] > thresh) + mvd[i] = -1; + else + ret++; + } + if (!ret) { + ret = 1; + } else for (int i = 0, j = np - 1, k = 0; k < np - ret; k++, i++, j--) { + while (mvd[i] != -1) i++; + while (mvd[j] == -1) j--; + assert(i != j); + if (i > j) break; + // replace the discarded samples; + mvd[i] = mvd[j]; + memcpy(pts[i], pts[j], sizeof(*pts)); + } + + if (!find_affine_int(pts, ret, bw4, bh4, mv, wmp, t->bx, t->by) && + !get_shear_params(wmp)) + { + wmp->type = WM_TYPE_AFFINE; + } else + wmp->type = WM_TYPE_IDENTITY; +} + +static inline int findoddzero(const uint8_t *buf, int len) { + for (int n = 0; n < len; n++) + if (!buf[n * 2]) return 1; + return 0; +} + +static void read_pal_plane(Dav1dTileContext *const t, Av1Block *const b, + const int pl, const int sz_ctx, + const int bx4, const int by4) +{ + Dav1dTileState *const ts = t->ts; + const Dav1dFrameContext *const f = t->f; + const int pal_sz = b->pal_sz[pl] = 2 + msac_decode_symbol_adapt(&ts->msac, + ts->cdf.m.pal_sz[pl][sz_ctx], 7); + uint16_t cache[16], used_cache[8]; + int l_cache = pl ? t->pal_sz_uv[1][by4] : t->l.pal_sz[by4]; + int n_cache = 0; + // don't reuse above palette outside SB64 boundaries + int a_cache = by4 & 15 ? pl ? t->pal_sz_uv[0][bx4] : t->a->pal_sz[bx4] : 0; + const uint16_t *l = t->al_pal[1][by4][pl], *a = t->al_pal[0][bx4][pl]; + + // fill/sort cache + while (l_cache && a_cache) { + if (*l < *a) { + if (!n_cache || cache[n_cache - 1] != *l) + cache[n_cache++] = *l; + l++; + l_cache--; + } else { + if (*a == *l) { + l++; + l_cache--; + } + if (!n_cache || cache[n_cache - 1] != *a) + cache[n_cache++] = *a; + a++; + a_cache--; + } + } + if (l_cache) { + do { + if (!n_cache || cache[n_cache - 1] != *l) + cache[n_cache++] = *l; + l++; + } while (--l_cache > 0); + } else if (a_cache) { + do { + if (!n_cache || cache[n_cache - 1] != *a) + cache[n_cache++] = *a; + a++; + } while (--a_cache > 0); + } + + // find reused cache entries + int i = 0; + for (int n = 0; n < n_cache && i < pal_sz; n++) + if (msac_decode_bool(&ts->msac, 128 << 7)) + used_cache[i++] = cache[n]; + const int n_used_cache = i; + + // parse new entries + uint16_t *const pal = f->frame_thread.pass ? + f->frame_thread.pal[((t->by >> 1) + (t->bx & 1)) * (f->b4_stride >> 1) + + ((t->bx >> 1) + (t->by & 1))][pl] : t->pal[pl]; + if (i < pal_sz) { + int prev = pal[i++] = msac_decode_bools(&ts->msac, f->cur.p.p.bpc); + + if (i < pal_sz) { + int bits = f->cur.p.p.bpc - 3 + msac_decode_bools(&ts->msac, 2); + const int max = (1 << f->cur.p.p.bpc) - 1; + + do { + const int delta = msac_decode_bools(&ts->msac, bits); + prev = pal[i++] = imin(prev + delta + !pl, max); + if (prev + !pl >= max) { + for (; i < pal_sz; i++) + pal[i] = pal[i - 1]; + break; + } + bits = imin(bits, 1 + ulog2(max - prev - !pl)); + } while (i < pal_sz); + } + + // merge cache+new entries + int n = 0, m = n_used_cache; + for (i = 0; i < pal_sz; i++) { + if (n < n_used_cache && (m >= pal_sz || used_cache[n] <= pal[m])) { + pal[i] = used_cache[n++]; + } else { + assert(m < pal_sz); + pal[i] = pal[m++]; + } + } + } else { + memcpy(pal, used_cache, n_used_cache * sizeof(*used_cache)); + } + + if (DEBUG_BLOCK_INFO) { + printf("Post-pal[pl=%d,sz=%d,cache_size=%d,used_cache=%d]: r=%d, cache=", + pl, b->pal_sz[pl], n_cache, n_used_cache, ts->msac.rng); + for (int n = 0; n < n_cache; n++) + printf("%c%02x", n ? ' ' : '[', cache[n]); + printf("%s, pal=", n_cache ? "]" : "[]"); + for (int n = 0; n < b->pal_sz[0]; n++) + printf("%c%02x", n ? ' ' : '[', pal[n]); + printf("]\n"); + } +} + +static void read_pal_uv(Dav1dTileContext *const t, Av1Block *const b, + const int sz_ctx, const int cbx4, const int cby4) +{ + read_pal_plane(t, b, 1, sz_ctx, cbx4, cby4); + + // V pal coding + Dav1dTileState *const ts = t->ts; + const Dav1dFrameContext *const f = t->f; + uint16_t *const pal = f->frame_thread.pass ? + f->frame_thread.pal[((t->by >> 1) + (t->bx & 1)) * (f->b4_stride >> 1) + + ((t->bx >> 1) + (t->by & 1))][2] : t->pal[2]; + if (msac_decode_bool(&ts->msac, 128 << 7)) { + const int bits = f->cur.p.p.bpc - 4 + msac_decode_bools(&ts->msac, 2); + int prev = pal[0] = msac_decode_bools(&ts->msac, f->cur.p.p.bpc); + const int max = (1 << f->cur.p.p.bpc) - 1; + for (int i = 1; i < b->pal_sz[1]; i++) { + int delta = msac_decode_bools(&ts->msac, bits); + if (delta && msac_decode_bool(&ts->msac, 128 << 7)) delta = -delta; + prev = pal[i] = (prev + delta) & max; + } + } else { + for (int i = 0; i < b->pal_sz[1]; i++) + pal[i] = msac_decode_bools(&ts->msac, f->cur.p.p.bpc); + } + if (DEBUG_BLOCK_INFO) { + printf("Post-pal[pl=2]: r=%d ", ts->msac.rng); + for (int n = 0; n < b->pal_sz[1]; n++) + printf("%c%02x", n ? ' ' : '[', pal[n]); + printf("]\n"); + } +} + +// meant to be SIMD'able, so that theoretical complexity of this function +// times block size goes from w4*h4 to w4+h4-1 +// a and b are previous two lines containing (a) top/left entries or (b) +// top/left entries, with a[0] being either the first top or first left entry, +// depending on top_offset being 1 or 0, and b being the first top/left entry +// for whichever has one. left_offset indicates whether the (len-1)th entry +// has a left neighbour. +// output is order[] and ctx for each member of this diagonal. +static void order_palette(const uint8_t *pal_idx, const ptrdiff_t stride, + const int i, const int first, const int last, + uint8_t (*const order)[8], uint8_t *const ctx) +{ + int have_top = i > first; + + pal_idx += first + (i - first) * stride; + for (int j = first, n = 0; j >= last; have_top = 1, j--, n++, pal_idx += stride - 1) { + const int have_left = j > 0; + + assert(have_left || have_top); + +#define add(v_in) do { \ + const int v = v_in; \ + assert(v < 8U); \ + order[n][o_idx++] = v; \ + mask |= 1 << v; \ + } while (0) + + unsigned mask = 0; + int o_idx = 0; + if (!have_left) { + ctx[n] = 0; + add(pal_idx[-stride]); + } else if (!have_top) { + ctx[n] = 0; + add(pal_idx[-1]); + } else { + const int l = pal_idx[-1], t = pal_idx[-stride], tl = pal_idx[-(stride + 1)]; + const int same_t_l = t == l; + const int same_t_tl = t == tl; + const int same_l_tl = l == tl; + const int same_all = same_t_l & same_t_tl & same_l_tl; + + if (same_all) { + ctx[n] = 4; + add(t); + } else if (same_t_l) { + ctx[n] = 3; + add(t); + add(tl); + } else if (same_t_tl | same_l_tl) { + ctx[n] = 2; + add(tl); + add(same_t_tl ? l : t); + } else { + ctx[n] = 1; + add(imin(t, l)); + add(imax(t, l)); + add(tl); + } + } + for (unsigned m = 1, bit = 0; m < 0x100; m <<= 1, bit++) + if (!(mask & m)) + order[n][o_idx++] = bit; + assert(o_idx == 8); +#undef add + } +} + +static void read_pal_indices(Dav1dTileContext *const t, + uint8_t *const pal_idx, + const Av1Block *const b, const int pl, + const int w4, const int h4, + const int bw4, const int bh4) +{ + Dav1dTileState *const ts = t->ts; + const ptrdiff_t stride = bw4 * 4; + pal_idx[0] = msac_decode_uniform(&ts->msac, b->pal_sz[pl]); + uint16_t (*const color_map_cdf)[8 + 1] = + ts->cdf.m.color_map[pl][b->pal_sz[pl] - 2]; + for (int i = 1; i < 4 * (w4 + h4) - 1; i++) { + // top/left-to-bottom/right diagonals ("wave-front") + uint8_t order[64][8], ctx[64]; + const int first = imin(i, w4 * 4 - 1); + const int last = imax(0, i - h4 * 4 + 1); + order_palette(pal_idx, stride, i, first, last, order, ctx); + for (int j = first, m = 0; j >= last; j--, m++) { + const int color_idx = + msac_decode_symbol_adapt(&ts->msac, color_map_cdf[ctx[m]], + b->pal_sz[pl]); + pal_idx[(i - j) * stride + j] = order[m][color_idx]; + } + } + // fill invisible edges + if (bw4 > w4) + for (int y = 0; y < 4 * h4; y++) + memset(&pal_idx[y * stride + 4 * w4], + pal_idx[y * stride + 4 * w4 - 1], 4 * (bw4 - w4)); + if (h4 < bh4) { + const uint8_t *const src = &pal_idx[stride * (4 * h4 - 1)]; + for (int y = h4 * 4; y < bh4 * 4; y++) + memcpy(&pal_idx[y * stride], src, bw4 * 4); + } +} + +static void read_vartx_tree(Dav1dTileContext *const t, + Av1Block *const b, const enum BlockSize bs, + const int bx4, const int by4) +{ + const Dav1dFrameContext *const f = t->f; + const uint8_t *const b_dim = av1_block_dimensions[bs]; + const int bw4 = b_dim[0], bh4 = b_dim[1]; + + // var-tx tree coding + b->tx_split[0] = b->tx_split[1] = 0; + b->max_ytx = av1_max_txfm_size_for_bs[bs][0]; + if (f->frame_hdr.segmentation.lossless[b->seg_id] || + b->max_ytx == TX_4X4) + { + b->max_ytx = b->uvtx = TX_4X4; + if (f->frame_hdr.txfm_mode == TX_SWITCHABLE) { + memset(&t->a->tx[bx4], TX_4X4, bw4); + memset(&t->l.tx[by4], TX_4X4, bh4); + } + } else if (f->frame_hdr.txfm_mode != TX_SWITCHABLE || b->skip) { + if (f->frame_hdr.txfm_mode == TX_SWITCHABLE) { + memset(&t->a->tx[bx4], b_dim[2], bw4); + memset(&t->l.tx[by4], b_dim[3], bh4); + } else { + assert(f->frame_hdr.txfm_mode == TX_LARGEST); + } + b->uvtx = av1_max_txfm_size_for_bs[bs][f->cur.p.p.layout]; + } else { + assert(imin(bw4, bh4) <= 16 || b->max_ytx == TX_64X64); + int y, x, y_off, x_off; + const TxfmInfo *const ytx = &av1_txfm_dimensions[b->max_ytx]; + for (y = 0, y_off = 0; y < bh4; y += ytx->h, y_off++) { + for (x = 0, x_off = 0; x < bw4; x += ytx->w, x_off++) { + read_tx_tree(t, b->max_ytx, 0, b->tx_split, x_off, y_off); + // contexts are updated inside read_tx_tree() + t->bx += ytx->w; + } + t->bx -= x; + t->by += ytx->h; + } + t->by -= y; + if (DEBUG_BLOCK_INFO) + printf("Post-vartxtree[%x/%x]: r=%d\n", + b->tx_split[0], b->tx_split[1], t->ts->msac.rng); + b->uvtx = av1_max_txfm_size_for_bs[bs][f->cur.p.p.layout]; + } +} + +static inline unsigned get_prev_frame_segid(const Dav1dFrameContext *const f, + const int by, const int bx, + const int w4, int h4, + const uint8_t *ref_seg_map, + const ptrdiff_t stride) +{ + unsigned seg_id = 8; + + assert(f->frame_hdr.primary_ref_frame != PRIMARY_REF_NONE); + dav1d_thread_picture_wait(&f->refp[f->frame_hdr.primary_ref_frame], + (by + h4) * 4, PLANE_TYPE_BLOCK); + + ref_seg_map += by * stride + bx; + do { + for (int x = 0; x < w4; x++) + seg_id = imin(seg_id, ref_seg_map[x]); + ref_seg_map += stride; + } while (--h4 > 0); + assert(seg_id < 8); + + return seg_id; +} + +static void decode_b(Dav1dTileContext *const t, + const enum BlockLevel bl, + const enum BlockSize bs, + const enum BlockPartition bp, + const enum EdgeFlags intra_edge_flags) +{ + Dav1dTileState *const ts = t->ts; + const Dav1dFrameContext *const f = t->f; + Av1Block b_mem, *const b = f->frame_thread.pass ? + &f->frame_thread.b[t->by * f->b4_stride + t->bx] : &b_mem; + const uint8_t *const b_dim = av1_block_dimensions[bs]; + const int bx4 = t->bx & 31, by4 = t->by & 31; + const int ss_ver = f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I420; + const int ss_hor = f->cur.p.p.layout != DAV1D_PIXEL_LAYOUT_I444; + const int cbx4 = bx4 >> ss_hor, cby4 = by4 >> ss_ver; + const int bw4 = b_dim[0], bh4 = b_dim[1]; + const int w4 = imin(bw4, f->bw - t->bx), h4 = imin(bh4, f->bh - t->by); + const int cbw4 = (bw4 + ss_hor) >> ss_hor, cbh4 = (bh4 + ss_ver) >> ss_ver; + const int have_left = t->bx > ts->tiling.col_start; + const int have_top = t->by > ts->tiling.row_start; + const int has_chroma = f->seq_hdr.layout != DAV1D_PIXEL_LAYOUT_I400 && + (bw4 > ss_hor || t->bx & 1) && + (bh4 > ss_ver || t->by & 1); + + if (f->frame_thread.pass == 2) { + if (b->intra) { + f->bd_fn.recon_b_intra(t, bs, intra_edge_flags, b); + + if (has_chroma) { + memset(&t->l.uvmode[cby4], b->uv_mode, cbh4); + memset(&t->a->uvmode[cbx4], b->uv_mode, cbw4); + } + const enum IntraPredMode y_mode_nofilt = + b->y_mode == FILTER_PRED ? DC_PRED : b->y_mode; + memset(&t->l.mode[by4], y_mode_nofilt, bh4); + memset(&t->a->mode[bx4], y_mode_nofilt, bw4); + } else { + if (b->comp_type == COMP_INTER_NONE && b->motion_mode == MM_WARP) { + uint64_t mask[2] = { 0, 0 }; + find_matching_ref(t, intra_edge_flags, bw4, bh4, w4, h4, + have_left, have_top, b->ref[0], mask); + derive_warpmv(t, bw4, bh4, mask, b->mv[0], &t->warpmv); + } + f->bd_fn.recon_b_inter(t, bs, b); + + const uint8_t *const filter = eve_av1_filter_dir[b->filter2d]; + memset(&t->l.filter[0][by4], filter[0], bh4); + memset(&t->a->filter[0][bx4], filter[0], bw4); + memset(&t->l.filter[1][by4], filter[1], bh4); + memset(&t->a->filter[1][bx4], filter[1], bw4); + if (has_chroma) { + memset(&t->l.uvmode[cby4], DC_PRED, cbh4); + memset(&t->a->uvmode[cbx4], DC_PRED, cbw4); + } + } + memset(&t->l.intra[by4], b->intra, bh4); + memset(&t->a->intra[bx4], b->intra, bw4); + return; + } + + const int cw4 = (w4 + ss_hor) >> ss_hor, ch4 = (h4 + ss_ver) >> ss_ver; + + b->bl = bl; + b->bp = bp; + b->bs = bs; + + // skip_mode + if (f->frame_hdr.skip_mode_enabled && imin(bw4, bh4) > 1) { + const int smctx = t->a->skip_mode[bx4] + t->l.skip_mode[by4]; + b->skip_mode = msac_decode_bool_adapt(&ts->msac, + ts->cdf.m.skip_mode[smctx]); + if (DEBUG_BLOCK_INFO) + printf("Post-skipmode[%d]: r=%d\n", b->skip_mode, ts->msac.rng); + } else { + b->skip_mode = 0; + } + + // segment_id (if seg_feature for skip/ref/gmv is enabled) + int seg_pred = 0; + if (f->frame_hdr.segmentation.enabled) { + if (!f->frame_hdr.segmentation.update_map) { + b->seg_id = f->prev_segmap ? + get_prev_frame_segid(f, t->by, t->bx, w4, h4, + f->prev_segmap, f->b4_stride) : 0; + } else if (f->frame_hdr.segmentation.seg_data.preskip) { + if (f->frame_hdr.segmentation.temporal && + (seg_pred = msac_decode_bool_adapt(&ts->msac, + ts->cdf.m.seg_pred[t->a->seg_pred[bx4] + + t->l.seg_pred[by4]]))) + { + // temporal predicted seg_id + b->seg_id = f->prev_segmap ? + get_prev_frame_segid(f, t->by, t->bx, w4, h4, + f->prev_segmap, f->b4_stride) : 0; + } else { + int seg_ctx; + const unsigned pred_seg_id = + get_cur_frame_segid(t->by, t->bx, have_top, have_left, + &seg_ctx, f->cur_segmap, f->b4_stride); + const unsigned diff = msac_decode_symbol_adapt(&ts->msac, + ts->cdf.m.seg_id[seg_ctx], + NUM_SEGMENTS); + const unsigned last_active_seg_id = + f->frame_hdr.segmentation.seg_data.last_active_segid; + b->seg_id = av1_neg_deinterleave(diff, pred_seg_id, + last_active_seg_id + 1); + if (b->seg_id > last_active_seg_id) b->seg_id = 0; // error? + } + + if (DEBUG_BLOCK_INFO) + printf("Post-segid[preskip;%d]: r=%d\n", + b->seg_id, ts->msac.rng); + } + } else { + b->seg_id = 0; + } + + // skip + const int sctx = t->a->skip[bx4] + t->l.skip[by4]; + b->skip = b->skip_mode ? 1 : + msac_decode_bool_adapt(&ts->msac, ts->cdf.m.skip[sctx]); + if (DEBUG_BLOCK_INFO) + printf("Post-skip[%d]: r=%d\n", b->skip, ts->msac.rng); + + // segment_id + if (f->frame_hdr.segmentation.enabled && + f->frame_hdr.segmentation.update_map && + !f->frame_hdr.segmentation.seg_data.preskip) + { + if (!b->skip && f->frame_hdr.segmentation.temporal && + (seg_pred = msac_decode_bool_adapt(&ts->msac, + ts->cdf.m.seg_pred[t->a->seg_pred[bx4] + + t->l.seg_pred[by4]]))) + { + // temporal predicted seg_id + b->seg_id = f->prev_segmap ? + get_prev_frame_segid(f, t->by, t->bx, w4, h4, + f->prev_segmap, f->b4_stride) : 0; + } else { + int seg_ctx; + const unsigned pred_seg_id = + get_cur_frame_segid(t->by, t->bx, have_top, have_left, + &seg_ctx, f->cur_segmap, f->b4_stride); + if (b->skip) { + b->seg_id = pred_seg_id; + } else { + const unsigned diff = msac_decode_symbol_adapt(&ts->msac, + ts->cdf.m.seg_id[seg_ctx], + NUM_SEGMENTS); + const unsigned last_active_seg_id = + f->frame_hdr.segmentation.seg_data.last_active_segid; + b->seg_id = av1_neg_deinterleave(diff, pred_seg_id, + last_active_seg_id + 1); + if (b->seg_id > last_active_seg_id) b->seg_id = 0; // error? + } + } + + if (DEBUG_BLOCK_INFO) + printf("Post-segid[postskip;%d]: r=%d\n", + b->seg_id, ts->msac.rng); + } + + // cdef index + if (!b->skip) { + const int idx = f->seq_hdr.sb128 ? ((t->bx & 16) >> 4) + + ((t->by & 16) >> 3) : 0; + if (t->cur_sb_cdef_idx_ptr[idx] == -1) { + const int v = msac_decode_bools(&ts->msac, f->frame_hdr.cdef.n_bits); + t->cur_sb_cdef_idx_ptr[idx] = v; + if (bw4 > 16) t->cur_sb_cdef_idx_ptr[idx + 1] = v; + if (bh4 > 16) t->cur_sb_cdef_idx_ptr[idx + 2] = v; + if (bw4 == 32 && bh4 == 32) t->cur_sb_cdef_idx_ptr[idx + 3] = v; + + if (DEBUG_BLOCK_INFO) + printf("Post-cdef_idx[%d]: r=%d\n", + *t->cur_sb_cdef_idx_ptr, ts->msac.rng); + } + } + + // delta-q/lf + if (!(t->bx & (31 >> !f->seq_hdr.sb128)) && + !(t->by & (31 >> !f->seq_hdr.sb128))) + { + const int prev_qidx = ts->last_qidx; + const int have_delta_q = f->frame_hdr.delta_q_present && + (bs != (f->seq_hdr.sb128 ? BS_128x128 : BS_64x64) || !b->skip); + if (have_delta_q) { + int delta_q = msac_decode_symbol_adapt(&ts->msac, ts->cdf.m.delta_q, 4); + if (delta_q == 3) { + const int n_bits = 1 + msac_decode_bools(&ts->msac, 3); + delta_q = msac_decode_bools(&ts->msac, n_bits) + 1 + (1 << n_bits); + } + if (delta_q) { + if (msac_decode_bool(&ts->msac, 128 << 7)) delta_q = -delta_q; + delta_q *= 1 << f->frame_hdr.delta_q_res_log2; + } + ts->last_qidx = iclip(ts->last_qidx + delta_q, 1, 255); + if (have_delta_q && DEBUG_BLOCK_INFO) + printf("Post-delta_q[%d->%d]: r=%d\n", + delta_q, ts->last_qidx, ts->msac.rng); + } + if (ts->last_qidx == f->frame_hdr.quant.yac) { + // assign frame-wide q values to this sb + ts->dq = f->dq; + } else if (ts->last_qidx != prev_qidx) { + // find sb-specific quant parameters + init_quant_tables(&f->seq_hdr, &f->frame_hdr, ts->last_qidx, ts->dqmem); + ts->dq = ts->dqmem; + } + + // delta_lf + int8_t prev_delta_lf[4]; + memcpy(prev_delta_lf, ts->last_delta_lf, 4); + if (have_delta_q && f->frame_hdr.delta_lf_present) { + const int n_lfs = f->frame_hdr.delta_lf_multi ? + f->seq_hdr.layout != DAV1D_PIXEL_LAYOUT_I400 ? 4 : 2 : 1; + + for (int i = 0; i < n_lfs; i++) { + int delta_lf = msac_decode_symbol_adapt(&ts->msac, + ts->cdf.m.delta_lf[i + f->frame_hdr.delta_lf_multi], 4); + if (delta_lf == 3) { + const int n_bits = 1 + msac_decode_bools(&ts->msac, 3); + delta_lf = msac_decode_bools(&ts->msac, n_bits) + 1 + (1 << n_bits); + } + if (delta_lf) { + if (msac_decode_bool(&ts->msac, 128 << 7)) delta_lf = -delta_lf; + delta_lf *= 1 << f->frame_hdr.delta_lf_res_log2; + } + ts->last_delta_lf[i] = iclip(ts->last_delta_lf[i] + delta_lf, -63, 63); + if (have_delta_q && DEBUG_BLOCK_INFO) + printf("Post-delta_lf[%d:%d]: r=%d\n", i, delta_lf, ts->msac.rng); + } + } + if (!memcmp(ts->last_delta_lf, (int8_t[4]) { 0, 0, 0, 0 }, 4)) { + // assign frame-wide lf values to this sb + ts->lflvl = f->lf.lvl; + } else if (memcmp(ts->last_delta_lf, prev_delta_lf, 4)) { + // find sb-specific lf lvl parameters + dav1d_calc_lf_values(ts->lflvlmem, &f->frame_hdr, ts->last_delta_lf); + ts->lflvl = ts->lflvlmem; + } + } + + if (b->skip_mode) { + b->intra = 0; + } else if (f->frame_hdr.frame_type & 1) { + const int ictx = get_intra_ctx(t->a, &t->l, by4, bx4, + have_top, have_left); + b->intra = !msac_decode_bool_adapt(&ts->msac, ts->cdf.m.intra[ictx]); + if (DEBUG_BLOCK_INFO) + printf("Post-intra[%d]: r=%d\n", b->intra, ts->msac.rng); + } else if (f->frame_hdr.allow_intrabc) { + b->intra = !msac_decode_bool_adapt(&ts->msac, ts->cdf.m.intrabc); + if (DEBUG_BLOCK_INFO) + printf("Post-intrabcflag[%d]: r=%d\n", b->intra, ts->msac.rng); + } else { + b->intra = 1; + } + + // intra/inter-specific stuff + if (b->intra) { + uint16_t *const ymode_cdf = f->frame_hdr.frame_type & 1 ? + ts->cdf.m.y_mode[av1_ymode_size_context[bs]] : + ts->cdf.kfym[intra_mode_context[t->a->mode[bx4]]] + [intra_mode_context[t->l.mode[by4]]]; + b->y_mode = msac_decode_symbol_adapt(&ts->msac, ymode_cdf, + N_INTRA_PRED_MODES); + if (DEBUG_BLOCK_INFO) + printf("Post-ymode[%d]: r=%d\n", b->y_mode, ts->msac.rng); + + // angle delta + if (b_dim[2] + b_dim[3] >= 2 && b->y_mode >= VERT_PRED && + b->y_mode <= VERT_LEFT_PRED) + { + uint16_t *const acdf = ts->cdf.m.angle_delta[b->y_mode - VERT_PRED]; + const int angle = msac_decode_symbol_adapt(&ts->msac, acdf, 7); + b->y_angle = angle - 3; + } else { + b->y_angle = 0; + } + + if (has_chroma) { + const int cfl_allowed = !!(cfl_allowed_mask & (1 << bs)); + uint16_t *const uvmode_cdf = ts->cdf.m.uv_mode[cfl_allowed][b->y_mode]; + b->uv_mode = msac_decode_symbol_adapt(&ts->msac, uvmode_cdf, + N_UV_INTRA_PRED_MODES - !cfl_allowed); + if (DEBUG_BLOCK_INFO) + printf("Post-uvmode[%d]: r=%d\n", b->uv_mode, ts->msac.rng); + + if (b->uv_mode == CFL_PRED) { +#define SIGN(a) (!!(a) + ((a) > 0)) + const int sign = + msac_decode_symbol_adapt(&ts->msac, ts->cdf.m.cfl_sign, 8) + 1; + const int sign_u = sign * 0x56 >> 8, sign_v = sign - sign_u * 3; + assert(sign_u == sign / 3); + if (sign_u) { + const int ctx = (sign_u == 2) * 3 + sign_v; + b->cfl_alpha[0] = msac_decode_symbol_adapt(&ts->msac, + ts->cdf.m.cfl_alpha[ctx], 16) + 1; + if (sign_u == 1) b->cfl_alpha[0] = -b->cfl_alpha[0]; + } else { + b->cfl_alpha[0] = 0; + } + if (sign_v) { + const int ctx = (sign_v == 2) * 3 + sign_u; + b->cfl_alpha[1] = msac_decode_symbol_adapt(&ts->msac, + ts->cdf.m.cfl_alpha[ctx], 16) + 1; + if (sign_v == 1) b->cfl_alpha[1] = -b->cfl_alpha[1]; + } else { + b->cfl_alpha[1] = 0; + } +#undef SIGN + if (DEBUG_BLOCK_INFO) + printf("Post-uvalphas[%d/%d]: r=%d\n", + b->cfl_alpha[0], b->cfl_alpha[1], ts->msac.rng); + } else if (b_dim[2] + b_dim[3] >= 2 && b->uv_mode >= VERT_PRED && + b->uv_mode <= VERT_LEFT_PRED) + { + uint16_t *const acdf = ts->cdf.m.angle_delta[b->uv_mode - VERT_PRED]; + const int angle = msac_decode_symbol_adapt(&ts->msac, acdf, 7); + b->uv_angle = angle - 3; + } else { + b->uv_angle = 0; + } + } + + b->pal_sz[0] = b->pal_sz[1] = 0; + if (f->frame_hdr.allow_screen_content_tools && + imax(bw4, bh4) <= 16 && bw4 + bh4 >= 4) + { + const int sz_ctx = b_dim[2] + b_dim[3] - 2; + if (b->y_mode == DC_PRED) { + const int pal_ctx = (t->a->pal_sz[bx4] > 0) + (t->l.pal_sz[by4] > 0); + const int use_y_pal = + msac_decode_bool_adapt(&ts->msac, ts->cdf.m.pal_y[sz_ctx][pal_ctx]); + if (DEBUG_BLOCK_INFO) + printf("Post-y_pal[%d]: r=%d\n", use_y_pal, ts->msac.rng); + if (use_y_pal) + read_pal_plane(t, b, 0, sz_ctx, bx4, by4); + } + + if (has_chroma && b->uv_mode == DC_PRED) { + const int pal_ctx = b->pal_sz[0] > 0; + const int use_uv_pal = + msac_decode_bool_adapt(&ts->msac, ts->cdf.m.pal_uv[pal_ctx]); + if (DEBUG_BLOCK_INFO) + printf("Post-uv_pal[%d]: r=%d\n", use_uv_pal, ts->msac.rng); + if (use_uv_pal) + read_pal_uv(t, b, sz_ctx, cbx4, cby4); + } + } + + if (b->y_mode == DC_PRED && !b->pal_sz[0] && + imax(b_dim[2], b_dim[3]) <= 3 && f->seq_hdr.filter_intra) + { + const int is_filter = msac_decode_bool_adapt(&ts->msac, + ts->cdf.m.use_filter_intra[bs]); + if (is_filter) { + b->y_mode = FILTER_PRED; + b->y_angle = msac_decode_symbol_adapt(&ts->msac, + ts->cdf.m.filter_intra, 5); + } + if (DEBUG_BLOCK_INFO) + printf("Post-filterintramode[%d/%d]: r=%d\n", + b->y_mode, b->y_angle, ts->msac.rng); + } + + if (b->pal_sz[0]) { + uint8_t *pal_idx; + if (f->frame_thread.pass) { + pal_idx = ts->frame_thread.pal_idx; + ts->frame_thread.pal_idx += bw4 * bh4 * 16; + } else + pal_idx = t->scratch.pal_idx; + read_pal_indices(t, pal_idx, b, 0, w4, h4, bw4, bh4); + if (DEBUG_BLOCK_INFO) + printf("Post-y-pal-indices: r=%d\n", ts->msac.rng); + } + + if (has_chroma && b->pal_sz[1]) { + uint8_t *pal_idx; + if (f->frame_thread.pass) { + pal_idx = ts->frame_thread.pal_idx; + ts->frame_thread.pal_idx += cbw4 * cbh4 * 16; + } else + pal_idx = &t->scratch.pal_idx[bw4 * bh4 * 16]; + read_pal_indices(t, pal_idx, b, 1, cw4, ch4, cbw4, cbh4); + if (DEBUG_BLOCK_INFO) + printf("Post-uv-pal-indices: r=%d\n", ts->msac.rng); + } + + const TxfmInfo *t_dim; + if (f->frame_hdr.segmentation.lossless[b->seg_id]) { + b->tx = b->uvtx = (int) TX_4X4; + t_dim = &av1_txfm_dimensions[TX_4X4]; + } else { + b->tx = av1_max_txfm_size_for_bs[bs][0]; + b->uvtx = av1_max_txfm_size_for_bs[bs][f->cur.p.p.layout]; + t_dim = &av1_txfm_dimensions[b->tx]; + if (f->frame_hdr.txfm_mode == TX_SWITCHABLE && t_dim->max > TX_4X4) { + const int tctx = get_tx_ctx(t->a, &t->l, t_dim, by4, bx4, + have_top, have_left); + uint16_t *const tx_cdf = ts->cdf.m.txsz[t_dim->max - 1][tctx]; + int depth = msac_decode_symbol_adapt(&ts->msac, tx_cdf, + imin(t_dim->max + 1, 3)); + + while (depth--) { + b->tx = t_dim->sub; + t_dim = &av1_txfm_dimensions[b->tx]; + } + } + if (DEBUG_BLOCK_INFO) + printf("Post-tx[%d]: r=%d\n", b->tx, ts->msac.rng); + } + + // reconstruction + if (f->frame_thread.pass == 1) { + f->bd_fn.read_coef_blocks(t, bs, b); + } else { + f->bd_fn.recon_b_intra(t, bs, intra_edge_flags, b); + } + + dav1d_create_lf_mask_intra(t->lf_mask, f->lf.level, f->b4_stride, + &f->frame_hdr, (const uint8_t (*)[8][2]) + &ts->lflvl[b->seg_id][0][0][0], + t->bx, t->by, f->bw, f->bh, bs, + b->tx, b->uvtx, f->cur.p.p.layout, + &t->a->tx_lpf_y[bx4], &t->l.tx_lpf_y[by4], + has_chroma ? &t->a->tx_lpf_uv[cbx4] : NULL, + has_chroma ? &t->l.tx_lpf_uv[cby4] : NULL); + + // update contexts + memset(&t->a->tx_intra[bx4], t_dim->lw, bw4); + memset(&t->l.tx_intra[by4], t_dim->lh, bh4); + const enum IntraPredMode y_mode_nofilt = + b->y_mode == FILTER_PRED ? DC_PRED : b->y_mode; + memset(&t->l.mode[by4], y_mode_nofilt, bh4); + memset(&t->a->mode[bx4], y_mode_nofilt, bw4); + memset(&t->l.pal_sz[by4], b->pal_sz[0], bh4); + memset(&t->a->pal_sz[bx4], b->pal_sz[0], bw4); + if (b->pal_sz[0]) { + uint16_t *const pal = f->frame_thread.pass ? + f->frame_thread.pal[((t->by >> 1) + (t->bx & 1)) * (f->b4_stride >> 1) + + ((t->bx >> 1) + (t->by & 1))][0] : t->pal[0]; + for (int x = 0; x < bw4; x++) + memcpy(t->al_pal[0][bx4 + x][0], pal, 16); + for (int y = 0; y < bh4; y++) + memcpy(t->al_pal[1][by4 + y][0], pal, 16); + } + if (has_chroma) { + memset(&t->l.uvmode[cby4], b->uv_mode, cbh4); + memset(&t->a->uvmode[cbx4], b->uv_mode, cbw4); + memset(&t->pal_sz_uv[1][cby4], b->pal_sz[1], cbh4); + memset(&t->pal_sz_uv[0][cbx4], b->pal_sz[1], cbw4); + if (b->pal_sz[1]) for (int pl = 1; pl < 3; pl++) { + uint16_t *const pal = f->frame_thread.pass ? + f->frame_thread.pal[((t->by >> 1) + (t->bx & 1)) * (f->b4_stride >> 1) + + ((t->bx >> 1) + (t->by & 1))][pl] : t->pal[pl]; + for (int x = 0; x < cbw4; x++) + memcpy(t->al_pal[0][cbx4 + x][pl], pal, 16); + for (int y = 0; y < cbh4; y++) + memcpy(t->al_pal[1][cby4 + y][pl], pal, 16); + } + } + if ((f->frame_hdr.frame_type & 1) || f->frame_hdr.allow_intrabc) { + memset(&t->a->tx[bx4], t_dim->lw, bw4); + memset(&t->l.tx[by4], t_dim->lh, bh4); + splat_intraref(f->mvs, f->b4_stride, t->by, t->bx, bs, + y_mode_nofilt); + } + if (f->frame_hdr.frame_type & 1) { + memset(&t->l.comp_type[by4], COMP_INTER_NONE, bh4); + memset(&t->a->comp_type[bx4], COMP_INTER_NONE, bw4); + memset(&t->l.ref[0][by4], -1, bh4); + memset(&t->a->ref[0][bx4], -1, bw4); + memset(&t->l.ref[1][by4], -1, bh4); + memset(&t->a->ref[1][bx4], -1, bw4); + memset(&t->l.filter[0][by4], N_SWITCHABLE_FILTERS, bh4); + memset(&t->a->filter[0][bx4], N_SWITCHABLE_FILTERS, bw4); + memset(&t->l.filter[1][by4], N_SWITCHABLE_FILTERS, bh4); + memset(&t->a->filter[1][bx4], N_SWITCHABLE_FILTERS, bw4); + } + } else if (!(f->frame_hdr.frame_type & 1)) { + // intra block copy + candidate_mv mvstack[8]; + int n_mvs; + mv mvlist[2][2]; + av1_find_ref_mvs(mvstack, &n_mvs, mvlist, NULL, + (int[2]) { -1, -1 }, f->bw, f->bh, + bs, bp, t->by, t->bx, ts->tiling.col_start, + ts->tiling.col_end, ts->tiling.row_start, + ts->tiling.row_end, f->libaom_cm); + + if (mvlist[0][0].y | mvlist[0][0].x) + b->mv[0] = mvlist[0][0]; + else if (mvlist[0][1].y | mvlist[0][1].x) + b->mv[0] = mvlist[0][1]; + else { + if (t->by - (16 << f->seq_hdr.sb128) < ts->tiling.row_start) { + b->mv[0].y = 0; + b->mv[0].x = -(512 << f->seq_hdr.sb128) - 2048; + } else { + b->mv[0].y = -(512 << f->seq_hdr.sb128); + b->mv[0].x = 0; + } + } + + const struct mv ref = b->mv[0]; + read_mv_residual(t, &b->mv[0], &ts->cdf.dmv, 0); + if (DEBUG_BLOCK_INFO) + printf("Post-dmv[%d/%d,ref=%d/%d|%d/%d]: r=%d\n", + b->mv[0].y, b->mv[0].x, ref.y, ref.x, + mvlist[0][0].y, mvlist[0][0].x, ts->msac.rng); + read_vartx_tree(t, b, bs, bx4, by4); + + // reconstruction + if (f->frame_thread.pass == 1) { + f->bd_fn.read_coef_blocks(t, bs, b); + } else { + f->bd_fn.recon_b_inter(t, bs, b); + } + + splat_intrabc_mv(f->mvs, f->b4_stride, t->by, t->bx, bs, b->mv[0]); + + memset(&t->a->tx_intra[bx4], b_dim[2], bw4); + memset(&t->l.tx_intra[by4], b_dim[3], bh4); + memset(&t->l.mode[by4], DC_PRED, bh4); + memset(&t->a->mode[bx4], DC_PRED, bw4); + memset(&t->l.pal_sz[by4], 0, bh4); + memset(&t->a->pal_sz[bx4], 0, bw4); + if (has_chroma) { + memset(&t->l.uvmode[cby4], DC_PRED, cbh4); + memset(&t->a->uvmode[cbx4], DC_PRED, cbw4); + memset(&t->pal_sz_uv[1][cby4], 0, cbh4); + memset(&t->pal_sz_uv[0][cbx4], 0, cbw4); + } + } else { + // inter-specific mode/mv coding + int is_comp, has_subpel_filter; + + if (b->skip_mode) { + is_comp = 1; + } else if (f->frame_hdr.switchable_comp_refs && imin(bw4, bh4) > 1) { + const int ctx = get_comp_ctx(t->a, &t->l, by4, bx4, + have_top, have_left); + is_comp = msac_decode_bool_adapt(&ts->msac, ts->cdf.m.comp[ctx]); + if (DEBUG_BLOCK_INFO) + printf("Post-compflag[%d]: r=%d\n", is_comp, ts->msac.rng); + } else { + is_comp = 0; + } + + if (b->skip_mode) { + b->ref[0] = f->frame_hdr.skip_mode_refs[0]; + b->ref[1] = f->frame_hdr.skip_mode_refs[1]; + b->comp_type = COMP_INTER_AVG; + b->inter_mode = NEARESTMV_NEARESTMV; + b->drl_idx = 0; + has_subpel_filter = 0; + + candidate_mv mvstack[8]; + int n_mvs, ctx; + mv mvlist[2][2]; + av1_find_ref_mvs(mvstack, &n_mvs, mvlist, &ctx, + (int[2]) { b->ref[0], b->ref[1] }, f->bw, f->bh, + bs, bp, t->by, t->bx, ts->tiling.col_start, + ts->tiling.col_end, ts->tiling.row_start, + ts->tiling.row_end, f->libaom_cm); + + b->mv[0] = mvstack[0].this_mv; + b->mv[1] = mvstack[0].comp_mv; + if (!f->frame_hdr.hp) { + unset_hp_bit(&b->mv[0]); + unset_hp_bit(&b->mv[1]); + } + if (DEBUG_BLOCK_INFO) + printf("Post-skipmodeblock[mv=1:y=%d,x=%d,2:y=%d,x=%d,refs=%d+%d\n", + b->mv[0].y, b->mv[0].x, b->mv[1].y, b->mv[1].x, + b->ref[0], b->ref[1]); + } else if (is_comp) { + const int dir_ctx = get_comp_dir_ctx(t->a, &t->l, by4, bx4, + have_top, have_left); + if (msac_decode_bool_adapt(&ts->msac, ts->cdf.m.comp_dir[dir_ctx])) { + // bidir - first reference (fw) + const int ctx1 = av1_get_fwd_ref_ctx(t->a, &t->l, by4, bx4, + have_top, have_left); + if (msac_decode_bool_adapt(&ts->msac, + ts->cdf.m.comp_fwd_ref[0][ctx1])) + { + const int ctx2 = av1_get_fwd_ref_2_ctx(t->a, &t->l, by4, bx4, + have_top, have_left); + b->ref[0] = 2 + msac_decode_bool_adapt(&ts->msac, + ts->cdf.m.comp_fwd_ref[2][ctx2]); + } else { + const int ctx2 = av1_get_fwd_ref_1_ctx(t->a, &t->l, by4, bx4, + have_top, have_left); + b->ref[0] = msac_decode_bool_adapt(&ts->msac, + ts->cdf.m.comp_fwd_ref[1][ctx2]); + } + + // second reference (bw) + const int ctx3 = av1_get_bwd_ref_ctx(t->a, &t->l, by4, bx4, + have_top, have_left); + if (msac_decode_bool_adapt(&ts->msac, + ts->cdf.m.comp_bwd_ref[0][ctx3])) + { + b->ref[1] = 6; + } else { + const int ctx4 = av1_get_bwd_ref_1_ctx(t->a, &t->l, by4, bx4, + have_top, have_left); + b->ref[1] = 4 + msac_decode_bool_adapt(&ts->msac, + ts->cdf.m.comp_bwd_ref[1][ctx4]); + } + } else { + // unidir + const int uctx_p = av1_get_uni_p_ctx(t->a, &t->l, by4, bx4, + have_top, have_left); + if (msac_decode_bool_adapt(&ts->msac, + ts->cdf.m.comp_uni_ref[0][uctx_p])) + { + b->ref[0] = 4; + b->ref[1] = 6; + } else { + const int uctx_p1 = av1_get_uni_p1_ctx(t->a, &t->l, by4, bx4, + have_top, have_left); + b->ref[0] = 0; + b->ref[1] = 1 + msac_decode_bool_adapt(&ts->msac, + ts->cdf.m.comp_uni_ref[1][uctx_p1]); + if (b->ref[1] == 2) { + const int uctx_p2 = av1_get_uni_p2_ctx(t->a, &t->l, by4, bx4, + have_top, have_left); + b->ref[1] += msac_decode_bool_adapt(&ts->msac, + ts->cdf.m.comp_uni_ref[2][uctx_p2]); + } + } + } + if (DEBUG_BLOCK_INFO) + printf("Post-refs[%d/%d]: r=%d\n", + b->ref[0], b->ref[1], ts->msac.rng); + + candidate_mv mvstack[8]; + int n_mvs, ctx; + mv mvlist[2][2]; + av1_find_ref_mvs(mvstack, &n_mvs, mvlist, &ctx, + (int[2]) { b->ref[0], b->ref[1] }, f->bw, f->bh, + bs, bp, t->by, t->bx, ts->tiling.col_start, + ts->tiling.col_end, ts->tiling.row_start, + ts->tiling.row_end, f->libaom_cm); + + b->inter_mode = msac_decode_symbol_adapt(&ts->msac, + ts->cdf.m.comp_inter_mode[ctx], + N_COMP_INTER_PRED_MODES); + if (DEBUG_BLOCK_INFO) + printf("Post-compintermode[%d,ctx=%d,n_mvs=%d]: r=%d\n", + b->inter_mode, ctx, n_mvs, ts->msac.rng); + + const uint8_t *const im = av1_comp_inter_pred_modes[b->inter_mode]; + b->drl_idx = 0; + if (b->inter_mode == NEWMV_NEWMV) { + if (n_mvs > 1) { + const int drl_ctx_v1 = get_drl_context(mvstack, 0); + b->drl_idx += msac_decode_bool_adapt(&ts->msac, + ts->cdf.m.drl_bit[drl_ctx_v1]); + if (b->drl_idx == 1 && n_mvs > 2) { + const int drl_ctx_v2 = get_drl_context(mvstack, 1); + b->drl_idx += msac_decode_bool_adapt(&ts->msac, + ts->cdf.m.drl_bit[drl_ctx_v2]); + } + if (DEBUG_BLOCK_INFO) + printf("Post-drlidx[%d,n_mvs=%d]: r=%d\n", + b->drl_idx, n_mvs, ts->msac.rng); + } + } else if (im[0] == NEARMV || im[1] == NEARMV) { + b->drl_idx = 1; + if (n_mvs > 2) { + const int drl_ctx_v2 = get_drl_context(mvstack, 1); + b->drl_idx += msac_decode_bool_adapt(&ts->msac, + ts->cdf.m.drl_bit[drl_ctx_v2]); + if (b->drl_idx == 2 && n_mvs > 3) { + const int drl_ctx_v3 = get_drl_context(mvstack, 2); + b->drl_idx += msac_decode_bool_adapt(&ts->msac, + ts->cdf.m.drl_bit[drl_ctx_v3]); + } + if (DEBUG_BLOCK_INFO) + printf("Post-drlidx[%d,n_mvs=%d]: r=%d\n", + b->drl_idx, n_mvs, ts->msac.rng); + } + } + +#define assign_comp_mv(idx, pfx) \ + switch (im[idx]) { \ + case NEARMV: \ + case NEARESTMV: \ + b->mv[idx] = mvstack[b->drl_idx].pfx##_mv; \ + if (!f->frame_hdr.hp) unset_hp_bit(&b->mv[idx]); \ + break; \ + case GLOBALMV: \ + has_subpel_filter |= \ + f->frame_hdr.gmv[b->ref[idx]].type == WM_TYPE_TRANSLATION; \ + b->mv[idx] = get_gmv_2d(&f->frame_hdr.gmv[b->ref[idx]], \ + t->bx, t->by, bw4, bh4, &f->frame_hdr); \ + break; \ + case NEWMV: \ + b->mv[idx] = mvstack[b->drl_idx].pfx##_mv; \ + read_mv_residual(t, &b->mv[idx], &ts->cdf.mv, \ + !f->frame_hdr.force_integer_mv); \ + break; \ + } + has_subpel_filter = imin(bw4, bh4) == 1 || + b->inter_mode != GLOBALMV_GLOBALMV; + assign_comp_mv(0, this); + assign_comp_mv(1, comp); +#undef assign_comp_mv + if (DEBUG_BLOCK_INFO) + printf("Post-residual_mv[1:y=%d,x=%d,2:y=%d,x=%d]: r=%d\n", + b->mv[0].y, b->mv[0].x, b->mv[1].y, b->mv[1].x, + ts->msac.rng); + + // jnt_comp vs. seg vs. wedge + int is_segwedge = 0; + if (f->seq_hdr.masked_compound) { + const int mask_ctx = get_mask_comp_ctx(t->a, &t->l, by4, bx4); + + is_segwedge = msac_decode_bool_adapt(&ts->msac, + ts->cdf.m.mask_comp[mask_ctx]); + if (DEBUG_BLOCK_INFO) + printf("Post-segwedge_vs_jntavg[%d,ctx=%d]: r=%d\n", + is_segwedge, mask_ctx, ts->msac.rng); + } + + if (!is_segwedge) { + if (f->seq_hdr.jnt_comp) { + const int jnt_ctx = + get_jnt_comp_ctx(f->seq_hdr.order_hint_n_bits, + f->cur.p.poc, f->refp[b->ref[0]].p.poc, + f->refp[b->ref[1]].p.poc, t->a, &t->l, + by4, bx4); + b->comp_type = COMP_INTER_WEIGHTED_AVG + + msac_decode_bool_adapt(&ts->msac, + ts->cdf.m.jnt_comp[jnt_ctx]); + if (DEBUG_BLOCK_INFO) + printf("Post-jnt_comp[%d,ctx=%d[ac:%d,ar:%d,lc:%d,lr:%d]]: r=%d\n", + b->comp_type == COMP_INTER_AVG, + jnt_ctx, t->a->comp_type[bx4], t->a->ref[0][bx4], + t->l.comp_type[by4], t->l.ref[0][by4], + ts->msac.rng); + } else { + b->comp_type = COMP_INTER_AVG; + } + } else { + if (wedge_allowed_mask & (1 << bs)) { + const int ctx = av1_wedge_ctx_lut[bs]; + b->comp_type = COMP_INTER_WEDGE - + msac_decode_bool_adapt(&ts->msac, + ts->cdf.m.wedge_comp[ctx]); + if (b->comp_type == COMP_INTER_WEDGE) + b->wedge_idx = msac_decode_symbol_adapt(&ts->msac, + ts->cdf.m.wedge_idx[ctx], 16); + } else { + b->comp_type = COMP_INTER_SEG; + } + b->mask_sign = msac_decode_bool(&ts->msac, 128 << 7); + if (DEBUG_BLOCK_INFO) + printf("Post-seg/wedge[%d,wedge_idx=%d,sign=%d]: r=%d\n", + b->comp_type == COMP_INTER_WEDGE, + b->wedge_idx, b->mask_sign, ts->msac.rng); + } + } else { + b->comp_type = COMP_INTER_NONE; + + // ref + const int ctx1 = av1_get_ref_ctx(t->a, &t->l, by4, bx4, + have_top, have_left); + if (msac_decode_bool_adapt(&ts->msac, ts->cdf.m.ref[0][ctx1])) { + const int ctx2 = av1_get_ref_2_ctx(t->a, &t->l, by4, bx4, + have_top, have_left); + if (msac_decode_bool_adapt(&ts->msac, ts->cdf.m.ref[1][ctx2])) { + b->ref[0] = 6; + } else { + const int ctx3 = av1_get_ref_6_ctx(t->a, &t->l, by4, bx4, + have_top, have_left); + b->ref[0] = 4 + msac_decode_bool_adapt(&ts->msac, + ts->cdf.m.ref[5][ctx3]); + } + } else { + const int ctx2 = av1_get_ref_3_ctx(t->a, &t->l, by4, bx4, + have_top, have_left); + if (msac_decode_bool_adapt(&ts->msac, ts->cdf.m.ref[2][ctx2])) { + const int ctx3 = av1_get_ref_5_ctx(t->a, &t->l, by4, bx4, + have_top, have_left); + b->ref[0] = 2 + msac_decode_bool_adapt(&ts->msac, + ts->cdf.m.ref[4][ctx3]); + } else { + const int ctx3 = av1_get_ref_4_ctx(t->a, &t->l, by4, bx4, + have_top, have_left); + b->ref[0] = msac_decode_bool_adapt(&ts->msac, + ts->cdf.m.ref[3][ctx3]); + } + } + b->ref[1] = -1; + if (DEBUG_BLOCK_INFO) + printf("Post-ref[%d]: r=%d\n", b->ref[0], ts->msac.rng); + + candidate_mv mvstack[8]; + int n_mvs, ctx; + mv mvlist[2][2]; + av1_find_ref_mvs(mvstack, &n_mvs, mvlist, &ctx, + (int[2]) { b->ref[0], -1 }, f->bw, f->bh, bs, bp, + t->by, t->bx, ts->tiling.col_start, + ts->tiling.col_end, ts->tiling.row_start, + ts->tiling.row_end, f->libaom_cm); + + // mode parsing and mv derivation from ref_mvs + if (msac_decode_bool_adapt(&ts->msac, ts->cdf.m.newmv_mode[ctx & 7])) { + if (!msac_decode_bool_adapt(&ts->msac, + ts->cdf.m.globalmv_mode[(ctx >> 3) & 1])) + { + b->inter_mode = GLOBALMV; + b->mv[0] = get_gmv_2d(&f->frame_hdr.gmv[b->ref[0]], + t->bx, t->by, bw4, bh4, &f->frame_hdr); + has_subpel_filter = imin(bw4, bh4) == 1 || + f->frame_hdr.gmv[b->ref[0]].type == WM_TYPE_TRANSLATION; + } else { + has_subpel_filter = 1; + if (msac_decode_bool_adapt(&ts->msac, + ts->cdf.m.refmv_mode[(ctx >> 4) & 15])) + { + b->inter_mode = NEARMV; + b->drl_idx = 1; + if (n_mvs > 2) { + const int drl_ctx_v2 = get_drl_context(mvstack, 1); + b->drl_idx += msac_decode_bool_adapt(&ts->msac, + ts->cdf.m.drl_bit[drl_ctx_v2]); + if (b->drl_idx == 2 && n_mvs > 3) { + const int drl_ctx_v3 = + get_drl_context(mvstack, 2); + b->drl_idx += msac_decode_bool_adapt(&ts->msac, + ts->cdf.m.drl_bit[drl_ctx_v3]); + } + } + } else { + b->inter_mode = NEARESTMV; + b->drl_idx = 0; + } + if (b->drl_idx >= 2) { + b->mv[0] = mvstack[b->drl_idx].this_mv; + } else { + b->mv[0] = mvlist[0][b->drl_idx]; + if (!f->frame_hdr.hp) unset_hp_bit(&b->mv[0]); + } + } + + if (DEBUG_BLOCK_INFO) + printf("Post-intermode[%d,drl=%d,mv=y:%d,x:%d,n_mvs=%d]: r=%d\n", + b->inter_mode, b->drl_idx, b->mv[0].y, b->mv[0].x, n_mvs, + ts->msac.rng); + } else { + has_subpel_filter = 1; + b->inter_mode = NEWMV; + b->drl_idx = 0; + if (n_mvs > 1) { + const int drl_ctx_v1 = get_drl_context(mvstack, 0); + b->drl_idx += msac_decode_bool_adapt(&ts->msac, + ts->cdf.m.drl_bit[drl_ctx_v1]); + if (b->drl_idx == 1 && n_mvs > 2) { + const int drl_ctx_v2 = get_drl_context(mvstack, 1); + b->drl_idx += msac_decode_bool_adapt(&ts->msac, + ts->cdf.m.drl_bit[drl_ctx_v2]); + } + } + if (n_mvs > 1) { + b->mv[0] = mvstack[b->drl_idx].this_mv; + } else { + b->mv[0] = mvlist[0][0]; + if (!f->frame_hdr.hp) unset_hp_bit(&b->mv[0]); + } + if (DEBUG_BLOCK_INFO) + printf("Post-intermode[%d,drl=%d]: r=%d\n", + b->inter_mode, b->drl_idx, ts->msac.rng); + read_mv_residual(t, &b->mv[0], &ts->cdf.mv, + !f->frame_hdr.force_integer_mv); + if (DEBUG_BLOCK_INFO) + printf("Post-residualmv[mv=y:%d,x:%d]: r=%d\n", + b->mv[0].y, b->mv[0].x, ts->msac.rng); + } + + // interintra flags + const int ii_sz_grp = av1_ymode_size_context[bs]; + if (f->seq_hdr.inter_intra && + interintra_allowed_mask & (1 << bs) && + msac_decode_bool_adapt(&ts->msac, ts->cdf.m.interintra[ii_sz_grp])) + { + b->interintra_mode = msac_decode_symbol_adapt(&ts->msac, + ts->cdf.m.interintra_mode[ii_sz_grp], + N_INTER_INTRA_PRED_MODES); + const int wedge_ctx = av1_wedge_ctx_lut[bs]; + b->interintra_type = INTER_INTRA_BLEND + + msac_decode_bool_adapt(&ts->msac, + ts->cdf.m.interintra_wedge[wedge_ctx]); + if (b->interintra_type == INTER_INTRA_WEDGE) + b->wedge_idx = msac_decode_symbol_adapt(&ts->msac, + ts->cdf.m.wedge_idx[wedge_ctx], 16); + } else { + b->interintra_type = INTER_INTRA_NONE; + } + if (DEBUG_BLOCK_INFO && f->seq_hdr.inter_intra && + interintra_allowed_mask & (1 << bs)) + { + printf("Post-interintra[t=%d,m=%d,w=%d]: r=%d\n", + b->interintra_type, b->interintra_mode, + b->wedge_idx, ts->msac.rng); + } + + // motion variation + if (f->frame_hdr.switchable_motion_mode && + b->interintra_type == INTER_INTRA_NONE && imin(bw4, bh4) >= 2 && + // is not warped global motion + !(!f->frame_hdr.force_integer_mv && b->inter_mode == GLOBALMV && + f->frame_hdr.gmv[b->ref[0]].type > WM_TYPE_TRANSLATION) && + // has overlappable neighbours + ((have_left && findoddzero(&t->l.intra[by4 + 1], h4 >> 1)) || + (have_top && findoddzero(&t->a->intra[bx4 + 1], w4 >> 1)))) + { + // reaching here means the block allows obmc - check warp by + // finding matching-ref blocks in top/left edges + uint64_t mask[2] = { 0, 0 }; + find_matching_ref(t, intra_edge_flags, bw4, bh4, w4, h4, + have_left, have_top, b->ref[0], mask); + const int allow_warp = !f->frame_hdr.force_integer_mv && + f->frame_hdr.warp_motion && (mask[0] | mask[1]); + + b->motion_mode = allow_warp ? + msac_decode_symbol_adapt(&ts->msac, ts->cdf.m.motion_mode[bs], 3) : + msac_decode_bool_adapt(&ts->msac, ts->cdf.m.obmc[bs]); + if (b->motion_mode == MM_WARP) { + has_subpel_filter = 0; + derive_warpmv(t, bw4, bh4, mask, b->mv[0], &t->warpmv); +#define signabs(v) v < 0 ? '-' : ' ', abs(v) + if (DEBUG_BLOCK_INFO) + printf("[ %c%x %c%x %c%x\n %c%x %c%x %c%x ]\n" + "alpha=%c%x, beta=%c%x, gamma=%c%x, delta=%c%x\n", + signabs(t->warpmv.matrix[0]), + signabs(t->warpmv.matrix[1]), + signabs(t->warpmv.matrix[2]), + signabs(t->warpmv.matrix[3]), + signabs(t->warpmv.matrix[4]), + signabs(t->warpmv.matrix[5]), + signabs(t->warpmv.alpha), + signabs(t->warpmv.beta), + signabs(t->warpmv.gamma), + signabs(t->warpmv.delta)); +#undef signabs + } + + if (DEBUG_BLOCK_INFO) + printf("Post-motionmode[%d]: r=%d [mask: 0x%" PRIu64 "x/0x%" + PRIu64 "x]\n", b->motion_mode, ts->msac.rng, mask[0], + mask[1]); + } else { + b->motion_mode = MM_TRANSLATION; + } + } + + // subpel filter + enum FilterMode filter[2]; + if (f->frame_hdr.subpel_filter_mode == FILTER_SWITCHABLE) { + if (has_subpel_filter) { + const int comp = b->comp_type != COMP_INTER_NONE; + const int ctx1 = get_filter_ctx(t->a, &t->l, comp, 0, b->ref[0], + by4, bx4); + filter[0] = msac_decode_symbol_adapt(&ts->msac, + ts->cdf.m.filter[0][ctx1], N_SWITCHABLE_FILTERS); + if (f->seq_hdr.dual_filter) { + const int ctx2 = get_filter_ctx(t->a, &t->l, comp, 1, + b->ref[0], by4, bx4); + if (DEBUG_BLOCK_INFO) + printf("Post-subpel_filter1[%d,ctx=%d]: r=%d\n", + filter[0], ctx1, ts->msac.rng); + filter[1] = msac_decode_symbol_adapt(&ts->msac, + ts->cdf.m.filter[1][ctx2], N_SWITCHABLE_FILTERS); + if (DEBUG_BLOCK_INFO) + printf("Post-subpel_filter2[%d,ctx=%d]: r=%d\n", + filter[1], ctx2, ts->msac.rng); + } else { + filter[1] = filter[0]; + if (DEBUG_BLOCK_INFO) + printf("Post-subpel_filter[%d,ctx=%d]: r=%d\n", + filter[0], ctx1, ts->msac.rng); + } + } else { + filter[0] = filter[1] = FILTER_8TAP_REGULAR; + } + } else { + filter[0] = filter[1] = f->frame_hdr.subpel_filter_mode; + } + b->filter2d = av1_filter_2d[filter[1]][filter[0]]; + + read_vartx_tree(t, b, bs, bx4, by4); + + // reconstruction + if (f->frame_thread.pass == 1) { + f->bd_fn.read_coef_blocks(t, bs, b); + } else { + f->bd_fn.recon_b_inter(t, bs, b); + } + + const int is_globalmv = + b->inter_mode == (is_comp ? GLOBALMV_GLOBALMV : GLOBALMV); + const uint8_t (*const lf_lvls)[8][2] = (const uint8_t (*)[8][2]) + &ts->lflvl[b->seg_id][0][b->ref[0] + 1][!is_globalmv]; + dav1d_create_lf_mask_inter(t->lf_mask, f->lf.level, f->b4_stride, + &f->frame_hdr, lf_lvls, t->bx, t->by, + f->bw, f->bh, b->skip, bs, b->tx_split, + b->uvtx, f->cur.p.p.layout, + &t->a->tx_lpf_y[bx4], &t->l.tx_lpf_y[by4], + has_chroma ? &t->a->tx_lpf_uv[cbx4] : NULL, + has_chroma ? &t->l.tx_lpf_uv[cby4] : NULL); + + // context updates + if (is_comp) { + splat_tworef_mv(f->mvs, f->b4_stride, t->by, t->bx, bs, + b->inter_mode, b->ref[0], b->ref[1], + b->mv[0], b->mv[1]); + } else { + splat_oneref_mv(f->mvs, f->b4_stride, t->by, t->bx, bs, + b->inter_mode, b->ref[0], b->mv[0], + b->interintra_type); + } + memset(&t->l.pal_sz[by4], 0, bh4); + memset(&t->a->pal_sz[bx4], 0, bw4); + if (has_chroma) { + memset(&t->l.uvmode[cby4], DC_PRED, cbh4); + memset(&t->a->uvmode[cbx4], DC_PRED, cbw4); + memset(&t->pal_sz_uv[1][cby4], 0, cbh4); + memset(&t->pal_sz_uv[0][cbx4], 0, cbw4); + } + memset(&t->a->tx_intra[bx4], b_dim[2], bw4); + memset(&t->l.tx_intra[by4], b_dim[3], bh4); + memset(&t->l.comp_type[by4], b->comp_type, bh4); + memset(&t->a->comp_type[bx4], b->comp_type, bw4); + memset(&t->l.filter[0][by4], filter[0], bh4); + memset(&t->a->filter[0][bx4], filter[0], bw4); + memset(&t->l.filter[1][by4], filter[1], bh4); + memset(&t->a->filter[1][bx4], filter[1], bw4); + memset(&t->l.mode[by4], b->inter_mode, bh4); + memset(&t->a->mode[bx4], b->inter_mode, bw4); + memset(&t->l.ref[0][by4], b->ref[0], bh4); + memset(&t->a->ref[0][bx4], b->ref[0], bw4); + memset(&t->l.ref[1][by4], b->ref[1], bh4); + memset(&t->a->ref[1][bx4], b->ref[1], bw4); + } + + // update contexts + if (f->frame_hdr.segmentation.enabled && + f->frame_hdr.segmentation.update_map) + { + uint8_t *seg_ptr = &f->cur_segmap[t->by * f->b4_stride + t->bx]; + for (int y = 0; y < bh4; y++) { + memset(seg_ptr, b->seg_id, bw4); + seg_ptr += f->b4_stride; + } + } + memset(&t->l.seg_pred[by4], seg_pred, bh4); + memset(&t->a->seg_pred[bx4], seg_pred, bw4); + memset(&t->l.skip_mode[by4], b->skip_mode, bh4); + memset(&t->a->skip_mode[bx4], b->skip_mode, bw4); + memset(&t->l.intra[by4], b->intra, bh4); + memset(&t->a->intra[bx4], b->intra, bw4); + memset(&t->l.skip[by4], b->skip, bh4); + memset(&t->a->skip[bx4], b->skip, bw4); + if (!b->skip) { + uint32_t *noskip_mask = &t->lf_mask->noskip_mask[by4]; + const unsigned mask = ((1ULL << bw4) - 1) << bx4; + for (int y = 0; y < bh4; y++) + *noskip_mask++ |= mask; + } +} + +static int decode_sb(Dav1dTileContext *const t, const enum BlockLevel bl, + const EdgeNode *const node) +{ + const Dav1dFrameContext *const f = t->f; + const int hsz = 16 >> bl; + const int have_h_split = f->bw > t->bx + hsz; + const int have_v_split = f->bh > t->by + hsz; + + if (!have_h_split && !have_v_split) { + assert(bl < BL_8X8); + return decode_sb(t, bl + 1, ((const EdgeBranch *) node)->split[0]); + } + + uint16_t *pc; + enum BlockPartition bp; + int ctx, bx8, by8; + if (f->frame_thread.pass != 2) { + if (0 && bl == BL_64X64) + printf("poc=%d,y=%d,x=%d,bl=%d,r=%d\n", + f->frame_hdr.frame_offset, t->by, t->bx, bl, t->ts->msac.rng); + bx8 = (t->bx & 31) >> 1; + by8 = (t->by & 31) >> 1; + ctx = get_partition_ctx(t->a, &t->l, bl, by8, bx8); + pc = t->ts->cdf.m.partition[bl][ctx]; + } + + if (have_h_split && have_v_split) { + if (f->frame_thread.pass == 2) { + const Av1Block *const b = &f->frame_thread.b[t->by * f->b4_stride + t->bx]; + bp = b->bl == bl ? b->bp : PARTITION_SPLIT; + } else { + const unsigned n_part = bl == BL_8X8 ? N_SUB8X8_PARTITIONS : + bl == BL_128X128 ? N_PARTITIONS - 2 : N_PARTITIONS; + bp = msac_decode_symbol_adapt(&t->ts->msac, pc, n_part); + if (f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I422 && + (bp == PARTITION_V || bp == PARTITION_V4 || + bp == PARTITION_T_LEFT_SPLIT || bp == PARTITION_T_RIGHT_SPLIT)) + { + return 1; + } + if (DEBUG_BLOCK_INFO) + printf("poc=%d,y=%d,x=%d,bl=%d,ctx=%d,bp=%d: r=%d\n", + f->frame_hdr.frame_offset, t->by, t->bx, bl, ctx, bp, + t->ts->msac.rng); + } + const uint8_t *const b = av1_block_sizes[bl][bp]; + + switch (bp) { + case PARTITION_NONE: + decode_b(t, bl, b[0], PARTITION_NONE, node->o); + break; + case PARTITION_H: + decode_b(t, bl, b[0], PARTITION_H, node->h[0]); + t->by += hsz; + decode_b(t, bl, b[0], PARTITION_H, node->h[1]); + t->by -= hsz; + break; + case PARTITION_V: + decode_b(t, bl, b[0], PARTITION_V, node->v[0]); + t->bx += hsz; + decode_b(t, bl, b[0], PARTITION_V, node->v[1]); + t->bx -= hsz; + break; + case PARTITION_SPLIT: + if (bl == BL_8X8) { + const EdgeTip *const tip = (const EdgeTip *) node; + assert(hsz == 1); + decode_b(t, bl, BS_4x4, PARTITION_SPLIT, tip->split[0]); + const enum Filter2d tl_filter = t->tl_4x4_filter; + t->bx++; + decode_b(t, bl, BS_4x4, PARTITION_SPLIT, tip->split[1]); + t->bx--; + t->by++; + decode_b(t, bl, BS_4x4, PARTITION_SPLIT, tip->split[2]); + t->bx++; + t->tl_4x4_filter = tl_filter; + decode_b(t, bl, BS_4x4, PARTITION_SPLIT, tip->split[3]); + t->bx--; + t->by--; + } else { + const EdgeBranch *const branch = (const EdgeBranch *) node; + if (decode_sb(t, bl + 1, branch->split[0])) return 1; + t->bx += hsz; + if (decode_sb(t, bl + 1, branch->split[1])) return 1; + t->bx -= hsz; + t->by += hsz; + if (decode_sb(t, bl + 1, branch->split[2])) return 1; + t->bx += hsz; + if (decode_sb(t, bl + 1, branch->split[3])) return 1; + t->bx -= hsz; + t->by -= hsz; + } + break; + case PARTITION_T_TOP_SPLIT: { + const EdgeBranch *const branch = (const EdgeBranch *) node; + decode_b(t, bl, b[0], PARTITION_T_TOP_SPLIT, branch->tts[0]); + t->bx += hsz; + decode_b(t, bl, b[0], PARTITION_T_TOP_SPLIT, branch->tts[1]); + t->bx -= hsz; + t->by += hsz; + decode_b(t, bl, b[1], PARTITION_T_TOP_SPLIT, branch->tts[2]); + t->by -= hsz; + break; + } + case PARTITION_T_BOTTOM_SPLIT: { + const EdgeBranch *const branch = (const EdgeBranch *) node; + decode_b(t, bl, b[0], PARTITION_T_BOTTOM_SPLIT, branch->tbs[0]); + t->by += hsz; + decode_b(t, bl, b[1], PARTITION_T_BOTTOM_SPLIT, branch->tbs[1]); + t->bx += hsz; + decode_b(t, bl, b[1], PARTITION_T_BOTTOM_SPLIT, branch->tbs[2]); + t->bx -= hsz; + t->by -= hsz; + break; + } + case PARTITION_T_LEFT_SPLIT: { + const EdgeBranch *const branch = (const EdgeBranch *) node; + decode_b(t, bl, b[0], PARTITION_T_LEFT_SPLIT, branch->tls[0]); + t->by += hsz; + decode_b(t, bl, b[0], PARTITION_T_LEFT_SPLIT, branch->tls[1]); + t->by -= hsz; + t->bx += hsz; + decode_b(t, bl, b[1], PARTITION_T_LEFT_SPLIT, branch->tls[2]); + t->bx -= hsz; + break; + } + case PARTITION_T_RIGHT_SPLIT: { + const EdgeBranch *const branch = (const EdgeBranch *) node; + decode_b(t, bl, b[0], PARTITION_T_RIGHT_SPLIT, branch->trs[0]); + t->bx += hsz; + decode_b(t, bl, b[1], PARTITION_T_RIGHT_SPLIT, branch->trs[1]); + t->by += hsz; + decode_b(t, bl, b[1], PARTITION_T_RIGHT_SPLIT, branch->trs[2]); + t->by -= hsz; + t->bx -= hsz; + break; + } + case PARTITION_H4: { + const EdgeBranch *const branch = (const EdgeBranch *) node; + decode_b(t, bl, b[0], PARTITION_H4, branch->h4[0]); + t->by += hsz >> 1; + decode_b(t, bl, b[0], PARTITION_H4, branch->h4[1]); + t->by += hsz >> 1; + decode_b(t, bl, b[0], PARTITION_H4, branch->h4[2]); + t->by += hsz >> 1; + if (t->by < f->bh) + decode_b(t, bl, b[0], PARTITION_H4, branch->h4[3]); + t->by -= hsz * 3 >> 1; + break; + } + case PARTITION_V4: { + const EdgeBranch *const branch = (const EdgeBranch *) node; + decode_b(t, bl, b[0], PARTITION_V4, branch->v4[0]); + t->bx += hsz >> 1; + decode_b(t, bl, b[0], PARTITION_V4, branch->v4[1]); + t->bx += hsz >> 1; + decode_b(t, bl, b[0], PARTITION_V4, branch->v4[2]); + t->bx += hsz >> 1; + if (t->bx < f->bw) + decode_b(t, bl, b[0], PARTITION_V4, branch->v4[3]); + t->bx -= hsz * 3 >> 1; + break; + } + default: assert(0); + } + } else if (have_h_split) { + unsigned is_split; + if (f->frame_thread.pass == 2) { + const Av1Block *const b = &f->frame_thread.b[t->by * f->b4_stride + t->bx]; + is_split = b->bl != bl; + } else { + const unsigned p = gather_top_partition_prob(pc, bl); + is_split = msac_decode_bool(&t->ts->msac, p); + if (DEBUG_BLOCK_INFO) + printf("poc=%d,y=%d,x=%d,bl=%d,ctx=%d,bp=%d: r=%d\n", + f->frame_hdr.frame_offset, t->by, t->bx, bl, ctx, + is_split ? PARTITION_SPLIT : PARTITION_H, t->ts->msac.rng); + } + + assert(bl < BL_8X8); + if (is_split) { + const EdgeBranch *const branch = (const EdgeBranch *) node; + bp = PARTITION_SPLIT; + if (decode_sb(t, bl + 1, branch->split[0])) return 1; + t->bx += hsz; + if (decode_sb(t, bl + 1, branch->split[1])) return 1; + t->bx -= hsz; + } else { + bp = PARTITION_H; + decode_b(t, bl, av1_block_sizes[bl][PARTITION_H][0], PARTITION_H, + node->h[0]); + } + } else { + assert(have_v_split); + unsigned is_split; + if (f->frame_thread.pass == 2) { + const Av1Block *const b = &f->frame_thread.b[t->by * f->b4_stride + t->bx]; + is_split = b->bl != bl; + } else { + const unsigned p = gather_left_partition_prob(pc, bl); + is_split = msac_decode_bool(&t->ts->msac, p); + if (f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I422 && !is_split) + return 1; + if (DEBUG_BLOCK_INFO) + printf("poc=%d,y=%d,x=%d,bl=%d,ctx=%d,bp=%d: r=%d\n", + f->frame_hdr.frame_offset, t->by, t->bx, bl, ctx, + is_split ? PARTITION_SPLIT : PARTITION_V, t->ts->msac.rng); + } + + assert(bl < BL_8X8); + if (is_split) { + const EdgeBranch *const branch = (const EdgeBranch *) node; + bp = PARTITION_SPLIT; + if (decode_sb(t, bl + 1, branch->split[0])) return 1; + t->by += hsz; + if (decode_sb(t, bl + 1, branch->split[2])) return 1; + t->by -= hsz; + } else { + bp = PARTITION_V; + decode_b(t, bl, av1_block_sizes[bl][PARTITION_V][0], PARTITION_V, + node->v[0]); + } + } + + if (f->frame_thread.pass != 2 && (bp != PARTITION_SPLIT || bl == BL_8X8)) { + memset(&t->a->partition[bx8], av1_al_part_ctx[0][bl][bp], hsz); + memset(&t->l.partition[by8], av1_al_part_ctx[1][bl][bp], hsz); + } + + return 0; +} + +static void reset_context(BlockContext *const ctx, const int keyframe, const int pass) { + memset(ctx->intra, keyframe, sizeof(ctx->intra)); + memset(ctx->uvmode, DC_PRED, sizeof(ctx->uvmode)); + if (keyframe) + memset(ctx->mode, DC_PRED, sizeof(ctx->mode)); + + if (pass == 2) return; + + memset(ctx->partition, 0, sizeof(ctx->partition)); + memset(ctx->skip, 0, sizeof(ctx->skip)); + memset(ctx->skip_mode, 0, sizeof(ctx->skip_mode)); + memset(ctx->tx_lpf_y, 2, sizeof(ctx->tx_lpf_y)); + memset(ctx->tx_lpf_uv, 1, sizeof(ctx->tx_lpf_uv)); + memset(ctx->tx_intra, -1, sizeof(ctx->tx_intra)); + memset(ctx->tx, TX_64X64, sizeof(ctx->tx)); + if (!keyframe) { + memset(ctx->ref, -1, sizeof(ctx->ref)); + memset(ctx->comp_type, 0, sizeof(ctx->comp_type)); + memset(ctx->mode, NEARESTMV, sizeof(ctx->mode)); + } + memset(ctx->lcoef, 0x40, sizeof(ctx->lcoef)); + memset(ctx->ccoef, 0x40, sizeof(ctx->ccoef)); + memset(ctx->filter, N_SWITCHABLE_FILTERS, sizeof(ctx->filter)); + memset(ctx->seg_pred, 0, sizeof(ctx->seg_pred)); + memset(ctx->pal_sz, 0, sizeof(ctx->pal_sz)); +} + +static void setup_tile(Dav1dTileState *const ts, + const Dav1dFrameContext *const f, + const uint8_t *const data, const size_t sz, + const int tile_row, const int tile_col, + const int tile_start_off) +{ + const int col_sb_start = f->frame_hdr.tiling.col_start_sb[tile_col]; + const int col_sb128_start = col_sb_start >> !f->seq_hdr.sb128; + const int col_sb_end = f->frame_hdr.tiling.col_start_sb[tile_col + 1]; + const int row_sb_start = f->frame_hdr.tiling.row_start_sb[tile_row]; + const int row_sb_end = f->frame_hdr.tiling.row_start_sb[tile_row + 1]; + const int sb_shift = f->sb_shift; + + ts->frame_thread.pal_idx = &f->frame_thread.pal_idx[tile_start_off * 2]; + ts->frame_thread.cf = &((int32_t *) f->frame_thread.cf)[tile_start_off * 3]; + ts->cdf = *f->in_cdf.cdf; + ts->last_qidx = f->frame_hdr.quant.yac; + memset(ts->last_delta_lf, 0, sizeof(ts->last_delta_lf)); + + msac_init(&ts->msac, data, sz); + + ts->tiling.row = tile_row; + ts->tiling.col = tile_col; + ts->tiling.col_start = col_sb_start << sb_shift; + ts->tiling.col_end = imin(col_sb_end << sb_shift, f->bw); + ts->tiling.row_start = row_sb_start << sb_shift; + ts->tiling.row_end = imin(row_sb_end << sb_shift, f->bh); + + // Reference Restoration Unit (used for exp coding) + Av1Filter *const lf_mask = + f->lf.mask + (ts->tiling.row_start >> 5) * f->sb128w + col_sb128_start; + const int unit_idx = ((ts->tiling.row_start & 16) >> 3) + + ((ts->tiling.col_start & 16) >> 4); + for (int p = 0; p < 3; p++) { + ts->lr_ref[p] = &lf_mask->lr[p][unit_idx]; + ts->lr_ref[p]->filter_v[0] = 3; + ts->lr_ref[p]->filter_v[1] = -7; + ts->lr_ref[p]->filter_v[2] = 15; + ts->lr_ref[p]->filter_h[0] = 3; + ts->lr_ref[p]->filter_h[1] = -7; + ts->lr_ref[p]->filter_h[2] = 15; + ts->lr_ref[p]->sgr_weights[0] = -32; + ts->lr_ref[p]->sgr_weights[1] = 31; + } + + if (f->n_tc > 1) + atomic_init(&ts->progress, 0); +} + +int decode_tile_sbrow(Dav1dTileContext *const t) { + const Dav1dFrameContext *const f = t->f; + const enum BlockLevel root_bl = f->seq_hdr.sb128 ? BL_128X128 : BL_64X64; + Dav1dTileState *const ts = t->ts; + const Dav1dContext *const c = f->c; + const int sb_step = f->sb_step; + const int tile_row = ts->tiling.row, tile_col = ts->tiling.col; + const int col_sb_start = f->frame_hdr.tiling.col_start_sb[tile_col]; + const int col_sb128_start = col_sb_start >> !f->seq_hdr.sb128; + + reset_context(&t->l, !(f->frame_hdr.frame_type & 1), f->frame_thread.pass); + if (f->frame_thread.pass == 2) { + for (t->bx = ts->tiling.col_start, + t->a = f->a + col_sb128_start + tile_row * f->sb128w; + t->bx < ts->tiling.col_end; t->bx += sb_step) + { + if (decode_sb(t, root_bl, c->intra_edge.root[root_bl])) + return 1; + if (t->bx & 16 || f->seq_hdr.sb128) + t->a++; + } + f->bd_fn.backup_ipred_edge(t); + return 0; + } + + const int ss_ver = f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I420; + const int ss_hor = f->cur.p.p.layout != DAV1D_PIXEL_LAYOUT_I444; + + if (c->n_fc > 1 && f->frame_hdr.use_ref_frame_mvs) { + for (int n = 0; n < 7; n++) + dav1d_thread_picture_wait(&f->refp[n], 4 * (t->by + sb_step), + PLANE_TYPE_BLOCK); + av1_init_ref_mv_tile_row(f->libaom_cm, + ts->tiling.col_start, ts->tiling.col_end, + t->by, imin(t->by + sb_step, f->bh)); + } + memset(t->pal_sz_uv[1], 0, sizeof(*t->pal_sz_uv)); + const int sb128y = t->by >> 5; + for (t->bx = ts->tiling.col_start, t->a = f->a + col_sb128_start + tile_row * f->sb128w, + t->lf_mask = f->lf.mask + sb128y * f->sb128w + col_sb128_start; + t->bx < ts->tiling.col_end; t->bx += sb_step) + { + if (root_bl == BL_128X128) { + t->cur_sb_cdef_idx_ptr = t->lf_mask->cdef_idx; + t->cur_sb_cdef_idx_ptr[0] = -1; + t->cur_sb_cdef_idx_ptr[1] = -1; + t->cur_sb_cdef_idx_ptr[2] = -1; + t->cur_sb_cdef_idx_ptr[3] = -1; + } else { + t->cur_sb_cdef_idx_ptr = + &t->lf_mask->cdef_idx[((t->bx & 16) >> 4) + + ((t->by & 16) >> 3)]; + t->cur_sb_cdef_idx_ptr[0] = -1; + } + // Restoration filter + for (int p = 0; p < 3; p++) { + if (f->frame_hdr.restoration.type[p] == RESTORATION_NONE) + continue; + const int by = t->by >> (ss_ver & !!p); + const int bx = t->bx >> (ss_hor & !!p); + const int bh = f->bh >> (ss_ver & !!p); + const int bw = f->bw >> (ss_hor & !!p); + + const int unit_size_log2 = + f->frame_hdr.restoration.unit_size[!!p]; + // 4pel unit size + const int b_unit_size = 1 << (unit_size_log2 - 2); + const unsigned mask = b_unit_size - 1; + if (by & mask || bx & mask) continue; + const int half_unit = b_unit_size >> 1; + // Round half up at frame boundaries, if there's more than one + // restoration unit + const int bottom_round = by && by + half_unit > bh; + const int right_round = bx && bx + half_unit > bw; + if (bottom_round || right_round) continue; + const int unit_idx = ((t->by & 16) >> 3) + ((t->bx & 16) >> 4); + Av1RestorationUnit *const lr = &t->lf_mask->lr[p][unit_idx]; + const enum RestorationType frame_type = + f->frame_hdr.restoration.type[p]; + + if (frame_type == RESTORATION_SWITCHABLE) { + const int filter = + msac_decode_symbol_adapt(&ts->msac, + ts->cdf.m.restore_switchable, 3); + lr->type = filter ? filter == 2 ? RESTORATION_SGRPROJ : + RESTORATION_WIENER : + RESTORATION_NONE; + } else { + const unsigned type = + msac_decode_bool_adapt(&ts->msac, + frame_type == RESTORATION_WIENER ? + ts->cdf.m.restore_wiener : + ts->cdf.m.restore_sgrproj); + lr->type = type ? frame_type : RESTORATION_NONE; + } + + if (lr->type == RESTORATION_WIENER) { + lr->filter_v[0] = + !p ? msac_decode_subexp(&ts->msac, + ts->lr_ref[p]->filter_v[0] + 5, 16, + 1) - 5: + 0; + lr->filter_v[1] = + msac_decode_subexp(&ts->msac, + ts->lr_ref[p]->filter_v[1] + 23, 32, + 2) - 23; + lr->filter_v[2] = + msac_decode_subexp(&ts->msac, + ts->lr_ref[p]->filter_v[2] + 17, 64, + 3) - 17; + + lr->filter_h[0] = + !p ? msac_decode_subexp(&ts->msac, + ts->lr_ref[p]->filter_h[0] + 5, 16, + 1) - 5: + 0; + lr->filter_h[1] = + msac_decode_subexp(&ts->msac, + ts->lr_ref[p]->filter_h[1] + 23, 32, + 2) - 23; + lr->filter_h[2] = + msac_decode_subexp(&ts->msac, + ts->lr_ref[p]->filter_h[2] + 17, 64, + 3) - 17; + memcpy(lr->sgr_weights, ts->lr_ref[p]->sgr_weights, sizeof(lr->sgr_weights)); + ts->lr_ref[p] = lr; + if (DEBUG_BLOCK_INFO) + printf("Post-lr_wiener[pl=%d,v[%d,%d,%d],h[%d,%d,%d]]: r=%d\n", + p, lr->filter_v[0], lr->filter_v[1], + lr->filter_v[2], lr->filter_h[0], + lr->filter_h[1], lr->filter_h[2], ts->msac.rng); + } else if (lr->type == RESTORATION_SGRPROJ) { + const unsigned idx = msac_decode_bools(&ts->msac, 4); + lr->sgr_idx = idx; + lr->sgr_weights[0] = sgr_params[idx][0] ? + msac_decode_subexp(&ts->msac, + ts->lr_ref[p]->sgr_weights[0] + 96, 128, + 4) - 96 : + 0; + lr->sgr_weights[1] = sgr_params[idx][1] ? + msac_decode_subexp(&ts->msac, + ts->lr_ref[p]->sgr_weights[1] + 32, 128, + 4) - 32 : + iclip(128 - lr->sgr_weights[0], -32, 95); + memcpy(lr->filter_v, ts->lr_ref[p]->filter_v, sizeof(lr->filter_v)); + memcpy(lr->filter_h, ts->lr_ref[p]->filter_h, sizeof(lr->filter_h)); + ts->lr_ref[p] = lr; + if (DEBUG_BLOCK_INFO) + printf("Post-lr_sgrproj[pl=%d,idx=%d,w[%d,%d]]: r=%d\n", + p, lr->sgr_idx, lr->sgr_weights[0], + lr->sgr_weights[1], ts->msac.rng); + } + } + if (decode_sb(t, root_bl, c->intra_edge.root[root_bl])) + return 1; + if (t->bx & 16 || f->seq_hdr.sb128) { + t->a++; + t->lf_mask++; + } + } + + // backup pre-loopfilter pixels for intra prediction of the next sbrow + if (f->frame_thread.pass != 1) + f->bd_fn.backup_ipred_edge(t); + + // backup t->a/l.tx_lpf_y/uv at tile boundaries to use them to "fix" + // up the initial value in neighbour tiles when running the loopfilter + int align_h = (f->bh + 31) & ~31; + memcpy(&f->lf.tx_lpf_right_edge[0][align_h * tile_col + t->by], + &t->l.tx_lpf_y[t->by & 16], sb_step); + align_h >>= 1; + memcpy(&f->lf.tx_lpf_right_edge[1][align_h * tile_col + (t->by >> 1)], + &t->l.tx_lpf_uv[(t->by & 16) >> 1], sb_step >> 1); + + return 0; +} + +int decode_frame(Dav1dFrameContext *const f) { + const Dav1dContext *const c = f->c; + + if (f->n_tc > 1) { + if (f->frame_hdr.tiling.cols * f->sbh > f->tile_thread.titsati_sz) { + f->tile_thread.task_idx_to_sby_and_tile_idx = + malloc(sizeof(*f->tile_thread.task_idx_to_sby_and_tile_idx) * + f->frame_hdr.tiling.cols * f->sbh); + if (!f->tile_thread.task_idx_to_sby_and_tile_idx) return -ENOMEM; + f->tile_thread.titsati_sz = f->frame_hdr.tiling.cols * f->sbh; + } + if (f->tile_thread.titsati_init[0] != f->frame_hdr.tiling.cols || + f->tile_thread.titsati_init[1] != f->sbh) + { + for (int tile_row = 0, tile_idx = 0; + tile_row < f->frame_hdr.tiling.rows; tile_row++) + { + for (int sby = f->frame_hdr.tiling.row_start_sb[tile_row]; + sby < f->frame_hdr.tiling.row_start_sb[tile_row + 1]; sby++) + { + for (int tile_col = 0; tile_col < f->frame_hdr.tiling.cols; + tile_col++, tile_idx++) + { + f->tile_thread.task_idx_to_sby_and_tile_idx[tile_idx][0] = sby; + f->tile_thread.task_idx_to_sby_and_tile_idx[tile_idx][1] = + tile_row * f->frame_hdr.tiling.cols + tile_col; + } + } + } + f->tile_thread.titsati_init[0] = f->frame_hdr.tiling.cols; + f->tile_thread.titsati_init[1] = f->sbh; + } + } + + if (f->frame_hdr.tiling.cols * f->frame_hdr.tiling.rows > f->n_ts) { + f->ts = realloc(f->ts, f->frame_hdr.tiling.cols * + f->frame_hdr.tiling.rows * sizeof(*f->ts)); + if (!f->ts) return -ENOMEM; + for (int n = f->n_ts; + n < f->frame_hdr.tiling.cols * f->frame_hdr.tiling.rows; n++) + { + Dav1dTileState *const ts = &f->ts[n]; + pthread_mutex_init(&ts->tile_thread.lock, NULL); + pthread_cond_init(&ts->tile_thread.cond, NULL); + } + if (c->n_fc > 1) { + freep(&f->frame_thread.tile_start_off); + f->frame_thread.tile_start_off = + malloc(sizeof(*f->frame_thread.tile_start_off) * + f->frame_hdr.tiling.cols * f->frame_hdr.tiling.rows); + } + f->n_ts = f->frame_hdr.tiling.cols * f->frame_hdr.tiling.rows; + } + + if (c->n_fc > 1) { + int tile_idx = 0; + for (int tile_row = 0; tile_row < f->frame_hdr.tiling.rows; tile_row++) { + int row_off = f->frame_hdr.tiling.row_start_sb[tile_row] * + f->sb_step * 4 * f->sb128w * 128; + int b_diff = (f->frame_hdr.tiling.row_start_sb[tile_row + 1] - + f->frame_hdr.tiling.row_start_sb[tile_row]) * f->sb_step * 4; + for (int tile_col = 0; tile_col < f->frame_hdr.tiling.cols; tile_col++) { + f->frame_thread.tile_start_off[tile_idx++] = row_off + b_diff * + f->frame_hdr.tiling.col_start_sb[tile_col] * f->sb_step * 4; + } + } + } + + if (f->sb128w * f->frame_hdr.tiling.rows > f->a_sz) { + freep(&f->a); + f->a = malloc(f->sb128w * f->frame_hdr.tiling.rows * sizeof(*f->a)); + if (!f->a) return -ENOMEM; + f->a_sz = f->sb128w * f->frame_hdr.tiling.rows; + } + + // update allocation of block contexts for above + if (f->sb128w > f->lf.line_sz) { + dav1d_freep_aligned(&f->lf.cdef_line); + dav1d_freep_aligned(&f->lf.lr_lpf_line); + + // note that we allocate all pixel arrays as if we were dealing with + // 10 bits/component data + uint16_t *ptr = f->lf.cdef_line = + dav1d_alloc_aligned(f->b4_stride * 4 * 12 * sizeof(uint16_t), 32); + + uint16_t *lr_ptr = f->lf.lr_lpf_line = + dav1d_alloc_aligned(f->b4_stride * 4 * 3 * 12 * sizeof(uint16_t), 32); + + for (int pl = 0; pl <= 2; pl++) { + f->lf.cdef_line_ptr[0][pl][0] = ptr + f->b4_stride * 4 * 0; + f->lf.cdef_line_ptr[0][pl][1] = ptr + f->b4_stride * 4 * 1; + f->lf.cdef_line_ptr[1][pl][0] = ptr + f->b4_stride * 4 * 2; + f->lf.cdef_line_ptr[1][pl][1] = ptr + f->b4_stride * 4 * 3; + ptr += f->b4_stride * 4 * 4; + + f->lf.lr_lpf_line_ptr[pl] = lr_ptr; + lr_ptr += f->b4_stride * 4 * 12; + } + + f->lf.line_sz = f->sb128w; + } + + // update allocation for loopfilter masks + if (f->sb128w * f->sb128h > f->lf.mask_sz) { + freep(&f->lf.mask); + freep(&f->lf.level); + freep(&f->frame_thread.b); + f->lf.mask = malloc(f->sb128w * f->sb128h * sizeof(*f->lf.mask)); + f->lf.level = malloc(f->sb128w * f->sb128h * 32 * 32 * + sizeof(*f->lf.level)); + if (!f->lf.mask || !f->lf.level) return -ENOMEM; + if (c->n_fc > 1) { + freep(&f->frame_thread.b); + freep(&f->frame_thread.cbi); + dav1d_freep_aligned(&f->frame_thread.cf); + dav1d_freep_aligned(&f->frame_thread.pal_idx); + freep(&f->frame_thread.pal); + f->frame_thread.b = malloc(sizeof(*f->frame_thread.b) * + f->sb128w * f->sb128h * 32 * 32); + f->frame_thread.pal = malloc(sizeof(*f->frame_thread.pal) * + f->sb128w * f->sb128h * 16 * 16); + f->frame_thread.pal_idx = + dav1d_alloc_aligned(sizeof(*f->frame_thread.pal_idx) * + f->sb128w * f->sb128h * 128 * 128 * 2, 32); + f->frame_thread.cbi = malloc(sizeof(*f->frame_thread.cbi) * + f->sb128w * f->sb128h * 32 * 32); + f->frame_thread.cf = + dav1d_alloc_aligned(sizeof(int32_t) * 3 * + f->sb128w * f->sb128h * 128 * 128, 32); + if (!f->frame_thread.b || !f->frame_thread.pal_idx || + !f->frame_thread.cf) + { + return -ENOMEM; + } + memset(f->frame_thread.cf, 0, + sizeof(int32_t) * 3 * f->sb128w * f->sb128h * 128 * 128); + } + f->lf.mask_sz = f->sb128w * f->sb128h; + } + if (f->frame_hdr.loopfilter.sharpness != f->lf.last_sharpness) { + dav1d_calc_eih(&f->lf.lim_lut, f->frame_hdr.loopfilter.sharpness); + f->lf.last_sharpness = f->frame_hdr.loopfilter.sharpness; + } + dav1d_calc_lf_values(f->lf.lvl, &f->frame_hdr, (int8_t[4]) { 0, 0, 0, 0 }); + memset(f->lf.mask, 0, sizeof(*f->lf.mask) * f->sb128w * f->sb128h); + + if (f->sbh * f->sb128w * 128 > f->ipred_edge_sz) { + dav1d_freep_aligned(&f->ipred_edge[0]); + uint16_t *ptr = f->ipred_edge[0] = + dav1d_alloc_aligned(f->sb128w * 128 * f->sbh * 3 * sizeof(uint16_t), 32); + if (!f->ipred_edge[0]) return -ENOMEM; + f->ipred_edge_sz = f->sbh * f->sb128w * 128; + f->ipred_edge[1] = &ptr[f->ipred_edge_sz]; + f->ipred_edge[2] = &ptr[f->ipred_edge_sz * 2]; + } + + if (f->sb128h > f->lf.re_sz) { + freep(&f->lf.tx_lpf_right_edge[0]); + f->lf.tx_lpf_right_edge[0] = malloc((f->sb128h * 32 * 2) * + f->frame_hdr.tiling.cols); + if (!f->lf.tx_lpf_right_edge[0]) return -ENOMEM; + f->lf.tx_lpf_right_edge[1] = f->lf.tx_lpf_right_edge[0] + + f->sb128h * 32 * f->frame_hdr.tiling.cols; + f->lf.re_sz = f->sb128h; + } + + // init ref mvs + if ((f->frame_hdr.frame_type & 1) || f->frame_hdr.allow_intrabc) { + f->mvs = f->mvs_ref->data; + const int order_hint_n_bits = f->seq_hdr.order_hint * f->seq_hdr.order_hint_n_bits; + av1_init_ref_mv_common(f->libaom_cm, f->bw >> 1, f->bh >> 1, + f->b4_stride, f->seq_hdr.sb128, + f->mvs, f->ref_mvs, f->cur.p.poc, f->refpoc, + f->refrefpoc, f->frame_hdr.gmv, + f->frame_hdr.hp, f->frame_hdr.force_integer_mv, + f->frame_hdr.use_ref_frame_mvs, + order_hint_n_bits); + if (c->n_fc == 1 && f->frame_hdr.use_ref_frame_mvs) + av1_init_ref_mv_tile_row(f->libaom_cm, 0, f->bw, 0, f->bh); + } + + // setup dequant tables + init_quant_tables(&f->seq_hdr, &f->frame_hdr, f->frame_hdr.quant.yac, f->dq); + if (f->frame_hdr.quant.qm) + for (int j = 0; j < N_RECT_TX_SIZES; j++) { + f->qm[0][j][0] = av1_qm_tbl[f->frame_hdr.quant.qm_y][0][j]; + f->qm[0][j][1] = av1_qm_tbl[f->frame_hdr.quant.qm_u][1][j]; + f->qm[0][j][2] = av1_qm_tbl[f->frame_hdr.quant.qm_v][1][j]; + } + for (int i = f->frame_hdr.quant.qm; i < 2; i++) + for (int tx = 0; tx < N_RECT_TX_SIZES; tx++) + for (int pl = 0; pl < 3; pl++) + f->qm[i][tx][pl] = av1_qm_tbl[15][!!pl][tx]; + + // setup jnt_comp weights + if (f->frame_hdr.switchable_comp_refs) { + for (int i = 0; i < 7; i++) { + const unsigned ref0poc = f->refp[i].p.poc; + + for (int j = i + 1; j < 7; j++) { + const unsigned ref1poc = f->refp[j].p.poc; + + const unsigned d1 = imin(abs(get_poc_diff(f->seq_hdr.order_hint_n_bits, + ref0poc, f->cur.p.poc)), 31); + const unsigned d0 = imin(abs(get_poc_diff(f->seq_hdr.order_hint_n_bits, + ref1poc, f->cur.p.poc)), 31); + const int order = d0 <= d1; + + static const uint8_t quant_dist_weight[3][2] = { + { 2, 3 }, { 2, 5 }, { 2, 7 } + }; + static const uint8_t quant_dist_lookup_table[4][2] = { + { 9, 7 }, { 11, 5 }, { 12, 4 }, { 13, 3 } + }; + + int k; + for (k = 0; k < 3; k++) { + const int c0 = quant_dist_weight[k][order]; + const int c1 = quant_dist_weight[k][!order]; + const int d0_c0 = d0 * c0; + const int d1_c1 = d1 * c1; + if ((d0 > d1 && d0_c0 < d1_c1) || (d0 <= d1 && d0_c0 > d1_c1)) break; + } + + f->jnt_weights[i][j] = quant_dist_lookup_table[k][order]; + } + } + } + + // init loopfilter pointers + f->lf.mask_ptr = f->lf.mask; + f->lf.p[0] = f->cur.p.data[0]; + f->lf.p[1] = f->cur.p.data[1]; + f->lf.p[2] = f->cur.p.data[2]; + f->lf.tile_row = 1; + + cdf_thread_wait(&f->in_cdf); + + // parse individual tiles per tile group + int update_set = 0, tile_idx = 0; + const unsigned tile_col_mask = (1 << f->frame_hdr.tiling.log2_cols) - 1; + for (int i = 0; i < f->n_tile_data; i++) { + const uint8_t *data = f->tile[i].data.data; + size_t size = f->tile[i].data.sz; + + const int last_tile_row_plus1 = 1 + (f->tile[i].end >> f->frame_hdr.tiling.log2_cols); + const int last_tile_col_plus1 = 1 + (f->tile[i].end & tile_col_mask); + const int empty_tile_cols = imax(0, last_tile_col_plus1 - f->frame_hdr.tiling.cols); + const int empty_tile_rows = imax(0, last_tile_row_plus1 - f->frame_hdr.tiling.rows); + const int empty_tiles = + (empty_tile_rows << f->frame_hdr.tiling.log2_cols) + empty_tile_cols; + for (int j = f->tile[i].start; j <= f->tile[i].end - empty_tiles; j++) { + const int tile_row = j >> f->frame_hdr.tiling.log2_cols; + const int tile_col = j & tile_col_mask; + + if (tile_col >= f->frame_hdr.tiling.cols) continue; + if (tile_row >= f->frame_hdr.tiling.rows) continue; + + size_t tile_sz; + if (j == f->tile[i].end - empty_tiles) { + tile_sz = size; + } else { + tile_sz = 0; + for (int k = 0; k < f->frame_hdr.tiling.n_bytes; k++) + tile_sz |= *data++ << (k * 8); + tile_sz++; + size -= f->frame_hdr.tiling.n_bytes; + if (tile_sz > size) goto error; + } + + setup_tile(&f->ts[tile_row * f->frame_hdr.tiling.cols + tile_col], + f, data, tile_sz, tile_row, tile_col, + c->n_fc > 1 ? f->frame_thread.tile_start_off[tile_idx++] : 0); + if (j == f->frame_hdr.tiling.update && f->frame_hdr.refresh_context) + update_set = 1; + data += tile_sz; + size -= tile_sz; + } + } + + cdf_thread_unref(&f->in_cdf); + + // 2-pass decoding: + // - enabled for frame-threading, so that one frame can do symbol parsing + // as another (or multiple) are doing reconstruction. One advantage here + // is that although reconstruction is limited by reference availability, + // symbol parsing is not. Therefore, symbol parsing can effectively use + // row and col tile threading, but reconstruction only col tile threading; + // - pass 0 means no 2-pass; + // - pass 1 means symbol parsing only; + // - pass 2 means reconstruction and loop filtering. + + const int uses_2pass = c->n_fc > 1 && f->frame_hdr.refresh_context; + for (f->frame_thread.pass = uses_2pass; + f->frame_thread.pass <= 2 * uses_2pass; f->frame_thread.pass++) + { + const enum PlaneType progress_plane_type = + f->frame_thread.pass == 0 ? PLANE_TYPE_ALL : + f->frame_thread.pass == 1 ? PLANE_TYPE_BLOCK : PLANE_TYPE_Y; + + for (int n = 0; n < f->sb128w * f->frame_hdr.tiling.rows; n++) + reset_context(&f->a[n], !(f->frame_hdr.frame_type & 1), f->frame_thread.pass); + + if (f->n_tc == 1) { + Dav1dTileContext *const t = f->tc; + + // no tile threading - we explicitly interleave tile/sbrow decoding + // and post-filtering, so that the full process runs in-line, so + // that frame threading is still possible + for (int tile_row = 0; tile_row < f->frame_hdr.tiling.rows; tile_row++) { + for (int sby = f->frame_hdr.tiling.row_start_sb[tile_row]; + sby < f->frame_hdr.tiling.row_start_sb[tile_row + 1]; sby++) + { + t->by = sby << (4 + f->seq_hdr.sb128); + for (int tile_col = 0; tile_col < f->frame_hdr.tiling.cols; tile_col++) { + t->ts = &f->ts[tile_row * f->frame_hdr.tiling.rows + tile_col]; + + int res; + if ((res = decode_tile_sbrow(t))) + return res; + } + + // loopfilter + cdef + restoration + if (f->frame_thread.pass != 1) + f->bd_fn.filter_sbrow(f, sby); + dav1d_thread_picture_signal(&f->cur, (sby + 1) * f->sb_step * 4, + progress_plane_type); + } + } + } else { + // signal available tasks to worker threads + int num_tasks; + + const uint64_t all_mask = ~0ULL >> (64 - f->n_tc); + pthread_mutex_lock(&f->tile_thread.lock); + while (f->tile_thread.available != all_mask) + pthread_cond_wait(&f->tile_thread.icond, &f->tile_thread.lock); + assert(!f->tile_thread.tasks_left); + if (f->frame_thread.pass == 1 || f->n_tc >= f->frame_hdr.tiling.cols) { + // we can (or in fact, if >, we need to) do full tile decoding. + // loopfilter happens below + num_tasks = f->frame_hdr.tiling.cols * f->frame_hdr.tiling.rows; + } else { + // we need to interleave sbrow decoding for all tile cols in a + // tile row, since otherwise subsequent threads will be blocked + // waiting for the post-filter to complete + num_tasks = f->sbh * f->frame_hdr.tiling.cols; + } + f->tile_thread.num_tasks = f->tile_thread.tasks_left = num_tasks; + pthread_cond_broadcast(&f->tile_thread.cond); + pthread_mutex_unlock(&f->tile_thread.lock); + + // loopfilter + cdef + restoration + for (int tile_row = 0; tile_row < f->frame_hdr.tiling.rows; tile_row++) { + for (int sby = f->frame_hdr.tiling.row_start_sb[tile_row]; + sby < f->frame_hdr.tiling.row_start_sb[tile_row + 1]; sby++) + { + for (int tile_col = 0; tile_col < f->frame_hdr.tiling.cols; + tile_col++) + { + Dav1dTileState *const ts = + &f->ts[tile_row * f->frame_hdr.tiling.cols + tile_col]; + + if (atomic_load(&ts->progress) <= sby) { + pthread_mutex_lock(&ts->tile_thread.lock); + while (atomic_load(&ts->progress) <= sby) + pthread_cond_wait(&ts->tile_thread.cond, + &ts->tile_thread.lock); + pthread_mutex_unlock(&ts->tile_thread.lock); + } + } + + // loopfilter + cdef + restoration + if (f->frame_thread.pass != 1) + f->bd_fn.filter_sbrow(f, sby); + dav1d_thread_picture_signal(&f->cur, (sby + 1) * f->sb_step * 4, + progress_plane_type); + } + } + } + + if (f->frame_thread.pass <= 1 && f->frame_hdr.refresh_context) { + // cdf update + if (update_set) + av1_update_tile_cdf(&f->frame_hdr, f->out_cdf.cdf, + &f->ts[f->frame_hdr.tiling.update].cdf); + cdf_thread_signal(&f->out_cdf); + cdf_thread_unref(&f->out_cdf); + } + if (f->frame_thread.pass == 1) { + assert(c->n_fc > 1); + for (int tile_idx = 0; + tile_idx < f->frame_hdr.tiling.rows * f->frame_hdr.tiling.cols; + tile_idx++) + { + Dav1dTileState *const ts = &f->ts[tile_idx]; + const int tile_start_off = f->frame_thread.tile_start_off[tile_idx]; + ts->frame_thread.pal_idx = &f->frame_thread.pal_idx[tile_start_off * 2]; + ts->frame_thread.cf = &((int32_t *) f->frame_thread.cf)[tile_start_off * 3]; + if (f->n_tc > 0) + atomic_init(&ts->progress, 0); + } + } + } + + dav1d_thread_picture_signal(&f->cur, UINT_MAX, PLANE_TYPE_ALL); + + for (int i = 0; i < 7; i++) { + if (f->refp[i].p.data[0]) + dav1d_thread_picture_unref(&f->refp[i]); + if (f->ref_mvs_ref[i]) + dav1d_ref_dec(f->ref_mvs_ref[i]); + } + + dav1d_thread_picture_unref(&f->cur); + if (f->cur_segmap_ref) + dav1d_ref_dec(f->cur_segmap_ref); + if (f->prev_segmap_ref) + dav1d_ref_dec(f->prev_segmap_ref); + if (f->mvs_ref) + dav1d_ref_dec(f->mvs_ref); + + for (int i = 0; i < f->n_tile_data; i++) + dav1d_data_unref(&f->tile[i].data); + + return 0; + +error: + for (int i = 0; i < f->n_tile_data; i++) + dav1d_data_unref(&f->tile[i].data); + + return -EINVAL; +} + +int submit_frame(Dav1dContext *const c) { + Dav1dFrameContext *f; + int res; + + // wait for c->out_delayed[next] and move into c->out if visible + Dav1dThreadPicture *out_delayed; + if (c->n_fc > 1) { + const unsigned next = c->frame_thread.next++; + if (c->frame_thread.next == c->n_fc) + c->frame_thread.next = 0; + + f = &c->fc[next]; + pthread_mutex_lock(&f->frame_thread.td.lock); + while (f->n_tile_data > 0) + pthread_cond_wait(&f->frame_thread.td.cond, + &f->frame_thread.td.lock); + out_delayed = &c->frame_thread.out_delayed[next]; + if (out_delayed->p.data[0]) { + if (out_delayed->visible) + dav1d_picture_ref(&c->out, &out_delayed->p); + dav1d_thread_picture_unref(out_delayed); + } + } else { + f = c->fc; + } + + f->seq_hdr = c->seq_hdr; + f->frame_hdr = c->frame_hdr; + const int bd_idx = (f->seq_hdr.bpc - 8) >> 1; + f->dsp = &c->dsp[bd_idx]; + + if (!f->dsp->ipred.intra_pred[TX_4X4][DC_PRED]) { + Dav1dDSPContext *const dsp = &c->dsp[bd_idx]; + + switch (f->seq_hdr.bpc) { +#define assign_bitdepth_case(bd) \ + case bd: \ + dav1d_cdef_dsp_init_##bd##bpc(&dsp->cdef); \ + dav1d_intra_pred_dsp_init_##bd##bpc(&dsp->ipred); \ + dav1d_itx_dsp_init_##bd##bpc(&dsp->itx); \ + dav1d_loop_filter_dsp_init_##bd##bpc(&dsp->lf); \ + dav1d_loop_restoration_dsp_init_##bd##bpc(&dsp->lr); \ + dav1d_mc_dsp_init_##bd##bpc(&dsp->mc); \ + break +#if CONFIG_8BPC + assign_bitdepth_case(8); +#endif +#if CONFIG_10BPC + assign_bitdepth_case(10); +#endif +#undef assign_bitdepth_case + default: + fprintf(stderr, "Compiled without support for %d-bit decoding\n", + f->seq_hdr.bpc); + return -ENOPROTOOPT; + } + } + +#define assign_bitdepth_case(bd) \ + f->bd_fn.recon_b_inter = recon_b_inter_##bd##bpc; \ + f->bd_fn.recon_b_intra = recon_b_intra_##bd##bpc; \ + f->bd_fn.filter_sbrow = filter_sbrow_##bd##bpc; \ + f->bd_fn.backup_ipred_edge = backup_ipred_edge_##bd##bpc; \ + f->bd_fn.read_coef_blocks = read_coef_blocks_##bd##bpc + if (f->seq_hdr.bpc <= 8) { +#if CONFIG_8BPC + assign_bitdepth_case(8); +#endif + } else { +#if CONFIG_10BPC + assign_bitdepth_case(16); +#endif + } +#undef assign_bitdepth_case + + if (f->frame_hdr.frame_type & 1) + for (int i = 0; i < 7; i++) { + const int refidx = f->frame_hdr.refidx[i]; + dav1d_thread_picture_ref(&f->refp[i], &c->refs[refidx].p); + } + + // setup entropy + if (f->frame_hdr.primary_ref_frame == PRIMARY_REF_NONE) { + av1_init_states(&f->in_cdf, f->frame_hdr.quant.yac); + } else { + const int pri_ref = f->frame_hdr.refidx[f->frame_hdr.primary_ref_frame]; + cdf_thread_ref(&f->in_cdf, &c->cdf[pri_ref]); + } + if (f->frame_hdr.refresh_context) { + cdf_thread_alloc(&f->out_cdf, c->n_fc > 1 ? &f->frame_thread.td : NULL); + memcpy(f->out_cdf.cdf, f->in_cdf.cdf, sizeof(*f->in_cdf.cdf)); + } + + // FIXME qsort so tiles are in order (for frame threading) + memcpy(f->tile, c->tile, c->n_tile_data * sizeof(*f->tile)); + f->n_tile_data = c->n_tile_data; + c->n_tile_data = 0; + + // allocate frame + if ((res = dav1d_thread_picture_alloc(&f->cur, f->frame_hdr.width, + f->frame_hdr.height, + f->seq_hdr.layout, f->seq_hdr.bpc, + c->n_fc > 1 ? &f->frame_thread.td : NULL, + f->frame_hdr.show_frame)) < 0) + { + return res; + } + + f->cur.p.poc = f->frame_hdr.frame_offset; + f->cur.p.p.pri = f->seq_hdr.pri; + f->cur.p.p.trc = f->seq_hdr.trc; + f->cur.p.p.mtrx = f->seq_hdr.mtrx; + f->cur.p.p.chr = f->seq_hdr.chr; + f->cur.p.p.fullrange = f->seq_hdr.color_range; + + // move f->cur into output queue + if (c->n_fc == 1) { + if (f->frame_hdr.show_frame) + dav1d_picture_ref(&c->out, &f->cur.p); + } else { + dav1d_thread_picture_ref(out_delayed, &f->cur); + } + + f->bw = (f->frame_hdr.width + 3) >> 2; + f->bh = (f->frame_hdr.height + 3) >> 2; + f->sb128w = (f->bw + 31) >> 5; + f->sb128h = (f->bh + 31) >> 5; + f->sb_shift = 4 + f->seq_hdr.sb128; + f->sb_step = 16 << f->seq_hdr.sb128; + f->sbh = (f->bh + f->sb_step - 1) >> f->sb_shift; + f->b4_stride = (f->bw + 31) & ~31; + + // ref_mvs + if ((f->frame_hdr.frame_type & 1) || f->frame_hdr.allow_intrabc) { + f->mvs_ref = dav1d_ref_create(f->sb128h * 32 * f->b4_stride * + sizeof(*f->mvs)); + f->mvs = f->mvs_ref->data; + if (f->frame_hdr.use_ref_frame_mvs) { + for (int i = 0; i < 7; i++) { + const int refidx = f->frame_hdr.refidx[i]; + f->refpoc[i] = f->refp[i].p.poc; + if (c->refs[refidx].refmvs != NULL && + f->refp[i].p.p.w == f->cur.p.p.w && + f->refp[i].p.p.h == f->cur.p.p.h) + { + f->ref_mvs_ref[i] = c->refs[refidx].refmvs; + dav1d_ref_inc(f->ref_mvs_ref[i]); + f->ref_mvs[i] = c->refs[refidx].refmvs->data; + } else { + f->ref_mvs[i] = NULL; + f->ref_mvs_ref[i] = NULL; + } + memcpy(f->refrefpoc[i], c->refs[refidx].refpoc, + sizeof(*f->refrefpoc)); + } + } else { + memset(f->ref_mvs_ref, 0, sizeof(f->ref_mvs_ref)); + } + } else { + f->mvs_ref = NULL; + memset(f->ref_mvs_ref, 0, sizeof(f->ref_mvs_ref)); + } + + // segmap + if (f->frame_hdr.segmentation.enabled) { + if (f->frame_hdr.segmentation.temporal) { + const int pri_ref = f->frame_hdr.primary_ref_frame; + assert(pri_ref != PRIMARY_REF_NONE); + const int ref_w = (f->refp[pri_ref].p.p.w + 3) >> 2; + const int ref_h = (f->refp[pri_ref].p.p.h + 3) >> 2; + if (ref_w == f->bw && ref_h == f->bh) { + f->prev_segmap_ref = c->refs[f->frame_hdr.refidx[pri_ref]].segmap; + dav1d_ref_inc(f->prev_segmap_ref); + f->prev_segmap = f->prev_segmap_ref->data; + } else { + f->prev_segmap_ref = NULL; + f->prev_segmap = NULL; + } + } else { + f->prev_segmap_ref = NULL; + f->prev_segmap = NULL; + } + if (f->frame_hdr.segmentation.update_map) { + f->cur_segmap_ref = dav1d_ref_create(f->b4_stride * 32 * f->sb128h); + f->cur_segmap = f->cur_segmap_ref->data; + } else { + f->cur_segmap_ref = f->prev_segmap_ref; + dav1d_ref_inc(f->cur_segmap_ref); + f->cur_segmap = f->prev_segmap_ref->data; + } + } else { + f->cur_segmap = NULL; + f->cur_segmap_ref = NULL; + f->prev_segmap_ref = NULL; + } + + // update references etc. + for (int i = 0; i < 8; i++) { + if (f->frame_hdr.refresh_frame_flags & (1 << i)) { + if (c->refs[i].p.p.data[0]) + dav1d_thread_picture_unref(&c->refs[i].p); + dav1d_thread_picture_ref(&c->refs[i].p, &f->cur); + + if (c->cdf[i].cdf) cdf_thread_unref(&c->cdf[i]); + if (f->frame_hdr.refresh_context) { + cdf_thread_ref(&c->cdf[i], &f->out_cdf); + } else { + cdf_thread_ref(&c->cdf[i], &f->in_cdf); + } + c->refs[i].lf_mode_ref_deltas = + f->frame_hdr.loopfilter.mode_ref_deltas; + c->refs[i].seg_data = f->frame_hdr.segmentation.seg_data; + memcpy(c->refs[i].gmv, f->frame_hdr.gmv, sizeof(c->refs[i].gmv)); + c->refs[i].film_grain = f->frame_hdr.film_grain.data; + + if (c->refs[i].segmap) + dav1d_ref_dec(c->refs[i].segmap); + c->refs[i].segmap = f->cur_segmap_ref; + if (f->cur_segmap_ref) + dav1d_ref_inc(f->cur_segmap_ref); + if (c->refs[i].refmvs) + dav1d_ref_dec(c->refs[i].refmvs); + if (f->frame_hdr.allow_intrabc) { + c->refs[i].refmvs = NULL; + } else { + c->refs[i].refmvs = f->mvs_ref; + if (f->mvs_ref) + dav1d_ref_inc(f->mvs_ref); + } + memcpy(c->refs[i].refpoc, f->refpoc, sizeof(f->refpoc)); + } + } + + if (c->n_fc == 1) { + if ((res = decode_frame(f)) < 0) + return res; + } else { + pthread_cond_signal(&f->frame_thread.td.cond); + pthread_mutex_unlock(&f->frame_thread.td.lock); + } + + return 0; +} diff --git a/src/decode.h b/src/decode.h new file mode 100644 index 0000000..5947976 --- /dev/null +++ b/src/decode.h @@ -0,0 +1,35 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_SRC_DECODE_H__ +#define __DAV1D_SRC_DECODE_H__ + +#include "src/internal.h" + +int submit_frame(Dav1dContext *c); + +#endif /* __DAV1D_SRC_DECODE_H__ */ diff --git a/src/dequant_tables.c b/src/dequant_tables.c new file mode 100644 index 0000000..a8fe4c5 --- /dev/null +++ b/src/dequant_tables.c @@ -0,0 +1,164 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include "src/dequant_tables.h" + +const uint16_t dav1d_dq_tbl[][QINDEX_RANGE][2] = { + { + { 4, 4, }, { 8, 8, }, { 8, 9, }, { 9, 10, }, + { 10, 11, }, { 11, 12, }, { 12, 13, }, { 12, 14, }, + { 13, 15, }, { 14, 16, }, { 15, 17, }, { 16, 18, }, + { 17, 19, }, { 18, 20, }, { 19, 21, }, { 19, 22, }, + { 20, 23, }, { 21, 24, }, { 22, 25, }, { 23, 26, }, + { 24, 27, }, { 25, 28, }, { 26, 29, }, { 26, 30, }, + { 27, 31, }, { 28, 32, }, { 29, 33, }, { 30, 34, }, + { 31, 35, }, { 32, 36, }, { 32, 37, }, { 33, 38, }, + { 34, 39, }, { 35, 40, }, { 36, 41, }, { 37, 42, }, + { 38, 43, }, { 38, 44, }, { 39, 45, }, { 40, 46, }, + { 41, 47, }, { 42, 48, }, { 43, 49, }, { 43, 50, }, + { 44, 51, }, { 45, 52, }, { 46, 53, }, { 47, 54, }, + { 48, 55, }, { 48, 56, }, { 49, 57, }, { 50, 58, }, + { 51, 59, }, { 52, 60, }, { 53, 61, }, { 53, 62, }, + { 54, 63, }, { 55, 64, }, { 56, 65, }, { 57, 66, }, + { 57, 67, }, { 58, 68, }, { 59, 69, }, { 60, 70, }, + { 61, 71, }, { 62, 72, }, { 62, 73, }, { 63, 74, }, + { 64, 75, }, { 65, 76, }, { 66, 77, }, { 66, 78, }, + { 67, 79, }, { 68, 80, }, { 69, 81, }, { 70, 82, }, + { 70, 83, }, { 71, 84, }, { 72, 85, }, { 73, 86, }, + { 74, 87, }, { 74, 88, }, { 75, 89, }, { 76, 90, }, + { 77, 91, }, { 78, 92, }, { 78, 93, }, { 79, 94, }, + { 80, 95, }, { 81, 96, }, { 81, 97, }, { 82, 98, }, + { 83, 99, }, { 84, 100, }, { 85, 101, }, { 85, 102, }, + { 87, 104, }, { 88, 106, }, { 90, 108, }, { 92, 110, }, + { 93, 112, }, { 95, 114, }, { 96, 116, }, { 98, 118, }, + { 99, 120, }, { 101, 122, }, { 102, 124, }, { 104, 126, }, + { 105, 128, }, { 107, 130, }, { 108, 132, }, { 110, 134, }, + { 111, 136, }, { 113, 138, }, { 114, 140, }, { 116, 142, }, + { 117, 144, }, { 118, 146, }, { 120, 148, }, { 121, 150, }, + { 123, 152, }, { 125, 155, }, { 127, 158, }, { 129, 161, }, + { 131, 164, }, { 134, 167, }, { 136, 170, }, { 138, 173, }, + { 140, 176, }, { 142, 179, }, { 144, 182, }, { 146, 185, }, + { 148, 188, }, { 150, 191, }, { 152, 194, }, { 154, 197, }, + { 156, 200, }, { 158, 203, }, { 161, 207, }, { 164, 211, }, + { 166, 215, }, { 169, 219, }, { 172, 223, }, { 174, 227, }, + { 177, 231, }, { 180, 235, }, { 182, 239, }, { 185, 243, }, + { 187, 247, }, { 190, 251, }, { 192, 255, }, { 195, 260, }, + { 199, 265, }, { 202, 270, }, { 205, 275, }, { 208, 280, }, + { 211, 285, }, { 214, 290, }, { 217, 295, }, { 220, 300, }, + { 223, 305, }, { 226, 311, }, { 230, 317, }, { 233, 323, }, + { 237, 329, }, { 240, 335, }, { 243, 341, }, { 247, 347, }, + { 250, 353, }, { 253, 359, }, { 257, 366, }, { 261, 373, }, + { 265, 380, }, { 269, 387, }, { 272, 394, }, { 276, 401, }, + { 280, 408, }, { 284, 416, }, { 288, 424, }, { 292, 432, }, + { 296, 440, }, { 300, 448, }, { 304, 456, }, { 309, 465, }, + { 313, 474, }, { 317, 483, }, { 322, 492, }, { 326, 501, }, + { 330, 510, }, { 335, 520, }, { 340, 530, }, { 344, 540, }, + { 349, 550, }, { 354, 560, }, { 359, 571, }, { 364, 582, }, + { 369, 593, }, { 374, 604, }, { 379, 615, }, { 384, 627, }, + { 389, 639, }, { 395, 651, }, { 400, 663, }, { 406, 676, }, + { 411, 689, }, { 417, 702, }, { 423, 715, }, { 429, 729, }, + { 435, 743, }, { 441, 757, }, { 447, 771, }, { 454, 786, }, + { 461, 801, }, { 467, 816, }, { 475, 832, }, { 482, 848, }, + { 489, 864, }, { 497, 881, }, { 505, 898, }, { 513, 915, }, + { 522, 933, }, { 530, 951, }, { 539, 969, }, { 549, 988, }, + { 559, 1007, }, { 569, 1026, }, { 579, 1046, }, { 590, 1066, }, + { 602, 1087, }, { 614, 1108, }, { 626, 1129, }, { 640, 1151, }, + { 654, 1173, }, { 668, 1196, }, { 684, 1219, }, { 700, 1243, }, + { 717, 1267, }, { 736, 1292, }, { 755, 1317, }, { 775, 1343, }, + { 796, 1369, }, { 819, 1396, }, { 843, 1423, }, { 869, 1451, }, + { 896, 1479, }, { 925, 1508, }, { 955, 1537, }, { 988, 1567, }, + { 1022, 1597, }, { 1058, 1628, }, { 1098, 1660, }, { 1139, 1692, }, + { 1184, 1725, }, { 1232, 1759, }, { 1282, 1793, }, { 1336, 1828, }, + }, { + { 4, 4, }, { 9, 9, }, { 10, 11, }, { 13, 13, }, + { 15, 16, }, { 17, 18, }, { 20, 21, }, { 22, 24, }, + { 25, 27, }, { 28, 30, }, { 31, 33, }, { 34, 37, }, + { 37, 40, }, { 40, 44, }, { 43, 48, }, { 47, 51, }, + { 50, 55, }, { 53, 59, }, { 57, 63, }, { 60, 67, }, + { 64, 71, }, { 68, 75, }, { 71, 79, }, { 75, 83, }, + { 78, 88, }, { 82, 92, }, { 86, 96, }, { 90, 100, }, + { 93, 105, }, { 97, 109, }, { 101, 114, }, { 105, 118, }, + { 109, 122, }, { 113, 127, }, { 116, 131, }, { 120, 136, }, + { 124, 140, }, { 128, 145, }, { 132, 149, }, { 136, 154, }, + { 140, 158, }, { 143, 163, }, { 147, 168, }, { 151, 172, }, + { 155, 177, }, { 159, 181, }, { 163, 186, }, { 166, 190, }, + { 170, 195, }, { 174, 199, }, { 178, 204, }, { 182, 208, }, + { 185, 213, }, { 189, 217, }, { 193, 222, }, { 197, 226, }, + { 200, 231, }, { 204, 235, }, { 208, 240, }, { 212, 244, }, + { 215, 249, }, { 219, 253, }, { 223, 258, }, { 226, 262, }, + { 230, 267, }, { 233, 271, }, { 237, 275, }, { 241, 280, }, + { 244, 284, }, { 248, 289, }, { 251, 293, }, { 255, 297, }, + { 259, 302, }, { 262, 306, }, { 266, 311, }, { 269, 315, }, + { 273, 319, }, { 276, 324, }, { 280, 328, }, { 283, 332, }, + { 287, 337, }, { 290, 341, }, { 293, 345, }, { 297, 349, }, + { 300, 354, }, { 304, 358, }, { 307, 362, }, { 310, 367, }, + { 314, 371, }, { 317, 375, }, { 321, 379, }, { 324, 384, }, + { 327, 388, }, { 331, 392, }, { 334, 396, }, { 337, 401, }, + { 343, 409, }, { 350, 417, }, { 356, 425, }, { 362, 433, }, + { 369, 441, }, { 375, 449, }, { 381, 458, }, { 387, 466, }, + { 394, 474, }, { 400, 482, }, { 406, 490, }, { 412, 498, }, + { 418, 506, }, { 424, 514, }, { 430, 523, }, { 436, 531, }, + { 442, 539, }, { 448, 547, }, { 454, 555, }, { 460, 563, }, + { 466, 571, }, { 472, 579, }, { 478, 588, }, { 484, 596, }, + { 490, 604, }, { 499, 616, }, { 507, 628, }, { 516, 640, }, + { 525, 652, }, { 533, 664, }, { 542, 676, }, { 550, 688, }, + { 559, 700, }, { 567, 713, }, { 576, 725, }, { 584, 737, }, + { 592, 749, }, { 601, 761, }, { 609, 773, }, { 617, 785, }, + { 625, 797, }, { 634, 809, }, { 644, 825, }, { 655, 841, }, + { 666, 857, }, { 676, 873, }, { 687, 889, }, { 698, 905, }, + { 708, 922, }, { 718, 938, }, { 729, 954, }, { 739, 970, }, + { 749, 986, }, { 759, 1002, }, { 770, 1018, }, { 782, 1038, }, + { 795, 1058, }, { 807, 1078, }, { 819, 1098, }, { 831, 1118, }, + { 844, 1138, }, { 856, 1158, }, { 868, 1178, }, { 880, 1198, }, + { 891, 1218, }, { 906, 1242, }, { 920, 1266, }, { 933, 1290, }, + { 947, 1314, }, { 961, 1338, }, { 975, 1362, }, { 988, 1386, }, + { 1001, 1411, }, { 1015, 1435, }, { 1030, 1463, }, { 1045, 1491, }, + { 1061, 1519, }, { 1076, 1547, }, { 1090, 1575, }, { 1105, 1603, }, + { 1120, 1631, }, { 1137, 1663, }, { 1153, 1695, }, { 1170, 1727, }, + { 1186, 1759, }, { 1202, 1791, }, { 1218, 1823, }, { 1236, 1859, }, + { 1253, 1895, }, { 1271, 1931, }, { 1288, 1967, }, { 1306, 2003, }, + { 1323, 2039, }, { 1342, 2079, }, { 1361, 2119, }, { 1379, 2159, }, + { 1398, 2199, }, { 1416, 2239, }, { 1436, 2283, }, { 1456, 2327, }, + { 1476, 2371, }, { 1496, 2415, }, { 1516, 2459, }, { 1537, 2507, }, + { 1559, 2555, }, { 1580, 2603, }, { 1601, 2651, }, { 1624, 2703, }, + { 1647, 2755, }, { 1670, 2807, }, { 1692, 2859, }, { 1717, 2915, }, + { 1741, 2971, }, { 1766, 3027, }, { 1791, 3083, }, { 1817, 3143, }, + { 1844, 3203, }, { 1871, 3263, }, { 1900, 3327, }, { 1929, 3391, }, + { 1958, 3455, }, { 1990, 3523, }, { 2021, 3591, }, { 2054, 3659, }, + { 2088, 3731, }, { 2123, 3803, }, { 2159, 3876, }, { 2197, 3952, }, + { 2236, 4028, }, { 2276, 4104, }, { 2319, 4184, }, { 2363, 4264, }, + { 2410, 4348, }, { 2458, 4432, }, { 2508, 4516, }, { 2561, 4604, }, + { 2616, 4692, }, { 2675, 4784, }, { 2737, 4876, }, { 2802, 4972, }, + { 2871, 5068, }, { 2944, 5168, }, { 3020, 5268, }, { 3102, 5372, }, + { 3188, 5476, }, { 3280, 5584, }, { 3375, 5692, }, { 3478, 5804, }, + { 3586, 5916, }, { 3702, 6032, }, { 3823, 6148, }, { 3953, 6268, }, + { 4089, 6388, }, { 4236, 6512, }, { 4394, 6640, }, { 4559, 6768, }, + { 4737, 6900, }, { 4929, 7036, }, { 5130, 7172, }, { 5347, 7312, }, + } +}; diff --git a/src/dequant_tables.h b/src/dequant_tables.h new file mode 100644 index 0000000..82b4fdc --- /dev/null +++ b/src/dequant_tables.h @@ -0,0 +1,37 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_SRC_DEQUANT_TABLES_H__ +#define __DAV1D_SRC_DEQUANT_TABLES_H__ + +#include <stdint.h> + +#include "src/levels.h" + +extern const uint16_t dav1d_dq_tbl[][QINDEX_RANGE][2]; + +#endif /* __DAV1D_SRC_DEQUANT_TABLES_H__ */ diff --git a/src/env.h b/src/env.h new file mode 100644 index 0000000..2f406b1 --- /dev/null +++ b/src/env.h @@ -0,0 +1,754 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_SRC_ENV_H__ +#define __DAV1D_SRC_ENV_H__ + +#include <assert.h> +#include <stddef.h> +#include <stdint.h> +#include <stdlib.h> + +#include "src/levels.h" +#include "src/ref_mvs.h" +#include "src/tables.h" + +typedef struct BlockContext { + uint8_t mode[32]; + uint8_t lcoef[32]; + uint8_t ccoef[2][32]; + uint8_t seg_pred[32]; + uint8_t skip[32]; + uint8_t skip_mode[32]; + uint8_t intra[32]; + uint8_t comp_type[32]; + int8_t ref[2][32]; // -1 means intra + uint8_t filter[2][32]; // 3 means unset + int8_t tx_intra[32]; + int8_t tx[32]; + uint8_t tx_lpf_y[32]; + uint8_t tx_lpf_uv[32]; + uint8_t partition[16]; + uint8_t uvmode[32]; + uint8_t pal_sz[32]; +} BlockContext; + +static inline int get_intra_ctx(const BlockContext *const a, + const BlockContext *const l, + const int yb4, const int xb4, + const int have_top, const int have_left) +{ + if (have_left) { + if (have_top) { + const int ctx = l->intra[yb4] + a->intra[xb4]; + return ctx + (ctx == 2); + } else + return l->intra[yb4] * 2; + } else { + return have_top ? a->intra[xb4] * 2 : 0; + } +} + +static inline int get_tx_ctx(const BlockContext *const a, + const BlockContext *const l, + const TxfmInfo *const max_tx, + const int yb4, const int xb4, + const int have_top, const int have_left) +{ + return (l->tx_intra[yb4] >= max_tx->lh) + (a->tx_intra[xb4] >= max_tx->lw); +} + +static inline int get_partition_ctx(const BlockContext *const a, + const BlockContext *const l, + const enum BlockLevel bl, + const int yb8, const int xb8) +{ + return ((a->partition[xb8] >> (4 - bl)) & 1) + + (((l->partition[yb8] >> (4 - bl)) & 1) << 1); +} + +static inline unsigned cdf_element_prob(const uint16_t *const cdf, const int e) { + return (e > 0 ? cdf[e - 1] : 32768) - cdf[e]; +} + +static inline unsigned gather_left_partition_prob(const uint16_t *const in, + const enum BlockLevel bl) +{ + unsigned out = 32768; + out -= cdf_element_prob(in, PARTITION_H); + if (bl != BL_128X128) + out -= cdf_element_prob(in, PARTITION_H4); + out -= cdf_element_prob(in, PARTITION_SPLIT); + out -= cdf_element_prob(in, PARTITION_T_TOP_SPLIT); + out -= cdf_element_prob(in, PARTITION_T_BOTTOM_SPLIT); + out -= cdf_element_prob(in, PARTITION_T_LEFT_SPLIT); + return 32768 - out; +} + +static inline unsigned gather_top_partition_prob(const uint16_t *const in, + const enum BlockLevel bl) +{ + unsigned out = 32768; + out -= cdf_element_prob(in, PARTITION_V); + if (bl != BL_128X128) + out -= cdf_element_prob(in, PARTITION_V4); + out -= cdf_element_prob(in, PARTITION_SPLIT); + out -= cdf_element_prob(in, PARTITION_T_TOP_SPLIT); + out -= cdf_element_prob(in, PARTITION_T_LEFT_SPLIT); + out -= cdf_element_prob(in, PARTITION_T_RIGHT_SPLIT); + return 32768 - out; +} + +static inline enum TxfmTypeSet get_ext_txtp_set(const enum RectTxfmSize tx, + const int inter, + const Av1FrameHeader *const hdr, + const int seg_id) +{ + if (hdr->segmentation.lossless[seg_id]) { + assert(tx == (int) TX_4X4); + return TXTP_SET_LOSSLESS; + } + + const TxfmInfo *const t_dim = &av1_txfm_dimensions[tx]; + + if (t_dim->max >= TX_64X64) + return TXTP_SET_DCT; + + if (t_dim->max == TX_32X32) + return inter ? TXTP_SET_DCT_ID : TXTP_SET_DCT; + + if (hdr->reduced_txtp_set) + return inter ? TXTP_SET_DCT_ID : TXTP_SET_DT4_ID; + + const enum TxfmSize txsqsz = t_dim->min; + + if (inter) + return txsqsz == TX_16X16 ? TXTP_SET_DT9_ID_1D : TXTP_SET_ALL; + else + return txsqsz == TX_16X16 ? TXTP_SET_DT4_ID : TXTP_SET_DT4_ID_1D; +} + +static inline enum TxfmType get_uv_intra_txtp(const enum IntraPredMode uv_mode, + const enum RectTxfmSize tx, + const Av1FrameHeader *const hdr, + const int seg_id) +{ + if (hdr->segmentation.lossless[seg_id]) { + assert(tx == (int) TX_4X4); + return WHT_WHT; + } + + const TxfmInfo *const t_dim = &av1_txfm_dimensions[tx]; + + return t_dim->max == TX_32X32 ? DCT_DCT : av1_txtp_from_uvmode[uv_mode]; +} + +static inline enum TxfmType get_uv_inter_txtp(const TxfmInfo *const uvt_dim, + const enum TxfmType ytxtp, + const Av1FrameHeader *const hdr, + const int seg_id) +{ + if (hdr->segmentation.lossless[seg_id]) { + assert(uvt_dim->max == TX_4X4); + return WHT_WHT; + } + + if (uvt_dim->max == TX_32X32) + return ytxtp == IDTX ? IDTX : DCT_DCT; + if (uvt_dim->min == TX_16X16 && + ((1 << ytxtp) & ((1 << H_FLIPADST) | (1 << V_FLIPADST) | + (1 << H_ADST) | (1 << V_ADST)))) + { + return DCT_DCT; + } + + return ytxtp; +} + +static inline int get_filter_ctx(const BlockContext *const a, + const BlockContext *const l, + const int comp, const int dir, const int ref, + const int yb4, const int xb4) +{ + const int a_filter = (a->ref[0][xb4] == ref || a->ref[1][xb4] == ref) ? + a->filter[dir][xb4] : N_SWITCHABLE_FILTERS; + const int l_filter = (l->ref[0][yb4] == ref || l->ref[1][yb4] == ref) ? + l->filter[dir][yb4] : N_SWITCHABLE_FILTERS; + + if (a_filter == l_filter) { + return comp * 4 + a_filter; + } else if (a_filter == N_SWITCHABLE_FILTERS) { + return comp * 4 + l_filter; + } else if (l_filter == N_SWITCHABLE_FILTERS) { + return comp * 4 + a_filter; + } else { + return comp * 4 + N_SWITCHABLE_FILTERS; + } +} + +static inline int get_comp_ctx(const BlockContext *const a, + const BlockContext *const l, + const int yb4, const int xb4, + const int have_top, const int have_left) +{ + if (have_top) { + if (have_left) { + if (a->comp_type[xb4]) { + if (l->comp_type[yb4]) { + return 4; + } else { + // 4U means intra (-1) or bwd (>= 4) + return 2 + (l->ref[0][yb4] >= 4U); + } + } else if (l->comp_type[yb4]) { + // 4U means intra (-1) or bwd (>= 4) + return 2 + (a->ref[0][xb4] >= 4U); + } else { + return (l->ref[0][yb4] >= 4) ^ (a->ref[0][xb4] >= 4); + } + } else { + return a->comp_type[xb4] ? 3 : a->ref[0][xb4] >= 4; + } + } else if (have_left) { + return l->comp_type[yb4] ? 3 : l->ref[0][yb4] >= 4; + } else { + return 1; + } +} + +static inline int get_comp_dir_ctx(const BlockContext *const a, + const BlockContext *const l, + const int yb4, const int xb4, + const int have_top, const int have_left) +{ +#define has_uni_comp(edge, off) \ + ((edge->ref[0][off] < 4) == (edge->ref[1][off] < 4)) + + if (have_top && have_left) { + const int a_intra = a->intra[xb4], l_intra = l->intra[yb4]; + + if (a_intra && l_intra) return 2; + if (a_intra || l_intra) { + const BlockContext *const edge = a_intra ? l : a; + const int off = a_intra ? yb4 : xb4; + + if (edge->comp_type[off] == COMP_INTER_NONE) return 2; + return 1 + 2 * has_uni_comp(edge, off); + } + + const int a_comp = a->comp_type[xb4] != COMP_INTER_NONE; + const int l_comp = l->comp_type[yb4] != COMP_INTER_NONE; + const int a_ref0 = a->ref[0][xb4], l_ref0 = l->ref[0][yb4]; + + if (!a_comp && !l_comp) { + return 1 + 2 * ((a_ref0 >= 4) == (l_ref0 >= 4)); + } else if (!a_comp || !l_comp) { + const BlockContext *const edge = a_comp ? a : l; + const int off = a_comp ? xb4 : yb4; + + if (!has_uni_comp(edge, off)) return 1; + return 3 + ((a_ref0 >= 4) == (l_ref0 >= 4)); + } else { + const int a_uni = has_uni_comp(a, xb4), l_uni = has_uni_comp(l, yb4); + + if (!a_uni && !l_uni) return 0; + if (!a_uni || !l_uni) return 2; + return 3 + ((a_ref0 == 4) == (l_ref0 == 4)); + } + } else if (have_top || have_left) { + const BlockContext *const edge = have_left ? l : a; + const int off = have_left ? yb4 : xb4; + + if (edge->intra[off]) return 2; + if (edge->comp_type[off] == COMP_INTER_NONE) return 2; + return 4 * has_uni_comp(edge, off); + } else { + return 2; + } +} + +static inline int get_poc_diff(const int order_hint_n_bits, + const int poc0, const int poc1) +{ + const int mask = 1 << (order_hint_n_bits - 1); + const int diff = poc0 - poc1; + return (diff & (mask - 1)) - (diff & mask); +} + +static inline int get_jnt_comp_ctx(const int order_hint_n_bits, + const unsigned poc, const unsigned ref0poc, + const unsigned ref1poc, + const BlockContext *const a, + const BlockContext *const l, + const int yb4, const int xb4) +{ + const unsigned d0 = abs(get_poc_diff(order_hint_n_bits, ref0poc, poc)); + const unsigned d1 = abs(get_poc_diff(order_hint_n_bits, ref1poc, poc)); + const int offset = d0 == d1; + const int a_ctx = a->comp_type[xb4] >= COMP_INTER_AVG || + a->ref[0][xb4] == 6; + const int l_ctx = l->comp_type[yb4] >= COMP_INTER_AVG || + l->ref[0][yb4] == 6; + + return 3 * offset + a_ctx + l_ctx; +} + +static inline int get_mask_comp_ctx(const BlockContext *const a, + const BlockContext *const l, + const int yb4, const int xb4) +{ + const int a_ctx = a->comp_type[xb4] >= COMP_INTER_SEG ? 1 : + a->ref[0][xb4] == 6 ? 3 : 0; + const int l_ctx = l->comp_type[yb4] >= COMP_INTER_SEG ? 1 : + l->ref[0][yb4] == 6 ? 3 : 0; + + return imin(a_ctx + l_ctx, 5); +} + +#define av1_get_ref_2_ctx av1_get_bwd_ref_ctx +#define av1_get_ref_3_ctx av1_get_fwd_ref_ctx +#define av1_get_ref_4_ctx av1_get_fwd_ref_1_ctx +#define av1_get_ref_5_ctx av1_get_fwd_ref_2_ctx +#define av1_get_ref_6_ctx av1_get_bwd_ref_1_ctx +#define av1_get_uni_p_ctx av1_get_ref_ctx +#define av1_get_uni_p2_ctx av1_get_fwd_ref_2_ctx + +static inline int av1_get_ref_ctx(const BlockContext *const a, + const BlockContext *const l, + const int yb4, const int xb4, + int have_top, int have_left) +{ + int cnt[2] = { 0 }; + + if (have_top && !a->intra[xb4]) { + cnt[a->ref[0][xb4] >= 4]++; + if (a->comp_type[xb4]) cnt[a->ref[1][xb4] >= 4]++; + } + + if (have_left && !l->intra[yb4]) { + cnt[l->ref[0][yb4] >= 4]++; + if (l->comp_type[yb4]) cnt[l->ref[1][yb4] >= 4]++; + } + + return cnt[0] == cnt[1] ? 1 : cnt[0] < cnt[1] ? 0 : 2; +} + +static inline int av1_get_fwd_ref_ctx(const BlockContext *const a, + const BlockContext *const l, + const int yb4, const int xb4, + const int have_top, const int have_left) +{ + int cnt[4] = { 0 }; + + if (have_top && !a->intra[xb4]) { + if (a->ref[0][xb4] < 4) cnt[a->ref[0][xb4]]++; + if (a->comp_type[xb4] && a->ref[1][xb4] < 4) cnt[a->ref[1][xb4]]++; + } + + if (have_left && !l->intra[yb4]) { + if (l->ref[0][yb4] < 4) cnt[l->ref[0][yb4]]++; + if (l->comp_type[yb4] && l->ref[1][yb4] < 4) cnt[l->ref[1][yb4]]++; + } + + cnt[0] += cnt[1]; + cnt[2] += cnt[3]; + + return cnt[0] == cnt[2] ? 1 : cnt[0] < cnt[2] ? 0 : 2; +} + +static inline int av1_get_fwd_ref_1_ctx(const BlockContext *const a, + const BlockContext *const l, + const int yb4, const int xb4, + const int have_top, const int have_left) +{ + int cnt[2] = { 0 }; + + if (have_top && !a->intra[xb4]) { + if (a->ref[0][xb4] < 2) cnt[a->ref[0][xb4]]++; + if (a->comp_type[xb4] && a->ref[1][xb4] < 2) cnt[a->ref[1][xb4]]++; + } + + if (have_left && !l->intra[yb4]) { + if (l->ref[0][yb4] < 2) cnt[l->ref[0][yb4]]++; + if (l->comp_type[yb4] && l->ref[1][yb4] < 2) cnt[l->ref[1][yb4]]++; + } + + return cnt[0] == cnt[1] ? 1 : cnt[0] < cnt[1] ? 0 : 2; +} + +static inline int av1_get_fwd_ref_2_ctx(const BlockContext *const a, + const BlockContext *const l, + const int yb4, const int xb4, + const int have_top, const int have_left) +{ + int cnt[2] = { 0 }; + + if (have_top && !a->intra[xb4]) { + if (a->ref[0][xb4] - 2U < 2) cnt[a->ref[0][xb4] - 2]++; + if (a->comp_type[xb4] && a->ref[1][xb4] - 2U < 2) cnt[a->ref[1][xb4] - 2]++; + } + + if (have_left && !l->intra[yb4]) { + if (l->ref[0][yb4] - 2U < 2) cnt[l->ref[0][yb4] - 2]++; + if (l->comp_type[yb4] && l->ref[1][yb4] - 2U < 2) cnt[l->ref[1][yb4] - 2]++; + } + + return cnt[0] == cnt[1] ? 1 : cnt[0] < cnt[1] ? 0 : 2; +} + +static inline int av1_get_bwd_ref_ctx(const BlockContext *const a, + const BlockContext *const l, + const int yb4, const int xb4, + const int have_top, const int have_left) +{ + int cnt[3] = { 0 }; + + if (have_top && !a->intra[xb4]) { + if (a->ref[0][xb4] >= 4) cnt[a->ref[0][xb4] - 4]++; + if (a->comp_type[xb4] && a->ref[1][xb4] >= 4) cnt[a->ref[1][xb4] - 4]++; + } + + if (have_left && !l->intra[yb4]) { + if (l->ref[0][yb4] >= 4) cnt[l->ref[0][yb4] - 4]++; + if (l->comp_type[yb4] && l->ref[1][yb4] >= 4) cnt[l->ref[1][yb4] - 4]++; + } + + cnt[1] += cnt[0]; + + return cnt[2] == cnt[1] ? 1 : cnt[1] < cnt[2] ? 0 : 2; +} + +static inline int av1_get_bwd_ref_1_ctx(const BlockContext *const a, + const BlockContext *const l, + const int yb4, const int xb4, + const int have_top, const int have_left) +{ + int cnt[3] = { 0 }; + + if (have_top && !a->intra[xb4]) { + if (a->ref[0][xb4] >= 4) cnt[a->ref[0][xb4] - 4]++; + if (a->comp_type[xb4] && a->ref[1][xb4] >= 4) cnt[a->ref[1][xb4] - 4]++; + } + + if (have_left && !l->intra[yb4]) { + if (l->ref[0][yb4] >= 4) cnt[l->ref[0][yb4] - 4]++; + if (l->comp_type[yb4] && l->ref[1][yb4] >= 4) cnt[l->ref[1][yb4] - 4]++; + } + + return cnt[0] == cnt[1] ? 1 : cnt[0] < cnt[1] ? 0 : 2; +} + +static inline int av1_get_uni_p1_ctx(const BlockContext *const a, + const BlockContext *const l, + const int yb4, const int xb4, + const int have_top, const int have_left) +{ + int cnt[3] = { 0 }; + + if (have_top && !a->intra[xb4]) { + if (a->ref[0][xb4] - 1U < 3) cnt[a->ref[0][xb4] - 1]++; + if (a->comp_type[xb4] && a->ref[1][xb4] - 1U < 3) cnt[a->ref[1][xb4] - 1]++; + } + + if (have_left && !l->intra[yb4]) { + if (l->ref[0][yb4] - 1U < 3) cnt[l->ref[0][yb4] - 1]++; + if (l->comp_type[yb4] && l->ref[1][yb4] - 1U < 3) cnt[l->ref[1][yb4] - 1]++; + } + + cnt[1] += cnt[2]; + + return cnt[0] == cnt[1] ? 1 : cnt[0] < cnt[1] ? 0 : 2; +} + +static inline int get_drl_context(const candidate_mv *const ref_mv_stack, + const int ref_idx) +{ + if (ref_mv_stack[ref_idx].weight >= 640 && + ref_mv_stack[ref_idx + 1].weight >= 640) + return 0; + + if (ref_mv_stack[ref_idx].weight >= 640 && + ref_mv_stack[ref_idx + 1].weight < 640) + return 1; + + if (ref_mv_stack[ref_idx].weight < 640 && + ref_mv_stack[ref_idx + 1].weight < 640) + return 2; + + return 0; +} + +static inline unsigned get_cur_frame_segid(const int by, const int bx, + const int have_top, + const int have_left, + int *const seg_ctx, + const uint8_t *cur_seg_map, + const ptrdiff_t stride) +{ + cur_seg_map += bx + by * stride; + if (have_left && have_top) { + const int l = cur_seg_map[-1]; + const int a = cur_seg_map[-stride]; + const int al = cur_seg_map[-(stride + 1)]; + + if (l == a && al == l) *seg_ctx = 2; + else if (l == a || al == l || a == al) *seg_ctx = 1; + else *seg_ctx = 0; + return a == al ? a : l; + } else { + *seg_ctx = 0; + return have_left ? cur_seg_map[-1] : have_top ? cur_seg_map[-stride] : 0; + } +} + +static inline int get_coef_skip_ctx(const TxfmInfo *const t_dim, + const enum BlockSize bs, + const uint8_t *const a, + const uint8_t *const l, + const int chroma, + const enum Dav1dPixelLayout layout) +{ + const uint8_t *const b_dim = av1_block_dimensions[bs]; + + if (chroma) { + const int ss_ver = layout == DAV1D_PIXEL_LAYOUT_I420; + const int ss_hor = layout != DAV1D_PIXEL_LAYOUT_I444; + const int not_one_blk = b_dim[2] - (!!b_dim[2] && ss_hor) > t_dim->lw || + b_dim[3] - (!!b_dim[3] && ss_ver) > t_dim->lh; + int ca, cl; + +#define MERGE_CTX(dir, type, mask) \ + c##dir = !!((*(const type *) dir) & mask); \ + break + switch (t_dim->lw) { + case TX_4X4: MERGE_CTX(a, uint8_t, 0x3F); + case TX_8X8: MERGE_CTX(a, uint16_t, 0x3F3F); + case TX_16X16: MERGE_CTX(a, uint32_t, 0x3F3F3F3FU); + case TX_32X32: MERGE_CTX(a, uint64_t, 0x3F3F3F3F3F3F3F3FULL); + default: abort(); + } + switch (t_dim->lh) { + case TX_4X4: MERGE_CTX(l, uint8_t, 0x3F); + case TX_8X8: MERGE_CTX(l, uint16_t, 0x3F3F); + case TX_16X16: MERGE_CTX(l, uint32_t, 0x3F3F3F3FU); + case TX_32X32: MERGE_CTX(l, uint64_t, 0x3F3F3F3F3F3F3F3FULL); + default: abort(); + } +#undef MERGE_CTX + + return 7 + not_one_blk * 3 + ca + cl; + } else if (b_dim[2] == t_dim->lw && b_dim[3] == t_dim->lh) { + return 0; + } else { + static const uint8_t skip_contexts[5][5] = { + { 1, 2, 2, 2, 3 }, + { 1, 4, 4, 4, 5 }, + { 1, 4, 4, 4, 5 }, + { 1, 4, 4, 4, 5 }, + { 1, 4, 4, 4, 6 } + }; + uint64_t la, ll; + +#define MERGE_CTX(dir, type, tx) do { \ + l##dir = *(const type *) dir; \ + if (tx == TX_64X64) \ + l##dir |= *(const type *) &dir[sizeof(type)]; \ + if (tx >= TX_32X32) l##dir |= l##dir >> 32; \ + if (tx >= TX_16X16) l##dir |= l##dir >> 16; \ + if (tx >= TX_8X8) l##dir |= l##dir >> 8; \ + l##dir &= 0x3F; \ + } while (0); \ + break + switch (t_dim->lw) { + case TX_4X4: MERGE_CTX(a, uint8_t, TX_4X4); + case TX_8X8: MERGE_CTX(a, uint16_t, TX_8X8); + case TX_16X16: MERGE_CTX(a, uint32_t, TX_16X16); + case TX_32X32: MERGE_CTX(a, uint64_t, TX_32X32); + case TX_64X64: MERGE_CTX(a, uint64_t, TX_64X64); + } + switch (t_dim->lh) { + case TX_4X4: MERGE_CTX(l, uint8_t, TX_4X4); + case TX_8X8: MERGE_CTX(l, uint16_t, TX_8X8); + case TX_16X16: MERGE_CTX(l, uint32_t, TX_16X16); + case TX_32X32: MERGE_CTX(l, uint64_t, TX_32X32); + case TX_64X64: MERGE_CTX(l, uint64_t, TX_64X64); + } +#undef MERGE_CTX + + const int max = imin(la | ll, 4); + const int min = imin(imin(la, ll), 4); + + return skip_contexts[min][max]; + } +} + +static inline int get_coef_nz_ctx(uint8_t *const levels, const int scan_idx, + const int rc, const int is_eob, + const enum RectTxfmSize tx, + const enum TxClass tx_class) +{ + const TxfmInfo *const t_dim = &av1_txfm_dimensions[tx]; + + if (is_eob) { + if (scan_idx == 0) return 0; + const int eighth_sz = imin(t_dim->w, 8) * imin(t_dim->h, 8) * 2; + if (scan_idx <= eighth_sz) return 1; + const int quart_sz = eighth_sz * 2; + if (scan_idx <= quart_sz) return 2; + return 3; + } + + const int x = rc >> (2 + imin(t_dim->lh, 3)); + const int y = rc & (4 * imin(t_dim->h, 8) - 1); + const ptrdiff_t stride = 4 * (imin(t_dim->h, 8) + 1); + static const uint8_t offsets[3][5][2 /* x, y */] = { + [TX_CLASS_2D] = { + { 0, 1 }, { 1, 0 }, { 2, 0 }, { 0, 2 }, { 1, 1 } + }, [TX_CLASS_V] = { + { 0, 1 }, { 1, 0 }, { 0, 2 }, { 0, 3 }, { 0, 4 } + }, [TX_CLASS_H] = { + { 0, 1 }, { 1, 0 }, { 2, 0 }, { 3, 0 }, { 4, 0 } + } + }; + const uint8_t (*const off)[2] = offsets[tx_class]; + int mag = 0; + for (int i = 0; i < 5; i++) + mag += imin(levels[(x + off[i][0]) * stride + (y + off[i][1])], 3); + const int ctx = imin((mag + 1) >> 1, 4); + if (tx_class == TX_CLASS_2D) { + return !rc ? 0 : + av1_nz_map_ctx_offset[tx][imin(y, 4)][imin(x, 4)] + ctx; + } else { + return 26 + imin((tx_class == TX_CLASS_V) ? y : x, 2) * 5 + ctx; + } +} + +static inline int get_dc_sign_ctx(const TxfmInfo *const t_dim, + const uint8_t *const a, + const uint8_t *const l) +{ + uint64_t sa, sl; + +#define MERGE_CTX(dir, type, tx, mask) do { \ + s##dir = ((*(const type *) dir) >> 6) & mask; \ + if (tx == TX_64X64) \ + s##dir += ((*(const type *) &dir[sizeof(type)]) >> 6) & mask; \ + if (tx >= TX_32X32) s##dir += s##dir >> 32; \ + if (tx >= TX_16X16) s##dir += s##dir >> 16; \ + if (tx >= TX_8X8) s##dir += s##dir >> 8; \ + } while (0); \ + break + switch (t_dim->lw) { + case TX_4X4: MERGE_CTX(a, uint8_t, TX_4X4, 0x03); + case TX_8X8: MERGE_CTX(a, uint16_t, TX_8X8, 0x0303); + case TX_16X16: MERGE_CTX(a, uint32_t, TX_16X16, 0x03030303U); + case TX_32X32: MERGE_CTX(a, uint64_t, TX_32X32, 0x0303030303030303ULL); + case TX_64X64: MERGE_CTX(a, uint64_t, TX_64X64, 0x0303030303030303ULL); + } + switch (t_dim->lh) { + case TX_4X4: MERGE_CTX(l, uint8_t, TX_4X4, 0x03); + case TX_8X8: MERGE_CTX(l, uint16_t, TX_8X8, 0x0303); + case TX_16X16: MERGE_CTX(l, uint32_t, TX_16X16, 0x03030303U); + case TX_32X32: MERGE_CTX(l, uint64_t, TX_32X32, 0x0303030303030303ULL); + case TX_64X64: MERGE_CTX(l, uint64_t, TX_64X64, 0x0303030303030303ULL); + } +#undef MERGE_CTX + const int s = ((int) ((sa + sl) & 0xFF)) - (t_dim->w + t_dim->h); + + return s < 0 ? 1 : s > 0 ? 2 : 0; +} + +static inline int get_br_ctx(const uint8_t *const levels, + const int rc, const enum RectTxfmSize tx, + const enum TxClass tx_class) +{ + const TxfmInfo *const t_dim = &av1_txfm_dimensions[tx]; + const int x = rc >> (imin(t_dim->lh, 3) + 2); + const int y = rc & (4 * imin(t_dim->h, 8) - 1); + const int stride = 4 * (imin(t_dim->h, 8) + 1); + int mag = 0; + static const uint8_t offsets_from_txclass[3][3][2] = { + [TX_CLASS_2D] = { { 0, 1 }, { 1, 0 }, { 1, 1 } }, + [TX_CLASS_H] = { { 0, 1 }, { 1, 0 }, { 0, 2 } }, + [TX_CLASS_V] = { { 0, 1 }, { 1, 0 }, { 2, 0 } } + }; + const uint8_t (*const offsets)[2] = offsets_from_txclass[tx_class]; + for (int i = 0; i < 3; i++) + mag += levels[(x + offsets[i][1]) * stride + y + offsets[i][0]]; + + mag = imin((mag + 1) >> 1, 6); + if (rc == 0) return mag; + switch (tx_class) { + case TX_CLASS_2D: + if (y < 2 && x < 2) return mag + 7; + break; + case TX_CLASS_H: + if (x == 0) return mag + 7; + break; + case TX_CLASS_V: + if (y == 0) return mag + 7; + break; + } + return mag + 14; +} + +static inline mv get_gmv_2d(const WarpedMotionParams *const gmv, + const int bx4, const int by4, + const int bw4, const int bh4, + const Av1FrameHeader *const hdr) +{ + switch (gmv->type) { + case WM_TYPE_ROT_ZOOM: + assert(gmv->matrix[5] == gmv->matrix[2]); + assert(gmv->matrix[4] == -gmv->matrix[3]); + // fall-through + default: + case WM_TYPE_AFFINE: { + const int x = bx4 * 4 + bw4 * 2 - 1; + const int y = by4 * 4 + bh4 * 2 - 1; + const int xc = (gmv->matrix[2] - (1 << 16)) * x + + gmv->matrix[3] * y + gmv->matrix[0]; + const int yc = (gmv->matrix[5] - (1 << 16)) * y + + gmv->matrix[4] * x + gmv->matrix[1]; + const int shift = 16 - (3 - !hdr->hp); + const int round = (1 << shift) >> 1; + return (mv) { + .y = apply_sign(((abs(yc) + round) >> shift) << !hdr->hp, yc), + .x = apply_sign(((abs(xc) + round) >> shift) << !hdr->hp, xc), + }; + } + case WM_TYPE_TRANSLATION: + return (mv) { + .y = gmv->matrix[0] >> 13, + .x = gmv->matrix[1] >> 13, + }; + case WM_TYPE_IDENTITY: + return (mv) { .x = 0, .y = 0 }; + } +} + +#endif /* __DAV1D_SRC_ENV_H__ */ diff --git a/src/getbits.c b/src/getbits.c new file mode 100644 index 0000000..9eb0759 --- /dev/null +++ b/src/getbits.c @@ -0,0 +1,129 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <assert.h> + +#include "common/intops.h" + +#include "src/getbits.h" + +void init_get_bits(GetBits *const c, + const uint8_t *const data, const size_t sz) +{ + c->ptr = c->ptr_start = data; + c->ptr_end = &c->ptr_start[sz]; + c->bits_left = 0; + c->state = 0; + c->error = 0; + c->eof = 0; +} + +static void refill(GetBits *const c, const unsigned n) { + assert(c->bits_left <= 56); + uint64_t state = 0; + do { + state <<= 8; + c->bits_left += 8; + if (!c->eof) + state |= *c->ptr++; + if (c->ptr >= c->ptr_end) { + c->error = c->eof; + c->eof = 1; + } + } while (n > c->bits_left); + c->state |= state << (64 - c->bits_left); +} + +unsigned get_bits(GetBits *const c, const unsigned n) { + assert(n <= 32 /* can go up to 57 if we change return type */); + + if (n > c->bits_left) refill(c, n); + + const uint64_t state = c->state; + c->bits_left -= n; + c->state <<= n; + + return state >> (64 - n); +} + +int get_sbits(GetBits *const c, const unsigned n) { + const int shift = 31 - n; + const int res = get_bits(c, n + 1) << shift; + return res >> shift; +} + +unsigned get_uniform(GetBits *const c, const unsigned n) { + assert(n > 0); + const int l = ulog2(n) + 1; + assert(l > 0); + const int m = (1 << l) - n; + const int v = get_bits(c, l - 1); + return v < m ? v : (v << 1) - m + get_bits(c, 1); +} + +unsigned get_vlc(GetBits *const c) { + int n_bits = 0; + while (!get_bits(c, 1)) n_bits++; + if (n_bits >= 32) return 0xFFFFFFFFU; + return ((1 << n_bits) - 1) + get_bits(c, n_bits); +} + +static unsigned get_bits_subexp_u(GetBits *const c, const unsigned ref, + const unsigned n) +{ + unsigned v = 0; + + for (int i = 0;; i++) { + const int b = i ? 3 + i - 1 : 3; + + if (n < v + 3 * (1 << b)) { + v += get_uniform(c, n - v + 1); + break; + } + + if (!get_bits(c, 1)) { + v += get_bits(c, b); + break; + } + + v += 1 << b; + } + + return ref * 2 <= n ? inv_recenter(ref, v) : n - inv_recenter(n - ref, v); +} + +int get_bits_subexp(GetBits *const c, const int ref, const unsigned n) { + return (int) get_bits_subexp_u(c, ref + (1 << n), 2 << n) - (1 << n); +} + +const uint8_t *flush_get_bits(GetBits *c) { + c->bits_left = 0; + c->state = 0; + return c->ptr; +} diff --git a/src/getbits.h b/src/getbits.h new file mode 100644 index 0000000..1a2c940 --- /dev/null +++ b/src/getbits.h @@ -0,0 +1,49 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_SRC_GETBITS_H__ +#define __DAV1D_SRC_GETBITS_H__ + +#include <stddef.h> +#include <stdint.h> + +typedef struct GetBits { + int error, eof; + uint64_t state; + unsigned bits_left; + const uint8_t *ptr, *ptr_start, *ptr_end; +} GetBits; + +void init_get_bits(GetBits *c, const uint8_t *data, size_t sz); +unsigned get_bits(GetBits *c, unsigned n); +int get_sbits(GetBits *c, unsigned n); +unsigned get_uniform(GetBits *c, unsigned range); +unsigned get_vlc(GetBits *c); +int get_bits_subexp(GetBits *c, int ref, unsigned n); +const uint8_t *flush_get_bits(GetBits *c); + +#endif /* __DAV1D_SRC_GETBITS_H__ */ diff --git a/src/internal.h b/src/internal.h new file mode 100644 index 0000000..ffb2b64 --- /dev/null +++ b/src/internal.h @@ -0,0 +1,275 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_SRC_INTERNAL_H__ +#define __DAV1D_SRC_INTERNAL_H__ + +#include <pthread.h> +#include <stdatomic.h> + +#include "dav1d/data.h" + +typedef struct Dav1dFrameContext Dav1dFrameContext; +typedef struct Dav1dTileState Dav1dTileState; +typedef struct Dav1dTileContext Dav1dTileContext; + +#include "common/attributes.h" + +#include "src/cdef.h" +#include "src/cdf.h" +#include "src/env.h" +#include "src/intra_edge.h" +#include "src/ipred.h" +#include "src/itx.h" +#include "src/levels.h" +#include "src/lf_mask.h" +#include "src/loopfilter.h" +#include "src/looprestoration.h" +#include "src/mc.h" +#include "src/msac.h" +#include "src/picture.h" +#include "src/recon.h" +#include "src/ref_mvs.h" + +typedef struct Dav1dDSPContext { + Dav1dIntraPredDSPContext ipred; + Dav1dMCDSPContext mc; + Dav1dInvTxfmDSPContext itx; + Dav1dLoopFilterDSPContext lf; + Dav1dCdefDSPContext cdef; + Dav1dLoopRestorationDSPContext lr; +} Dav1dDSPContext; + +struct Dav1dContext { + Dav1dFrameContext *fc; + int n_fc; + + // cache of OBUs that make up a single frame before we submit them + // to a frame worker to be decoded + struct { + Dav1dData data; + int start, end; + } tile[256]; + int n_tile_data, have_seq_hdr, have_frame_hdr; + unsigned tile_mask; + Av1SequenceHeader seq_hdr; // FIXME make ref? + Av1FrameHeader frame_hdr; // FIXME make ref? + + // decoded output picture queue + Dav1dPicture out; + struct { + Dav1dThreadPicture *out_delayed; + unsigned next; + } frame_thread; + + // reference/entropy state + struct { + Dav1dThreadPicture p; + Dav1dRef *segmap; + Av1SegmentationDataSet seg_data; + Dav1dRef *refmvs; + unsigned refpoc[7]; + WarpedMotionParams gmv[7]; + Av1LoopfilterModeRefDeltas lf_mode_ref_deltas; + Av1FilmGrainData film_grain; + } refs[8]; + CdfThreadContext cdf[8]; + + Dav1dDSPContext dsp[3 /* 8, 10, 12 bits/component */]; + + // tree to keep track of which edges are available + struct { + EdgeNode *root[2 /* BL_128X128 vs. BL_64X64 */]; + EdgeBranch branch_sb128[1 + 4 + 16 + 64]; + EdgeBranch branch_sb64[1 + 4 + 16]; + EdgeTip tip_sb128[256]; + EdgeTip tip_sb64[64]; + } intra_edge; +}; + +struct Dav1dFrameContext { + Av1SequenceHeader seq_hdr; + Av1FrameHeader frame_hdr; + Dav1dThreadPicture refp[7], cur; + Dav1dRef *mvs_ref; + refmvs *mvs, *ref_mvs[7]; + Dav1dRef *ref_mvs_ref[7]; + Dav1dRef *cur_segmap_ref, *prev_segmap_ref; + uint8_t *cur_segmap; + const uint8_t *prev_segmap; + unsigned refpoc[7], refrefpoc[7][7]; + CdfThreadContext in_cdf, out_cdf; + struct { + Dav1dData data; + int start, end; + } tile[256]; + int n_tile_data; + + const Dav1dContext *c; + Dav1dTileContext *tc; + int n_tc; + Dav1dTileState *ts; + int n_ts; + const Dav1dDSPContext *dsp; + struct { + recon_b_intra_fn recon_b_intra; + recon_b_inter_fn recon_b_inter; + filter_sbrow_fn filter_sbrow; + backup_ipred_edge_fn backup_ipred_edge; + read_coef_blocks_fn read_coef_blocks; + } bd_fn; + + int ipred_edge_sz; + pixel *ipred_edge[3]; + ptrdiff_t b4_stride; + int bw, bh, sb128w, sb128h, sbh, sb_shift, sb_step; + uint16_t dq[NUM_SEGMENTS][3 /* plane */][2 /* dc/ac */]; + const uint8_t *qm[2 /* is_1d */][N_RECT_TX_SIZES][3 /* plane */]; + BlockContext *a; + int a_sz /* w*tile_rows */; + AV1_COMMON *libaom_cm; // FIXME + uint8_t jnt_weights[7][7]; + + struct { + struct thread_data td; + int pass, die; + // indexed using t->by * f->b4_stride + t->bx + Av1Block *b; + struct CodedBlockInfo { + int16_t eob[3 /* plane */]; + uint8_t txtp[3 /* plane */]; + } *cbi; + int8_t *txtp; + // indexed using (t->by >> 1) * (f->b4_stride >> 1) + (t->bx >> 1) + uint16_t (*pal)[3 /* plane */][8 /* idx */]; + // iterated over inside tile state + uint8_t *pal_idx; + coef *cf; + // start offsets per tile + int *tile_start_off; + } frame_thread; + + // loopfilter + struct { + uint8_t (*level)[4]; + Av1Filter *mask; + int top_pre_cdef_toggle; + int mask_sz /* w*h */, line_sz /* w */, re_sz /* h */; + Av1FilterLUT lim_lut; + int last_sharpness; + uint8_t lvl[8 /* seg_id */][4 /* dir */][8 /* ref */][2 /* is_gmv */]; + uint8_t *tx_lpf_right_edge[2]; + pixel *cdef_line; + pixel *cdef_line_ptr[2 /* pre, post */][3 /* plane */][2 /* y */]; + pixel *lr_lpf_line; + pixel *lr_lpf_line_ptr[3 /* plane */]; + + // in-loop filter per-frame state keeping + int tile_row; // for carry-over at tile row edges + pixel *p[3]; + Av1Filter *mask_ptr, *prev_mask_ptr; + } lf; + + // threading (refer to tc[] for per-thread things) + struct FrameTileThreadData { + uint64_t available; + pthread_mutex_t lock; + pthread_cond_t cond, icond; + int tasks_left, num_tasks; + int (*task_idx_to_sby_and_tile_idx)[2]; + int titsati_sz, titsati_init[2]; + } tile_thread; +}; + +struct Dav1dTileState { + struct { + int col_start, col_end, row_start, row_end; // in 4px units + int col, row; // in tile units + } tiling; + + CdfContext cdf; + MsacContext msac; + + atomic_int progress; // in sby units + struct { + pthread_mutex_t lock; + pthread_cond_t cond; + } tile_thread; + struct { + uint8_t *pal_idx; + coef *cf; + } frame_thread; + + uint16_t dqmem[NUM_SEGMENTS][3 /* plane */][2 /* dc/ac */]; + const uint16_t (*dq)[3][2]; + int last_qidx; + + int8_t last_delta_lf[4]; + uint8_t lflvlmem[8 /* seg_id */][4 /* dir */][8 /* ref */][2 /* is_gmv */]; + const uint8_t (*lflvl)[4][8][2]; + + Av1RestorationUnit *lr_ref[3]; +}; + +struct Dav1dTileContext { + const Dav1dFrameContext *f; + Dav1dTileState *ts; + int bx, by; + BlockContext l, *a; + coef *cf; + pixel *emu_edge; // stride=160 + // FIXME types can be changed to pixel (and dynamically allocated) + // which would make copy/assign operations slightly faster? + uint16_t al_pal[2 /* a/l */][32 /* bx/y4 */][3 /* plane */][8 /* palette_idx */]; + uint16_t pal[3 /* plane */][8 /* palette_idx */]; + uint8_t pal_sz_uv[2 /* a/l */][32 /* bx4/by4 */]; + uint8_t txtp_map[32 * 32]; // inter-only + WarpedMotionParams warpmv; + union { + void *mem; + uint8_t *pal_idx; + int16_t *ac; + pixel *interintra, *lap; + coef *compinter; + } scratch; + ALIGN(uint8_t scratch_seg_mask[128 * 128], 32); + + Av1Filter *lf_mask; + int8_t *cur_sb_cdef_idx_ptr; + // for chroma sub8x8, we need to know the filter for all 4 subblocks in + // a 4x4 area, but the top/left one can go out of cache already, so this + // keeps it accessible + enum Filter2d tl_4x4_filter; + + struct { + struct thread_data td; + struct FrameTileThreadData *fttd; + int die; + } tile_thread; +}; + +#endif /* __DAV1D_SRC_INTERNAL_H__ */ diff --git a/src/intra_edge.c b/src/intra_edge.c new file mode 100644 index 0000000..e2ec080 --- /dev/null +++ b/src/intra_edge.c @@ -0,0 +1,166 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <assert.h> + +#include "src/intra_edge.h" +#include "src/levels.h" + +struct ModeSelMem { + EdgeBranch *nwc[3 /* 64x64, 32x32, 16x16 */]; + EdgeTip *nt; +}; + +static void init_edges(EdgeNode *const node, + const enum BlockLevel bl, + const enum EdgeFlags edge_flags) +{ + node->o = edge_flags; + +#define ALL_FL(t) (EDGE_I444_##t | EDGE_I422_##t | EDGE_I420_##t) + if (bl == BL_8X8) { + EdgeTip *const nt = (EdgeTip *) node; + + node->h[0] = edge_flags | ALL_FL(LEFT_HAS_BOTTOM); + node->h[1] = edge_flags & (ALL_FL(LEFT_HAS_BOTTOM) | + EDGE_I420_TOP_HAS_RIGHT); + + node->v[0] = edge_flags | ALL_FL(TOP_HAS_RIGHT); + node->v[1] = edge_flags & (ALL_FL(TOP_HAS_RIGHT) | + EDGE_I420_LEFT_HAS_BOTTOM | + EDGE_I422_LEFT_HAS_BOTTOM); + + nt->split[0] = ALL_FL(TOP_HAS_RIGHT) | ALL_FL(LEFT_HAS_BOTTOM); + nt->split[1] = (edge_flags & ALL_FL(TOP_HAS_RIGHT)) | + EDGE_I422_LEFT_HAS_BOTTOM; + nt->split[2] = edge_flags | EDGE_I444_TOP_HAS_RIGHT; + nt->split[3] = edge_flags & (EDGE_I420_TOP_HAS_RIGHT | + EDGE_I420_LEFT_HAS_BOTTOM | + EDGE_I422_LEFT_HAS_BOTTOM); + } else { + EdgeBranch *const nwc = (EdgeBranch *) node; + + node->h[0] = edge_flags | ALL_FL(LEFT_HAS_BOTTOM); + node->h[1] = edge_flags & ALL_FL(LEFT_HAS_BOTTOM); + + node->v[0] = edge_flags | ALL_FL(TOP_HAS_RIGHT); + node->v[1] = edge_flags & ALL_FL(TOP_HAS_RIGHT); + + nwc->h4[0] = edge_flags | ALL_FL(LEFT_HAS_BOTTOM); + nwc->h4[1] = + nwc->h4[2] = ALL_FL(LEFT_HAS_BOTTOM); + nwc->h4[3] = edge_flags & ALL_FL(LEFT_HAS_BOTTOM); + if (bl == BL_16X16) + nwc->h4[1] |= edge_flags & EDGE_I420_TOP_HAS_RIGHT; + + nwc->v4[0] = edge_flags | ALL_FL(TOP_HAS_RIGHT); + nwc->v4[1] = + nwc->v4[2] = ALL_FL(TOP_HAS_RIGHT); + nwc->v4[3] = edge_flags & ALL_FL(TOP_HAS_RIGHT); + if (bl == BL_16X16) + nwc->v4[1] |= edge_flags & (EDGE_I420_LEFT_HAS_BOTTOM | + EDGE_I422_LEFT_HAS_BOTTOM); + + nwc->tls[0] = ALL_FL(TOP_HAS_RIGHT) | ALL_FL(LEFT_HAS_BOTTOM); + nwc->tls[1] = edge_flags & ALL_FL(LEFT_HAS_BOTTOM); + nwc->tls[2] = edge_flags & ALL_FL(TOP_HAS_RIGHT); + + nwc->trs[0] = edge_flags | ALL_FL(TOP_HAS_RIGHT); + nwc->trs[1] = edge_flags | ALL_FL(LEFT_HAS_BOTTOM); + nwc->trs[2] = 0; + + nwc->tts[0] = ALL_FL(TOP_HAS_RIGHT) | ALL_FL(LEFT_HAS_BOTTOM); + nwc->tts[1] = edge_flags & ALL_FL(TOP_HAS_RIGHT); + nwc->tts[2] = edge_flags & ALL_FL(LEFT_HAS_BOTTOM); + + nwc->tbs[0] = edge_flags | ALL_FL(LEFT_HAS_BOTTOM); + nwc->tbs[1] = edge_flags | ALL_FL(TOP_HAS_RIGHT); + nwc->tbs[2] = 0; + } +} + +static void init_mode_node(EdgeBranch *const nwc, + const enum BlockLevel bl, + struct ModeSelMem *const mem, + const int top_has_right, + const int left_has_bottom) +{ + int n; + + init_edges(&nwc->node, bl, + (top_has_right ? ALL_FL(TOP_HAS_RIGHT) : 0) | + (left_has_bottom ? ALL_FL(LEFT_HAS_BOTTOM) : 0)); + if (bl == BL_16X16) { + for (n = 0; n < 4; n++) { + EdgeTip *const nt = mem->nt++; + nwc->split[n] = &nt->node; + init_edges(&nt->node, bl + 1, + ((n == 3 || (n == 1 && !top_has_right)) ? 0 : + ALL_FL(TOP_HAS_RIGHT)) | + (!(n == 0 || (n == 2 && left_has_bottom)) ? 0 : + ALL_FL(LEFT_HAS_BOTTOM))); + } + } else { + for (n = 0; n < 4; n++) { + EdgeBranch *const nwc_child = mem->nwc[bl]++; + nwc->split[n] = &nwc_child->node; + init_mode_node(nwc_child, bl + 1, mem, + !(n == 3 || (n == 1 && !top_has_right)), + n == 0 || (n == 2 && left_has_bottom)); + } + } +} + +void init_mode_tree(EdgeNode *const root_node, EdgeTip *const nt, + const int allow_sb128) +{ + EdgeBranch *const root = (EdgeBranch *) root_node; + struct ModeSelMem mem; + + if (allow_sb128) { + mem.nwc[BL_128X128] = &root[1]; + mem.nwc[BL_64X64] = &root[1 + 4]; + mem.nwc[BL_32X32] = &root[1 + 4 + 16]; + mem.nt = nt; + init_mode_node(root, BL_128X128, &mem, 1, 0); + assert(mem.nwc[BL_128X128] == &root[1 + 4]); + assert(mem.nwc[BL_64X64] == &root[1 + 4 + 16]); + assert(mem.nwc[BL_32X32] == &root[1 + 4 + 16 + 64]); + assert(mem.nt == &nt[256]); + } else { + mem.nwc[BL_128X128] = NULL; + mem.nwc[BL_64X64] = &root[1]; + mem.nwc[BL_32X32] = &root[1 + 4]; + mem.nt = nt; + init_mode_node(root, BL_64X64, &mem, 1, 0); + assert(mem.nwc[BL_64X64] == &root[1 + 4]); + assert(mem.nwc[BL_32X32] == &root[1 + 4 + 16]); + assert(mem.nt == &nt[64]); + } +} diff --git a/src/intra_edge.h b/src/intra_edge.h new file mode 100644 index 0000000..aa0181c --- /dev/null +++ b/src/intra_edge.h @@ -0,0 +1,57 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_SRC_INTRA_EDGE_H__ +#define __DAV1D_SRC_INTRA_EDGE_H__ + +enum EdgeFlags { + EDGE_I444_TOP_HAS_RIGHT = 1 << 0, + EDGE_I422_TOP_HAS_RIGHT = 1 << 1, + EDGE_I420_TOP_HAS_RIGHT = 1 << 2, + EDGE_I444_LEFT_HAS_BOTTOM = 1 << 3, + EDGE_I422_LEFT_HAS_BOTTOM = 1 << 4, + EDGE_I420_LEFT_HAS_BOTTOM = 1 << 5, +}; + +typedef struct EdgeNode EdgeNode; +struct EdgeNode { + enum EdgeFlags o, h[2], v[2]; +}; +typedef struct EdgeTip { + EdgeNode node; + enum EdgeFlags split[4]; +} EdgeTip; +typedef struct EdgeBranch { + EdgeNode node; + enum EdgeFlags tts[3], tbs[3], tls[3], trs[3], h4[4], v4[4]; + EdgeNode *split[4]; +} EdgeBranch; + +void init_mode_tree(EdgeNode *const root, EdgeTip *const nt, + const int allow_sb128); + +#endif /* __DAV1D_SRC_INTRA_EDGE_H__ */ diff --git a/src/ipred.c b/src/ipred.c new file mode 100644 index 0000000..1c50f45 --- /dev/null +++ b/src/ipred.c @@ -0,0 +1,1010 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <assert.h> +#include <stdlib.h> +#include <string.h> + +#include "common/intops.h" + +#include "src/ipred.h" + +#define sz_grid(l_fn) \ +l_fn( 4, 4); \ +l_fn( 4, 8); \ +l_fn( 4, 16); \ +l_fn( 8, 4); \ +l_fn( 8, 8); \ +l_fn( 8, 16); \ +l_fn( 8, 32); \ +l_fn(16, 4); \ +l_fn(16, 8); \ +l_fn(16, 16); \ +l_fn(16, 32); \ +l_fn(16, 64); \ +l_fn(32, 8); \ +l_fn(32, 16); \ +l_fn(32, 32); \ +l_fn(32, 64); \ +l_fn(64, 16); \ +l_fn(64, 32); \ +l_fn(64, 64) + +static __attribute__((noinline)) void +splat_dc_c(pixel *dst, const ptrdiff_t stride, + const int w, const int h, const unsigned dc) +{ + assert(dc <= (1 << BITDEPTH) - 1); +#if BITDEPTH == 8 + if (w > 4) { + const uint64_t dcN = dc * 0x0101010101010101ULL; + for (int y = 0; y < h; y++) { + for (int x = 0; x < w; x += sizeof(dcN)) + *((uint64_t *) &dst[x]) = dcN; + dst += PXSTRIDE(stride); + } + } else { + const unsigned dcN = dc * 0x01010101U; + for (int y = 0; y < h; y++) { + for (int x = 0; x < w; x += sizeof(dcN)) + *((unsigned *) &dst[x]) = dcN; + dst += PXSTRIDE(stride); + } + } +#else + const uint64_t dcN = dc * 0x0001000100010001ULL; + for (int y = 0; y < h; y++) { + for (int x = 0; x < w; x += sizeof(dcN) >> 1) + *((uint64_t *) &dst[x]) = dcN; + dst += PXSTRIDE(stride); + } +#endif +} + +#define dc_lfn(w, h, dir, dc_gen) \ +static void dc##dir##_##w##x##h##_c(pixel *dst, const ptrdiff_t stride, \ + const pixel *const topleft, const int a) \ +{ \ + dc_gen; \ + splat_dc_c(dst, stride, w, h, dc); \ +} + +#define dc1d_lfns(width, height, sh1, sh2) \ +dc_lfn(width, height, top, unsigned dc = width >> 1; \ + for (int i = 0; i < width; i++) \ + dc += topleft[1 + i]; \ + dc >>= sh1); \ +dc_lfn(width, height, left, unsigned dc = height >> 1; \ + for (int i = 0; i < height; i++) \ + dc += topleft[-(1 + i)]; \ + dc >>= sh2) + +dc1d_lfns( 4, 4, 2, 2); +dc1d_lfns( 4, 8, 2, 3); +dc1d_lfns( 4, 16, 2, 4); +dc1d_lfns( 8, 4, 3, 2); +dc1d_lfns( 8, 8, 3, 3); +dc1d_lfns( 8, 16, 3, 4); +dc1d_lfns( 8, 32, 3, 5); +dc1d_lfns(16, 4, 4, 2); +dc1d_lfns(16, 8, 4, 3); +dc1d_lfns(16, 16, 4, 4); +dc1d_lfns(16, 32, 4, 5); +dc1d_lfns(16, 64, 4, 6); +dc1d_lfns(32, 8, 5, 3); +dc1d_lfns(32, 16, 5, 4); +dc1d_lfns(32, 32, 5, 5); +dc1d_lfns(32, 64, 5, 6); +dc1d_lfns(64, 16, 6, 4); +dc1d_lfns(64, 32, 6, 5); +dc1d_lfns(64, 64, 6, 6); + +#define dc2d_lfn(width, height, dc_gen) \ +dc_lfn(width, height,, unsigned dc = (width + height) >> 1; \ + for (int i = 0; i < width; i++) \ + dc += topleft[i + 1]; \ + for (int i = 0; i < height; i++) \ + dc += topleft[-(i + 1)]; \ + dc_gen) + +dc2d_lfn( 4, 4, dc >>= 3); +dc2d_lfn( 4, 8, dc = iclip_pixel(0x5556 * dc >> 18)); +dc2d_lfn( 4, 16, dc = iclip_pixel(0x3334 * dc >> 18)); +dc2d_lfn( 8, 4, dc = iclip_pixel(0x5556 * dc >> 18)); +dc2d_lfn( 8, 8, dc >>= 4); +dc2d_lfn( 8, 16, dc = iclip_pixel(0x5556 * dc >> 19)); +dc2d_lfn( 8, 32, dc = iclip_pixel(0x3334 * dc >> 19)); +dc2d_lfn(16, 4, dc = iclip_pixel(0x3334 * dc >> 18)); +dc2d_lfn(16, 8, dc = iclip_pixel(0x5556 * dc >> 19)); +dc2d_lfn(16, 16, dc >>= 5); +dc2d_lfn(16, 32, dc = iclip_pixel(0x5556 * dc >> 20)); +dc2d_lfn(16, 64, dc = iclip_pixel(0x3334 * dc >> 20)); +dc2d_lfn(32, 8, dc = iclip_pixel(0x3334 * dc >> 19)); +dc2d_lfn(32, 16, dc = iclip_pixel(0x5556 * dc >> 20)); +dc2d_lfn(32, 32, dc >>= 6); +dc2d_lfn(32, 64, dc = iclip_pixel(0x5556 * dc >> 21)); +dc2d_lfn(64, 16, dc = iclip_pixel(0x3334 * dc >> 20)); +dc2d_lfn(64, 32, dc = iclip_pixel(0x5556 * dc >> 21)); +dc2d_lfn(64, 64, dc >>= 7); + +#define dc128_lfn(width, height) \ +dc_lfn(width, height, 128, const unsigned dc = (1 << BITDEPTH) >> 1) + +sz_grid(dc128_lfn); + +static __attribute__((noinline)) void +v_c(pixel *dst, const ptrdiff_t stride, + const pixel *const topleft, const int width, const int height) +{ + for (int y = 0; y < height; y++) { + pixel_copy(dst, topleft + 1, width); + dst += PXSTRIDE(stride); + } +} + +#define v_lfn(width, height) \ +static void v_##width##x##height##_##c(pixel *dst, const ptrdiff_t stride, \ + const pixel *const topleft, const int a) \ +{ \ + v_c(dst, stride, topleft, width, height); \ +} + +sz_grid(v_lfn); + +static __attribute__((noinline)) void +h_c(pixel *dst, const ptrdiff_t stride, + const pixel *const topleft, const int width, const int height) +{ + for (int y = 0; y < height; y++) { + pixel_set(dst, topleft[-(1 + y)], width); + dst += PXSTRIDE(stride); + } +} + +#define h_lfn(width, height) \ +static void h_##width##x##height##_c(pixel *dst, const ptrdiff_t stride, \ + const pixel *const topleft, const int a) \ +{ \ + h_c(dst, stride, topleft, width, height); \ +} + +sz_grid(h_lfn); + +static __attribute__((noinline)) void +paeth_c(pixel *dst, const ptrdiff_t stride, const pixel *const tl_ptr, + const int width, const int height) +{ + const int topleft = tl_ptr[0]; + for (int y = 0; y < height; y++) { + const int left = tl_ptr[-(y + 1)]; + for (int x = 0; x < width; x++) { + const int top = tl_ptr[1 + x]; + const int base = left + top - topleft; + const int ldiff = abs(left - base); + const int tdiff = abs(top - base); + const int tldiff = abs(topleft - base); + + dst[x] = ldiff <= tdiff && ldiff <= tldiff ? left : + tdiff <= tldiff ? top : topleft; + } + dst += PXSTRIDE(stride); + } +} + +#define paeth_lfn(width, height) \ +static void paeth_##width##x##height##_c(pixel *dst, const ptrdiff_t stride, \ + const pixel *const topleft, \ + const int a) \ +{ \ + paeth_c(dst, stride, topleft, width, height); \ +} + +sz_grid(paeth_lfn); + +static const uint8_t sm_weight_arrays[] = { + // Unused, because we always offset by bs, which is at least 2. + 0, 0, + // bs = 2 + 255, 128, + // bs = 4 + 255, 149, 85, 64, + // bs = 8 + 255, 197, 146, 105, 73, 50, 37, 32, + // bs = 16 + 255, 225, 196, 170, 145, 123, 102, 84, 68, 54, 43, 33, 26, 20, 17, 16, + // bs = 32 + 255, 240, 225, 210, 196, 182, 169, 157, 145, 133, 122, 111, 101, 92, 83, 74, + 66, 59, 52, 45, 39, 34, 29, 25, 21, 17, 14, 12, 10, 9, 8, 8, + // bs = 64 + 255, 248, 240, 233, 225, 218, 210, 203, 196, 189, 182, 176, 169, 163, 156, + 150, 144, 138, 133, 127, 121, 116, 111, 106, 101, 96, 91, 86, 82, 77, 73, 69, + 65, 61, 57, 54, 50, 47, 44, 41, 38, 35, 32, 29, 27, 25, 22, 20, 18, 16, 15, + 13, 12, 10, 9, 8, 7, 6, 6, 5, 5, 4, 4, 4, +}; + +static __attribute__((noinline)) void +smooth_c(pixel *dst, const ptrdiff_t stride, const pixel *const topleft, + const int width, const int height) +{ + const uint8_t *const weights_hor = &sm_weight_arrays[width]; + const uint8_t *const weights_ver = &sm_weight_arrays[height]; + const int right = topleft[width], bottom = topleft[-height]; + + for (int y = 0; y < height; y++) { + for (int x = 0; x < width; x++) { + const int pred = weights_ver[y] * topleft[1 + x] + + (256 - weights_ver[y]) * bottom + + weights_hor[x] * topleft[-(1 + y)] + + (256 - weights_hor[x]) * right; + dst[x] = (pred + 256) >> 9; + } + dst += PXSTRIDE(stride); + } +} + +#define smooth_lfn(width, height) \ +static void smooth_##width##x##height##_c(pixel *dst, const ptrdiff_t stride, \ + const pixel *const topleft, \ + const int a) \ +{ \ + smooth_c(dst, stride, topleft, width, height); \ +} + +sz_grid(smooth_lfn); + +static __attribute__((noinline)) void +smooth_v_c(pixel *dst, const ptrdiff_t stride, const pixel *const topleft, + const int width, const int height) +{ + const uint8_t *const weights_ver = &sm_weight_arrays[height]; + const int bottom = topleft[-height]; + + for (int y = 0; y < height; y++) { + for (int x = 0; x < width; x++) { + const int pred = weights_ver[y] * topleft[1 + x] + + (256 - weights_ver[y]) * bottom; + dst[x] = (pred + 128) >> 8; + } + dst += PXSTRIDE(stride); + } +} + +#define smooth_v_lfn(width, height) \ +static void smooth_v_##width##x##height##_c(pixel *dst, const ptrdiff_t stride, \ + const pixel *const topleft, \ + const int a) \ +{ \ + smooth_v_c(dst, stride, topleft, width, height); \ +} + +sz_grid(smooth_v_lfn); + +static __attribute__((noinline)) void +smooth_h_c(pixel *dst, const ptrdiff_t stride, const pixel *const topleft, + const int width, const int height) +{ + const uint8_t *const weights_hor = &sm_weight_arrays[width]; + const int right = topleft[width]; + + for (int y = 0; y < height; y++) { + for (int x = 0; x < width; x++) { + const int pred = weights_hor[x] * topleft[-(y + 1)] + + (256 - weights_hor[x]) * right; + dst[x] = (pred + 128) >> 8; + } + dst += PXSTRIDE(stride); + } +} + +#define smooth_h_lfn(width, height) \ +static void smooth_h_##width##x##height##_c(pixel *dst, const ptrdiff_t stride, \ + const pixel *const topleft, \ + const int a) \ +{ \ + smooth_h_c(dst, stride, topleft, width, height); \ +} + +sz_grid(smooth_h_lfn); + +static const int16_t dr_intra_derivative[90] = { + // More evenly spread out angles and limited to 10-bit + // Values that are 0 will never be used + // Approx angle + 0, 0, 0, // + 1023, 0, 0, // 3, ... + 547, 0, 0, // 6, ... + 372, 0, 0, 0, 0, // 9, ... + 273, 0, 0, // 14, ... + 215, 0, 0, // 17, ... + 178, 0, 0, // 20, ... + 151, 0, 0, // 23, ... (113 & 203 are base angles) + 132, 0, 0, // 26, ... + 116, 0, 0, // 29, ... + 102, 0, 0, 0, // 32, ... + 90, 0, 0, // 36, ... + 80, 0, 0, // 39, ... + 71, 0, 0, // 42, ... + 64, 0, 0, // 45, ... (45 & 135 are base angles) + 57, 0, 0, // 48, ... + 51, 0, 0, // 51, ... + 45, 0, 0, 0, // 54, ... + 40, 0, 0, // 58, ... + 35, 0, 0, // 61, ... + 31, 0, 0, // 64, ... + 27, 0, 0, // 67, ... (67 & 157 are base angles) + 23, 0, 0, // 70, ... + 19, 0, 0, // 73, ... + 15, 0, 0, 0, 0, // 76, ... + 11, 0, 0, // 81, ... + 7, 0, 0, // 84, ... + 3, 0, 0, // 87, ... +}; + +static int get_filter_strength(const unsigned blk_wh, const unsigned d, + const int type) +{ + int strength = 0; + + if (type == 0) { + if (blk_wh <= 8) { + if (d >= 56) strength = 1; + } else if (blk_wh <= 12) { + if (d >= 40) strength = 1; + } else if (blk_wh <= 16) { + if (d >= 40) strength = 1; + } else if (blk_wh <= 24) { + if (d >= 8) strength = 1; + if (d >= 16) strength = 2; + if (d >= 32) strength = 3; + } else if (blk_wh <= 32) { + if (d >= 1) strength = 1; + if (d >= 4) strength = 2; + if (d >= 32) strength = 3; + } else { + if (d >= 1) strength = 3; + } + } else { + if (blk_wh <= 8) { + if (d >= 40) strength = 1; + if (d >= 64) strength = 2; + } else if (blk_wh <= 16) { + if (d >= 20) strength = 1; + if (d >= 48) strength = 2; + } else if (blk_wh <= 24) { + if (d >= 4) strength = 3; + } else { + if (d >= 1) strength = 3; + } + } + + return strength; +} + +static void filter_edge(pixel *const out, const int sz, + const pixel *const in, const int from, const int to, + const unsigned strength) +{ + const uint8_t kernel[3][5] = { + { 0, 4, 8, 4, 0 }, + { 0, 5, 6, 5, 0 }, + { 2, 4, 4, 4, 2 } + }; + + assert(strength > 0); + for (int i = 0; i < sz; i++) { + int s = 0; + for (int j = 0; j < 5; j++) + s += in[iclip(i - 2 + j, from, to - 1)] * kernel[strength - 1][j]; + out[i] = (s + 8) >> 4; + } +} + +static int get_upsample(const int blk_wh, const unsigned d, const int type) { + if (d >= 40) return 0; + return type ? (blk_wh <= 8) : (blk_wh <= 16); +} + +static void upsample_edge(pixel *const out, const int hsz, + const pixel *const in, const int from, const int to) +{ + const int8_t kernel[4] = { -1, 9, 9, -1 }; + int i; + for (i = 0; i < hsz - 1; i++) { + out[i * 2] = in[iclip(i, from, to - 1)]; + + int s = 0; + for (int j = 0; j < 4; j++) + s += in[iclip(i + j - 1, from, to - 1)] * kernel[j]; + out[i * 2 + 1] = iclip_pixel((s + 8) >> 4); + } + out[i * 2] = in[iclip(i, from, to - 1)]; +} + +static __attribute__((noinline)) void +z1_c(pixel *dst, const ptrdiff_t stride, const pixel *const topleft_in, + int angle, const int width, const int height) +{ + const int is_sm = angle >> 9; + angle &= 511; + assert(angle < 90); + const int dx = dr_intra_derivative[angle]; + pixel top_out[(width + height) * 2]; + const pixel *top; + int max_base_x; + const int upsample_above = get_upsample(width + height, 90 - angle, is_sm); + if (upsample_above) { + upsample_edge(top_out, width + height, + &topleft_in[1], -1, width + imin(width, height)); + top = top_out; + max_base_x = 2 * (width + height) - 2; + } else { + const int filter_strength = + get_filter_strength(width + height, 90 - angle, is_sm); + + if (filter_strength) { + filter_edge(top_out, width + height, + &topleft_in[1], -1, width + imin(width, height), + filter_strength); + top = top_out; + max_base_x = width + height - 1; + } else { + top = &topleft_in[1]; + max_base_x = width + imin(width, height) - 1; + } + } + const int frac_bits = 6 - upsample_above; + const int base_inc = 1 << upsample_above; + for (int y = 0, xpos = dx; y < height; + y++, dst += PXSTRIDE(stride), xpos += dx) + { + int base = xpos >> frac_bits; + const int frac = ((xpos << upsample_above) & 0x3F) >> 1; + + for (int x = 0; x < width; x++, base += base_inc) { + if (base < max_base_x) { + const int v = top[base] * (32 - frac) + top[base + 1] * frac; + dst[x] = iclip_pixel((v + 16) >> 5); + } else { + pixel_set(&dst[x], top[max_base_x], width - x); + break; + } + } + } +} + +#define z1_lfn(width, height) \ +static void z1_##width##x##height##_c(pixel *dst, const ptrdiff_t stride, \ + const pixel *const topleft, \ + const int angle) \ +{ \ + z1_c(dst, stride, topleft, angle, width, height); \ +} + +sz_grid(z1_lfn); + +static __attribute__((noinline)) void +z2_c(pixel *dst, const ptrdiff_t stride, const pixel *const topleft_in, + int angle, const int width, const int height) +{ + const int is_sm = angle >> 9; + angle &= 511; + assert(angle > 90 && angle < 180); + const int dy = dr_intra_derivative[angle - 90]; + const int dx = dr_intra_derivative[180 - angle]; + const int upsample_left = get_upsample(width + height, 180 - angle, is_sm); + const int upsample_above = get_upsample(width + height, angle - 90, is_sm); + pixel edge[width * 2 + height * 2 + 1]; + pixel *const topleft = &edge[height * 2]; + + if (upsample_above) { + upsample_edge(topleft, width + 1, topleft_in, 0, width + 1); + } else { + const int filter_strength = + get_filter_strength(width + height, angle - 90, is_sm); + + if (filter_strength) { + filter_edge(&topleft[1], width, &topleft_in[1], -1, width, + filter_strength); + } else { + pixel_copy(&topleft[1], &topleft_in[1], width); + } + } + if (upsample_left) { + upsample_edge(edge, height + 1, &topleft_in[-height], 0, height + 1); + } else { + const int filter_strength = + get_filter_strength(width + height, 180 - angle, is_sm); + + if (filter_strength) { + filter_edge(&topleft[-height], height, &topleft_in[-height], + 0, height + 1, filter_strength); + } else { + pixel_copy(&topleft[-height], &topleft_in[-height], height); + } + } + *topleft = *topleft_in; + + const int min_base_x = -(1 << upsample_above); + const int frac_bits_y = 6 - upsample_left, frac_bits_x = 6 - upsample_above; + const int base_inc_x = 1 << upsample_above; + const pixel *const left = &topleft[-(1 << upsample_left)]; + const pixel *const top = &topleft[1 << upsample_above]; + for (int y = 0, xpos = -dx; y < height; + y++, xpos -= dx, dst += PXSTRIDE(stride)) + { + int base_x = xpos >> frac_bits_x; + const int frac_x = ((xpos * (1 << upsample_above)) & 0x3F) >> 1; + + for (int x = 0, ypos = (y << 6) - dy; x < width; + x++, base_x += base_inc_x, ypos -= dy) + { + int v; + + if (base_x >= min_base_x) { + v = top[base_x] * (32 - frac_x) + top[base_x + 1] * frac_x; + } else { + const int base_y = ypos >> frac_bits_y; + assert(base_y >= -(1 << upsample_left)); + const int frac_y = ((ypos * (1 << upsample_left)) & 0x3F) >> 1; + v = left[-base_y] * (32 - frac_y) + left[-(base_y + 1)] * frac_y; + } + dst[x] = iclip_pixel((v + 16) >> 5); + } + } +} + +#define z2_lfn(width, height) \ +static void z2_##width##x##height##_c(pixel *dst, const ptrdiff_t stride, \ + const pixel *const topleft, \ + const int angle) \ +{ \ + z2_c(dst, stride, topleft, angle, width, height); \ +} + +sz_grid(z2_lfn); + +static __attribute__((noinline)) void +z3_c(pixel *dst, const ptrdiff_t stride, const pixel *const topleft_in, + int angle, const int width, const int height) +{ + const int is_sm = angle >> 9; + angle &= 511; + assert(angle > 180); + const int dy = dr_intra_derivative[270 - angle]; + pixel left_out[(width + height) * 2]; + const pixel *left; + int max_base_y; + const int upsample_left = get_upsample(width + height, angle - 180, is_sm); + if (upsample_left) { + upsample_edge(left_out, width + height, + &topleft_in[-(width + height)], + imax(width - height, 0), width + height + 1); + left = &left_out[2 * (width + height) - 2]; + max_base_y = 2 * (width + height) - 2; + } else { + const int filter_strength = + get_filter_strength(width + height, angle - 180, is_sm); + + if (filter_strength) { + filter_edge(left_out, width + height, + &topleft_in[-(width + height)], + imax(width - height, 0), width + height + 1, + filter_strength); + left = &left_out[width + height - 1]; + max_base_y = width + height - 1; + } else { + left = &topleft_in[-1]; + max_base_y = height + imin(width, height) - 1; + } + } + const int frac_bits = 6 - upsample_left; + const int base_inc = 1 << upsample_left; + for (int x = 0, ypos = dy; x < width; x++, ypos += dy) { + int base = ypos >> frac_bits; + const int frac = ((ypos << upsample_left) & 0x3F) >> 1; + + for (int y = 0; y < height; y++, base += base_inc) { + if (base < max_base_y) { + const int v = left[-base] * (32 - frac) + + left[-(base + 1)] * frac; + dst[y * PXSTRIDE(stride) + x] = iclip_pixel((v + 16) >> 5); + } else { + do { + dst[y * PXSTRIDE(stride) + x] = left[-max_base_y]; + } while (++y < height); + break; + } + } + } +} + +#define z3_lfn(width, height) \ +static void z3_##width##x##height##_c(pixel *dst, const ptrdiff_t stride, \ + const pixel *const topleft, \ + const int angle) \ +{ \ + z3_c(dst, stride, topleft, angle, width, height); \ +} + +sz_grid(z3_lfn); + +static const int8_t av1_filter_intra_taps[5][8][8] = { + { + { -6, 10, 0, 0, 0, 12, 0, 0 }, + { -5, 2, 10, 0, 0, 9, 0, 0 }, + { -3, 1, 1, 10, 0, 7, 0, 0 }, + { -3, 1, 1, 2, 10, 5, 0, 0 }, + { -4, 6, 0, 0, 0, 2, 12, 0 }, + { -3, 2, 6, 0, 0, 2, 9, 0 }, + { -3, 2, 2, 6, 0, 2, 7, 0 }, + { -3, 1, 2, 2, 6, 3, 5, 0 }, + }, { + { -10, 16, 0, 0, 0, 10, 0, 0 }, + { -6, 0, 16, 0, 0, 6, 0, 0 }, + { -4, 0, 0, 16, 0, 4, 0, 0 }, + { -2, 0, 0, 0, 16, 2, 0, 0 }, + { -10, 16, 0, 0, 0, 0, 10, 0 }, + { -6, 0, 16, 0, 0, 0, 6, 0 }, + { -4, 0, 0, 16, 0, 0, 4, 0 }, + { -2, 0, 0, 0, 16, 0, 2, 0 }, + }, { + { -8, 8, 0, 0, 0, 16, 0, 0 }, + { -8, 0, 8, 0, 0, 16, 0, 0 }, + { -8, 0, 0, 8, 0, 16, 0, 0 }, + { -8, 0, 0, 0, 8, 16, 0, 0 }, + { -4, 4, 0, 0, 0, 0, 16, 0 }, + { -4, 0, 4, 0, 0, 0, 16, 0 }, + { -4, 0, 0, 4, 0, 0, 16, 0 }, + { -4, 0, 0, 0, 4, 0, 16, 0 }, + }, { + { -2, 8, 0, 0, 0, 10, 0, 0 }, + { -1, 3, 8, 0, 0, 6, 0, 0 }, + { -1, 2, 3, 8, 0, 4, 0, 0 }, + { 0, 1, 2, 3, 8, 2, 0, 0 }, + { -1, 4, 0, 0, 0, 3, 10, 0 }, + { -1, 3, 4, 0, 0, 4, 6, 0 }, + { -1, 2, 3, 4, 0, 4, 4, 0 }, + { -1, 2, 2, 3, 4, 3, 3, 0 }, + }, { + { -12, 14, 0, 0, 0, 14, 0, 0 }, + { -10, 0, 14, 0, 0, 12, 0, 0 }, + { -9, 0, 0, 14, 0, 11, 0, 0 }, + { -8, 0, 0, 0, 14, 10, 0, 0 }, + { -10, 12, 0, 0, 0, 0, 14, 0 }, + { -9, 1, 12, 0, 0, 0, 12, 0 }, + { -8, 0, 0, 12, 0, 1, 11, 0 }, + { -7, 0, 0, 1, 12, 1, 9, 0 }, + }, +}; + +static __attribute__((noinline)) void +filter_intra_c(pixel *dst, const ptrdiff_t stride, + const pixel *const topleft_in, + int filt_idx, const int width, const int height) +{ + filt_idx &= 511; + assert(filt_idx < 5); + + const int8_t (*const filter)[8] = av1_filter_intra_taps[filt_idx]; + int x, y; + ptrdiff_t left_stride; + const pixel *left, *topleft, *top; + + top = &topleft_in[1]; + for (y = 0; y < height; y += 2) { + topleft = &topleft_in[-y]; + left = &topleft[-1]; + left_stride = -1; + for (x = 0; x < width; x += 4) { + const int p0 = *topleft; + const int p1 = top[0], p2 = top[1], p3 = top[2], p4 = top[3]; + const int p5 = left[0 * left_stride], p6 = left[1 * left_stride]; + pixel *ptr = &dst[x]; + const int8_t (*flt_ptr)[8] = filter; + + for (int yy = 0; yy < 2; yy++) { + for (int xx = 0; xx < 4; xx++, flt_ptr++) { + int acc = flt_ptr[0][0] * p0 + flt_ptr[0][1] * p1 + + flt_ptr[0][2] * p2 + flt_ptr[0][3] * p3 + + flt_ptr[0][4] * p4 + flt_ptr[0][5] * p5 + + flt_ptr[0][6] * p6; + ptr[xx] = iclip_pixel((acc + 8) >> 4); + } + ptr += PXSTRIDE(stride); + } + + left = &dst[x + 4 - 1]; + left_stride = PXSTRIDE(stride); + top += 4; + topleft = &top[-1]; + } + top = &dst[PXSTRIDE(stride)]; + dst = &dst[PXSTRIDE(stride) * 2]; + } +} + +#define filter_lfn(width, height) \ +static void filter_##width##x##height##_c(pixel *const dst, \ + const ptrdiff_t stride, \ + const pixel *const topleft, \ + const int filt_idx) \ +{ \ + filter_intra_c(dst, stride, topleft, filt_idx, width, height); \ +} + +filter_lfn( 4, 4); +filter_lfn( 8, 4); +filter_lfn(16, 4); +filter_lfn( 4, 8); +filter_lfn( 8, 8); +filter_lfn(16, 8); +filter_lfn(32, 8); +filter_lfn( 4, 16); +filter_lfn( 8, 16); +filter_lfn(16, 16); +filter_lfn(32, 16); +filter_lfn( 8, 32); +filter_lfn(16, 32); +filter_lfn(32, 32); + +static __attribute__((noinline)) void +cfl_ac_c(int16_t *ac, const pixel *ypx, const ptrdiff_t stride, + const int w_pad, const int h_pad, const int width, const int height, + const int ss_hor, const int ss_ver, const int log2sz) +{ + int y, x; + int16_t *const ac_orig = ac; + + assert(w_pad >= 0 && w_pad * 4 < width); + assert(h_pad >= 0 && h_pad * 4 < height); + + for (y = 0; y < height - 4 * h_pad; y++) { + for (x = 0; x < width - 4 * w_pad; x++) { + int ac_sum = ypx[x << ss_hor]; + if (ss_hor) ac_sum += ypx[x * 2 + 1]; + if (ss_ver) { + ac_sum += ypx[(x << ss_hor) + PXSTRIDE(stride)]; + if (ss_hor) ac_sum += ypx[x * 2 + 1 + PXSTRIDE(stride)]; + } + ac[x] = ac_sum << (1 + !ss_ver + !ss_hor); + } + for (; x < width; x++) + ac[x] = ac[x - 1]; + ac += width; + ypx += PXSTRIDE(stride) << ss_ver; + } + for (; y < height; y++) { + memcpy(ac, &ac[-32], width * sizeof(*ac)); + ac += width; + } + + int sum = (1 << log2sz) >> 1; + for (ac = ac_orig, y = 0; y < height; y++) { + for (x = 0; x < width; x++) + sum += ac[x]; + ac += width; + } + sum >>= log2sz; + + // subtract DC + for (ac = ac_orig, y = 0; y < height; y++) { + for (x = 0; x < width; x++) + ac[x] -= sum; + ac += width; + } +} + +#define cfl_ac_fn(lw, lh, cw, ch, ss_hor, ss_ver, log2sz) \ +static void cfl_ac_##lw##x##lh##_to_##cw##x##ch##_c(int16_t *const ac, \ + const pixel *const ypx, \ + const ptrdiff_t stride, \ + const int w_pad, \ + const int h_pad) \ +{ \ + cfl_ac_c(ac, ypx, stride, w_pad, h_pad, cw, ch, ss_hor, ss_ver, log2sz); \ +} + +cfl_ac_fn( 8, 8, 4, 4, 1, 1, 4); +cfl_ac_fn( 8, 16, 4, 8, 1, 1, 5); +cfl_ac_fn( 8, 32, 4, 16, 1, 1, 6); +cfl_ac_fn(16, 8, 8, 4, 1, 1, 5); +cfl_ac_fn(16, 16, 8, 8, 1, 1, 6); +cfl_ac_fn(16, 32, 8, 16, 1, 1, 7); +cfl_ac_fn(32, 8, 16, 4, 1, 1, 6); +cfl_ac_fn(32, 16, 16, 8, 1, 1, 7); +cfl_ac_fn(32, 32, 16, 16, 1, 1, 8); + +cfl_ac_fn( 8, 4, 4, 4, 1, 0, 4); +cfl_ac_fn( 8, 8, 4, 8, 1, 0, 5); +cfl_ac_fn(16, 4, 8, 4, 1, 0, 5); +cfl_ac_fn(16, 8, 8, 8, 1, 0, 6); +cfl_ac_fn(16, 16, 8, 16, 1, 0, 7); +cfl_ac_fn(32, 8, 16, 8, 1, 0, 7); +cfl_ac_fn(32, 16, 16, 16, 1, 0, 8); +cfl_ac_fn(32, 32, 16, 32, 1, 0, 9); + +cfl_ac_fn( 4, 4, 4, 4, 0, 0, 4); +cfl_ac_fn( 4, 8, 4, 8, 0, 0, 5); +cfl_ac_fn( 4, 16, 4, 16, 0, 0, 6); +cfl_ac_fn( 8, 4, 8, 4, 0, 0, 5); +cfl_ac_fn( 8, 8, 8, 8, 0, 0, 6); +cfl_ac_fn( 8, 16, 8, 16, 0, 0, 7); +cfl_ac_fn( 8, 32, 8, 32, 0, 0, 8); +cfl_ac_fn(16, 4, 16, 4, 0, 0, 6); +cfl_ac_fn(16, 8, 16, 8, 0, 0, 7); +cfl_ac_fn(16, 16, 16, 16, 0, 0, 8); +cfl_ac_fn(16, 32, 16, 32, 0, 0, 9); +cfl_ac_fn(32, 8, 32, 8, 0, 0, 8); +cfl_ac_fn(32, 16, 32, 16, 0, 0, 9); +cfl_ac_fn(32, 32, 32, 32, 0, 0, 10); + +static __attribute__((noinline)) void +cfl_pred_c(pixel *dstU, pixel *dstV, const ptrdiff_t stride, + const int16_t *ac, const pixel *const dc_pred, + const int8_t *const alphas, const int width, const int height) +{ + for (int y = 0; y < height; y++) { + for (int x = 0; x < width; x++) { + const int diff1 = alphas[0] * ac[x]; + dstU[x] = iclip_pixel(dc_pred[ 0] + apply_sign((abs(diff1) + 32) >> 6, + diff1)); + const int diff2 = alphas[1] * ac[x]; + dstV[x] = iclip_pixel(dc_pred[32] + apply_sign((abs(diff2) + 32) >> 6, + diff2)); + } + ac += width; + dstU += PXSTRIDE(stride); + dstV += PXSTRIDE(stride); + } +} + +#define cfl_pred_fn(width) \ +static void cfl_pred_##width##xN_c(pixel *const dstU, \ + pixel *const dstV, \ + const ptrdiff_t stride, \ + const int16_t *const ac, \ + const pixel *const dc_pred, \ + const int8_t *const alphas, \ + const int height) \ +{ \ + cfl_pred_c(dstU, dstV, stride, ac, dc_pred, alphas, width, height); \ +} + +cfl_pred_fn( 4); +cfl_pred_fn( 8); +cfl_pred_fn(16); +cfl_pred_fn(32); + +static void pal_pred_c(pixel *dst, const ptrdiff_t stride, + const uint16_t *const pal, const uint8_t *idx, + const int w, const int h) +{ + for (int y = 0; y < h; y++) { + for (int x = 0; x < w; x++) + dst[x] = pal[idx[x]]; + idx += w; + dst += PXSTRIDE(stride); + } +} + +void bitfn(dav1d_intra_pred_dsp_init)(Dav1dIntraPredDSPContext *const c) { +#define assign_lfn(w, h, p1, p2, pfx) \ + c->intra_pred[pfx##TX_##w##X##h][p1##_PRED] = p2##_##w##x##h##_c +#define assign_fns(p1, p2) \ + assign_lfn( 4, 4, p1, p2,); \ + assign_lfn( 4, 8, p1, p2, R); \ + assign_lfn( 4, 16, p1, p2, R); \ + assign_lfn( 8, 4, p1, p2, R); \ + assign_lfn( 8, 8, p1, p2,); \ + assign_lfn( 8, 16, p1, p2, R); \ + assign_lfn( 8, 32, p1, p2, R); \ + assign_lfn(16, 4, p1, p2, R); \ + assign_lfn(16, 8, p1, p2, R); \ + assign_lfn(16, 16, p1, p2,); \ + assign_lfn(16, 32, p1, p2, R); \ + assign_lfn(16, 64, p1, p2, R); \ + assign_lfn(32, 8, p1, p2, R); \ + assign_lfn(32, 16, p1, p2, R); \ + assign_lfn(32, 32, p1, p2,); \ + assign_lfn(32, 64, p1, p2, R); \ + assign_lfn(64, 16, p1, p2, R); \ + assign_lfn(64, 32, p1, p2, R); \ + assign_lfn(64, 64, p1, p2,); \ + + assign_fns(DC, dc); + assign_fns(DC_128, dc128); + assign_fns(TOP_DC, dctop); + assign_fns(LEFT_DC, dcleft); + assign_fns(HOR, h); + assign_fns(VERT, v); + assign_fns(PAETH, paeth); + assign_fns(SMOOTH, smooth); + assign_fns(SMOOTH_V, smooth_v); + assign_fns(SMOOTH_H, smooth_h); + assign_fns(Z1, z1); + assign_fns(Z2, z2); + assign_fns(Z3, z3); + + assign_lfn( 4, 4, FILTER, filter,); + assign_lfn( 8, 4, FILTER, filter, R); + assign_lfn(16, 4, FILTER, filter, R); + assign_lfn( 4, 8, FILTER, filter, R); + assign_lfn( 8, 8, FILTER, filter,); + assign_lfn(16, 8, FILTER, filter, R); + assign_lfn(32, 8, FILTER, filter, R); + assign_lfn( 4, 16, FILTER, filter, R); + assign_lfn( 8, 16, FILTER, filter, R); + assign_lfn(16, 16, FILTER, filter,); + assign_lfn(32, 16, FILTER, filter, R); + assign_lfn( 8, 32, FILTER, filter, R); + assign_lfn(16, 32, FILTER, filter, R); + assign_lfn(32, 32, FILTER, filter,); + + // cfl functions are split per chroma subsampling type + c->cfl_ac[DAV1D_PIXEL_LAYOUT_I420 - 1][ TX_4X4 ] = cfl_ac_8x8_to_4x4_c; + c->cfl_ac[DAV1D_PIXEL_LAYOUT_I420 - 1][RTX_4X8 ] = cfl_ac_8x16_to_4x8_c; + c->cfl_ac[DAV1D_PIXEL_LAYOUT_I420 - 1][RTX_4X16 ] = cfl_ac_8x32_to_4x16_c; + c->cfl_ac[DAV1D_PIXEL_LAYOUT_I420 - 1][RTX_8X4 ] = cfl_ac_16x8_to_8x4_c; + c->cfl_ac[DAV1D_PIXEL_LAYOUT_I420 - 1][ TX_8X8 ] = cfl_ac_16x16_to_8x8_c; + c->cfl_ac[DAV1D_PIXEL_LAYOUT_I420 - 1][RTX_8X16 ] = cfl_ac_16x32_to_8x16_c; + c->cfl_ac[DAV1D_PIXEL_LAYOUT_I420 - 1][RTX_16X4 ] = cfl_ac_32x8_to_16x4_c; + c->cfl_ac[DAV1D_PIXEL_LAYOUT_I420 - 1][RTX_16X8 ] = cfl_ac_32x16_to_16x8_c; + c->cfl_ac[DAV1D_PIXEL_LAYOUT_I420 - 1][ TX_16X16] = cfl_ac_32x32_to_16x16_c; + + c->cfl_ac[DAV1D_PIXEL_LAYOUT_I422 - 1][ TX_4X4 ] = cfl_ac_8x4_to_4x4_c; + c->cfl_ac[DAV1D_PIXEL_LAYOUT_I422 - 1][RTX_4X8 ] = cfl_ac_8x8_to_4x8_c; + c->cfl_ac[DAV1D_PIXEL_LAYOUT_I422 - 1][RTX_8X4 ] = cfl_ac_16x4_to_8x4_c; + c->cfl_ac[DAV1D_PIXEL_LAYOUT_I422 - 1][ TX_8X8 ] = cfl_ac_16x8_to_8x8_c; + c->cfl_ac[DAV1D_PIXEL_LAYOUT_I422 - 1][RTX_8X16] = cfl_ac_16x16_to_8x16_c; + c->cfl_ac[DAV1D_PIXEL_LAYOUT_I422 - 1][RTX_16X8 ] = cfl_ac_32x8_to_16x8_c; + c->cfl_ac[DAV1D_PIXEL_LAYOUT_I422 - 1][ TX_16X16] = cfl_ac_32x16_to_16x16_c; + c->cfl_ac[DAV1D_PIXEL_LAYOUT_I422 - 1][RTX_16X32] = cfl_ac_32x32_to_16x32_c; + + c->cfl_ac[DAV1D_PIXEL_LAYOUT_I444 - 1][ TX_4X4 ] = cfl_ac_4x4_to_4x4_c; + c->cfl_ac[DAV1D_PIXEL_LAYOUT_I444 - 1][RTX_4X8 ] = cfl_ac_4x8_to_4x8_c; + c->cfl_ac[DAV1D_PIXEL_LAYOUT_I444 - 1][RTX_4X16 ] = cfl_ac_4x16_to_4x16_c; + c->cfl_ac[DAV1D_PIXEL_LAYOUT_I444 - 1][RTX_8X4 ] = cfl_ac_8x4_to_8x4_c; + c->cfl_ac[DAV1D_PIXEL_LAYOUT_I444 - 1][ TX_8X8 ] = cfl_ac_8x8_to_8x8_c; + c->cfl_ac[DAV1D_PIXEL_LAYOUT_I444 - 1][RTX_8X16 ] = cfl_ac_8x16_to_8x16_c; + c->cfl_ac[DAV1D_PIXEL_LAYOUT_I444 - 1][RTX_8X32 ] = cfl_ac_8x32_to_8x32_c; + c->cfl_ac[DAV1D_PIXEL_LAYOUT_I444 - 1][RTX_16X4 ] = cfl_ac_16x4_to_16x4_c; + c->cfl_ac[DAV1D_PIXEL_LAYOUT_I444 - 1][RTX_16X8 ] = cfl_ac_16x8_to_16x8_c; + c->cfl_ac[DAV1D_PIXEL_LAYOUT_I444 - 1][ TX_16X16] = cfl_ac_16x16_to_16x16_c; + c->cfl_ac[DAV1D_PIXEL_LAYOUT_I444 - 1][RTX_16X32] = cfl_ac_16x32_to_16x32_c; + c->cfl_ac[DAV1D_PIXEL_LAYOUT_I444 - 1][RTX_32X8 ] = cfl_ac_32x8_to_32x8_c; + c->cfl_ac[DAV1D_PIXEL_LAYOUT_I444 - 1][RTX_32X16] = cfl_ac_32x16_to_32x16_c; + c->cfl_ac[DAV1D_PIXEL_LAYOUT_I444 - 1][ TX_32X32] = cfl_ac_32x32_to_32x32_c; + + c->cfl_pred[0] = cfl_pred_4xN_c; + c->cfl_pred[1] = cfl_pred_8xN_c; + c->cfl_pred[2] = cfl_pred_16xN_c; + c->cfl_pred[3] = cfl_pred_32xN_c; + + c->pal_pred = pal_pred_c; +} diff --git a/src/ipred.h b/src/ipred.h new file mode 100644 index 0000000..4e6c312 --- /dev/null +++ b/src/ipred.h @@ -0,0 +1,92 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_SRC_IPRED_H__ +#define __DAV1D_SRC_IPRED_H__ + +#include "common/bitdepth.h" + +#include "src/levels.h" + +/* + * Intra prediction. + * - a is the angle (in degrees) for directional intra predictors. For other + * modes, it is ignored; + * - topleft is the same as the argument given to dav1d_prepare_intra_edges(), + * see ipred_prepare.h for more detailed documentation. + */ +#define decl_angular_ipred_fn(name) \ +void (name)(pixel *dst, ptrdiff_t stride, const pixel *topleft, int angle); +typedef decl_angular_ipred_fn(*angular_ipred_fn); + +/* + * Create a subsampled Y plane with the DC subtracted. + * - w/h_pad is the edge of the width/height that extends outside the visible + * portion of the frame in 4px units; + * - ac has a stride of 16. + */ +#define decl_cfl_ac_fn(name) \ +void (name)(int16_t *ac, const pixel *y, ptrdiff_t stride, \ + int w_pad, int h_pad) +typedef decl_cfl_ac_fn(*cfl_ac_fn); + +/* + * dst[plane][x,y] = dc[plane] + alpha[plane] * ac[x,y] + * - alphas contains two q3 scalars (one for each plane) in [-16,16] range; + * - dc_pred[] is the first line of each plane's DC prediction, the second plane + * starting at an offset of 16 * sizeof(pixel) bytes. + */ +#define decl_cfl_pred_fn(name) \ +void (name)(pixel *u_dst, pixel *v_dst, ptrdiff_t stride, \ + const int16_t *ac, const pixel *dc_pred, \ + const int8_t *const alphas, const int height) +typedef decl_cfl_pred_fn(*cfl_pred_fn); + +/* + * dst[x,y] = pal[idx[x,y]] + * - palette indices are [0-7] + */ +#define decl_pal_pred_fn(name) \ +void (name)(pixel *dst, ptrdiff_t stride, const uint16_t *pal, \ + const uint8_t *idx, const int w, const int h) +typedef decl_pal_pred_fn(*pal_pred_fn); + +typedef struct Dav1dIntraPredDSPContext { + angular_ipred_fn intra_pred[N_RECT_TX_SIZES][N_IMPL_INTRA_PRED_MODES]; + + // chroma-from-luma + cfl_ac_fn cfl_ac[3 /* 420, 422, 444 */][N_RECT_TX_SIZES /* chroma tx size */]; + cfl_pred_fn cfl_pred[4]; + + // palette + pal_pred_fn pal_pred; +} Dav1dIntraPredDSPContext; + +void dav1d_intra_pred_dsp_init_8bpc(Dav1dIntraPredDSPContext *c); +void dav1d_intra_pred_dsp_init_10bpc(Dav1dIntraPredDSPContext *c); + +#endif /* __DAV1D_SRC_IPRED_H__ */ diff --git a/src/ipred_prepare.c b/src/ipred_prepare.c new file mode 100644 index 0000000..d7c3c51 --- /dev/null +++ b/src/ipred_prepare.c @@ -0,0 +1,209 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <assert.h> +#include <stdint.h> +#include <string.h> + +#include "common/intops.h" + +#include "src/ipred_prepare.h" + +static const uint8_t av1_mode_conv[N_INTRA_PRED_MODES] + [2 /* have_left */][2 /* have_top */] = +{ + [DC_PRED] = { { DC_128_PRED, TOP_DC_PRED }, + { LEFT_DC_PRED, DC_PRED } }, + [PAETH_PRED] = { { DC_128_PRED, VERT_PRED }, + { HOR_PRED, PAETH_PRED } }, +}; + +static const uint8_t av1_mode_to_angle_map[8] = { + 90, 180, 45, 135, 113, 157, 203, 67 +}; + +static const struct { + uint8_t needs_left:1; + uint8_t needs_top:1; + uint8_t needs_topleft:1; + uint8_t needs_topright:1; + uint8_t needs_bottomleft:1; +} av1_intra_prediction_edges[N_IMPL_INTRA_PRED_MODES] = { + [DC_PRED] = { .needs_top = 1, .needs_left = 1 }, + [VERT_PRED] = { .needs_top = 1 }, + [HOR_PRED] = { .needs_left = 1 }, + [LEFT_DC_PRED] = { .needs_left = 1 }, + [TOP_DC_PRED] = { .needs_top = 1 }, + [DC_128_PRED] = { 0 }, + [Z1_PRED] = { .needs_top = 1, .needs_topright = 1, + .needs_topleft = 1 }, + [Z2_PRED] = { .needs_left = 1, .needs_top = 1, .needs_topleft = 1 }, + [Z3_PRED] = { .needs_left = 1, .needs_bottomleft = 1, + .needs_topleft = 1 }, + [SMOOTH_PRED] = { .needs_left = 1, .needs_top = 1 }, + [SMOOTH_V_PRED] = { .needs_left = 1, .needs_top = 1 }, + [SMOOTH_H_PRED] = { .needs_left = 1, .needs_top = 1 }, + [PAETH_PRED] = { .needs_left = 1, .needs_top = 1, .needs_topleft = 1 }, + [FILTER_PRED] = { .needs_left = 1, .needs_top = 1, .needs_topleft = 1 }, +}; + +enum IntraPredMode +bytefn(prepare_intra_edges)(const int x, const int have_left, + const int y, const int have_top, + const int w, const int h, + const enum EdgeFlags edge_flags, + const pixel *const dst, + const ptrdiff_t stride, + const pixel *prefilter_toplevel_sb_edge, + enum IntraPredMode mode, int *const angle, + const int tw, const int th, + pixel *const topleft_out) +{ + assert(y < h && x < w); + + switch (mode) { + case VERT_PRED: + case HOR_PRED: + case DIAG_DOWN_LEFT_PRED: + case DIAG_DOWN_RIGHT_PRED: + case VERT_RIGHT_PRED: + case HOR_DOWN_PRED: + case HOR_UP_PRED: + case VERT_LEFT_PRED: { + *angle = av1_mode_to_angle_map[mode - VERT_PRED] + 3 * *angle; + + if (*angle < 90) { + mode = have_top ? Z1_PRED : VERT_PRED; + } else if (*angle == 90) { + mode = VERT_PRED; + } else if (*angle < 180) { + mode = Z2_PRED; + } else if (*angle == 180) { + mode = HOR_PRED; + } else { + mode = have_left ? Z3_PRED : HOR_PRED; + } + break; + } + case DC_PRED: + case PAETH_PRED: + mode = av1_mode_conv[mode][have_left][have_top]; + break; + default: + break; + } + + const pixel *dst_top; + if (have_top && + (av1_intra_prediction_edges[mode].needs_top || + av1_intra_prediction_edges[mode].needs_topleft || + (av1_intra_prediction_edges[mode].needs_left && !have_left))) + { + if (prefilter_toplevel_sb_edge) { + dst_top = &prefilter_toplevel_sb_edge[x * 4]; + } else { + dst_top = &dst[-PXSTRIDE(stride)]; + } + } + + if (av1_intra_prediction_edges[mode].needs_left) { + const int sz = th << 2; + pixel *const left = &topleft_out[-sz]; + + if (have_left) { + const int px_have = imin(sz, (h - y) << 2); + + for (int i = 0; i < px_have; i++) + left[sz - 1 - i] = dst[PXSTRIDE(stride) * i - 1]; + if (px_have < sz) + pixel_set(left, left[sz - px_have], sz - px_have); + } else { + pixel_set(left, have_top ? *dst_top : ((1 << BITDEPTH) >> 1) + 1, sz); + } + + if (av1_intra_prediction_edges[mode].needs_bottomleft) { + const int have_bottomleft = (!have_left || y + th >= h) ? 0 : + (edge_flags & EDGE_I444_LEFT_HAS_BOTTOM); + + if (have_bottomleft) { + const int px_have = imin(sz, (h - y - th) << 2); + + for (int i = 0; i < px_have; i++) + left[-(i + 1)] = dst[(sz + i) * PXSTRIDE(stride) - 1]; + if (px_have < sz) + pixel_set(left - sz, left[-px_have], sz - px_have); + } else { + pixel_set(left - sz, left[0], sz); + } + } + } + + if (av1_intra_prediction_edges[mode].needs_top) { + const int sz = tw << 2; + pixel *const top = &topleft_out[1]; + + if (have_top) { + const int px_have = imin(sz, (w - x) << 2); + pixel_copy(top, dst_top, px_have); + if (px_have < sz) + pixel_set(top + px_have, top[px_have - 1], sz - px_have); + } else { + pixel_set(top, have_left ? dst[-1] : ((1 << BITDEPTH) >> 1) - 1, sz); + } + + if (av1_intra_prediction_edges[mode].needs_topright) { + const int have_topright = (!have_top || x + tw >= w) ? 0 : + (edge_flags & EDGE_I444_TOP_HAS_RIGHT); + + if (have_topright) { + const int px_have = imin(sz, (w - x - tw) << 2); + + pixel_copy(top + sz, &dst_top[sz], px_have); + if (px_have < sz) + pixel_set(top + sz + px_have, top[sz + px_have - 1], + sz - px_have); + } else { + pixel_set(top + sz, top[sz - 1], sz); + } + } + } + + if (av1_intra_prediction_edges[mode].needs_topleft) { + if (have_left) { + *topleft_out = have_top ? dst_top[-1] : dst[-1]; + } else { + *topleft_out = have_top ? *dst_top : (1 << BITDEPTH) >> 1; + } + if (mode == Z2_PRED && tw + th >= 6) + *topleft_out = (topleft_out[-1] * 5 + topleft_out[0] * 6 + + topleft_out[1] * 5 + 8) >> 4; + } + + return mode; +} diff --git a/src/ipred_prepare.h b/src/ipred_prepare.h new file mode 100644 index 0000000..7552be1 --- /dev/null +++ b/src/ipred_prepare.h @@ -0,0 +1,102 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_SRC_IPRED_PREPARE_H__ +#define __DAV1D_SRC_IPRED_PREPARE_H__ + +#include <stddef.h> +#include <stdint.h> + +#include "common/bitdepth.h" + +#include "src/env.h" +#include "src/intra_edge.h" +#include "src/levels.h" + +/* + * Luma intra edge preparation. + * + * x/y/start/w/h are in luma block (4px) units: + * - x and y are the absolute block positions in the image; + * - start/w/h are the *dependent tile* boundary positions. In practice, start + * is the horizontal tile start, w is the horizontal tile end, the vertical + * tile start is assumed to be 0 and h is the vertical image end. + * + * edge_flags signals which edges are available for this transform-block inside + * the given partition, as well as for the partition inside the superblock + * structure. + * + * dst and stride are pointers to the top/left position of the current block, + * and can be used to locate the top, left, top/left, top/right and bottom/left + * edge pointers also. + * + * angle is the angle_delta [-3..3] on input, and the absolute angle on output. + * + * mode is the intra prediction mode as coded in the bitstream. The return value + * is this same mode, converted to an index in the DSP functions. + * + * tw/th are the size of the transform block in block (4px) units. + * + * topleft_out is a pointer to scratch memory that will be filled with the edge + * pixels. The memory array should have space to be indexed in the [-2*w,2*w] + * range, in the following order: + * - [0] will be the top/left edge pixel; + * - [1..w] will be the top edge pixels (1 being left-most, w being right-most); + * - [w+1..w*w] will be the top/right edge pixels; + * - [-1..-w] will be the left edge pixels (-1 being top-most, -w being bottom- + * most); + * - [-w-1..-2*w] will be the bottom/left edge pixels. + * Each edge may remain uninitialized if it is not used by the returned mode + * index. If edges are not available (because the edge position is outside the + * tile dimensions or because edge_flags indicates lack of edge availability), + * they will be extended from nearby edges as defined by the av1 spec. + */ +enum IntraPredMode + bytefn(prepare_intra_edges)(int x, int have_left, int y, int have_top, + int w, int h, enum EdgeFlags edge_flags, + const pixel *dst, ptrdiff_t stride, + const pixel *prefilter_toplevel_sb_edge, + enum IntraPredMode mode, int *angle, + int tw, int th, pixel *topleft_out); + +// is or'ed with the angle argument into intra predictors to signal that edges +// are smooth and should use reduced filter strength +#define ANGLE_SMOOTH_EDGE_FLAG 512 +static inline int sm_flag(const BlockContext *const b, const int idx) { + if (!b->intra[idx]) return 0; + const enum IntraPredMode m = b->mode[idx]; + return (m == SMOOTH_PRED || m == SMOOTH_H_PRED || + m == SMOOTH_V_PRED) ? ANGLE_SMOOTH_EDGE_FLAG : 0; +} + +static inline int sm_uv_flag(const BlockContext *const b, const int idx) { + const enum IntraPredMode m = b->uvmode[idx]; + return (m == SMOOTH_PRED || m == SMOOTH_H_PRED || + m == SMOOTH_V_PRED) ? ANGLE_SMOOTH_EDGE_FLAG : 0; +} + +#endif /* __DAV1D_SRC_IPRED_PREPARE_H__ */ diff --git a/src/itx.c b/src/itx.c new file mode 100644 index 0000000..730e790 --- /dev/null +++ b/src/itx.c @@ -0,0 +1,224 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <assert.h> +#include <stddef.h> +#include <stdint.h> +#include <string.h> + +#include "common/intops.h" + +#include "src/itx.h" + +#include "src/itx_1d.c" + +typedef void (*itx_1d_fn)(const coef *in, ptrdiff_t in_s, + coef *out, ptrdiff_t out_s); + +static void __attribute__((noinline)) +inv_txfm_add_c(pixel *dst, const ptrdiff_t stride, + coef *const coeff, const int eob, + const int w, const int h, const int shift1, const int shift2, + const itx_1d_fn first_1d_fn, const itx_1d_fn second_1d_fn) +{ + int i, j; + const ptrdiff_t sh = imin(h, 32), sw = imin(w, 32); + coef tmp[w * h], out[h], in_mem[w]; + const int is_rect2 = w * 2 == h || h * 2 == w; + + if (w != sw) memset(&in_mem[sw], 0, (w - sw) * sizeof(*in_mem)); + const int rnd1 = (1 << shift1) >> 1; + for (i = 0; i < sh; i++) { + if (w != sw || is_rect2) { + for (j = 0; j < sw; j++) { + in_mem[j] = coeff[i + j * sh]; + if (is_rect2) + in_mem[j] = (in_mem[j] * 2896 + 2048) >> 12; + } + first_1d_fn(in_mem, 1, &tmp[i * w], 1); + } else { + first_1d_fn(&coeff[i], sh, &tmp[i * w], 1); + } + for (j = 0; j < w; j++) + tmp[i * w + j] = (tmp[i * w + j] + (rnd1)) >> shift1; + } + + if (h != sh) memset(&tmp[sh * w], 0, w * (h - sh) * sizeof(*tmp)); + const int rnd2 = (1 << shift2) >> 1; + for (i = 0; i < w; i++) { + second_1d_fn(&tmp[i], w, out, 1); + for (j = 0; j < h; j++) + dst[i + j * PXSTRIDE(stride)] = + iclip_pixel(dst[i + j * PXSTRIDE(stride)] + + ((out[j] + (rnd2)) >> shift2)); + } + memset(coeff, 0, sizeof(*coeff) * sh * sw); +} + +#define inv_txfm_fn(type1, type2, w, h, shift1, shift2) \ +static void \ +inv_txfm_add_##type1##_##type2##_##w##x##h##_c(pixel *dst, \ + const ptrdiff_t stride, \ + coef *const coeff, \ + const int eob) \ +{ \ + inv_txfm_add_c(dst, stride, coeff, eob, w, h, shift1, shift2, \ + inv_##type1##w##_1d, inv_##type2##h##_1d); \ +} + +#define inv_txfm_fn64(w, h, shift1, shift2) \ +inv_txfm_fn(dct, dct, w, h, shift1, shift2) + +#define inv_txfm_fn32(w, h, shift1, shift2) \ +inv_txfm_fn64(w, h, shift1, shift2); \ +inv_txfm_fn(identity, identity, w, h, shift1, shift2) + +#define inv_txfm_fn16(w, h, shift1, shift2) \ +inv_txfm_fn32(w, h, shift1, shift2); \ +inv_txfm_fn(adst, dct, w, h, shift1, shift2); \ +inv_txfm_fn(dct, adst, w, h, shift1, shift2); \ +inv_txfm_fn(adst, adst, w, h, shift1, shift2); \ +inv_txfm_fn(dct, flipadst, w, h, shift1, shift2); \ +inv_txfm_fn(flipadst, dct, w, h, shift1, shift2); \ +inv_txfm_fn(adst, flipadst, w, h, shift1, shift2); \ +inv_txfm_fn(flipadst, adst, w, h, shift1, shift2); \ +inv_txfm_fn(flipadst, flipadst, w, h, shift1, shift2); \ +inv_txfm_fn(identity, dct, w, h, shift1, shift2); \ +inv_txfm_fn(dct, identity, w, h, shift1, shift2); \ + +#define inv_txfm_fn84(w, h, shift1, shift2) \ +inv_txfm_fn16(w, h, shift1, shift2); \ +inv_txfm_fn(identity, flipadst, w, h, shift1, shift2); \ +inv_txfm_fn(flipadst, identity, w, h, shift1, shift2); \ +inv_txfm_fn(identity, adst, w, h, shift1, shift2); \ +inv_txfm_fn(adst, identity, w, h, shift1, shift2); \ + +inv_txfm_fn84( 4, 4, 0, 4); +inv_txfm_fn84( 4, 8, 0, 4); +inv_txfm_fn84( 4, 16, 1, 4); +inv_txfm_fn84( 8, 4, 0, 4); +inv_txfm_fn84( 8, 8, 1, 4); +inv_txfm_fn84( 8, 16, 1, 4); +inv_txfm_fn32( 8, 32, 2, 4); +inv_txfm_fn84(16, 4, 1, 4); +inv_txfm_fn84(16, 8, 1, 4); +inv_txfm_fn16(16, 16, 2, 4); +inv_txfm_fn32(16, 32, 1, 4); +inv_txfm_fn64(16, 64, 2, 4); +inv_txfm_fn32(32, 8, 2, 4); +inv_txfm_fn32(32, 16, 1, 4); +inv_txfm_fn32(32, 32, 2, 4); +inv_txfm_fn64(32, 64, 1, 4); +inv_txfm_fn64(64, 16, 2, 4); +inv_txfm_fn64(64, 32, 1, 4); +inv_txfm_fn64(64, 64, 2, 4); + +static void inv_txfm_add_wht_wht_4x4_c(pixel *dst, const ptrdiff_t stride, + coef *const coeff, const int eob) +{ + int i, j; + coef tmp[4 * 4], out[4]; + + for (i = 0; i < 4; i++) + inv_wht4_1d(&coeff[i], 4, &tmp[i * 4], 1, 0); + + for (i = 0; i < 4; i++) { + inv_wht4_1d(&tmp[i], 4, out, 1, 1); + for (j = 0; j < 4; j++) + dst[i + j * PXSTRIDE(stride)] = + iclip_pixel(dst[i + j * PXSTRIDE(stride)] + out[j]); + } + memset(coeff, 0, sizeof(*coeff) * 4 * 4); +} + +void bitfn(dav1d_itx_dsp_init)(Dav1dInvTxfmDSPContext *const c) { +#define assign_itx_all_fn64(w, h, pfx) \ + c->itxfm_add[pfx##TX_##w##X##h][DCT_DCT ] = \ + inv_txfm_add_dct_dct_##w##x##h##_c + +#define assign_itx_all_fn32(w, h, pfx) \ + assign_itx_all_fn64(w, h, pfx); \ + c->itxfm_add[pfx##TX_##w##X##h][IDTX] = \ + inv_txfm_add_identity_identity_##w##x##h##_c + +#define assign_itx_all_fn16(w, h, pfx) \ + assign_itx_all_fn32(w, h, pfx); \ + c->itxfm_add[pfx##TX_##w##X##h][DCT_ADST ] = \ + inv_txfm_add_adst_dct_##w##x##h##_c; \ + c->itxfm_add[pfx##TX_##w##X##h][ADST_DCT ] = \ + inv_txfm_add_dct_adst_##w##x##h##_c; \ + c->itxfm_add[pfx##TX_##w##X##h][ADST_ADST] = \ + inv_txfm_add_adst_adst_##w##x##h##_c; \ + c->itxfm_add[pfx##TX_##w##X##h][ADST_FLIPADST] = \ + inv_txfm_add_flipadst_adst_##w##x##h##_c; \ + c->itxfm_add[pfx##TX_##w##X##h][FLIPADST_ADST] = \ + inv_txfm_add_adst_flipadst_##w##x##h##_c; \ + c->itxfm_add[pfx##TX_##w##X##h][DCT_FLIPADST] = \ + inv_txfm_add_flipadst_dct_##w##x##h##_c; \ + c->itxfm_add[pfx##TX_##w##X##h][FLIPADST_DCT] = \ + inv_txfm_add_dct_flipadst_##w##x##h##_c; \ + c->itxfm_add[pfx##TX_##w##X##h][FLIPADST_FLIPADST] = \ + inv_txfm_add_flipadst_flipadst_##w##x##h##_c; \ + c->itxfm_add[pfx##TX_##w##X##h][H_DCT] = \ + inv_txfm_add_dct_identity_##w##x##h##_c; \ + c->itxfm_add[pfx##TX_##w##X##h][V_DCT] = \ + inv_txfm_add_identity_dct_##w##x##h##_c + +#define assign_itx_all_fn84(w, h, pfx) \ + assign_itx_all_fn16(w, h, pfx); \ + c->itxfm_add[pfx##TX_##w##X##h][H_FLIPADST] = \ + inv_txfm_add_flipadst_identity_##w##x##h##_c; \ + c->itxfm_add[pfx##TX_##w##X##h][V_FLIPADST] = \ + inv_txfm_add_identity_flipadst_##w##x##h##_c; \ + c->itxfm_add[pfx##TX_##w##X##h][H_ADST] = \ + inv_txfm_add_adst_identity_##w##x##h##_c; \ + c->itxfm_add[pfx##TX_##w##X##h][V_ADST] = \ + inv_txfm_add_identity_adst_##w##x##h##_c; \ + + c->itxfm_add[TX_4X4][WHT_WHT] = inv_txfm_add_wht_wht_4x4_c; + assign_itx_all_fn84( 4, 4, ); + assign_itx_all_fn84( 4, 8, R); + assign_itx_all_fn84( 4, 16, R); + assign_itx_all_fn84( 8, 4, R); + assign_itx_all_fn84( 8, 8, ); + assign_itx_all_fn84( 8, 16, R); + assign_itx_all_fn32( 8, 32, R); + assign_itx_all_fn84(16, 4, R); + assign_itx_all_fn84(16, 8, R); + assign_itx_all_fn16(16, 16, ); + assign_itx_all_fn32(16, 32, R); + assign_itx_all_fn64(16, 64, R); + assign_itx_all_fn32(32, 8, R); + assign_itx_all_fn32(32, 16, R); + assign_itx_all_fn32(32, 32, ); + assign_itx_all_fn64(32, 64, R); + assign_itx_all_fn64(64, 16, R); + assign_itx_all_fn64(64, 32, R); + assign_itx_all_fn64(64, 64, ); +} diff --git a/src/itx.h b/src/itx.h new file mode 100644 index 0000000..a20503b --- /dev/null +++ b/src/itx.h @@ -0,0 +1,46 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_SRC_ITX_H__ +#define __DAV1D_SRC_ITX_H__ + +#include "common/bitdepth.h" + +#include "src/levels.h" + +#define decl_itx_fn(name) \ +void (name)(pixel *dst, ptrdiff_t dst_stride, coef *coeff, int eob) +typedef decl_itx_fn(*itxfm_fn); + +typedef struct Dav1dInvTxfmDSPContext { + itxfm_fn itxfm_add[N_RECT_TX_SIZES][N_TX_TYPES_PLUS_LL]; +} Dav1dInvTxfmDSPContext; + +void dav1d_itx_dsp_init_8bpc(Dav1dInvTxfmDSPContext *c); +void dav1d_itx_dsp_init_10bpc(Dav1dInvTxfmDSPContext *c); + +#endif /* __DAV1D_SRC_ITX_H__ */ diff --git a/src/itx_1d.c b/src/itx_1d.c new file mode 100644 index 0000000..0c4547e --- /dev/null +++ b/src/itx_1d.c @@ -0,0 +1,861 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <stddef.h> +#include <stdint.h> + +static void __attribute__((noinline)) +inv_dct4_1d(const coef *const in, const ptrdiff_t in_s, + coef *const out, const ptrdiff_t out_s) +{ + const int in0 = in[0 * in_s], in1 = in[1 * in_s]; + const int in2 = in[2 * in_s], in3 = in[3 * in_s]; + + int t0 = ((in0 + in2) * 2896 + 2048) >> 12; + int t1 = ((in0 - in2) * 2896 + 2048) >> 12; + int t2 = (in1 * 1567 - in3 * 3784 + 2048) >> 12; + int t3 = (in1 * 3784 + in3 * 1567 + 2048) >> 12; + + out[0 * out_s] = t0 + t3; + out[1 * out_s] = t1 + t2; + out[2 * out_s] = t1 - t2; + out[3 * out_s] = t0 - t3; +} + +static void __attribute__((noinline)) +inv_dct8_1d(const coef *const in, const ptrdiff_t in_s, + coef *const out, const ptrdiff_t out_s) +{ + coef tmp[4]; + + inv_dct4_1d(in, in_s * 2, tmp, 1); + + const int in1 = in[1 * in_s], in3 = in[3 * in_s]; + const int in5 = in[5 * in_s], in7 = in[7 * in_s]; + + int t4a = (in1 * 799 - in7 * 4017 + 2048) >> 12; + int t5a = (in5 * 3406 - in3 * 2276 + 2048) >> 12; + int t6a = (in5 * 2276 + in3 * 3406 + 2048) >> 12; + int t7a = (in1 * 4017 + in7 * 799 + 2048) >> 12; + + int t4 = t4a + t5a; + t5a = t4a - t5a; + int t7 = t7a + t6a; + t6a = t7a - t6a; + + int t5 = ((t6a - t5a) * 2896 + 2048) >> 12; + int t6 = ((t6a + t5a) * 2896 + 2048) >> 12; + + out[0 * out_s] = tmp[0] + t7; + out[1 * out_s] = tmp[1] + t6; + out[2 * out_s] = tmp[2] + t5; + out[3 * out_s] = tmp[3] + t4; + out[4 * out_s] = tmp[3] - t4; + out[5 * out_s] = tmp[2] - t5; + out[6 * out_s] = tmp[1] - t6; + out[7 * out_s] = tmp[0] - t7; +} + +static void __attribute__((noinline)) +inv_dct16_1d(const coef *const in, const ptrdiff_t in_s, + coef *const out, const ptrdiff_t out_s) +{ + coef tmp[8]; + + inv_dct8_1d(in, in_s * 2, tmp, 1); + + const int in1 = in[ 1 * in_s], in3 = in[ 3 * in_s]; + const int in5 = in[ 5 * in_s], in7 = in[ 7 * in_s]; + const int in9 = in[ 9 * in_s], in11 = in[11 * in_s]; + const int in13 = in[13 * in_s], in15 = in[15 * in_s]; + + int t8a = (in1 * 401 - in15 * 4076 + 2048) >> 12; + int t15a = (in1 * 4076 + in15 * 401 + 2048) >> 12; + int t9a = (in9 * 3166 - in7 * 2598 + 2048) >> 12; + int t14a = (in9 * 2598 + in7 * 3166 + 2048) >> 12; + int t10a = (in5 * 1931 - in11 * 3612 + 2048) >> 12; + int t13a = (in5 * 3612 + in11 * 1931 + 2048) >> 12; + int t11a = (in13 * 3920 - in3 * 1189 + 2048) >> 12; + int t12a = (in13 * 1189 + in3 * 3920 + 2048) >> 12; + + int t8 = t8a + t9a; + int t9 = t8a - t9a; + int t10 = t11a - t10a; + int t11 = t11a + t10a; + int t12 = t12a + t13a; + int t13 = t12a - t13a; + int t14 = t15a - t14a; + int t15 = t15a + t14a; + + t9a = ( t14 * 1567 - t9 * 3784 + 2048) >> 12; + t14a = ( t14 * 3784 + t9 * 1567 + 2048) >> 12; + t10a = (-(t13 * 3784 + t10 * 1567) + 2048) >> 12; + t13a = ( t13 * 1567 - t10 * 3784 + 2048) >> 12; + + t8a = t8 + t11; + t9 = t9a + t10a; + t10 = t9a - t10a; + t11a = t8 - t11; + t12a = t15 - t12; + t13 = t14a - t13a; + t14 = t14a + t13a; + t15a = t15 + t12; + + t10a = ((t13 - t10) * 2896 + 2048) >> 12; + t13a = ((t13 + t10) * 2896 + 2048) >> 12; + t11 = ((t12a - t11a) * 2896 + 2048) >> 12; + t12 = ((t12a + t11a) * 2896 + 2048) >> 12; + + out[ 0 * out_s] = tmp[0] + t15a; + out[ 1 * out_s] = tmp[1] + t14; + out[ 2 * out_s] = tmp[2] + t13a; + out[ 3 * out_s] = tmp[3] + t12; + out[ 4 * out_s] = tmp[4] + t11; + out[ 5 * out_s] = tmp[5] + t10a; + out[ 6 * out_s] = tmp[6] + t9; + out[ 7 * out_s] = tmp[7] + t8a; + out[ 8 * out_s] = tmp[7] - t8a; + out[ 9 * out_s] = tmp[6] - t9; + out[10 * out_s] = tmp[5] - t10a; + out[11 * out_s] = tmp[4] - t11; + out[12 * out_s] = tmp[3] - t12; + out[13 * out_s] = tmp[2] - t13a; + out[14 * out_s] = tmp[1] - t14; + out[15 * out_s] = tmp[0] - t15a; +} + +static void __attribute__((noinline)) +inv_dct32_1d(const coef *const in, const ptrdiff_t in_s, + coef *const out, const ptrdiff_t out_s) +{ + coef tmp[16]; + + inv_dct16_1d(in, in_s * 2, tmp, 1); + + const int in1 = in[ 1 * in_s], in3 = in[ 3 * in_s]; + const int in5 = in[ 5 * in_s], in7 = in[ 7 * in_s]; + const int in9 = in[ 9 * in_s], in11 = in[11 * in_s]; + const int in13 = in[13 * in_s], in15 = in[15 * in_s]; + const int in17 = in[17 * in_s], in19 = in[19 * in_s]; + const int in21 = in[21 * in_s], in23 = in[23 * in_s]; + const int in25 = in[25 * in_s], in27 = in[27 * in_s]; + const int in29 = in[29 * in_s], in31 = in[31 * in_s]; + + int t16a = (in1 * 201 - in31 * 4091 + 2048) >> 12; + int t31a = (in1 * 4091 + in31 * 201 + 2048) >> 12; + int t17a = (in17 * 3035 - in15 * 2751 + 2048) >> 12; + int t30a = (in17 * 2751 + in15 * 3035 + 2048) >> 12; + int t18a = (in9 * 1751 - in23 * 3703 + 2048) >> 12; + int t29a = (in9 * 3703 + in23 * 1751 + 2048) >> 12; + int t19a = (in25 * 3857 - in7 * 1380 + 2048) >> 12; + int t28a = (in25 * 1380 + in7 * 3857 + 2048) >> 12; + int t20a = (in5 * 995 - in27 * 3973 + 2048) >> 12; + int t27a = (in5 * 3973 + in27 * 995 + 2048) >> 12; + int t21a = (in21 * 3513 - in11 * 2106 + 2048) >> 12; + int t26a = (in21 * 2106 + in11 * 3513 + 2048) >> 12; + int t22a = (in13 * 2440 - in19 * 3290 + 2048) >> 12; + int t25a = (in13 * 3290 + in19 * 2440 + 2048) >> 12; + int t23a = (in29 * 4052 - in3 * 601 + 2048) >> 12; + int t24a = (in29 * 601 + in3 * 4052 + 2048) >> 12; + + int t16 = t16a + t17a; + int t17 = t16a - t17a; + int t18 = t19a - t18a; + int t19 = t19a + t18a; + int t20 = t20a + t21a; + int t21 = t20a - t21a; + int t22 = t23a - t22a; + int t23 = t23a + t22a; + int t24 = t24a + t25a; + int t25 = t24a - t25a; + int t26 = t27a - t26a; + int t27 = t27a + t26a; + int t28 = t28a + t29a; + int t29 = t28a - t29a; + int t30 = t31a - t30a; + int t31 = t31a + t30a; + + t17a = ( t30 * 799 - t17 * 4017 + 2048) >> 12; + t30a = ( t30 * 4017 + t17 * 799 + 2048) >> 12; + t18a = (-(t29 * 4017 + t18 * 799) + 2048) >> 12; + t29a = ( t29 * 799 - t18 * 4017 + 2048) >> 12; + t21a = ( t26 * 3406 - t21 * 2276 + 2048) >> 12; + t26a = ( t26 * 2276 + t21 * 3406 + 2048) >> 12; + t22a = (-(t25 * 2276 + t22 * 3406) + 2048) >> 12; + t25a = ( t25 * 3406 - t22 * 2276 + 2048) >> 12; + + t16a = t16 + t19; + t17 = t17a + t18a; + t18 = t17a - t18a; + t19a = t16 - t19; + t20a = t23 - t20; + t21 = t22a - t21a; + t22 = t22a + t21a; + t23a = t23 + t20; + t24a = t24 + t27; + t25 = t25a + t26a; + t26 = t25a - t26a; + t27a = t24 - t27; + t28a = t31 - t28; + t29 = t30a - t29a; + t30 = t30a + t29a; + t31a = t31 + t28; + + t18a = ( t29 * 1567 - t18 * 3784 + 2048) >> 12; + t29a = ( t29 * 3784 + t18 * 1567 + 2048) >> 12; + t19 = ( t28a * 1567 - t19a * 3784 + 2048) >> 12; + t28 = ( t28a * 3784 + t19a * 1567 + 2048) >> 12; + t20 = (-(t27a * 3784 + t20a * 1567) + 2048) >> 12; + t27 = ( t27a * 1567 - t20a * 3784 + 2048) >> 12; + t21a = (-(t26 * 3784 + t21 * 1567) + 2048) >> 12; + t26a = ( t26 * 1567 - t21 * 3784 + 2048) >> 12; + + t16 = t16a + t23a; + t17a = t17 + t22; + t18 = t18a + t21a; + t19a = t19 + t20; + t20a = t19 - t20; + t21 = t18a - t21a; + t22a = t17 - t22; + t23 = t16a - t23a; + t24 = t31a - t24a; + t25a = t30 - t25; + t26 = t29a - t26a; + t27a = t28 - t27; + t28a = t28 + t27; + t29 = t29a + t26a; + t30a = t30 + t25; + t31 = t31a + t24a; + + t20 = ((t27a - t20a) * 2896 + 2048) >> 12; + t27 = ((t27a + t20a) * 2896 + 2048) >> 12; + t21a = ((t26 - t21 ) * 2896 + 2048) >> 12; + t26a = ((t26 + t21 ) * 2896 + 2048) >> 12; + t22 = ((t25a - t22a) * 2896 + 2048) >> 12; + t25 = ((t25a + t22a) * 2896 + 2048) >> 12; + t23a = ((t24 - t23 ) * 2896 + 2048) >> 12; + t24a = ((t24 + t23 ) * 2896 + 2048) >> 12; + + out[ 0 * out_s] = tmp[ 0] + t31; + out[ 1 * out_s] = tmp[ 1] + t30a; + out[ 2 * out_s] = tmp[ 2] + t29; + out[ 3 * out_s] = tmp[ 3] + t28a; + out[ 4 * out_s] = tmp[ 4] + t27; + out[ 5 * out_s] = tmp[ 5] + t26a; + out[ 6 * out_s] = tmp[ 6] + t25; + out[ 7 * out_s] = tmp[ 7] + t24a; + out[ 8 * out_s] = tmp[ 8] + t23a; + out[ 9 * out_s] = tmp[ 9] + t22; + out[10 * out_s] = tmp[10] + t21a; + out[11 * out_s] = tmp[11] + t20; + out[12 * out_s] = tmp[12] + t19a; + out[13 * out_s] = tmp[13] + t18; + out[14 * out_s] = tmp[14] + t17a; + out[15 * out_s] = tmp[15] + t16; + out[16 * out_s] = tmp[15] - t16; + out[17 * out_s] = tmp[14] - t17a; + out[18 * out_s] = tmp[13] - t18; + out[19 * out_s] = tmp[12] - t19a; + out[20 * out_s] = tmp[11] - t20; + out[21 * out_s] = tmp[10] - t21a; + out[22 * out_s] = tmp[ 9] - t22; + out[23 * out_s] = tmp[ 8] - t23a; + out[24 * out_s] = tmp[ 7] - t24a; + out[25 * out_s] = tmp[ 6] - t25; + out[26 * out_s] = tmp[ 5] - t26a; + out[27 * out_s] = tmp[ 4] - t27; + out[28 * out_s] = tmp[ 3] - t28a; + out[29 * out_s] = tmp[ 2] - t29; + out[30 * out_s] = tmp[ 1] - t30a; + out[31 * out_s] = tmp[ 0] - t31; +} + +static void __attribute__((noinline)) +inv_dct64_1d(const coef *const in, const ptrdiff_t in_s, + coef *const out, const ptrdiff_t out_s) +{ + coef tmp[32]; + + inv_dct32_1d(in, in_s * 2, tmp, 1); + + const int in1 = in[ 1 * in_s], in3 = in[ 3 * in_s]; + const int in5 = in[ 5 * in_s], in7 = in[ 7 * in_s]; + const int in9 = in[ 9 * in_s], in11 = in[11 * in_s]; + const int in13 = in[13 * in_s], in15 = in[15 * in_s]; + const int in17 = in[17 * in_s], in19 = in[19 * in_s]; + const int in21 = in[21 * in_s], in23 = in[23 * in_s]; + const int in25 = in[25 * in_s], in27 = in[27 * in_s]; + const int in29 = in[29 * in_s], in31 = in[31 * in_s]; + const int in33 = in[33 * in_s], in35 = in[35 * in_s]; + const int in37 = in[37 * in_s], in39 = in[39 * in_s]; + const int in41 = in[41 * in_s], in43 = in[43 * in_s]; + const int in45 = in[45 * in_s], in47 = in[47 * in_s]; + const int in49 = in[49 * in_s], in51 = in[51 * in_s]; + const int in53 = in[53 * in_s], in55 = in[55 * in_s]; + const int in57 = in[57 * in_s], in59 = in[59 * in_s]; + const int in61 = in[61 * in_s], in63 = in[63 * in_s]; + + int t32a = (in1 * 101 - in63 * 4095 + 2048) >> 12; + int t33a = (in33 * 2967 - in31 * 2824 + 2048) >> 12; + int t34a = (in17 * 1660 - in47 * 3745 + 2048) >> 12; + int t35a = (in49 * 3822 - in15 * 1474 + 2048) >> 12; + int t36a = (in9 * 897 - in55 * 3996 + 2048) >> 12; + int t37a = (in41 * 3461 - in23 * 2191 + 2048) >> 12; + int t38a = (in25 * 2359 - in39 * 3349 + 2048) >> 12; + int t39a = (in57 * 4036 - in7 * 700 + 2048) >> 12; + int t40a = (in5 * 501 - in59 * 4065 + 2048) >> 12; + int t41a = (in37 * 3229 - in27 * 2520 + 2048) >> 12; + int t42a = (in21 * 2019 - in43 * 3564 + 2048) >> 12; + int t43a = (in53 * 3948 - in11 * 1092 + 2048) >> 12; + int t44a = (in13 * 1285 - in51 * 3889 + 2048) >> 12; + int t45a = (in45 * 3659 - in19 * 1842 + 2048) >> 12; + int t46a = (in29 * 2675 - in35 * 3102 + 2048) >> 12; + int t47a = (in61 * 4085 - in3 * 301 + 2048) >> 12; + int t48a = (in61 * 301 + in3 * 4085 + 2048) >> 12; + int t49a = (in29 * 3102 + in35 * 2675 + 2048) >> 12; + int t50a = (in45 * 1842 + in19 * 3659 + 2048) >> 12; + int t51a = (in13 * 3889 + in51 * 1285 + 2048) >> 12; + int t52a = (in53 * 1092 + in11 * 3948 + 2048) >> 12; + int t53a = (in21 * 3564 + in43 * 2019 + 2048) >> 12; + int t54a = (in37 * 2520 + in27 * 3229 + 2048) >> 12; + int t55a = (in5 * 4065 + in59 * 501 + 2048) >> 12; + int t56a = (in57 * 700 + in7 * 4036 + 2048) >> 12; + int t57a = (in25 * 3349 + in39 * 2359 + 2048) >> 12; + int t58a = (in41 * 2191 + in23 * 3461 + 2048) >> 12; + int t59a = (in9 * 3996 + in55 * 897 + 2048) >> 12; + int t60a = (in49 * 1474 + in15 * 3822 + 2048) >> 12; + int t61a = (in17 * 3745 + in47 * 1660 + 2048) >> 12; + int t62a = (in33 * 2824 + in31 * 2967 + 2048) >> 12; + int t63a = (in1 * 4095 + in63 * 101 + 2048) >> 12; + + int t32 = t32a + t33a; + int t33 = t32a - t33a; + int t34 = t35a - t34a; + int t35 = t35a + t34a; + int t36 = t36a + t37a; + int t37 = t36a - t37a; + int t38 = t39a - t38a; + int t39 = t39a + t38a; + int t40 = t40a + t41a; + int t41 = t40a - t41a; + int t42 = t43a - t42a; + int t43 = t43a + t42a; + int t44 = t44a + t45a; + int t45 = t44a - t45a; + int t46 = t47a - t46a; + int t47 = t47a + t46a; + int t48 = t48a + t49a; + int t49 = t48a - t49a; + int t50 = t51a - t50a; + int t51 = t51a + t50a; + int t52 = t52a + t53a; + int t53 = t52a - t53a; + int t54 = t55a - t54a; + int t55 = t55a + t54a; + int t56 = t56a + t57a; + int t57 = t56a - t57a; + int t58 = t59a - t58a; + int t59 = t59a + t58a; + int t60 = t60a + t61a; + int t61 = t60a - t61a; + int t62 = t63a - t62a; + int t63 = t63a + t62a; + + t33a = (t33 * -4076 + t62 * 401 + 2048) >> 12; + t34a = (t34 * - 401 + t61 * -4076 + 2048) >> 12; + t37a = (t37 * -2598 + t58 * 3166 + 2048) >> 12; + t38a = (t38 * -3166 + t57 * -2598 + 2048) >> 12; + t41a = (t41 * -3612 + t54 * 1931 + 2048) >> 12; + t42a = (t42 * -1931 + t53 * -3612 + 2048) >> 12; + t45a = (t45 * -1189 + t50 * 3920 + 2048) >> 12; + t46a = (t46 * -3920 + t49 * -1189 + 2048) >> 12; + t49a = (t46 * -1189 + t49 * 3920 + 2048) >> 12; + t50a = (t45 * 3920 + t50 * 1189 + 2048) >> 12; + t53a = (t42 * -3612 + t53 * 1931 + 2048) >> 12; + t54a = (t41 * 1931 + t54 * 3612 + 2048) >> 12; + t57a = (t38 * -2598 + t57 * 3166 + 2048) >> 12; + t58a = (t37 * 3166 + t58 * 2598 + 2048) >> 12; + t61a = (t34 * -4076 + t61 * 401 + 2048) >> 12; + t62a = (t33 * 401 + t62 * 4076 + 2048) >> 12; + + t32a = t32 + t35; + t33 = t33a + t34a; + t34 = t33a - t34a; + t35a = t32 - t35; + t36a = t39 - t36; + t37 = t38a - t37a; + t38 = t38a + t37a; + t39a = t39 + t36; + t40a = t40 + t43; + t41 = t41a + t42a; + t42 = t41a - t42a; + t43a = t40 - t43; + t44a = t47 - t44; + t45 = t46a - t45a; + t46 = t46a + t45a; + t47a = t47 + t44; + t48a = t48 + t51; + t49 = t49a + t50a; + t50 = t49a - t50a; + t51a = t48 - t51; + t52a = t55 - t52; + t53 = t54a - t53a; + t54 = t54a + t53a; + t55a = t55 + t52; + t56a = t56 + t59; + t57 = t57a + t58a; + t58 = t57a - t58a; + t59a = t56 - t59; + t60a = t63 - t60; + t61 = t62a - t61a; + t62 = t62a + t61a; + t63a = t63 + t60; + + t34a = (t34 * -4017 + t61 * 799 + 2048) >> 12; + t35 = (t35a * -4017 + t60a * 799 + 2048) >> 12; + t36 = (t36a * - 799 + t59a * -4017 + 2048) >> 12; + t37a = (t37 * - 799 + t58 * -4017 + 2048) >> 12; + t42a = (t42 * -2276 + t53 * 3406 + 2048) >> 12; + t43 = (t43a * -2276 + t52a * 3406 + 2048) >> 12; + t44 = (t44a * -3406 + t51a * -2276 + 2048) >> 12; + t45a = (t45 * -3406 + t50 * -2276 + 2048) >> 12; + t50a = (t45 * -2276 + t50 * 3406 + 2048) >> 12; + t51 = (t44a * -2276 + t51a * 3406 + 2048) >> 12; + t52 = (t43a * 3406 + t52a * 2276 + 2048) >> 12; + t53a = (t42 * 3406 + t53 * 2276 + 2048) >> 12; + t58a = (t37 * -4017 + t58 * 799 + 2048) >> 12; + t59 = (t36a * -4017 + t59a * 799 + 2048) >> 12; + t60 = (t35a * 799 + t60a * 4017 + 2048) >> 12; + t61a = (t34 * 799 + t61 * 4017 + 2048) >> 12; + + t32 = t32a + t39a; + t33a = t33 + t38; + t34 = t34a + t37a; + t35a = t35 + t36; + t36a = t35 - t36; + t37 = t34a - t37a; + t38a = t33 - t38; + t39 = t32a - t39a; + t40 = t47a - t40a; + t41a = t46 - t41; + t42 = t45a - t42a; + t43a = t44 - t43; + t44a = t44 + t43; + t45 = t45a + t42a; + t46a = t46 + t41; + t47 = t47a + t40a; + t48 = t48a + t55a; + t49a = t49 + t54; + t50 = t50a + t53a; + t51a = t51 + t52; + t52a = t51 - t52; + t53 = t50a - t53a; + t54a = t49 - t54; + t55 = t48a - t55a; + t56 = t63a - t56a; + t57a = t62 - t57; + t58 = t61a - t58a; + t59a = t60 - t59; + t60a = t60 + t59; + t61 = t61a + t58a; + t62a = t62 + t57; + t63 = t63a + t56a; + + t36 = (t36a * -3784 + t59a * 1567 + 2048) >> 12; + t37a = (t37 * -3784 + t58 * 1567 + 2048) >> 12; + t38 = (t38a * -3784 + t57a * 1567 + 2048) >> 12; + t39a = (t39 * -3784 + t56 * 1567 + 2048) >> 12; + t40a = (t40 * -1567 + t55 * -3784 + 2048) >> 12; + t41 = (t41a * -1567 + t54a * -3784 + 2048) >> 12; + t42a = (t42 * -1567 + t53 * -3784 + 2048) >> 12; + t43 = (t43a * -1567 + t52a * -3784 + 2048) >> 12; + t52 = (t43a * -3784 + t52a * 1567 + 2048) >> 12; + t53a = (t42 * -3784 + t53 * 1567 + 2048) >> 12; + t54 = (t41a * -3784 + t54a * 1567 + 2048) >> 12; + t55a = (t40 * -3784 + t55 * 1567 + 2048) >> 12; + t56a = (t39 * 1567 + t56 * 3784 + 2048) >> 12; + t57 = (t38a * 1567 + t57a * 3784 + 2048) >> 12; + t58a = (t37 * 1567 + t58 * 3784 + 2048) >> 12; + t59 = (t36a * 1567 + t59a * 3784 + 2048) >> 12; + + t32a = t32 + t47; + t33 = t33a + t46a; + t34a = t34 + t45; + t35 = t35a + t44a; + t36a = t36 + t43; + t37 = t37a + t42a; + t38a = t38 + t41; + t39 = t39a + t40a; + t40 = t39a - t40a; + t41a = t38 - t41; + t42 = t37a - t42a; + t43a = t36 - t43; + t44 = t35a - t44a; + t45a = t34 - t45; + t46 = t33a - t46a; + t47a = t32 - t47; + t48a = t63 - t48; + t49 = t62a - t49a; + t50a = t61 - t50; + t51 = t60a - t51a; + t52a = t59 - t52; + t53 = t58a - t53a; + t54a = t57 - t54; + t55 = t56a - t55a; + t56 = t56a + t55a; + t57a = t57 + t54; + t58 = t58a + t53a; + t59a = t59 + t52; + t60 = t60a + t51a; + t61a = t61 + t50; + t62 = t62a + t49a; + t63a = t63 + t48; + + t40a = (t40 * -2896 + t55 * 2896 + 2048) >> 12; + t41 = (t41a * -2896 + t54a * 2896 + 2048) >> 12; + t42a = (t42 * -2896 + t53 * 2896 + 2048) >> 12; + t43 = (t43a * -2896 + t52a * 2896 + 2048) >> 12; + t44a = (t44 * -2896 + t51 * 2896 + 2048) >> 12; + t45 = (t45a * -2896 + t50a * 2896 + 2048) >> 12; + t46a = (t46 * -2896 + t49 * 2896 + 2048) >> 12; + t47 = (t47a * -2896 + t48a * 2896 + 2048) >> 12; + t48 = (t47a * 2896 + t48a * 2896 + 2048) >> 12; + t49a = (t46 * 2896 + t49 * 2896 + 2048) >> 12; + t50 = (t45a * 2896 + t50a * 2896 + 2048) >> 12; + t51a = (t44 * 2896 + t51 * 2896 + 2048) >> 12; + t52 = (t43a * 2896 + t52a * 2896 + 2048) >> 12; + t53a = (t42 * 2896 + t53 * 2896 + 2048) >> 12; + t54 = (t41a * 2896 + t54a * 2896 + 2048) >> 12; + t55a = (t40 * 2896 + t55 * 2896 + 2048) >> 12; + + out[ 0 * out_s] = tmp[ 0] + t63a; + out[ 1 * out_s] = tmp[ 1] + t62; + out[ 2 * out_s] = tmp[ 2] + t61a; + out[ 3 * out_s] = tmp[ 3] + t60; + out[ 4 * out_s] = tmp[ 4] + t59a; + out[ 5 * out_s] = tmp[ 5] + t58; + out[ 6 * out_s] = tmp[ 6] + t57a; + out[ 7 * out_s] = tmp[ 7] + t56; + out[ 8 * out_s] = tmp[ 8] + t55a; + out[ 9 * out_s] = tmp[ 9] + t54; + out[10 * out_s] = tmp[10] + t53a; + out[11 * out_s] = tmp[11] + t52; + out[12 * out_s] = tmp[12] + t51a; + out[13 * out_s] = tmp[13] + t50; + out[14 * out_s] = tmp[14] + t49a; + out[15 * out_s] = tmp[15] + t48; + out[16 * out_s] = tmp[16] + t47; + out[17 * out_s] = tmp[17] + t46a; + out[18 * out_s] = tmp[18] + t45; + out[19 * out_s] = tmp[19] + t44a; + out[20 * out_s] = tmp[20] + t43; + out[21 * out_s] = tmp[21] + t42a; + out[22 * out_s] = tmp[22] + t41; + out[23 * out_s] = tmp[23] + t40a; + out[24 * out_s] = tmp[24] + t39; + out[25 * out_s] = tmp[25] + t38a; + out[26 * out_s] = tmp[26] + t37; + out[27 * out_s] = tmp[27] + t36a; + out[28 * out_s] = tmp[28] + t35; + out[29 * out_s] = tmp[29] + t34a; + out[30 * out_s] = tmp[30] + t33; + out[31 * out_s] = tmp[31] + t32a; + out[32 * out_s] = tmp[31] - t32a; + out[33 * out_s] = tmp[30] - t33; + out[34 * out_s] = tmp[29] - t34a; + out[35 * out_s] = tmp[28] - t35; + out[36 * out_s] = tmp[27] - t36a; + out[37 * out_s] = tmp[26] - t37; + out[38 * out_s] = tmp[25] - t38a; + out[39 * out_s] = tmp[24] - t39; + out[40 * out_s] = tmp[23] - t40a; + out[41 * out_s] = tmp[22] - t41; + out[42 * out_s] = tmp[21] - t42a; + out[43 * out_s] = tmp[20] - t43; + out[44 * out_s] = tmp[19] - t44a; + out[45 * out_s] = tmp[18] - t45; + out[46 * out_s] = tmp[17] - t46a; + out[47 * out_s] = tmp[16] - t47; + out[48 * out_s] = tmp[15] - t48; + out[49 * out_s] = tmp[14] - t49a; + out[50 * out_s] = tmp[13] - t50; + out[51 * out_s] = tmp[12] - t51a; + out[52 * out_s] = tmp[11] - t52; + out[53 * out_s] = tmp[10] - t53a; + out[54 * out_s] = tmp[ 9] - t54; + out[55 * out_s] = tmp[ 8] - t55a; + out[56 * out_s] = tmp[ 7] - t56; + out[57 * out_s] = tmp[ 6] - t57a; + out[58 * out_s] = tmp[ 5] - t58; + out[59 * out_s] = tmp[ 4] - t59a; + out[60 * out_s] = tmp[ 3] - t60; + out[61 * out_s] = tmp[ 2] - t61a; + out[62 * out_s] = tmp[ 1] - t62; + out[63 * out_s] = tmp[ 0] - t63a; +} + +static void __attribute__((noinline)) +inv_adst4_1d(const coef *const in, const ptrdiff_t in_s, + coef *const out, const ptrdiff_t out_s) +{ + const int in0 = in[0 * in_s], in1 = in[1 * in_s]; + const int in2 = in[2 * in_s], in3 = in[3 * in_s]; + + int t0 = 1321 * in0 + 3803 * in2 + 2482 * in3; + int t1 = 2482 * in0 - 1321 * in2 - 3803 * in3; + int t2 = 3344 * (in0 - in2 + in3); + int t3 = 3344 * in1; + + out[0 * out_s] = (t0 + t3 + 2048) >> 12; + out[1 * out_s] = (t1 + t3 + 2048) >> 12; + out[2 * out_s] = (t2 + 2048) >> 12; + out[3 * out_s] = (t0 + t1 - t3 + 2048) >> 12; +} + +static void __attribute__((noinline)) +inv_adst8_1d(const coef *const in, const ptrdiff_t in_s, + coef *const out, const ptrdiff_t out_s) +{ + const int in0 = in[0 * in_s], in1 = in[1 * in_s]; + const int in2 = in[2 * in_s], in3 = in[3 * in_s]; + const int in4 = in[4 * in_s], in5 = in[5 * in_s]; + const int in6 = in[6 * in_s], in7 = in[7 * in_s]; + + int t0a = (4076 * in7 + 401 * in0 + 2048) >> 12; + int t1a = ( 401 * in7 - 4076 * in0 + 2048) >> 12; + int t2a = (3612 * in5 + 1931 * in2 + 2048) >> 12; + int t3a = (1931 * in5 - 3612 * in2 + 2048) >> 12; + int t4a = (2598 * in3 + 3166 * in4 + 2048) >> 12; + int t5a = (3166 * in3 - 2598 * in4 + 2048) >> 12; + int t6a = (1189 * in1 + 3920 * in6 + 2048) >> 12; + int t7a = (3920 * in1 - 1189 * in6 + 2048) >> 12; + + int t0 = t0a + t4a; + int t1 = t1a + t5a; + int t2 = t2a + t6a; + int t3 = t3a + t7a; + int t4 = t0a - t4a; + int t5 = t1a - t5a; + int t6 = t2a - t6a; + int t7 = t3a - t7a; + + t4a = (3784 * t4 + 1567 * t5 + 2048) >> 12; + t5a = (1567 * t4 - 3784 * t5 + 2048) >> 12; + t6a = (3784 * t7 - 1567 * t6 + 2048) >> 12; + t7a = (1567 * t7 + 3784 * t6 + 2048) >> 12; + + out[0 * out_s] = t0 + t2; + out[7 * out_s] = -(t1 + t3); + t2 = t0 - t2; + t3 = t1 - t3; + + out[1 * out_s] = -(t4a + t6a); + out[6 * out_s] = t5a + t7a; + t6 = t4a - t6a; + t7 = t5a - t7a; + + out[3 * out_s] = -(((t2 + t3) * 2896 + 2048) >> 12); + out[4 * out_s] = ((t2 - t3) * 2896 + 2048) >> 12; + out[2 * out_s] = ((t6 + t7) * 2896 + 2048) >> 12; + out[5 * out_s] = -(((t6 - t7) * 2896 + 2048) >> 12); +} + +static void __attribute__((noinline)) +inv_adst16_1d(const coef *const in, const ptrdiff_t in_s, + coef *const out, const ptrdiff_t out_s) +{ + const int in0 = in[ 0 * in_s], in1 = in[ 1 * in_s]; + const int in2 = in[ 2 * in_s], in3 = in[ 3 * in_s]; + const int in4 = in[ 4 * in_s], in5 = in[ 5 * in_s]; + const int in6 = in[ 6 * in_s], in7 = in[ 7 * in_s]; + const int in8 = in[ 8 * in_s], in9 = in[ 9 * in_s]; + const int in10 = in[10 * in_s], in11 = in[11 * in_s]; + const int in12 = in[12 * in_s], in13 = in[13 * in_s]; + const int in14 = in[14 * in_s], in15 = in[15 * in_s]; + + int t0 = (in15 * 4091 + in0 * 201 + 2048) >> 12; + int t1 = (in15 * 201 - in0 * 4091 + 2048) >> 12; + int t2 = (in13 * 3973 + in2 * 995 + 2048) >> 12; + int t3 = (in13 * 995 - in2 * 3973 + 2048) >> 12; + int t4 = (in11 * 3703 + in4 * 1751 + 2048) >> 12; + int t5 = (in11 * 1751 - in4 * 3703 + 2048) >> 12; + int t6 = (in9 * 3290 + in6 * 2440 + 2048) >> 12; + int t7 = (in9 * 2440 - in6 * 3290 + 2048) >> 12; + int t8 = (in7 * 2751 + in8 * 3035 + 2048) >> 12; + int t9 = (in7 * 3035 - in8 * 2751 + 2048) >> 12; + int t10 = (in5 * 2106 + in10 * 3513 + 2048) >> 12; + int t11 = (in5 * 3513 - in10 * 2106 + 2048) >> 12; + int t12 = (in3 * 1380 + in12 * 3857 + 2048) >> 12; + int t13 = (in3 * 3857 - in12 * 1380 + 2048) >> 12; + int t14 = (in1 * 601 + in14 * 4052 + 2048) >> 12; + int t15 = (in1 * 4052 - in14 * 601 + 2048) >> 12; + + int t0a = t0 + t8; + int t1a = t1 + t9; + int t2a = t2 + t10; + int t3a = t3 + t11; + int t4a = t4 + t12; + int t5a = t5 + t13; + int t6a = t6 + t14; + int t7a = t7 + t15; + int t8a = t0 - t8; + int t9a = t1 - t9; + int t10a = t2 - t10; + int t11a = t3 - t11; + int t12a = t4 - t12; + int t13a = t5 - t13; + int t14a = t6 - t14; + int t15a = t7 - t15; + + t8 = (t8a * 4017 + t9a * 799 + 2048) >> 12; + t9 = (t8a * 799 - t9a * 4017 + 2048) >> 12; + t10 = (t10a * 2276 + t11a * 3406 + 2048) >> 12; + t11 = (t10a * 3406 - t11a * 2276 + 2048) >> 12; + t12 = (t13a * 4017 - t12a * 799 + 2048) >> 12; + t13 = (t13a * 799 + t12a * 4017 + 2048) >> 12; + t14 = (t15a * 2276 - t14a * 3406 + 2048) >> 12; + t15 = (t15a * 3406 + t14a * 2276 + 2048) >> 12; + + t0 = t0a + t4a; + t1 = t1a + t5a; + t2 = t2a + t6a; + t3 = t3a + t7a; + t4 = t0a - t4a; + t5 = t1a - t5a; + t6 = t2a - t6a; + t7 = t3a - t7a; + t8a = t8 + t12; + t9a = t9 + t13; + t10a = t10 + t14; + t11a = t11 + t15; + t12a = t8 - t12; + t13a = t9 - t13; + t14a = t10 - t14; + t15a = t11 - t15; + + t4a = (t4 * 3784 + t5 * 1567 + 2048) >> 12; + t5a = (t4 * 1567 - t5 * 3784 + 2048) >> 12; + t6a = (t7 * 3784 - t6 * 1567 + 2048) >> 12; + t7a = (t7 * 1567 + t6 * 3784 + 2048) >> 12; + t12 = (t12a * 3784 + t13a * 1567 + 2048) >> 12; + t13 = (t12a * 1567 - t13a * 3784 + 2048) >> 12; + t14 = (t15a * 3784 - t14a * 1567 + 2048) >> 12; + t15 = (t15a * 1567 + t14a * 3784 + 2048) >> 12; + + out[ 0 * out_s] = t0 + t2; + out[15 * out_s] = -(t1 + t3); + t2a = t0 - t2; + t3a = t1 - t3; + out[ 3 * out_s] = -(t4a + t6a); + out[12 * out_s] = t5a + t7a; + t6 = t4a - t6a; + t7 = t5a - t7a; + out[ 1 * out_s] = -(t8a + t10a); + out[14 * out_s] = t9a + t11a; + t10 = t8a - t10a; + t11 = t9a - t11a; + out[ 2 * out_s] = t12 + t14; + out[13 * out_s] = -(t13 + t15); + t14a = t12 - t14; + t15a = t13 - t15; + + out[ 7 * out_s] = -(((t2a + t3a) * 2896 + 2048) >> 12); + out[ 8 * out_s] = ((t2a - t3a) * 2896 + 2048) >> 12; + out[ 4 * out_s] = ((t6 + t7) * 2896 + 2048) >> 12; + out[11 * out_s] = -(((t6 - t7) * 2896 + 2048) >> 12); + out[ 6 * out_s] = ((t10 + t11) * 2896 + 2048) >> 12; + out[ 9 * out_s] = -(((t10 - t11) * 2896 + 2048) >> 12); + out[ 5 * out_s] = -(((t14a + t15a) * 2896 + 2048) >> 12); + out[10 * out_s] = ((t14a - t15a) * 2896 + 2048) >> 12; +} + +#define flip_inv_adst(sz) \ +static void inv_flipadst##sz##_1d(const coef *const in, const ptrdiff_t in_s, \ + coef *const out, const ptrdiff_t out_s) \ +{ \ + inv_adst##sz##_1d(in, in_s, &out[(sz - 1) * out_s], -out_s); \ +} + +flip_inv_adst(4); +flip_inv_adst(8); +flip_inv_adst(16); + +#undef flip_inv_adst + +static void __attribute__((noinline)) +inv_identity4_1d(const coef *const in, const ptrdiff_t in_s, + coef *const out, const ptrdiff_t out_s) +{ + for (int i = 0; i < 4; i++) + out[out_s * i] = (in[in_s * i] * 5793 + 2048) >> 12; +} + +static void __attribute__((noinline)) +inv_identity8_1d(const coef *const in, const ptrdiff_t in_s, + coef *const out, const ptrdiff_t out_s) +{ + for (int i = 0; i < 8; i++) + out[out_s * i] = in[in_s * i] * 2; +} + +static void __attribute__((noinline)) +inv_identity16_1d(const coef *const in, const ptrdiff_t in_s, + coef *const out, const ptrdiff_t out_s) +{ + for (int i = 0; i < 16; i++) + out[out_s * i] = (in[in_s * i] * 2 * 5793 + 2048) >> 12; +} + +static void __attribute__((noinline)) +inv_identity32_1d(const coef *const in, const ptrdiff_t in_s, + coef *const out, const ptrdiff_t out_s) +{ + for (int i = 0; i < 32; i++) + out[out_s * i] = in[in_s * i] * 4; +} + +static void __attribute__((noinline)) +inv_wht4_1d(const coef *const in, const ptrdiff_t in_s, + coef *const out, const ptrdiff_t out_s, + const int pass) +{ + const int sh = 2 * !pass; + const int in0 = in[0 * in_s] >> sh, in1 = in[1 * in_s] >> sh; + const int in2 = in[2 * in_s] >> sh, in3 = in[3 * in_s] >> sh; + const int t0 = in0 + in1; + const int t2 = in2 - in3; + const int t4 = (t0 - t2) >> 1; + const int t3 = t4 - in3; + const int t1 = t4 - in1; + + out[0 * out_s] = t0 - t3; + out[1 * out_s] = t3; + out[2 * out_s] = t1; + out[3 * out_s] = t2 + t1; +} diff --git a/src/levels.h b/src/levels.h new file mode 100644 index 0000000..d339f92 --- /dev/null +++ b/src/levels.h @@ -0,0 +1,525 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_SRC_LEVELS_H__ +#define __DAV1D_SRC_LEVELS_H__ + +#include "dav1d/picture.h" + +enum ObuType { + OBU_SEQ_HDR = 1, + OBU_TD = 2, + OBU_FRAME_HDR = 3, + OBU_TILE_GRP = 4, + OBU_METADATA = 5, + OBU_FRAME = 6, + OBU_PADDING = 15, +}; + +enum FrameType { + KEY_FRAME = 0, + INTER_FRAME = 1, + INTRAONLY_FRAME = 2, + S_FRAME = 3, +} FRAME_TYPE; + +enum TxfmSize { + TX_4X4, + TX_8X8, + TX_16X16, + TX_32X32, + TX_64X64, + N_TX_SIZES, +}; + +enum BlockLevel { + BL_128X128, + BL_64X64, + BL_32X32, + BL_16X16, + BL_8X8, + N_BL_LEVELS, +}; + +enum TxfmMode { + TX_4X4_ONLY, + TX_LARGEST, + TX_SWITCHABLE, + N_TX_MODES, +}; + +enum RectTxfmSize { + RTX_4X8 = N_TX_SIZES, + RTX_8X4, + RTX_8X16, + RTX_16X8, + RTX_16X32, + RTX_32X16, + RTX_32X64, + RTX_64X32, + RTX_4X16, + RTX_16X4, + RTX_8X32, + RTX_32X8, + RTX_16X64, + RTX_64X16, + N_RECT_TX_SIZES +}; + +enum TxfmType { + DCT_DCT, // DCT in both horizontal and vertical + ADST_DCT, // ADST in vertical, DCT in horizontal + DCT_ADST, // DCT in vertical, ADST in horizontal + ADST_ADST, // ADST in both directions + FLIPADST_DCT, + DCT_FLIPADST, + FLIPADST_FLIPADST, + ADST_FLIPADST, + FLIPADST_ADST, + IDTX, + V_DCT, + H_DCT, + V_ADST, + H_ADST, + V_FLIPADST, + H_FLIPADST, + N_TX_TYPES, + WHT_WHT = N_TX_TYPES, + N_TX_TYPES_PLUS_LL, +}; + +enum TxfmTypeSet { + TXTP_SET_DCT, + TXTP_SET_DCT_ID, + TXTP_SET_DT4_ID, + TXTP_SET_DT4_ID_1D, + TXTP_SET_DT9_ID_1D, + TXTP_SET_ALL, + TXTP_SET_LOSSLESS, + N_TXTP_SETS +}; + +enum TxClass { + TX_CLASS_2D, + TX_CLASS_H, + TX_CLASS_V, +}; + +enum IntraPredMode { + DC_PRED, + VERT_PRED, + HOR_PRED, + DIAG_DOWN_LEFT_PRED, + DIAG_DOWN_RIGHT_PRED, + VERT_RIGHT_PRED, + HOR_DOWN_PRED, + HOR_UP_PRED, + VERT_LEFT_PRED, + SMOOTH_PRED, + SMOOTH_V_PRED, + SMOOTH_H_PRED, + PAETH_PRED, + N_INTRA_PRED_MODES, + CFL_PRED = N_INTRA_PRED_MODES, + N_UV_INTRA_PRED_MODES, + N_IMPL_INTRA_PRED_MODES = N_UV_INTRA_PRED_MODES, + LEFT_DC_PRED = DIAG_DOWN_LEFT_PRED, + TOP_DC_PRED, + DC_128_PRED, + Z1_PRED, + Z2_PRED, + Z3_PRED, + FILTER_PRED = N_INTRA_PRED_MODES, +}; + +enum InterIntraPredMode { + II_DC_PRED, + II_VERT_PRED, + II_HOR_PRED, + II_SMOOTH_PRED, + N_INTER_INTRA_PRED_MODES, +}; + +enum BlockPartition { + PARTITION_NONE, // [ ] <-. + PARTITION_H, // [-] | + PARTITION_V, // [|] | + PARTITION_SPLIT, // [+] --' + PARTITION_T_TOP_SPLIT, // [⊥] i.e. split top, H bottom + PARTITION_T_BOTTOM_SPLIT, // [т] i.e. H top, split bottom + PARTITION_T_LEFT_SPLIT, // [-|] i.e. split left, V right + PARTITION_T_RIGHT_SPLIT, // [|-] i.e. V left, split right + PARTITION_H4, // [Ⲷ] + PARTITION_V4, // [Ⲽ] + N_PARTITIONS, + N_SUB8X8_PARTITIONS = PARTITION_T_TOP_SPLIT, +}; + +enum BlockSize { + BS_128x128, + BS_128x64, + BS_64x128, + BS_64x64, + BS_64x32, + BS_64x16, + BS_32x64, + BS_32x32, + BS_32x16, + BS_32x8, + BS_16x64, + BS_16x32, + BS_16x16, + BS_16x8, + BS_16x4, + BS_8x32, + BS_8x16, + BS_8x8, + BS_8x4, + BS_4x16, + BS_4x8, + BS_4x4, + N_BS_SIZES, +}; + +enum FilterMode { + FILTER_8TAP_REGULAR, + FILTER_8TAP_SMOOTH, + FILTER_8TAP_SHARP, + N_SWITCHABLE_FILTERS, + FILTER_BILINEAR = N_SWITCHABLE_FILTERS, + N_FILTERS, + FILTER_SWITCHABLE = N_FILTERS, +}; + +enum Filter2d { // order is horizontal, vertical + FILTER_2D_8TAP_REGULAR, + FILTER_2D_8TAP_REGULAR_SMOOTH, + FILTER_2D_8TAP_REGULAR_SHARP, + FILTER_2D_8TAP_SHARP_REGULAR, + FILTER_2D_8TAP_SHARP_SMOOTH, + FILTER_2D_8TAP_SHARP, + FILTER_2D_8TAP_SMOOTH_REGULAR, + FILTER_2D_8TAP_SMOOTH, + FILTER_2D_8TAP_SMOOTH_SHARP, + FILTER_2D_BILINEAR, + N_2D_FILTERS, +}; + +enum MVJoint { + MV_JOINT_ZERO, + MV_JOINT_H, + MV_JOINT_V, + MV_JOINT_HV, + N_MV_JOINTS, +}; + +enum InterPredMode { + NEARESTMV, + NEARMV, + GLOBALMV, + NEWMV, + N_INTER_PRED_MODES, +}; + +enum CompInterPredMode { + NEARESTMV_NEARESTMV, + NEARMV_NEARMV, + NEARESTMV_NEWMV, + NEWMV_NEARESTMV, + NEARMV_NEWMV, + NEWMV_NEARMV, + GLOBALMV_GLOBALMV, + NEWMV_NEWMV, + N_COMP_INTER_PRED_MODES, +}; + +enum CompInterType { + COMP_INTER_NONE, + COMP_INTER_WEIGHTED_AVG, + COMP_INTER_AVG, + COMP_INTER_SEG, + COMP_INTER_WEDGE, +}; + +enum InterIntraType { + INTER_INTRA_NONE, + INTER_INTRA_BLEND, + INTER_INTRA_WEDGE, +}; + +enum AdaptiveBoolean { + OFF = 0, + ON = 1, + ADAPTIVE = 2, +}; + +enum RestorationType { + RESTORATION_NONE, + RESTORATION_SWITCHABLE, + RESTORATION_WIENER, + RESTORATION_SGRPROJ, +}; + +typedef struct mv { + int16_t y, x; +} mv; + +enum WarpedMotionType { + WM_TYPE_IDENTITY, + WM_TYPE_TRANSLATION, + WM_TYPE_ROT_ZOOM, + WM_TYPE_AFFINE, +}; + +typedef struct WarpedMotionParams { + enum WarpedMotionType type; + int32_t matrix[6]; + union { + struct { + int16_t alpha, beta, gamma, delta; + }; + int16_t abcd[4]; + }; +} WarpedMotionParams; + +enum MotionMode { + MM_TRANSLATION, + MM_OBMC, + MM_WARP, +}; + +typedef struct Av1SequenceHeader { + int profile; + int still_picture; + int reduced_still_picture_header; + int timing_info_present; + int num_units_in_tick; + int time_scale; + int equal_picture_interval; + int num_ticks_per_picture; + int decoder_model_info_present; + int bitrate_scale; + int buffer_size_scale; + int encoder_decoder_buffer_delay_length; + int num_units_in_decoding_tick; + int buffer_removal_delay_length; + int frame_presentation_delay_length; + int display_model_info_present; + int num_operating_points; + struct Av1SequenceHeaderOperatingPoint { + int idc; + int major_level, minor_level; + int tier; + int decoder_model_param_present; + int bitrate; + int buffer_size; + int cbr; + int decoder_buffer_delay; + int encoder_buffer_delay; + int low_delay_mode; + int display_model_param_present; + int initial_display_delay; + } operating_points[32]; + int max_width, max_height, width_n_bits, height_n_bits; + int frame_id_numbers_present; + int delta_frame_id_n_bits; + int frame_id_n_bits; + int sb128; + int filter_intra; + int intra_edge_filter; + int inter_intra; + int masked_compound; + int warped_motion; + int dual_filter; + int order_hint; + int jnt_comp; + int ref_frame_mvs; + enum AdaptiveBoolean screen_content_tools; + enum AdaptiveBoolean force_integer_mv; + int order_hint_n_bits; + int super_res; + int cdef; + int restoration; + int bpc; + int hbd; + int color_description_present; + enum Dav1dPixelLayout layout; + enum Dav1dColorPrimaries pri; + enum Dav1dTransferCharacteristics trc; + enum Dav1dMatrixCoefficients mtrx; + enum Dav1dChromaSamplePosition chr; + int color_range; + int separate_uv_delta_q; + int film_grain_present; +} Av1SequenceHeader; + +#define NUM_SEGMENTS 8 + +typedef struct Av1SegmentationData { + int delta_q; + int delta_lf_y_v, delta_lf_y_h, delta_lf_u, delta_lf_v; + int ref; + int skip; + int globalmv; +} Av1SegmentationData; + +typedef struct Av1SegmentationDataSet { + Av1SegmentationData d[NUM_SEGMENTS]; + int preskip; + int last_active_segid; +} Av1SegmentationDataSet; + +typedef struct Av1LoopfilterModeRefDeltas { + int mode_delta[2]; + int ref_delta[8]; +} Av1LoopfilterModeRefDeltas; + +typedef struct Av1FilmGrainData { + int num_y_points; + uint8_t y_points[14][2 /* value, scaling */]; + int chroma_scaling_from_luma; + int num_uv_points[2]; + uint8_t uv_points[2][10][2 /* value, scaling */]; + int scaling_shift; + int ar_coeff_lag; + int8_t ar_coeffs_y[24]; + int8_t ar_coeffs_uv[2][25]; + int ar_coeff_shift; + int grain_scale_shift; + int uv_mult[2]; + int uv_luma_mult[2]; + int uv_offset[2]; + int overlap_flag; + int clip_to_restricted_range; +} Av1FilmGrainData; + +typedef struct Av1FrameHeader { + int show_existing_frame; + int existing_frame_idx; + int frame_id; + enum FrameType frame_type; + int show_frame; + int showable_frame; + int error_resilient_mode; + int disable_cdf_update; + int allow_screen_content_tools; + int force_integer_mv; + int frame_size_override; +#define PRIMARY_REF_NONE 7 + int primary_ref_frame; + int frame_offset; + int refresh_frame_flags; + int width, height; + int render_width, render_height; + int super_res; + int have_render_size; + int allow_intrabc; + int frame_ref_short_signaling; + int refidx[7]; + int hp; + enum FilterMode subpel_filter_mode; + int switchable_motion_mode; + int use_ref_frame_mvs; + int refresh_context; + struct { + int uniform; + int n_bytes; + int min_log2_cols, max_log2_cols, log2_cols, cols; + int col_start_sb[1025]; + int min_log2_rows, max_log2_rows, log2_rows, rows; + int row_start_sb[1025]; + int update; + } tiling; + struct { + int yac; + int ydc_delta; + int udc_delta, uac_delta, vdc_delta, vac_delta; + int qm, qm_y, qm_u, qm_v; + } quant; + struct { + int enabled, update_map, temporal, update_data; + Av1SegmentationDataSet seg_data; + int lossless[NUM_SEGMENTS], qidx[NUM_SEGMENTS]; + } segmentation; + int delta_q_present; + int delta_q_res_log2; + int delta_lf_present; + int delta_lf_res_log2; + int delta_lf_multi; + int all_lossless; + struct { + int level_y[2]; + int level_u, level_v; + int mode_ref_delta_enabled; + int mode_ref_delta_update; + Av1LoopfilterModeRefDeltas mode_ref_deltas; + int sharpness; + } loopfilter; + struct { + int damping; + int n_bits; + int y_strength[8]; + int uv_strength[8]; + } cdef; + struct { + enum RestorationType type[3]; + int unit_size[2]; + } restoration; + enum TxfmMode txfm_mode; + int switchable_comp_refs; + int skip_mode_allowed, skip_mode_enabled, skip_mode_refs[2]; + int warp_motion; + int reduced_txtp_set; + WarpedMotionParams gmv[7]; + struct { + int present, update, seed; + Av1FilmGrainData data; + } film_grain; +} Av1FrameHeader; + +#define QINDEX_RANGE 256 + +typedef struct Av1Block { + uint8_t bl, bs, bp; + uint8_t intra, seg_id, skip_mode, skip, uvtx; + union { + struct { + uint8_t y_mode, uv_mode, tx, pal_sz[2]; + int8_t y_angle, uv_angle, cfl_alpha[2]; + }; // intra + struct { + int8_t ref[2]; + uint8_t comp_type, wedge_idx, mask_sign, inter_mode, drl_idx; + uint8_t interintra_type, interintra_mode, motion_mode; + uint8_t max_ytx, filter2d; + uint16_t tx_split[2]; + mv mv[2]; + }; // inter + }; +} Av1Block; + +#endif /* __DAV1D_SRC_LEVELS_H__ */ diff --git a/src/lf_apply.c b/src/lf_apply.c new file mode 100644 index 0000000..f5a24ef --- /dev/null +++ b/src/lf_apply.c @@ -0,0 +1,330 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <assert.h> +#include <string.h> + +#include "common/intops.h" + +#include "src/lf_apply.h" + +static inline int maxifzero(const uint8_t (*const a)[4], const int have_b, + const uint8_t (*const b)[4], const int diridx) +{ + const int a_val = (*a)[diridx]; + if (a_val) return a_val; + if (!have_b) return a_val; + return (*b)[diridx]; +} + +static inline void filter_plane_cols_y(const Dav1dFrameContext *const f, + const int have_left, + const uint8_t (*lvl)[4], + const ptrdiff_t b4_stride, + const uint32_t (*const mask)[3], + pixel *dst, const ptrdiff_t ls, + const int starty4, const int endy4) +{ + const Dav1dDSPContext *const dsp = f->dsp; + + // filter edges between columns (e.g. block1 | block2) + for (int y = starty4; y < endy4; + y++, dst += 4 * PXSTRIDE(ls), lvl += b4_stride) + { + pixel *ptr = dst; + const uint8_t (*l)[4] = lvl; + const uint32_t *const hmask = mask[y]; + const unsigned hm = hmask[0] | hmask[1] | hmask[2]; + + for (unsigned x = 1; hm & ~(x - 1); l++, x <<= 1, ptr += 4) { + if ((have_left || x > 1) && (hm & x)) { + const int L = maxifzero(l, have_left || x > 1, &l[-1], 0); + if (!L) continue; + const int H = L >> 4; + const int E = f->lf.lim_lut.e[L], I = f->lf.lim_lut.i[L]; + const int idx = (hmask[2] & x) ? 2 : !!(hmask[1] & x); + + dsp->lf.loop_filter[idx][0](ptr, ls, E, I, H); + } + } + } +} + +static inline void filter_plane_rows_y(const Dav1dFrameContext *const f, + const int have_top, + const uint8_t (*lvl)[4], + const ptrdiff_t b4_stride, + const uint32_t (*const mask)[3], + pixel *dst, const ptrdiff_t ls, + const int starty4, const int endy4) +{ + const Dav1dDSPContext *const dsp = f->dsp; + + // block1 + // filter edges between rows (e.g. ------) + // block2 + for (int y = starty4; y < endy4; + y++, dst += 4 * PXSTRIDE(ls), lvl += b4_stride) + { + pixel *ptr = dst; + const uint8_t (*l)[4] = lvl; + const uint32_t *const vmask = mask[y]; + const unsigned vm = vmask[0] | vmask[1] | vmask[2]; + + for (unsigned x = 1; vm & ~(x - 1); x <<= 1, ptr += 4, l++) { + if ((have_top || y) && (vm & x)) { + const int L = maxifzero(l, have_top || y, &l[-b4_stride], 1); + if (!L) continue; + const int H = L >> 4; + const int E = f->lf.lim_lut.e[L], I = f->lf.lim_lut.i[L]; + const int idx = (vmask[2] & x) ? 2 : !!(vmask[1] & x); + + dsp->lf.loop_filter[idx][1](ptr, ls, E, I, H); + } + } + } +} + +static inline void filter_plane_cols_uv(const Dav1dFrameContext *const f, + const int have_left, + const uint8_t (*lvl)[4], + const ptrdiff_t b4_stride, + const uint32_t (*const mask)[2], + pixel *const u, pixel *const v, + const ptrdiff_t ls, + const int starty4, const int endy4) +{ + const Dav1dDSPContext *const dsp = f->dsp; + int y; + ptrdiff_t off_l; + const int ss_ver = f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I420; + const int ss_hor = f->cur.p.p.layout != DAV1D_PIXEL_LAYOUT_I444; + const int hstep = 1 << ss_hor; + + // filter edges between columns (e.g. block1 | block2) + lvl += ss_hor + ss_ver * b4_stride; + for (off_l = 0, y = starty4; y < endy4; + y++, off_l += 4 * PXSTRIDE(ls), lvl += b4_stride << ss_ver) + { + ptrdiff_t off = off_l; + const uint8_t (*l)[4] = lvl; + const uint32_t *const hmask = mask[y]; + const unsigned hm = hmask[0] | hmask[1]; + + for (unsigned x = 1; hm & ~(x - 1); l += hstep, x <<= 1, off += 4) { + if ((have_left || x > 1) && (hm & x)) { + const int idx = !!(hmask[1] & x); + + const int Lu = maxifzero(l, have_left || x > 1, &l[-hstep], 2); + if (Lu) { + const int H = Lu >> 4; + const int E = f->lf.lim_lut.e[Lu], I = f->lf.lim_lut.i[Lu]; + + dsp->lf.loop_filter_uv[idx][0](&u[off], ls, E, I, H); + } + + const int Lv = maxifzero(l, have_left || x > 1, &l[-hstep], 3); + if (Lv) { + const int H = Lv >> 4; + const int E = f->lf.lim_lut.e[Lv], I = f->lf.lim_lut.i[Lv]; + + dsp->lf.loop_filter_uv[idx][0](&v[off], ls, E, I, H); + } + } + } + } +} + +static inline void filter_plane_rows_uv(const Dav1dFrameContext *const f, + const int have_top, + const uint8_t (*lvl)[4], + const ptrdiff_t b4_stride, + const uint32_t (*const mask)[2], + pixel *const u, pixel *const v, + const ptrdiff_t ls, + const int starty4, const int endy4) +{ + const Dav1dDSPContext *const dsp = f->dsp; + int y; + ptrdiff_t off_l; + const int ss_ver = f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I420; + const int ss_hor = f->cur.p.p.layout != DAV1D_PIXEL_LAYOUT_I444; + const int hstep = 1 << ss_hor; + + // block1 + // filter edges between rows (e.g. ------) + // block2 + lvl += ss_ver * b4_stride + ss_hor; + for (off_l = 0, y = starty4; y < endy4; + y++, off_l += 4 * PXSTRIDE(ls), lvl += b4_stride << ss_ver) + { + ptrdiff_t off = off_l; + const uint8_t (*l)[4] = lvl; + const uint32_t *const vmask = mask[y]; + const unsigned vm = vmask[0] | vmask[1]; + + for (unsigned x = 1; vm & ~(x - 1); x <<= 1, off += 4, l += hstep) { + if ((have_top || y) && (vm & x)) { + const int idx = !!(vmask[1] & x); + + const int Lu = maxifzero(l, have_top || y, + &l[-(b4_stride << ss_ver)], 2); + if (Lu) { + const int H = Lu >> 4; + const int E = f->lf.lim_lut.e[Lu], I = f->lf.lim_lut.i[Lu]; + + dsp->lf.loop_filter_uv[idx][1](&u[off], ls, E, I, H); + } + + const int Lv = maxifzero(l, have_top || y, + &l[-(b4_stride << ss_ver)], 3); + if (Lv) { + const int H = Lv >> 4; + const int E = f->lf.lim_lut.e[Lv], I = f->lf.lim_lut.i[Lv]; + + dsp->lf.loop_filter_uv[idx][1](&v[off], ls, E, I, H); + } + } + } + } +} + +void bytefn(dav1d_loopfilter_sbrow)(const Dav1dFrameContext *const f, + pixel *const p[3], Av1Filter *const lflvl, + int sby, const int start_of_tile_row) +{ + int x, have_left; + const int have_top = sby > 0; + const int is_sb64 = !f->seq_hdr.sb128; + const int starty4 = (sby & is_sb64) << 4; + const int sbsz = 32 >> is_sb64; + const int sbl2 = 5 - is_sb64; + const int endy4 = starty4 + imin(f->bh - sby * f->sb_step, sbsz); + const int halign = (f->bh + 31) & ~31; + const int ss_ver = f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I420; + const int ss_hor = f->cur.p.p.layout != DAV1D_PIXEL_LAYOUT_I444; + + // fix lpf strength at tile col boundaries + const uint8_t *lpf_y = &f->lf.tx_lpf_right_edge[0][sby << sbl2]; + const uint8_t *lpf_uv = &f->lf.tx_lpf_right_edge[1][sby << (sbl2 - ss_ver)]; + for (int tile_col = 1;; tile_col++) { + x = f->frame_hdr.tiling.col_start_sb[tile_col]; + if ((x << sbl2) >= f->bw) break; + const int mask = x & is_sb64 ? 1 << 16 : 1; + const int uv_mask = x & is_sb64 ? 1 << (16 >> ss_hor) : 1; + x >>= is_sb64; + for (int y = starty4; y < endy4; y++) { + const int idx = 2 * !!(lflvl[x].filter_y[0][y][2] & mask) + + !!(lflvl[x].filter_y[0][y][1] & mask); + lflvl[x].filter_y[0][y][2] &= ~mask; + lflvl[x].filter_y[0][y][1] &= ~mask; + lflvl[x].filter_y[0][y][0] &= ~mask; + lflvl[x].filter_y[0][y][imin(idx, lpf_y[y - starty4])] |= mask; + } + for (int y = starty4 >> ss_ver; y < (endy4 >> ss_ver); y++) { + const int idx = !!(lflvl[x].filter_uv[0][y][1] & uv_mask); + lflvl[x].filter_uv[0][y][1] &= ~uv_mask; + lflvl[x].filter_uv[0][y][0] &= ~uv_mask; + lflvl[x].filter_uv[0][y][imin(idx, lpf_uv[y - (starty4 >> ss_ver)])] |= uv_mask; + } + lpf_y += halign; + lpf_uv += halign >> ss_ver; + } + + // fix lpf strength at tile row boundaries + if (start_of_tile_row) { + const BlockContext *a; + for (x = 0, a = &f->a[f->sb128w * (start_of_tile_row - 1)]; + x < f->sb128w; x++, a++) + { + uint32_t *const y_vmask = lflvl[x].filter_y[1][starty4]; + const unsigned y_vm = y_vmask[0] | y_vmask[1] | y_vmask[2]; + + for (unsigned mask = 1, i = 0; i < 32; mask <<= 1, i++) { + if (!(y_vm & mask)) continue; + const int idx = 2 * !!(y_vmask[2] & mask) + !!(y_vmask[1] & mask); + y_vmask[2] &= ~mask; + y_vmask[1] &= ~mask; + y_vmask[0] &= ~mask; + y_vmask[imin(idx, a->tx_lpf_y[i])] |= mask; + } + + uint32_t *const uv_vmask = lflvl[x].filter_uv[1][starty4 >> ss_ver]; + const unsigned uv_vm = uv_vmask[0] | uv_vmask[1]; + for (unsigned mask = 1, i = 0; i < (32 >> ss_hor); mask <<= 1, i++) { + if (!(uv_vm & mask)) continue; + const int idx = !!(uv_vmask[1] & mask); + uv_vmask[1] &= ~mask; + uv_vmask[0] &= ~mask; + uv_vmask[imin(idx, a->tx_lpf_uv[i])] |= mask; + } + } + } + + pixel *ptr; + uint8_t (*level_ptr)[4] = f->lf.level + f->b4_stride * sby * sbsz; + for (ptr = p[0], have_left = 0, x = 0; x < f->sb128w; + x++, have_left = 1, ptr += 128, level_ptr += 32) + { + filter_plane_cols_y(f, have_left, level_ptr, f->b4_stride, + lflvl[x].filter_y[0], + ptr, f->cur.p.stride[0], starty4, endy4); + } + + level_ptr = f->lf.level + f->b4_stride * sby * sbsz; + for (ptr = p[0], x = 0; x < f->sb128w; x++, ptr += 128, level_ptr += 32) { + filter_plane_rows_y(f, have_top, level_ptr, f->b4_stride, + lflvl[x].filter_y[1], + ptr, f->cur.p.stride[0], starty4, endy4); + } + + if (!f->frame_hdr.loopfilter.level_u && !f->frame_hdr.loopfilter.level_v) + return; + + ptrdiff_t uv_off; + level_ptr = f->lf.level + f->b4_stride * sby * sbsz; + for (uv_off = 0, have_left = 0, x = 0; x < f->sb128w; + x++, have_left = 1, uv_off += 128 >> ss_hor, level_ptr += 32) + { + filter_plane_cols_uv(f, have_left, level_ptr, f->b4_stride, + lflvl[x].filter_uv[0], + &p[1][uv_off], &p[2][uv_off], f->cur.p.stride[1], + starty4 >> ss_ver, endy4 >> ss_ver); + } + + level_ptr = f->lf.level + f->b4_stride * sby * sbsz; + for (uv_off = 0, x = 0; x < f->sb128w; + x++, uv_off += 128 >> ss_hor, level_ptr += 32) + { + filter_plane_rows_uv(f, have_top, level_ptr, f->b4_stride, + lflvl[x].filter_uv[1], + &p[1][uv_off], &p[2][uv_off], f->cur.p.stride[1], + starty4 >> ss_ver, endy4 >> ss_ver); + } +} diff --git a/src/lf_apply.h b/src/lf_apply.h new file mode 100644 index 0000000..580aafb --- /dev/null +++ b/src/lf_apply.h @@ -0,0 +1,42 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_SRC_LF_APPLY_H__ +#define __DAV1D_SRC_LF_APPLY_H__ + +#include <stdint.h> + +#include "common/bitdepth.h" + +#include "src/internal.h" +#include "src/levels.h" + +void bytefn(dav1d_loopfilter_sbrow)(const Dav1dFrameContext *f, + pixel *const p[3], Av1Filter *lflvl, + int sby, int start_of_tile_row); + +#endif /* __DAV1D_SRC_LF_APPLY_H__ */ diff --git a/src/lf_mask.c b/src/lf_mask.c new file mode 100644 index 0000000..9c5572c --- /dev/null +++ b/src/lf_mask.c @@ -0,0 +1,402 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <assert.h> +#include <string.h> + +#include "common/intops.h" + +#include "src/levels.h" +#include "src/lf_mask.h" +#include "src/tables.h" + +static void decomp_tx(uint8_t (*txa)[2 /* txsz, step */][32 /* y */][32 /* x */], + const enum RectTxfmSize from, + const int depth, + const int y_off, const int x_off, + const uint16_t *const tx_masks) +{ + const TxfmInfo *const t_dim = &av1_txfm_dimensions[from]; + int is_split; + + if (depth > 1) { + is_split = 0; + } else { + const int off = y_off * 4 + x_off; + is_split = (tx_masks[depth] >> off) & 1; + } + + if (is_split) { + const enum RectTxfmSize sub = t_dim->sub; + const int htw4 = t_dim->w >> 1, hth4 = t_dim->h >> 1; + + decomp_tx(txa, sub, depth + 1, y_off * 2 + 0, x_off * 2 + 0, tx_masks); + if (t_dim->w >= t_dim->h) + decomp_tx((uint8_t(*)[2][32][32]) &txa[0][0][0][htw4], + sub, depth + 1, y_off * 2 + 0, x_off * 2 + 1, tx_masks); + if (t_dim->h >= t_dim->w) { + decomp_tx((uint8_t(*)[2][32][32]) &txa[0][0][hth4][0], + sub, depth + 1, y_off * 2 + 1, x_off * 2 + 0, tx_masks); + if (t_dim->w >= t_dim->h) + decomp_tx((uint8_t(*)[2][32][32]) &txa[0][0][hth4][htw4], + sub, depth + 1, y_off * 2 + 1, x_off * 2 + 1, tx_masks); + } + } else { + const int lw = imin(2, t_dim->lw), lh = imin(2, t_dim->lh); + int y; + + for (y = 0; y < t_dim->h; y++) { + memset(txa[0][0][y], lw, t_dim->w); + memset(txa[1][0][y], lh, t_dim->w); + txa[0][1][y][0] = t_dim->w; + } + memset(txa[1][1][0], t_dim->h, t_dim->w); + } +} + +static inline void mask_edges_inter(uint32_t (*masks)[32][3], + const int by4, const int bx4, + const int w4, const int h4, const int skip, + const enum RectTxfmSize max_tx, + const uint16_t *const tx_masks, + uint8_t *const a, uint8_t *const l) +{ + const TxfmInfo *const t_dim = &av1_txfm_dimensions[max_tx]; + int y, x; + + uint8_t txa[2 /* edge */][2 /* txsz, step */][32 /* y */][32 /* x */]; + int y_off, x_off; + for (y_off = 0, y = 0; y < h4; y += t_dim->h, y_off++) + for (x_off = 0, x = 0; x < w4; x += t_dim->w, x_off++) + decomp_tx((uint8_t(*)[2][32][32]) &txa[0][0][y][x], + max_tx, 0, y_off, x_off, tx_masks); + + // left block edge + unsigned mask = 1U << bx4; + for (y = 0; y < h4; y++) + masks[0][by4 + y][imin(txa[0][0][y][0], l[y])] |= mask; + + // top block edge + for (x = 0; x < w4; x++, mask <<= 1) + masks[1][by4][imin(txa[1][0][0][x], a[x])] |= mask; + + if (!skip) { + // inner (tx) left|right edges + for (y = 0; y < h4; y++) { + int ltx = txa[0][0][y][0]; + int step = txa[0][1][y][0]; + for (x = step, mask = 1U << (bx4 + step); + x < w4; x += step, mask <<= step) + { + const int rtx = txa[0][0][y][x]; + masks[0][by4 + y][imin(rtx, ltx)] |= mask; + ltx = rtx; + step = txa[0][1][y][x]; + } + } + + // top + // inner (tx) --- edges + // bottom + for (x = 0, mask = 1U << bx4; x < w4; x++, mask <<= 1) { + int ttx = txa[1][0][0][x]; + int step = txa[1][1][0][x]; + for (y = step; y < h4; y += step) { + const int btx = txa[1][0][y][x]; + masks[1][by4 + y][imin(ttx, btx)] |= mask; + ttx = btx; + step = txa[1][1][y][x]; + } + } + } + + for (y = 0; y < h4; y++) + l[y] = txa[0][0][y][w4 - 1]; + memcpy(a, txa[1][0][h4 - 1], w4); +} + +static inline void mask_edges_intra(uint32_t (*const masks)[32][3], + const int by4, const int bx4, + const int w4, const int h4, + const enum RectTxfmSize tx, + uint8_t *const a, uint8_t *const l) +{ + const TxfmInfo *const t_dim = &av1_txfm_dimensions[tx]; + const int twl4 = t_dim->lw, thl4 = t_dim->lh; + const int twl4c = imin(2, twl4), thl4c = imin(2, thl4); + int y, x; + + // left block edge + unsigned mask = 1U << bx4; + for (y = 0; y < h4; y++) + masks[0][by4 + y][imin(twl4c, l[y])] |= mask; + + // top block edge + for (mask = 1U << bx4, x = 0; x < w4; x++, mask <<= 1) + masks[1][by4][imin(thl4c, a[x])] |= mask; + + static const uint32_t hstep[] = { + 0xffffffff, 0x55555555, 0x11111111, 0x01010101, 0x00010001 + }; + + // inner (tx) left|right edges + const unsigned t = 1U << bx4; + const unsigned inner = (((uint64_t) t) << w4) - t; + mask = (inner - t) & hstep[twl4]; + for (y = 0; y < h4; y++) + masks[0][by4 + y][twl4c] |= mask; + + // top + // inner (tx) --- edges + // bottom + const int vstep = t_dim->h; + for (y = vstep; y < h4; y += vstep) + masks[1][by4 + y][thl4c] |= inner; + + memset(a, thl4c, w4); + memset(l, twl4c, h4); +} + +static inline void mask_edges_chroma(uint32_t (*const masks)[32][2], + const int cby4, const int cbx4, + const int cw4, const int ch4, + const int skip_inter, + const enum RectTxfmSize tx, + uint8_t *const a, uint8_t *const l) +{ + const TxfmInfo *const t_dim = &av1_txfm_dimensions[tx]; + const int twl4 = t_dim->lw, thl4 = t_dim->lh; + const int twl4c = !!twl4, thl4c = !!thl4; + int y, x; + + // left block edge + unsigned mask = 1U << cbx4; + for (y = 0; y < ch4; y++) + masks[0][cby4 + y][imin(twl4c, l[y])] |= mask; + + // top block edge + for (mask = 1U << cbx4, x = 0; x < cw4; x++, mask <<= 1) + masks[1][cby4][imin(thl4c, a[x])] |= mask; + + if (!skip_inter) { + static const uint32_t hstep[] = { + 0xffffffff, 0x55555555, 0x11111111, 0x01010101 + }; + + // inner (tx) left|right edges + const int t = 1U << cbx4; + const unsigned inner = (((uint64_t) t) << cw4) - t; + mask = (inner - t) & hstep[twl4]; + for (y = 0; y < ch4; y++) + masks[0][cby4 + y][twl4c] |= mask; + + // top + // inner (tx) --- edges + // bottom + const int vstep = t_dim->h; + for (y = vstep; y < ch4; y += vstep) + masks[1][cby4 + y][thl4c] |= inner; + } + + memset(a, thl4c, cw4); + memset(l, twl4c, ch4); +} + +void dav1d_create_lf_mask_intra(Av1Filter *const lflvl, + uint8_t (*level_cache)[4], + const ptrdiff_t b4_stride, + const Av1FrameHeader *const hdr, + const uint8_t (*filter_level)[8][2], + const int bx, const int by, + const int iw, const int ih, + const enum BlockSize bs, + const enum RectTxfmSize ytx, + const enum RectTxfmSize uvtx, + const enum Dav1dPixelLayout layout, + uint8_t *const ay, uint8_t *const ly, + uint8_t *const auv, uint8_t *const luv) +{ + if (!hdr->loopfilter.level_y[0] && !hdr->loopfilter.level_y[1]) + return; + + const uint8_t *const b_dim = av1_block_dimensions[bs]; + const int bw4 = imin(iw - bx, b_dim[0]); + const int bh4 = imin(ih - by, b_dim[1]); + const int bx4 = bx & 31; + const int by4 = by & 31; + + level_cache += by * b4_stride + bx; + for (int y = 0; y < bh4; y++) { + for (int x = 0; x < bw4; x++) { + level_cache[x][0] = filter_level[0][0][0]; + level_cache[x][1] = filter_level[1][0][0]; + level_cache[x][2] = filter_level[2][0][0]; + level_cache[x][3] = filter_level[3][0][0]; + } + level_cache += b4_stride; + } + + mask_edges_intra(lflvl->filter_y, by4, bx4, bw4, bh4, ytx, ay, ly); + + if (!auv) return; + + const int ss_ver = layout == DAV1D_PIXEL_LAYOUT_I420; + const int ss_hor = layout != DAV1D_PIXEL_LAYOUT_I444; + const int cbw4 = (bw4 + ss_hor) >> ss_hor; + const int cbh4 = (bh4 + ss_ver) >> ss_ver; + const int cbx4 = bx4 >> ss_hor; + const int cby4 = by4 >> ss_ver; + + mask_edges_chroma(lflvl->filter_uv, cby4, cbx4, cbw4, cbh4, 0, uvtx, auv, luv); +} + +void dav1d_create_lf_mask_inter(Av1Filter *const lflvl, + uint8_t (*level_cache)[4], + const ptrdiff_t b4_stride, + const Av1FrameHeader *const hdr, + const uint8_t (*filter_level)[8][2], + const int bx, const int by, + const int iw, const int ih, + const int skip, const enum BlockSize bs, + const uint16_t *const tx_masks, + const enum RectTxfmSize uvtx, + const enum Dav1dPixelLayout layout, + uint8_t *const ay, uint8_t *const ly, + uint8_t *const auv, uint8_t *const luv) +{ + if (!hdr->loopfilter.level_y[0] && !hdr->loopfilter.level_y[1]) + return; + + const uint8_t *const b_dim = av1_block_dimensions[bs]; + const int bw4 = imin(iw - bx, b_dim[0]); + const int bh4 = imin(ih - by, b_dim[1]); + const int bx4 = bx & 31; + const int by4 = by & 31; + + level_cache += by * b4_stride + bx; + for (int y = 0; y < bh4; y++) { + for (int x = 0; x < bw4; x++) { + level_cache[x][0] = filter_level[0][0][0]; + level_cache[x][1] = filter_level[1][0][0]; + level_cache[x][2] = filter_level[2][0][0]; + level_cache[x][3] = filter_level[3][0][0]; + } + level_cache += b4_stride; + } + + mask_edges_inter(lflvl->filter_y, by4, bx4, bw4, bh4, skip, + av1_max_txfm_size_for_bs[bs][0], tx_masks, ay, ly); + + if (!auv) return; + + const int ss_ver = layout == DAV1D_PIXEL_LAYOUT_I420; + const int ss_hor = layout != DAV1D_PIXEL_LAYOUT_I444; + const int cbw4 = (bw4 + ss_hor) >> ss_hor; + const int cbh4 = (bh4 + ss_ver) >> ss_ver; + const int cbx4 = bx4 >> ss_hor; + const int cby4 = by4 >> ss_ver; + + mask_edges_chroma(lflvl->filter_uv, cby4, cbx4, cbw4, cbh4, skip, uvtx, auv, luv); +} + +void dav1d_calc_eih(Av1FilterLUT *const lim_lut, const int filter_sharpness) { + int level; + + // set E/I/H values from loopfilter level + for (level = 0; level < 64; level++) { + const int sharp = filter_sharpness; + int limit = level; + + if (sharp > 0) { + limit >>= (sharp + 3) >> 2; + limit = imin(limit, 9 - sharp); + } + limit = imax(limit, 1); + + lim_lut->i[level] = limit; + lim_lut->e[level] = 2 * (level + 2) + limit; + } +} + +static void dav1d_calc_lf_value(uint8_t (*const lflvl_values)[2], + const int is_chroma, const int base_lvl, + const int lf_delta, const int seg_delta, + const Av1LoopfilterModeRefDeltas *const mr_delta) +{ + const int base = iclip(iclip(base_lvl + lf_delta, 0, 63) + seg_delta, 0, 63); + + if (!base_lvl && is_chroma) { + memset(lflvl_values, 0, 8 * 2); + } else if (!mr_delta) { + memset(lflvl_values, base, 8 * 2); + } else { + const int sh = base >= 32; + lflvl_values[0][0] = lflvl_values[0][1] = + iclip(base + (mr_delta->ref_delta[0] * (1 << sh)), 0, 63); + for (int r = 1; r < 8; r++) { + for (int m = 0; m < 2; m++) { + const int delta = + mr_delta->mode_delta[m] + mr_delta->ref_delta[r]; + lflvl_values[r][m] = iclip(base + (delta * (1 << sh)), 0, 63); + } + } + } +} + +void dav1d_calc_lf_values(uint8_t (*const lflvl_values)[4][8][2], + const Av1FrameHeader *const hdr, + const int8_t lf_delta[4]) +{ + const int n_seg = hdr->segmentation.enabled ? 8 : 1; + + if (!hdr->loopfilter.level_y[0] && !hdr->loopfilter.level_y[1]) { + memset(lflvl_values, 0, 8 * 4 * 2 * n_seg); + return; + } + + const Av1LoopfilterModeRefDeltas *const mr_deltas = + hdr->loopfilter.mode_ref_delta_enabled ? + &hdr->loopfilter.mode_ref_deltas : NULL; + for (int s = 0; s < n_seg; s++) { + const Av1SegmentationData *const segd = + hdr->segmentation.enabled ? &hdr->segmentation.seg_data.d[s] : NULL; + + dav1d_calc_lf_value(lflvl_values[s][0], 0, hdr->loopfilter.level_y[0], + lf_delta[0], segd ? segd->delta_lf_y_v : 0, mr_deltas); + dav1d_calc_lf_value(lflvl_values[s][1], 0, hdr->loopfilter.level_y[1], + lf_delta[hdr->delta_lf_multi ? 1 : 0], + segd ? segd->delta_lf_y_h : 0, mr_deltas); + dav1d_calc_lf_value(lflvl_values[s][2], 1, hdr->loopfilter.level_u, + lf_delta[hdr->delta_lf_multi ? 2 : 0], + segd ? segd->delta_lf_u : 0, mr_deltas); + dav1d_calc_lf_value(lflvl_values[s][3], 1, hdr->loopfilter.level_v, + lf_delta[hdr->delta_lf_multi ? 3 : 0], + segd ? segd->delta_lf_v : 0, mr_deltas); + } +} diff --git a/src/lf_mask.h b/src/lf_mask.h new file mode 100644 index 0000000..ed7412a --- /dev/null +++ b/src/lf_mask.h @@ -0,0 +1,80 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_SRC_LF_MASK_H__ +#define __DAV1D_SRC_LF_MASK_H__ + +#include <stddef.h> +#include <stdint.h> + +#include "src/levels.h" + +typedef struct Av1FilterLUT { + uint8_t e[64]; + uint8_t i[64]; +} Av1FilterLUT; + +typedef struct Av1RestorationUnit { + enum RestorationType type; + int16_t filter_h[3]; + int16_t filter_v[3]; + uint8_t sgr_idx; + int16_t sgr_weights[2]; +} Av1RestorationUnit; + +// each struct describes one 128x128 area (1 or 4 SBs) +typedef struct Av1Filter { + // each bit is 1 col + uint32_t filter_y[2 /* 0=col, 1=row */][32][3]; + uint32_t filter_uv[2 /* 0=col, 1=row */][32][2]; + int8_t cdef_idx[4]; // -1 means "unset" + uint32_t noskip_mask[32]; + Av1RestorationUnit lr[3][4]; +} Av1Filter; + +void dav1d_create_lf_mask_intra(Av1Filter *lflvl, uint8_t (*level_cache)[4], + const ptrdiff_t b4_stride, + const Av1FrameHeader *hdr, + const uint8_t (*level)[8][2], int bx, int by, + int iw, int ih, enum BlockSize bs, + enum RectTxfmSize ytx, enum RectTxfmSize uvtx, + enum Dav1dPixelLayout layout, uint8_t *ay, + uint8_t *ly, uint8_t *auv, uint8_t *luv); +void dav1d_create_lf_mask_inter(Av1Filter *lflvl, uint8_t (*level_cache)[4], + const ptrdiff_t b4_stride, + const Av1FrameHeader *hdr, + const uint8_t (*level)[8][2], int bx, int by, + int iw, int ih, int skip_inter, + enum BlockSize bs, const uint16_t *tx_mask, + enum RectTxfmSize uvtx, + enum Dav1dPixelLayout layout, uint8_t *ay, + uint8_t *ly, uint8_t *auv, uint8_t *luv); +void dav1d_calc_eih(Av1FilterLUT *lim_lut, int filter_sharpness); +void dav1d_calc_lf_values(uint8_t (*values)[4][8][2], const Av1FrameHeader *hdr, + const int8_t lf_delta[4]); + +#endif /* __DAV1D_SRC_LF_MASK_H__ */ diff --git a/src/lib.c b/src/lib.c new file mode 100644 index 0000000..7954f49 --- /dev/null +++ b/src/lib.c @@ -0,0 +1,297 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <errno.h> +#include <string.h> + +#include "dav1d/dav1d.h" +#include "dav1d/data.h" + +#include "include/version.h" + +#include "common/mem.h" +#include "common/validate.h" + +#include "src/internal.h" +#include "src/obu.h" +#include "src/qm.h" +#include "src/ref.h" +#include "src/thread_task.h" +#include "src/wedge.h" + +void dav1d_init(void) { + av1_init_wedge_masks(); + av1_init_interintra_masks(); + av1_init_qm_tables(); +} + +const char *dav1d_version(void) { + return DAV1D_VERSION; +} + +void dav1d_default_settings(Dav1dSettings *const s) { + s->n_frame_threads = 1; + s->n_tile_threads = 1; +} + +int dav1d_open(Dav1dContext **const c_out, + const Dav1dSettings *const s) +{ + validate_input_or_ret(c_out != NULL, -EINVAL); + validate_input_or_ret(s != NULL, -EINVAL); + validate_input_or_ret(s->n_tile_threads >= 1 && + s->n_tile_threads <= 64, -EINVAL); + validate_input_or_ret(s->n_frame_threads >= 1 && + s->n_frame_threads <= 256, -EINVAL); + + Dav1dContext *const c = *c_out = dav1d_alloc_aligned(sizeof(*c), 32); + if (!c) goto error; + memset(c, 0, sizeof(*c)); + + c->n_fc = s->n_frame_threads; + c->fc = dav1d_alloc_aligned(sizeof(*c->fc) * s->n_frame_threads, 32); + if (!c->fc) goto error; + memset(c->fc, 0, sizeof(*c->fc) * s->n_frame_threads); + if (c->n_fc > 1) { + c->frame_thread.out_delayed = + malloc(sizeof(*c->frame_thread.out_delayed) * c->n_fc); + memset(c->frame_thread.out_delayed, 0, + sizeof(*c->frame_thread.out_delayed) * c->n_fc); + } + for (int n = 0; n < s->n_frame_threads; n++) { + Dav1dFrameContext *const f = &c->fc[n]; + f->c = c; + f->lf.last_sharpness = -1; + f->n_tc = s->n_tile_threads; + f->tc = dav1d_alloc_aligned(sizeof(*f->tc) * s->n_tile_threads, 32); + if (!f->tc) goto error; + memset(f->tc, 0, sizeof(*f->tc) * s->n_tile_threads); + if (f->n_tc > 1) { + pthread_mutex_init(&f->tile_thread.lock, NULL); + pthread_cond_init(&f->tile_thread.cond, NULL); + pthread_cond_init(&f->tile_thread.icond, NULL); + } + for (int m = 0; m < s->n_tile_threads; m++) { + Dav1dTileContext *const t = &f->tc[m]; + t->f = f; + t->cf = dav1d_alloc_aligned(32 * 32 * sizeof(int32_t), 32); + if (!t->cf) goto error; + t->scratch.mem = dav1d_alloc_aligned(128 * 128 * 8, 32); + if (!t->scratch.mem) goto error; + memset(t->cf, 0, 32 * 32 * sizeof(int32_t)); + t->emu_edge = + dav1d_alloc_aligned(160 * (128 + 7) * sizeof(uint16_t), 32); + if (!t->emu_edge) goto error; + if (f->n_tc > 1) { + pthread_mutex_init(&t->tile_thread.td.lock, NULL); + pthread_cond_init(&t->tile_thread.td.cond, NULL); + t->tile_thread.fttd = &f->tile_thread; + pthread_create(&t->tile_thread.td.thread, NULL, dav1d_tile_task, t); + } + } + f->libaom_cm = av1_alloc_ref_mv_common(); + if (c->n_fc > 1) { + pthread_mutex_init(&f->frame_thread.td.lock, NULL); + pthread_cond_init(&f->frame_thread.td.cond, NULL); + pthread_create(&f->frame_thread.td.thread, NULL, dav1d_frame_task, f); + } + } + + // intra edge tree + c->intra_edge.root[BL_128X128] = &c->intra_edge.branch_sb128[0].node; + init_mode_tree(c->intra_edge.root[BL_128X128], c->intra_edge.tip_sb128, 1); + c->intra_edge.root[BL_64X64] = &c->intra_edge.branch_sb64[0].node; + init_mode_tree(c->intra_edge.root[BL_64X64], c->intra_edge.tip_sb64, 0); + + return 0; + +error: + if (c) { + if (c->fc) { + for (int n = 0; n < c->n_fc; n++) + if (c->fc[n].tc) + free(c->fc[n].tc); + free(c->fc); + } + free(c); + } + fprintf(stderr, "Failed to allocate memory: %s\n", strerror(errno)); + return -ENOMEM; +} + +int dav1d_decode(Dav1dContext *const c, + Dav1dData *const in, Dav1dPicture *const out) +{ + int res; + + validate_input_or_ret(c != NULL, -EINVAL); + validate_input_or_ret(out != NULL, -EINVAL); + + while (!in) { + if (c->n_fc == 1) return -EAGAIN; + + // flush + const unsigned next = c->frame_thread.next; + Dav1dFrameContext *const f = &c->fc[next]; + + pthread_mutex_lock(&f->frame_thread.td.lock); + while (f->n_tile_data > 0) + pthread_cond_wait(&f->frame_thread.td.cond, + &f->frame_thread.td.lock); + pthread_mutex_unlock(&f->frame_thread.td.lock); + Dav1dThreadPicture *const out_delayed = + &c->frame_thread.out_delayed[next]; + if (out_delayed->p.data[0]) { + if (++c->frame_thread.next == c->n_fc) + c->frame_thread.next = 0; + if (out_delayed->visible) { + dav1d_picture_ref(out, &out_delayed->p); + } + dav1d_thread_picture_unref(out_delayed); + if (out->data[0]) { + return 0; + } + // else continue + } else { + return -EAGAIN; + } + } + + while (in->sz > 0) { + if ((res = parse_obus(c, in)) < 0) + return res; + + assert(res <= in->sz); + in->sz -= res; + in->data += res; + if (c->out.data[0]) { + if (!in->sz) dav1d_data_unref(in); + dav1d_picture_ref(out, &c->out); + dav1d_picture_unref(&c->out); + return 0; + } + } + + if (c->out.data[0]) { + dav1d_picture_ref(out, &c->out); + dav1d_picture_unref(&c->out); + return 0; + } + + return -EAGAIN; +} + +void dav1d_close(Dav1dContext *const c) { + validate_input(c != NULL); + + for (int n = 0; n < c->n_fc; n++) { + Dav1dFrameContext *const f = &c->fc[n]; + + // clean-up threading stuff + if (c->n_fc > 1) { + pthread_mutex_lock(&f->frame_thread.td.lock); + f->frame_thread.die = 1; + pthread_cond_signal(&f->frame_thread.td.cond); + pthread_mutex_unlock(&f->frame_thread.td.lock); + pthread_join(f->frame_thread.td.thread, NULL); + freep(&f->frame_thread.b); + dav1d_free_aligned(&f->frame_thread.pal_idx); + dav1d_free_aligned(&f->frame_thread.cf); + freep(&f->frame_thread.tile_start_off); + freep(&f->frame_thread.pal); + freep(&f->frame_thread.cbi); + pthread_mutex_destroy(&f->frame_thread.td.lock); + pthread_cond_destroy(&f->frame_thread.td.cond); + } + if (f->n_tc > 1) { + pthread_mutex_lock(&f->tile_thread.lock); + for (int m = 0; m < f->n_tc; m++) { + Dav1dTileContext *const t = &f->tc[m]; + t->tile_thread.die = 1; + } + pthread_cond_broadcast(&f->tile_thread.cond); + while (f->tile_thread.available != (1 << f->n_tc) - 1) + pthread_cond_wait(&f->tile_thread.icond, + &f->tile_thread.lock); + pthread_mutex_unlock(&f->tile_thread.lock); + for (int m = 0; m < f->n_tc; m++) { + Dav1dTileContext *const t = &f->tc[m]; + if (f->n_tc > 1) { + pthread_join(t->tile_thread.td.thread, NULL); + pthread_mutex_destroy(&t->tile_thread.td.lock); + pthread_cond_destroy(&t->tile_thread.td.cond); + } + } + pthread_mutex_destroy(&f->tile_thread.lock); + pthread_cond_destroy(&f->tile_thread.cond); + pthread_cond_destroy(&f->tile_thread.icond); + } + for (int m = 0; m < f->n_tc; m++) { + Dav1dTileContext *const t = &f->tc[m]; + dav1d_free_aligned(t->cf); + dav1d_free_aligned(t->scratch.mem); + dav1d_free_aligned(t->emu_edge); + } + for (int m = 0; m < f->n_ts; m++) { + Dav1dTileState *const ts = &f->ts[m]; + pthread_cond_destroy(&ts->tile_thread.cond); + pthread_mutex_destroy(&ts->tile_thread.lock); + } + free(f->ts); + dav1d_free_aligned(f->tc); + dav1d_free_aligned(f->ipred_edge[0]); + free(f->a); + free(f->lf.mask); + free(f->lf.level); + free(f->lf.tx_lpf_right_edge[0]); + av1_free_ref_mv_common(f->libaom_cm); + dav1d_free_aligned(f->lf.cdef_line); + dav1d_free_aligned(f->lf.lr_lpf_line); + } + dav1d_free_aligned(c->fc); + if (c->n_fc > 1) { + for (int n = 0; n < c->n_fc; n++) + if (c->frame_thread.out_delayed[n].p.data[0]) + dav1d_thread_picture_unref(&c->frame_thread.out_delayed[n]); + free(c->frame_thread.out_delayed); + } + for (int n = 0; n < c->n_tile_data; n++) + dav1d_data_unref(&c->tile[n].data); + for (int n = 0; n < 8; n++) { + if (c->cdf[n].cdf) + cdf_thread_unref(&c->cdf[n]); + if (c->refs[n].p.p.data[0]) + dav1d_thread_picture_unref(&c->refs[n].p); + if (c->refs[n].refmvs) + dav1d_ref_dec(c->refs[n].refmvs); + if (c->refs[n].segmap) + dav1d_ref_dec(c->refs[n].segmap); + } + dav1d_free_aligned(c); +} diff --git a/src/loopfilter.c b/src/loopfilter.c new file mode 100644 index 0000000..a460eb7 --- /dev/null +++ b/src/loopfilter.c @@ -0,0 +1,195 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <stdlib.h> + +#include "common/intops.h" + +#include "src/loopfilter.h" + +static __attribute__((noinline)) void +loop_filter(pixel *dst, int E, int I, int H, + const ptrdiff_t stridea, const ptrdiff_t strideb, const int wd) +{ + int i, F = 1 << (BITDEPTH - 8); + + E <<= BITDEPTH - 8; + I <<= BITDEPTH - 8; + H <<= BITDEPTH - 8; + + for (i = 0; i < 4; i++, dst += stridea) { + int p6, p5, p4, p3, p2; + int p1 = dst[strideb * -2], p0 = dst[strideb * -1]; + int q0 = dst[strideb * +0], q1 = dst[strideb * +1]; + int q2, q3, q4, q5, q6; + int fm, flat8out, flat8in; + + fm = abs(p1 - p0) <= I && abs(q1 - q0) <= I && + abs(p0 - q0) * 2 + (abs(p1 - q1) >> 1) <= E; + + if (wd > 4) { + p2 = dst[strideb * -3]; + q2 = dst[strideb * +2]; + + fm &= abs(p2 - p1) <= I && abs(q2 - q1) <= I; + + if (wd > 6) { + p3 = dst[strideb * -4]; + q3 = dst[strideb * +3]; + + fm &= abs(p3 - p2) <= I && abs(q3 - q2) <= I; + } + } + + if (!fm) continue; + + if (wd >= 16) { + p6 = dst[strideb * -7]; + p5 = dst[strideb * -6]; + p4 = dst[strideb * -5]; + q4 = dst[strideb * +4]; + q5 = dst[strideb * +5]; + q6 = dst[strideb * +6]; + + flat8out = abs(p6 - p0) <= F && abs(p5 - p0) <= F && + abs(p4 - p0) <= F && abs(q4 - q0) <= F && + abs(q5 - q0) <= F && abs(q6 - q0) <= F; + } + + if (wd >= 6) + flat8in = abs(p2 - p0) <= F && abs(p1 - p0) <= F && + abs(q1 - q0) <= F && abs(q2 - q0) <= F; + + if (wd >= 8) + flat8in &= abs(p3 - p0) <= F && abs(q3 - q0) <= F; + + if (wd >= 16 && (flat8out & flat8in)) { + dst[strideb * -6] = (p6 + p6 + p6 + p6 + p6 + p6 * 2 + p5 * 2 + + p4 * 2 + p3 + p2 + p1 + p0 + q0 + 8) >> 4; + dst[strideb * -5] = (p6 + p6 + p6 + p6 + p6 + p5 * 2 + p4 * 2 + + p3 * 2 + p2 + p1 + p0 + q0 + q1 + 8) >> 4; + dst[strideb * -4] = (p6 + p6 + p6 + p6 + p5 + p4 * 2 + p3 * 2 + + p2 * 2 + p1 + p0 + q0 + q1 + q2 + 8) >> 4; + dst[strideb * -3] = (p6 + p6 + p6 + p5 + p4 + p3 * 2 + p2 * 2 + + p1 * 2 + p0 + q0 + q1 + q2 + q3 + 8) >> 4; + dst[strideb * -2] = (p6 + p6 + p5 + p4 + p3 + p2 * 2 + p1 * 2 + + p0 * 2 + q0 + q1 + q2 + q3 + q4 + 8) >> 4; + dst[strideb * -1] = (p6 + p5 + p4 + p3 + p2 + p1 * 2 + p0 * 2 + + q0 * 2 + q1 + q2 + q3 + q4 + q5 + 8) >> 4; + dst[strideb * +0] = (p5 + p4 + p3 + p2 + p1 + p0 * 2 + q0 * 2 + + q1 * 2 + q2 + q3 + q4 + q5 + q6 + 8) >> 4; + dst[strideb * +1] = (p4 + p3 + p2 + p1 + p0 + q0 * 2 + q1 * 2 + + q2 * 2 + q3 + q4 + q5 + q6 + q6 + 8) >> 4; + dst[strideb * +2] = (p3 + p2 + p1 + p0 + q0 + q1 * 2 + q2 * 2 + + q3 * 2 + q4 + q5 + q6 + q6 + q6 + 8) >> 4; + dst[strideb * +3] = (p2 + p1 + p0 + q0 + q1 + q2 * 2 + q3 * 2 + + q4 * 2 + q5 + q6 + q6 + q6 + q6 + 8) >> 4; + dst[strideb * +4] = (p1 + p0 + q0 + q1 + q2 + q3 * 2 + q4 * 2 + + q5 * 2 + q6 + q6 + q6 + q6 + q6 + 8) >> 4; + dst[strideb * +5] = (p0 + q0 + q1 + q2 + q3 + q4 * 2 + q5 * 2 + + q6 * 2 + q6 + q6 + q6 + q6 + q6 + 8) >> 4; + } else if (wd >= 8 && flat8in) { + dst[strideb * -3] = (p3 + p3 + p3 + 2 * p2 + p1 + p0 + q0 + 4) >> 3; + dst[strideb * -2] = (p3 + p3 + p2 + 2 * p1 + p0 + q0 + q1 + 4) >> 3; + dst[strideb * -1] = (p3 + p2 + p1 + 2 * p0 + q0 + q1 + q2 + 4) >> 3; + dst[strideb * +0] = (p2 + p1 + p0 + 2 * q0 + q1 + q2 + q3 + 4) >> 3; + dst[strideb * +1] = (p1 + p0 + q0 + 2 * q1 + q2 + q3 + q3 + 4) >> 3; + dst[strideb * +2] = (p0 + q0 + q1 + 2 * q2 + q3 + q3 + q3 + 4) >> 3; + } else if (wd == 6 && flat8in) { + dst[strideb * -2] = (p2 + 2 * p2 + 2 * p1 + 2 * p0 + q0 + 4) >> 3; + dst[strideb * -1] = (p2 + 2 * p1 + 2 * p0 + 2 * q0 + q1 + 4) >> 3; + dst[strideb * +0] = (p1 + 2 * p0 + 2 * q0 + 2 * q1 + q2 + 4) >> 3; + dst[strideb * +1] = (p0 + 2 * q0 + 2 * q1 + 2 * q2 + q2 + 4) >> 3; + } else { + int hev = abs(p1 - p0) > H || abs(q1 - q0) > H; + +#define iclip_diff(v) iclip(v, -128 * (1 << (BITDEPTH - 8)), \ + 127 * (1 << (BITDEPTH - 8))) + + if (hev) { + int f = iclip_diff(p1 - q1), f1, f2; + f = iclip_diff(3 * (q0 - p0) + f); + + f1 = imin(f + 4, 127) >> 3; + f2 = imin(f + 3, 127) >> 3; + + dst[strideb * -1] = iclip_pixel(p0 + f2); + dst[strideb * +0] = iclip_pixel(q0 - f1); + } else { + int f = iclip_diff(3 * (q0 - p0)), f1, f2; + + f1 = imin(f + 4, 127) >> 3; + f2 = imin(f + 3, 127) >> 3; + + dst[strideb * -1] = iclip_pixel(p0 + f2); + dst[strideb * +0] = iclip_pixel(q0 - f1); + + f = (f1 + 1) >> 1; + dst[strideb * -2] = iclip_pixel(p1 + f); + dst[strideb * +1] = iclip_pixel(q1 - f); + } +#undef iclip_diff + } + } +} + +#define lf_4_fn(dir, wd, stridea, strideb) \ +static void loop_filter_##dir##_##wd##wd_4px_c(pixel *const dst, \ + const ptrdiff_t stride, \ + const int E, const int I, \ + const int H) \ +{ \ + loop_filter(dst, E, I, H, stridea, strideb, wd); \ +} + +#define lf_4_fns(wd) \ +lf_4_fn(h, wd, PXSTRIDE(stride), 1) \ +lf_4_fn(v, wd, 1, PXSTRIDE(stride)) + +lf_4_fns(4) +lf_4_fns(6) +lf_4_fns(8) +lf_4_fns(16) + +#undef lf_4_fn +#undef lf_4_fns + +void bitfn(dav1d_loop_filter_dsp_init)(Dav1dLoopFilterDSPContext *const c) { + c->loop_filter[0][0] = loop_filter_h_4wd_4px_c; + c->loop_filter[0][1] = loop_filter_v_4wd_4px_c; + c->loop_filter[1][0] = loop_filter_h_8wd_4px_c; + c->loop_filter[1][1] = loop_filter_v_8wd_4px_c; + c->loop_filter[2][0] = loop_filter_h_16wd_4px_c; + c->loop_filter[2][1] = loop_filter_v_16wd_4px_c; + + c->loop_filter_uv[0][0] = loop_filter_h_4wd_4px_c; + c->loop_filter_uv[0][1] = loop_filter_v_4wd_4px_c; + c->loop_filter_uv[1][0] = loop_filter_h_6wd_4px_c; + c->loop_filter_uv[1][1] = loop_filter_v_6wd_4px_c; +} diff --git a/src/loopfilter.h b/src/loopfilter.h new file mode 100644 index 0000000..4676978 --- /dev/null +++ b/src/loopfilter.h @@ -0,0 +1,56 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_SRC_LOOPFILTER_H__ +#define __DAV1D_SRC_LOOPFILTER_H__ + +#include <stdint.h> +#include <stddef.h> + +#include "common/bitdepth.h" + +#include "src/levels.h" + +#define decl_loopfilter_fn(name) \ +void (name)(pixel *dst, ptrdiff_t stride, int mb_lim, int lim, int hev_thr); +typedef decl_loopfilter_fn(*loopfilter_fn); + +typedef struct Dav1dLoopFilterDSPContext { + /* + * dimension 1: filter taps (0=4, 1=8, 2=16 for luma; 0=4, 1=6 for chroma) + * dimension 2: 0=col-edge filter (h), 1=row-edge filter (v) + * + * dst/stride are aligned by 4 + */ + loopfilter_fn loop_filter[3][2]; + loopfilter_fn loop_filter_uv[2][2]; +} Dav1dLoopFilterDSPContext; + +void dav1d_loop_filter_dsp_init_8bpc(Dav1dLoopFilterDSPContext *c); +void dav1d_loop_filter_dsp_init_10bpc(Dav1dLoopFilterDSPContext *c); + +#endif /* __DAV1D_SRC_LOOPFILTER_H__ */ diff --git a/src/looprestoration.c b/src/looprestoration.c new file mode 100644 index 0000000..a08d3a5 --- /dev/null +++ b/src/looprestoration.c @@ -0,0 +1,577 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <stdlib.h> + +#include "common/intops.h" + +#include "src/looprestoration.h" +#include "src/tables.h" + + +// TODO Reuse p when no padding is needed (add and remove lpf pixels in p) +// TODO Chroma only requires 2 rows of padding. +static void padding(pixel *dst, const ptrdiff_t dst_stride, + const pixel *p, const ptrdiff_t p_stride, + const pixel *lpf, const ptrdiff_t lpf_stride, + int unit_w, const int stripe_h, const enum LrEdgeFlags edges) +{ + const int have_left = !!(edges & LR_HAVE_LEFT); + const int have_right = !!(edges & LR_HAVE_RIGHT); + + // Copy more pixels if we don't have to pad them + unit_w += 3 * have_left + 3 * have_right; + pixel *dst_l = dst + 3 * !have_left; + p -= 3 * have_left; + lpf -= 3 * have_left; + + if (edges & LR_HAVE_TOP) { + // Copy previous loop filtered rows + const pixel *const above_1 = lpf; + const pixel *const above_2 = above_1 + PXSTRIDE(lpf_stride); + pixel_copy(dst_l, above_1, unit_w); + pixel_copy(dst_l + PXSTRIDE(dst_stride), above_1, unit_w); + pixel_copy(dst_l + 2 * PXSTRIDE(dst_stride), above_2, unit_w); + } else { + // Pad with first row + pixel_copy(dst_l, p, unit_w); + pixel_copy(dst_l + PXSTRIDE(dst_stride), p, unit_w); + pixel_copy(dst_l + 2 * PXSTRIDE(dst_stride), p, unit_w); + } + + pixel *dst_tl = dst_l + 3 * PXSTRIDE(dst_stride); + if (edges & LR_HAVE_BOTTOM) { + // Copy next loop filtered rows + const pixel *const below_1 = lpf + 6 * PXSTRIDE(lpf_stride); + const pixel *const below_2 = below_1 + PXSTRIDE(lpf_stride); + pixel_copy(dst_tl + stripe_h * PXSTRIDE(dst_stride), below_1, unit_w); + pixel_copy(dst_tl + (stripe_h + 1) * PXSTRIDE(dst_stride), below_2, unit_w); + pixel_copy(dst_tl + (stripe_h + 2) * PXSTRIDE(dst_stride), below_2, unit_w); + } else { + // Pad with last row + const pixel *const src = p + (stripe_h - 1) * PXSTRIDE(p_stride); + pixel_copy(dst_tl + stripe_h * PXSTRIDE(dst_stride), src, unit_w); + pixel_copy(dst_tl + (stripe_h + 1) * PXSTRIDE(dst_stride), src, unit_w); + pixel_copy(dst_tl + (stripe_h + 2) * PXSTRIDE(dst_stride), src, unit_w); + } + + // Inner UNIT_WxSTRIPE_H + for (int j = 0; j < stripe_h; j++) { + pixel_copy(dst_tl, p, unit_w); + dst_tl += PXSTRIDE(dst_stride); + p += PXSTRIDE(p_stride); + } + + if (!have_right) { + pixel *pad = dst_l + unit_w; + pixel *row_last = &dst_l[unit_w - 1]; + // Pad 3x(STRIPE_H+6) with last column + for (int j = 0; j < stripe_h + 6; j++) { + pixel_set(pad, *row_last, 3); + pad += PXSTRIDE(dst_stride); + row_last += PXSTRIDE(dst_stride); + } + } + + if (!have_left) { + // Pad 3x(STRIPE_H+6) with first column + for (int j = 0; j < stripe_h + 6; j++) { + pixel_set(dst, *dst_l, 3); + dst += PXSTRIDE(dst_stride); + dst_l += PXSTRIDE(dst_stride); + } + } +} + +// FIXME Could split into luma and chroma specific functions, +// (since first and last tops are always 0 for chroma) +// FIXME Could implement a version that requires less temporary memory +// (should be possible to implement with only 6 rows of temp storage) +static void wiener_c(pixel *p, const ptrdiff_t p_stride, + const pixel *lpf, const ptrdiff_t lpf_stride, + const int w, const int h, + const int16_t filterh[7], const int16_t filterv[7], + const enum LrEdgeFlags edges) +{ + // padding is 3 pixels above and 3 pixels below + const ptrdiff_t tmp_stride = sizeof(pixel) * (w + 6); + pixel tmp[(h + 6) * PXSTRIDE(tmp_stride)]; + pixel *tmp_ptr = tmp; + + padding(tmp, tmp_stride, p, p_stride, lpf, lpf_stride, w, h, edges); + + // Values stored between horizontal and vertical filtering don't + // fit in a uint8_t. + uint16_t hor[(h + 6 /*padding*/) * w]; + uint16_t *hor_ptr = hor; + + const int round_bits_h = 3 + (BITDEPTH == 12) * 2; + const int rounding_off_h = 1 << (round_bits_h - 1); + const int clip_limit = 1 << ((BITDEPTH) + 1 + 7 - round_bits_h); + for (int j = 0; j < h + 6; j++) { + for (int i = 0; i < w; i++) { + int sum = (tmp_ptr[i + 3] << 7) + (1 << (BITDEPTH + 6)); + + for (int k = 0; k < 7; k++) { + sum += tmp_ptr[i + k] * filterh[k]; + } + + hor_ptr[i] = + iclip((sum + rounding_off_h) >> round_bits_h, 0, clip_limit); + } + tmp_ptr += PXSTRIDE(tmp_stride); + hor_ptr += w; + } + + const int round_bits_v = 11 - (BITDEPTH == 12) * 2; + const int rounding_off_v = 1 << (round_bits_v - 1); + const int round_offset = 1 << (BITDEPTH + (round_bits_v - 1)); + for (int i = 0; i < w; i++) { + for (int j = 0; j < h; j++) { + int sum = (hor[w * (j + 3) + i] << 7) - round_offset; + + for (int k = 0; k < 7; k++) { + sum += hor[(j + k) * w + i] * filterv[k]; + } + + p[j * PXSTRIDE(p_stride) + i] = + iclip_pixel((sum + rounding_off_v) >> round_bits_v); + } + } +} + +// Sum over a 3x3 area +// The dst and src pointers are positioned 3 pixels above and 3 pixels to the +// left of the top left corner. However, the self guided filter only needs 1 +// pixel above and one pixel to the left. As for the pixels below and to the +// right they must be computed in the sums, but don't need to be stored. +// +// Example for a 4x4 block: +// x x x x x x x x x x +// x c c c c c c c c x +// x i s s s s s s i x +// x i s s s s s s i x +// x i s s s s s s i x +// x i s s s s s s i x +// x i s s s s s s i x +// x i s s s s s s i x +// x c c c c c c c c x +// x x x x x x x x x x +// +// s: Pixel summed and stored +// i: Pixel summed and stored (between loops) +// c: Pixel summed not stored +// x: Pixel not summed not stored +static void boxsum3(coef *dst, const ptrdiff_t dst_stride, + const pixel *src, ptrdiff_t src_stride, + const int w, const int h) +{ + src_stride = PXSTRIDE(src_stride); + // We skip the first row, as it is never used + src += src_stride; + dst += dst_stride; + + // We skip the first and last columns, as they are never used + for (int x = 1; x < w - 1; x++) { + coef *ds = dst + x; + const pixel *s = src + x; + int a = s[0], b = s[src_stride]; + + // We skip the first 2 rows, as they are skipped in the next loop and + // we don't need the last 2 row as it is skipped in the next loop + for (int y = 2; y < h - 2; y++) { + s += src_stride; + const int c = s[src_stride]; + ds += dst_stride; + *ds = a + b + c; + a = b; + b = c; + } + } + + // We skip the first 2 rows as they are never read + dst += dst_stride; + // We skip the last 2 rows as it is never read + for (int y = 2; y < h - 2; y++) { + int a = dst[1], b = dst[2]; + + // We don't store the first column as it is never read and + // we don't store the last 2 columns as they are never read + for (int x = 2; x < w - 2; x++) { + const int c = dst[x + 1]; + dst[x] = a + b + c; + a = b; + b = c; + } + dst += dst_stride; + } +} + +// Sum over a 5x5 area +// The dst and src pointers are positioned 3 pixels above and 3 pixels to the +// left of the top left corner. However, the self guided filter only needs 1 +// pixel above and one pixel to the left. As for the pixels below and to the +// right they must be computed in the sums, but don't need to be stored. +// +// Example for a 4x4 block: +// c c c c c c c c c c +// c c c c c c c c c c +// i i s s s s s s i i +// i i s s s s s s i i +// i i s s s s s s i i +// i i s s s s s s i i +// i i s s s s s s i i +// i i s s s s s s i i +// c c c c c c c c c c +// c c c c c c c c c c +// +// s: Pixel summed and stored +// i: Pixel summed and stored (between loops) +// c: Pixel summed not stored +// x: Pixel not summed not stored +static void boxsum5(coef *dst, const ptrdiff_t dst_stride, + const pixel *const src, ptrdiff_t src_stride, + const int w, const int h) +{ + src_stride = PXSTRIDE(src_stride); + + // We skip the first row, as it is never used + dst += dst_stride; + + for (int x = 0; x < w; x++) { + coef *ds = dst + x; + const pixel *s = src + 3 * src_stride + x; + int a = s[-3 * src_stride]; + int b = s[-2 * src_stride]; + int c = s[-1 * src_stride]; + int d = s[0]; + + // We skip the first 2 rows, as they are skipped in the next loop and + // we don't need the last 2 row as it is skipped in the next loop + for (int y = 2; y < h - 2; y++) { + s += src_stride; + const int e = *s; + ds += dst_stride; + *ds = a + b + c + d + e; + a = b; + b = c; + c = d; + d = e; + } + } + + // We skip the first 2 rows as they are never read + dst += dst_stride; + for (int y = 2; y < h - 2; y++) { + int a = dst[0]; + int b = dst[1]; + int c = dst[2]; + int d = dst[3]; + + for (int x = 2; x < w - 2; x++) { + const int e = dst[x + 2]; + dst[x] = a + b + c + d + e; + a = b; + b = c; + c = d; + d = e; + } + dst += dst_stride; + } +} + +// See boxsum3 function comments for details on row and column skipping +static void boxsum3sqr(int32_t *dst, const ptrdiff_t dst_stride, + const pixel *src, ptrdiff_t src_stride, + const int w, const int h) +{ + src_stride = PXSTRIDE(src_stride); + + // We skip the first row, as it is never used + src += src_stride; + dst += dst_stride; + + // We skip the first and last columns, as they are never used + for (int x = 1; x < w - 1; x++) { + int *ds = dst + x; + const pixel *s = src + x; + int a = s[0] * s[0]; + int b = s[src_stride] * s[src_stride]; + + // We skip the first row, as it is skipped in the next loop and + // we don't need the last row as it is skipped in the next loop + for (int y = 2; y < h - 2; y++) { + s += src_stride; + const int c = s[src_stride] * s[src_stride]; + ds += dst_stride; + *ds = a + b + c; + a = b; + b = c; + } + } + + // We skip the first row as it is never read + dst += dst_stride; + // We skip the last row as it is never read + for (int y = 2; y < h - 2; y++) { + int a = dst[1], b = dst[2]; + + // We don't store the first column as it is never read and + // we don't store the last 2 columns as they are never read + for (int x = 2; x < w - 2; x++) { + const int c = dst[x + 1]; + dst[x] = a + b + c; + a = b; + b = c; + } + dst += dst_stride; + } +} + +// See boxsum5 function comments for details on row and column skipping +static void boxsum5sqr(int32_t *dst, const ptrdiff_t dst_stride, + const pixel *const src, ptrdiff_t src_stride, + const int w, const int h) +{ + src_stride = PXSTRIDE(src_stride); + + // We skip the first row, as it is never used + dst += dst_stride; + + for (int x = 0; x < w; x++) { + int *ds = dst + x; + const pixel *s = src + 3 * src_stride + x; + int a = s[-3 * src_stride] * s[-3 * src_stride]; + int b = s[-2 * src_stride] * s[-2 * src_stride]; + int c = s[-1 * src_stride] * s[-1 * src_stride]; + int d = s[0] * s[0]; + + // We skip the first 2 rows, as they are skipped in the next loop and + // we don't need the last 2 row as it is skipped in the next loop + for (int y = 2; y < h - 2; y++) { + s += src_stride; + const int e = s[0] * s[0]; + ds += dst_stride; + *ds = a + b + c + d + e; + a = b; + b = c; + c = d; + d = e; + } + } + + // We skip the first 2 rows as they are never read + dst += dst_stride; + for (int y = 2; y < h - 2; y++) { + int a = dst[0]; + int b = dst[1]; + int c = dst[2]; + int d = dst[3]; + + for (int x = 2; x < w - 2; x++) { + const int e = dst[x + 2]; + dst[x] = a + b + c + d + e; + a = b; + b = c; + c = d; + d = e; + } + dst += dst_stride; + } +} + +static void selfguided_filter(int32_t *dst, const ptrdiff_t dst_stride, + const pixel *src, const ptrdiff_t src_stride, + const int w, const int h, const int n, const int s) +{ + const int tmp_stride = w + 6; + // FIXME Replace array with scratch memory + int32_t A_[(h + 6) * tmp_stride]; + int32_t *A = A_ + 3 * tmp_stride + 3; + // By inverting A and B after the boxsums, B can be of size coef instead + // of int32_t + coef B_[(h + 6) * tmp_stride]; + coef *B = B_ + 3 * tmp_stride + 3; + + const int step = (n == 25) + 1; + if (n == 25) { + boxsum5(B_, tmp_stride, src, src_stride, w + 6, h + 6); + boxsum5sqr(A_, tmp_stride, src, src_stride, w + 6, h + 6); + } else { + boxsum3(B_, tmp_stride, src, src_stride, w + 6, h + 6); + boxsum3sqr(A_, tmp_stride, src, src_stride, w + 6, h + 6); + } + + int32_t *AA = A - tmp_stride; + coef *BB = B - tmp_stride; + for (int j = -1; j < h + 1; j+= step) { + for (int i = -1; i < w + 1; i++) { + const int a = + (AA[i] + (1 << (2 * (BITDEPTH - 8)) >> 1)) >> (2 * (BITDEPTH - 8)); + const int b = + (BB[i] + (1 << (BITDEPTH - 8) >> 1)) >> (BITDEPTH - 8); + + const uint32_t p = (a * n >= b * b) * (a * n - b * b); + const uint32_t z = (p * s + (1 << 19)) >> 20; + + const int x = sgr_x_by_xplus1[imin(z, 255)]; + // This is where we invert A and B, so that B is of size coef. + AA[i] = (((1 << 8) - x) * BB[i] * sgr_one_by_x[n - 1] + (1 << 11)) >> 12; + BB[i] = x; + } + AA += step * tmp_stride; + BB += step * tmp_stride; + } + + src += 3 * PXSTRIDE(src_stride) + 3; + if (n == 25) { + for (int j = 0; j < h; j+=2) { + for (int i = 0; i < w; i++) { + const int32_t a = (B[i - tmp_stride] + + B[i + tmp_stride]) * 6 + + (B[i - 1 - tmp_stride] + + B[i - 1 + tmp_stride] + + B[i + 1 - tmp_stride] + + B[i + 1 + tmp_stride]) * 5; + const int32_t b = (A[i - tmp_stride] + + A[i + tmp_stride]) * 6 + + (A[i - 1 - tmp_stride] + + A[i - 1 + tmp_stride] + + A[i + 1 - tmp_stride] + + A[i + 1 + tmp_stride]) * 5; + dst[i] = (a * src[i] + b + (1 << 8)) >> 9; + } + dst += dst_stride; + src += PXSTRIDE(src_stride); + B += tmp_stride; + A += tmp_stride; + for (int i = 0; i < w; i++) { + const int32_t a = B[i] * 6 + (B[i - 1] + B[i + 1]) * 5; + const int32_t b = A[i] * 6 + (A[i - 1] + A[i + 1]) * 5; + dst[i] = (a * src[i] + b + (1 << 7)) >> 8; + } + dst += dst_stride; + src += PXSTRIDE(src_stride); + B += tmp_stride; + A += tmp_stride; + } + } else { + for (int j = 0; j < h; j++) { + for (int i = 0; i < w; i++) { + const int32_t a = + (B[i] + B[i - 1] + B[i + 1] + + B[i - tmp_stride] + + B[i + tmp_stride]) * 4 + + (B[i - 1 - tmp_stride] + + B[i - 1 + tmp_stride] + + B[i + 1 - tmp_stride] + + B[i + 1 + tmp_stride]) * 3; + + const int32_t b = + (A[i] + A[i - 1] + A[i + 1] + + A[i - tmp_stride] + + A[i + tmp_stride]) * 4 + + (A[i - 1 - tmp_stride] + + A[i - 1 + tmp_stride] + + A[i + 1 - tmp_stride] + + A[i + 1 + tmp_stride]) * 3; + + dst[i] = (a * src[i] + b + (1 << 8)) >> 9; + } + dst += dst_stride; + src += PXSTRIDE(src_stride); + B += tmp_stride; + A += tmp_stride; + } + } +} + +static void selfguided_c(pixel *p, const ptrdiff_t p_stride, + const pixel *lpf, const ptrdiff_t lpf_stride, + const int w, const int h, const int sgr_idx, + const int16_t sgr_w[2], const enum LrEdgeFlags edges) +{ + // padding is 3 pixels above and 3 pixels below + const int tmp_stride = sizeof(pixel) * (w + 6); + pixel tmp[(h + 6) * PXSTRIDE(tmp_stride)]; + + padding(tmp, tmp_stride, p, p_stride, lpf, lpf_stride, w, h, edges); + + // both r1 and r0 can't be zero + if (!sgr_params[sgr_idx][0]) { + int32_t dst[h * w]; + const int s1 = sgr_params[sgr_idx][3]; + selfguided_filter(dst, w, tmp, tmp_stride, w, h, 9, s1); + const int w1 = (1 << 7) - sgr_w[1]; + for (int j = 0; j < h; j++) { + for (int i = 0; i < w; i++) { + const int32_t u = (p[i] << 4); + const int32_t v = (u << 7) + w1 * (dst[j * w + i] - u); + p[i] = iclip_pixel((v + (1 << 10)) >> 11); + } + p += PXSTRIDE(p_stride); + } + } else if (!sgr_params[sgr_idx][1]) { + int32_t dst[h * w]; + const int s0 = sgr_params[sgr_idx][2]; + selfguided_filter(dst, w, tmp, tmp_stride, w, h, 25, s0); + const int w0 = sgr_w[0]; + for (int j = 0; j < h; j++) { + for (int i = 0; i < w; i++) { + const int32_t u = (p[i] << 4); + const int32_t v = (u << 7) + w0 * (dst[j * w + i] - u); + p[i] = iclip_pixel((v + (1 << 10)) >> 11); + } + p += PXSTRIDE(p_stride); + } + } else { + int32_t dst0[h * w]; + int32_t dst1[h * w]; + const int s0 = sgr_params[sgr_idx][2]; + const int s1 = sgr_params[sgr_idx][3]; + const int w0 = sgr_w[0]; + const int w1 = (1 << 7) - w0 - sgr_w[1]; + selfguided_filter(dst0, w, tmp, tmp_stride, w, h, 25, s0); + selfguided_filter(dst1, w, tmp, tmp_stride, w, h, 9, s1); + for (int j = 0; j < h; j++) { + for (int i = 0; i < w; i++) { + const int32_t u = (p[i] << 4); + const int32_t v = (u << 7) + w0 * (dst0[j * w + i] - u) + + w1 * (dst1[j * w + i] - u); + p[i] = iclip_pixel((v + (1 << 10)) >> 11); + } + p += PXSTRIDE(p_stride); + } + } +} + +void bitfn(dav1d_loop_restoration_dsp_init)(Dav1dLoopRestorationDSPContext *const c) { + c->wiener = wiener_c; + c->selfguided = selfguided_c; +} diff --git a/src/looprestoration.h b/src/looprestoration.h new file mode 100644 index 0000000..b1dd24a --- /dev/null +++ b/src/looprestoration.h @@ -0,0 +1,65 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_SRC_LOOPRESTORATION_H__ +#define __DAV1D_SRC_LOOPRESTORATION_H__ + +#include <stdint.h> +#include <stddef.h> + +#include "common/bitdepth.h" + +enum LrEdgeFlags { + LR_HAVE_LEFT = 1 << 0, + LR_HAVE_RIGHT = 1 << 1, + LR_HAVE_TOP = 1 << 2, + LR_HAVE_BOTTOM = 1 << 3, +}; + +// Although the spec applies restoration filters over 4x4 blocks, the wiener +// filter can be applied to a bigger surface. +// * w is constrained by the restoration unit size (w <= 256) +// * h is constrained by the stripe height (h <= 64) +typedef void (*wienerfilter_fn)(pixel *dst, ptrdiff_t dst_stride, + const pixel *lpf, ptrdiff_t lpf_stride, + int w, int h, const int16_t filterh[7], + const int16_t filterv[7], enum LrEdgeFlags edges); + +typedef void (*selfguided_fn)(pixel *dst, ptrdiff_t dst_stride, + const pixel *lpf, ptrdiff_t lpf_stride, + int w, int h, int sgr_idx, const int16_t sgr_w[2], + const enum LrEdgeFlags edges); + +typedef struct Dav1dLoopRestorationDSPContext { + wienerfilter_fn wiener; + selfguided_fn selfguided; +} Dav1dLoopRestorationDSPContext; + +void dav1d_loop_restoration_dsp_init_8bpc(Dav1dLoopRestorationDSPContext *c); +void dav1d_loop_restoration_dsp_init_10bpc(Dav1dLoopRestorationDSPContext *c); + +#endif /* __DAV1D_SRC_LOOPRESTORATION_H__ */ diff --git a/src/lr_apply.c b/src/lr_apply.c new file mode 100644 index 0000000..21ed86d --- /dev/null +++ b/src/lr_apply.c @@ -0,0 +1,302 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <stdio.h> + +#include "common/intops.h" + +#include "src/lr_apply.h" + + +enum LrRestorePlanes { + LR_RESTORE_Y = 1 << 0, + LR_RESTORE_U = 1 << 1, + LR_RESTORE_V = 1 << 2, +}; + +static void backup_lpf(pixel *dst, ptrdiff_t dst_stride, + const pixel *src, ptrdiff_t src_stride, + const int first_stripe_h, const int next_stripe_h, + int row, const int row_h, const int w, const int h) +{ + src_stride = PXSTRIDE(src_stride); + dst_stride = PXSTRIDE(dst_stride); + if (row) { + // Copy the top part of the stored loop filtered pixels from the + // previous sb row needed above the first stripe of this sb row. + pixel_copy(&dst[dst_stride * 0], &dst[dst_stride * 8], w); + pixel_copy(&dst[dst_stride * 1], &dst[dst_stride * 9], w); + pixel_copy(&dst[dst_stride * 2], &dst[dst_stride * 10], w); + pixel_copy(&dst[dst_stride * 3], &dst[dst_stride * 11], w); + } + + int stripe_h = first_stripe_h; + dst += 4 * dst_stride; + src += (stripe_h - 2) * src_stride; + for (; row + stripe_h <= row_h; row += stripe_h) { + for (int i = 0; i < 4; i++) { + pixel_copy(dst, src, w); + dst += dst_stride; + src += src_stride; + } + stripe_h = next_stripe_h; + src += (stripe_h - 4) * src_stride; + } +} + +void bytefn(dav1d_lr_copy_lpf)(Dav1dFrameContext *const f, + /*const*/ pixel *const src[3], const int sby) +{ + const int stripe_h = 64 - (8 * !sby); + const ptrdiff_t offset = 8 * !!sby; + const ptrdiff_t *const src_stride = f->cur.p.stride; + + // TODO Also check block level restore type to reduce copying. + const int restore_planes = + ((f->frame_hdr.restoration.type[0] != RESTORATION_NONE) << 0) + + ((f->frame_hdr.restoration.type[1] != RESTORATION_NONE) << 1) + + ((f->frame_hdr.restoration.type[2] != RESTORATION_NONE) << 2); + + if (restore_planes & LR_RESTORE_Y) { + const int h = f->bh << 2; + const int w = f->bw << 2; + const int row_h = imin((sby + 1) << (6 + f->seq_hdr.sb128), h); + const int y_stripe = (sby << (6 + f->seq_hdr.sb128)) - offset; + backup_lpf(f->lf.lr_lpf_line_ptr[0], sizeof(pixel) * f->b4_stride * 4, + src[0] - offset * PXSTRIDE(src_stride[0]), + src_stride[0], stripe_h, 64, y_stripe, row_h, w, h); + } + if (restore_planes & (LR_RESTORE_U | LR_RESTORE_V)) { + const int ss_ver = f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I420; + const int ss_hor = f->cur.p.p.layout != DAV1D_PIXEL_LAYOUT_I444; + const int h = f->bh << (2 - ss_ver); + const int w = f->bw << (2 - ss_hor); + const int row_h = imin((sby + 1) << ((6 - ss_ver) + f->seq_hdr.sb128), h); + const int stripe_h_uv = stripe_h >> ss_ver; + const ptrdiff_t offset_uv = offset >> ss_ver; + const int y_stripe = + (sby << ((6 - ss_ver) + f->seq_hdr.sb128)) - offset_uv; + + if (restore_planes & LR_RESTORE_U) { + backup_lpf(f->lf.lr_lpf_line_ptr[1], sizeof(pixel) * f->b4_stride * 4, + src[1] - offset_uv * PXSTRIDE(src_stride[1]), + src_stride[1], stripe_h_uv, 32, y_stripe, + row_h, w, h); + } + if (restore_planes & LR_RESTORE_V) { + backup_lpf(f->lf.lr_lpf_line_ptr[2], sizeof(pixel) * f->b4_stride * 4, + src[2] - offset_uv * PXSTRIDE(src_stride[1]), + src_stride[1], stripe_h_uv, 32, y_stripe, + row_h, w, h); + } + } +} + + +static void lr_stripe(const Dav1dFrameContext *const f, pixel *p, int x, int y, + const int plane, const int unit_w, + const int first_stripe_h, const int next_stripe_h, + const int row_h, const Av1RestorationUnit *const lr, + enum LrEdgeFlags edges) +{ + const Dav1dDSPContext *const dsp = f->dsp; + const int sbrow_has_bottom = (edges & LR_HAVE_BOTTOM); + const pixel *lpf = f->lf.lr_lpf_line_ptr[plane] + x; + const ptrdiff_t p_stride = f->cur.p.stride[!!plane]; + const ptrdiff_t lpf_stride = sizeof(pixel) * f->b4_stride * 4; + + int stripe_h = first_stripe_h; + + // FIXME [8] might be easier for SIMD + int16_t filterh[7], filterv[7]; + if (lr->type == RESTORATION_WIENER) { + filterh[0] = filterh[6] = lr->filter_h[0]; + filterh[1] = filterh[5] = lr->filter_h[1]; + filterh[2] = filterh[4] = lr->filter_h[2]; + filterh[3] = -((filterh[0] + filterh[1] + filterh[2]) * 2); + + filterv[0] = filterv[6] = lr->filter_v[0]; + filterv[1] = filterv[5] = lr->filter_v[1]; + filterv[2] = filterv[4] = lr->filter_v[2]; + filterv[3] = -((filterv[0] + filterv[1] + filterv[2]) * 2); + } + + while (y + stripe_h <= row_h) { + // TODO Look into getting rid of the this if + if (y + stripe_h == row_h) { + edges &= ~LR_HAVE_BOTTOM; + } else { + edges |= LR_HAVE_BOTTOM; + } + if (lr->type == RESTORATION_WIENER) { + dsp->lr.wiener(p, p_stride, lpf, lpf_stride, unit_w, stripe_h, + filterh, filterv, edges); + } else { + assert(lr->type == RESTORATION_SGRPROJ); + dsp->lr.selfguided(p, p_stride, lpf, lpf_stride, unit_w, stripe_h, + lr->sgr_idx, lr->sgr_weights, edges); + } + + y += stripe_h; + edges |= LR_HAVE_TOP; + if (y + stripe_h > row_h && sbrow_has_bottom) break; + p += stripe_h * PXSTRIDE(p_stride); + stripe_h = imin(next_stripe_h, row_h - y); + if (stripe_h == 0) break; + lpf += 4 * PXSTRIDE(lpf_stride); + } +} + +static void backup3xU(pixel *dst, const pixel *src, const ptrdiff_t src_stride, + int u) +{ + for (; u > 0; u--, dst += 3, src += PXSTRIDE(src_stride)) + pixel_copy(dst, src, 3); +} + +static void restore3xU(pixel *dst, const ptrdiff_t dst_stride, const pixel *src, + int u) +{ + for (; u > 0; u--, dst += PXSTRIDE(dst_stride), src += 3) + pixel_copy(dst, src, 3); +} + +static void lr_sbrow(const Dav1dFrameContext *const f, pixel *p, const int y, + const int w, const int h, const int row_h, const int plane) +{ + const int ss_ver = !!plane * f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I420; + const ptrdiff_t p_stride = f->cur.p.stride[!!plane]; + + const int unit_size_log2 = f->frame_hdr.restoration.unit_size[!!plane]; + const int unit_size = 1 << unit_size_log2; + const int half_unit_size = unit_size >> 1; + const int max_unit_size = unit_size + half_unit_size; + + const int row_y = y + ((8 >> ss_ver) * !!y); + + // FIXME This is an ugly hack to lookup the proper AV1Filter unit for + // chroma planes. Question: For Multithreaded decoding, is it better + // to store the chroma LR information with collocated Luma information? + // In other words. For a chroma restoration unit locate at 128,128 and + // with a 4:2:0 chroma subsampling, do we store the filter information at + // the AV1Filter unit located at (128,128) or (256,256) + // TODO Support chroma subsampling. + const int shift = plane ? 6 : 7; + + int ruy = (row_y >> unit_size_log2); + // Merge last restoration unit if its height is < half_unit_size + if (ruy > 0) ruy -= (ruy << unit_size_log2) + half_unit_size > h; + + const int proc_h = 64 >> ss_ver; + const int stripe_h = proc_h - ((8 >> ss_ver) * !y); + const int filter_h = imin(stripe_h + proc_h * f->seq_hdr.sb128, h - y); + + pixel pre_lr_border[filter_h * 3]; + pixel post_lr_border[filter_h * 3]; + + int unit_w = unit_size; + + enum LrEdgeFlags edges = (y > 0 ? LR_HAVE_TOP : 0) | + (row_h < h ? LR_HAVE_BOTTOM : 0); + + for (int x = 0, rux = 0; x < w; x+= unit_w, rux++, edges |= LR_HAVE_LEFT) { + // TODO Clean up this if statement. + if (x + max_unit_size > w) { + unit_w = w - x; + edges &= ~LR_HAVE_RIGHT; + } else { + edges |= LR_HAVE_RIGHT; + } + + // Based on the position of the restoration unit, find the corresponding + // AV1Filter unit. + const int unit_idx = ((ruy & 16) >> 3) + ((rux & 16) >> 4); + const Av1RestorationUnit *const lr = + &f->lf.mask[(((ruy << unit_size_log2) >> shift) * f->sb128w) + + (x >> shift)].lr[plane][unit_idx]; + + if (edges & LR_HAVE_LEFT) { + restore3xU(p - 3, p_stride, pre_lr_border, filter_h); + } + // FIXME Don't backup if the next restoration unit is RESTORE_NONE + // This also requires not restoring in the same conditions. + if (edges & LR_HAVE_RIGHT) { + backup3xU(pre_lr_border, p + unit_w - 3, p_stride, filter_h); + } + if (lr->type != RESTORATION_NONE) { + lr_stripe(f, p, x, y, plane, unit_w, stripe_h, proc_h, + row_h, lr, edges); + } + if (edges & LR_HAVE_LEFT) { + restore3xU(p - 3, p_stride, post_lr_border, filter_h); + } + if (edges & LR_HAVE_RIGHT) { + backup3xU(post_lr_border, p + unit_w - 3, p_stride, filter_h); + } + p += unit_w; + } +} + +void bytefn(dav1d_lr_sbrow)(Dav1dFrameContext *const f, pixel *const dst[3], + const int sby) +{ + const ptrdiff_t offset_y = 8 * !!sby; + const ptrdiff_t *const dst_stride = f->cur.p.stride; + + const int restore_planes = + ((f->frame_hdr.restoration.type[0] != RESTORATION_NONE) << 0) + + ((f->frame_hdr.restoration.type[1] != RESTORATION_NONE) << 1) + + ((f->frame_hdr.restoration.type[2] != RESTORATION_NONE) << 2); + + if (restore_planes & LR_RESTORE_Y) { + const int h = f->bh << 2; + const int w = f->bw << 2; + const int row_h = imin((sby + 1) << (6 + f->seq_hdr.sb128), h); + const int y_stripe = (sby << (6 + f->seq_hdr.sb128)) - offset_y; + lr_sbrow(f, dst[0] - offset_y * PXSTRIDE(dst_stride[0]), y_stripe, w, + h, row_h, 0); + } + if (restore_planes & (LR_RESTORE_U | LR_RESTORE_V)) { + const int ss_ver = f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I420; + const int ss_hor = f->cur.p.p.layout != DAV1D_PIXEL_LAYOUT_I444; + const int h = f->bh << (2 - ss_ver); + const int w = f->bw << (2 - ss_hor); + const int row_h = imin((sby + 1) << ((6 - ss_ver) + f->seq_hdr.sb128), h); + const ptrdiff_t offset_uv = offset_y >> ss_ver; + const int y_stripe = + (sby << ((6 - ss_ver) + f->seq_hdr.sb128)) - offset_uv; + if (restore_planes & LR_RESTORE_U) + lr_sbrow(f, dst[1] - offset_uv * PXSTRIDE(dst_stride[1]), y_stripe, + w, h, row_h, 1); + + if (restore_planes & LR_RESTORE_V) + lr_sbrow(f, dst[2] - offset_uv * PXSTRIDE(dst_stride[1]), y_stripe, + w, h, row_h, 2); + } +} diff --git a/src/lr_apply.h b/src/lr_apply.h new file mode 100644 index 0000000..67a7a21 --- /dev/null +++ b/src/lr_apply.h @@ -0,0 +1,44 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_SRC_LR_APPLY_H__ +#define __DAV1D_SRC_LR_APPLY_H__ + +#include <stdint.h> +#include <stddef.h> + +#include "common/bitdepth.h" + +#include "src/internal.h" + +void bytefn(dav1d_lr_copy_lpf)(Dav1dFrameContext *const f, + /*const*/ pixel *const src[3], int sby); + +void bytefn(dav1d_lr_sbrow)(Dav1dFrameContext *const f, pixel *const dst[3], + int sby); + +#endif /* __DAV1D_SRC_LR_APPLY_H__ */ diff --git a/src/mc.c b/src/mc.c new file mode 100644 index 0000000..10106b2 --- /dev/null +++ b/src/mc.c @@ -0,0 +1,533 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <stdlib.h> +#include <string.h> + +#include "common/intops.h" + +#include "src/mc.h" +#include "src/tables.h" + +static __attribute__((noinline)) void +put_c(pixel *dst, const ptrdiff_t dst_stride, + const pixel *src, const ptrdiff_t src_stride, const int w, int h) +{ + do { + pixel_copy(dst, src, w); + + dst += dst_stride; + src += src_stride; + } while (--h); +} + +static __attribute__((noinline)) void +prep_c(coef *tmp, const pixel *src, const ptrdiff_t src_stride, + const int w, int h) +{ + do { + for (int x = 0; x < w; x++) + tmp[x] = src[x] << 4; + + tmp += w; + src += src_stride; + } while (--h); +} + +#define FILTER_8TAP(src, x, F, stride) \ + (F[0] * src[x + -3 * stride] + \ + F[1] * src[x + -2 * stride] + \ + F[2] * src[x + -1 * stride] + \ + F[3] * src[x + +0 * stride] + \ + F[4] * src[x + +1 * stride] + \ + F[5] * src[x + +2 * stride] + \ + F[6] * src[x + +3 * stride] + \ + F[7] * src[x + +4 * stride]) + +#define FILTER_8TAP_RND(src, x, F, stride, sh) \ + ((FILTER_8TAP(src, x, F, stride) + ((1 << sh) >> 1)) >> sh) + +#define FILTER_8TAP_CLIP(src, x, F, stride, sh) \ + iclip_pixel(FILTER_8TAP_RND(src, x, F, stride, sh)) + +#define GET_FILTERS() \ + const int8_t *const fh = !mx ? NULL : w > 4 ? \ + dav1d_mc_subpel_filters[filter_type & 3][mx - 1] : \ + dav1d_mc_subpel_filters[3 + (filter_type & 1)][mx - 1]; \ + const int8_t *const fv = !my ? NULL : h > 4 ? \ + dav1d_mc_subpel_filters[filter_type >> 2][my - 1] : \ + dav1d_mc_subpel_filters[3 + ((filter_type >> 2) & 1)][my - 1]; \ + +static __attribute__((noinline)) void +put_8tap_c(pixel *dst, ptrdiff_t dst_stride, + const pixel *src, ptrdiff_t src_stride, + const int w, int h, const int mx, const int my, + const int filter_type) +{ + GET_FILTERS(); + dst_stride = PXSTRIDE(dst_stride); + src_stride = PXSTRIDE(src_stride); + + if (fh) { + if (fv) { + int tmp_h = h + 7; + coef mid[128 * 135], *mid_ptr = mid; + + src -= src_stride * 3; + do { + for (int x = 0; x < w; x++) + mid_ptr[x] = FILTER_8TAP_RND(src, x, fh, 1, 3); + + mid_ptr += 128; + src += src_stride; + } while (--tmp_h); + + mid_ptr = mid + 128 * 3; + do { + for (int x = 0; x < w; x++) + dst[x] = FILTER_8TAP_CLIP(mid_ptr, x, fv, 128, 11); + + mid_ptr += 128; + dst += dst_stride; + } while (--h); + } else { + do { + for (int x = 0; x < w; x++) { + const int px = FILTER_8TAP_RND(src, x, fh, 1, 3); + dst[x] = iclip_pixel((px + 8) >> 4); + } + + dst += dst_stride; + src += src_stride; + } while (--h); + } + } else if (fv) { + do { + for (int x = 0; x < w; x++) + dst[x] = FILTER_8TAP_CLIP(src, x, fv, src_stride, 7); + + dst += dst_stride; + src += src_stride; + } while (--h); + } else + put_c(dst, dst_stride, src, src_stride, w, h); +} + +static __attribute__((noinline)) void +prep_8tap_c(coef *tmp, const pixel *src, ptrdiff_t src_stride, + const int w, int h, const int mx, const int my, + const int filter_type) +{ + GET_FILTERS(); + src_stride = PXSTRIDE(src_stride); + + if (fh) { + if (fv) { + int tmp_h = h + 7; + coef mid[128 * 135], *mid_ptr = mid; + + src -= src_stride * 3; + do { + for (int x = 0; x < w; x++) + mid_ptr[x] = FILTER_8TAP_RND(src, x, fh, 1, 3); + + mid_ptr += 128; + src += src_stride; + } while (--tmp_h); + + mid_ptr = mid + 128 * 3; + do { + for (int x = 0; x < w; x++) + tmp[x] = FILTER_8TAP_RND(mid_ptr, x, fv, 128, 7); + + mid_ptr += 128; + tmp += w; + } while (--h); + } else { + do { + for (int x = 0; x < w; x++) + tmp[x] = FILTER_8TAP_RND(src, x, fh, 1, 3); + + tmp += w; + src += src_stride; + } while (--h); + } + } else if (fv) { + do { + for (int x = 0; x < w; x++) + tmp[x] = FILTER_8TAP_RND(src, x, fv, src_stride, 3); + + tmp += w; + src += src_stride; + } while (--h); + } else + prep_c(tmp, src, src_stride, w, h); +} + +#define filter_fns(type, type_h, type_v) \ +static void put_8tap_##type##_c(pixel *const dst, \ + const ptrdiff_t dst_stride, \ + const pixel *const src, \ + const ptrdiff_t src_stride, \ + const int w, const int h, \ + const int mx, const int my) \ +{ \ + put_8tap_c(dst, dst_stride, src, src_stride, w, h, mx, my, \ + type_h | (type_v << 2)); \ +} \ +static void prep_8tap_##type##_c(coef *const tmp, \ + const pixel *const src, \ + const ptrdiff_t src_stride, \ + const int w, const int h, \ + const int mx, const int my) \ +{ \ + prep_8tap_c(tmp, src, src_stride, w, h, mx, my, \ + type_h | (type_v << 2)); \ +} + +filter_fns(regular, FILTER_8TAP_REGULAR, FILTER_8TAP_REGULAR) +filter_fns(regular_sharp, FILTER_8TAP_REGULAR, FILTER_8TAP_SHARP) +filter_fns(regular_smooth, FILTER_8TAP_REGULAR, FILTER_8TAP_SMOOTH) +filter_fns(smooth, FILTER_8TAP_SMOOTH, FILTER_8TAP_SMOOTH) +filter_fns(smooth_regular, FILTER_8TAP_SMOOTH, FILTER_8TAP_REGULAR) +filter_fns(smooth_sharp, FILTER_8TAP_SMOOTH, FILTER_8TAP_SHARP) +filter_fns(sharp, FILTER_8TAP_SHARP, FILTER_8TAP_SHARP) +filter_fns(sharp_regular, FILTER_8TAP_SHARP, FILTER_8TAP_REGULAR) +filter_fns(sharp_smooth, FILTER_8TAP_SHARP, FILTER_8TAP_SMOOTH) + +#define FILTER_BILIN(src, x, mxy, stride) \ + (16 * src[x] + (mxy * (src[x + stride] - src[x]))) + +#define FILTER_BILIN_RND(src, x, mxy, stride, sh) \ + ((FILTER_BILIN(src, x, mxy, stride) + ((1 << sh) >> 1)) >> sh) + +#define FILTER_BILIN_CLIP(src, x, mxy, stride, sh) \ + iclip_pixel(FILTER_BILIN_RND(src, x, mxy, stride, sh)) + +static void put_bilin_c(pixel *dst, ptrdiff_t dst_stride, + const pixel *src, ptrdiff_t src_stride, + const int w, int h, const int mx, const int my) +{ + dst_stride = PXSTRIDE(dst_stride); + src_stride = PXSTRIDE(src_stride); + + if (mx) { + if (my) { + coef mid[128 * 129], *mid_ptr = mid; + int tmp_h = h + 1; + + do { + for (int x = 0; x < w; x++) + mid_ptr[x] = FILTER_BILIN(src, x, mx, 1); + + mid_ptr += 128; + src += src_stride; + } while (--tmp_h); + + mid_ptr = mid; + do { + for (int x = 0; x < w; x++) + dst[x] = FILTER_BILIN_CLIP(mid_ptr, x, my, 128, 8); + + mid_ptr += 128; + dst += dst_stride; + } while (--h); + } else { + do { + for (int x = 0; x < w; x++) + dst[x] = FILTER_BILIN_CLIP(src, x, mx, 1, 4); + + dst += dst_stride; + src += src_stride; + } while (--h); + } + } else if (my) { + do { + for (int x = 0; x < w; x++) + dst[x] = FILTER_BILIN_CLIP(src, x, my, src_stride, 4); + + dst += dst_stride; + src += src_stride; + } while (--h); + } else + put_c(dst, dst_stride, src, src_stride, w, h); +} + +static void prep_bilin_c(coef *tmp, + const pixel *src, ptrdiff_t src_stride, + const int w, int h, const int mx, const int my) +{ + src_stride = PXSTRIDE(src_stride); + + if (mx) { + if (my) { + coef mid[128 * 129], *mid_ptr = mid; + int tmp_h = h + 1; + + do { + for (int x = 0; x < w; x++) + mid_ptr[x] = FILTER_BILIN(src, x, mx, 1); + + mid_ptr += 128; + src += src_stride; + } while (--tmp_h); + + mid_ptr = mid; + do { + for (int x = 0; x < w; x++) + tmp[x] = FILTER_BILIN_RND(mid_ptr, x, my, 128, 4); + + mid_ptr += 128; + tmp += w; + } while (--h); + } else { + do { + for (int x = 0; x < w; x++) + tmp[x] = FILTER_BILIN(src, x, mx, 1); + + tmp += w; + src += src_stride; + } while (--h); + } + } else if (my) { + do { + for (int x = 0; x < w; x++) + tmp[x] = FILTER_BILIN(src, x, my, src_stride); + + tmp += w; + src += src_stride; + } while (--h); + } else + prep_c(tmp, src, src_stride, w, h); +} + +static void avg_c(pixel *dst, const ptrdiff_t dst_stride, + const coef *tmp1, const coef *tmp2, const int w, int h) +{ + do { + for (int x = 0; x < w; x++) + dst[x] = iclip_pixel((tmp1[x] + tmp2[x] + 16) >> 5); + + tmp1 += w; + tmp2 += w; + dst += PXSTRIDE(dst_stride); + } while (--h); +} + +static void w_avg_c(pixel *dst, const ptrdiff_t dst_stride, + const coef *tmp1, const coef *tmp2, const int w, int h, + const int weight) +{ + do { + for (int x = 0; x < w; x++) + dst[x] = iclip_pixel((tmp1[x] * weight + + tmp2[x] * (16 - weight) + 128) >> 8); + + tmp1 += w; + tmp2 += w; + dst += PXSTRIDE(dst_stride); + } while (--h); +} + +static void mask_c(pixel *dst, const ptrdiff_t dst_stride, + const coef *tmp1, const coef *tmp2, const int w, int h, + const uint8_t *mask) +{ + do { + for (int x = 0; x < w; x++) + dst[x] = iclip_pixel((tmp1[x] * mask[x] + + tmp2[x] * (64 - mask[x]) + 512) >> 10); + + tmp1 += w; + tmp2 += w; + mask += w; + dst += PXSTRIDE(dst_stride); + } while (--h); +} + +static void blend_c(pixel *dst, const ptrdiff_t dst_stride, + const pixel *tmp, const ptrdiff_t tmp_stride, + const int w, const int h, + const uint8_t *mask, const ptrdiff_t m_stride) +{ + for (int y = 0; y < h; y++) { + for (int x = 0; x < w; x++) { +#define blend_px(a, b, m) (((a * (64 - m) + b * m) + 32) >> 6) + dst[x] = blend_px(dst[x], tmp[x], mask[m_stride == 1 ? 0 : x]); + } + dst += PXSTRIDE(dst_stride); + tmp += PXSTRIDE(tmp_stride); + mask += m_stride; + } +} + +static void w_mask_c(pixel *dst, const ptrdiff_t dst_stride, + const coef *tmp1, const coef *tmp2, const int w, int h, + uint8_t *mask, const int sign, + const int ss_hor, const int ss_ver) +{ + // store mask at 2x2 resolution, i.e. store 2x1 sum for even rows, + // and then load this intermediate to calculate final value for odd rows + const int rnd = 8 << (BITDEPTH - 8); + do { + for (int x = 0; x < w; x++) { + const int m = imin(38 + ((abs(tmp1[x] - tmp2[x]) + rnd) >> BITDEPTH), 64); + dst[x] = iclip_pixel((tmp1[x] * m + + tmp2[x] * (64 - m) + 512) >> 10); + + if (ss_hor) { + x++; + + const int n = imin(38 + ((abs(tmp1[x] - tmp2[x]) + rnd) >> BITDEPTH), 64); + dst[x] = iclip_pixel((tmp1[x] * n + + tmp2[x] * (64 - n) + 512) >> 10); + + if (h & ss_ver) { + mask[x >> 1] = (m + n + mask[x >> 1] + 2 - sign) >> 2; + } else if (ss_ver) { + mask[x >> 1] = m + n; + } else { + mask[x >> 1] = (m + n + 1 - sign) >> 1; + } + } else { + mask[x] = m; + } + } + + tmp1 += w; + tmp2 += w; + dst += PXSTRIDE(dst_stride); + if (!ss_ver || (h & 1)) mask += w >> ss_hor; + } while (--h); +} + +#define w_mask_fns(ssn, ss_hor, ss_ver) \ +static void w_mask_##ssn##_c(pixel *const dst, const ptrdiff_t dst_stride, \ + const coef *const tmp1, const coef *const tmp2, \ + const int w, const int h, uint8_t *mask, \ + const int sign) \ +{ \ + w_mask_c(dst, dst_stride, tmp1, tmp2, w, h, mask, sign, ss_hor, ss_ver); \ +} + +w_mask_fns(444, 0, 0); +w_mask_fns(422, 1, 0); +w_mask_fns(420, 1, 1); + +#undef w_mask_fns + +static void warp_affine_8x8_c(pixel *dst, const ptrdiff_t dst_stride, + const pixel *src, const ptrdiff_t src_stride, + const int16_t *const abcd, int mx, int my) +{ + coef mid[15 * 8], *mid_ptr = mid; + + src -= 3 * PXSTRIDE(src_stride); + for (int y = 0; y < 15; y++, mx += abcd[1]) { + for (int x = 0, tmx = mx; x < 8; x++, tmx += abcd[0]) { + const int8_t *const filter = + dav1d_mc_warp_filter[64 + ((tmx + 512) >> 10)]; + + mid_ptr[x] = FILTER_8TAP_RND(src, x, filter, 1, 3); + } + src += PXSTRIDE(src_stride); + mid_ptr += 8; + } + + mid_ptr = &mid[3 * 8]; + for (int y = 0; y < 8; y++, my += abcd[3]) { + for (int x = 0, tmy = my; x < 8; x++, tmy += abcd[2]) { + const int8_t *const filter = + dav1d_mc_warp_filter[64 + ((tmy + 512) >> 10)]; + + dst[x] = FILTER_8TAP_CLIP(mid_ptr, x, filter, 8, 11); + } + mid_ptr += 8; + dst += PXSTRIDE(dst_stride); + } +} + +static void warp_affine_8x8t_c(coef *tmp, const ptrdiff_t tmp_stride, + const pixel *src, const ptrdiff_t src_stride, + const int16_t *const abcd, int mx, int my) +{ + coef mid[15 * 8], *mid_ptr = mid; + + src -= 3 * PXSTRIDE(src_stride); + for (int y = 0; y < 15; y++, mx += abcd[1]) { + for (int x = 0, tmx = mx; x < 8; x++, tmx += abcd[0]) { + const int8_t *const filter = + dav1d_mc_warp_filter[64 + ((tmx + 512) >> 10)]; + + mid_ptr[x] = FILTER_8TAP_RND(src, x, filter, 1, 3); + } + src += PXSTRIDE(src_stride); + mid_ptr += 8; + } + + mid_ptr = &mid[3 * 8]; + for (int y = 0; y < 8; y++, my += abcd[3]) { + for (int x = 0, tmy = my; x < 8; x++, tmy += abcd[2]) { + const int8_t *const filter = + dav1d_mc_warp_filter[64 + ((tmy + 512) >> 10)]; + + tmp[x] = FILTER_8TAP_RND(mid_ptr, x, filter, 8, 7); + } + mid_ptr += 8; + tmp += tmp_stride; + } +} + +void bitfn(dav1d_mc_dsp_init)(Dav1dMCDSPContext *const c) { +#define init_mc_fns(type, name) do { \ + c->mc [type] = put_##name##_c; \ + c->mct[type] = prep_##name##_c; \ +} while (0) + + init_mc_fns(FILTER_2D_8TAP_REGULAR, 8tap_regular); + init_mc_fns(FILTER_2D_8TAP_REGULAR_SMOOTH, 8tap_regular_smooth); + init_mc_fns(FILTER_2D_8TAP_REGULAR_SHARP, 8tap_regular_sharp); + init_mc_fns(FILTER_2D_8TAP_SHARP_REGULAR, 8tap_sharp_regular); + init_mc_fns(FILTER_2D_8TAP_SHARP_SMOOTH, 8tap_sharp_smooth); + init_mc_fns(FILTER_2D_8TAP_SHARP, 8tap_sharp); + init_mc_fns(FILTER_2D_8TAP_SMOOTH_REGULAR, 8tap_smooth_regular); + init_mc_fns(FILTER_2D_8TAP_SMOOTH, 8tap_smooth); + init_mc_fns(FILTER_2D_8TAP_SMOOTH_SHARP, 8tap_smooth_sharp); + init_mc_fns(FILTER_2D_BILINEAR, bilin); + + c->avg = avg_c; + c->w_avg = w_avg_c; + c->mask = mask_c; + c->blend = blend_c; + c->w_mask[0] = w_mask_444_c; + c->w_mask[1] = w_mask_422_c; + c->w_mask[2] = w_mask_420_c; + c->warp8x8 = warp_affine_8x8_c; + c->warp8x8t = warp_affine_8x8t_c; +} diff --git a/src/mc.h b/src/mc.h new file mode 100644 index 0000000..af1c41f --- /dev/null +++ b/src/mc.h @@ -0,0 +1,104 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_SRC_MC_H__ +#define __DAV1D_SRC_MC_H__ + +#include <stdint.h> +#include <stddef.h> + +#include "common/bitdepth.h" + +#include "src/levels.h" + +#define decl_mc_fn(name) \ +void (name)(pixel *dst, ptrdiff_t dst_stride, \ + const pixel *src, ptrdiff_t src_stride, \ + int w, int h, int mx, int my) +typedef decl_mc_fn(*mc_fn); + +#define decl_warp8x8_fn(name) \ +void (name)(pixel *dst, ptrdiff_t dst_stride, \ + const pixel *src, ptrdiff_t src_stride, \ + const int16_t *abcd, int mx, int my) +typedef decl_warp8x8_fn(*warp8x8_fn); + +#define decl_mct_fn(name) \ +void (name)(coef *tmp, const pixel *src, ptrdiff_t src_stride, \ + int w, int h, int mx, int my) +typedef decl_mct_fn(*mct_fn); + +#define decl_warp8x8t_fn(name) \ +void (name)(coef *tmp, const ptrdiff_t tmp_stride, \ + const pixel *src, ptrdiff_t src_stride, \ + const int16_t *abcd, int mx, int my) +typedef decl_warp8x8t_fn(*warp8x8t_fn); + +#define decl_avg_fn(name) \ +void (name)(pixel *dst, ptrdiff_t dst_stride, \ + const coef *tmp1, const coef *tmp2, int w, int h) +typedef decl_avg_fn(*avg_fn); + +#define decl_w_avg_fn(name) \ +void (name)(pixel *dst, ptrdiff_t dst_stride, \ + const coef *tmp1, const coef *tmp2, int w, int h, int weight) +typedef decl_w_avg_fn(*w_avg_fn); + +#define decl_mask_fn(name) \ +void (name)(pixel *dst, ptrdiff_t dst_stride, \ + const coef *tmp1, const coef *tmp2, int w, int h, \ + const uint8_t *mask) +typedef decl_mask_fn(*mask_fn); + +#define decl_w_mask_fn(name) \ +void (name)(pixel *dst, ptrdiff_t dst_stride, \ + const coef *tmp1, const coef *tmp2, int w, int h, \ + uint8_t *mask, int sign) +typedef decl_w_mask_fn(*w_mask_fn); + +#define decl_blend_fn(name) \ +void (name)(pixel *dst, ptrdiff_t dst_stride, \ + const pixel *tmp, ptrdiff_t tmp_stride, int w, int h, \ + const uint8_t *mask, ptrdiff_t mstride) +typedef decl_blend_fn(*blend_fn); + +typedef struct Dav1dMCDSPContext { + mc_fn mc[N_2D_FILTERS]; + mct_fn mct[N_2D_FILTERS]; + avg_fn avg; + w_avg_fn w_avg; + mask_fn mask; + w_mask_fn w_mask[3 /* 444, 422, 420 */]; + blend_fn blend; + warp8x8_fn warp8x8; + warp8x8t_fn warp8x8t; +} Dav1dMCDSPContext; + +void dav1d_mc_dsp_init_8bpc(Dav1dMCDSPContext *c); +void dav1d_mc_dsp_init_10bpc(Dav1dMCDSPContext *c); + +#endif /* __DAV1D_SRC_MC_H__ */ diff --git a/src/msac.c b/src/msac.c new file mode 100644 index 0000000..b3ae55d --- /dev/null +++ b/src/msac.c @@ -0,0 +1,318 @@ +/* + * Copyright (c) 2001-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 "config.h" + +#include <assert.h> +#include <limits.h> + +#include "common/intops.h" + +#include "src/msac.h" + +typedef MsacContext od_ec_dec; + +//#define CDF_SIZE(x) ((x) + 1) +#define CDF_PROB_BITS 15 +#define CDF_PROB_TOP (1 << CDF_PROB_BITS) +//#define CDF_INIT_TOP 32768 +#define CDF_SHIFT (15 - CDF_PROB_BITS) + +#define OD_CLZ0 (1) +#define OD_CLZ(x) (-get_msb(x)) +#define OD_ILOG_NZ(x) (OD_CLZ0 - OD_CLZ(x)) + +static inline int get_msb(unsigned int n) { + assert(n != 0); + return 31 ^ __builtin_clz(n); +} + +#define EC_PROB_SHIFT 6 +#define EC_MIN_PROB 4 // must be <= (1<<EC_PROB_SHIFT)/16 + +/*OPT: od_ec_window must be at least 32 bits, but if you have fast arithmetic + on a larger type, you can speed up the decoder by using it here.*/ +typedef uint32_t od_ec_window; + +#define OD_EC_WINDOW_SIZE ((int)sizeof(od_ec_window) * CHAR_BIT) + +/*The resolution of fractional-precision bit usage measurements, i.e., + 3 => 1/8th bits.*/ +#define OD_BITRES (3) + +#define OD_ICDF AOM_ICDF + +#define AOM_ICDF(a) (32768-(a)) + +/*A range decoder. + This is an entropy decoder based upon \cite{Mar79}, which is itself a + rediscovery of the FIFO arithmetic code introduced by \cite{Pas76}. + It is very similar to arithmetic encoding, except that encoding is done with + digits in any base, instead of with bits, and so it is faster when using + larger bases (i.e.: a byte). + The author claims an average waste of $\frac{1}{2}\log_b(2b)$ bits, where $b$ + is the base, longer than the theoretical optimum, but to my knowledge there + is no published justification for this claim. + This only seems true when using near-infinite precision arithmetic so that + the process is carried out with no rounding errors. + + An excellent description of implementation details is available at + http://www.arturocampos.com/ac_range.html + A recent work \cite{MNW98} which proposes several changes to arithmetic + encoding for efficiency actually re-discovers many of the principles + behind range encoding, and presents a good theoretical analysis of them. + + End of stream is handled by writing out the smallest number of bits that + ensures that the stream will be correctly decoded regardless of the value of + any subsequent bits. + od_ec_dec_tell() can be used to determine how many bits were needed to decode + all the symbols thus far; other data can be packed in the remaining bits of + the input buffer. + @PHDTHESIS{Pas76, + author="Richard Clark Pasco", + title="Source coding algorithms for fast data compression", + school="Dept. of Electrical Engineering, Stanford University", + address="Stanford, CA", + month=May, + year=1976, + URL="http://www.richpasco.org/scaffdc.pdf" + } + @INPROCEEDINGS{Mar79, + author="Martin, G.N.N.", + title="Range encoding: an algorithm for removing redundancy from a digitised + message", + booktitle="Video & Data Recording Conference", + year=1979, + address="Southampton", + month=Jul, + URL="http://www.compressconsult.com/rangecoder/rngcod.pdf.gz" + } + @ARTICLE{MNW98, + author="Alistair Moffat and Radford Neal and Ian H. Witten", + title="Arithmetic Coding Revisited", + journal="{ACM} Transactions on Information Systems", + year=1998, + volume=16, + number=3, + pages="256--294", + month=Jul, + URL="http://researchcommons.waikato.ac.nz/bitstream/handle/10289/78/content.pdf" + }*/ + +/*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 OD_EC_LOTS_OF_BITS (0x4000) + +static void od_ec_dec_refill(od_ec_dec *dec) { + int s; + od_ec_window dif; + int16_t cnt; + const unsigned char *bptr; + const unsigned char *end; + dif = dec->dif; + cnt = dec->cnt; + bptr = dec->bptr; + end = dec->end; + s = OD_EC_WINDOW_SIZE - 9 - (cnt + 15); + for (; s >= 0 && bptr < end; s -= 8, bptr++) { + assert(s <= OD_EC_WINDOW_SIZE - 8); + dif ^= (od_ec_window)bptr[0] << s; + cnt += 8; + } + if (bptr >= end) { + dec->tell_offs += OD_EC_LOTS_OF_BITS - cnt; + cnt = OD_EC_LOTS_OF_BITS; + } + dec->dif = dif; + dec->cnt = cnt; + dec->bptr = bptr; +} + +/*Takes updated dif and range values, renormalizes them so that + 32768 <= rng < 65536 (reading more bytes from the stream into dif if + necessary), and stores them back in the decoder context. + dif: The new value of dif. + rng: The new value of the range. + ret: The value to return. + Return: ret. + This allows the compiler to jump to this function via a tail-call.*/ +static int od_ec_dec_normalize(od_ec_dec *dec, od_ec_window dif, unsigned rng, + int ret) { + int d; + assert(rng <= 65535U); + d = 16 - OD_ILOG_NZ(rng); + dec->cnt -= d; + /*This is equivalent to shifting in 1's instead of 0's.*/ + dec->dif = ((dif + 1) << d) - 1; + dec->rng = rng << d; + if (dec->cnt < 0) od_ec_dec_refill(dec); + return ret; +} + +/*Initializes the decoder. + buf: The input buffer to use. + Return: 0 on success, or a negative value on error.*/ +void od_ec_dec_init(od_ec_dec *dec, const unsigned char *buf, + uint32_t storage) { + dec->buf = buf; + dec->tell_offs = 10 - (OD_EC_WINDOW_SIZE - 8); + dec->end = buf + storage; + dec->bptr = buf; + dec->dif = ((od_ec_window)1 << (OD_EC_WINDOW_SIZE - 1)) - 1; + dec->rng = 0x8000; + dec->cnt = -15; + dec->error = 0; + od_ec_dec_refill(dec); +} + +/*Decode a single binary value. + f: The probability that the bit is one, scaled by 32768. + Return: The value decoded (0 or 1).*/ +int od_ec_decode_bool_q15(od_ec_dec *dec, unsigned f) { + od_ec_window dif; + od_ec_window vw; + unsigned r; + unsigned r_new; + unsigned v; + int ret; + assert(0 < f); + assert(f < 32768U); + dif = dec->dif; + r = dec->rng; + assert(dif >> (OD_EC_WINDOW_SIZE - 16) < r); + assert(32768U <= r); + v = ((r >> 8) * (uint32_t)(f >> EC_PROB_SHIFT) >> (7 - EC_PROB_SHIFT)); + v += EC_MIN_PROB; + vw = (od_ec_window)v << (OD_EC_WINDOW_SIZE - 16); + ret = 1; + r_new = v; + if (dif >= vw) { + r_new = r - v; + dif -= vw; + ret = 0; + } + return od_ec_dec_normalize(dec, dif, r_new, ret); +} + +/*Decodes a symbol given an inverse cumulative distribution function (CDF) + table in Q15. + icdf: CDF_PROB_TOP minus the CDF, such that symbol s falls in the range + [s > 0 ? (CDF_PROB_TOP - icdf[s - 1]) : 0, CDF_PROB_TOP - icdf[s]). + The values must be monotonically non-increasing, and icdf[nsyms - 1] + must be 0. + nsyms: The number of symbols in the alphabet. + This should be at most 16. + Return: The decoded symbol s.*/ +int od_ec_decode_cdf_q15(od_ec_dec *dec, const uint16_t *icdf, int nsyms) { + od_ec_window dif; + unsigned r; + unsigned c; + unsigned u; + unsigned v; + int ret; + (void)nsyms; + dif = dec->dif; + r = dec->rng; + const int N = nsyms - 1; + + assert(dif >> (OD_EC_WINDOW_SIZE - 16) < r); + assert(icdf[nsyms - 1] == OD_ICDF(CDF_PROB_TOP)); + assert(32768U <= r); + assert(7 - EC_PROB_SHIFT - CDF_SHIFT >= 0); + c = (unsigned)(dif >> (OD_EC_WINDOW_SIZE - 16)); + v = r; + ret = -1; + do { + u = v; + v = ((r >> 8) * (uint32_t)(icdf[++ret] >> EC_PROB_SHIFT) >> + (7 - EC_PROB_SHIFT - CDF_SHIFT)); + v += EC_MIN_PROB * (N - ret); + } while (c < v); + assert(v < u); + assert(u <= r); + r = u - v; + dif -= (od_ec_window)v << (OD_EC_WINDOW_SIZE - 16); + return od_ec_dec_normalize(dec, dif, r, ret); +} + +void msac_init(MsacContext *const c, + const uint8_t *const data, const size_t sz) +{ + od_ec_dec_init(c, data, sz); +} + +unsigned msac_decode_symbol(MsacContext *const c, const uint16_t *const cdf, + const unsigned n_symbols) +{ + return od_ec_decode_cdf_q15(c, cdf, n_symbols); +} + +unsigned msac_decode_bool(MsacContext *const c, const unsigned cdf) { + return od_ec_decode_bool_q15(c, cdf); +} + +unsigned msac_decode_bools(MsacContext *const c, const unsigned l) { + int v = 0; + for (int n = (int) l - 1; n >= 0; n--) + v = (v << 1) | msac_decode_bool(c, 128 << 7); + return v; +} + +int msac_decode_subexp(MsacContext *const c, const int ref, + const unsigned n, const unsigned k) +{ + int i = 0; + int a = 0; + int b = k; + while ((2 << b) < n) { + if (!msac_decode_bool(c, 128 << 7)) break; + b = k + i++; + a = (1 << b); + } + const unsigned v = msac_decode_bools(c, b) + a; + return ref * 2 <= n ? inv_recenter(ref, v) : + n - 1 - inv_recenter(n - 1 - ref, v); +} + +int msac_decode_uniform(MsacContext *const c, const unsigned n) { + assert(n > 0); + const int l = ulog2(n) + 1; + assert(l > 1); + const int m = (1 << l) - n; + const int v = msac_decode_bools(c, l - 1); + return v < m ? v : (v << 1) - m + msac_decode_bool(c, 128 << 7); +} + +void update_cdf(uint16_t *cdf, unsigned val, unsigned nsymbs) { + int rate; + int i, tmp; + + static const int nsymbs2speed[17] = { + 0, 0, 1, 1, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2 + }; + assert(nsymbs < 17); + rate = 3 + (cdf[nsymbs] > 15) + (cdf[nsymbs] > 31) + nsymbs2speed[nsymbs]; + tmp = 32768; + + // Single loop (faster) + for (i = 0; i < nsymbs - 1; ++i) { + tmp = (i == val) ? 0 : tmp; + if (tmp < cdf[i]) { + cdf[i] -= ((cdf[i] - tmp) >> rate); + } else { + cdf[i] += ((tmp - cdf[i]) >> rate); + } + } + + cdf[nsymbs] += (cdf[nsymbs] < 32); +} diff --git a/src/msac.h b/src/msac.h new file mode 100644 index 0000000..8e61b5c --- /dev/null +++ b/src/msac.h @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2001-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 __DAV1D_SRC_MSAC_H__ +#define __DAV1D_SRC_MSAC_H__ + +#include <stdint.h> +#include <stdlib.h> + +typedef struct MsacContext { + const uint8_t *buf, *end, *bptr; + int32_t tell_offs; + uint32_t dif; + uint16_t rng; + int16_t cnt; + int error; +} MsacContext; + +void msac_init(MsacContext *c, const uint8_t *data, size_t sz); +unsigned msac_decode_symbol(MsacContext *c, const uint16_t *cdf, + const unsigned n_symbols); +unsigned msac_decode_bool(MsacContext *c, unsigned cdf); +unsigned msac_decode_bools(MsacContext *c, unsigned l); +int msac_decode_subexp(MsacContext *c, int ref, unsigned n, unsigned k); +int msac_decode_uniform(MsacContext *c, unsigned n); +void update_cdf(uint16_t *cdf, unsigned val, unsigned nsymbs); + +static inline unsigned msac_decode_symbol_adapt(MsacContext *const c, + uint16_t *const cdf, + const unsigned n_symbols) +{ + const unsigned val = msac_decode_symbol(c, cdf, n_symbols); + update_cdf(cdf, val, n_symbols); + return val; +} + +static inline unsigned msac_decode_bool_adapt(MsacContext *const c, + uint16_t *const cdf) +{ + const unsigned bit = msac_decode_bool(c, *cdf); + uint16_t bak_cdf[3] = { cdf[0], 0, cdf[1] }; + update_cdf(bak_cdf, bit, 2); + cdf[0] = bak_cdf[0]; + cdf[1] = bak_cdf[2]; + return bit; +} + +#endif /* __DAV1D_SRC_MSAC_H__ */ diff --git a/src/obu.c b/src/obu.c new file mode 100644 index 0000000..cf5490b --- /dev/null +++ b/src/obu.c @@ -0,0 +1,1102 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <assert.h> +#include <errno.h> +#include <limits.h> +#include <stdio.h> + +#include "dav1d/data.h" + +#include "common/intops.h" + +#include "src/decode.h" +#include "src/getbits.h" +#include "src/levels.h" +#include "src/obu.h" +#include "src/ref.h" +#include "src/warpmv.h" + +static int parse_seq_hdr(Dav1dContext *const c, GetBits *const gb) { + const uint8_t *const init_ptr = gb->ptr; + Av1SequenceHeader *const hdr = &c->seq_hdr; + +#define DEBUG_SEQ_HDR 0 + + hdr->profile = get_bits(gb, 3); + if (hdr->profile > 2U) goto error; +#if DEBUG_SEQ_HDR + printf("SEQHDR: post-profile: off=%ld\n", + (gb->ptr - init_ptr) * 8 - gb->bits_left); +#endif + + hdr->still_picture = get_bits(gb, 1); + hdr->reduced_still_picture_header = get_bits(gb, 1); + if (hdr->reduced_still_picture_header && !hdr->still_picture) goto error; +#if DEBUG_SEQ_HDR + printf("SEQHDR: post-stillpicture_flags: off=%ld\n", + (gb->ptr - init_ptr) * 8 - gb->bits_left); +#endif + + if (hdr->reduced_still_picture_header) { + hdr->timing_info_present = 0; + hdr->decoder_model_info_present = 0; + hdr->display_model_info_present = 0; + hdr->num_operating_points = 1; + hdr->operating_points[0].idc = 0; + hdr->operating_points[0].major_level = get_bits(gb, 3); + hdr->operating_points[0].minor_level = get_bits(gb, 2); + hdr->operating_points[0].tier = 0; + hdr->operating_points[0].decoder_model_param_present = 0; + hdr->operating_points[0].display_model_param_present = 0; + } else { + hdr->timing_info_present = get_bits(gb, 1); + if (hdr->timing_info_present) { + hdr->num_units_in_tick = get_bits(gb, 32); + hdr->time_scale = get_bits(gb, 32); + hdr->equal_picture_interval = get_bits(gb, 1); + if (hdr->equal_picture_interval) + hdr->num_ticks_per_picture = get_vlc(gb) + 1; + + hdr->decoder_model_info_present = get_bits(gb, 1); + if (hdr->decoder_model_info_present) { + hdr->bitrate_scale = get_bits(gb, 4); + hdr->buffer_size_scale = get_bits(gb, 4); + hdr->encoder_decoder_buffer_delay_length = get_bits(gb, 5) + 1; + hdr->num_units_in_decoding_tick = get_bits(gb, 32); + hdr->buffer_removal_delay_length = get_bits(gb, 5) + 1; + hdr->frame_presentation_delay_length = get_bits(gb, 5) + 1; + } + } else { + hdr->decoder_model_info_present = 0; + } +#if DEBUG_SEQ_HDR + printf("SEQHDR: post-timinginfo: off=%ld\n", + (gb->ptr - init_ptr) * 8 - gb->bits_left); +#endif + + hdr->display_model_info_present = get_bits(gb, 1); + hdr->num_operating_points = get_bits(gb, 5) + 1; + for (int i = 0; i < c->seq_hdr.num_operating_points; i++) { + struct Av1SequenceHeaderOperatingPoint *const op = + &hdr->operating_points[i]; + op->idc = get_bits(gb, 12); + op->major_level = 2 + get_bits(gb, 3); + op->minor_level = get_bits(gb, 2); + op->tier = op->major_level > 3 ? get_bits(gb, 1) : 0; + op->decoder_model_param_present = + hdr->decoder_model_info_present && get_bits(gb, 1); + if (op->decoder_model_param_present) { + op->bitrate = get_vlc(gb) + 1; + op->buffer_size = get_vlc(gb) + 1; + op->cbr = get_bits(gb, 1); + op->decoder_buffer_delay = + get_bits(gb, hdr->encoder_decoder_buffer_delay_length); + op->encoder_buffer_delay = + get_bits(gb, hdr->encoder_decoder_buffer_delay_length); + op->low_delay_mode = get_bits(gb, 1); + } + op->display_model_param_present = + hdr->display_model_info_present && get_bits(gb, 1); + if (op->display_model_param_present) { + op->initial_display_delay = get_bits(gb, 4) + 1; + } + } +#if DEBUG_SEQ_HDR + printf("SEQHDR: post-operating-points: off=%ld\n", + (gb->ptr - init_ptr) * 8 - gb->bits_left); +#endif + } + + hdr->width_n_bits = get_bits(gb, 4) + 1; + hdr->height_n_bits = get_bits(gb, 4) + 1; + hdr->max_width = get_bits(gb, hdr->width_n_bits) + 1; + hdr->max_height = get_bits(gb, hdr->height_n_bits) + 1; +#if DEBUG_SEQ_HDR + printf("SEQHDR: post-size: off=%ld\n", + (gb->ptr - init_ptr) * 8 - gb->bits_left); +#endif + hdr->frame_id_numbers_present = + hdr->reduced_still_picture_header ? 0 : get_bits(gb, 1); + if (hdr->frame_id_numbers_present) { + hdr->delta_frame_id_n_bits = get_bits(gb, 4) + 2; + hdr->frame_id_n_bits = get_bits(gb, 3) + hdr->delta_frame_id_n_bits + 1; + } +#if DEBUG_SEQ_HDR + printf("SEQHDR: post-frame-id-numbers-present: off=%ld\n", + (gb->ptr - init_ptr) * 8 - gb->bits_left); +#endif + + hdr->sb128 = get_bits(gb, 1); + hdr->filter_intra = get_bits(gb, 1); + hdr->intra_edge_filter = get_bits(gb, 1); + if (hdr->reduced_still_picture_header) { + hdr->inter_intra = 0; + hdr->masked_compound = 0; + hdr->warped_motion = 0; + hdr->dual_filter = 0; + hdr->order_hint = 0; + hdr->jnt_comp = 0; + hdr->ref_frame_mvs = 0; + hdr->order_hint_n_bits = 0; + hdr->screen_content_tools = ADAPTIVE; + hdr->force_integer_mv = ADAPTIVE; + } else { + hdr->inter_intra = get_bits(gb, 1); + hdr->masked_compound = get_bits(gb, 1); + hdr->warped_motion = get_bits(gb, 1); + hdr->dual_filter = get_bits(gb, 1); + hdr->order_hint = get_bits(gb, 1); + if (hdr->order_hint) { + hdr->jnt_comp = get_bits(gb, 1); + hdr->ref_frame_mvs = get_bits(gb, 1); + } else { + hdr->jnt_comp = 0; + hdr->ref_frame_mvs = 0; + hdr->order_hint_n_bits = 0; + } + hdr->screen_content_tools = get_bits(gb, 1) ? ADAPTIVE : get_bits(gb, 1); + #if DEBUG_SEQ_HDR + printf("SEQHDR: post-screentools: off=%ld\n", + (gb->ptr - init_ptr) * 8 - gb->bits_left); + #endif + hdr->force_integer_mv = hdr->screen_content_tools ? + get_bits(gb, 1) ? ADAPTIVE : get_bits(gb, 1) : 2; + if (hdr->order_hint) + hdr->order_hint_n_bits = get_bits(gb, 3) + 1; + } + hdr->super_res = get_bits(gb, 1); + hdr->cdef = get_bits(gb, 1); + hdr->restoration = get_bits(gb, 1); +#if DEBUG_SEQ_HDR + printf("SEQHDR: post-featurebits: off=%ld\n", + (gb->ptr - init_ptr) * 8 - gb->bits_left); +#endif + + const int hbd = get_bits(gb, 1); + hdr->bpc = hdr->profile == 2 && hbd ? 10 + 2 * get_bits(gb, 1): 8 + 2 * hbd; + hdr->hbd = hdr->bpc > 8; + const int monochrome = hdr->profile != 1 ? get_bits(gb, 1) : 0; + hdr->color_description_present = get_bits(gb, 1); + if (hdr->color_description_present) { + hdr->pri = get_bits(gb, 8); + hdr->trc = get_bits(gb, 8); + hdr->mtrx = get_bits(gb, 8); + } else { + hdr->pri = DAV1D_COLOR_PRI_UNKNOWN; + hdr->trc = DAV1D_TRC_UNKNOWN; + hdr->mtrx = DAV1D_MC_UNKNOWN; + } + if (monochrome) { + hdr->color_range = get_bits(gb, 1); + hdr->layout = DAV1D_PIXEL_LAYOUT_I400; + hdr->chr = DAV1D_CHR_UNKNOWN; + hdr->separate_uv_delta_q = 0; + } else if (hdr->pri == DAV1D_COLOR_PRI_BT709 && + hdr->trc == DAV1D_TRC_SRGB && + hdr->mtrx == DAV1D_MC_IDENTITY) + { + hdr->layout = DAV1D_PIXEL_LAYOUT_I444; + hdr->color_range = 1; + if (hdr->profile != 1 && !(hdr->profile == 2 && hdr->bpc == 12)) + goto error; + } else { + hdr->color_range = get_bits(gb, 1); + switch (hdr->profile) { + case 0: hdr->layout = DAV1D_PIXEL_LAYOUT_I420; break; + case 1: hdr->layout = DAV1D_PIXEL_LAYOUT_I444; break; + case 2: + if (hdr->bpc == 12) { + hdr->layout = get_bits(gb, 1) ? + get_bits(gb, 1) ? DAV1D_PIXEL_LAYOUT_I420 : + DAV1D_PIXEL_LAYOUT_I422 : + DAV1D_PIXEL_LAYOUT_I444; + } else + hdr->layout = DAV1D_PIXEL_LAYOUT_I422; + break; + } + if (hdr->layout == DAV1D_PIXEL_LAYOUT_I420) + hdr->chr = get_bits(gb, 2); + hdr->separate_uv_delta_q = get_bits(gb, 1); + } +#if DEBUG_SEQ_HDR + printf("SEQHDR: post-colorinfo: off=%ld\n", + (gb->ptr - init_ptr) * 8 - gb->bits_left); +#endif + + c->seq_hdr.film_grain_present = get_bits(gb, 1); +#if DEBUG_SEQ_HDR + printf("SEQHDR: post-filmgrain: off=%ld\n", + (gb->ptr - init_ptr) * 8 - gb->bits_left); +#endif + + get_bits(gb, 1); // dummy bit + + return flush_get_bits(gb) - init_ptr; + +error: + fprintf(stderr, "Error parsing sequence header\n"); + return -EINVAL; +} + +static int read_frame_size(Dav1dContext *const c, GetBits *const gb, + const int use_ref) +{ + const Av1SequenceHeader *const seqhdr = &c->seq_hdr; + Av1FrameHeader *const hdr = &c->frame_hdr; + + if (use_ref) { + for (int i = 0; i < 7; i++) { + if (get_bits(gb, 1)) { + Dav1dThreadPicture *const ref = + &c->refs[c->frame_hdr.refidx[i]].p; + if (!ref->p.data[0]) return -1; + // FIXME render_* may be wrong + hdr->render_width = hdr->width = ref->p.p.w; + hdr->render_height = hdr->height = ref->p.p.h; + hdr->super_res = 0; // FIXME probably wrong + return 0; + } + } + } + + if (hdr->frame_size_override) { + hdr->width = get_bits(gb, seqhdr->width_n_bits) + 1; + hdr->height = get_bits(gb, seqhdr->height_n_bits) + 1; + } else { + hdr->width = seqhdr->max_width; + hdr->height = seqhdr->max_height; + } + hdr->super_res = seqhdr->super_res && get_bits(gb, 1); + if (hdr->super_res) return -1; // FIXME + hdr->have_render_size = get_bits(gb, 1); + if (hdr->have_render_size) { + hdr->render_width = get_bits(gb, seqhdr->width_n_bits) + 1; + hdr->render_height = get_bits(gb, seqhdr->height_n_bits) + 1; + } else { + hdr->render_width = hdr->width; + hdr->render_height = hdr->height; + } + return 0; +} + +static inline int tile_log2(int sz, int tgt) { + int k; + for (k = 0; (sz << k) < tgt; k++) ; + return k; +} + +static const Av1LoopfilterModeRefDeltas default_mode_ref_deltas = { + .mode_delta = { 0, 0 }, + .ref_delta = { 1, 0, 0, 0, -1, 0, -1, -1 }, +}; + +static int parse_frame_hdr(Dav1dContext *const c, GetBits *const gb, + const int have_trailing_bit) +{ + const uint8_t *const init_ptr = gb->ptr; + const Av1SequenceHeader *const seqhdr = &c->seq_hdr; + Av1FrameHeader *const hdr = &c->frame_hdr; + int res; + +#define DEBUG_FRAME_HDR 0 + + hdr->show_existing_frame = + !seqhdr->reduced_still_picture_header && get_bits(gb, 1); +#if DEBUG_FRAME_HDR + printf("HDR: post-show_existing_frame: off=%ld\n", + (gb->ptr - init_ptr) * 8 - gb->bits_left); +#endif + if (hdr->show_existing_frame) { + hdr->existing_frame_idx = get_bits(gb, 3); + if (seqhdr->frame_id_numbers_present) + hdr->frame_id = get_bits(gb, seqhdr->frame_id_n_bits); + goto end; + } + + hdr->frame_type = seqhdr->reduced_still_picture_header ? KEY_FRAME : get_bits(gb, 2); + hdr->show_frame = seqhdr->reduced_still_picture_header || get_bits(gb, 1); + if (!hdr->show_frame) + hdr->showable_frame = get_bits(gb, 1); + hdr->error_resilient_mode = + (hdr->frame_type == KEY_FRAME && hdr->show_frame) || + hdr->frame_type == S_FRAME || + seqhdr->reduced_still_picture_header || get_bits(gb, 1); +#if DEBUG_FRAME_HDR + printf("HDR: post-frametype_bits: off=%ld\n", + (gb->ptr - init_ptr) * 8 - gb->bits_left); +#endif + hdr->disable_cdf_update = get_bits(gb, 1); + hdr->allow_screen_content_tools = seqhdr->screen_content_tools == ADAPTIVE ? + get_bits(gb, 1) : seqhdr->screen_content_tools; + if (hdr->allow_screen_content_tools) + hdr->force_integer_mv = seqhdr->force_integer_mv == ADAPTIVE ? + get_bits(gb, 1) : seqhdr->force_integer_mv; + + if (seqhdr->frame_id_numbers_present) + hdr->frame_id = get_bits(gb, seqhdr->frame_id_n_bits); + + hdr->frame_size_override = seqhdr->reduced_still_picture_header ? 0 : + hdr->frame_type == S_FRAME ? 1 : get_bits(gb, 1); +#if DEBUG_FRAME_HDR + printf("HDR: post-frame_size_override_flag: off=%ld\n", + (gb->ptr - init_ptr) * 8 - gb->bits_left); +#endif + hdr->frame_offset = seqhdr->order_hint ? + get_bits(gb, seqhdr->order_hint_n_bits) : 0; + hdr->primary_ref_frame = !hdr->error_resilient_mode && hdr->frame_type & 1 ? + get_bits(gb, 3) : PRIMARY_REF_NONE; + + if (hdr->frame_type == KEY_FRAME) { + hdr->refresh_frame_flags = hdr->show_frame ? 0xff : get_bits(gb, 8); + if ((res = read_frame_size(c, gb, 0)) < 0) goto error; + hdr->allow_intrabc = hdr->allow_screen_content_tools && + /* FIXME: no superres scaling && */ get_bits(gb, 1); + hdr->use_ref_frame_mvs = 0; + } else { + if (hdr->error_resilient_mode && seqhdr->order_hint) + for (int i = 0; i < 8; i++) + get_bits(gb, seqhdr->order_hint_n_bits); + + if (hdr->frame_type == INTRAONLY_FRAME) { + hdr->refresh_frame_flags = get_bits(gb, 8); + if ((res = read_frame_size(c, gb, 0)) < 0) goto error; + hdr->allow_intrabc = hdr->allow_screen_content_tools && + /* FIXME: no superres scaling && */ get_bits(gb, 1); + } else { + hdr->allow_intrabc = 0; + hdr->refresh_frame_flags = hdr->frame_type == S_FRAME ? 0xff : + get_bits(gb, 8); + hdr->frame_ref_short_signaling = + seqhdr->order_hint && get_bits(gb, 1); + if (hdr->frame_ref_short_signaling) goto error; // FIXME + for (int i = 0; i < 7; i++) { + hdr->refidx[i] = get_bits(gb, 3); + if (seqhdr->frame_id_numbers_present) + get_bits(gb, seqhdr->delta_frame_id_n_bits); + } + const int use_ref = !hdr->error_resilient_mode && + hdr->frame_size_override; + if ((res = read_frame_size(c, gb, use_ref)) < 0) goto error; + hdr->hp = !hdr->force_integer_mv && get_bits(gb, 1); + hdr->subpel_filter_mode = get_bits(gb, 1) ? FILTER_SWITCHABLE : + get_bits(gb, 2); + hdr->switchable_motion_mode = get_bits(gb, 1); + hdr->use_ref_frame_mvs = !hdr->error_resilient_mode && + seqhdr->ref_frame_mvs && seqhdr->order_hint && + hdr->frame_type & 1 && get_bits(gb, 1); + } + } +#if DEBUG_FRAME_HDR + printf("HDR: post-frametype-specific-bits: off=%ld\n", + (gb->ptr - init_ptr) * 8 - gb->bits_left); +#endif + + hdr->refresh_context = !seqhdr->reduced_still_picture_header && + !hdr->disable_cdf_update && !get_bits(gb, 1); +#if DEBUG_FRAME_HDR + printf("HDR: post-refresh_context: off=%ld\n", + (gb->ptr - init_ptr) * 8 - gb->bits_left); +#endif + + // tile data + hdr->tiling.uniform = get_bits(gb, 1); + const int sbsz_min1 = (64 << seqhdr->sb128) - 1; + int sbsz_log2 = 6 + seqhdr->sb128; + int sbw = (hdr->width + sbsz_min1) >> sbsz_log2; + int sbh = (hdr->height + sbsz_min1) >> sbsz_log2; + int max_tile_width_sb = 4096 >> sbsz_log2, max_tile_height_sb; + int max_tile_area_sb = 4096 * 2304 >> (2 * sbsz_log2); + hdr->tiling.min_log2_cols = tile_log2(max_tile_width_sb, sbw); + hdr->tiling.max_log2_cols = tile_log2(1, imin(sbw, 1024)); + hdr->tiling.max_log2_rows = tile_log2(1, imin(sbh, 1024)); + int min_log2_tiles = imax(tile_log2(max_tile_area_sb, sbw * sbh), + hdr->tiling.min_log2_cols); + if (hdr->tiling.uniform) { + for (hdr->tiling.log2_cols = hdr->tiling.min_log2_cols; + hdr->tiling.log2_cols < hdr->tiling.max_log2_cols && get_bits(gb, 1); + hdr->tiling.log2_cols++) ; + const int tile_w = 1 + ((sbw - 1) >> hdr->tiling.log2_cols); + hdr->tiling.cols = 0; + for (int sbx = 0; sbx < sbw; sbx += tile_w, hdr->tiling.cols++) + hdr->tiling.col_start_sb[hdr->tiling.cols] = sbx; + hdr->tiling.min_log2_rows = + imax(min_log2_tiles - hdr->tiling.log2_cols, 0); + max_tile_height_sb = sbh >> hdr->tiling.min_log2_rows; + + for (hdr->tiling.log2_rows = hdr->tiling.min_log2_rows; + hdr->tiling.log2_rows < hdr->tiling.max_log2_rows && get_bits(gb, 1); + hdr->tiling.log2_rows++) ; + const int tile_h = 1 + ((sbh - 1) >> hdr->tiling.log2_rows); + hdr->tiling.rows = 0; + for (int sby = 0; sby < sbh; sby += tile_h, hdr->tiling.rows++) + hdr->tiling.row_start_sb[hdr->tiling.rows] = sby; + } else { + hdr->tiling.cols = 0; + int widest_tile = 0, max_tile_area_sb = sbw * sbh; + for (int sbx = 0; sbx < sbw; hdr->tiling.cols++) { + const int tile_w = get_uniform(gb, imin(sbw - sbx, + max_tile_width_sb)); + hdr->tiling.col_start_sb[hdr->tiling.cols] = sbx; + sbx += tile_w; + widest_tile = imax(widest_tile, tile_w); + } + hdr->tiling.log2_cols = tile_log2(1, hdr->tiling.cols); + if (min_log2_tiles) max_tile_area_sb >>= min_log2_tiles + 1; + max_tile_height_sb = imax(max_tile_area_sb / widest_tile, 1); + + hdr->tiling.rows = 0; + for (int sby = 0; sby < sbh; hdr->tiling.rows++) { + const int tile_h = get_uniform(gb, imin(sbh - sby, + max_tile_height_sb)); + hdr->tiling.row_start_sb[hdr->tiling.rows] = sby; + sby += tile_h; + } + hdr->tiling.log2_rows = tile_log2(1, hdr->tiling.rows); + } + hdr->tiling.col_start_sb[hdr->tiling.cols] = sbw; + hdr->tiling.row_start_sb[hdr->tiling.rows] = sbh; + if (hdr->tiling.log2_cols || hdr->tiling.log2_rows) { + hdr->tiling.update = get_bits(gb, hdr->tiling.log2_cols + + hdr->tiling.log2_rows); + hdr->tiling.n_bytes = get_bits(gb, 2) + 1; + } else { + hdr->tiling.n_bytes = hdr->tiling.update = 0; + } +#if DEBUG_FRAME_HDR + printf("HDR: post-tiling: off=%ld\n", + (gb->ptr - init_ptr) * 8 - gb->bits_left); +#endif + + // quant data + hdr->quant.yac = get_bits(gb, 8); + hdr->quant.ydc_delta = get_bits(gb, 1) ? get_sbits(gb, 6) : 0; + if (seqhdr->layout != DAV1D_PIXEL_LAYOUT_I400) { + hdr->quant.udc_delta = get_bits(gb, 1) ? get_sbits(gb, 6) : 0; + hdr->quant.uac_delta = get_bits(gb, 1) ? get_sbits(gb, 6) : 0; + if (seqhdr->separate_uv_delta_q) { + hdr->quant.vdc_delta = get_bits(gb, 1) ? get_sbits(gb, 6) : 0; + hdr->quant.vac_delta = get_bits(gb, 1) ? get_sbits(gb, 6) : 0; + } else { + hdr->quant.vdc_delta = hdr->quant.udc_delta; + hdr->quant.vac_delta = hdr->quant.uac_delta; + } + } +#if DEBUG_FRAME_HDR + printf("HDR: post-quant: off=%ld\n", + (gb->ptr - init_ptr) * 8 - gb->bits_left); +#endif + hdr->quant.qm = get_bits(gb, 1); + if (hdr->quant.qm) { + hdr->quant.qm_y = get_bits(gb, 4); + hdr->quant.qm_u = get_bits(gb, 4); + hdr->quant.qm_v = seqhdr->separate_uv_delta_q ? get_bits(gb, 4) : + hdr->quant.qm_u; + } +#if DEBUG_FRAME_HDR + printf("HDR: post-qm: off=%ld\n", + (gb->ptr - init_ptr) * 8 - gb->bits_left); +#endif + + // segmentation data + hdr->segmentation.enabled = get_bits(gb, 1); + if (hdr->segmentation.enabled) { + if (hdr->primary_ref_frame == PRIMARY_REF_NONE) { + hdr->segmentation.update_map = 1; + hdr->segmentation.temporal = 0; + hdr->segmentation.update_data = 1; + } else { + hdr->segmentation.update_map = get_bits(gb, 1); + hdr->segmentation.temporal = + hdr->segmentation.update_map ? get_bits(gb, 1) : 0; + hdr->segmentation.update_data = get_bits(gb, 1); + } + + if (hdr->segmentation.update_data) { + hdr->segmentation.seg_data.preskip = 0; + hdr->segmentation.seg_data.last_active_segid = -1; + for (int i = 0; i < NUM_SEGMENTS; i++) { + Av1SegmentationData *const seg = + &hdr->segmentation.seg_data.d[i]; + if (get_bits(gb, 1)) { + seg->delta_q = get_sbits(gb, 8); + hdr->segmentation.seg_data.last_active_segid = i; + } else { + seg->delta_q = 0; + } + if (get_bits(gb, 1)) { + seg->delta_lf_y_v = get_sbits(gb, 6); + hdr->segmentation.seg_data.last_active_segid = i; + } else { + seg->delta_lf_y_v = 0; + } + if (get_bits(gb, 1)) { + seg->delta_lf_y_h = get_sbits(gb, 6); + hdr->segmentation.seg_data.last_active_segid = i; + } else { + seg->delta_lf_y_h = 0; + } + if (get_bits(gb, 1)) { + seg->delta_lf_u = get_sbits(gb, 6); + hdr->segmentation.seg_data.last_active_segid = i; + } else { + seg->delta_lf_u = 0; + } + if (get_bits(gb, 1)) { + seg->delta_lf_v = get_sbits(gb, 6); + hdr->segmentation.seg_data.last_active_segid = i; + } else { + seg->delta_lf_v = 0; + } + if (get_bits(gb, 1)) { + seg->ref = get_bits(gb, 3); + hdr->segmentation.seg_data.last_active_segid = i; + hdr->segmentation.seg_data.preskip = 1; + } else { + seg->ref = -1; + } + if ((seg->skip = get_bits(gb, 1))) { + hdr->segmentation.seg_data.last_active_segid = i; + hdr->segmentation.seg_data.preskip = 1; + } + if ((seg->globalmv = get_bits(gb, 1))) { + hdr->segmentation.seg_data.last_active_segid = i; + hdr->segmentation.seg_data.preskip = 1; + } + } + } else { + const int pri_ref = hdr->refidx[hdr->primary_ref_frame]; + hdr->segmentation.seg_data = c->refs[pri_ref].seg_data; + } + } else { + const int pri_ref = hdr->refidx[hdr->primary_ref_frame]; + hdr->segmentation.seg_data = c->refs[pri_ref].seg_data; + } +#if DEBUG_FRAME_HDR + printf("HDR: post-segmentation: off=%ld\n", + (gb->ptr - init_ptr) * 8 - gb->bits_left); +#endif + + // delta q + hdr->delta_q_present = hdr->quant.yac ? get_bits(gb, 1) : 0; + hdr->delta_q_res_log2 = hdr->delta_q_present ? get_bits(gb, 2) : 0; + hdr->delta_lf_present = hdr->delta_q_present && !hdr->allow_intrabc && + get_bits(gb, 1); + hdr->delta_lf_res_log2 = hdr->delta_lf_present ? get_bits(gb, 2) : 0; + hdr->delta_lf_multi = hdr->delta_lf_present ? get_bits(gb, 1) : 0; +#if DEBUG_FRAME_HDR + printf("HDR: post-delta_q_lf_flags: off=%ld\n", + (gb->ptr - init_ptr) * 8 - gb->bits_left); +#endif + + // derive lossless flags + const int delta_lossless = !hdr->quant.ydc_delta && !hdr->quant.udc_delta && + !hdr->quant.uac_delta && !hdr->quant.vdc_delta && !hdr->quant.vac_delta; + hdr->all_lossless = 1; + for (int i = 0; i < NUM_SEGMENTS; i++) { + hdr->segmentation.qidx[i] = hdr->segmentation.enabled ? + iclip_u8(hdr->quant.yac + hdr->segmentation.seg_data.d[i].delta_q) : + hdr->quant.yac; + hdr->segmentation.lossless[i] = + !hdr->segmentation.qidx[i] && delta_lossless; + hdr->all_lossless &= hdr->segmentation.lossless[i]; + } + + // loopfilter + if (hdr->all_lossless || hdr->allow_intrabc) { + hdr->loopfilter.level_y[0] = hdr->loopfilter.level_y[1] = 0; + hdr->loopfilter.level_u = hdr->loopfilter.level_v = 0; + hdr->loopfilter.sharpness = 0; + hdr->loopfilter.mode_ref_delta_enabled = 1; + hdr->loopfilter.mode_ref_delta_update = 1; + hdr->loopfilter.mode_ref_deltas = default_mode_ref_deltas; + } else { + hdr->loopfilter.level_y[0] = get_bits(gb, 6); + hdr->loopfilter.level_y[1] = get_bits(gb, 6); + if (seqhdr->layout != DAV1D_PIXEL_LAYOUT_I400 && + (hdr->loopfilter.level_y[0] || hdr->loopfilter.level_y[1])) + { + hdr->loopfilter.level_u = get_bits(gb, 6); + hdr->loopfilter.level_v = get_bits(gb, 6); + } + hdr->loopfilter.sharpness = get_bits(gb, 3); + + if (hdr->primary_ref_frame == PRIMARY_REF_NONE) { + hdr->loopfilter.mode_ref_deltas = default_mode_ref_deltas; + } else { + const int ref = hdr->refidx[hdr->primary_ref_frame]; + hdr->loopfilter.mode_ref_deltas = c->refs[ref].lf_mode_ref_deltas; + } + hdr->loopfilter.mode_ref_delta_enabled = get_bits(gb, 1); + if (hdr->loopfilter.mode_ref_delta_enabled) { + hdr->loopfilter.mode_ref_delta_update = get_bits(gb, 1); + if (hdr->loopfilter.mode_ref_delta_update) { + for (int i = 0; i < 8; i++) + if (get_bits(gb, 1)) + hdr->loopfilter.mode_ref_deltas.ref_delta[i] = + get_sbits(gb, 6); + for (int i = 0; i < 2; i++) + if (get_bits(gb, 1)) + hdr->loopfilter.mode_ref_deltas.mode_delta[i] = + get_sbits(gb, 6); + } + } + } +#if DEBUG_FRAME_HDR + printf("HDR: post-lpf: off=%ld\n", + (gb->ptr - init_ptr) * 8 - gb->bits_left); +#endif + + // cdef + if (!hdr->all_lossless && seqhdr->cdef && !hdr->allow_intrabc) { + hdr->cdef.damping = get_bits(gb, 2) + 3; + hdr->cdef.n_bits = get_bits(gb, 2); + for (int i = 0; i < (1 << hdr->cdef.n_bits); i++) { + hdr->cdef.y_strength[i] = get_bits(gb, 6); + if (seqhdr->layout != DAV1D_PIXEL_LAYOUT_I400) + hdr->cdef.uv_strength[i] = get_bits(gb, 6); + } + } else { + hdr->cdef.n_bits = 0; + hdr->cdef.y_strength[0] = 0; + hdr->cdef.uv_strength[0] = 0; + } +#if DEBUG_FRAME_HDR + printf("HDR: post-cdef: off=%ld\n", + (gb->ptr - init_ptr) * 8 - gb->bits_left); +#endif + + // restoration + if (!hdr->all_lossless && seqhdr->restoration && !hdr->allow_intrabc) { + hdr->restoration.type[0] = get_bits(gb, 2); + if (seqhdr->layout != DAV1D_PIXEL_LAYOUT_I400) { + hdr->restoration.type[1] = get_bits(gb, 2); + hdr->restoration.type[2] = get_bits(gb, 2); + } + + if (hdr->restoration.type[0] || hdr->restoration.type[1] || + hdr->restoration.type[2]) + { + // Log2 of the restoration unit size. + hdr->restoration.unit_size[0] = 6 + seqhdr->sb128; + if (get_bits(gb, 1)) { + hdr->restoration.unit_size[0]++; + if (!seqhdr->sb128) + hdr->restoration.unit_size[0] += get_bits(gb, 1); + } + hdr->restoration.unit_size[1] = hdr->restoration.unit_size[0]; + if ((hdr->restoration.type[1] || hdr->restoration.type[2]) && + seqhdr->layout == DAV1D_PIXEL_LAYOUT_I420) + { + hdr->restoration.unit_size[1] -= get_bits(gb, 1); + } + } else { + hdr->restoration.unit_size[0] = 8; + } + } else { + hdr->restoration.type[0] = RESTORATION_NONE; + hdr->restoration.type[1] = RESTORATION_NONE; + hdr->restoration.type[2] = RESTORATION_NONE; + } +#if DEBUG_FRAME_HDR + printf("HDR: post-restoration: off=%ld\n", + (gb->ptr - init_ptr) * 8 - gb->bits_left); +#endif + + hdr->txfm_mode = hdr->all_lossless ? TX_4X4_ONLY : + get_bits(gb, 1) ? TX_SWITCHABLE : TX_LARGEST; +#if DEBUG_FRAME_HDR + printf("HDR: post-txfmmode: off=%ld\n", + (gb->ptr - init_ptr) * 8 - gb->bits_left); +#endif + hdr->switchable_comp_refs = hdr->frame_type & 1 ? get_bits(gb, 1) : 0; +#if DEBUG_FRAME_HDR + printf("HDR: post-refmode: off=%ld\n", + (gb->ptr - init_ptr) * 8 - gb->bits_left); +#endif + hdr->skip_mode_allowed = 0; + if (hdr->switchable_comp_refs && hdr->frame_type & 1) { + const unsigned poc = hdr->frame_offset; + unsigned off_before[2] = { 0xFFFFFFFF, 0xFFFFFFFF }; + int off_after = -1; + int off_before_idx[2], off_after_idx; + for (int i = 0; i < 7; i++) { + const unsigned refpoc = c->refs[hdr->refidx[i]].p.p.poc; + + const int diff = get_poc_diff(seqhdr->order_hint_n_bits, refpoc, poc); + if (diff > 0) { + if (off_after == -1 || get_poc_diff(seqhdr->order_hint_n_bits, + off_after, refpoc) > 0) + { + off_after = refpoc; + off_after_idx = i; + } + } else if (diff < 0) { + if (off_before[0] == 0xFFFFFFFFU || + get_poc_diff(seqhdr->order_hint_n_bits, + refpoc, off_before[0]) > 0) + { + off_before[1] = off_before[0]; + off_before[0] = refpoc; + off_before_idx[1] = off_before_idx[0]; + off_before_idx[0] = i; + } else if (refpoc != off_before[0] && + (off_before[1] == 0xFFFFFFFFU || + get_poc_diff(seqhdr->order_hint_n_bits, + refpoc, off_before[1]) > 0)) + { + off_before[1] = refpoc; + off_before_idx[1] = i; + } + } + } + + if (off_before[0] != 0xFFFFFFFFU && off_after != -1) { + hdr->skip_mode_refs[0] = off_before_idx[0]; + hdr->skip_mode_refs[1] = off_after_idx; + hdr->skip_mode_allowed = 1; + } else if (off_before[0] != 0xFFFFFFFFU && + off_before[1] != 0xFFFFFFFFU) + { + hdr->skip_mode_refs[0] = off_before_idx[0]; + hdr->skip_mode_refs[1] = off_before_idx[1]; + hdr->skip_mode_allowed = 1; + } + } + hdr->skip_mode_enabled = hdr->skip_mode_allowed ? get_bits(gb, 1) : 0; +#if DEBUG_FRAME_HDR + printf("HDR: post-extskip: off=%ld\n", + (gb->ptr - init_ptr) * 8 - gb->bits_left); +#endif + hdr->warp_motion = !hdr->error_resilient_mode && hdr->frame_type & 1 && + seqhdr->warped_motion && get_bits(gb, 1); +#if DEBUG_FRAME_HDR + printf("HDR: post-warpmotionbit: off=%ld\n", + (gb->ptr - init_ptr) * 8 - gb->bits_left); +#endif + hdr->reduced_txtp_set = get_bits(gb, 1); +#if DEBUG_FRAME_HDR + printf("HDR: post-reducedtxtpset: off=%ld\n", + (gb->ptr - init_ptr) * 8 - gb->bits_left); +#endif + + for (int i = 0; i < 7; i++) + hdr->gmv[i] = default_wm_params; + + if (hdr->frame_type & 1) { + for (int i = 0; i < 7; i++) { + hdr->gmv[i].type = !get_bits(gb, 1) ? WM_TYPE_IDENTITY : + get_bits(gb, 1) ? WM_TYPE_ROT_ZOOM : + get_bits(gb, 1) ? WM_TYPE_TRANSLATION : + WM_TYPE_AFFINE; + + if (hdr->gmv[i].type == WM_TYPE_IDENTITY) continue; + + const WarpedMotionParams *const ref_gmv = + hdr->primary_ref_frame == PRIMARY_REF_NONE ? &default_wm_params : + &c->refs[hdr->refidx[hdr->primary_ref_frame]].gmv[i]; + int32_t *const mat = hdr->gmv[i].matrix; + const int32_t *const ref_mat = ref_gmv->matrix; + int bits, shift; + + if (hdr->gmv[i].type >= WM_TYPE_ROT_ZOOM) { + mat[2] = (1 << 16) + 2 * + get_bits_subexp(gb, (ref_mat[2] - (1 << 16)) >> 1, 12); + mat[3] = 2 * get_bits_subexp(gb, ref_mat[3] >> 1, 12); + + bits = 12; + shift = 10; + } else { + bits = 9 - !hdr->hp; + shift = 13 + !hdr->hp; + } + + if (hdr->gmv[i].type == WM_TYPE_AFFINE) { + mat[4] = 2 * get_bits_subexp(gb, ref_mat[4] >> 1, 12); + mat[5] = (1 << 16) + 2 * + get_bits_subexp(gb, (ref_mat[5] - (1 << 16)) >> 1, 12); + } else { + mat[4] = -mat[3]; + mat[5] = mat[2]; + } + + mat[0] = get_bits_subexp(gb, ref_mat[0] >> shift, bits) * (1 << shift); + mat[1] = get_bits_subexp(gb, ref_mat[1] >> shift, bits) * (1 << shift); + + if (get_shear_params(&hdr->gmv[i])) + goto error; + } + } +#if DEBUG_FRAME_HDR + printf("HDR: post-gmv: off=%ld\n", + (gb->ptr - init_ptr) * 8 - gb->bits_left); +#endif + + hdr->film_grain.present = seqhdr->film_grain_present && get_bits(gb, 1); + if (hdr->film_grain.present) { + hdr->film_grain.seed = get_bits(gb, 16); + hdr->film_grain.update = hdr->frame_type != INTER_FRAME || get_bits(gb, 1); + if (!hdr->film_grain.update) { + const int refidx = get_bits(gb, 3); + int i; + for (i = 0; i < 7; i++) + if (hdr->refidx[i] == refidx) + break; + if (i == 7) goto error; + hdr->film_grain.data = c->refs[refidx].film_grain; + } else { + Av1FilmGrainData *const fgd = &hdr->film_grain.data; + + fgd->num_y_points = get_bits(gb, 4); + if (fgd->num_y_points > 14) goto error; + for (int i = 0; i < fgd->num_y_points; i++) { + fgd->y_points[i][0] = get_bits(gb, 8); + if (i && fgd->y_points[i - 1][0] >= fgd->y_points[i][0]) + goto error; + fgd->y_points[i][1] = get_bits(gb, 8); + } + + fgd->chroma_scaling_from_luma = + seqhdr->layout != DAV1D_PIXEL_LAYOUT_I400 && get_bits(gb, 1); + if (seqhdr->layout == DAV1D_PIXEL_LAYOUT_I400 || + fgd->chroma_scaling_from_luma || + (seqhdr->layout == DAV1D_PIXEL_LAYOUT_I420 && !fgd->num_y_points)) + { + fgd->num_uv_points[0] = fgd->num_uv_points[1] = 0; + } else for (int pl = 0; pl < 2; pl++) { + fgd->num_uv_points[pl] = get_bits(gb, 4); + if (fgd->num_uv_points[pl] > 10) goto error; + for (int i = 0; i < fgd->num_uv_points[pl]; i++) { + fgd->uv_points[pl][i][0] = get_bits(gb, 8); + if (i && fgd->uv_points[pl][i - 1][0] >= fgd->uv_points[pl][i][0]) + goto error; + fgd->uv_points[pl][i][1] = get_bits(gb, 8); + } + } + + if (seqhdr->layout == DAV1D_PIXEL_LAYOUT_I420 && + !!fgd->num_uv_points[0] != !!fgd->num_uv_points[1]) + { + goto error; + } + + fgd->scaling_shift = get_bits(gb, 2) + 8; + fgd->ar_coeff_lag = get_bits(gb, 2); + const int num_y_pos = 2 * fgd->ar_coeff_lag * (fgd->ar_coeff_lag + 1); + if (fgd->num_y_points) + for (int i = 0; i < num_y_pos; i++) + fgd->ar_coeffs_y[i] = get_bits(gb, 8) - 128; + for (int pl = 0; pl < 2; pl++) + if (fgd->num_uv_points[pl] || fgd->chroma_scaling_from_luma) { + const int num_uv_pos = num_y_pos + !!fgd->num_y_points; + for (int i = 0; i < num_uv_pos; i++) + fgd->ar_coeffs_uv[pl][i] = get_bits(gb, 8) - 128; + } + fgd->ar_coeff_shift = get_bits(gb, 2) + 6; + fgd->grain_scale_shift = get_bits(gb, 2); + for (int pl = 0; pl < 2; pl++) + if (fgd->num_uv_points[pl]) { + fgd->uv_mult[pl] = get_bits(gb, 8); + fgd->uv_luma_mult[pl] = get_bits(gb, 8); + fgd->uv_offset[pl] = get_bits(gb, 9); + } + fgd->overlap_flag = get_bits(gb, 1); + fgd->clip_to_restricted_range = get_bits(gb, 1); + } + } else { + memset(&hdr->film_grain.data, 0, sizeof(hdr->film_grain)); + } +#if DEBUG_FRAME_HDR + printf("HDR: post-filmgrain: off=%ld\n", + (gb->ptr - init_ptr) * 8 - gb->bits_left); +#endif + +end: + + if (have_trailing_bit) + get_bits(gb, 1); // dummy bit + + return flush_get_bits(gb) - init_ptr; + +error: + fprintf(stderr, "Error parsing frame header\n"); + return -EINVAL; +} + +static int parse_tile_hdr(Dav1dContext *const c, GetBits *const gb) { + const uint8_t *const init_ptr = gb->ptr; + + int have_tile_pos = 0; + const int n_bits = c->frame_hdr.tiling.log2_cols + + c->frame_hdr.tiling.log2_rows; + if (n_bits) + have_tile_pos = get_bits(gb, 1); + + if (have_tile_pos) { + c->tile[c->n_tile_data].start = get_bits(gb, n_bits); + c->tile[c->n_tile_data].end = get_bits(gb, n_bits); + } else { + c->tile[c->n_tile_data].start = 0; + c->tile[c->n_tile_data].end = (1 << n_bits) - 1; + } + + return flush_get_bits(gb) - init_ptr; +} + +int parse_obus(Dav1dContext *const c, Dav1dData *const in) { + GetBits gb; + int res; + + init_get_bits(&gb, in->data, in->sz); + + // obu header + get_bits(&gb, 1); // obu_forbidden_bit + const enum ObuType type = get_bits(&gb, 4); + const int has_extension = get_bits(&gb, 1); + const int has_length_field = get_bits(&gb, 1); + if (!has_length_field) goto error; + get_bits(&gb, 1); // reserved + if (has_extension) { + get_bits(&gb, 3); // temporal_layer_id + get_bits(&gb, 2); // enhancement_layer_id + get_bits(&gb, 3); // reserved + } + + // obu length field + int len = 0, more, i = 0; + do { + more = get_bits(&gb, 1); + len |= get_bits(&gb, 7) << (i * 7); + if (more && ++i == 8) goto error; + } while (more); + if (gb.error) goto error; + + int off = flush_get_bits(&gb) - in->data; + const int init_off = off; + if (len > in->sz - off) goto error; + + switch (type) { + case OBU_SEQ_HDR: + if ((res = parse_seq_hdr(c, &gb)) < 0) + return res; + if (res != len) goto error; + c->have_seq_hdr = 1; + c->have_frame_hdr = 0; + break; + case OBU_FRAME: + case OBU_FRAME_HDR: + if (!c->have_seq_hdr) goto error; + if ((res = parse_frame_hdr(c, &gb, type == OBU_FRAME_HDR)) < 0) + return res; + c->have_frame_hdr = 1; + for (int n = 0; n < c->n_tile_data; n++) + dav1d_data_unref(&c->tile[n].data); + c->n_tile_data = 0; + c->tile_mask = 0; + if (type == OBU_FRAME_HDR) break; + off += res; + // fall-through + case OBU_TILE_GRP: + if (!c->have_frame_hdr) goto error; + if (c->n_tile_data >= 256) goto error; + if ((res = parse_tile_hdr(c, &gb)) < 0) + return res; + off += res; + dav1d_ref_inc(in->ref); + c->tile[c->n_tile_data].data.ref = in->ref; + c->tile[c->n_tile_data].data.data = in->data + off; + c->tile[c->n_tile_data].data.sz = len + init_off - off; + if (c->tile[c->n_tile_data].start > c->tile[c->n_tile_data].end) + goto error; +#define mask(a) ((1 << (a)) - 1) + const unsigned tile_mask = mask(c->tile[c->n_tile_data].end + 1) - + mask(c->tile[c->n_tile_data].start); +#undef mask + if (tile_mask & c->tile_mask) goto error; // tile overlap + c->tile_mask |= tile_mask; + c->n_tile_data++; + break; + case OBU_PADDING: + case OBU_TD: + case OBU_METADATA: + // ignore OBUs we don't care about + break; + default: + fprintf(stderr, "Unknown OBU type %d of size %d\n", type, len); + return -EINVAL; + } + + const int n_tiles = 1 << (c->frame_hdr.tiling.log2_cols + + c->frame_hdr.tiling.log2_rows); + if (c->have_seq_hdr && c->have_frame_hdr && + c->tile_mask == (1 << n_tiles) - 1) + { + assert(c->n_tile_data); + submit_frame(c); + assert(!c->n_tile_data); + c->have_frame_hdr = 0; + c->tile_mask = 0; + } else if (c->have_seq_hdr && c->have_frame_hdr && + c->frame_hdr.show_existing_frame) + { + if (c->n_fc == 1) { + dav1d_picture_ref(&c->out, + &c->refs[c->frame_hdr.existing_frame_idx].p.p); + } else { + // need to append this to the frame output queue + const unsigned next = c->frame_thread.next++; + if (c->frame_thread.next == c->n_fc) + c->frame_thread.next = 0; + + Dav1dFrameContext *const f = &c->fc[next]; + pthread_mutex_lock(&f->frame_thread.td.lock); + while (f->n_tile_data > 0) + pthread_cond_wait(&f->frame_thread.td.cond, + &f->frame_thread.td.lock); + Dav1dThreadPicture *const out_delayed = + &c->frame_thread.out_delayed[next]; + if (out_delayed->p.data[0]) { + if (out_delayed->visible) + dav1d_picture_ref(&c->out, &out_delayed->p); + dav1d_thread_picture_unref(out_delayed); + } + dav1d_thread_picture_ref(out_delayed, + &c->refs[c->frame_hdr.existing_frame_idx].p); + out_delayed->visible = 1; + pthread_mutex_unlock(&f->frame_thread.td.lock); + } + c->have_frame_hdr = 0; + } + + return len + init_off; + +error: + fprintf(stderr, "Error parsing OBU data\n"); + return -EINVAL; +} diff --git a/src/obu.h b/src/obu.h new file mode 100644 index 0000000..df476fc --- /dev/null +++ b/src/obu.h @@ -0,0 +1,36 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_SRC_OBU_H__ +#define __DAV1D_SRC_OBU_H__ + +#include "dav1d/data.h" +#include "src/internal.h" + +int parse_obus(Dav1dContext *c, Dav1dData *in); + +#endif /* __DAV1D_SRC_OBU_H__ */ diff --git a/src/picture.c b/src/picture.c new file mode 100644 index 0000000..dccfd40 --- /dev/null +++ b/src/picture.c @@ -0,0 +1,187 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <assert.h> +#include <errno.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "common/intops.h" +#include "common/mem.h" +#include "common/validate.h" + +#include "src/picture.h" +#include "src/ref.h" + +static int picture_alloc_with_edges(Dav1dPicture *const p, + const int w, const int h, + const enum Dav1dPixelLayout layout, + const int bpc, + const int extra, void **const extra_ptr) +{ + int aligned_h; + + if (p->data[0]) { + fprintf(stderr, "Picture already allocated!\n"); + return -1; + } + assert(bpc > 0 && bpc <= 16); + + const int hbd = bpc > 8; + const int aligned_w = (w + 127) & ~127; + const int has_chroma = layout != DAV1D_PIXEL_LAYOUT_I400; + const int ss_ver = layout == DAV1D_PIXEL_LAYOUT_I420; + const int ss_hor = layout != DAV1D_PIXEL_LAYOUT_I444; + p->stride[0] = aligned_w << hbd; + p->stride[1] = has_chroma ? (aligned_w >> ss_hor) << hbd : 0; + p->p.w = w; + p->p.h = h; + p->p.pri = DAV1D_COLOR_PRI_UNKNOWN; + p->p.trc = DAV1D_TRC_UNKNOWN; + p->p.mtrx = DAV1D_MC_UNKNOWN; + p->p.chr = DAV1D_CHR_UNKNOWN; + aligned_h = (h + 127) & ~127; + p->p.layout = layout; + p->p.bpc = bpc; + const size_t y_sz = p->stride[0] * aligned_h; + const size_t uv_sz = p->stride[1] * (aligned_h >> ss_ver); + if (!(p->ref = dav1d_ref_create(y_sz + 2 * uv_sz + extra))) { + fprintf(stderr, "Failed to allocate memory of size %zu: %s\n", + y_sz + 2 * uv_sz + extra, strerror(errno)); + return -ENOMEM; + } + uint8_t *data = p->ref->data; + p->data[0] = data; + p->data[1] = has_chroma ? data + y_sz : NULL; + p->data[2] = has_chroma ? data + y_sz + uv_sz : NULL; + + if (extra) + *extra_ptr = &data[y_sz + uv_sz * 2]; + + return 0; +} + +int dav1d_thread_picture_alloc(Dav1dThreadPicture *const p, + const int w, const int h, + const enum Dav1dPixelLayout layout, const int bpc, + struct thread_data *const t, const int visible) +{ + p->t = t; + + const int res = + picture_alloc_with_edges(&p->p, w, h, layout, bpc, + t != NULL ? sizeof(atomic_int) * 2 : 0, + (void **) &p->progress); + + p->visible = visible; + if (t) { + atomic_init(&p->progress[0], 0); + atomic_init(&p->progress[1], 0); + } + return res; +} + +void dav1d_picture_ref(Dav1dPicture *const dst, const Dav1dPicture *const src) { + validate_input(dst != NULL); + validate_input(dst->data[0] == NULL); + validate_input(src != NULL); + + if (src->ref) { + validate_input(src->data[0] != NULL); + dav1d_ref_inc(src->ref); + } + *dst = *src; +} + +void dav1d_thread_picture_ref(Dav1dThreadPicture *dst, + const Dav1dThreadPicture *src) +{ + dav1d_picture_ref(&dst->p, &src->p); + dst->t = src->t; + dst->visible = src->visible; + dst->progress = src->progress; +} + +void dav1d_picture_unref(Dav1dPicture *const p) { + validate_input(p != NULL); + + if (p->ref) { + validate_input(p->data[0] != NULL); + dav1d_ref_dec(p->ref); + } + memset(p, 0, sizeof(*p)); +} + +void dav1d_thread_picture_unref(Dav1dThreadPicture *const p) { + dav1d_picture_unref(&p->p); + + p->t = NULL; + p->progress = NULL; +} + +void dav1d_thread_picture_wait(const Dav1dThreadPicture *const p, + int y_unclipped, const enum PlaneType plane_type) +{ + assert(plane_type != PLANE_TYPE_ALL); + + if (!p->t) + return; + + // convert to luma units; include plane delay from loopfilters; clip + const int ss_ver = p->p.p.layout != DAV1D_PIXEL_LAYOUT_I444; + y_unclipped <<= plane_type & ss_ver; // we rely here on PLANE_TYPE_UV being 1 + y_unclipped += (plane_type != PLANE_TYPE_BLOCK) * 8; // delay imposed by loopfilter + const int y = iclip(y_unclipped, 0, p->p.p.h - 1); + atomic_uint *const progress = &p->progress[plane_type != PLANE_TYPE_BLOCK]; + + if (atomic_load_explicit(progress, memory_order_acquire) >= y) + return; + + pthread_mutex_lock(&p->t->lock); + while (atomic_load_explicit(progress, memory_order_relaxed) < y) + pthread_cond_wait(&p->t->cond, &p->t->lock); + pthread_mutex_unlock(&p->t->lock); +} + +void dav1d_thread_picture_signal(const Dav1dThreadPicture *const p, + const int y, // in pixel units + const enum PlaneType plane_type) +{ + assert(plane_type != PLANE_TYPE_UV); + + if (!p->t) + return; + + pthread_mutex_lock(&p->t->lock); + if (plane_type != PLANE_TYPE_Y) atomic_store(&p->progress[0], y); + if (plane_type != PLANE_TYPE_BLOCK) atomic_store(&p->progress[1], y); + pthread_cond_broadcast(&p->t->cond); + pthread_mutex_unlock(&p->t->lock); +} diff --git a/src/picture.h b/src/picture.h new file mode 100644 index 0000000..051d4cf --- /dev/null +++ b/src/picture.h @@ -0,0 +1,91 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_SRC_PICTURE_H__ +#define __DAV1D_SRC_PICTURE_H__ + +#include <pthread.h> +#include <stdatomic.h> + +#include "dav1d/picture.h" + +#include "src/thread_data.h" + +enum PlaneType { + PLANE_TYPE_Y, + PLANE_TYPE_UV, + PLANE_TYPE_BLOCK, + PLANE_TYPE_ALL, +}; + +typedef struct Dav1dThreadPicture { + Dav1dPicture p; + int visible; + struct thread_data *t; + // [0] block data (including segmentation map and motion vectors) + // [1] pixel data + atomic_uint *progress; +} Dav1dThreadPicture; + +/* + * Allocate a picture with custom border size. + */ +int dav1d_thread_picture_alloc(Dav1dThreadPicture *p, int w, int h, + enum Dav1dPixelLayout layout, int bpc, + struct thread_data *t, int visible); + +/** + * Create a copy of a picture. + */ +void dav1d_picture_ref(Dav1dPicture *dst, const Dav1dPicture *src); +void dav1d_thread_picture_ref(Dav1dThreadPicture *dst, + const Dav1dThreadPicture *src); +void dav1d_thread_picture_unref(Dav1dThreadPicture *p); + +/** + * Wait for picture to reach a certain stage. + * + * y is in full-pixel units. If pt is not UV, this is in luma + * units, else it is in chroma units. + * plane_type is used to determine how many pixels delay are + * introduced by loopfilter processes. + */ +void dav1d_thread_picture_wait(const Dav1dThreadPicture *p, int y, + enum PlaneType plane_type); + +/** + * Signal decoding progress. + * + * y is in full-pixel luma units. + * plane_type denotes whether we have completed block data (pass 1; + * PLANE_TYPE_BLOCK), pixel data (pass 2, PLANE_TYPE_Y) or both (no + * 2-pass decoding; PLANE_TYPE_ALL). + */ +void dav1d_thread_picture_signal(const Dav1dThreadPicture *p, int y, + enum PlaneType plane_type); + +#endif /* __DAV1D_SRC_PICTURE_H__ */ diff --git a/src/qm.c b/src/qm.c new file mode 100644 index 0000000..51e129c --- /dev/null +++ b/src/qm.c @@ -0,0 +1,3152 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <string.h> + +#include "src/qm.h" + +static const uint8_t qm_tbl_4x4_t[][2][10] = { + { + { + 32, + 43, 67, + 73, 94, 137, + 97, 110, 150, 200, + }, { + 35, + 46, 60, + 57, 69, 90, + 66, 71, 90, 109, + }, + }, { + { + 32, + 41, 63, + 69, 88, 127, + 92, 103, 140, 184, + }, { + 33, + 45, 58, + 56, 66, 86, + 64, 69, 87, 105, + }, + }, { + { + 32, + 38, 56, + 63, 78, 113, + 86, 97, 130, 169, + }, { + 32, + 45, 55, + 53, 62, 80, + 63, 67, 84, 101, + }, + }, { + { + 32, + 37, 54, + 58, 72, 102, + 81, 91, 121, 156, + }, { + 32, + 45, 54, + 51, 59, 75, + 61, 65, 81, 97, + }, + }, { + { + 32, + 34, 49, + 53, 64, 91, + 75, 81, 112, 140, + }, { + 32, + 46, 53, + 49, 55, 70, + 58, 62, 78, 91, + }, + }, { + { + 32, + 34, 48, + 49, 60, 82, + 72, 79, 104, 134, + }, { + 32, + 46, 53, + 47, 54, 66, + 57, 60, 75, 89, + }, + }, { + { + 32, + 33, 39, + 45, 51, 71, + 62, 64, 87, 108, + }, { + 31, + 42, 48, + 47, 50, 61, + 53, 54, 67, 78, + }, + }, { + { + 32, + 33, 38, + 42, 46, 63, + 55, 57, 75, 92, + }, { + 31, + 41, 48, + 46, 48, 58, + 51, 51, 62, 71, + }, + }, { + { + 32, + 32, 35, + 38, 40, 54, + 51, 49, 64, 81, + }, { + 31, + 38, 47, + 47, 46, 54, + 49, 46, 57, 66, + }, + }, { + { + 32, + 32, 34, + 35, 37, 48, + 43, 43, 54, 65, + }, { + 31, + 37, 44, + 47, 47, 53, + 47, 45, 53, 59, + }, + }, { + { + 32, + 32, 33, + 34, 35, 39, + 38, 39, 45, 54, + }, { + 31, + 34, 39, + 42, 45, 48, + 47, 46, 49, 54, + }, + }, { + { + 32, + 32, 32, + 32, 33, 35, + 35, 35, 38, 46, + }, { + 31, + 32, 34, + 38, 41, 47, + 46, 46, 47, 52, + }, + }, { + { + 31, + 32, 32, + 32, 32, 33, + 32, 33, 34, 35, + }, { + 31, + 31, 32, + 34, 35, 39, + 38, 40, 43, 47, + }, + }, { + { + 31, + 31, 32, + 31, 32, 32, + 32, 32, 32, 33, + }, { + 31, + 31, 31, + 31, 31, 32, + 34, 35, 35, 39, + }, + }, { + { + 31, + 31, 32, + 31, 32, 32, + 31, 32, 32, 32, + }, { + 31, + 31, 31, + 31, 31, 31, + 31, 31, 31, 31, + }, + }, +}; + +static const uint8_t qm_tbl_8x4[][2][32] = { + { + { + 32, 33, 37, 49, 65, 80, 91, 104, + 42, 42, 58, 71, 84, 97, 100, 112, + 75, 69, 84, 103, 125, 142, 145, 146, + 91, 86, 91, 110, 128, 152, 178, 190, + }, { + 31, 40, 46, 48, 54, 61, 64, 68, + 47, 45, 56, 61, 65, 69, 68, 71, + 60, 54, 64, 75, 85, 92, 90, 87, + 66, 61, 64, 73, 82, 92, 102, 105, + }, + }, { + { + 32, 33, 36, 46, 60, 75, 86, 98, + 42, 42, 56, 67, 79, 92, 95, 105, + 69, 64, 77, 93, 112, 130, 136, 136, + 88, 83, 88, 105, 122, 144, 167, 177, + }, { + 31, 40, 46, 47, 52, 59, 63, 66, + 47, 45, 55, 60, 64, 68, 66, 69, + 57, 52, 61, 70, 79, 87, 88, 85, + 65, 61, 63, 72, 81, 90, 99, 102, + }, + }, { + { + 32, 32, 34, 44, 54, 72, 82, 92, + 38, 40, 51, 61, 69, 84, 89, 98, + 62, 58, 68, 85, 98, 118, 129, 127, + 86, 80, 85, 101, 117, 136, 157, 165, + }, { + 31, 38, 46, 46, 50, 57, 61, 65, + 47, 46, 53, 56, 59, 64, 65, 67, + 54, 50, 57, 66, 74, 82, 85, 82, + 64, 60, 62, 71, 79, 88, 97, 99, + }, + }, { + { + 32, 32, 34, 41, 51, 65, 75, 86, + 35, 36, 47, 53, 61, 73, 81, 92, + 59, 57, 65, 78, 92, 108, 117, 119, + 83, 78, 82, 97, 111, 129, 148, 154, + }, { + 31, 36, 46, 45, 49, 54, 59, 63, + 47, 47, 52, 53, 55, 58, 61, 65, + 53, 50, 55, 63, 71, 77, 81, 80, + 63, 59, 61, 70, 77, 86, 94, 95, + }, + }, { + { + 32, 32, 34, 38, 48, 60, 72, 81, + 35, 36, 42, 51, 59, 68, 79, 86, + 51, 50, 54, 67, 80, 92, 104, 112, + 77, 72, 75, 87, 103, 119, 135, 144, + }, { + 31, 36, 43, 45, 47, 52, 57, 61, + 47, 47, 50, 53, 54, 56, 60, 63, + 50, 47, 50, 58, 66, 70, 75, 77, + 61, 57, 58, 65, 74, 82, 90, 93, + }, + }, { + { + 32, 32, 34, 37, 45, 54, 65, 75, + 35, 36, 42, 50, 56, 63, 73, 81, + 51, 50, 54, 65, 76, 87, 97, 106, + 75, 71, 73, 84, 96, 110, 125, 136, + }, { + 31, 36, 43, 46, 46, 50, 54, 59, + 47, 47, 50, 53, 54, 55, 58, 61, + 50, 47, 50, 57, 64, 68, 72, 75, + 60, 56, 57, 64, 71, 78, 85, 90, + }, + }, { + { + 32, 32, 33, 35, 41, 49, 57, 66, + 34, 34, 37, 43, 48, 54, 60, 68, + 43, 42, 44, 54, 64, 71, 78, 86, + 62, 59, 58, 68, 79, 91, 101, 111, + }, { + 31, 33, 40, 47, 45, 48, 51, 55, + 42, 44, 47, 50, 49, 50, 52, 55, + 47, 45, 46, 54, 59, 61, 63, 66, + 54, 51, 50, 57, 64, 70, 75, 79, + }, + }, { + { + 32, 32, 32, 34, 38, 44, 50, 61, + 32, 33, 35, 37, 40, 45, 50, 58, + 42, 41, 42, 50, 58, 66, 71, 79, + 56, 53, 52, 59, 68, 78, 86, 97, + }, { + 31, 32, 39, 44, 46, 47, 48, 53, + 38, 40, 47, 47, 47, 46, 47, 50, + 47, 45, 45, 51, 56, 59, 61, 64, + 52, 49, 48, 53, 58, 64, 68, 73, + }, + }, { + { + 32, 32, 32, 34, 35, 40, 46, 52, + 32, 33, 34, 37, 38, 42, 46, 51, + 37, 36, 38, 44, 49, 55, 59, 64, + 52, 49, 49, 54, 60, 69, 76, 83, + }, { + 31, 31, 36, 42, 47, 46, 48, 50, + 38, 40, 44, 47, 48, 46, 46, 48, + 47, 46, 47, 50, 53, 54, 55, 56, + 50, 48, 47, 50, 54, 60, 64, 67, + }, + }, { + { + 31, 32, 32, 32, 34, 37, 42, 46, + 32, 33, 34, 35, 37, 40, 43, 46, + 35, 34, 36, 38, 43, 49, 53, 56, + 43, 41, 42, 42, 49, 56, 63, 67, + }, { + 31, 31, 35, 39, 43, 47, 46, 48, + 38, 40, 43, 47, 47, 47, 46, 46, + 47, 46, 47, 47, 50, 53, 53, 54, + 48, 45, 46, 45, 50, 55, 58, 59, + }, + }, { + { + 31, 32, 32, 32, 33, 34, 37, 40, + 32, 32, 33, 33, 34, 36, 38, 40, + 34, 34, 34, 36, 38, 41, 44, 46, + 39, 38, 38, 40, 42, 47, 52, 56, + }, { + 31, 31, 33, 36, 40, 45, 47, 47, + 34, 35, 37, 41, 44, 46, 47, 46, + 42, 42, 44, 46, 48, 49, 50, 49, + 48, 46, 46, 46, 48, 51, 54, 55, + }, + }, { + { + 31, 32, 32, 32, 32, 33, 34, 35, + 31, 32, 32, 32, 33, 33, 34, 34, + 32, 32, 33, 34, 35, 36, 37, 38, + 35, 35, 34, 36, 38, 40, 42, 48, + }, { + 31, 31, 31, 34, 37, 39, 42, 48, + 31, 31, 32, 36, 39, 41, 43, 46, + 37, 38, 40, 43, 46, 47, 47, 48, + 48, 47, 46, 47, 47, 48, 50, 53, + }, + }, { + { + 31, 31, 32, 32, 32, 32, 32, 33, + 31, 32, 32, 32, 32, 32, 33, 33, + 32, 32, 32, 32, 33, 34, 34, 35, + 32, 32, 32, 33, 34, 34, 35, 36, + }, { + 31, 31, 31, 31, 34, 35, 38, 41, + 31, 31, 32, 32, 36, 37, 40, 42, + 35, 36, 37, 37, 40, 42, 45, 45, + 37, 38, 39, 40, 43, 44, 47, 47, + }, + }, { + { + 31, 31, 31, 31, 31, 31, 32, 32, + 31, 32, 32, 32, 32, 32, 32, 32, + 31, 32, 32, 32, 32, 32, 32, 32, + 32, 32, 32, 32, 32, 33, 33, 33, + }, { + 31, 31, 31, 31, 31, 31, 34, 34, + 31, 31, 31, 32, 32, 33, 36, 36, + 31, 31, 31, 32, 32, 33, 36, 36, + 34, 35, 35, 36, 36, 37, 40, 40, + }, + }, { + { + 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 32, 32, 32, 32, 32, 32, + 31, 31, 32, 32, 32, 32, 32, 32, + 31, 31, 32, 32, 32, 32, 32, 32, + }, { + 31, 31, 31, 31, 31, 31, 31, 30, + 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 32, 32, + 31, 31, 31, 31, 31, 31, 32, 32, + }, + }, +}; + +static const uint8_t qm_tbl_8x8_t[][2][36] = { + { + { + 32, + 32, 35, + 38, 40, 54, + 51, 49, 65, 82, + 68, 63, 78, 97, 117, + 84, 76, 91, 111, 134, 152, + 95, 89, 98, 113, 138, 159, 183, + 109, 102, 106, 121, 142, 168, 199, 220, + }, { + 31, + 38, 47, + 47, 46, 54, + 50, 47, 57, 66, + 57, 52, 61, 72, 82, + 63, 57, 66, 77, 88, 96, + 67, 62, 67, 75, 86, 95, 104, + 71, 67, 68, 75, 84, 95, 107, 113, + }, + }, { + { + 32, + 32, 35, + 37, 39, 51, + 47, 46, 60, 73, + 62, 58, 71, 87, 105, + 78, 72, 84, 100, 121, 140, + 90, 84, 93, 106, 129, 148, 169, + 102, 96, 100, 113, 132, 155, 183, 201, + }, { + 31, + 38, 47, + 47, 47, 53, + 48, 46, 55, 62, + 54, 50, 58, 67, 76, + 61, 55, 63, 72, 83, 91, + 66, 61, 65, 73, 84, 92, 101, + 69, 65, 66, 73, 82, 92, 103, 109, + }, + }, { + { + 32, + 32, 34, + 35, 37, 48, + 46, 45, 56, 70, + 57, 54, 64, 80, 93, + 76, 70, 79, 96, 111, 134, + 85, 79, 87, 100, 121, 138, 156, + 96, 90, 93, 105, 122, 144, 168, 184, + }, { + 31, + 36, 43, + 47, 47, 53, + 48, 46, 54, 61, + 52, 49, 55, 65, 71, + 60, 55, 60, 70, 78, 89, + 64, 59, 63, 71, 81, 89, 97, + 67, 63, 64, 71, 79, 89, 99, 104, + }, + }, { + { + 32, + 32, 33, + 35, 36, 46, + 42, 42, 52, 63, + 53, 51, 60, 73, 86, + 68, 64, 72, 84, 100, 117, + 78, 74, 80, 92, 109, 128, 140, + 90, 84, 87, 98, 114, 133, 155, 168, + }, { + 31, + 34, 39, + 46, 47, 52, + 47, 45, 52, 58, + 50, 48, 54, 62, 68, + 57, 53, 58, 65, 73, 82, + 61, 57, 61, 68, 77, 86, 91, + 65, 61, 62, 68, 76, 86, 95, 100, + }, + }, { + { + 32, + 32, 33, + 34, 35, 39, + 39, 40, 46, 56, + 50, 48, 53, 65, 78, + 62, 59, 63, 75, 90, 105, + 76, 71, 74, 86, 101, 118, 134, + 84, 79, 81, 92, 106, 123, 142, 153, + }, { + 31, + 34, 39, + 42, 45, 48, + 47, 46, 49, 55, + 49, 47, 50, 58, 65, + 54, 51, 53, 61, 69, 76, + 60, 56, 57, 65, 73, 82, 89, + 64, 59, 60, 66, 74, 83, 92, 96, + }, + }, { + { + 32, + 32, 33, + 34, 35, 39, + 38, 39, 45, 54, + 46, 45, 51, 61, 71, + 56, 54, 58, 69, 80, 92, + 68, 64, 68, 78, 90, 103, 117, + 78, 74, 76, 86, 99, 113, 128, 140, + }, { + 31, + 34, 39, + 42, 45, 48, + 47, 46, 49, 54, + 48, 46, 50, 56, 61, + 52, 49, 52, 58, 65, 71, + 57, 53, 55, 61, 68, 75, 82, + 61, 57, 58, 64, 71, 79, 86, 91, + }, + }, { + { + 31, + 32, 32, + 32, 33, 35, + 35, 35, 38, 48, + 42, 41, 43, 54, 63, + 51, 49, 49, 59, 71, 81, + 59, 56, 56, 66, 77, 89, 98, + 69, 65, 64, 73, 85, 97, 108, 119, + }, { + 31, + 32, 35, + 38, 42, 47, + 48, 47, 48, 53, + 47, 45, 45, 53, 58, + 50, 47, 47, 54, 61, 66, + 53, 50, 49, 56, 63, 69, 73, + 57, 54, 52, 58, 65, 72, 77, 82, + }, + }, { + { + 31, + 32, 32, + 32, 32, 35, + 34, 34, 37, 42, + 38, 37, 40, 47, 54, + 46, 44, 45, 52, 60, 69, + 52, 49, 49, 56, 65, 75, 82, + 63, 59, 58, 65, 73, 84, 92, 105, + }, { + 31, + 31, 32, + 38, 40, 47, + 44, 44, 47, 50, + 47, 45, 46, 51, 54, + 48, 46, 46, 51, 56, 61, + 50, 47, 47, 52, 57, 63, 66, + 55, 52, 50, 54, 60, 66, 70, 76, + }, + }, { + { + 31, + 32, 32, + 32, 32, 34, + 34, 33, 35, 39, + 35, 34, 37, 42, 48, + 41, 40, 41, 47, 53, 60, + 47, 44, 45, 51, 57, 65, 71, + 53, 50, 51, 55, 61, 70, 77, 85, + }, { + 31, + 31, 32, + 35, 36, 41, + 42, 42, 45, 48, + 48, 46, 47, 50, 53, + 47, 45, 45, 49, 53, 57, + 49, 46, 46, 50, 54, 59, 61, + 51, 48, 48, 51, 54, 60, 64, 68, + }, + }, { + { + 31, + 31, 32, + 32, 32, 33, + 32, 32, 34, 35, + 34, 34, 35, 37, 41, + 37, 36, 38, 39, 45, 51, + 43, 41, 42, 42, 49, 56, 63, + 47, 44, 45, 46, 52, 59, 67, 71, + }, { + 31, + 31, 32, + 34, 35, 39, + 37, 40, 43, 47, + 43, 43, 45, 47, 49, + 48, 46, 46, 47, 50, 53, + 47, 45, 45, 45, 50, 55, 58, + 49, 46, 46, 46, 50, 55, 60, 61, + }, + }, { + { + 31, + 31, 32, + 32, 32, 32, + 32, 32, 33, 34, + 33, 33, 34, 35, 37, + 34, 34, 35, 36, 39, 43, + 37, 36, 37, 38, 41, 46, 51, + 41, 39, 40, 41, 44, 49, 54, 58, + }, { + 31, + 31, 31, + 32, 33, 35, + 35, 37, 39, 43, + 39, 41, 42, 45, 47, + 45, 44, 45, 47, 48, 50, + 48, 46, 46, 47, 48, 51, 53, + 48, 46, 45, 46, 47, 51, 54, 56, + }, + }, { + { + 31, + 31, 32, + 31, 32, 32, + 32, 32, 32, 33, + 32, 32, 32, 34, 35, + 32, 33, 33, 34, 35, 36, + 34, 34, 33, 35, 36, 38, 39, + 35, 35, 34, 36, 38, 40, 42, 48, + }, { + 31, + 31, 31, + 30, 31, 32, + 34, 34, 35, 39, + 36, 37, 39, 42, 46, + 39, 40, 41, 44, 47, 47, + 42, 42, 42, 45, 47, 48, 48, + 48, 47, 46, 47, 47, 49, 50, 53, + }, + }, { + { + 31, + 31, 32, + 31, 32, 32, + 31, 32, 32, 32, + 32, 32, 32, 32, 33, + 32, 32, 32, 32, 33, 34, + 32, 32, 32, 32, 34, 34, 35, + 33, 33, 33, 33, 35, 35, 36, 38, + }, { + 31, + 31, 31, + 31, 31, 31, + 30, 31, 31, 32, + 34, 34, 35, 35, 39, + 35, 35, 36, 36, 40, 41, + 37, 38, 39, 40, 43, 44, 47, + 40, 41, 41, 42, 44, 45, 47, 48, + }, + }, { + { + 31, + 31, 32, + 31, 32, 32, + 31, 32, 32, 32, + 31, 32, 32, 32, 32, + 31, 32, 32, 32, 32, 32, + 32, 32, 32, 32, 32, 32, 33, + 32, 32, 32, 32, 32, 32, 33, 33, + }, { + 31, + 31, 31, + 31, 31, 31, + 31, 31, 31, 31, + 30, 31, 31, 31, 32, + 31, 32, 32, 32, 32, 33, + 33, 34, 34, 35, 35, 36, 39, + 33, 34, 34, 35, 35, 36, 39, 39, + }, + }, { + { + 31, + 31, 31, + 31, 31, 31, + 31, 31, 32, 32, + 31, 31, 32, 32, 32, + 31, 31, 32, 32, 32, 32, + 31, 31, 32, 32, 32, 32, 32, + 31, 31, 32, 32, 32, 32, 32, 32, + }, { + 31, + 31, 31, + 31, 31, 31, + 31, 31, 31, 31, + 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, + 30, 31, 31, 31, 31, 31, 31, 31, + }, + }, +}; + +static const uint8_t qm_tbl_16x4[][2][64] = { + { + { + 31, 32, 32, 34, 34, 41, 45, 54, 60, 72, 75, 83, 88, 94, 101, 108, + 44, 41, 42, 48, 54, 63, 67, 75, 79, 90, 92, 100, 100, 101, 108, 115, + 79, 72, 71, 73, 78, 90, 96, 110, 118, 133, 136, 142, 140, 144, 141, 151, + 96, 90, 86, 83, 89, 95, 102, 111, 123, 135, 149, 160, 173, 180, 188, 197, + }, { + 31, 32, 36, 43, 46, 45, 46, 50, 52, 57, 59, 62, 63, 65, 67, 69, + 49, 45, 46, 49, 53, 58, 59, 62, 64, 67, 68, 71, 69, 68, 70, 72, + 63, 57, 56, 57, 60, 67, 71, 78, 82, 89, 90, 91, 89, 89, 86, 88, + 69, 65, 62, 60, 63, 66, 70, 74, 80, 85, 91, 96, 101, 103, 105, 107, + }, + }, { + { + 31, 32, 32, 33, 34, 37, 44, 49, 56, 65, 72, 78, 84, 89, 95, 101, + 44, 41, 42, 44, 54, 58, 66, 71, 77, 84, 90, 95, 95, 95, 101, 108, + 73, 67, 65, 66, 74, 79, 90, 99, 107, 119, 127, 133, 132, 136, 132, 141, + 93, 87, 83, 81, 86, 92, 98, 107, 117, 129, 141, 151, 163, 169, 175, 183, + }, { + 31, 32, 36, 41, 46, 46, 46, 48, 51, 54, 57, 60, 62, 64, 65, 67, + 49, 45, 46, 47, 53, 56, 59, 61, 63, 65, 67, 69, 67, 66, 68, 70, + 61, 55, 54, 54, 59, 62, 68, 73, 77, 82, 86, 88, 86, 87, 83, 86, + 69, 64, 61, 59, 62, 65, 68, 73, 78, 84, 89, 93, 98, 100, 102, 103, + }, + }, { + { + 31, 32, 32, 33, 34, 37, 41, 46, 53, 60, 65, 74, 79, 84, 89, 94, + 39, 38, 39, 40, 47, 54, 58, 62, 68, 73, 78, 85, 90, 90, 95, 101, + 65, 60, 59, 58, 65, 73, 79, 86, 97, 105, 111, 120, 125, 128, 124, 131, + 90, 84, 81, 78, 83, 89, 94, 102, 112, 123, 134, 143, 154, 158, 164, 170, + }, { + 31, 32, 36, 40, 44, 46, 45, 47, 49, 52, 54, 58, 60, 62, 64, 65, + 48, 46, 46, 46, 51, 54, 56, 57, 58, 60, 62, 64, 66, 64, 66, 68, + 57, 53, 51, 50, 54, 60, 64, 68, 73, 76, 79, 82, 84, 84, 81, 83, + 68, 63, 60, 58, 61, 64, 67, 71, 77, 82, 87, 91, 95, 97, 99, 100, + }, + }, { + { + 31, 32, 32, 33, 34, 34, 39, 44, 49, 54, 60, 68, 75, 79, 84, 88, + 36, 35, 36, 38, 42, 48, 51, 56, 60, 63, 68, 75, 81, 85, 89, 94, + 62, 58, 57, 56, 61, 66, 74, 82, 90, 95, 102, 110, 117, 120, 116, 123, + 88, 82, 79, 76, 81, 85, 91, 98, 107, 117, 127, 135, 145, 148, 153, 159, + }, { + 31, 32, 35, 40, 43, 46, 45, 46, 48, 50, 52, 56, 58, 60, 62, 63, + 48, 46, 47, 47, 50, 53, 53, 54, 54, 55, 56, 59, 61, 63, 64, 66, + 56, 52, 50, 49, 53, 56, 61, 65, 70, 72, 75, 79, 81, 82, 79, 81, + 67, 62, 60, 57, 60, 63, 66, 70, 75, 80, 85, 89, 93, 94, 96, 97, + }, + }, { + { + 31, 32, 32, 32, 33, 34, 37, 41, 45, 49, 54, 61, 68, 74, 78, 83, + 36, 35, 35, 37, 41, 48, 50, 53, 56, 60, 63, 69, 75, 80, 84, 88, + 53, 51, 49, 49, 53, 60, 65, 71, 76, 82, 87, 93, 100, 105, 109, 114, + 81, 76, 73, 71, 74, 80, 85, 91, 98, 105, 112, 121, 130, 137, 142, 148, + }, { + 31, 31, 33, 38, 42, 46, 46, 45, 46, 48, 50, 52, 56, 58, 60, 62, + 48, 47, 46, 47, 49, 53, 53, 53, 54, 54, 55, 57, 59, 61, 62, 64, + 52, 49, 48, 47, 50, 54, 57, 61, 64, 66, 68, 71, 73, 75, 76, 78, + 64, 60, 57, 56, 57, 61, 64, 68, 71, 75, 78, 83, 87, 90, 92, 94, + }, + }, { + { + 31, 32, 32, 32, 33, 34, 34, 37, 41, 45, 49, 54, 60, 65, 72, 75, + 36, 35, 34, 36, 38, 42, 48, 50, 53, 56, 60, 63, 68, 73, 79, 81, + 53, 51, 49, 50, 49, 54, 60, 65, 71, 76, 82, 87, 92, 97, 104, 106, + 79, 75, 72, 71, 69, 73, 78, 84, 90, 96, 103, 110, 118, 125, 133, 136, + }, { + 31, 31, 32, 36, 40, 43, 46, 46, 45, 46, 48, 50, 52, 54, 57, 59, + 48, 47, 46, 47, 47, 50, 53, 53, 53, 54, 54, 55, 56, 58, 60, 61, + 52, 50, 48, 47, 47, 50, 54, 57, 61, 64, 66, 68, 70, 72, 75, 75, + 63, 60, 57, 56, 54, 57, 60, 64, 67, 71, 75, 78, 82, 85, 89, 90, + }, + }, { + { + 31, 32, 32, 32, 32, 34, 34, 36, 39, 42, 45, 50, 54, 60, 66, 73, + 34, 34, 33, 35, 37, 39, 42, 44, 46, 48, 51, 54, 58, 63, 68, 74, + 44, 43, 41, 43, 43, 48, 53, 57, 60, 64, 67, 72, 76, 80, 85, 91, + 65, 62, 59, 59, 58, 63, 67, 71, 76, 81, 85, 92, 98, 105, 111, 118, + }, { + 31, 31, 32, 35, 40, 43, 46, 46, 46, 46, 47, 48, 50, 52, 55, 58, + 42, 42, 42, 45, 47, 48, 50, 50, 49, 49, 50, 50, 52, 53, 55, 58, + 49, 47, 45, 46, 46, 49, 53, 55, 57, 59, 60, 61, 63, 64, 66, 68, + 57, 54, 52, 51, 50, 53, 56, 58, 61, 64, 67, 71, 73, 76, 79, 82, + }, + }, { + { + 31, 32, 32, 32, 32, 32, 34, 35, 37, 39, 41, 45, 50, 54, 57, 61, + 32, 32, 33, 34, 34, 35, 37, 38, 40, 41, 43, 46, 50, 53, 56, 58, + 44, 42, 41, 42, 42, 42, 48, 54, 57, 60, 63, 67, 71, 74, 77, 79, + 58, 55, 53, 53, 53, 52, 57, 63, 67, 70, 74, 79, 86, 90, 93, 97, + }, { + 31, 31, 32, 34, 37, 39, 42, 47, 46, 46, 46, 47, 48, 50, 51, 53, + 37, 38, 40, 42, 44, 47, 47, 48, 47, 46, 46, 46, 47, 48, 49, 50, + 49, 47, 45, 45, 45, 45, 49, 53, 55, 57, 58, 59, 61, 62, 63, 64, + 54, 51, 49, 49, 48, 48, 51, 55, 58, 60, 62, 65, 68, 70, 71, 73, + }, + }, { + { + 31, 32, 32, 32, 32, 32, 33, 34, 35, 37, 38, 42, 45, 47, 51, 55, + 32, 32, 32, 33, 34, 35, 36, 37, 38, 40, 40, 43, 45, 47, 50, 54, + 38, 37, 36, 36, 38, 39, 41, 44, 49, 51, 52, 56, 58, 60, 63, 67, + 53, 51, 49, 49, 50, 49, 51, 54, 60, 63, 65, 71, 75, 77, 82, 87, + }, { + 31, 31, 31, 32, 35, 39, 40, 42, 47, 47, 46, 46, 47, 48, 49, 51, + 37, 38, 39, 40, 43, 47, 47, 47, 48, 47, 47, 46, 46, 47, 47, 49, + 48, 47, 46, 46, 46, 47, 48, 50, 53, 53, 54, 55, 55, 55, 56, 57, + 52, 50, 48, 48, 47, 47, 48, 50, 54, 56, 57, 61, 63, 64, 66, 68, + }, + }, { + { + 31, 32, 32, 32, 32, 32, 32, 33, 34, 35, 35, 38, 40, 42, 45, 46, + 32, 32, 32, 33, 34, 34, 35, 36, 37, 38, 38, 40, 41, 43, 45, 46, + 36, 35, 35, 34, 36, 36, 38, 40, 42, 47, 48, 50, 51, 53, 56, 56, + 44, 42, 41, 41, 42, 42, 42, 44, 48, 52, 54, 58, 60, 63, 66, 67, + }, { + 31, 31, 31, 31, 34, 35, 39, 40, 42, 46, 47, 47, 47, 46, 48, 48, + 37, 38, 39, 40, 42, 43, 47, 47, 47, 48, 48, 47, 46, 46, 46, 46, + 48, 47, 46, 46, 47, 47, 47, 48, 50, 52, 53, 53, 53, 53, 54, 54, + 49, 47, 46, 45, 45, 46, 45, 47, 49, 53, 53, 56, 57, 58, 59, 59, + }, + }, { + { + 31, 32, 32, 32, 32, 32, 32, 32, 32, 34, 34, 35, 35, 38, 38, 42, + 32, 32, 32, 32, 32, 33, 33, 34, 34, 35, 35, 36, 36, 39, 39, 42, + 34, 34, 34, 33, 33, 35, 35, 37, 37, 39, 39, 43, 43, 45, 45, 48, + 39, 38, 38, 37, 37, 39, 39, 40, 40, 45, 45, 51, 51, 54, 54, 58, + }, { + 31, 31, 31, 31, 31, 34, 34, 38, 38, 42, 42, 48, 48, 47, 47, 47, + 33, 34, 34, 35, 35, 39, 39, 43, 43, 45, 45, 47, 47, 46, 46, 45, + 42, 42, 42, 42, 42, 45, 45, 47, 47, 48, 48, 50, 50, 50, 50, 49, + 48, 47, 47, 45, 45, 46, 46, 46, 46, 50, 50, 53, 53, 54, 54, 56, + }, + }, { + { + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 34, 34, 35, 35, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 34, 34, 34, 34, + 32, 32, 32, 32, 33, 33, 34, 34, 34, 35, 35, 36, 37, 37, 38, 38, + 36, 35, 35, 35, 34, 34, 36, 36, 37, 38, 38, 41, 42, 44, 48, 48, + }, { + 31, 31, 31, 31, 31, 31, 34, 34, 36, 38, 38, 41, 42, 44, 48, 48, + 31, 31, 31, 32, 32, 32, 35, 36, 37, 40, 40, 42, 43, 44, 46, 46, + 37, 38, 38, 39, 40, 40, 42, 43, 44, 47, 47, 47, 47, 47, 48, 48, + 48, 47, 47, 46, 46, 46, 47, 47, 47, 47, 47, 49, 50, 51, 53, 53, + }, + }, { + { + 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 34, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 34, + 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 34, 34, 34, 35, 36, + 32, 32, 32, 32, 32, 33, 33, 33, 34, 34, 34, 35, 35, 35, 36, 37, + }, { + 31, 31, 31, 31, 31, 31, 31, 31, 33, 34, 34, 36, 38, 38, 39, 42, + 31, 31, 31, 31, 32, 32, 32, 33, 35, 36, 36, 38, 40, 40, 41, 43, + 35, 35, 36, 36, 36, 37, 37, 38, 40, 40, 40, 43, 45, 45, 45, 46, + 37, 38, 38, 38, 39, 40, 40, 40, 42, 43, 43, 45, 47, 47, 47, 47, + }, + }, { + { + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, + }, { + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 33, 34, 34, 34, + 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 33, 35, 36, 36, 36, + 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 33, 35, 36, 36, 36, + 34, 34, 35, 35, 35, 35, 36, 36, 36, 36, 36, 37, 39, 40, 40, 40, + }, + }, { + { + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + }, { + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 30, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, + }, + }, +}; + +static const uint8_t qm_tbl_16x8[][2][128] = { + { + { + 32, 31, 32, 34, 36, 44, 48, 58, 65, 79, 82, 91, 97, 103, 110, 118, + 32, 33, 34, 37, 38, 43, 46, 54, 58, 70, 72, 80, 86, 93, 100, 107, + 36, 34, 36, 42, 48, 53, 56, 63, 68, 79, 81, 88, 94, 98, 101, 105, + 53, 49, 50, 54, 60, 71, 76, 87, 92, 104, 106, 106, 107, 114, 117, 118, + 65, 59, 59, 63, 68, 79, 85, 98, 105, 118, 121, 130, 128, 131, 138, 136, + 87, 78, 77, 79, 84, 95, 102, 116, 124, 141, 144, 148, 157, 150, 161, 157, + 93, 86, 82, 80, 86, 94, 105, 112, 122, 135, 149, 162, 167, 174, 183, 182, + 99, 93, 89, 88, 90, 97, 105, 115, 124, 135, 146, 159, 171, 186, 193, 203, + }, { + 32, 30, 33, 42, 49, 49, 50, 54, 57, 63, 64, 68, 70, 72, 74, 76, + 37, 40, 43, 47, 48, 46, 46, 49, 50, 55, 56, 59, 62, 64, 67, 69, + 48, 46, 47, 50, 53, 53, 54, 55, 56, 60, 61, 64, 66, 66, 66, 67, + 52, 48, 47, 50, 54, 61, 64, 68, 70, 75, 75, 74, 73, 75, 74, 73, + 57, 52, 51, 53, 57, 64, 67, 73, 76, 82, 83, 86, 83, 83, 84, 82, + 66, 60, 59, 60, 62, 69, 73, 80, 84, 92, 93, 94, 96, 92, 94, 91, + 68, 63, 60, 59, 62, 66, 72, 76, 80, 87, 93, 98, 99, 101, 103, 101, + 71, 66, 63, 62, 62, 66, 70, 75, 79, 84, 89, 94, 98, 104, 106, 109, + }, + }, { + { + 32, 31, 32, 32, 36, 39, 47, 53, 61, 71, 79, 86, 92, 98, 104, 110, + 32, 32, 34, 35, 37, 40, 45, 50, 56, 64, 70, 76, 82, 88, 94, 100, + 36, 35, 36, 40, 48, 50, 56, 60, 65, 73, 79, 84, 89, 93, 95, 98, + 47, 44, 45, 47, 56, 60, 69, 75, 81, 89, 95, 100, 101, 108, 110, 111, + 65, 60, 59, 60, 68, 73, 84, 92, 100, 111, 118, 124, 121, 124, 129, 127, + 79, 72, 71, 71, 78, 84, 95, 103, 113, 125, 133, 140, 148, 141, 151, 147, + 90, 84, 80, 78, 83, 91, 101, 108, 116, 129, 142, 153, 157, 163, 171, 169, + 96, 90, 87, 85, 87, 94, 101, 110, 118, 129, 138, 150, 161, 174, 181, 188, + }, { + 32, 30, 33, 39, 49, 48, 50, 52, 55, 60, 63, 66, 68, 70, 72, 74, + 35, 38, 41, 46, 48, 46, 46, 47, 49, 53, 55, 58, 60, 62, 65, 67, + 48, 46, 47, 48, 53, 53, 54, 54, 56, 58, 60, 62, 64, 65, 65, 65, + 50, 46, 46, 47, 54, 56, 61, 63, 65, 68, 70, 72, 71, 73, 72, 71, + 57, 52, 51, 51, 57, 60, 66, 71, 74, 79, 82, 84, 81, 81, 82, 79, + 63, 58, 56, 55, 60, 64, 70, 75, 79, 85, 89, 91, 94, 89, 92, 89, + 68, 63, 60, 58, 61, 65, 71, 75, 79, 85, 91, 95, 97, 98, 100, 98, + 70, 65, 63, 61, 61, 65, 69, 74, 78, 82, 87, 91, 96, 101, 103, 105, + }, + }, { + { + 32, 31, 32, 32, 34, 39, 44, 49, 57, 65, 71, 81, 87, 92, 98, 103, + 32, 32, 33, 34, 36, 39, 42, 46, 53, 59, 64, 72, 77, 83, 88, 94, + 36, 35, 36, 38, 44, 50, 53, 57, 63, 68, 73, 80, 85, 88, 89, 92, + 44, 41, 42, 42, 50, 58, 63, 67, 74, 79, 84, 91, 96, 102, 103, 103, + 58, 54, 53, 52, 59, 68, 74, 81, 90, 97, 102, 110, 114, 117, 121, 119, + 79, 73, 71, 69, 75, 84, 90, 97, 108, 118, 125, 135, 140, 133, 141, 137, + 88, 81, 78, 76, 81, 88, 97, 104, 111, 123, 135, 145, 148, 153, 160, 158, + 93, 88, 84, 82, 84, 90, 97, 105, 113, 122, 131, 141, 151, 163, 169, 175, + }, { + 32, 31, 33, 37, 44, 48, 49, 51, 54, 57, 60, 64, 66, 68, 70, 72, + 34, 36, 40, 44, 46, 46, 45, 47, 49, 51, 53, 57, 59, 61, 63, 65, + 48, 46, 47, 47, 51, 53, 53, 54, 55, 56, 58, 61, 63, 63, 63, 63, + 49, 46, 46, 45, 51, 56, 58, 60, 62, 64, 65, 68, 69, 71, 70, 69, + 54, 50, 49, 48, 53, 58, 62, 65, 70, 73, 75, 78, 79, 79, 80, 77, + 63, 58, 56, 54, 59, 64, 67, 71, 77, 82, 85, 89, 91, 87, 89, 86, + 67, 62, 59, 57, 60, 64, 70, 73, 77, 83, 89, 93, 94, 96, 97, 95, + 69, 65, 62, 60, 61, 64, 68, 72, 76, 81, 85, 89, 93, 98, 100, 102, + }, + }, { + { + 32, 31, 31, 32, 34, 36, 41, 47, 53, 58, 65, 74, 82, 87, 92, 97, + 31, 32, 33, 34, 35, 36, 40, 44, 50, 54, 59, 67, 73, 78, 83, 88, + 35, 34, 35, 37, 41, 46, 49, 53, 57, 61, 66, 73, 79, 83, 84, 86, + 44, 41, 42, 42, 48, 54, 60, 66, 71, 75, 79, 86, 92, 96, 97, 97, + 53, 50, 49, 49, 54, 60, 67, 75, 82, 87, 92, 100, 105, 110, 114, 111, + 65, 61, 59, 58, 63, 68, 76, 84, 92, 98, 105, 113, 120, 125, 132, 128, + 82, 76, 73, 71, 76, 80, 88, 97, 106, 112, 120, 131, 139, 144, 150, 147, + 90, 85, 81, 79, 81, 87, 93, 101, 108, 116, 124, 134, 142, 153, 157, 163, + }, { + 32, 31, 33, 37, 42, 49, 48, 50, 52, 54, 57, 61, 64, 66, 68, 70, + 33, 34, 37, 43, 44, 47, 46, 46, 47, 49, 51, 55, 57, 59, 61, 63, + 45, 45, 46, 47, 49, 52, 51, 52, 53, 54, 55, 58, 60, 61, 61, 61, + 49, 46, 45, 45, 49, 53, 57, 59, 61, 62, 64, 66, 68, 69, 68, 67, + 52, 49, 47, 47, 50, 54, 59, 63, 66, 68, 70, 73, 75, 77, 77, 75, + 57, 53, 51, 50, 53, 57, 61, 66, 71, 73, 76, 80, 83, 84, 86, 83, + 64, 60, 57, 55, 58, 61, 66, 71, 75, 79, 83, 87, 91, 93, 94, 92, + 68, 64, 61, 59, 60, 63, 67, 71, 74, 79, 83, 87, 91, 95, 97, 98, + }, + }, { + { + 32, 31, 31, 32, 33, 36, 39, 44, 48, 53, 58, 66, 74, 81, 86, 91, + 31, 32, 32, 33, 34, 35, 38, 41, 45, 49, 54, 60, 67, 73, 78, 82, + 33, 33, 34, 36, 38, 42, 44, 46, 50, 53, 57, 63, 69, 75, 78, 80, + 40, 39, 38, 40, 44, 51, 54, 59, 62, 66, 70, 75, 81, 86, 90, 90, + 51, 49, 47, 48, 52, 58, 63, 69, 74, 79, 84, 90, 97, 102, 106, 103, + 65, 61, 59, 58, 62, 68, 73, 79, 85, 92, 98, 106, 113, 120, 124, 119, + 79, 74, 71, 69, 72, 78, 84, 90, 96, 103, 110, 119, 128, 135, 140, 137, + 87, 82, 79, 77, 78, 84, 89, 96, 103, 111, 118, 126, 134, 143, 147, 151, + }, { + 32, 31, 31, 35, 41, 49, 48, 49, 50, 52, 54, 57, 61, 64, 66, 68, + 32, 33, 35, 39, 43, 47, 46, 45, 46, 48, 50, 52, 55, 58, 59, 61, + 40, 41, 43, 46, 48, 50, 49, 48, 49, 50, 51, 53, 56, 58, 59, 59, + 49, 47, 46, 46, 49, 53, 54, 56, 57, 58, 59, 61, 63, 65, 66, 65, + 51, 49, 47, 47, 49, 54, 57, 61, 63, 65, 67, 69, 72, 73, 75, 72, + 57, 54, 51, 50, 52, 57, 60, 64, 67, 71, 73, 77, 80, 82, 84, 81, + 63, 59, 57, 55, 57, 60, 64, 67, 71, 75, 78, 82, 86, 89, 91, 89, + 67, 63, 60, 58, 59, 62, 65, 69, 73, 77, 81, 85, 88, 92, 94, 95, + }, + }, { + { + 32, 31, 31, 32, 32, 34, 36, 39, 44, 48, 53, 58, 65, 71, 79, 82, + 31, 32, 32, 32, 33, 34, 34, 37, 41, 45, 49, 54, 60, 65, 72, 75, + 32, 32, 33, 34, 35, 37, 38, 40, 43, 46, 50, 54, 58, 63, 70, 72, + 36, 35, 34, 36, 38, 42, 48, 50, 53, 56, 60, 63, 68, 73, 79, 81, + 44, 42, 41, 42, 42, 48, 54, 58, 63, 67, 71, 75, 79, 84, 90, 92, + 53, 51, 49, 50, 49, 54, 60, 65, 71, 76, 82, 87, 92, 97, 104, 106, + 65, 62, 59, 59, 58, 63, 68, 73, 79, 85, 92, 98, 105, 111, 118, 121, + 79, 75, 72, 71, 69, 73, 78, 84, 90, 96, 103, 110, 118, 125, 133, 136, + }, { + 32, 31, 30, 33, 37, 42, 49, 48, 49, 50, 52, 54, 57, 60, 63, 64, + 31, 31, 32, 36, 40, 43, 46, 46, 45, 46, 48, 50, 52, 54, 57, 59, + 37, 38, 40, 43, 47, 47, 48, 47, 46, 46, 47, 49, 50, 52, 55, 56, + 48, 47, 46, 47, 47, 50, 53, 53, 53, 54, 54, 55, 56, 58, 60, 61, + 49, 47, 45, 46, 45, 49, 53, 56, 58, 59, 61, 62, 64, 65, 67, 68, + 52, 50, 48, 47, 47, 50, 54, 57, 61, 64, 66, 68, 70, 72, 75, 75, + 57, 54, 52, 51, 50, 53, 57, 60, 64, 67, 71, 73, 76, 79, 82, 83, + 63, 60, 57, 56, 54, 57, 60, 64, 67, 71, 75, 78, 82, 85, 89, 90, + }, + }, { + { + 32, 31, 31, 32, 32, 34, 35, 38, 41, 44, 48, 53, 58, 65, 71, 79, + 31, 32, 32, 32, 33, 34, 34, 36, 39, 42, 45, 49, 54, 60, 65, 72, + 32, 32, 33, 34, 35, 37, 38, 40, 41, 43, 46, 50, 54, 58, 63, 70, + 36, 35, 34, 36, 38, 42, 47, 49, 51, 54, 56, 60, 63, 68, 73, 79, + 44, 42, 41, 42, 42, 48, 52, 56, 60, 64, 67, 71, 75, 79, 84, 90, + 53, 51, 49, 50, 49, 54, 59, 63, 67, 72, 76, 82, 87, 92, 97, 104, + 62, 59, 57, 57, 56, 61, 65, 69, 74, 79, 83, 90, 95, 102, 108, 115, + 73, 69, 66, 65, 64, 69, 73, 77, 81, 86, 91, 99, 105, 112, 119, 127, + }, { + 32, 31, 30, 33, 37, 42, 47, 48, 48, 49, 50, 52, 54, 57, 60, 63, + 31, 31, 32, 36, 40, 43, 46, 46, 45, 45, 46, 48, 50, 52, 54, 57, + 37, 38, 40, 43, 47, 47, 48, 47, 46, 46, 46, 47, 49, 50, 52, 55, + 48, 47, 46, 47, 47, 50, 52, 53, 53, 53, 54, 54, 55, 56, 58, 60, + 49, 47, 45, 46, 45, 49, 53, 55, 57, 58, 59, 61, 62, 64, 65, 67, + 52, 50, 48, 47, 47, 50, 53, 56, 59, 62, 64, 66, 68, 70, 72, 75, + 56, 53, 51, 50, 49, 53, 55, 58, 61, 64, 66, 70, 72, 75, 77, 80, + 61, 57, 55, 54, 52, 56, 58, 61, 63, 66, 69, 73, 76, 79, 82, 86, + }, + }, { + { + 32, 31, 31, 31, 32, 32, 34, 36, 38, 41, 44, 48, 53, 57, 61, 65, + 31, 32, 32, 32, 32, 33, 34, 34, 37, 39, 41, 45, 49, 53, 56, 60, + 32, 32, 33, 34, 34, 35, 37, 38, 40, 41, 43, 46, 50, 53, 56, 58, + 35, 35, 34, 35, 36, 37, 41, 46, 47, 49, 51, 54, 57, 60, 63, 66, + 39, 38, 37, 38, 39, 40, 44, 50, 52, 54, 57, 60, 64, 67, 69, 72, + 44, 42, 41, 42, 42, 42, 48, 54, 57, 60, 63, 67, 71, 74, 77, 79, + 53, 51, 49, 49, 49, 49, 54, 60, 64, 67, 71, 76, 82, 86, 89, 92, + 65, 62, 59, 59, 58, 58, 63, 68, 72, 76, 79, 85, 92, 97, 100, 105, + }, { + 32, 31, 30, 33, 35, 37, 42, 49, 48, 48, 49, 50, 52, 54, 55, 57, + 31, 31, 32, 35, 37, 40, 43, 46, 46, 45, 45, 46, 48, 49, 51, 52, + 37, 38, 40, 42, 44, 47, 47, 48, 47, 46, 46, 46, 47, 48, 49, 50, + 45, 45, 44, 46, 46, 47, 49, 52, 51, 51, 51, 52, 53, 54, 54, 55, + 48, 47, 45, 46, 46, 47, 50, 53, 54, 54, 55, 56, 57, 58, 58, 59, + 49, 47, 45, 45, 45, 45, 49, 53, 55, 57, 58, 59, 61, 62, 63, 64, + 52, 50, 48, 47, 47, 47, 50, 54, 57, 59, 61, 64, 66, 68, 69, 70, + 57, 54, 52, 51, 51, 50, 53, 57, 59, 61, 64, 67, 71, 73, 74, 76, + }, + }, { + { + 32, 31, 31, 31, 32, 32, 32, 34, 36, 38, 39, 44, 47, 49, 53, 58, + 31, 32, 32, 32, 32, 33, 33, 34, 34, 36, 37, 41, 44, 46, 49, 54, + 32, 32, 32, 33, 34, 35, 35, 36, 37, 39, 40, 42, 45, 47, 50, 54, + 32, 33, 33, 33, 34, 36, 36, 38, 40, 41, 42, 45, 47, 48, 51, 55, + 36, 35, 35, 35, 36, 38, 40, 42, 48, 49, 50, 53, 56, 57, 60, 63, + 44, 42, 41, 41, 42, 42, 44, 48, 54, 56, 58, 63, 66, 67, 71, 75, + 47, 45, 44, 44, 45, 45, 47, 50, 56, 58, 60, 66, 69, 71, 75, 79, + 53, 51, 49, 49, 50, 49, 51, 54, 60, 63, 65, 71, 75, 77, 82, 87, + }, { + 32, 31, 30, 31, 33, 37, 39, 42, 49, 48, 48, 49, 50, 51, 52, 54, + 31, 31, 32, 33, 36, 40, 41, 43, 46, 46, 46, 45, 46, 47, 48, 50, + 35, 37, 38, 38, 41, 45, 46, 46, 48, 47, 46, 45, 46, 47, 47, 49, + 38, 40, 40, 41, 44, 47, 47, 48, 49, 48, 48, 47, 48, 48, 48, 50, + 48, 47, 46, 46, 47, 47, 48, 50, 53, 53, 53, 53, 54, 54, 54, 55, + 49, 47, 45, 45, 46, 45, 47, 49, 53, 55, 56, 58, 59, 60, 61, 62, + 50, 48, 46, 46, 46, 46, 47, 50, 54, 55, 56, 59, 61, 61, 63, 65, + 52, 50, 48, 48, 47, 47, 48, 50, 54, 56, 57, 61, 63, 64, 66, 68, + }, + }, { + { + 32, 31, 31, 31, 31, 32, 32, 32, 34, 35, 36, 39, 41, 44, 47, 48, + 31, 32, 32, 32, 32, 32, 33, 33, 34, 34, 34, 37, 39, 41, 44, 45, + 31, 32, 32, 32, 33, 33, 34, 34, 35, 36, 36, 39, 40, 42, 44, 45, + 32, 32, 32, 33, 34, 34, 35, 36, 37, 38, 38, 40, 41, 43, 45, 46, + 35, 35, 34, 34, 35, 36, 37, 39, 41, 45, 46, 48, 49, 51, 53, 54, + 36, 35, 35, 34, 36, 36, 38, 40, 42, 47, 48, 50, 51, 53, 56, 56, + 44, 42, 41, 41, 42, 42, 42, 44, 48, 52, 54, 58, 60, 63, 66, 67, + 47, 45, 45, 44, 44, 45, 45, 47, 50, 55, 56, 60, 62, 66, 69, 70, + }, { + 32, 31, 31, 30, 33, 33, 37, 39, 42, 47, 49, 48, 48, 49, 50, 50, + 31, 31, 32, 32, 35, 36, 40, 41, 43, 46, 46, 46, 45, 45, 46, 46, + 33, 34, 34, 35, 37, 38, 43, 43, 44, 46, 47, 46, 46, 45, 46, 46, + 37, 38, 39, 40, 42, 43, 47, 47, 47, 48, 48, 47, 46, 46, 46, 46, + 45, 45, 45, 44, 46, 46, 47, 48, 49, 51, 52, 51, 51, 51, 52, 52, + 48, 47, 46, 46, 47, 47, 47, 48, 50, 52, 53, 53, 53, 53, 54, 54, + 49, 47, 46, 45, 45, 46, 45, 47, 49, 53, 53, 56, 57, 58, 59, 59, + 50, 48, 47, 46, 46, 46, 46, 47, 50, 53, 54, 56, 57, 59, 61, 61, + }, + }, { + { + 32, 31, 31, 31, 31, 32, 32, 32, 32, 34, 34, 36, 36, 39, 39, 44, + 31, 32, 32, 32, 32, 32, 32, 33, 33, 34, 34, 34, 34, 37, 37, 41, + 31, 32, 32, 32, 32, 32, 32, 33, 33, 34, 34, 34, 34, 37, 37, 41, + 32, 32, 32, 33, 33, 34, 34, 35, 35, 37, 37, 38, 38, 40, 40, 43, + 32, 32, 32, 33, 33, 34, 34, 35, 35, 37, 37, 38, 38, 40, 40, 43, + 36, 35, 35, 34, 34, 36, 36, 38, 38, 42, 42, 48, 48, 50, 50, 53, + 36, 35, 35, 34, 34, 36, 36, 38, 38, 42, 42, 48, 48, 50, 50, 53, + 44, 42, 42, 41, 41, 42, 42, 42, 42, 48, 48, 54, 54, 58, 58, 63, + }, { + 32, 31, 31, 30, 30, 33, 33, 37, 37, 42, 42, 49, 49, 48, 48, 49, + 31, 31, 31, 32, 32, 36, 36, 40, 40, 43, 43, 46, 46, 46, 46, 45, + 31, 31, 31, 32, 32, 36, 36, 40, 40, 43, 43, 46, 46, 46, 46, 45, + 37, 38, 38, 40, 40, 43, 43, 47, 47, 47, 47, 48, 48, 47, 47, 46, + 37, 38, 38, 40, 40, 43, 43, 47, 47, 47, 47, 48, 48, 47, 47, 46, + 48, 47, 47, 46, 46, 47, 47, 47, 47, 50, 50, 53, 53, 53, 53, 53, + 48, 47, 47, 46, 46, 47, 47, 47, 47, 50, 50, 53, 53, 53, 53, 53, + 49, 47, 47, 45, 45, 46, 46, 45, 45, 49, 49, 53, 53, 56, 56, 58, + }, + }, { + { + 32, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 33, 34, 34, 36, 36, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 34, 34, 35, 35, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 34, 34, 34, 34, + 31, 32, 32, 32, 32, 32, 33, 33, 33, 34, 34, 35, 35, 35, 36, 36, + 32, 32, 32, 32, 33, 33, 34, 34, 34, 35, 35, 36, 37, 37, 38, 38, + 32, 32, 32, 32, 33, 33, 34, 34, 34, 35, 35, 36, 37, 37, 38, 38, + 35, 35, 35, 34, 34, 34, 35, 36, 36, 37, 37, 40, 41, 43, 46, 46, + 36, 35, 35, 35, 34, 34, 36, 36, 37, 38, 38, 41, 42, 44, 48, 48, + }, { + 32, 31, 31, 31, 30, 30, 33, 33, 35, 37, 37, 41, 42, 44, 49, 49, + 31, 31, 31, 31, 32, 32, 34, 35, 37, 39, 39, 42, 42, 44, 47, 47, + 31, 31, 31, 32, 32, 32, 35, 36, 37, 40, 40, 42, 43, 44, 46, 46, + 33, 34, 34, 34, 35, 35, 37, 38, 40, 43, 43, 44, 44, 45, 47, 47, + 37, 38, 38, 39, 40, 40, 42, 43, 44, 47, 47, 47, 47, 47, 48, 48, + 37, 38, 38, 39, 40, 40, 42, 43, 44, 47, 47, 47, 47, 47, 48, 48, + 45, 45, 45, 45, 44, 44, 46, 46, 46, 47, 47, 49, 49, 50, 52, 52, + 48, 47, 47, 46, 46, 46, 47, 47, 47, 47, 47, 49, 50, 51, 53, 53, + }, + }, { + { + 32, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 34, + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 34, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 34, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 34, + 31, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 34, 34, 34, 35, + 32, 32, 32, 32, 32, 33, 33, 33, 34, 34, 34, 35, 35, 35, 36, 37, + 32, 32, 32, 32, 32, 33, 33, 33, 34, 34, 34, 35, 35, 35, 36, 37, + 32, 33, 33, 33, 33, 33, 33, 33, 34, 34, 34, 35, 36, 36, 36, 38, + }, { + 32, 31, 31, 31, 31, 30, 30, 31, 33, 33, 33, 35, 37, 37, 39, 42, + 31, 31, 31, 31, 31, 31, 31, 32, 34, 35, 35, 37, 39, 39, 40, 42, + 31, 31, 31, 31, 32, 32, 32, 33, 35, 36, 36, 38, 40, 40, 41, 43, + 31, 31, 31, 31, 32, 32, 32, 33, 35, 36, 36, 38, 40, 40, 41, 43, + 33, 33, 34, 34, 34, 35, 35, 35, 37, 38, 38, 41, 43, 43, 43, 44, + 37, 38, 38, 38, 39, 40, 40, 40, 42, 43, 43, 45, 47, 47, 47, 47, + 37, 38, 38, 38, 39, 40, 40, 40, 42, 43, 43, 45, 47, 47, 47, 47, + 38, 39, 40, 40, 40, 41, 41, 41, 43, 44, 44, 46, 47, 47, 47, 48, + }, + }, { + { + 32, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, + 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 34, 34, 34, + }, { + 32, 31, 31, 31, 31, 31, 31, 30, 30, 30, 30, 31, 33, 33, 33, 33, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 34, 34, 34, 34, + 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 33, 34, 35, 35, 35, + 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 33, 35, 36, 36, 36, + 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 33, 35, 36, 36, 36, + 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 33, 35, 36, 36, 36, + 33, 33, 34, 34, 34, 34, 34, 34, 35, 35, 35, 36, 37, 38, 38, 38, + 35, 36, 36, 37, 37, 37, 37, 38, 38, 38, 38, 39, 40, 41, 41, 41, + }, + }, { + { + 32, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + }, { + 32, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 30, 30, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, + }, + }, +}; + +static const uint8_t qm_tbl_32x8[][2][256] = { + { + { + 32, 31, 31, 31, 32, 32, 34, 35, 36, 39, 44, 46, 48, 53, 58, 61, 65, 71, 79, 81, 82, 88, 91, 94, 97, 100, 103, 107, 110, 114, 118, 122, + 32, 32, 33, 33, 34, 35, 37, 37, 38, 40, 43, 44, 46, 50, 54, 56, 58, 63, 70, 71, 72, 77, 80, 83, 86, 89, 93, 96, 100, 104, 107, 111, + 36, 35, 34, 35, 36, 38, 42, 45, 48, 50, 53, 55, 56, 60, 63, 66, 68, 73, 79, 80, 81, 85, 88, 91, 94, 97, 98, 100, 101, 103, 105, 107, + 53, 51, 49, 49, 50, 49, 54, 57, 60, 65, 71, 73, 76, 82, 87, 89, 92, 97, 104, 105, 106, 108, 106, 105, 107, 111, 114, 117, 117, 117, 118, 119, + 65, 62, 59, 59, 59, 58, 63, 65, 68, 73, 79, 82, 85, 92, 98, 101, 105, 111, 118, 119, 121, 126, 130, 131, 128, 127, 131, 136, 138, 137, 136, 136, + 87, 82, 78, 78, 77, 75, 79, 82, 84, 89, 95, 98, 102, 109, 116, 120, 124, 132, 141, 142, 144, 149, 148, 153, 157, 152, 150, 155, 161, 159, 157, 156, + 93, 88, 86, 84, 82, 82, 80, 84, 86, 91, 94, 98, 105, 107, 112, 119, 122, 130, 135, 140, 149, 153, 162, 165, 167, 173, 174, 177, 183, 185, 182, 179, + 99, 94, 93, 90, 89, 89, 88, 87, 90, 93, 97, 99, 105, 107, 115, 116, 124, 127, 135, 139, 146, 152, 159, 166, 171, 182, 186, 191, 193, 201, 203, 204, + }, { + 32, 31, 30, 32, 33, 37, 42, 45, 49, 48, 49, 49, 50, 52, 54, 55, 57, 60, 63, 64, 64, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 37, 38, 40, 41, 43, 47, 47, 47, 48, 47, 46, 46, 46, 47, 49, 49, 50, 52, 55, 55, 56, 58, 59, 60, 62, 63, 64, 65, 67, 68, 69, 70, + 48, 47, 46, 46, 47, 47, 50, 51, 53, 53, 53, 53, 54, 54, 55, 56, 56, 58, 60, 61, 61, 63, 64, 65, 66, 67, 66, 66, 66, 66, 67, 67, + 52, 50, 48, 48, 47, 47, 50, 52, 54, 57, 61, 62, 64, 66, 68, 69, 70, 72, 75, 75, 75, 76, 74, 72, 73, 74, 75, 75, 74, 74, 73, 73, + 57, 54, 52, 51, 51, 50, 53, 55, 57, 60, 64, 65, 67, 71, 73, 75, 76, 79, 82, 82, 83, 85, 86, 85, 83, 82, 83, 84, 84, 83, 82, 81, + 66, 63, 60, 59, 59, 57, 60, 61, 62, 66, 69, 71, 73, 77, 80, 82, 84, 88, 92, 92, 93, 95, 94, 95, 96, 93, 92, 93, 94, 93, 91, 90, + 68, 65, 63, 62, 60, 60, 59, 61, 62, 65, 66, 68, 72, 73, 76, 79, 80, 84, 87, 89, 93, 94, 98, 99, 99, 102, 101, 102, 103, 103, 101, 99, + 71, 67, 66, 64, 63, 62, 62, 61, 62, 64, 66, 67, 70, 71, 75, 76, 79, 81, 84, 86, 89, 91, 94, 97, 98, 102, 104, 106, 106, 109, 109, 108, + }, + }, { + { + 32, 31, 31, 31, 32, 32, 32, 34, 36, 38, 39, 44, 47, 49, 53, 58, 61, 65, 71, 76, 79, 82, 86, 89, 92, 95, 98, 101, 104, 107, 110, 114, + 32, 32, 32, 33, 34, 35, 35, 36, 37, 39, 40, 42, 45, 47, 50, 54, 56, 59, 64, 68, 70, 73, 76, 79, 82, 85, 88, 91, 94, 97, 100, 104, + 36, 35, 35, 35, 36, 38, 40, 42, 48, 49, 50, 53, 56, 57, 60, 63, 65, 68, 73, 76, 79, 81, 84, 87, 89, 92, 93, 94, 95, 96, 98, 100, + 47, 45, 44, 44, 45, 45, 47, 50, 56, 58, 60, 66, 69, 71, 75, 79, 81, 84, 89, 92, 95, 97, 100, 99, 101, 105, 108, 110, 110, 110, 111, 111, + 65, 62, 60, 59, 59, 58, 60, 63, 68, 71, 73, 79, 84, 86, 92, 98, 100, 105, 111, 115, 118, 121, 124, 124, 121, 120, 124, 128, 129, 128, 127, 127, + 79, 75, 72, 71, 71, 69, 71, 73, 78, 81, 84, 90, 95, 97, 103, 110, 113, 118, 125, 130, 133, 136, 140, 145, 148, 143, 141, 146, 151, 149, 147, 145, + 90, 86, 84, 82, 80, 80, 78, 82, 83, 88, 91, 94, 101, 103, 108, 114, 116, 124, 129, 134, 142, 145, 153, 156, 157, 163, 163, 166, 171, 173, 169, 166, + 96, 91, 90, 87, 87, 86, 85, 84, 87, 90, 94, 96, 101, 102, 110, 111, 118, 121, 129, 132, 138, 144, 150, 156, 161, 171, 174, 179, 181, 188, 188, 190, + }, { + 32, 31, 30, 31, 33, 37, 39, 42, 49, 48, 48, 49, 50, 51, 52, 54, 55, 57, 60, 62, 63, 64, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, + 35, 37, 38, 38, 41, 45, 46, 46, 48, 47, 46, 45, 46, 47, 47, 49, 49, 50, 53, 54, 55, 56, 58, 59, 60, 61, 62, 64, 65, 66, 67, 68, + 48, 47, 46, 46, 47, 47, 48, 50, 53, 53, 53, 53, 54, 54, 54, 55, 56, 56, 58, 60, 60, 61, 62, 63, 64, 65, 65, 65, 65, 65, 65, 65, + 50, 48, 46, 46, 46, 46, 47, 50, 54, 55, 56, 59, 61, 61, 63, 65, 65, 66, 68, 69, 70, 71, 72, 71, 71, 72, 73, 73, 72, 72, 71, 71, + 57, 54, 52, 52, 51, 50, 51, 53, 57, 58, 60, 64, 66, 68, 71, 73, 74, 76, 79, 81, 82, 83, 84, 83, 81, 80, 81, 82, 82, 81, 79, 78, + 63, 60, 58, 57, 56, 54, 55, 57, 60, 62, 64, 67, 70, 71, 75, 78, 79, 82, 85, 87, 89, 90, 91, 93, 94, 91, 89, 90, 92, 90, 89, 87, + 68, 64, 63, 61, 60, 59, 58, 60, 61, 64, 65, 67, 71, 72, 75, 78, 79, 83, 85, 87, 91, 92, 95, 96, 97, 99, 98, 99, 100, 100, 98, 96, + 70, 66, 65, 63, 63, 62, 61, 60, 61, 63, 65, 66, 69, 70, 74, 74, 78, 79, 82, 84, 87, 89, 91, 94, 96, 100, 101, 103, 103, 105, 105, 105, + }, + }, { + { + 32, 31, 31, 31, 32, 32, 32, 34, 34, 36, 39, 40, 44, 47, 49, 53, 57, 59, 65, 69, 71, 79, 81, 82, 87, 90, 92, 95, 98, 100, 103, 106, + 32, 32, 32, 32, 33, 34, 34, 35, 36, 37, 39, 40, 42, 45, 46, 50, 53, 54, 59, 62, 64, 71, 72, 73, 77, 80, 83, 85, 88, 91, 94, 97, + 36, 35, 35, 34, 36, 37, 38, 42, 44, 48, 50, 51, 53, 56, 57, 60, 63, 64, 68, 71, 73, 79, 80, 81, 85, 87, 88, 88, 89, 90, 92, 93, + 44, 42, 41, 41, 42, 42, 42, 48, 50, 54, 58, 59, 63, 66, 67, 71, 74, 75, 79, 83, 84, 90, 91, 92, 96, 99, 102, 103, 103, 103, 103, 104, + 58, 55, 54, 53, 53, 53, 52, 57, 59, 63, 68, 70, 74, 79, 81, 86, 90, 91, 97, 100, 102, 109, 110, 111, 114, 113, 117, 120, 121, 120, 119, 118, + 79, 75, 73, 72, 71, 70, 69, 73, 75, 78, 84, 85, 90, 95, 97, 103, 108, 111, 118, 122, 125, 133, 135, 136, 140, 135, 133, 137, 141, 139, 137, 135, + 88, 83, 81, 79, 78, 77, 76, 79, 81, 85, 88, 91, 97, 99, 104, 109, 111, 119, 123, 127, 135, 137, 145, 147, 148, 153, 153, 155, 160, 161, 158, 155, + 93, 88, 88, 84, 84, 83, 82, 81, 84, 86, 90, 92, 97, 98, 105, 106, 113, 115, 122, 125, 131, 136, 141, 147, 151, 160, 163, 168, 169, 175, 175, 176, + }, { + 32, 31, 31, 30, 33, 35, 37, 42, 44, 49, 48, 48, 49, 50, 51, 52, 54, 54, 57, 59, 60, 63, 64, 64, 66, 67, 68, 69, 70, 71, 72, 73, + 34, 35, 36, 36, 40, 42, 44, 45, 46, 47, 46, 46, 45, 46, 47, 47, 49, 49, 51, 52, 53, 56, 57, 57, 59, 60, 61, 62, 63, 64, 65, 66, + 48, 47, 46, 46, 47, 47, 47, 50, 51, 53, 53, 53, 53, 54, 54, 54, 55, 55, 56, 58, 58, 60, 61, 61, 63, 63, 63, 63, 63, 63, 63, 63, + 49, 47, 46, 45, 46, 45, 45, 49, 51, 53, 56, 56, 58, 59, 60, 61, 62, 62, 64, 65, 65, 67, 68, 68, 69, 70, 71, 71, 70, 70, 69, 69, + 54, 51, 50, 49, 49, 48, 48, 51, 53, 55, 58, 59, 62, 65, 65, 68, 70, 70, 73, 74, 75, 77, 78, 78, 79, 78, 79, 80, 80, 78, 77, 76, + 63, 60, 58, 57, 56, 55, 54, 57, 59, 60, 64, 65, 67, 70, 71, 75, 77, 78, 82, 84, 85, 89, 89, 90, 91, 88, 87, 88, 89, 88, 86, 84, + 67, 63, 62, 60, 59, 58, 57, 59, 60, 63, 64, 66, 70, 70, 73, 76, 77, 81, 83, 85, 89, 90, 93, 94, 94, 96, 96, 96, 97, 97, 95, 93, + 69, 65, 65, 62, 62, 61, 60, 59, 61, 62, 64, 65, 68, 68, 72, 73, 76, 77, 81, 82, 85, 87, 89, 92, 93, 97, 98, 100, 100, 102, 102, 101, + }, + }, { + { + 32, 31, 31, 31, 31, 32, 32, 32, 34, 35, 36, 39, 41, 44, 47, 48, 53, 55, 58, 63, 65, 71, 74, 79, 82, 82, 87, 89, 92, 94, 97, 99, + 31, 32, 32, 32, 33, 33, 34, 34, 35, 36, 36, 39, 40, 42, 44, 45, 50, 51, 54, 58, 59, 64, 67, 71, 73, 74, 78, 81, 83, 85, 88, 91, + 35, 35, 34, 34, 35, 36, 37, 39, 41, 45, 46, 48, 49, 51, 53, 54, 57, 59, 61, 65, 66, 71, 73, 77, 79, 79, 83, 83, 84, 85, 86, 87, + 44, 42, 41, 41, 42, 42, 42, 44, 48, 52, 54, 58, 60, 63, 66, 67, 71, 72, 75, 78, 79, 84, 86, 90, 92, 92, 96, 97, 97, 97, 97, 97, + 53, 51, 50, 49, 49, 50, 49, 51, 54, 59, 60, 65, 67, 71, 75, 76, 82, 84, 87, 91, 92, 97, 100, 104, 105, 106, 110, 113, 114, 112, 111, 110, + 65, 62, 61, 59, 59, 59, 58, 60, 63, 67, 68, 73, 76, 79, 84, 85, 92, 94, 98, 103, 105, 111, 113, 118, 120, 121, 125, 128, 132, 130, 128, 126, + 82, 78, 76, 74, 73, 73, 71, 73, 76, 79, 80, 86, 88, 92, 97, 98, 106, 108, 112, 118, 120, 127, 131, 136, 139, 139, 144, 145, 150, 151, 147, 144, + 90, 86, 85, 82, 81, 80, 79, 78, 81, 83, 87, 88, 93, 94, 101, 101, 108, 110, 116, 119, 124, 129, 134, 139, 142, 150, 153, 157, 157, 163, 163, 163, + }, { + 32, 31, 31, 30, 33, 33, 37, 39, 42, 47, 49, 48, 48, 49, 50, 50, 52, 53, 54, 56, 57, 60, 61, 63, 64, 64, 66, 67, 68, 69, 70, 70, + 33, 34, 34, 35, 37, 38, 43, 43, 44, 46, 47, 46, 46, 45, 46, 46, 47, 48, 49, 51, 51, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, + 45, 45, 45, 44, 46, 46, 47, 48, 49, 51, 52, 51, 51, 51, 52, 52, 53, 53, 54, 55, 55, 57, 58, 59, 60, 60, 61, 61, 61, 61, 61, 61, + 49, 47, 46, 45, 45, 46, 45, 47, 49, 53, 53, 56, 57, 58, 59, 59, 61, 61, 62, 63, 64, 65, 66, 67, 68, 68, 69, 69, 68, 68, 67, 67, + 52, 50, 49, 48, 47, 47, 47, 48, 50, 53, 54, 57, 59, 61, 63, 64, 66, 67, 68, 70, 70, 72, 73, 75, 75, 75, 77, 78, 77, 76, 75, 74, + 57, 54, 53, 52, 51, 51, 50, 51, 53, 56, 57, 60, 61, 64, 66, 67, 71, 72, 73, 76, 76, 79, 80, 82, 83, 83, 84, 85, 86, 85, 83, 82, + 64, 61, 60, 58, 57, 57, 55, 56, 58, 61, 61, 64, 66, 68, 71, 71, 75, 77, 79, 82, 83, 86, 87, 90, 91, 91, 93, 93, 94, 94, 92, 90, + 68, 64, 64, 61, 61, 60, 59, 58, 60, 61, 63, 64, 67, 67, 71, 71, 74, 75, 79, 80, 83, 85, 87, 89, 91, 94, 95, 97, 97, 99, 98, 98, + }, + }, { + { + 32, 31, 31, 31, 31, 32, 32, 32, 33, 34, 36, 36, 39, 40, 44, 46, 48, 52, 53, 58, 58, 65, 66, 71, 74, 79, 81, 82, 86, 88, 91, 93, + 31, 32, 32, 32, 32, 33, 33, 33, 34, 34, 35, 35, 38, 39, 41, 43, 45, 48, 49, 53, 54, 59, 60, 65, 67, 72, 73, 74, 78, 80, 82, 85, + 33, 33, 33, 33, 34, 35, 36, 36, 38, 39, 42, 42, 44, 45, 46, 48, 50, 52, 53, 57, 57, 62, 63, 67, 69, 73, 75, 75, 78, 80, 80, 81, + 40, 39, 39, 38, 38, 39, 40, 41, 44, 45, 51, 51, 54, 56, 59, 60, 62, 65, 66, 69, 70, 74, 75, 79, 81, 85, 86, 87, 90, 90, 90, 90, + 51, 49, 49, 47, 47, 48, 48, 48, 52, 53, 58, 59, 63, 65, 69, 72, 74, 78, 79, 83, 84, 89, 90, 94, 97, 101, 102, 103, 106, 105, 103, 103, + 65, 62, 61, 59, 59, 59, 58, 58, 62, 63, 68, 68, 73, 75, 79, 82, 85, 90, 92, 97, 98, 105, 106, 111, 113, 118, 120, 121, 124, 122, 119, 117, + 79, 75, 74, 72, 71, 71, 69, 69, 72, 73, 78, 79, 84, 85, 90, 93, 96, 101, 103, 109, 110, 118, 119, 125, 128, 133, 135, 136, 140, 140, 137, 134, + 87, 83, 82, 79, 79, 78, 77, 75, 78, 80, 84, 85, 89, 90, 96, 97, 103, 105, 111, 113, 118, 122, 126, 131, 134, 141, 143, 147, 147, 152, 151, 152, + }, { + 32, 31, 31, 30, 31, 33, 35, 37, 41, 42, 49, 49, 48, 48, 49, 49, 50, 51, 52, 54, 54, 57, 57, 60, 61, 63, 64, 64, 66, 67, 68, 68, + 32, 33, 33, 33, 35, 37, 39, 41, 43, 43, 47, 47, 46, 46, 45, 46, 46, 47, 48, 49, 50, 52, 52, 54, 55, 57, 58, 58, 59, 60, 61, 62, + 40, 41, 41, 42, 43, 44, 46, 47, 48, 48, 50, 50, 49, 49, 48, 49, 49, 49, 50, 51, 51, 52, 53, 55, 56, 57, 58, 58, 59, 59, 59, 59, + 49, 47, 47, 45, 46, 46, 46, 46, 49, 49, 53, 53, 54, 55, 56, 57, 57, 58, 58, 59, 59, 60, 61, 62, 63, 64, 65, 65, 66, 66, 65, 65, + 51, 49, 49, 47, 47, 47, 47, 46, 49, 50, 54, 54, 57, 58, 61, 62, 63, 64, 65, 67, 67, 69, 69, 71, 72, 73, 73, 74, 75, 74, 72, 71, + 57, 54, 54, 52, 51, 51, 50, 50, 52, 53, 57, 57, 60, 61, 64, 65, 67, 69, 71, 73, 73, 76, 77, 79, 80, 82, 82, 83, 84, 82, 81, 79, + 63, 60, 59, 57, 57, 56, 55, 54, 57, 57, 60, 61, 64, 65, 67, 69, 71, 73, 75, 77, 78, 82, 82, 85, 86, 89, 89, 90, 91, 91, 89, 87, + 67, 63, 63, 60, 60, 59, 58, 57, 59, 60, 62, 63, 65, 66, 69, 70, 73, 74, 77, 78, 81, 83, 85, 87, 88, 92, 92, 94, 94, 96, 95, 95, + }, + }, { + { + 32, 31, 31, 31, 31, 32, 32, 32, 32, 34, 34, 36, 36, 39, 39, 44, 44, 48, 48, 53, 53, 58, 58, 65, 65, 71, 71, 79, 79, 82, 82, 87, + 31, 32, 32, 32, 32, 32, 32, 33, 33, 34, 34, 34, 34, 37, 37, 41, 41, 45, 45, 49, 49, 54, 54, 60, 60, 65, 65, 72, 72, 75, 75, 79, + 32, 32, 32, 33, 33, 34, 34, 35, 35, 37, 37, 38, 38, 40, 40, 43, 43, 46, 46, 50, 50, 54, 54, 58, 58, 63, 63, 70, 70, 72, 72, 76, + 36, 35, 35, 34, 34, 36, 36, 38, 38, 42, 42, 48, 48, 50, 50, 53, 53, 56, 56, 60, 60, 63, 63, 68, 68, 73, 73, 79, 79, 81, 81, 84, + 44, 42, 42, 41, 41, 42, 42, 42, 42, 48, 48, 54, 54, 58, 58, 63, 63, 67, 67, 71, 71, 75, 75, 79, 79, 84, 84, 90, 90, 92, 92, 96, + 53, 51, 51, 49, 49, 50, 50, 49, 49, 54, 54, 60, 60, 65, 65, 71, 71, 76, 76, 82, 82, 87, 87, 92, 92, 97, 97, 104, 104, 106, 106, 109, + 65, 62, 62, 59, 59, 59, 59, 58, 58, 63, 63, 68, 68, 73, 73, 79, 79, 85, 85, 92, 92, 98, 98, 105, 105, 111, 111, 118, 118, 121, 121, 124, + 79, 75, 75, 72, 72, 71, 71, 69, 69, 73, 73, 78, 78, 84, 84, 90, 90, 96, 96, 103, 103, 110, 110, 118, 118, 125, 125, 133, 133, 136, 136, 141, + }, { + 32, 31, 31, 30, 30, 33, 33, 37, 37, 42, 42, 49, 49, 48, 48, 49, 49, 50, 50, 52, 52, 54, 54, 57, 57, 60, 60, 63, 63, 64, 64, 66, + 31, 31, 31, 32, 32, 36, 36, 40, 40, 43, 43, 46, 46, 46, 46, 45, 45, 46, 46, 48, 48, 50, 50, 52, 52, 54, 54, 57, 57, 59, 59, 60, + 37, 38, 38, 40, 40, 43, 43, 47, 47, 47, 47, 48, 48, 47, 47, 46, 46, 46, 46, 47, 47, 49, 49, 50, 50, 52, 52, 55, 55, 56, 56, 57, + 48, 47, 47, 46, 46, 47, 47, 47, 47, 50, 50, 53, 53, 53, 53, 53, 53, 54, 54, 54, 54, 55, 55, 56, 56, 58, 58, 60, 60, 61, 61, 63, + 49, 47, 47, 45, 45, 46, 46, 45, 45, 49, 49, 53, 53, 56, 56, 58, 58, 59, 59, 61, 61, 62, 62, 64, 64, 65, 65, 67, 67, 68, 68, 69, + 52, 50, 50, 48, 48, 47, 47, 47, 47, 50, 50, 54, 54, 57, 57, 61, 61, 64, 64, 66, 66, 68, 68, 70, 70, 72, 72, 75, 75, 75, 75, 77, + 57, 54, 54, 52, 52, 51, 51, 50, 50, 53, 53, 57, 57, 60, 60, 64, 64, 67, 67, 71, 71, 73, 73, 76, 76, 79, 79, 82, 82, 83, 83, 84, + 63, 60, 60, 57, 57, 56, 56, 54, 54, 57, 57, 60, 60, 64, 64, 67, 67, 71, 71, 75, 75, 78, 78, 82, 82, 85, 85, 89, 89, 90, 90, 92, + }, + }, { + { + 32, 31, 31, 31, 31, 31, 32, 32, 32, 32, 34, 34, 35, 36, 38, 39, 41, 44, 44, 48, 48, 53, 53, 57, 58, 61, 65, 67, 71, 72, 79, 79, + 31, 32, 32, 32, 32, 32, 32, 32, 33, 33, 34, 34, 34, 34, 36, 37, 39, 41, 42, 45, 45, 49, 49, 52, 54, 57, 60, 61, 65, 66, 72, 72, + 32, 32, 32, 32, 33, 33, 34, 34, 35, 35, 37, 37, 38, 38, 40, 40, 41, 43, 43, 46, 46, 49, 50, 52, 54, 56, 58, 60, 63, 64, 70, 70, + 36, 35, 35, 35, 34, 35, 36, 37, 38, 39, 42, 42, 47, 48, 49, 50, 51, 53, 54, 56, 56, 59, 60, 62, 63, 66, 68, 69, 73, 73, 79, 79, + 44, 42, 42, 41, 41, 41, 42, 42, 42, 43, 48, 48, 52, 54, 56, 58, 60, 63, 64, 67, 67, 71, 71, 74, 75, 77, 79, 81, 84, 85, 90, 90, + 53, 51, 51, 50, 49, 49, 50, 49, 49, 50, 54, 54, 59, 60, 63, 65, 67, 71, 72, 76, 76, 81, 82, 85, 87, 89, 92, 94, 97, 98, 104, 104, + 62, 60, 59, 58, 57, 57, 57, 56, 56, 56, 61, 61, 65, 66, 69, 71, 74, 78, 79, 83, 83, 89, 90, 94, 95, 98, 102, 103, 108, 108, 115, 115, + 73, 70, 69, 67, 66, 66, 65, 65, 64, 64, 69, 69, 73, 74, 77, 79, 81, 85, 86, 91, 91, 98, 99, 103, 105, 108, 112, 114, 119, 119, 127, 127, + }, { + 32, 31, 31, 30, 30, 32, 33, 34, 37, 37, 42, 42, 47, 49, 48, 48, 48, 49, 49, 50, 50, 52, 52, 53, 54, 55, 57, 58, 60, 60, 63, 63, + 31, 31, 31, 32, 32, 34, 36, 37, 40, 40, 43, 43, 46, 46, 46, 46, 45, 45, 45, 46, 46, 48, 48, 49, 50, 51, 52, 53, 54, 55, 57, 57, + 37, 38, 38, 39, 40, 41, 43, 44, 47, 47, 47, 47, 48, 48, 47, 47, 46, 46, 46, 46, 46, 47, 47, 48, 49, 49, 50, 51, 52, 53, 55, 55, + 48, 47, 47, 46, 46, 46, 47, 47, 47, 48, 50, 50, 52, 53, 53, 53, 53, 53, 53, 54, 54, 54, 54, 55, 55, 56, 56, 57, 58, 59, 60, 60, + 49, 47, 47, 46, 45, 45, 46, 45, 45, 46, 49, 49, 53, 53, 55, 56, 57, 58, 58, 59, 59, 61, 61, 62, 62, 63, 64, 64, 65, 65, 67, 67, + 52, 50, 50, 48, 48, 48, 47, 47, 47, 47, 50, 50, 53, 54, 56, 57, 59, 61, 62, 64, 64, 66, 66, 68, 68, 69, 70, 71, 72, 73, 75, 75, + 56, 54, 53, 52, 51, 51, 50, 50, 49, 49, 53, 53, 55, 56, 58, 59, 61, 63, 64, 66, 66, 69, 70, 71, 72, 74, 75, 76, 77, 78, 80, 80, + 61, 58, 57, 56, 55, 54, 54, 53, 52, 53, 56, 56, 58, 59, 61, 62, 63, 66, 66, 69, 69, 72, 73, 75, 76, 78, 79, 80, 82, 83, 86, 86, + }, + }, { + { + 32, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 33, 34, 34, 36, 36, 38, 39, 41, 44, 44, 47, 48, 50, 53, 53, 57, 58, 61, 65, 65, 70, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 34, 34, 34, 34, 37, 37, 39, 41, 41, 44, 45, 46, 49, 49, 53, 54, 56, 60, 60, 64, + 32, 32, 32, 32, 33, 33, 34, 34, 34, 35, 35, 36, 37, 37, 38, 38, 40, 40, 41, 43, 43, 45, 46, 47, 50, 50, 53, 54, 56, 58, 58, 62, + 35, 35, 35, 34, 34, 34, 35, 36, 36, 37, 37, 40, 41, 43, 46, 46, 47, 48, 49, 51, 51, 53, 54, 55, 57, 57, 60, 61, 63, 66, 66, 70, + 39, 38, 38, 37, 37, 37, 38, 38, 39, 40, 40, 43, 44, 46, 50, 50, 52, 53, 54, 57, 57, 59, 60, 61, 64, 64, 67, 68, 69, 72, 72, 76, + 44, 42, 42, 41, 41, 41, 42, 42, 42, 42, 42, 46, 48, 50, 54, 54, 57, 58, 60, 63, 63, 66, 67, 68, 71, 71, 74, 75, 77, 79, 79, 83, + 53, 52, 51, 50, 49, 49, 49, 50, 49, 49, 49, 53, 54, 56, 60, 60, 64, 65, 67, 71, 71, 75, 76, 78, 82, 82, 86, 87, 89, 92, 92, 96, + 65, 63, 62, 61, 59, 59, 59, 59, 58, 58, 58, 62, 63, 65, 68, 68, 72, 73, 76, 79, 79, 84, 85, 88, 92, 92, 97, 98, 100, 105, 105, 109, + }, { + 32, 31, 31, 31, 30, 30, 33, 33, 35, 37, 37, 41, 42, 44, 49, 49, 48, 48, 48, 49, 49, 50, 50, 51, 52, 52, 54, 54, 55, 57, 57, 59, + 31, 31, 31, 32, 32, 32, 35, 36, 37, 40, 40, 42, 43, 44, 46, 46, 46, 46, 45, 45, 45, 46, 46, 47, 48, 48, 49, 50, 51, 52, 52, 54, + 37, 38, 38, 39, 40, 40, 42, 43, 44, 47, 47, 47, 47, 47, 48, 48, 47, 47, 46, 46, 46, 46, 46, 47, 47, 47, 48, 49, 49, 50, 50, 52, + 45, 45, 45, 45, 44, 44, 46, 46, 46, 47, 47, 49, 49, 50, 52, 52, 51, 51, 51, 51, 51, 52, 52, 52, 53, 53, 54, 54, 54, 55, 55, 57, + 48, 47, 47, 46, 45, 45, 46, 46, 46, 47, 47, 49, 50, 51, 53, 53, 54, 54, 54, 55, 55, 56, 56, 56, 57, 57, 58, 58, 58, 59, 59, 61, + 49, 47, 47, 46, 45, 45, 45, 46, 45, 45, 45, 48, 49, 51, 53, 53, 55, 56, 57, 58, 58, 59, 59, 60, 61, 61, 62, 62, 63, 64, 64, 65, + 52, 50, 50, 49, 48, 48, 47, 47, 47, 47, 47, 50, 50, 52, 54, 54, 57, 57, 59, 61, 61, 63, 64, 65, 66, 66, 68, 68, 69, 70, 70, 72, + 57, 55, 54, 53, 52, 52, 51, 51, 51, 50, 50, 52, 53, 54, 57, 57, 59, 60, 61, 64, 64, 66, 67, 68, 71, 71, 73, 73, 74, 76, 76, 78, + }, + }, { + { + 32, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 34, 34, 35, 36, 36, 38, 39, 39, 42, 44, 44, 47, 48, 49, 53, 53, 55, 58, 58, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 34, 34, 34, 34, 34, 36, 37, 37, 40, 41, 41, 44, 45, 46, 49, 49, 51, 54, 54, + 32, 32, 32, 32, 32, 32, 33, 33, 34, 34, 35, 35, 35, 36, 36, 37, 37, 37, 39, 40, 40, 42, 42, 43, 45, 46, 47, 49, 50, 51, 54, 54, + 32, 33, 33, 33, 33, 33, 33, 34, 34, 35, 36, 36, 36, 38, 38, 39, 40, 40, 41, 42, 42, 44, 45, 45, 47, 48, 48, 51, 51, 53, 55, 55, + 36, 35, 35, 35, 35, 34, 35, 36, 36, 37, 38, 38, 40, 42, 42, 45, 48, 48, 49, 50, 50, 52, 53, 54, 56, 56, 57, 59, 60, 61, 63, 63, + 44, 43, 42, 42, 41, 41, 41, 42, 42, 42, 42, 42, 44, 48, 48, 50, 54, 54, 56, 58, 58, 61, 63, 63, 66, 67, 67, 71, 71, 72, 75, 75, + 47, 46, 45, 45, 44, 44, 44, 45, 45, 45, 45, 45, 47, 50, 50, 53, 56, 56, 58, 60, 60, 64, 66, 66, 69, 70, 71, 74, 75, 76, 79, 79, + 53, 52, 51, 51, 49, 49, 49, 49, 50, 49, 49, 49, 51, 54, 54, 57, 60, 60, 63, 65, 65, 69, 71, 72, 75, 76, 77, 81, 82, 83, 87, 87, + }, { + 32, 31, 31, 31, 30, 30, 31, 33, 33, 34, 37, 37, 39, 42, 42, 45, 49, 49, 48, 48, 48, 49, 49, 49, 50, 50, 51, 52, 52, 53, 54, 54, + 31, 31, 31, 31, 32, 32, 33, 35, 36, 37, 40, 40, 41, 43, 43, 44, 46, 46, 46, 46, 46, 45, 45, 45, 46, 46, 47, 48, 48, 48, 50, 50, + 35, 36, 37, 37, 38, 38, 38, 41, 41, 42, 45, 45, 46, 46, 46, 47, 48, 48, 47, 46, 46, 46, 45, 46, 46, 46, 47, 47, 47, 48, 49, 49, + 38, 39, 40, 40, 40, 41, 41, 43, 44, 45, 47, 47, 47, 48, 48, 48, 49, 49, 48, 48, 48, 47, 47, 47, 48, 48, 48, 48, 48, 49, 50, 50, + 48, 47, 47, 47, 46, 46, 46, 47, 47, 47, 47, 47, 48, 50, 50, 51, 53, 53, 53, 53, 53, 53, 53, 53, 54, 54, 54, 54, 54, 54, 55, 55, + 49, 48, 47, 47, 45, 45, 45, 45, 46, 45, 45, 45, 47, 49, 49, 51, 53, 53, 55, 56, 56, 57, 58, 58, 59, 59, 60, 61, 61, 61, 62, 62, + 50, 49, 48, 48, 46, 46, 46, 46, 46, 46, 46, 46, 47, 50, 50, 52, 54, 54, 55, 56, 56, 58, 59, 60, 61, 61, 61, 63, 63, 63, 65, 65, + 52, 50, 50, 50, 48, 48, 48, 47, 47, 47, 47, 47, 48, 50, 50, 52, 54, 54, 56, 57, 57, 60, 61, 61, 63, 64, 64, 66, 66, 67, 68, 68, + }, + }, { + { + 32, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 34, 34, 34, 35, 36, 36, 38, 39, 39, 41, 44, 44, 44, 47, 48, 48, 51, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 34, 34, 34, 34, 34, 34, 36, 37, 37, 39, 41, 41, 42, 44, 45, 45, 47, + 31, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 34, 34, 34, 35, 35, 35, 36, 36, 36, 37, 39, 39, 40, 42, 42, 42, 44, 45, 45, 48, + 32, 32, 32, 32, 32, 33, 33, 33, 34, 34, 34, 35, 35, 35, 36, 37, 37, 37, 38, 38, 38, 40, 40, 40, 41, 43, 43, 43, 45, 46, 46, 48, + 35, 35, 35, 35, 34, 34, 34, 34, 35, 36, 36, 37, 37, 37, 39, 41, 41, 42, 45, 46, 46, 47, 48, 48, 49, 51, 51, 51, 53, 54, 54, 56, + 36, 35, 35, 35, 35, 34, 34, 35, 36, 36, 36, 37, 38, 38, 40, 42, 42, 43, 47, 48, 48, 49, 50, 50, 51, 53, 53, 54, 56, 56, 56, 58, + 44, 43, 42, 42, 41, 41, 41, 41, 42, 42, 42, 42, 42, 42, 44, 48, 48, 49, 52, 54, 54, 56, 58, 58, 60, 63, 63, 64, 66, 67, 67, 69, + 47, 46, 45, 45, 45, 44, 44, 44, 44, 45, 45, 45, 45, 45, 47, 50, 50, 51, 55, 56, 56, 58, 60, 60, 62, 66, 66, 67, 69, 70, 70, 73, + }, { + 32, 31, 31, 31, 31, 30, 30, 31, 33, 33, 33, 35, 37, 37, 39, 42, 42, 43, 47, 49, 49, 48, 48, 48, 48, 49, 49, 49, 50, 50, 50, 51, + 31, 31, 31, 31, 32, 32, 32, 33, 35, 36, 36, 38, 40, 40, 41, 43, 43, 43, 46, 46, 46, 46, 46, 46, 45, 45, 45, 45, 46, 46, 46, 47, + 33, 33, 34, 34, 34, 35, 35, 35, 37, 38, 38, 41, 43, 43, 43, 44, 44, 45, 46, 47, 47, 46, 46, 46, 46, 45, 45, 45, 46, 46, 46, 47, + 37, 38, 38, 38, 39, 40, 40, 40, 42, 43, 43, 45, 47, 47, 47, 47, 47, 47, 48, 48, 48, 47, 47, 47, 46, 46, 46, 46, 46, 46, 46, 47, + 45, 45, 45, 45, 45, 44, 44, 45, 46, 46, 46, 47, 47, 47, 48, 49, 49, 50, 51, 52, 52, 52, 51, 51, 51, 51, 51, 52, 52, 52, 52, 52, + 48, 47, 47, 47, 46, 46, 46, 46, 47, 47, 47, 47, 47, 47, 48, 50, 50, 50, 52, 53, 53, 53, 53, 53, 53, 53, 53, 53, 54, 54, 54, 54, + 49, 48, 47, 47, 46, 45, 45, 45, 45, 46, 46, 45, 45, 45, 47, 49, 49, 50, 53, 53, 53, 55, 56, 56, 57, 58, 58, 58, 59, 59, 59, 60, + 50, 49, 48, 48, 47, 46, 46, 46, 46, 46, 46, 46, 46, 46, 47, 50, 50, 50, 53, 54, 54, 55, 56, 56, 57, 59, 59, 60, 61, 61, 61, 62, + }, + }, { + { + 32, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 33, 34, 34, 34, 35, 36, 36, 36, 37, 39, 39, 39, 41, 44, 44, + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 34, 36, 37, 37, 37, 39, 41, 41, + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 34, 36, 37, 37, 37, 39, 41, 41, + 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 34, 34, 34, 34, 35, 35, 35, 36, 37, 37, 37, 37, 38, 38, 38, 39, 40, 40, 40, 42, 43, 43, + 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 34, 34, 34, 34, 35, 35, 35, 36, 37, 37, 37, 37, 38, 38, 38, 39, 40, 40, 40, 42, 43, 43, + 36, 35, 35, 35, 35, 35, 34, 34, 34, 35, 36, 36, 36, 37, 38, 38, 38, 40, 42, 42, 42, 45, 48, 48, 48, 49, 50, 50, 50, 52, 53, 53, + 36, 35, 35, 35, 35, 35, 34, 34, 34, 35, 36, 36, 36, 37, 38, 38, 38, 40, 42, 42, 42, 45, 48, 48, 48, 49, 50, 50, 50, 52, 53, 53, + 44, 43, 42, 42, 42, 41, 41, 41, 41, 41, 42, 42, 42, 42, 42, 42, 42, 45, 48, 48, 48, 50, 54, 54, 54, 56, 58, 58, 58, 60, 63, 63, + }, { + 32, 31, 31, 31, 31, 31, 30, 30, 30, 32, 33, 33, 33, 35, 37, 37, 37, 39, 42, 42, 42, 45, 49, 49, 49, 48, 48, 48, 48, 48, 49, 49, + 31, 31, 31, 31, 31, 32, 32, 32, 32, 34, 36, 36, 36, 38, 40, 40, 40, 41, 43, 43, 43, 44, 46, 46, 46, 46, 46, 46, 46, 45, 45, 45, + 31, 31, 31, 31, 31, 32, 32, 32, 32, 34, 36, 36, 36, 38, 40, 40, 40, 41, 43, 43, 43, 44, 46, 46, 46, 46, 46, 46, 46, 45, 45, 45, + 37, 37, 38, 38, 38, 39, 40, 40, 40, 41, 43, 43, 43, 45, 47, 47, 47, 47, 47, 47, 47, 47, 48, 48, 48, 47, 47, 47, 47, 46, 46, 46, + 37, 37, 38, 38, 38, 39, 40, 40, 40, 41, 43, 43, 43, 45, 47, 47, 47, 47, 47, 47, 47, 47, 48, 48, 48, 47, 47, 47, 47, 46, 46, 46, + 48, 47, 47, 47, 47, 46, 46, 46, 46, 46, 47, 47, 47, 47, 47, 47, 47, 49, 50, 50, 50, 51, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, + 48, 47, 47, 47, 47, 46, 46, 46, 46, 46, 47, 47, 47, 47, 47, 47, 47, 49, 50, 50, 50, 51, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, + 49, 48, 47, 47, 47, 46, 45, 45, 45, 45, 46, 46, 46, 45, 45, 45, 45, 47, 49, 49, 49, 51, 53, 53, 53, 54, 56, 56, 56, 57, 58, 58, + }, + }, { + { + 32, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 34, 34, 34, 34, 35, 36, 36, 36, 37, + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 34, 34, 34, 34, 34, 35, 35, 35, 36, + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 34, 34, 36, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 33, 34, 34, 34, 34, 35, 35, 35, 35, 35, 36, 36, 36, 36, 37, + 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 34, 34, 34, 34, 34, 35, 35, 35, 35, 36, 36, 37, 37, 37, 37, 38, 38, 38, 38, 39, + 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 34, 34, 34, 34, 34, 35, 35, 35, 35, 36, 36, 37, 37, 37, 37, 38, 38, 38, 38, 39, + 35, 35, 35, 35, 35, 35, 34, 34, 34, 34, 34, 35, 35, 36, 36, 36, 36, 37, 37, 37, 37, 39, 40, 41, 41, 41, 43, 45, 46, 46, 46, 46, + 36, 35, 35, 35, 35, 35, 35, 35, 34, 34, 34, 35, 36, 36, 36, 36, 37, 38, 38, 38, 38, 40, 41, 42, 42, 42, 44, 47, 48, 48, 48, 49, + }, { + 32, 31, 31, 31, 31, 31, 31, 30, 30, 30, 30, 31, 33, 33, 33, 33, 35, 36, 37, 37, 37, 39, 41, 42, 42, 42, 44, 47, 49, 49, 49, 49, + 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 33, 34, 35, 35, 35, 37, 38, 39, 39, 39, 40, 42, 42, 42, 42, 44, 46, 47, 47, 47, 47, + 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 33, 35, 36, 36, 36, 37, 39, 40, 40, 40, 41, 42, 43, 43, 43, 44, 46, 46, 46, 46, 46, + 33, 33, 34, 34, 34, 34, 34, 34, 35, 35, 35, 36, 37, 38, 38, 38, 40, 42, 43, 43, 43, 43, 44, 44, 44, 44, 45, 46, 47, 47, 47, 47, + 37, 37, 38, 38, 38, 38, 39, 39, 40, 40, 40, 41, 42, 43, 43, 43, 44, 46, 47, 47, 47, 47, 47, 47, 47, 47, 47, 48, 48, 48, 48, 47, + 37, 37, 38, 38, 38, 38, 39, 39, 40, 40, 40, 41, 42, 43, 43, 43, 44, 46, 47, 47, 47, 47, 47, 47, 47, 47, 47, 48, 48, 48, 48, 47, + 45, 45, 45, 45, 45, 45, 45, 44, 44, 44, 44, 45, 46, 46, 46, 46, 46, 47, 47, 47, 47, 48, 49, 49, 49, 49, 50, 51, 52, 52, 52, 52, + 48, 48, 47, 47, 47, 47, 46, 46, 46, 46, 46, 46, 47, 47, 47, 47, 47, 47, 47, 47, 47, 48, 49, 50, 50, 50, 51, 52, 53, 53, 53, 53, + }, + }, { + { + 32, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 34, 34, + 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 34, 34, + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 33, 34, 34, + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 33, 34, 34, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 35, 35, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 35, 35, 35, 35, 35, 35, 36, 36, 37, 37, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 35, 35, 35, 35, 35, 35, 36, 36, 37, 37, + 32, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 35, 35, 36, 36, 36, 36, 36, 36, 37, 38, 38, + }, { + 32, 31, 31, 31, 31, 31, 31, 31, 31, 30, 30, 30, 30, 30, 31, 32, 33, 33, 33, 33, 33, 34, 35, 36, 37, 37, 37, 37, 39, 40, 42, 42, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 33, 34, 35, 35, 35, 35, 36, 37, 38, 39, 39, 39, 39, 40, 41, 42, 42, + 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 33, 34, 35, 36, 36, 36, 36, 37, 38, 39, 40, 40, 40, 40, 41, 42, 43, 43, + 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 33, 34, 35, 36, 36, 36, 36, 37, 38, 39, 40, 40, 40, 40, 41, 42, 43, 43, + 33, 33, 33, 34, 34, 34, 34, 34, 34, 34, 35, 35, 35, 35, 35, 36, 37, 38, 38, 38, 38, 39, 41, 42, 43, 43, 43, 43, 43, 44, 44, 44, + 37, 37, 38, 38, 38, 38, 38, 38, 39, 39, 40, 40, 40, 40, 40, 41, 42, 43, 43, 43, 43, 44, 45, 47, 47, 47, 47, 47, 47, 47, 47, 47, + 37, 37, 38, 38, 38, 38, 38, 38, 39, 39, 40, 40, 40, 40, 40, 41, 42, 43, 43, 43, 43, 44, 45, 47, 47, 47, 47, 47, 47, 47, 47, 47, + 38, 39, 39, 40, 40, 40, 40, 40, 40, 40, 41, 41, 41, 41, 41, 42, 43, 44, 44, 44, 44, 45, 46, 47, 47, 47, 47, 47, 47, 47, 48, 48, + }, + }, { + { + 32, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 34, + }, { + 32, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 30, 30, 30, 30, 30, 30, 30, 31, 31, 32, 33, 33, 33, 33, 33, 33, 33, 34, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 33, 34, 34, 34, 34, 34, 34, 34, 35, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 33, 34, 34, 35, 35, 35, 35, 35, 35, 36, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 34, 35, 36, 36, 36, 36, 36, 36, 36, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 34, 35, 36, 36, 36, 36, 36, 36, 36, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 34, 35, 36, 36, 36, 36, 36, 36, 36, + 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 35, 35, 35, 35, 35, 35, 35, 36, 37, 37, 38, 38, 38, 38, 38, 38, 39, + 35, 35, 36, 36, 36, 37, 37, 37, 37, 37, 37, 37, 37, 37, 38, 38, 38, 38, 38, 38, 38, 38, 39, 40, 40, 41, 41, 41, 41, 41, 41, 42, + }, + }, { + { + 32, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + }, { + 32, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 30, 30, 30, 30, 30, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, + }, + }, +}; + +static const uint8_t qm_tbl_32x16[][2][512] = { + { + { + 32, 31, 31, 31, 32, 32, 34, 35, 36, 39, 44, 46, 48, 53, 58, 61, 65, 71, 79, 81, 82, 88, 91, 94, 97, 100, 103, 107, 110, 114, 118, 122, + 31, 32, 32, 32, 32, 33, 34, 34, 34, 37, 41, 43, 45, 49, 54, 57, 60, 65, 72, 74, 75, 80, 83, 85, 88, 91, 94, 97, 101, 104, 108, 111, + 32, 32, 33, 33, 34, 35, 37, 37, 38, 40, 43, 44, 46, 50, 54, 56, 58, 63, 70, 71, 72, 77, 80, 83, 86, 89, 93, 96, 100, 104, 107, 111, + 34, 34, 33, 34, 35, 37, 39, 41, 43, 45, 48, 49, 51, 54, 58, 60, 63, 68, 74, 75, 76, 80, 81, 82, 85, 87, 90, 93, 97, 100, 103, 107, + 36, 35, 34, 35, 36, 38, 42, 45, 48, 50, 53, 55, 56, 60, 63, 66, 68, 73, 79, 80, 81, 85, 88, 91, 94, 97, 98, 100, 101, 103, 105, 107, + 44, 42, 41, 41, 42, 42, 48, 50, 54, 58, 63, 65, 67, 71, 75, 77, 79, 84, 90, 91, 92, 97, 100, 100, 100, 100, 101, 104, 108, 112, 115, 119, + 53, 51, 49, 49, 50, 49, 54, 57, 60, 65, 71, 73, 76, 82, 87, 89, 92, 97, 104, 105, 106, 108, 106, 105, 107, 111, 114, 117, 117, 117, 118, 119, + 59, 56, 54, 54, 54, 53, 58, 61, 64, 69, 75, 78, 80, 87, 92, 95, 98, 103, 110, 112, 113, 115, 114, 118, 123, 121, 120, 119, 123, 127, 131, 136, + 65, 62, 59, 59, 59, 58, 63, 65, 68, 73, 79, 82, 85, 92, 98, 101, 105, 111, 118, 119, 121, 126, 130, 131, 128, 127, 131, 136, 138, 137, 136, 136, + 79, 75, 72, 71, 71, 69, 73, 76, 78, 84, 90, 93, 96, 103, 110, 114, 118, 125, 133, 135, 136, 142, 142, 137, 140, 145, 144, 142, 141, 146, 151, 156, + 87, 82, 78, 78, 77, 75, 79, 82, 84, 89, 95, 98, 102, 109, 116, 120, 124, 132, 141, 142, 144, 149, 148, 153, 157, 152, 150, 155, 161, 159, 157, 156, + 90, 85, 82, 81, 80, 78, 78, 83, 87, 89, 93, 100, 102, 107, 115, 118, 123, 132, 136, 140, 151, 153, 155, 160, 161, 164, 170, 168, 165, 167, 172, 178, + 93, 88, 86, 84, 82, 82, 80, 84, 86, 91, 94, 98, 105, 107, 112, 119, 122, 130, 135, 140, 149, 153, 162, 165, 167, 173, 174, 177, 183, 185, 182, 179, + 96, 91, 90, 87, 86, 86, 83, 84, 89, 91, 95, 100, 102, 110, 111, 118, 123, 128, 135, 138, 149, 152, 160, 167, 173, 178, 180, 187, 188, 190, 197, 203, + 99, 94, 93, 90, 89, 89, 88, 87, 90, 93, 97, 99, 105, 107, 115, 116, 124, 127, 135, 139, 146, 152, 159, 166, 171, 182, 186, 191, 193, 201, 203, 204, + 102, 97, 97, 93, 93, 92, 92, 90, 90, 96, 97, 103, 104, 111, 112, 120, 121, 130, 131, 142, 143, 154, 155, 168, 169, 181, 183, 198, 200, 206, 208, 217, + }, { + 32, 31, 30, 32, 33, 37, 42, 45, 49, 48, 49, 49, 50, 52, 54, 55, 57, 60, 63, 64, 64, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, + 31, 31, 32, 34, 36, 40, 43, 44, 46, 46, 45, 46, 46, 48, 50, 51, 52, 54, 57, 58, 59, 61, 62, 62, 63, 64, 65, 66, 67, 68, 69, 70, + 37, 38, 40, 41, 43, 47, 47, 47, 48, 47, 46, 46, 46, 47, 49, 49, 50, 52, 55, 55, 56, 58, 59, 60, 62, 63, 64, 65, 67, 68, 69, 70, + 42, 42, 42, 44, 45, 47, 48, 49, 50, 50, 49, 49, 50, 50, 52, 52, 53, 55, 58, 58, 58, 60, 60, 60, 60, 61, 62, 63, 64, 65, 66, 67, + 48, 47, 46, 46, 47, 47, 50, 51, 53, 53, 53, 53, 54, 54, 55, 56, 56, 58, 60, 61, 61, 63, 64, 65, 66, 67, 66, 66, 66, 66, 67, 67, + 49, 47, 45, 45, 46, 45, 49, 51, 53, 56, 58, 59, 59, 61, 62, 63, 64, 65, 67, 68, 68, 69, 71, 70, 69, 68, 68, 69, 70, 71, 72, 73, + 52, 50, 48, 48, 47, 47, 50, 52, 54, 57, 61, 62, 64, 66, 68, 69, 70, 72, 75, 75, 75, 76, 74, 72, 73, 74, 75, 75, 74, 74, 73, 73, + 54, 52, 50, 49, 49, 48, 52, 54, 55, 59, 62, 64, 65, 68, 71, 72, 73, 75, 78, 78, 79, 79, 78, 79, 81, 79, 78, 76, 77, 78, 80, 81, + 57, 54, 52, 51, 51, 50, 53, 55, 57, 60, 64, 65, 67, 71, 73, 75, 76, 79, 82, 82, 83, 85, 86, 85, 83, 82, 83, 84, 84, 83, 82, 81, + 63, 60, 57, 57, 56, 54, 57, 59, 60, 64, 67, 69, 71, 75, 78, 80, 82, 85, 89, 89, 90, 92, 91, 88, 89, 90, 89, 87, 86, 87, 88, 90, + 66, 63, 60, 59, 59, 57, 60, 61, 62, 66, 69, 71, 73, 77, 80, 82, 84, 88, 92, 92, 93, 95, 94, 95, 96, 93, 92, 93, 94, 93, 91, 90, + 67, 64, 62, 61, 60, 58, 58, 61, 63, 65, 67, 70, 72, 74, 78, 80, 82, 86, 88, 90, 95, 96, 96, 98, 97, 98, 100, 98, 96, 96, 97, 99, + 68, 65, 63, 62, 60, 60, 59, 61, 62, 65, 66, 68, 72, 73, 76, 79, 80, 84, 87, 89, 93, 94, 98, 99, 99, 102, 101, 102, 103, 103, 101, 99, + 69, 66, 65, 63, 62, 61, 60, 60, 63, 64, 66, 68, 70, 73, 74, 78, 80, 82, 85, 87, 91, 92, 96, 98, 101, 102, 103, 105, 105, 105, 107, 108, + 71, 67, 66, 64, 63, 62, 62, 61, 62, 64, 66, 67, 70, 71, 75, 76, 79, 81, 84, 86, 89, 91, 94, 97, 98, 102, 104, 106, 106, 109, 109, 108, + 72, 68, 68, 65, 65, 63, 63, 61, 62, 65, 65, 68, 69, 72, 73, 77, 77, 81, 81, 86, 87, 91, 91, 96, 97, 101, 102, 107, 107, 109, 110, 113, + }, + }, { + { + 32, 31, 31, 31, 32, 32, 32, 34, 36, 38, 39, 44, 47, 49, 53, 58, 61, 65, 71, 76, 79, 82, 86, 89, 92, 95, 98, 101, 104, 107, 110, 114, + 31, 32, 32, 32, 32, 33, 33, 34, 34, 36, 37, 41, 44, 46, 49, 54, 56, 60, 65, 69, 72, 75, 78, 81, 84, 86, 89, 92, 95, 98, 101, 104, + 32, 32, 32, 33, 34, 35, 35, 36, 37, 39, 40, 42, 45, 47, 50, 54, 56, 59, 64, 68, 70, 73, 76, 79, 82, 85, 88, 91, 94, 97, 100, 104, + 32, 33, 33, 33, 34, 36, 36, 38, 40, 41, 42, 45, 47, 48, 51, 55, 57, 60, 65, 69, 71, 74, 77, 78, 80, 83, 85, 88, 91, 94, 97, 100, + 36, 35, 35, 35, 36, 38, 40, 42, 48, 49, 50, 53, 56, 57, 60, 63, 65, 68, 73, 76, 79, 81, 84, 87, 89, 92, 93, 94, 95, 96, 98, 100, + 44, 42, 41, 41, 42, 42, 44, 48, 54, 56, 58, 63, 66, 67, 71, 75, 77, 79, 84, 88, 90, 92, 95, 95, 95, 95, 95, 98, 101, 105, 108, 111, + 47, 45, 44, 44, 45, 45, 47, 50, 56, 58, 60, 66, 69, 71, 75, 79, 81, 84, 89, 92, 95, 97, 100, 99, 101, 105, 108, 110, 110, 110, 111, 111, + 53, 51, 49, 49, 50, 49, 51, 54, 60, 63, 65, 71, 75, 77, 82, 87, 89, 92, 97, 101, 104, 106, 109, 112, 116, 114, 113, 112, 115, 119, 123, 126, + 65, 62, 60, 59, 59, 58, 60, 63, 68, 71, 73, 79, 84, 86, 92, 98, 100, 105, 111, 115, 118, 121, 124, 124, 121, 120, 124, 128, 129, 128, 127, 127, + 73, 69, 67, 66, 65, 64, 66, 69, 74, 77, 79, 85, 90, 93, 99, 105, 107, 112, 119, 123, 127, 130, 133, 130, 132, 136, 136, 133, 132, 136, 141, 145, + 79, 75, 72, 71, 71, 69, 71, 73, 78, 81, 84, 90, 95, 97, 103, 110, 113, 118, 125, 130, 133, 136, 140, 145, 148, 143, 141, 146, 151, 149, 147, 145, + 87, 83, 80, 79, 78, 76, 76, 80, 84, 86, 90, 96, 99, 103, 111, 114, 118, 126, 130, 134, 143, 146, 147, 152, 151, 155, 160, 158, 154, 156, 161, 166, + 90, 86, 84, 82, 80, 80, 78, 82, 83, 88, 91, 94, 101, 103, 108, 114, 116, 124, 129, 134, 142, 145, 153, 156, 157, 163, 163, 166, 171, 173, 169, 166, + 93, 88, 87, 84, 83, 83, 81, 81, 86, 88, 92, 96, 98, 105, 107, 113, 117, 122, 129, 131, 141, 144, 151, 157, 163, 167, 169, 175, 175, 177, 183, 189, + 96, 91, 90, 87, 87, 86, 85, 84, 87, 90, 94, 96, 101, 102, 110, 111, 118, 121, 129, 132, 138, 144, 150, 156, 161, 171, 174, 179, 181, 188, 188, 190, + 99, 94, 94, 90, 90, 88, 89, 86, 87, 93, 93, 99, 99, 106, 107, 115, 116, 124, 125, 135, 136, 145, 146, 158, 159, 170, 171, 185, 186, 192, 193, 201, + }, { + 32, 31, 30, 31, 33, 37, 39, 42, 49, 48, 48, 49, 50, 51, 52, 54, 55, 57, 60, 62, 63, 64, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, + 31, 31, 32, 33, 36, 40, 41, 43, 46, 46, 46, 45, 46, 47, 48, 50, 51, 52, 54, 56, 57, 59, 60, 61, 62, 63, 64, 65, 65, 66, 67, 68, + 35, 37, 38, 38, 41, 45, 46, 46, 48, 47, 46, 45, 46, 47, 47, 49, 49, 50, 53, 54, 55, 56, 58, 59, 60, 61, 62, 64, 65, 66, 67, 68, + 38, 40, 40, 41, 44, 47, 47, 48, 49, 48, 48, 47, 48, 48, 48, 50, 50, 51, 53, 55, 56, 57, 58, 58, 59, 60, 60, 61, 62, 63, 64, 65, + 48, 47, 46, 46, 47, 47, 48, 50, 53, 53, 53, 53, 54, 54, 54, 55, 56, 56, 58, 60, 60, 61, 62, 63, 64, 65, 65, 65, 65, 65, 65, 65, + 49, 47, 45, 45, 46, 45, 47, 49, 53, 55, 56, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 68, 67, 66, 66, 67, 68, 69, 70, 71, + 50, 48, 46, 46, 46, 46, 47, 50, 54, 55, 56, 59, 61, 61, 63, 65, 65, 66, 68, 69, 70, 71, 72, 71, 71, 72, 73, 73, 72, 72, 71, 71, + 52, 50, 48, 48, 47, 47, 48, 50, 54, 56, 57, 61, 63, 64, 66, 68, 69, 70, 72, 74, 75, 75, 76, 78, 79, 77, 76, 74, 75, 76, 77, 78, + 57, 54, 52, 52, 51, 50, 51, 53, 57, 58, 60, 64, 66, 68, 71, 73, 74, 76, 79, 81, 82, 83, 84, 83, 81, 80, 81, 82, 82, 81, 79, 78, + 61, 57, 55, 55, 54, 52, 54, 56, 59, 61, 62, 66, 68, 70, 73, 76, 77, 79, 82, 84, 86, 87, 88, 86, 86, 88, 87, 85, 83, 85, 86, 87, + 63, 60, 58, 57, 56, 54, 55, 57, 60, 62, 64, 67, 70, 71, 75, 78, 79, 82, 85, 87, 89, 90, 91, 93, 94, 91, 89, 90, 92, 90, 89, 87, + 67, 63, 61, 60, 59, 57, 57, 60, 63, 64, 66, 69, 71, 73, 77, 79, 81, 85, 87, 88, 92, 93, 94, 96, 95, 96, 97, 95, 93, 93, 94, 96, + 68, 64, 63, 61, 60, 59, 58, 60, 61, 64, 65, 67, 71, 72, 75, 78, 79, 83, 85, 87, 91, 92, 95, 96, 97, 99, 98, 99, 100, 100, 98, 96, + 69, 65, 64, 62, 61, 61, 59, 59, 62, 63, 65, 67, 68, 72, 73, 76, 78, 81, 84, 85, 89, 90, 93, 96, 98, 99, 100, 102, 102, 102, 103, 105, + 70, 66, 65, 63, 63, 62, 61, 60, 61, 63, 65, 66, 69, 70, 74, 74, 78, 79, 82, 84, 87, 89, 91, 94, 96, 100, 101, 103, 103, 105, 105, 105, + 71, 67, 67, 64, 64, 62, 62, 60, 61, 64, 64, 67, 67, 71, 71, 75, 75, 79, 80, 84, 84, 89, 89, 94, 94, 98, 99, 104, 104, 106, 106, 109, + }, + }, { + { + 32, 31, 31, 31, 32, 32, 32, 34, 34, 36, 39, 40, 44, 47, 49, 53, 57, 59, 65, 69, 71, 79, 81, 82, 87, 90, 92, 95, 98, 100, 103, 106, + 31, 32, 32, 32, 32, 32, 33, 34, 34, 34, 37, 38, 41, 44, 46, 49, 53, 54, 60, 63, 65, 72, 74, 75, 79, 82, 84, 87, 89, 92, 94, 97, + 32, 32, 32, 32, 33, 34, 34, 35, 36, 37, 39, 40, 42, 45, 46, 50, 53, 54, 59, 62, 64, 71, 72, 73, 77, 80, 83, 85, 88, 91, 94, 97, + 32, 32, 32, 33, 34, 34, 35, 37, 37, 38, 40, 41, 43, 46, 47, 50, 53, 54, 58, 62, 63, 70, 71, 72, 76, 78, 81, 83, 85, 88, 90, 93, + 36, 35, 35, 34, 36, 37, 38, 42, 44, 48, 50, 51, 53, 56, 57, 60, 63, 64, 68, 71, 73, 79, 80, 81, 85, 87, 88, 88, 89, 90, 92, 93, + 39, 38, 38, 37, 39, 40, 40, 45, 47, 51, 54, 55, 58, 61, 62, 65, 68, 69, 73, 76, 78, 84, 85, 86, 90, 89, 90, 92, 95, 98, 101, 104, + 44, 42, 41, 41, 42, 42, 42, 48, 50, 54, 58, 59, 63, 66, 67, 71, 74, 75, 79, 83, 84, 90, 91, 92, 96, 99, 102, 103, 103, 103, 103, 104, + 53, 51, 50, 49, 50, 49, 49, 54, 56, 60, 65, 67, 71, 75, 77, 82, 86, 87, 92, 96, 97, 104, 105, 106, 110, 108, 106, 105, 108, 111, 114, 118, + 58, 55, 54, 53, 53, 53, 52, 57, 59, 63, 68, 70, 74, 79, 81, 86, 90, 91, 97, 100, 102, 109, 110, 111, 114, 113, 117, 120, 121, 120, 119, 118, + 65, 62, 60, 59, 59, 58, 58, 63, 65, 68, 73, 75, 79, 85, 86, 92, 97, 98, 105, 109, 111, 118, 120, 121, 125, 129, 128, 125, 124, 127, 131, 135, + 79, 75, 73, 72, 71, 70, 69, 73, 75, 78, 84, 85, 90, 95, 97, 103, 108, 111, 118, 122, 125, 133, 135, 136, 140, 135, 133, 137, 141, 139, 137, 135, + 81, 77, 75, 74, 72, 71, 70, 75, 77, 80, 85, 87, 91, 97, 99, 105, 110, 112, 119, 124, 127, 135, 137, 139, 143, 146, 150, 148, 144, 146, 150, 154, + 88, 83, 81, 79, 78, 77, 76, 79, 81, 85, 88, 91, 97, 99, 104, 109, 111, 119, 123, 127, 135, 137, 145, 147, 148, 153, 153, 155, 160, 161, 158, 155, + 90, 86, 84, 82, 81, 80, 78, 79, 83, 85, 89, 92, 94, 101, 102, 108, 112, 117, 123, 125, 134, 136, 143, 148, 154, 157, 158, 164, 164, 165, 170, 175, + 93, 88, 88, 84, 84, 83, 82, 81, 84, 86, 90, 92, 97, 98, 105, 106, 113, 115, 122, 125, 131, 136, 141, 147, 151, 160, 163, 168, 169, 175, 175, 176, + 96, 91, 91, 87, 87, 85, 86, 83, 84, 89, 89, 95, 95, 102, 102, 110, 110, 118, 119, 128, 129, 137, 138, 149, 149, 159, 160, 173, 174, 179, 180, 187, + }, { + 32, 31, 31, 30, 33, 35, 37, 42, 44, 49, 48, 48, 49, 50, 51, 52, 54, 54, 57, 59, 60, 63, 64, 64, 66, 67, 68, 69, 70, 71, 72, 73, + 31, 31, 32, 32, 36, 38, 40, 43, 44, 46, 46, 45, 45, 46, 47, 48, 49, 50, 52, 54, 54, 57, 58, 59, 60, 61, 62, 63, 64, 65, 65, 66, + 34, 35, 36, 36, 40, 42, 44, 45, 46, 47, 46, 46, 45, 46, 47, 47, 49, 49, 51, 52, 53, 56, 57, 57, 59, 60, 61, 62, 63, 64, 65, 66, + 37, 38, 39, 40, 43, 45, 47, 47, 47, 48, 47, 46, 46, 46, 47, 47, 48, 49, 50, 52, 52, 55, 55, 56, 57, 58, 59, 60, 60, 61, 62, 63, + 48, 47, 46, 46, 47, 47, 47, 50, 51, 53, 53, 53, 53, 54, 54, 54, 55, 55, 56, 58, 58, 60, 61, 61, 63, 63, 63, 63, 63, 63, 63, 63, + 48, 47, 46, 45, 46, 46, 46, 50, 51, 53, 54, 55, 56, 56, 57, 57, 58, 59, 60, 61, 62, 64, 64, 65, 66, 65, 64, 65, 66, 67, 68, 69, + 49, 47, 46, 45, 46, 45, 45, 49, 51, 53, 56, 56, 58, 59, 60, 61, 62, 62, 64, 65, 65, 67, 68, 68, 69, 70, 71, 71, 70, 70, 69, 69, + 52, 50, 48, 48, 47, 47, 47, 50, 52, 54, 57, 58, 61, 63, 64, 66, 68, 68, 70, 72, 72, 75, 75, 75, 77, 75, 74, 72, 73, 74, 75, 76, + 54, 51, 50, 49, 49, 48, 48, 51, 53, 55, 58, 59, 62, 65, 65, 68, 70, 70, 73, 74, 75, 77, 78, 78, 79, 78, 79, 80, 80, 78, 77, 76, + 57, 54, 53, 52, 51, 50, 50, 53, 54, 57, 60, 61, 64, 66, 68, 71, 73, 74, 76, 78, 79, 82, 82, 83, 84, 85, 84, 82, 81, 82, 83, 84, + 63, 60, 58, 57, 56, 55, 54, 57, 59, 60, 64, 65, 67, 70, 71, 75, 77, 78, 82, 84, 85, 89, 89, 90, 91, 88, 87, 88, 89, 88, 86, 84, + 64, 61, 59, 58, 57, 56, 55, 58, 59, 61, 64, 65, 68, 71, 72, 75, 78, 79, 82, 85, 86, 90, 90, 91, 93, 93, 94, 93, 90, 90, 92, 93, + 67, 63, 62, 60, 59, 58, 57, 59, 60, 63, 64, 66, 70, 70, 73, 76, 77, 81, 83, 85, 89, 90, 93, 94, 94, 96, 96, 96, 97, 97, 95, 93, + 68, 64, 63, 61, 60, 60, 58, 58, 61, 62, 64, 66, 67, 71, 71, 75, 77, 79, 82, 83, 87, 88, 91, 93, 95, 97, 97, 99, 99, 99, 100, 101, + 69, 65, 65, 62, 62, 61, 60, 59, 61, 62, 64, 65, 68, 68, 72, 73, 76, 77, 81, 82, 85, 87, 89, 92, 93, 97, 98, 100, 100, 102, 102, 101, + 69, 66, 66, 63, 63, 61, 61, 59, 60, 63, 63, 66, 66, 70, 70, 73, 74, 78, 78, 82, 82, 86, 87, 91, 91, 95, 96, 101, 101, 103, 103, 105, + }, + }, { + { + 32, 31, 31, 31, 31, 32, 32, 32, 34, 35, 36, 39, 41, 44, 47, 48, 53, 55, 58, 63, 65, 71, 74, 79, 82, 82, 87, 89, 92, 94, 97, 99, + 31, 32, 32, 32, 32, 32, 33, 33, 34, 34, 34, 37, 39, 41, 44, 45, 49, 51, 54, 58, 60, 65, 68, 72, 75, 75, 79, 82, 84, 86, 88, 91, + 31, 32, 32, 32, 33, 33, 34, 34, 35, 36, 36, 39, 40, 42, 44, 45, 50, 51, 54, 58, 59, 64, 67, 71, 73, 74, 78, 81, 83, 85, 88, 91, + 32, 32, 32, 33, 34, 34, 35, 36, 37, 38, 38, 40, 41, 43, 45, 46, 50, 51, 54, 57, 58, 63, 66, 70, 72, 72, 76, 78, 80, 82, 85, 87, + 35, 35, 34, 34, 35, 36, 37, 39, 41, 45, 46, 48, 49, 51, 53, 54, 57, 59, 61, 65, 66, 71, 73, 77, 79, 79, 83, 83, 84, 85, 86, 87, + 36, 35, 35, 34, 36, 36, 38, 40, 42, 47, 48, 50, 51, 53, 56, 56, 60, 61, 63, 67, 68, 73, 75, 79, 81, 81, 85, 87, 89, 92, 94, 97, + 44, 42, 41, 41, 42, 42, 42, 44, 48, 52, 54, 58, 60, 63, 66, 67, 71, 72, 75, 78, 79, 84, 86, 90, 92, 92, 96, 97, 97, 97, 97, 97, + 47, 45, 45, 44, 44, 45, 45, 47, 50, 55, 56, 60, 62, 66, 69, 70, 75, 77, 79, 83, 84, 89, 91, 95, 97, 97, 100, 99, 101, 104, 107, 110, + 53, 51, 50, 49, 49, 50, 49, 51, 54, 59, 60, 65, 67, 71, 75, 76, 82, 84, 87, 91, 92, 97, 100, 104, 105, 106, 110, 113, 114, 112, 111, 110, + 62, 59, 58, 57, 57, 57, 56, 58, 61, 65, 66, 71, 74, 78, 82, 83, 90, 92, 95, 100, 102, 108, 110, 115, 117, 117, 120, 118, 116, 119, 123, 126, + 65, 62, 61, 59, 59, 59, 58, 60, 63, 67, 68, 73, 76, 79, 84, 85, 92, 94, 98, 103, 105, 111, 113, 118, 120, 121, 125, 128, 132, 130, 128, 126, + 79, 75, 74, 72, 71, 71, 69, 71, 73, 77, 78, 84, 86, 90, 95, 96, 103, 106, 110, 116, 118, 125, 128, 133, 136, 136, 141, 139, 135, 136, 140, 144, + 82, 78, 76, 74, 73, 73, 71, 73, 76, 79, 80, 86, 88, 92, 97, 98, 106, 108, 112, 118, 120, 127, 131, 136, 139, 139, 144, 145, 150, 151, 147, 144, + 88, 83, 82, 79, 79, 78, 76, 76, 81, 82, 85, 89, 91, 97, 98, 104, 107, 111, 117, 119, 127, 129, 135, 140, 145, 148, 148, 153, 153, 154, 159, 163, + 90, 86, 85, 82, 81, 80, 79, 78, 81, 83, 87, 88, 93, 94, 101, 101, 108, 110, 116, 119, 124, 129, 134, 139, 142, 150, 153, 157, 157, 163, 163, 163, + 93, 88, 88, 84, 84, 82, 83, 80, 80, 86, 86, 91, 91, 97, 98, 105, 105, 112, 113, 121, 122, 130, 130, 140, 140, 149, 150, 161, 162, 166, 167, 173, + }, { + 32, 31, 31, 30, 33, 33, 37, 39, 42, 47, 49, 48, 48, 49, 50, 50, 52, 53, 54, 56, 57, 60, 61, 63, 64, 64, 66, 67, 68, 69, 70, 70, + 31, 31, 32, 32, 35, 36, 40, 41, 43, 46, 46, 46, 45, 45, 46, 46, 48, 49, 50, 51, 52, 54, 56, 57, 58, 59, 60, 61, 62, 63, 63, 64, + 33, 34, 34, 35, 37, 38, 43, 43, 44, 46, 47, 46, 46, 45, 46, 46, 47, 48, 49, 51, 51, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, + 37, 38, 39, 40, 42, 43, 47, 47, 47, 48, 48, 47, 46, 46, 46, 46, 47, 48, 49, 50, 50, 52, 53, 55, 56, 56, 57, 58, 59, 59, 60, 61, + 45, 45, 45, 44, 46, 46, 47, 48, 49, 51, 52, 51, 51, 51, 52, 52, 53, 53, 54, 55, 55, 57, 58, 59, 60, 60, 61, 61, 61, 61, 61, 61, + 48, 47, 46, 46, 47, 47, 47, 48, 50, 52, 53, 53, 53, 53, 54, 54, 54, 55, 55, 56, 56, 58, 59, 60, 61, 61, 63, 63, 64, 65, 66, 67, + 49, 47, 46, 45, 45, 46, 45, 47, 49, 53, 53, 56, 57, 58, 59, 59, 61, 61, 62, 63, 64, 65, 66, 67, 68, 68, 69, 69, 68, 68, 67, 67, + 50, 48, 47, 46, 46, 46, 46, 47, 50, 53, 54, 56, 57, 59, 61, 61, 63, 64, 65, 66, 66, 68, 69, 70, 71, 71, 72, 70, 71, 72, 73, 74, + 52, 50, 49, 48, 47, 47, 47, 48, 50, 53, 54, 57, 59, 61, 63, 64, 66, 67, 68, 70, 70, 72, 73, 75, 75, 75, 77, 78, 77, 76, 75, 74, + 56, 53, 52, 51, 50, 50, 49, 50, 53, 55, 56, 59, 61, 63, 65, 66, 70, 71, 72, 74, 75, 77, 79, 80, 81, 81, 82, 80, 79, 80, 81, 82, + 57, 54, 53, 52, 51, 51, 50, 51, 53, 56, 57, 60, 61, 64, 66, 67, 71, 72, 73, 76, 76, 79, 80, 82, 83, 83, 84, 85, 86, 85, 83, 82, + 63, 60, 59, 57, 56, 56, 54, 55, 57, 60, 60, 64, 65, 67, 70, 71, 75, 76, 78, 81, 82, 85, 86, 89, 90, 90, 92, 90, 88, 88, 89, 90, + 64, 61, 60, 58, 57, 57, 55, 56, 58, 61, 61, 64, 66, 68, 71, 71, 75, 77, 79, 82, 83, 86, 87, 90, 91, 91, 93, 93, 94, 94, 92, 90, + 67, 63, 62, 60, 60, 59, 57, 57, 60, 61, 63, 65, 66, 70, 70, 73, 75, 77, 80, 81, 85, 86, 89, 91, 93, 94, 94, 96, 96, 95, 97, 98, + 68, 64, 64, 61, 61, 60, 59, 58, 60, 61, 63, 64, 67, 67, 71, 71, 74, 75, 79, 80, 83, 85, 87, 89, 91, 94, 95, 97, 97, 99, 98, 98, + 68, 65, 65, 62, 62, 60, 61, 59, 59, 62, 62, 65, 65, 68, 68, 72, 72, 76, 76, 80, 80, 84, 84, 89, 89, 93, 93, 97, 98, 99, 99, 102, + }, + }, { + { + 32, 31, 31, 31, 31, 32, 32, 32, 33, 34, 36, 36, 39, 40, 44, 46, 48, 52, 53, 58, 58, 65, 66, 71, 74, 79, 81, 82, 86, 88, 91, 93, + 31, 32, 32, 32, 32, 32, 32, 33, 33, 34, 34, 35, 37, 38, 41, 43, 45, 48, 49, 53, 54, 60, 61, 65, 68, 72, 74, 75, 78, 81, 83, 85, + 31, 32, 32, 32, 32, 33, 33, 33, 34, 34, 35, 35, 38, 39, 41, 43, 45, 48, 49, 53, 54, 59, 60, 65, 67, 72, 73, 74, 78, 80, 82, 85, + 32, 32, 32, 33, 33, 34, 35, 35, 36, 37, 38, 38, 40, 41, 43, 44, 46, 49, 50, 53, 54, 58, 59, 63, 66, 70, 71, 72, 75, 77, 79, 81, + 33, 33, 33, 33, 34, 35, 36, 36, 38, 39, 42, 42, 44, 45, 46, 48, 50, 52, 53, 57, 57, 62, 63, 67, 69, 73, 75, 75, 78, 80, 80, 81, + 36, 35, 35, 34, 35, 36, 37, 38, 41, 42, 48, 48, 50, 51, 53, 55, 56, 59, 60, 63, 63, 68, 69, 73, 75, 79, 80, 81, 84, 86, 88, 90, + 40, 39, 39, 38, 38, 39, 40, 41, 44, 45, 51, 51, 54, 56, 59, 60, 62, 65, 66, 69, 70, 74, 75, 79, 81, 85, 86, 87, 90, 90, 90, 90, + 44, 42, 42, 41, 41, 42, 42, 42, 46, 48, 54, 54, 58, 59, 63, 65, 67, 70, 71, 74, 75, 79, 80, 84, 86, 90, 91, 92, 95, 98, 100, 102, + 51, 49, 49, 47, 47, 48, 48, 48, 52, 53, 58, 59, 63, 65, 69, 72, 74, 78, 79, 83, 84, 89, 90, 94, 97, 101, 102, 103, 106, 105, 103, 103, + 53, 51, 51, 49, 49, 50, 49, 49, 53, 54, 60, 60, 65, 67, 71, 73, 76, 80, 82, 86, 87, 92, 93, 97, 100, 104, 105, 106, 109, 112, 114, 117, + 65, 62, 61, 59, 59, 59, 58, 58, 62, 63, 68, 68, 73, 75, 79, 82, 85, 90, 92, 97, 98, 105, 106, 111, 113, 118, 120, 121, 124, 122, 119, 117, + 66, 63, 62, 60, 60, 60, 59, 59, 63, 64, 69, 69, 74, 76, 80, 83, 86, 91, 93, 98, 99, 106, 107, 112, 115, 119, 121, 122, 125, 127, 130, 134, + 79, 75, 74, 72, 71, 71, 69, 69, 72, 73, 78, 79, 84, 85, 90, 93, 96, 101, 103, 109, 110, 118, 119, 125, 128, 133, 135, 136, 140, 140, 137, 134, + 81, 77, 76, 74, 73, 72, 71, 70, 74, 75, 80, 80, 85, 87, 91, 94, 98, 103, 105, 111, 112, 119, 121, 127, 130, 135, 137, 139, 142, 144, 148, 151, + 87, 83, 82, 79, 79, 78, 77, 75, 78, 80, 84, 85, 89, 90, 96, 97, 103, 105, 111, 113, 118, 122, 126, 131, 134, 141, 143, 147, 147, 152, 151, 152, + 90, 85, 85, 81, 81, 80, 80, 77, 78, 83, 83, 87, 88, 93, 93, 100, 100, 107, 107, 115, 115, 123, 123, 132, 132, 140, 140, 151, 151, 155, 155, 160, + }, { + 32, 31, 31, 30, 31, 33, 35, 37, 41, 42, 49, 49, 48, 48, 49, 49, 50, 51, 52, 54, 54, 57, 57, 60, 61, 63, 64, 64, 66, 67, 68, 68, + 31, 31, 31, 32, 33, 36, 38, 40, 42, 43, 46, 46, 46, 45, 45, 46, 46, 47, 48, 50, 50, 52, 52, 54, 56, 57, 58, 59, 60, 61, 62, 62, + 32, 33, 33, 33, 35, 37, 39, 41, 43, 43, 47, 47, 46, 46, 45, 46, 46, 47, 48, 49, 50, 52, 52, 54, 55, 57, 58, 58, 59, 60, 61, 62, + 37, 38, 38, 40, 41, 43, 45, 47, 47, 47, 48, 48, 47, 46, 46, 46, 46, 47, 47, 48, 49, 50, 51, 52, 53, 55, 55, 56, 57, 58, 58, 59, + 40, 41, 41, 42, 43, 44, 46, 47, 48, 48, 50, 50, 49, 49, 48, 49, 49, 49, 50, 51, 51, 52, 53, 55, 56, 57, 58, 58, 59, 59, 59, 59, + 48, 47, 47, 46, 46, 47, 47, 47, 49, 50, 53, 53, 53, 53, 53, 53, 54, 54, 54, 55, 55, 56, 57, 58, 59, 60, 61, 61, 62, 63, 64, 65, + 49, 47, 47, 45, 46, 46, 46, 46, 49, 49, 53, 53, 54, 55, 56, 57, 57, 58, 58, 59, 59, 60, 61, 62, 63, 64, 65, 65, 66, 66, 65, 65, + 49, 47, 47, 45, 45, 46, 45, 45, 48, 49, 53, 54, 56, 56, 58, 59, 59, 61, 61, 62, 62, 64, 64, 65, 66, 67, 68, 68, 69, 70, 71, 71, + 51, 49, 49, 47, 47, 47, 47, 46, 49, 50, 54, 54, 57, 58, 61, 62, 63, 64, 65, 67, 67, 69, 69, 71, 72, 73, 73, 74, 75, 74, 72, 71, + 52, 50, 49, 48, 48, 47, 47, 47, 50, 50, 54, 55, 57, 58, 61, 62, 64, 66, 66, 68, 68, 70, 71, 72, 73, 75, 75, 75, 76, 77, 78, 79, + 57, 54, 54, 52, 51, 51, 50, 50, 52, 53, 57, 57, 60, 61, 64, 65, 67, 69, 71, 73, 73, 76, 77, 79, 80, 82, 82, 83, 84, 82, 81, 79, + 58, 55, 54, 52, 52, 52, 51, 50, 53, 54, 57, 57, 60, 61, 64, 66, 67, 70, 71, 73, 74, 77, 77, 79, 81, 82, 83, 83, 85, 85, 86, 87, + 63, 60, 59, 57, 57, 56, 55, 54, 57, 57, 60, 61, 64, 65, 67, 69, 71, 73, 75, 77, 78, 82, 82, 85, 86, 89, 89, 90, 91, 91, 89, 87, + 64, 61, 60, 58, 57, 57, 56, 55, 57, 58, 61, 61, 64, 65, 68, 69, 71, 74, 75, 78, 78, 82, 83, 86, 87, 90, 90, 91, 92, 93, 94, 95, + 67, 63, 63, 60, 60, 59, 58, 57, 59, 60, 62, 63, 65, 66, 69, 70, 73, 74, 77, 78, 81, 83, 85, 87, 88, 92, 92, 94, 94, 96, 95, 95, + 67, 64, 64, 61, 61, 60, 60, 58, 58, 61, 61, 64, 64, 67, 67, 70, 71, 74, 74, 78, 78, 82, 82, 86, 86, 90, 90, 95, 95, 96, 96, 98, + }, + }, { + { + 32, 31, 31, 31, 31, 32, 32, 32, 32, 34, 34, 36, 36, 39, 39, 44, 44, 48, 48, 53, 53, 58, 58, 65, 65, 71, 71, 79, 79, 82, 82, 87, + 31, 32, 32, 32, 32, 32, 32, 33, 33, 34, 34, 34, 34, 37, 37, 41, 41, 45, 45, 49, 49, 54, 54, 60, 60, 65, 65, 72, 72, 75, 75, 79, + 31, 32, 32, 32, 32, 32, 32, 33, 33, 34, 34, 34, 34, 37, 37, 41, 41, 45, 45, 49, 49, 54, 54, 60, 60, 65, 65, 72, 72, 75, 75, 79, + 32, 32, 32, 33, 33, 34, 34, 35, 35, 37, 37, 38, 38, 40, 40, 43, 43, 46, 46, 50, 50, 54, 54, 58, 58, 63, 63, 70, 70, 72, 72, 76, + 32, 32, 32, 33, 33, 34, 34, 35, 35, 37, 37, 38, 38, 40, 40, 43, 43, 46, 46, 50, 50, 54, 54, 58, 58, 63, 63, 70, 70, 72, 72, 76, + 36, 35, 35, 34, 34, 36, 36, 38, 38, 42, 42, 48, 48, 50, 50, 53, 53, 56, 56, 60, 60, 63, 63, 68, 68, 73, 73, 79, 79, 81, 81, 84, + 36, 35, 35, 34, 34, 36, 36, 38, 38, 42, 42, 48, 48, 50, 50, 53, 53, 56, 56, 60, 60, 63, 63, 68, 68, 73, 73, 79, 79, 81, 81, 84, + 44, 42, 42, 41, 41, 42, 42, 42, 42, 48, 48, 54, 54, 58, 58, 63, 63, 67, 67, 71, 71, 75, 75, 79, 79, 84, 84, 90, 90, 92, 92, 96, + 44, 42, 42, 41, 41, 42, 42, 42, 42, 48, 48, 54, 54, 58, 58, 63, 63, 67, 67, 71, 71, 75, 75, 79, 79, 84, 84, 90, 90, 92, 92, 96, + 53, 51, 51, 49, 49, 50, 50, 49, 49, 54, 54, 60, 60, 65, 65, 71, 71, 76, 76, 82, 82, 87, 87, 92, 92, 97, 97, 104, 104, 106, 106, 109, + 53, 51, 51, 49, 49, 50, 50, 49, 49, 54, 54, 60, 60, 65, 65, 71, 71, 76, 76, 82, 82, 87, 87, 92, 92, 97, 97, 104, 104, 106, 106, 109, + 65, 62, 62, 59, 59, 59, 59, 58, 58, 63, 63, 68, 68, 73, 73, 79, 79, 85, 85, 92, 92, 98, 98, 105, 105, 111, 111, 118, 118, 121, 121, 124, + 65, 62, 62, 59, 59, 59, 59, 58, 58, 63, 63, 68, 68, 73, 73, 79, 79, 85, 85, 92, 92, 98, 98, 105, 105, 111, 111, 118, 118, 121, 121, 124, + 79, 75, 75, 72, 72, 71, 71, 69, 69, 73, 73, 78, 78, 84, 84, 90, 90, 96, 96, 103, 103, 110, 110, 118, 118, 125, 125, 133, 133, 136, 136, 141, + 79, 75, 75, 72, 72, 71, 71, 69, 69, 73, 73, 78, 78, 84, 84, 90, 90, 96, 96, 103, 103, 110, 110, 118, 118, 125, 125, 133, 133, 136, 136, 141, + 87, 82, 82, 78, 78, 77, 77, 75, 75, 79, 79, 84, 84, 89, 89, 95, 95, 102, 102, 109, 109, 116, 116, 124, 124, 132, 132, 141, 141, 144, 144, 149, + }, { + 32, 31, 31, 30, 30, 33, 33, 37, 37, 42, 42, 49, 49, 48, 48, 49, 49, 50, 50, 52, 52, 54, 54, 57, 57, 60, 60, 63, 63, 64, 64, 66, + 31, 31, 31, 32, 32, 36, 36, 40, 40, 43, 43, 46, 46, 46, 46, 45, 45, 46, 46, 48, 48, 50, 50, 52, 52, 54, 54, 57, 57, 59, 59, 60, + 31, 31, 31, 32, 32, 36, 36, 40, 40, 43, 43, 46, 46, 46, 46, 45, 45, 46, 46, 48, 48, 50, 50, 52, 52, 54, 54, 57, 57, 59, 59, 60, + 37, 38, 38, 40, 40, 43, 43, 47, 47, 47, 47, 48, 48, 47, 47, 46, 46, 46, 46, 47, 47, 49, 49, 50, 50, 52, 52, 55, 55, 56, 56, 57, + 37, 38, 38, 40, 40, 43, 43, 47, 47, 47, 47, 48, 48, 47, 47, 46, 46, 46, 46, 47, 47, 49, 49, 50, 50, 52, 52, 55, 55, 56, 56, 57, + 48, 47, 47, 46, 46, 47, 47, 47, 47, 50, 50, 53, 53, 53, 53, 53, 53, 54, 54, 54, 54, 55, 55, 56, 56, 58, 58, 60, 60, 61, 61, 63, + 48, 47, 47, 46, 46, 47, 47, 47, 47, 50, 50, 53, 53, 53, 53, 53, 53, 54, 54, 54, 54, 55, 55, 56, 56, 58, 58, 60, 60, 61, 61, 63, + 49, 47, 47, 45, 45, 46, 46, 45, 45, 49, 49, 53, 53, 56, 56, 58, 58, 59, 59, 61, 61, 62, 62, 64, 64, 65, 65, 67, 67, 68, 68, 69, + 49, 47, 47, 45, 45, 46, 46, 45, 45, 49, 49, 53, 53, 56, 56, 58, 58, 59, 59, 61, 61, 62, 62, 64, 64, 65, 65, 67, 67, 68, 68, 69, + 52, 50, 50, 48, 48, 47, 47, 47, 47, 50, 50, 54, 54, 57, 57, 61, 61, 64, 64, 66, 66, 68, 68, 70, 70, 72, 72, 75, 75, 75, 75, 77, + 52, 50, 50, 48, 48, 47, 47, 47, 47, 50, 50, 54, 54, 57, 57, 61, 61, 64, 64, 66, 66, 68, 68, 70, 70, 72, 72, 75, 75, 75, 75, 77, + 57, 54, 54, 52, 52, 51, 51, 50, 50, 53, 53, 57, 57, 60, 60, 64, 64, 67, 67, 71, 71, 73, 73, 76, 76, 79, 79, 82, 82, 83, 83, 84, + 57, 54, 54, 52, 52, 51, 51, 50, 50, 53, 53, 57, 57, 60, 60, 64, 64, 67, 67, 71, 71, 73, 73, 76, 76, 79, 79, 82, 82, 83, 83, 84, + 63, 60, 60, 57, 57, 56, 56, 54, 54, 57, 57, 60, 60, 64, 64, 67, 67, 71, 71, 75, 75, 78, 78, 82, 82, 85, 85, 89, 89, 90, 90, 92, + 63, 60, 60, 57, 57, 56, 56, 54, 54, 57, 57, 60, 60, 64, 64, 67, 67, 71, 71, 75, 75, 78, 78, 82, 82, 85, 85, 89, 89, 90, 90, 92, + 66, 63, 63, 60, 60, 59, 59, 57, 57, 60, 60, 62, 62, 66, 66, 69, 69, 73, 73, 77, 77, 80, 80, 84, 84, 88, 88, 92, 92, 93, 93, 95, + }, + }, { + { + 32, 31, 31, 31, 31, 31, 32, 32, 32, 32, 34, 34, 35, 36, 38, 39, 41, 44, 44, 48, 48, 53, 53, 57, 58, 61, 65, 67, 71, 72, 79, 79, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 33, 34, 34, 34, 35, 36, 38, 39, 41, 42, 45, 45, 49, 50, 53, 54, 57, 60, 62, 66, 66, 73, 73, + 31, 32, 32, 32, 32, 32, 32, 32, 33, 33, 34, 34, 34, 34, 36, 37, 39, 41, 42, 45, 45, 49, 49, 52, 54, 57, 60, 61, 65, 66, 72, 72, + 32, 32, 32, 32, 32, 33, 33, 34, 34, 34, 36, 36, 37, 37, 38, 40, 41, 42, 43, 46, 46, 49, 50, 52, 54, 56, 59, 60, 64, 64, 71, 71, + 32, 32, 32, 32, 33, 33, 34, 34, 35, 35, 37, 37, 38, 38, 40, 40, 41, 43, 43, 46, 46, 49, 50, 52, 54, 56, 58, 60, 63, 64, 70, 70, + 34, 34, 34, 33, 33, 34, 35, 35, 37, 37, 39, 39, 42, 43, 44, 45, 46, 48, 48, 51, 51, 54, 54, 57, 58, 60, 63, 64, 68, 68, 74, 74, + 36, 35, 35, 35, 34, 35, 36, 37, 38, 39, 42, 42, 47, 48, 49, 50, 51, 53, 54, 56, 56, 59, 60, 62, 63, 66, 68, 69, 73, 73, 79, 79, + 38, 37, 37, 36, 36, 37, 38, 38, 39, 40, 44, 44, 48, 49, 51, 52, 54, 56, 56, 59, 59, 62, 63, 65, 67, 69, 71, 72, 76, 76, 82, 82, + 44, 42, 42, 41, 41, 41, 42, 42, 42, 43, 48, 48, 52, 54, 56, 58, 60, 63, 64, 67, 67, 71, 71, 74, 75, 77, 79, 81, 84, 85, 90, 90, + 44, 43, 43, 42, 41, 42, 43, 43, 43, 44, 48, 48, 53, 54, 57, 58, 60, 64, 64, 67, 67, 71, 72, 75, 76, 78, 80, 82, 85, 86, 91, 91, + 53, 51, 51, 50, 49, 49, 50, 49, 49, 50, 54, 54, 59, 60, 63, 65, 67, 71, 72, 76, 76, 81, 82, 85, 87, 89, 92, 94, 97, 98, 104, 104, + 53, 51, 51, 50, 49, 49, 50, 49, 49, 50, 54, 54, 59, 60, 63, 65, 67, 71, 72, 76, 76, 81, 82, 85, 87, 89, 92, 94, 97, 98, 104, 104, + 62, 60, 59, 58, 57, 57, 57, 56, 56, 56, 61, 61, 65, 66, 69, 71, 74, 78, 79, 83, 83, 89, 90, 94, 95, 98, 102, 103, 108, 108, 115, 115, + 65, 62, 62, 60, 59, 59, 59, 59, 58, 58, 63, 63, 67, 68, 71, 73, 76, 79, 81, 85, 85, 91, 92, 96, 98, 101, 105, 106, 111, 111, 118, 118, + 73, 70, 69, 67, 66, 66, 65, 65, 64, 64, 69, 69, 73, 74, 77, 79, 81, 85, 86, 91, 91, 98, 99, 103, 105, 108, 112, 114, 119, 119, 127, 127, + 79, 75, 75, 73, 72, 71, 71, 70, 69, 69, 73, 73, 77, 78, 81, 84, 86, 90, 91, 96, 96, 103, 103, 108, 110, 114, 118, 120, 125, 125, 133, 133, + }, { + 32, 31, 31, 30, 30, 32, 33, 34, 37, 37, 42, 42, 47, 49, 48, 48, 48, 49, 49, 50, 50, 52, 52, 53, 54, 55, 57, 58, 60, 60, 63, 63, + 31, 31, 31, 32, 32, 33, 35, 37, 40, 40, 43, 43, 46, 47, 46, 46, 46, 45, 46, 47, 47, 48, 48, 50, 50, 51, 52, 53, 55, 55, 58, 58, + 31, 31, 31, 32, 32, 34, 36, 37, 40, 40, 43, 43, 46, 46, 46, 46, 45, 45, 45, 46, 46, 48, 48, 49, 50, 51, 52, 53, 54, 55, 57, 57, + 35, 36, 36, 37, 37, 39, 40, 42, 45, 45, 46, 46, 47, 47, 47, 46, 46, 45, 46, 46, 46, 47, 47, 48, 49, 50, 51, 51, 53, 53, 56, 56, + 37, 38, 38, 39, 40, 41, 43, 44, 47, 47, 47, 47, 48, 48, 47, 47, 46, 46, 46, 46, 46, 47, 47, 48, 49, 49, 50, 51, 52, 53, 55, 55, + 42, 42, 42, 42, 42, 44, 45, 45, 47, 47, 48, 48, 50, 50, 50, 50, 49, 49, 49, 50, 50, 50, 50, 51, 52, 52, 53, 54, 55, 55, 58, 58, + 48, 47, 47, 46, 46, 46, 47, 47, 47, 48, 50, 50, 52, 53, 53, 53, 53, 53, 53, 54, 54, 54, 54, 55, 55, 56, 56, 57, 58, 59, 60, 60, + 48, 47, 47, 46, 46, 46, 46, 47, 47, 47, 50, 50, 52, 53, 53, 54, 54, 55, 55, 55, 55, 56, 56, 57, 57, 58, 58, 59, 60, 60, 62, 62, + 49, 47, 47, 46, 45, 45, 46, 45, 45, 46, 49, 49, 53, 53, 55, 56, 57, 58, 58, 59, 59, 61, 61, 62, 62, 63, 64, 64, 65, 65, 67, 67, + 49, 47, 47, 46, 45, 45, 46, 46, 46, 46, 49, 49, 53, 54, 55, 56, 57, 59, 59, 60, 60, 61, 61, 62, 63, 63, 64, 65, 66, 66, 68, 68, + 52, 50, 50, 48, 48, 48, 47, 47, 47, 47, 50, 50, 53, 54, 56, 57, 59, 61, 62, 64, 64, 66, 66, 68, 68, 69, 70, 71, 72, 73, 75, 75, + 52, 50, 50, 48, 48, 48, 47, 47, 47, 47, 50, 50, 53, 54, 56, 57, 59, 61, 62, 64, 64, 66, 66, 68, 68, 69, 70, 71, 72, 73, 75, 75, + 56, 54, 53, 52, 51, 51, 50, 50, 49, 49, 53, 53, 55, 56, 58, 59, 61, 63, 64, 66, 66, 69, 70, 71, 72, 74, 75, 76, 77, 78, 80, 80, + 57, 54, 54, 52, 52, 51, 51, 51, 50, 50, 53, 53, 56, 57, 58, 60, 61, 64, 64, 67, 67, 70, 71, 72, 73, 75, 76, 77, 79, 79, 82, 82, + 61, 58, 57, 56, 55, 54, 54, 53, 52, 53, 56, 56, 58, 59, 61, 62, 63, 66, 66, 69, 69, 72, 73, 75, 76, 78, 79, 80, 82, 83, 86, 86, + 63, 60, 60, 58, 57, 57, 56, 55, 54, 55, 57, 57, 60, 60, 62, 64, 65, 67, 68, 71, 71, 74, 75, 77, 78, 80, 82, 83, 85, 85, 89, 89, + }, + }, { + { + 32, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 33, 34, 34, 36, 36, 38, 39, 41, 44, 44, 47, 48, 50, 53, 53, 57, 58, 61, 65, 65, 70, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 34, 34, 35, 35, 37, 38, 39, 41, 41, 44, 45, 47, 50, 50, 54, 55, 57, 61, 61, 65, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 34, 34, 34, 34, 37, 37, 39, 41, 41, 44, 45, 46, 49, 49, 53, 54, 56, 60, 60, 64, + 31, 32, 32, 32, 32, 32, 33, 33, 33, 34, 34, 35, 35, 35, 36, 36, 38, 39, 40, 42, 42, 44, 45, 47, 50, 50, 53, 54, 56, 59, 59, 63, + 32, 32, 32, 32, 33, 33, 34, 34, 34, 35, 35, 36, 37, 37, 38, 38, 40, 40, 41, 43, 43, 45, 46, 47, 50, 50, 53, 54, 56, 58, 58, 62, + 32, 32, 32, 32, 33, 33, 34, 34, 34, 35, 35, 36, 37, 37, 38, 38, 40, 40, 41, 43, 43, 45, 46, 47, 50, 50, 53, 54, 56, 58, 58, 62, + 35, 35, 35, 34, 34, 34, 35, 36, 36, 37, 37, 40, 41, 43, 46, 46, 47, 48, 49, 51, 51, 53, 54, 55, 57, 57, 60, 61, 63, 66, 66, 70, + 36, 35, 35, 35, 34, 34, 36, 36, 37, 38, 38, 41, 42, 44, 48, 48, 50, 50, 51, 53, 53, 56, 56, 58, 60, 60, 63, 63, 65, 68, 68, 72, + 39, 38, 38, 37, 37, 37, 38, 38, 39, 40, 40, 43, 44, 46, 50, 50, 52, 53, 54, 57, 57, 59, 60, 61, 64, 64, 67, 68, 69, 72, 72, 76, + 44, 42, 42, 41, 41, 41, 42, 42, 42, 42, 42, 46, 48, 50, 54, 54, 57, 58, 60, 63, 63, 66, 67, 68, 71, 71, 74, 75, 77, 79, 79, 83, + 44, 42, 42, 41, 41, 41, 42, 42, 42, 42, 42, 46, 48, 50, 54, 54, 57, 58, 60, 63, 63, 66, 67, 68, 71, 71, 74, 75, 77, 79, 79, 83, + 51, 49, 49, 48, 47, 47, 48, 48, 48, 48, 48, 52, 53, 55, 58, 58, 62, 63, 66, 69, 69, 73, 74, 76, 79, 79, 83, 84, 86, 89, 89, 93, + 53, 52, 51, 50, 49, 49, 49, 50, 49, 49, 49, 53, 54, 56, 60, 60, 64, 65, 67, 71, 71, 75, 76, 78, 82, 82, 86, 87, 89, 92, 92, 96, + 58, 56, 55, 54, 53, 53, 53, 53, 53, 52, 52, 56, 57, 59, 63, 63, 67, 68, 70, 74, 74, 78, 79, 82, 86, 86, 90, 91, 93, 97, 97, 101, + 65, 63, 62, 61, 59, 59, 59, 59, 58, 58, 58, 62, 63, 65, 68, 68, 72, 73, 76, 79, 79, 84, 85, 88, 92, 92, 97, 98, 100, 105, 105, 109, + 65, 63, 62, 61, 59, 59, 59, 59, 58, 58, 58, 62, 63, 65, 68, 68, 72, 73, 76, 79, 79, 84, 85, 88, 92, 92, 97, 98, 100, 105, 105, 109, + }, { + 32, 31, 31, 31, 30, 30, 33, 33, 35, 37, 37, 41, 42, 44, 49, 49, 48, 48, 48, 49, 49, 50, 50, 51, 52, 52, 54, 54, 55, 57, 57, 59, + 31, 31, 31, 31, 32, 32, 34, 35, 37, 39, 39, 42, 42, 44, 47, 47, 46, 46, 46, 46, 46, 47, 47, 48, 48, 48, 50, 51, 51, 53, 53, 55, + 31, 31, 31, 32, 32, 32, 35, 36, 37, 40, 40, 42, 43, 44, 46, 46, 46, 46, 45, 45, 45, 46, 46, 47, 48, 48, 49, 50, 51, 52, 52, 54, + 33, 34, 34, 34, 35, 35, 37, 38, 40, 43, 43, 44, 44, 45, 47, 47, 46, 46, 46, 45, 45, 46, 46, 47, 47, 47, 49, 49, 50, 51, 51, 53, + 37, 38, 38, 39, 40, 40, 42, 43, 44, 47, 47, 47, 47, 47, 48, 48, 47, 47, 46, 46, 46, 46, 46, 47, 47, 47, 48, 49, 49, 50, 50, 52, + 37, 38, 38, 39, 40, 40, 42, 43, 44, 47, 47, 47, 47, 47, 48, 48, 47, 47, 46, 46, 46, 46, 46, 47, 47, 47, 48, 49, 49, 50, 50, 52, + 45, 45, 45, 45, 44, 44, 46, 46, 46, 47, 47, 49, 49, 50, 52, 52, 51, 51, 51, 51, 51, 52, 52, 52, 53, 53, 54, 54, 54, 55, 55, 57, + 48, 47, 47, 46, 46, 46, 47, 47, 47, 47, 47, 49, 50, 51, 53, 53, 53, 53, 53, 53, 53, 54, 54, 54, 54, 54, 55, 55, 56, 56, 56, 58, + 48, 47, 47, 46, 45, 45, 46, 46, 46, 47, 47, 49, 50, 51, 53, 53, 54, 54, 54, 55, 55, 56, 56, 56, 57, 57, 58, 58, 58, 59, 59, 61, + 49, 47, 47, 46, 45, 45, 45, 46, 45, 45, 45, 48, 49, 51, 53, 53, 55, 56, 57, 58, 58, 59, 59, 60, 61, 61, 62, 62, 63, 64, 64, 65, + 49, 47, 47, 46, 45, 45, 45, 46, 45, 45, 45, 48, 49, 51, 53, 53, 55, 56, 57, 58, 58, 59, 59, 60, 61, 61, 62, 62, 63, 64, 64, 65, + 51, 50, 49, 48, 47, 47, 47, 47, 47, 46, 46, 49, 50, 52, 54, 54, 56, 57, 58, 61, 61, 62, 63, 64, 65, 65, 67, 67, 68, 69, 69, 70, + 52, 50, 50, 49, 48, 48, 47, 47, 47, 47, 47, 50, 50, 52, 54, 54, 57, 57, 59, 61, 61, 63, 64, 65, 66, 66, 68, 68, 69, 70, 70, 72, + 54, 52, 51, 51, 49, 49, 49, 49, 48, 48, 48, 51, 51, 53, 55, 55, 58, 58, 60, 62, 62, 64, 65, 66, 68, 68, 70, 70, 71, 73, 73, 74, + 57, 55, 54, 53, 52, 52, 51, 51, 51, 50, 50, 52, 53, 54, 57, 57, 59, 60, 61, 64, 64, 66, 67, 68, 71, 71, 73, 73, 74, 76, 76, 78, + 57, 55, 54, 53, 52, 52, 51, 51, 51, 50, 50, 52, 53, 54, 57, 57, 59, 60, 61, 64, 64, 66, 67, 68, 71, 71, 73, 73, 74, 76, 76, 78, + }, + }, { + { + 32, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 34, 34, 35, 36, 36, 38, 39, 39, 42, 44, 44, 47, 48, 49, 53, 53, 55, 58, 58, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 34, 34, 34, 35, 35, 37, 38, 38, 40, 42, 42, 45, 46, 47, 50, 51, 52, 55, 55, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 34, 34, 34, 34, 34, 36, 37, 37, 40, 41, 41, 44, 45, 46, 49, 49, 51, 54, 54, + 31, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 34, 34, 34, 35, 35, 37, 38, 38, 40, 41, 41, 44, 45, 46, 49, 49, 51, 54, 54, + 32, 32, 32, 32, 32, 32, 33, 33, 34, 34, 35, 35, 35, 36, 36, 37, 37, 37, 39, 40, 40, 42, 42, 43, 45, 46, 47, 49, 50, 51, 54, 54, + 32, 32, 32, 32, 32, 33, 33, 34, 34, 34, 35, 35, 36, 37, 37, 37, 38, 38, 40, 40, 40, 42, 43, 43, 45, 46, 47, 49, 50, 51, 54, 54, + 32, 33, 33, 33, 33, 33, 33, 34, 34, 35, 36, 36, 36, 38, 38, 39, 40, 40, 41, 42, 42, 44, 45, 45, 47, 48, 48, 51, 51, 53, 55, 55, + 35, 35, 35, 35, 34, 34, 35, 36, 36, 37, 38, 38, 39, 42, 42, 44, 47, 47, 48, 49, 49, 51, 52, 52, 54, 55, 56, 58, 59, 60, 62, 62, + 36, 35, 35, 35, 35, 34, 35, 36, 36, 37, 38, 38, 40, 42, 42, 45, 48, 48, 49, 50, 50, 52, 53, 54, 56, 56, 57, 59, 60, 61, 63, 63, + 38, 37, 37, 37, 36, 36, 36, 38, 38, 38, 39, 39, 41, 44, 44, 46, 49, 49, 51, 52, 52, 55, 56, 56, 58, 59, 60, 62, 63, 64, 67, 67, + 44, 43, 42, 42, 41, 41, 41, 42, 42, 42, 42, 42, 44, 48, 48, 50, 54, 54, 56, 58, 58, 61, 63, 63, 66, 67, 67, 71, 71, 72, 75, 75, + 44, 43, 42, 42, 41, 41, 41, 42, 42, 42, 42, 42, 44, 48, 48, 50, 54, 54, 56, 58, 58, 61, 63, 63, 66, 67, 67, 71, 71, 72, 75, 75, + 47, 46, 45, 45, 44, 44, 44, 45, 45, 45, 45, 45, 47, 50, 50, 53, 56, 56, 58, 60, 60, 64, 66, 66, 69, 70, 71, 74, 75, 76, 79, 79, + 53, 52, 51, 51, 49, 49, 49, 49, 50, 49, 49, 49, 51, 54, 54, 57, 60, 60, 63, 65, 65, 69, 71, 72, 75, 76, 77, 81, 82, 83, 87, 87, + 53, 52, 51, 51, 49, 49, 49, 49, 50, 49, 49, 49, 51, 54, 54, 57, 60, 60, 63, 65, 65, 69, 71, 72, 75, 76, 77, 81, 82, 83, 87, 87, + 59, 57, 56, 56, 54, 54, 54, 54, 54, 54, 53, 53, 55, 58, 58, 61, 64, 64, 67, 69, 69, 73, 75, 76, 79, 80, 81, 86, 87, 88, 92, 92, + }, { + 32, 31, 31, 31, 30, 30, 31, 33, 33, 34, 37, 37, 39, 42, 42, 45, 49, 49, 48, 48, 48, 49, 49, 49, 50, 50, 51, 52, 52, 53, 54, 54, + 31, 31, 31, 31, 31, 31, 32, 35, 35, 36, 39, 39, 40, 42, 42, 45, 47, 47, 47, 46, 46, 46, 46, 46, 47, 48, 48, 49, 49, 50, 51, 51, + 31, 31, 31, 31, 32, 32, 33, 35, 36, 37, 40, 40, 41, 43, 43, 44, 46, 46, 46, 46, 46, 45, 45, 45, 46, 46, 47, 48, 48, 48, 50, 50, + 31, 32, 32, 32, 32, 33, 33, 36, 36, 37, 41, 41, 42, 43, 43, 45, 47, 47, 46, 46, 46, 45, 45, 45, 46, 46, 47, 48, 48, 48, 50, 50, + 35, 36, 37, 37, 38, 38, 38, 41, 41, 42, 45, 45, 46, 46, 46, 47, 48, 48, 47, 46, 46, 46, 45, 46, 46, 46, 47, 47, 47, 48, 49, 49, + 37, 38, 38, 38, 39, 40, 40, 43, 43, 44, 47, 47, 47, 47, 47, 47, 48, 48, 47, 47, 47, 46, 46, 46, 46, 46, 47, 47, 47, 48, 49, 49, + 38, 39, 40, 40, 40, 41, 41, 43, 44, 45, 47, 47, 47, 48, 48, 48, 49, 49, 48, 48, 48, 47, 47, 47, 48, 48, 48, 48, 48, 49, 50, 50, + 47, 46, 46, 46, 45, 45, 45, 46, 46, 47, 47, 47, 48, 50, 50, 51, 52, 52, 52, 52, 52, 52, 52, 52, 53, 53, 53, 53, 53, 54, 55, 55, + 48, 47, 47, 47, 46, 46, 46, 47, 47, 47, 47, 47, 48, 50, 50, 51, 53, 53, 53, 53, 53, 53, 53, 53, 54, 54, 54, 54, 54, 54, 55, 55, + 48, 47, 47, 47, 46, 46, 46, 46, 46, 47, 47, 47, 48, 50, 50, 51, 53, 53, 53, 54, 54, 54, 55, 55, 55, 55, 55, 56, 56, 56, 57, 57, + 49, 48, 47, 47, 45, 45, 45, 45, 46, 45, 45, 45, 47, 49, 49, 51, 53, 53, 55, 56, 56, 57, 58, 58, 59, 59, 60, 61, 61, 61, 62, 62, + 49, 48, 47, 47, 45, 45, 45, 45, 46, 45, 45, 45, 47, 49, 49, 51, 53, 53, 55, 56, 56, 57, 58, 58, 59, 59, 60, 61, 61, 61, 62, 62, + 50, 49, 48, 48, 46, 46, 46, 46, 46, 46, 46, 46, 47, 50, 50, 52, 54, 54, 55, 56, 56, 58, 59, 60, 61, 61, 61, 63, 63, 63, 65, 65, + 52, 50, 50, 50, 48, 48, 48, 47, 47, 47, 47, 47, 48, 50, 50, 52, 54, 54, 56, 57, 57, 60, 61, 61, 63, 64, 64, 66, 66, 67, 68, 68, + 52, 50, 50, 50, 48, 48, 48, 47, 47, 47, 47, 47, 48, 50, 50, 52, 54, 54, 56, 57, 57, 60, 61, 61, 63, 64, 64, 66, 66, 67, 68, 68, + 54, 53, 52, 52, 50, 50, 50, 49, 49, 49, 48, 48, 50, 52, 52, 54, 55, 55, 57, 59, 59, 61, 62, 63, 65, 65, 66, 68, 68, 69, 71, 71, + }, + }, { + { + 32, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 34, 34, 34, 35, 36, 36, 38, 39, 39, 41, 44, 44, 44, 47, 48, 48, 51, + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 34, 34, 34, 35, 35, 35, 37, 38, 38, 40, 42, 42, 43, 45, 46, 46, 49, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 34, 34, 34, 34, 34, 34, 36, 37, 37, 39, 41, 41, 42, 44, 45, 45, 47, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 34, 34, 34, 34, 34, 34, 36, 37, 37, 39, 41, 41, 42, 44, 45, 45, 47, + 31, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 34, 34, 34, 35, 35, 35, 36, 36, 36, 37, 39, 39, 40, 42, 42, 42, 44, 45, 45, 48, + 32, 32, 32, 32, 32, 33, 33, 33, 34, 34, 34, 35, 35, 35, 36, 37, 37, 37, 38, 38, 38, 40, 40, 40, 41, 43, 43, 43, 45, 46, 46, 48, + 32, 32, 32, 32, 32, 33, 33, 33, 34, 34, 34, 35, 35, 35, 36, 37, 37, 37, 38, 38, 38, 40, 40, 40, 41, 43, 43, 43, 45, 46, 46, 48, + 32, 33, 33, 33, 33, 33, 33, 33, 34, 34, 34, 35, 36, 36, 36, 38, 38, 38, 39, 40, 40, 41, 42, 42, 43, 45, 45, 45, 47, 48, 48, 50, + 35, 35, 35, 35, 34, 34, 34, 34, 35, 36, 36, 37, 37, 37, 39, 41, 41, 42, 45, 46, 46, 47, 48, 48, 49, 51, 51, 51, 53, 54, 54, 56, + 36, 35, 35, 35, 35, 34, 34, 35, 36, 36, 36, 37, 38, 38, 40, 42, 42, 43, 47, 48, 48, 49, 50, 50, 51, 53, 53, 54, 56, 56, 56, 58, + 36, 35, 35, 35, 35, 34, 34, 35, 36, 36, 36, 37, 38, 38, 40, 42, 42, 43, 47, 48, 48, 49, 50, 50, 51, 53, 53, 54, 56, 56, 56, 58, + 40, 39, 39, 39, 39, 38, 38, 38, 39, 39, 39, 40, 41, 41, 42, 45, 45, 46, 50, 51, 51, 53, 54, 54, 56, 59, 59, 59, 61, 62, 62, 64, + 44, 43, 42, 42, 41, 41, 41, 41, 42, 42, 42, 42, 42, 42, 44, 48, 48, 49, 52, 54, 54, 56, 58, 58, 60, 63, 63, 64, 66, 67, 67, 69, + 44, 43, 42, 42, 41, 41, 41, 41, 42, 42, 42, 42, 42, 42, 44, 48, 48, 49, 52, 54, 54, 56, 58, 58, 60, 63, 63, 64, 66, 67, 67, 69, + 47, 46, 45, 45, 45, 44, 44, 44, 44, 45, 45, 45, 45, 45, 47, 50, 50, 51, 55, 56, 56, 58, 60, 60, 62, 66, 66, 67, 69, 70, 70, 73, + 53, 52, 51, 51, 50, 49, 49, 49, 49, 50, 50, 49, 49, 49, 51, 54, 54, 55, 59, 60, 60, 63, 65, 65, 67, 71, 71, 72, 75, 76, 76, 79, + }, { + 32, 31, 31, 31, 31, 30, 30, 31, 33, 33, 33, 35, 37, 37, 39, 42, 42, 43, 47, 49, 49, 48, 48, 48, 48, 49, 49, 49, 50, 50, 50, 51, + 31, 31, 31, 31, 31, 31, 31, 32, 34, 35, 35, 37, 39, 39, 40, 42, 42, 43, 46, 47, 47, 47, 47, 47, 47, 46, 46, 47, 48, 48, 48, 49, + 31, 31, 31, 31, 32, 32, 32, 33, 35, 36, 36, 38, 40, 40, 41, 43, 43, 43, 46, 46, 46, 46, 46, 46, 45, 45, 45, 45, 46, 46, 46, 47, + 31, 31, 31, 31, 32, 32, 32, 33, 35, 36, 36, 38, 40, 40, 41, 43, 43, 43, 46, 46, 46, 46, 46, 46, 45, 45, 45, 45, 46, 46, 46, 47, + 33, 33, 34, 34, 34, 35, 35, 35, 37, 38, 38, 41, 43, 43, 43, 44, 44, 45, 46, 47, 47, 46, 46, 46, 46, 45, 45, 45, 46, 46, 46, 47, + 37, 38, 38, 38, 39, 40, 40, 40, 42, 43, 43, 45, 47, 47, 47, 47, 47, 47, 48, 48, 48, 47, 47, 47, 46, 46, 46, 46, 46, 46, 46, 47, + 37, 38, 38, 38, 39, 40, 40, 40, 42, 43, 43, 45, 47, 47, 47, 47, 47, 47, 48, 48, 48, 47, 47, 47, 46, 46, 46, 46, 46, 46, 46, 47, + 38, 39, 40, 40, 40, 41, 41, 41, 43, 44, 44, 46, 47, 47, 47, 48, 48, 48, 48, 49, 49, 48, 48, 48, 47, 47, 47, 47, 48, 48, 48, 48, + 45, 45, 45, 45, 45, 44, 44, 45, 46, 46, 46, 47, 47, 47, 48, 49, 49, 50, 51, 52, 52, 52, 51, 51, 51, 51, 51, 52, 52, 52, 52, 52, + 48, 47, 47, 47, 46, 46, 46, 46, 47, 47, 47, 47, 47, 47, 48, 50, 50, 50, 52, 53, 53, 53, 53, 53, 53, 53, 53, 53, 54, 54, 54, 54, + 48, 47, 47, 47, 46, 46, 46, 46, 47, 47, 47, 47, 47, 47, 48, 50, 50, 50, 52, 53, 53, 53, 53, 53, 53, 53, 53, 53, 54, 54, 54, 54, + 49, 48, 47, 47, 46, 45, 45, 45, 46, 46, 46, 46, 46, 46, 47, 49, 49, 50, 52, 53, 53, 54, 54, 54, 55, 56, 56, 56, 57, 57, 57, 58, + 49, 48, 47, 47, 46, 45, 45, 45, 45, 46, 46, 45, 45, 45, 47, 49, 49, 50, 53, 53, 53, 55, 56, 56, 57, 58, 58, 58, 59, 59, 59, 60, + 49, 48, 47, 47, 46, 45, 45, 45, 45, 46, 46, 45, 45, 45, 47, 49, 49, 50, 53, 53, 53, 55, 56, 56, 57, 58, 58, 58, 59, 59, 59, 60, + 50, 49, 48, 48, 47, 46, 46, 46, 46, 46, 46, 46, 46, 46, 47, 50, 50, 50, 53, 54, 54, 55, 56, 56, 57, 59, 59, 60, 61, 61, 61, 62, + 52, 51, 50, 50, 49, 48, 48, 48, 47, 47, 47, 47, 47, 47, 48, 50, 50, 51, 53, 54, 54, 56, 57, 57, 59, 61, 61, 62, 63, 64, 64, 65, + }, + }, { + { + 32, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 33, 34, 34, 34, 35, 36, 36, 36, 37, 39, 39, 39, 41, 44, 44, + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 34, 34, 34, 34, 35, 35, 35, 37, 38, 38, 38, 40, 42, 42, + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 34, 36, 37, 37, 37, 39, 41, 41, + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 34, 36, 37, 37, 37, 39, 41, 41, + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 34, 36, 37, 37, 37, 39, 41, 41, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 34, 34, 34, 34, 35, 35, 35, 36, 36, 36, 36, 38, 39, 39, 39, 40, 42, 42, + 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 34, 34, 34, 34, 35, 35, 35, 36, 37, 37, 37, 37, 38, 38, 38, 39, 40, 40, 40, 42, 43, 43, + 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 34, 34, 34, 34, 35, 35, 35, 36, 37, 37, 37, 37, 38, 38, 38, 39, 40, 40, 40, 42, 43, 43, + 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 34, 34, 34, 34, 35, 35, 35, 36, 37, 37, 37, 37, 38, 38, 38, 39, 40, 40, 40, 42, 43, 43, + 34, 34, 34, 34, 34, 34, 33, 33, 33, 34, 35, 35, 35, 36, 37, 37, 37, 38, 39, 39, 39, 41, 43, 43, 43, 44, 45, 45, 45, 46, 48, 48, + 36, 35, 35, 35, 35, 35, 34, 34, 34, 35, 36, 36, 36, 37, 38, 38, 38, 40, 42, 42, 42, 45, 48, 48, 48, 49, 50, 50, 50, 52, 53, 53, + 36, 35, 35, 35, 35, 35, 34, 34, 34, 35, 36, 36, 36, 37, 38, 38, 38, 40, 42, 42, 42, 45, 48, 48, 48, 49, 50, 50, 50, 52, 53, 53, + 36, 35, 35, 35, 35, 35, 34, 34, 34, 35, 36, 36, 36, 37, 38, 38, 38, 40, 42, 42, 42, 45, 48, 48, 48, 49, 50, 50, 50, 52, 53, 53, + 39, 39, 38, 38, 38, 38, 37, 37, 37, 38, 39, 39, 39, 40, 40, 40, 40, 42, 45, 45, 45, 47, 51, 51, 51, 52, 54, 54, 54, 56, 58, 58, + 44, 43, 42, 42, 42, 41, 41, 41, 41, 41, 42, 42, 42, 42, 42, 42, 42, 45, 48, 48, 48, 50, 54, 54, 54, 56, 58, 58, 58, 60, 63, 63, + 44, 43, 42, 42, 42, 41, 41, 41, 41, 41, 42, 42, 42, 42, 42, 42, 42, 45, 48, 48, 48, 50, 54, 54, 54, 56, 58, 58, 58, 60, 63, 63, + }, { + 32, 31, 31, 31, 31, 31, 30, 30, 30, 32, 33, 33, 33, 35, 37, 37, 37, 39, 42, 42, 42, 45, 49, 49, 49, 48, 48, 48, 48, 48, 49, 49, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 33, 34, 34, 34, 36, 38, 38, 38, 40, 42, 42, 42, 45, 48, 48, 48, 47, 47, 47, 47, 47, 47, 47, + 31, 31, 31, 31, 31, 32, 32, 32, 32, 34, 36, 36, 36, 38, 40, 40, 40, 41, 43, 43, 43, 44, 46, 46, 46, 46, 46, 46, 46, 45, 45, 45, + 31, 31, 31, 31, 31, 32, 32, 32, 32, 34, 36, 36, 36, 38, 40, 40, 40, 41, 43, 43, 43, 44, 46, 46, 46, 46, 46, 46, 46, 45, 45, 45, + 31, 31, 31, 31, 31, 32, 32, 32, 32, 34, 36, 36, 36, 38, 40, 40, 40, 41, 43, 43, 43, 44, 46, 46, 46, 46, 46, 46, 46, 45, 45, 45, + 33, 34, 34, 34, 34, 35, 35, 35, 35, 37, 39, 39, 39, 41, 43, 43, 43, 44, 45, 45, 45, 46, 47, 47, 47, 47, 46, 46, 46, 46, 45, 45, + 37, 37, 38, 38, 38, 39, 40, 40, 40, 41, 43, 43, 43, 45, 47, 47, 47, 47, 47, 47, 47, 47, 48, 48, 48, 47, 47, 47, 47, 46, 46, 46, + 37, 37, 38, 38, 38, 39, 40, 40, 40, 41, 43, 43, 43, 45, 47, 47, 47, 47, 47, 47, 47, 47, 48, 48, 48, 47, 47, 47, 47, 46, 46, 46, + 37, 37, 38, 38, 38, 39, 40, 40, 40, 41, 43, 43, 43, 45, 47, 47, 47, 47, 47, 47, 47, 47, 48, 48, 48, 47, 47, 47, 47, 46, 46, 46, + 42, 42, 42, 42, 42, 42, 42, 42, 42, 44, 45, 45, 45, 46, 47, 47, 47, 48, 48, 48, 48, 49, 50, 50, 50, 50, 50, 50, 50, 49, 49, 49, + 48, 47, 47, 47, 47, 46, 46, 46, 46, 46, 47, 47, 47, 47, 47, 47, 47, 49, 50, 50, 50, 51, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, + 48, 47, 47, 47, 47, 46, 46, 46, 46, 46, 47, 47, 47, 47, 47, 47, 47, 49, 50, 50, 50, 51, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, + 48, 47, 47, 47, 47, 46, 46, 46, 46, 46, 47, 47, 47, 47, 47, 47, 47, 49, 50, 50, 50, 51, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, + 48, 48, 47, 47, 47, 46, 45, 45, 45, 46, 46, 46, 46, 46, 46, 46, 46, 48, 50, 50, 50, 51, 53, 53, 53, 54, 54, 54, 54, 55, 56, 56, + 49, 48, 47, 47, 47, 46, 45, 45, 45, 45, 46, 46, 46, 45, 45, 45, 45, 47, 49, 49, 49, 51, 53, 53, 53, 54, 56, 56, 56, 57, 58, 58, + 49, 48, 47, 47, 47, 46, 45, 45, 45, 45, 46, 46, 46, 45, 45, 45, 45, 47, 49, 49, 49, 51, 53, 53, 53, 54, 56, 56, 56, 57, 58, 58, + }, + }, { + { + 32, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 34, 34, 34, 34, 35, 36, 36, 36, 37, + 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 34, 34, 34, 34, 35, 35, 35, 35, 36, + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 34, 34, 34, 34, 34, 35, 35, 35, 36, + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 34, 34, 36, + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 34, 34, 36, + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 34, 34, 36, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 33, 34, 34, 34, 34, 35, 35, 35, 35, 35, 36, 36, 36, 36, 37, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 34, 34, 34, 34, 34, 35, 35, 35, 35, 36, 36, 36, 36, 37, 37, 37, 37, 37, 38, + 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 34, 34, 34, 34, 34, 35, 35, 35, 35, 36, 36, 37, 37, 37, 37, 38, 38, 38, 38, 39, + 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 34, 34, 34, 34, 34, 35, 35, 35, 35, 36, 36, 37, 37, 37, 37, 38, 38, 38, 38, 39, + 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 34, 34, 34, 34, 34, 35, 35, 35, 35, 36, 36, 37, 37, 37, 37, 38, 38, 38, 38, 39, + 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 34, 34, 35, 35, 35, 35, 36, 36, 36, 36, 37, 38, 39, 39, 39, 40, 41, 42, 42, 42, 42, + 35, 35, 35, 35, 35, 35, 34, 34, 34, 34, 34, 35, 35, 36, 36, 36, 36, 37, 37, 37, 37, 39, 40, 41, 41, 41, 43, 45, 46, 46, 46, 46, + 36, 35, 35, 35, 35, 35, 35, 35, 34, 34, 34, 35, 36, 36, 36, 36, 37, 38, 38, 38, 38, 40, 41, 42, 42, 42, 44, 47, 48, 48, 48, 49, + 36, 35, 35, 35, 35, 35, 35, 35, 34, 34, 34, 35, 36, 36, 36, 36, 37, 38, 38, 38, 38, 40, 41, 42, 42, 42, 44, 47, 48, 48, 48, 49, + 36, 35, 35, 35, 35, 35, 35, 35, 34, 34, 34, 35, 36, 36, 36, 36, 37, 38, 38, 38, 38, 40, 41, 42, 42, 42, 44, 47, 48, 48, 48, 49, + }, { + 32, 31, 31, 31, 31, 31, 31, 30, 30, 30, 30, 31, 33, 33, 33, 33, 35, 36, 37, 37, 37, 39, 41, 42, 42, 42, 44, 47, 49, 49, 49, 49, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 34, 34, 34, 34, 36, 37, 38, 38, 38, 39, 41, 42, 42, 42, 44, 46, 48, 48, 48, 48, + 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 33, 34, 35, 35, 35, 37, 38, 39, 39, 39, 40, 42, 42, 42, 42, 44, 46, 47, 47, 47, 47, + 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 33, 35, 36, 36, 36, 37, 39, 40, 40, 40, 41, 42, 43, 43, 43, 44, 46, 46, 46, 46, 46, + 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 33, 35, 36, 36, 36, 37, 39, 40, 40, 40, 41, 42, 43, 43, 43, 44, 46, 46, 46, 46, 46, + 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 33, 35, 36, 36, 36, 37, 39, 40, 40, 40, 41, 42, 43, 43, 43, 44, 46, 46, 46, 46, 46, + 33, 33, 34, 34, 34, 34, 34, 34, 35, 35, 35, 36, 37, 38, 38, 38, 40, 42, 43, 43, 43, 43, 44, 44, 44, 44, 45, 46, 47, 47, 47, 47, + 35, 36, 36, 37, 37, 37, 37, 38, 38, 38, 38, 39, 40, 41, 41, 41, 43, 44, 45, 45, 45, 46, 46, 46, 46, 46, 47, 47, 48, 48, 48, 47, + 37, 37, 38, 38, 38, 38, 39, 39, 40, 40, 40, 41, 42, 43, 43, 43, 44, 46, 47, 47, 47, 47, 47, 47, 47, 47, 47, 48, 48, 48, 48, 47, + 37, 37, 38, 38, 38, 38, 39, 39, 40, 40, 40, 41, 42, 43, 43, 43, 44, 46, 47, 47, 47, 47, 47, 47, 47, 47, 47, 48, 48, 48, 48, 47, + 37, 37, 38, 38, 38, 38, 39, 39, 40, 40, 40, 41, 42, 43, 43, 43, 44, 46, 47, 47, 47, 47, 47, 47, 47, 47, 47, 48, 48, 48, 48, 47, + 40, 41, 41, 41, 41, 41, 41, 42, 42, 42, 42, 43, 44, 44, 44, 44, 45, 47, 47, 47, 47, 48, 48, 48, 48, 48, 49, 49, 50, 50, 50, 49, + 45, 45, 45, 45, 45, 45, 45, 44, 44, 44, 44, 45, 46, 46, 46, 46, 46, 47, 47, 47, 47, 48, 49, 49, 49, 49, 50, 51, 52, 52, 52, 52, + 48, 48, 47, 47, 47, 47, 46, 46, 46, 46, 46, 46, 47, 47, 47, 47, 47, 47, 47, 47, 47, 48, 49, 50, 50, 50, 51, 52, 53, 53, 53, 53, + 48, 48, 47, 47, 47, 47, 46, 46, 46, 46, 46, 46, 47, 47, 47, 47, 47, 47, 47, 47, 47, 48, 49, 50, 50, 50, 51, 52, 53, 53, 53, 53, + 48, 48, 47, 47, 47, 47, 46, 46, 46, 46, 46, 46, 47, 47, 47, 47, 47, 47, 47, 47, 47, 48, 49, 50, 50, 50, 51, 52, 53, 53, 53, 53, + }, + }, { + { + 32, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 34, 34, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 34, 34, + 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 34, 34, + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 34, 34, + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 33, 34, 34, + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 33, 34, 34, + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 33, 34, 34, + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 34, 34, 34, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 35, 35, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 34, 35, 35, 36, 36, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 35, 35, 35, 35, 35, 35, 36, 36, 37, 37, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 35, 35, 35, 35, 35, 35, 36, 36, 37, 37, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 35, 35, 35, 35, 35, 35, 36, 36, 37, 37, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 35, 35, 35, 35, 35, 35, 36, 36, 37, 37, + 32, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 35, 35, 36, 36, 36, 36, 36, 36, 37, 38, 38, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 33, 33, 33, 33, 33, 34, 34, 35, 35, 35, 35, 35, 35, 36, 36, 37, 37, 37, 37, 38, 38, 39, 39, + }, { + 32, 31, 31, 31, 31, 31, 31, 31, 31, 30, 30, 30, 30, 30, 31, 32, 33, 33, 33, 33, 33, 34, 35, 36, 37, 37, 37, 37, 39, 40, 42, 42, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 33, 34, 34, 34, 34, 35, 36, 37, 38, 38, 38, 38, 39, 41, 42, 42, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 33, 34, 35, 35, 35, 35, 36, 37, 38, 39, 39, 39, 39, 40, 41, 42, 42, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 33, 35, 35, 35, 35, 35, 37, 38, 39, 40, 40, 40, 40, 41, 42, 43, 43, + 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 33, 34, 35, 36, 36, 36, 36, 37, 38, 39, 40, 40, 40, 40, 41, 42, 43, 43, + 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 33, 34, 35, 36, 36, 36, 36, 37, 38, 39, 40, 40, 40, 40, 41, 42, 43, 43, + 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 33, 34, 35, 36, 36, 36, 36, 37, 38, 39, 40, 40, 40, 40, 41, 42, 43, 43, + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 34, 35, 36, 36, 36, 36, 37, 39, 40, 41, 41, 41, 41, 42, 42, 43, 43, + 33, 33, 33, 34, 34, 34, 34, 34, 34, 34, 35, 35, 35, 35, 35, 36, 37, 38, 38, 38, 38, 39, 41, 42, 43, 43, 43, 43, 43, 44, 44, 44, + 35, 35, 35, 36, 36, 36, 36, 36, 36, 37, 37, 37, 37, 37, 38, 39, 40, 40, 40, 40, 40, 42, 43, 44, 45, 45, 45, 45, 45, 45, 46, 46, + 37, 37, 38, 38, 38, 38, 38, 38, 39, 39, 40, 40, 40, 40, 40, 41, 42, 43, 43, 43, 43, 44, 45, 47, 47, 47, 47, 47, 47, 47, 47, 47, + 37, 37, 38, 38, 38, 38, 38, 38, 39, 39, 40, 40, 40, 40, 40, 41, 42, 43, 43, 43, 43, 44, 45, 47, 47, 47, 47, 47, 47, 47, 47, 47, + 37, 37, 38, 38, 38, 38, 38, 38, 39, 39, 40, 40, 40, 40, 40, 41, 42, 43, 43, 43, 43, 44, 45, 47, 47, 47, 47, 47, 47, 47, 47, 47, + 37, 37, 38, 38, 38, 38, 38, 38, 39, 39, 40, 40, 40, 40, 40, 41, 42, 43, 43, 43, 43, 44, 45, 47, 47, 47, 47, 47, 47, 47, 47, 47, + 38, 39, 39, 40, 40, 40, 40, 40, 40, 40, 41, 41, 41, 41, 41, 42, 43, 44, 44, 44, 44, 45, 46, 47, 47, 47, 47, 47, 47, 47, 48, 48, + 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 43, 44, 44, 45, 45, 45, 45, 45, 46, 47, 47, 47, 47, 47, 48, 48, 48, 48, + }, + }, { + { + 32, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 33, 33, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 34, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 34, 34, + }, { + 32, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 30, 30, 30, 30, 30, 30, 30, 31, 31, 32, 33, 33, 33, 33, 33, 33, 33, 34, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 33, 34, 34, 34, 34, 34, 34, 34, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 33, 34, 34, 34, 34, 34, 34, 34, 35, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 33, 33, 34, 35, 35, 35, 35, 35, 35, 35, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 33, 34, 34, 35, 35, 35, 35, 35, 35, 36, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 34, 35, 36, 36, 36, 36, 36, 36, 36, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 34, 35, 36, 36, 36, 36, 36, 36, 36, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 34, 35, 36, 36, 36, 36, 36, 36, 36, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 34, 35, 36, 36, 36, 36, 36, 36, 36, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 34, 35, 36, 36, 36, 36, 36, 36, 36, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 34, 35, 36, 36, 36, 36, 36, 36, 36, + 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 34, 35, 35, 36, 37, 37, 37, 37, 37, 37, 38, + 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 35, 35, 35, 35, 35, 35, 35, 36, 37, 37, 38, 38, 38, 38, 38, 38, 39, + 34, 34, 34, 35, 35, 35, 35, 35, 35, 35, 35, 35, 36, 36, 36, 36, 36, 36, 36, 36, 36, 37, 37, 38, 39, 40, 40, 40, 40, 40, 40, 40, + 35, 35, 36, 36, 36, 37, 37, 37, 37, 37, 37, 37, 37, 37, 38, 38, 38, 38, 38, 38, 38, 38, 39, 40, 40, 41, 41, 41, 41, 41, 41, 42, + 37, 37, 37, 38, 38, 38, 38, 38, 38, 38, 38, 38, 39, 39, 39, 40, 40, 40, 40, 40, 40, 40, 41, 41, 42, 43, 43, 43, 43, 43, 43, 44, + }, + }, { + { + 32, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + }, { + 32, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 30, 30, 30, 30, 30, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 30, 30, 30, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, + }, + }, +}; + +static const uint8_t qm_tbl_32x32_t[][2][528] = { + { + { + 32, + 31, 32, + 31, 32, 32, + 31, 32, 32, 32, + 31, 32, 32, 33, 33, + 32, 32, 32, 33, 34, 35, + 34, 34, 33, 34, 35, 37, 39, + 35, 34, 34, 35, 36, 37, 41, 43, + 36, 35, 34, 35, 36, 38, 42, 45, 48, + 39, 38, 37, 38, 39, 40, 45, 47, 50, 54, + 44, 42, 41, 41, 42, 42, 47, 50, 54, 58, 63, + 46, 44, 42, 43, 44, 44, 49, 52, 55, 59, 65, 67, + 48, 46, 44, 45, 45, 46, 51, 53, 57, 61, 67, 69, 71, + 54, 51, 49, 49, 50, 49, 54, 57, 60, 65, 71, 74, 76, 82, + 59, 56, 54, 54, 54, 53, 58, 61, 64, 69, 75, 78, 80, 87, 92, + 62, 59, 56, 56, 56, 55, 60, 63, 66, 71, 77, 80, 83, 89, 95, 98, + 65, 62, 59, 59, 59, 58, 63, 65, 68, 73, 79, 82, 85, 92, 98, 101, 105, + 71, 68, 65, 64, 64, 63, 68, 70, 73, 78, 84, 87, 90, 97, 103, 107, 111, 117, + 80, 76, 72, 72, 71, 69, 74, 76, 79, 84, 90, 93, 96, 104, 110, 114, 118, 125, 134, + 81, 77, 73, 73, 72, 70, 75, 77, 80, 85, 91, 94, 97, 105, 111, 115, 119, 126, 135, 137, + 83, 78, 75, 74, 74, 72, 76, 79, 81, 86, 92, 95, 99, 106, 113, 117, 121, 128, 137, 138, 140, + 88, 84, 80, 79, 78, 76, 80, 82, 85, 91, 95, 98, 103, 111, 115, 119, 126, 134, 139, 144, 147, 152, + 91, 86, 83, 82, 81, 79, 81, 84, 88, 92, 95, 100, 107, 110, 115, 123, 127, 132, 140, 147, 151, 154, 159, + 94, 89, 86, 85, 84, 82, 82, 86, 90, 92, 97, 103, 105, 111, 119, 121, 128, 136, 139, 146, 156, 158, 161, 166, + 97, 92, 90, 88, 86, 85, 84, 89, 91, 95, 100, 102, 108, 114, 116, 125, 130, 133, 143, 148, 152, 163, 166, 168, 174, + 101, 95, 93, 91, 89, 89, 87, 91, 93, 98, 101, 105, 111, 113, 120, 126, 130, 138, 142, 149, 157, 159, 171, 174, 176, 183, + 104, 99, 97, 94, 93, 93, 90, 92, 96, 100, 102, 108, 111, 116, 122, 125, 134, 137, 144, 151, 155, 165, 169, 179, 182, 184, 191, + 107, 102, 101, 97, 96, 96, 93, 93, 99, 101, 105, 110, 113, 120, 122, 129, 133, 140, 146, 150, 161, 163, 173, 178, 187, 191, 193, 200, + 111, 105, 104, 101, 100, 99, 97, 96, 102, 103, 109, 111, 117, 120, 125, 131, 135, 143, 146, 156, 158, 168, 173, 180, 189, 195, 200, 202, 210, + 115, 109, 108, 104, 104, 102, 101, 100, 103, 106, 111, 113, 119, 121, 129, 131, 140, 142, 151, 155, 162, 168, 176, 183, 188, 199, 204, 210, 212, 220, + 119, 113, 112, 107, 107, 106, 105, 103, 105, 110, 112, 117, 120, 125, 130, 135, 140, 145, 152, 157, 165, 169, 179, 183, 193, 197, 210, 214, 220, 222, 231, + 123, 116, 116, 111, 111, 109, 110, 107, 107, 114, 114, 121, 122, 130, 130, 140, 140, 150, 151, 163, 164, 176, 177, 190, 191, 204, 206, 222, 224, 230, 232, 242, + }, { + 32, + 31, 31, + 30, 31, 32, + 32, 33, 33, 35, + 33, 34, 35, 37, 39, + 36, 38, 40, 41, 43, 47, + 41, 42, 42, 43, 45, 47, 48, + 45, 45, 44, 45, 46, 47, 49, 50, + 49, 47, 46, 47, 47, 48, 50, 51, 53, + 48, 47, 45, 46, 46, 46, 49, 51, 53, 54, + 49, 47, 45, 45, 45, 45, 49, 51, 53, 55, 58, + 50, 47, 45, 46, 46, 46, 49, 51, 54, 56, 59, 60, + 50, 48, 46, 46, 46, 46, 50, 52, 54, 56, 60, 60, 61, + 52, 50, 47, 47, 47, 47, 50, 52, 54, 57, 61, 62, 63, 66, + 54, 52, 49, 49, 49, 48, 52, 53, 55, 58, 62, 64, 65, 68, 71, + 56, 53, 51, 50, 50, 49, 52, 54, 56, 59, 63, 64, 66, 69, 72, 73, + 57, 54, 52, 51, 51, 50, 53, 55, 56, 60, 63, 65, 67, 70, 73, 75, 76, + 60, 57, 54, 54, 53, 52, 55, 57, 58, 61, 65, 67, 68, 72, 75, 77, 79, 82, + 63, 60, 57, 57, 56, 54, 57, 59, 60, 63, 67, 69, 71, 75, 78, 80, 82, 85, 89, + 64, 61, 58, 57, 57, 55, 58, 59, 61, 64, 67, 69, 71, 75, 78, 80, 82, 85, 89, 90, + 65, 61, 58, 58, 57, 55, 58, 60, 61, 64, 68, 70, 71, 75, 79, 81, 83, 86, 90, 91, 91, + 67, 63, 61, 60, 59, 57, 60, 61, 63, 66, 69, 70, 73, 77, 79, 81, 85, 88, 90, 92, 94, 96, + 68, 64, 62, 61, 60, 58, 59, 61, 64, 66, 67, 71, 74, 75, 78, 82, 84, 86, 90, 93, 94, 96, 98, + 69, 65, 63, 62, 61, 59, 59, 62, 64, 65, 68, 71, 72, 75, 79, 80, 83, 87, 89, 92, 96, 97, 98, 100, + 70, 66, 64, 63, 62, 61, 60, 63, 64, 66, 69, 70, 73, 76, 77, 81, 84, 85, 89, 92, 93, 98, 99, 100, 102, + 71, 67, 66, 64, 63, 62, 61, 63, 64, 67, 68, 70, 74, 75, 78, 81, 83, 86, 88, 91, 94, 95, 100, 101, 102, 104, + 72, 68, 67, 65, 64, 64, 61, 63, 65, 67, 68, 71, 73, 75, 78, 79, 84, 85, 88, 91, 93, 97, 98, 102, 103, 104, 106, + 73, 69, 68, 66, 65, 65, 63, 63, 66, 67, 69, 71, 73, 76, 77, 81, 82, 85, 88, 90, 94, 95, 99, 101, 104, 105, 106, 109, + 74, 70, 70, 67, 66, 66, 64, 63, 66, 67, 70, 71, 74, 75, 78, 80, 82, 86, 87, 91, 92, 96, 98, 101, 104, 106, 108, 108, 111, + 75, 71, 71, 68, 68, 67, 66, 64, 66, 68, 70, 71, 74, 75, 79, 79, 84, 84, 88, 90, 93, 95, 98, 101, 103, 107, 108, 110, 111, 113, + 76, 72, 72, 69, 69, 68, 67, 65, 66, 69, 70, 72, 74, 76, 78, 81, 83, 85, 88, 90, 93, 95, 98, 100, 104, 105, 109, 111, 112, 113, 116, + 78, 74, 74, 70, 70, 69, 69, 66, 66, 70, 70, 74, 74, 77, 78, 82, 82, 86, 87, 92, 92, 96, 97, 102, 102, 107, 107, 112, 113, 115, 115, 118, + }, + }, { + { + 32, + 31, 32, + 31, 32, 32, + 31, 32, 32, 32, + 31, 32, 32, 32, 33, + 32, 32, 32, 33, 34, 35, + 32, 33, 33, 33, 34, 36, 36, + 34, 34, 33, 34, 35, 37, 38, 39, + 36, 35, 34, 35, 36, 38, 40, 42, 48, + 38, 37, 36, 36, 38, 39, 41, 44, 50, 51, + 39, 38, 37, 38, 39, 40, 42, 45, 50, 52, 54, + 44, 42, 41, 41, 42, 42, 44, 47, 54, 56, 58, 63, + 47, 45, 44, 44, 45, 45, 47, 50, 56, 58, 60, 66, 69, + 49, 47, 46, 45, 46, 46, 48, 51, 57, 60, 62, 68, 71, 73, + 54, 51, 50, 49, 50, 49, 51, 54, 60, 63, 65, 71, 75, 77, 82, + 59, 56, 54, 54, 54, 53, 55, 58, 64, 67, 69, 75, 79, 81, 87, 92, + 61, 58, 56, 56, 56, 55, 57, 60, 65, 68, 70, 77, 81, 83, 89, 94, 97, + 65, 62, 60, 59, 59, 58, 60, 63, 68, 71, 73, 79, 84, 87, 92, 98, 101, 105, + 71, 68, 65, 65, 64, 63, 65, 68, 73, 76, 78, 84, 89, 92, 97, 103, 106, 111, 117, + 76, 72, 70, 69, 68, 66, 68, 71, 76, 79, 81, 88, 92, 95, 101, 107, 110, 115, 122, 127, + 80, 76, 73, 72, 71, 69, 71, 74, 79, 82, 84, 90, 95, 98, 104, 110, 113, 118, 125, 130, 134, + 83, 78, 76, 75, 74, 72, 73, 76, 81, 84, 86, 92, 97, 100, 106, 113, 116, 121, 128, 133, 137, 140, + 86, 82, 79, 78, 77, 74, 76, 79, 84, 87, 89, 95, 100, 103, 109, 116, 119, 124, 131, 136, 140, 144, 147, + 89, 85, 82, 81, 79, 78, 78, 82, 86, 87, 92, 97, 100, 105, 112, 114, 120, 128, 131, 136, 146, 147, 150, 155, + 92, 88, 85, 84, 82, 81, 80, 85, 86, 90, 95, 97, 102, 107, 110, 117, 122, 125, 134, 138, 142, 152, 154, 156, 162, + 95, 90, 88, 86, 85, 84, 82, 86, 88, 93, 95, 99, 105, 106, 113, 118, 121, 129, 132, 139, 146, 148, 159, 161, 163, 169, + 98, 93, 91, 89, 88, 87, 85, 87, 90, 94, 96, 102, 104, 109, 114, 117, 126, 128, 134, 141, 145, 154, 157, 166, 168, 170, 176, + 101, 96, 95, 92, 91, 90, 88, 88, 93, 95, 99, 103, 106, 112, 114, 121, 124, 131, 136, 140, 149, 151, 160, 165, 173, 176, 178, 184, + 104, 99, 98, 95, 94, 93, 91, 90, 95, 96, 102, 103, 109, 112, 117, 122, 125, 133, 136, 145, 146, 156, 160, 167, 174, 180, 184, 186, 193, + 108, 102, 101, 98, 97, 96, 95, 93, 97, 100, 104, 106, 111, 113, 121, 122, 130, 132, 140, 143, 150, 155, 162, 169, 174, 183, 188, 192, 194, 201, + 111, 105, 105, 101, 100, 99, 98, 96, 98, 103, 105, 109, 112, 117, 121, 125, 130, 135, 141, 146, 152, 156, 165, 169, 178, 181, 193, 196, 201, 202, 210, + 114, 109, 109, 104, 104, 102, 102, 99, 100, 106, 106, 113, 113, 120, 121, 129, 130, 139, 140, 151, 151, 162, 162, 175, 176, 187, 188, 203, 204, 210, 211, 219, + }, { + 32, + 31, 31, + 30, 31, 31, + 31, 32, 32, 33, + 33, 34, 35, 36, 39, + 36, 38, 39, 40, 43, 47, + 38, 40, 41, 41, 44, 47, 47, + 41, 42, 42, 43, 45, 47, 48, 48, + 49, 47, 46, 46, 47, 48, 49, 50, 53, + 49, 47, 46, 46, 46, 47, 48, 50, 53, 53, + 48, 47, 46, 45, 46, 46, 48, 49, 53, 54, 54, + 49, 47, 45, 45, 45, 45, 47, 49, 53, 55, 55, 58, + 50, 48, 46, 46, 46, 46, 47, 50, 54, 55, 56, 59, 61, + 51, 48, 47, 46, 47, 46, 47, 50, 54, 55, 56, 60, 61, 62, + 52, 50, 48, 47, 47, 47, 48, 50, 54, 56, 57, 61, 63, 64, 66, + 54, 52, 50, 49, 49, 48, 49, 52, 55, 57, 58, 62, 64, 66, 68, 71, + 55, 53, 51, 50, 50, 49, 50, 52, 56, 58, 59, 63, 65, 66, 69, 72, 73, + 57, 54, 52, 51, 51, 50, 51, 53, 56, 58, 60, 63, 66, 67, 70, 73, 74, 76, + 60, 57, 55, 54, 53, 52, 53, 55, 58, 60, 61, 65, 68, 69, 72, 75, 77, 79, 82, + 62, 59, 57, 56, 55, 53, 54, 56, 59, 61, 63, 66, 69, 70, 74, 77, 78, 80, 84, 86, + 63, 60, 58, 57, 56, 54, 55, 57, 60, 62, 63, 67, 70, 71, 75, 78, 79, 82, 85, 87, 89, + 65, 61, 59, 58, 57, 55, 56, 58, 61, 63, 64, 68, 71, 72, 75, 79, 80, 83, 86, 88, 90, 91, + 66, 63, 60, 59, 58, 56, 58, 59, 62, 64, 65, 69, 72, 73, 76, 80, 81, 84, 87, 90, 91, 93, 94, + 67, 64, 62, 61, 59, 58, 58, 60, 63, 64, 66, 69, 71, 73, 77, 78, 81, 85, 86, 89, 93, 94, 95, 97, + 68, 65, 63, 62, 60, 59, 58, 61, 62, 64, 67, 68, 71, 74, 75, 79, 81, 83, 87, 89, 91, 95, 96, 97, 99, + 69, 66, 64, 63, 61, 61, 59, 61, 62, 65, 66, 68, 72, 73, 76, 78, 80, 84, 85, 88, 91, 92, 97, 98, 98, 101, + 70, 67, 65, 63, 62, 62, 60, 61, 63, 65, 66, 69, 71, 73, 76, 77, 81, 83, 85, 88, 90, 94, 95, 99, 100, 100, 103, + 71, 67, 67, 64, 63, 63, 61, 61, 64, 65, 67, 69, 71, 74, 75, 78, 80, 83, 85, 87, 91, 92, 95, 97, 100, 102, 102, 105, + 72, 68, 68, 65, 65, 64, 62, 62, 64, 65, 68, 69, 72, 73, 76, 78, 80, 83, 84, 88, 89, 93, 95, 97, 100, 102, 104, 104, 107, + 73, 69, 69, 66, 66, 65, 64, 63, 64, 66, 68, 69, 72, 73, 77, 77, 81, 82, 86, 87, 90, 92, 95, 97, 99, 103, 104, 106, 106, 109, + 74, 70, 70, 67, 67, 66, 65, 63, 64, 67, 68, 70, 72, 74, 76, 78, 80, 82, 85, 87, 90, 91, 95, 96, 100, 101, 105, 106, 108, 108, 111, + 75, 71, 71, 68, 68, 66, 66, 64, 64, 68, 68, 71, 71, 75, 75, 79, 79, 83, 84, 88, 89, 93, 93, 98, 98, 102, 103, 108, 108, 110, 110, 113, + }, + }, { + { + 32, + 31, 32, + 31, 32, 32, + 31, 32, 32, 32, + 31, 32, 32, 32, 33, + 32, 32, 32, 32, 33, 34, + 32, 32, 32, 32, 34, 34, 35, + 34, 34, 33, 33, 35, 36, 37, 39, + 34, 34, 34, 34, 36, 36, 37, 41, 42, + 36, 35, 34, 34, 36, 37, 38, 42, 45, 48, + 39, 38, 38, 37, 39, 40, 40, 45, 47, 50, 54, + 41, 39, 39, 38, 40, 40, 41, 46, 48, 51, 55, 56, + 44, 42, 41, 41, 42, 42, 42, 47, 50, 54, 58, 59, 63, + 48, 46, 45, 44, 45, 45, 45, 50, 53, 56, 61, 62, 66, 70, + 49, 47, 46, 45, 46, 46, 46, 51, 53, 57, 62, 63, 68, 71, 73, + 54, 51, 50, 49, 50, 49, 49, 54, 56, 60, 65, 67, 71, 76, 77, 82, + 58, 55, 54, 53, 53, 53, 52, 57, 59, 63, 68, 70, 74, 79, 81, 86, 90, + 59, 57, 55, 54, 54, 54, 54, 59, 61, 64, 69, 71, 75, 80, 82, 87, 91, 93, + 65, 62, 60, 59, 59, 58, 58, 63, 65, 68, 73, 75, 79, 85, 87, 92, 97, 99, 105, + 69, 66, 64, 63, 63, 62, 61, 66, 68, 71, 76, 78, 83, 88, 90, 96, 100, 102, 109, 113, + 71, 68, 66, 65, 64, 63, 63, 68, 70, 73, 78, 80, 84, 90, 92, 97, 102, 104, 111, 115, 117, + 80, 76, 73, 72, 71, 70, 69, 74, 76, 79, 84, 86, 90, 96, 98, 104, 109, 111, 118, 123, 125, 134, + 81, 77, 75, 74, 73, 72, 71, 75, 77, 80, 85, 87, 91, 97, 99, 105, 110, 112, 120, 125, 127, 136, 137, + 83, 78, 76, 75, 74, 73, 72, 76, 78, 81, 86, 88, 92, 98, 100, 106, 111, 113, 121, 126, 128, 137, 139, 140, + 87, 83, 81, 79, 78, 77, 75, 80, 82, 85, 90, 91, 96, 101, 103, 110, 114, 117, 125, 129, 133, 142, 143, 145, 150, + 90, 85, 83, 81, 80, 79, 78, 81, 83, 87, 89, 93, 98, 100, 106, 110, 114, 121, 124, 130, 136, 138, 148, 149, 151, 156, + 93, 88, 86, 84, 83, 82, 80, 82, 85, 89, 90, 96, 98, 102, 107, 109, 118, 120, 125, 131, 134, 143, 145, 153, 156, 157, 163, + 95, 90, 89, 86, 85, 85, 83, 83, 88, 89, 93, 97, 99, 105, 106, 113, 116, 122, 127, 130, 139, 140, 148, 153, 159, 162, 164, 169, + 98, 93, 92, 89, 88, 87, 86, 85, 89, 90, 96, 97, 102, 105, 109, 114, 117, 124, 126, 134, 136, 144, 148, 154, 160, 166, 169, 170, 176, + 101, 96, 95, 91, 91, 90, 89, 87, 90, 93, 97, 99, 104, 105, 112, 113, 121, 122, 130, 133, 139, 144, 150, 155, 160, 168, 172, 176, 177, 184, + 104, 99, 98, 94, 94, 92, 92, 90, 92, 96, 98, 102, 104, 109, 112, 116, 121, 125, 130, 135, 141, 144, 152, 155, 163, 166, 177, 179, 184, 185, 191, + 107, 101, 101, 97, 97, 95, 95, 93, 93, 99, 99, 105, 105, 112, 112, 120, 120, 129, 129, 139, 140, 149, 149, 161, 161, 172, 172, 185, 186, 191, 192, 199, + }, { + 32, + 31, 31, + 30, 31, 31, + 30, 31, 31, 32, + 33, 34, 35, 35, 39, + 35, 36, 37, 37, 41, 43, + 36, 38, 39, 40, 43, 45, 47, + 41, 42, 42, 42, 45, 46, 47, 48, + 44, 44, 44, 44, 46, 46, 47, 49, 50, + 49, 47, 47, 46, 47, 47, 48, 50, 51, 53, + 48, 47, 46, 45, 46, 46, 46, 49, 51, 53, 54, + 48, 47, 46, 45, 46, 46, 46, 49, 51, 53, 54, 55, + 49, 47, 46, 45, 45, 45, 45, 49, 51, 53, 55, 56, 58, + 50, 48, 47, 46, 46, 46, 46, 50, 51, 54, 56, 57, 59, 61, + 51, 48, 47, 46, 47, 46, 46, 50, 51, 54, 56, 57, 60, 62, 62, + 52, 50, 48, 47, 47, 47, 47, 50, 52, 54, 57, 58, 61, 63, 64, 66, + 54, 51, 50, 49, 49, 48, 48, 51, 53, 55, 58, 59, 62, 64, 65, 68, 70, + 55, 52, 51, 50, 49, 49, 48, 52, 53, 55, 59, 60, 62, 65, 66, 68, 70, 71, + 57, 54, 53, 52, 51, 50, 50, 53, 54, 56, 60, 61, 63, 66, 67, 70, 73, 73, 76, + 59, 56, 54, 53, 53, 52, 51, 54, 56, 58, 61, 62, 65, 68, 69, 72, 74, 75, 78, 80, + 60, 57, 55, 54, 53, 53, 52, 55, 56, 58, 61, 63, 65, 68, 69, 72, 75, 76, 79, 81, 82, + 63, 60, 58, 57, 56, 55, 54, 57, 59, 60, 63, 65, 67, 70, 71, 75, 77, 78, 82, 84, 85, 89, + 64, 61, 59, 58, 57, 56, 55, 58, 59, 61, 64, 65, 68, 71, 72, 75, 78, 79, 82, 85, 86, 89, 90, + 65, 61, 60, 58, 57, 56, 55, 58, 59, 61, 64, 65, 68, 71, 72, 75, 78, 79, 83, 85, 86, 90, 91, 91, + 67, 63, 61, 60, 59, 58, 57, 60, 61, 63, 65, 66, 69, 72, 73, 77, 79, 80, 84, 86, 88, 92, 93, 93, 95, + 68, 64, 63, 61, 60, 59, 58, 60, 61, 63, 65, 67, 70, 71, 74, 76, 78, 81, 83, 86, 88, 89, 94, 94, 95, 97, + 68, 65, 64, 62, 61, 60, 58, 59, 61, 64, 64, 68, 69, 71, 74, 75, 79, 80, 83, 86, 87, 91, 92, 95, 96, 97, 99, + 69, 66, 65, 63, 62, 61, 59, 59, 62, 63, 65, 67, 69, 72, 72, 76, 78, 80, 83, 84, 88, 89, 92, 94, 97, 98, 99, 101, + 70, 67, 66, 63, 63, 62, 61, 60, 63, 63, 66, 67, 69, 71, 73, 76, 77, 81, 82, 85, 86, 90, 91, 94, 96, 99, 100, 100, 103, + 71, 67, 67, 64, 64, 63, 62, 61, 62, 64, 66, 67, 70, 71, 74, 74, 78, 79, 83, 84, 87, 89, 91, 94, 95, 99, 100, 102, 102, 104, + 72, 68, 68, 65, 65, 64, 63, 61, 62, 65, 66, 68, 69, 71, 73, 75, 77, 79, 82, 84, 87, 88, 92, 93, 96, 97, 101, 102, 104, 104, 106, + 73, 69, 69, 66, 66, 64, 64, 62, 62, 66, 66, 69, 69, 72, 73, 76, 77, 81, 81, 85, 85, 89, 90, 94, 94, 99, 99, 104, 104, 106, 106, 108, + }, + }, { + { + 32, + 31, 32, + 31, 32, 32, + 31, 32, 32, 32, + 31, 32, 32, 32, 33, + 31, 32, 32, 32, 33, 33, + 32, 32, 32, 32, 33, 34, 35, + 32, 33, 33, 33, 34, 34, 36, 36, + 34, 34, 34, 33, 35, 35, 37, 38, 39, + 35, 35, 34, 34, 36, 36, 38, 39, 42, 46, + 36, 35, 35, 34, 36, 36, 38, 40, 42, 47, 48, + 39, 38, 38, 37, 39, 39, 40, 42, 45, 49, 50, 54, + 41, 40, 39, 38, 40, 40, 41, 43, 46, 50, 52, 55, 57, + 44, 42, 42, 41, 42, 42, 42, 44, 47, 52, 54, 58, 60, 63, + 47, 45, 45, 44, 44, 45, 45, 47, 50, 55, 56, 60, 62, 66, 69, + 48, 46, 45, 44, 45, 45, 46, 47, 51, 55, 57, 61, 63, 67, 70, 71, + 54, 51, 50, 49, 49, 50, 49, 51, 54, 59, 60, 65, 67, 71, 75, 76, 82, + 56, 53, 52, 51, 51, 51, 51, 53, 56, 60, 61, 66, 69, 73, 77, 78, 84, 86, + 59, 56, 55, 54, 54, 54, 53, 55, 58, 62, 64, 69, 71, 75, 79, 80, 87, 89, 92, + 64, 61, 60, 58, 58, 58, 57, 59, 62, 66, 67, 72, 75, 79, 83, 84, 91, 93, 97, 102, + 65, 62, 61, 59, 59, 59, 58, 60, 63, 67, 68, 73, 75, 79, 84, 85, 92, 94, 98, 103, 105, + 71, 68, 67, 65, 64, 64, 63, 65, 68, 72, 73, 78, 80, 84, 89, 90, 97, 100, 103, 109, 111, 117, + 74, 71, 69, 68, 67, 67, 65, 67, 70, 74, 75, 80, 83, 86, 91, 93, 100, 102, 106, 112, 114, 120, 123, + 80, 76, 74, 72, 71, 71, 69, 71, 74, 78, 79, 84, 86, 90, 95, 96, 104, 106, 110, 116, 118, 125, 128, 134, + 82, 78, 76, 74, 73, 73, 71, 73, 76, 79, 80, 86, 88, 92, 97, 98, 106, 108, 112, 118, 120, 127, 131, 136, 139, + 83, 78, 77, 75, 74, 74, 72, 73, 76, 80, 81, 86, 89, 92, 97, 99, 106, 109, 113, 119, 121, 128, 131, 137, 139, 140, + 87, 83, 81, 79, 78, 78, 75, 77, 80, 83, 85, 90, 92, 96, 100, 102, 110, 112, 117, 122, 125, 133, 135, 142, 144, 145, 150, + 90, 85, 84, 81, 80, 80, 78, 78, 82, 84, 87, 91, 93, 98, 99, 106, 108, 113, 118, 121, 129, 130, 137, 141, 147, 150, 151, 156, + 92, 88, 87, 84, 83, 82, 80, 80, 84, 85, 90, 91, 95, 98, 102, 106, 109, 115, 117, 125, 126, 134, 137, 142, 148, 152, 155, 156, 162, + 95, 90, 89, 86, 85, 84, 83, 82, 85, 87, 91, 92, 97, 98, 105, 105, 112, 114, 121, 123, 129, 133, 138, 143, 147, 155, 158, 161, 162, 168, + 97, 92, 92, 88, 88, 86, 86, 84, 85, 90, 91, 95, 97, 101, 104, 108, 112, 116, 121, 125, 130, 133, 140, 143, 150, 152, 162, 164, 168, 168, 174, + 100, 95, 95, 90, 90, 89, 89, 86, 86, 92, 92, 97, 98, 104, 104, 111, 111, 119, 119, 128, 129, 137, 137, 147, 148, 157, 158, 169, 170, 174, 175, 181, + }, { + 32, + 31, 31, + 31, 31, 31, + 30, 31, 31, 32, + 33, 34, 34, 34, 37, + 33, 34, 35, 35, 38, 39, + 36, 38, 39, 40, 42, 43, 47, + 38, 40, 40, 41, 43, 44, 47, 47, + 41, 42, 42, 42, 44, 45, 47, 48, 48, + 47, 46, 46, 45, 46, 47, 47, 48, 50, 52, + 49, 47, 47, 46, 47, 47, 48, 49, 50, 52, 53, + 48, 47, 46, 45, 46, 46, 46, 48, 49, 52, 53, 54, + 49, 47, 46, 45, 46, 46, 46, 47, 49, 52, 53, 55, 55, + 49, 47, 46, 45, 45, 45, 45, 47, 49, 52, 53, 55, 57, 58, + 50, 48, 47, 46, 46, 46, 46, 47, 50, 53, 54, 56, 57, 59, 61, + 50, 48, 47, 46, 46, 46, 46, 47, 50, 53, 54, 56, 58, 60, 61, 61, + 52, 50, 49, 47, 47, 47, 47, 48, 50, 53, 54, 57, 59, 61, 63, 63, 66, + 53, 50, 50, 48, 48, 48, 47, 49, 51, 54, 55, 58, 59, 62, 64, 64, 67, 68, + 54, 52, 51, 49, 49, 49, 48, 49, 52, 55, 55, 58, 60, 62, 64, 65, 68, 69, 71, + 56, 54, 53, 51, 51, 51, 49, 51, 53, 55, 56, 59, 61, 63, 66, 66, 70, 71, 73, 75, + 57, 54, 53, 52, 51, 51, 50, 51, 53, 56, 56, 60, 61, 63, 66, 67, 70, 71, 73, 76, 76, + 60, 57, 56, 54, 53, 53, 52, 53, 55, 58, 58, 61, 63, 65, 68, 68, 72, 73, 75, 78, 79, 82, + 61, 58, 57, 55, 55, 54, 53, 54, 56, 58, 59, 62, 64, 66, 69, 69, 73, 74, 76, 79, 80, 83, 84, + 63, 60, 59, 57, 56, 56, 54, 55, 57, 60, 60, 63, 65, 67, 70, 71, 75, 76, 78, 81, 82, 85, 86, 89, + 64, 61, 60, 58, 57, 57, 55, 56, 58, 60, 61, 64, 66, 68, 70, 71, 75, 77, 79, 82, 82, 86, 87, 90, 91, + 65, 61, 60, 58, 57, 57, 55, 56, 58, 61, 61, 64, 66, 68, 71, 71, 75, 77, 79, 82, 83, 86, 88, 90, 91, 91, + 67, 63, 62, 60, 59, 59, 57, 58, 60, 62, 63, 66, 67, 69, 72, 73, 77, 78, 80, 83, 84, 88, 89, 92, 93, 93, 95, + 67, 64, 63, 61, 60, 60, 58, 58, 61, 61, 63, 65, 67, 70, 70, 74, 75, 78, 80, 81, 85, 86, 89, 91, 93, 94, 95, 97, + 68, 65, 64, 62, 61, 60, 59, 58, 61, 61, 64, 65, 67, 69, 71, 73, 75, 78, 79, 83, 83, 87, 88, 91, 93, 95, 96, 97, 99, + 69, 65, 65, 62, 62, 61, 60, 59, 61, 62, 64, 65, 68, 68, 72, 72, 76, 76, 80, 81, 84, 86, 88, 90, 92, 95, 96, 98, 98, 100, + 70, 66, 66, 63, 63, 62, 61, 60, 60, 63, 64, 66, 67, 69, 71, 73, 75, 77, 79, 81, 84, 85, 88, 89, 93, 93, 97, 98, 100, 100, 102, + 71, 67, 67, 64, 64, 62, 62, 60, 60, 64, 64, 67, 67, 70, 70, 74, 74, 78, 78, 82, 82, 86, 86, 91, 91, 95, 95, 100, 100, 101, 101, 104, + }, + }, { + { + 32, + 31, 32, + 31, 32, 32, + 31, 32, 32, 32, + 31, 32, 32, 32, 32, + 31, 32, 32, 32, 33, 33, + 32, 32, 32, 32, 33, 33, 34, + 32, 32, 32, 32, 33, 34, 35, 35, + 33, 33, 33, 33, 34, 35, 36, 36, 38, + 34, 34, 34, 33, 34, 35, 36, 37, 39, 39, + 36, 35, 35, 34, 35, 36, 37, 38, 42, 42, 48, + 36, 35, 35, 34, 35, 36, 38, 38, 42, 43, 48, 49, + 39, 38, 38, 37, 38, 39, 40, 40, 44, 45, 50, 51, 54, + 41, 39, 39, 38, 39, 40, 40, 41, 45, 46, 51, 52, 55, 56, + 44, 42, 42, 41, 41, 42, 42, 42, 46, 47, 54, 54, 58, 59, 63, + 46, 44, 44, 42, 43, 44, 44, 44, 48, 49, 55, 55, 59, 61, 65, 67, + 48, 46, 46, 44, 45, 45, 45, 46, 50, 51, 57, 57, 61, 63, 67, 69, 71, + 52, 50, 49, 48, 48, 48, 48, 48, 52, 53, 59, 59, 64, 65, 70, 72, 74, 78, + 54, 51, 51, 49, 49, 50, 49, 49, 53, 54, 60, 60, 65, 67, 71, 74, 76, 80, 82, + 58, 56, 55, 53, 53, 53, 53, 53, 57, 58, 63, 64, 68, 70, 75, 77, 80, 84, 86, 91, + 59, 56, 56, 54, 54, 54, 53, 53, 57, 58, 64, 64, 69, 70, 75, 78, 80, 85, 87, 91, 92, + 65, 62, 61, 59, 59, 59, 58, 58, 62, 63, 68, 68, 73, 75, 79, 82, 85, 90, 92, 97, 98, 105, + 66, 63, 63, 60, 60, 60, 59, 59, 63, 64, 69, 69, 74, 76, 80, 83, 86, 91, 93, 98, 99, 106, 107, + 71, 68, 67, 65, 65, 64, 63, 63, 67, 68, 73, 73, 78, 80, 84, 87, 90, 95, 97, 103, 103, 111, 112, 117, + 74, 71, 70, 68, 67, 67, 66, 65, 69, 70, 75, 75, 80, 82, 86, 89, 93, 97, 100, 105, 106, 114, 115, 120, 123, + 80, 76, 75, 72, 72, 71, 70, 69, 73, 74, 79, 79, 84, 86, 90, 93, 96, 101, 104, 110, 110, 118, 119, 125, 128, 134, + 81, 77, 77, 74, 73, 73, 71, 71, 74, 75, 80, 80, 85, 87, 91, 94, 98, 103, 105, 111, 112, 120, 121, 127, 130, 136, 137, + 83, 78, 78, 75, 74, 74, 72, 72, 75, 76, 81, 81, 86, 88, 92, 95, 99, 104, 106, 112, 113, 121, 122, 128, 131, 137, 139, 140, + 86, 82, 81, 78, 77, 77, 75, 74, 78, 79, 84, 84, 89, 91, 95, 98, 101, 106, 109, 115, 116, 124, 125, 131, 135, 140, 142, 144, 147, + 89, 84, 84, 80, 80, 79, 78, 77, 79, 81, 85, 86, 91, 92, 97, 98, 104, 106, 112, 114, 119, 123, 128, 132, 135, 142, 145, 148, 149, 153, + 91, 86, 86, 82, 82, 81, 80, 79, 80, 84, 85, 88, 91, 94, 97, 100, 104, 107, 112, 115, 120, 123, 129, 132, 138, 140, 148, 150, 153, 154, 159, + 93, 88, 88, 84, 84, 83, 83, 80, 81, 86, 86, 91, 91, 96, 97, 103, 103, 110, 110, 118, 119, 126, 126, 135, 136, 144, 144, 155, 155, 159, 159, 164, + }, { + 32, + 31, 31, + 31, 31, 31, + 30, 31, 31, 32, + 31, 32, 32, 33, 34, + 33, 34, 35, 35, 37, 39, + 35, 37, 37, 38, 39, 41, 44, + 36, 38, 39, 40, 41, 43, 46, 47, + 40, 41, 41, 42, 43, 44, 46, 47, 48, + 41, 42, 42, 42, 43, 45, 46, 47, 48, 48, + 49, 47, 47, 46, 46, 47, 47, 48, 50, 50, 53, + 49, 47, 47, 46, 46, 47, 47, 47, 49, 50, 53, 53, + 48, 47, 47, 45, 46, 46, 46, 46, 49, 49, 53, 53, 54, + 48, 47, 46, 45, 45, 46, 46, 46, 49, 49, 53, 53, 54, 55, + 49, 47, 46, 45, 45, 45, 45, 45, 48, 49, 53, 54, 55, 56, 58, + 50, 47, 47, 45, 46, 46, 46, 46, 49, 49, 54, 54, 56, 57, 59, 60, + 50, 48, 48, 46, 46, 46, 46, 46, 49, 50, 54, 54, 56, 57, 60, 60, 61, + 52, 49, 49, 47, 47, 47, 47, 46, 49, 50, 54, 54, 57, 58, 61, 62, 63, 65, + 52, 50, 49, 47, 47, 47, 47, 47, 49, 50, 54, 54, 57, 58, 61, 62, 63, 65, 66, + 54, 52, 51, 49, 49, 49, 48, 48, 51, 52, 55, 55, 58, 59, 62, 63, 65, 67, 68, 70, + 54, 52, 51, 49, 49, 49, 48, 48, 51, 52, 55, 56, 58, 60, 62, 64, 65, 67, 68, 70, 71, + 57, 54, 54, 52, 51, 51, 50, 50, 52, 53, 56, 57, 60, 61, 63, 65, 67, 69, 70, 73, 73, 76, + 57, 55, 54, 52, 52, 51, 51, 50, 53, 53, 57, 57, 60, 61, 64, 65, 67, 70, 71, 73, 74, 77, 77, + 60, 57, 56, 54, 54, 53, 52, 52, 54, 55, 58, 59, 61, 63, 65, 67, 68, 71, 72, 75, 75, 79, 79, 82, + 61, 58, 57, 55, 55, 54, 53, 53, 55, 56, 59, 59, 62, 63, 66, 68, 69, 72, 73, 76, 76, 80, 80, 83, 84, + 63, 60, 59, 57, 57, 56, 55, 54, 57, 57, 60, 61, 63, 65, 67, 69, 71, 73, 75, 78, 78, 82, 82, 85, 86, 89, + 64, 61, 60, 58, 57, 57, 56, 55, 57, 58, 61, 61, 64, 65, 68, 69, 71, 74, 75, 78, 78, 82, 83, 86, 87, 89, 90, + 65, 61, 61, 58, 58, 57, 56, 55, 58, 58, 61, 62, 64, 65, 68, 70, 71, 74, 75, 78, 79, 83, 83, 86, 88, 90, 91, 91, + 66, 63, 62, 60, 59, 58, 57, 56, 59, 59, 62, 63, 65, 66, 69, 70, 72, 75, 76, 79, 80, 84, 84, 87, 89, 91, 92, 93, 94, + 67, 64, 63, 61, 60, 59, 58, 57, 59, 60, 62, 63, 66, 66, 70, 70, 73, 74, 77, 78, 81, 83, 85, 87, 89, 92, 93, 94, 94, 96, + 68, 64, 64, 61, 61, 60, 59, 58, 59, 61, 62, 64, 65, 67, 69, 71, 72, 74, 77, 78, 81, 82, 85, 86, 89, 90, 94, 94, 96, 96, 98, + 69, 65, 65, 62, 62, 61, 61, 58, 59, 62, 62, 65, 65, 68, 68, 71, 71, 75, 75, 79, 79, 83, 83, 87, 87, 91, 91, 96, 96, 97, 97, 99, + }, + }, { + { + 32, + 31, 32, + 31, 32, 32, + 31, 32, 32, 32, + 31, 32, 32, 32, 32, + 31, 32, 32, 32, 32, 33, + 31, 32, 32, 32, 32, 33, 33, + 32, 32, 32, 32, 32, 34, 34, 35, + 32, 32, 32, 32, 32, 34, 34, 35, 35, + 34, 34, 34, 33, 33, 35, 35, 37, 37, 39, + 34, 34, 34, 33, 33, 35, 35, 37, 37, 39, 39, + 36, 35, 35, 34, 34, 36, 36, 38, 38, 42, 42, 48, + 36, 35, 35, 34, 34, 36, 36, 38, 38, 42, 42, 48, 48, + 39, 38, 38, 37, 37, 39, 39, 40, 40, 45, 45, 50, 50, 54, + 39, 38, 38, 37, 37, 39, 39, 40, 40, 45, 45, 50, 50, 54, 54, + 44, 42, 42, 41, 41, 42, 42, 42, 42, 47, 47, 54, 54, 58, 58, 63, + 44, 42, 42, 41, 41, 42, 42, 42, 42, 47, 47, 54, 54, 58, 58, 63, 63, + 48, 46, 46, 44, 44, 45, 45, 46, 46, 51, 51, 57, 57, 61, 61, 67, 67, 71, + 48, 46, 46, 44, 44, 45, 45, 46, 46, 51, 51, 57, 57, 61, 61, 67, 67, 71, 71, + 54, 51, 51, 49, 49, 50, 50, 49, 49, 54, 54, 60, 60, 65, 65, 71, 71, 76, 76, 82, + 54, 51, 51, 49, 49, 50, 50, 49, 49, 54, 54, 60, 60, 65, 65, 71, 71, 76, 76, 82, 82, + 59, 56, 56, 54, 54, 54, 54, 53, 53, 58, 58, 64, 64, 69, 69, 75, 75, 80, 80, 87, 87, 92, + 59, 56, 56, 54, 54, 54, 54, 53, 53, 58, 58, 64, 64, 69, 69, 75, 75, 80, 80, 87, 87, 92, 92, + 65, 62, 62, 59, 59, 59, 59, 58, 58, 63, 63, 68, 68, 73, 73, 79, 79, 85, 85, 92, 92, 98, 98, 105, + 65, 62, 62, 59, 59, 59, 59, 58, 58, 63, 63, 68, 68, 73, 73, 79, 79, 85, 85, 92, 92, 98, 98, 105, 105, + 71, 68, 68, 65, 65, 64, 64, 63, 63, 68, 68, 73, 73, 78, 78, 84, 84, 90, 90, 97, 97, 103, 103, 111, 111, 117, + 71, 68, 68, 65, 65, 64, 64, 63, 63, 68, 68, 73, 73, 78, 78, 84, 84, 90, 90, 97, 97, 103, 103, 111, 111, 117, 117, + 80, 76, 76, 72, 72, 71, 71, 69, 69, 74, 74, 79, 79, 84, 84, 90, 90, 96, 96, 104, 104, 110, 110, 118, 118, 125, 125, 134, + 80, 76, 76, 72, 72, 71, 71, 69, 69, 74, 74, 79, 79, 84, 84, 90, 90, 96, 96, 104, 104, 110, 110, 118, 118, 125, 125, 134, 134, + 83, 78, 78, 75, 75, 74, 74, 72, 72, 76, 76, 81, 81, 86, 86, 92, 92, 99, 99, 106, 106, 113, 113, 121, 121, 128, 128, 137, 137, 140, + 83, 78, 78, 75, 75, 74, 74, 72, 72, 76, 76, 81, 81, 86, 86, 92, 92, 99, 99, 106, 106, 113, 113, 121, 121, 128, 128, 137, 137, 140, 140, + 87, 83, 83, 79, 79, 77, 77, 75, 75, 80, 80, 84, 84, 90, 90, 96, 96, 102, 102, 109, 109, 116, 116, 124, 124, 132, 132, 141, 141, 144, 144, 149, + }, { + 32, + 31, 31, + 31, 31, 31, + 30, 31, 31, 32, + 30, 31, 31, 32, 32, + 33, 34, 34, 35, 35, 39, + 33, 34, 34, 35, 35, 39, 39, + 36, 38, 38, 40, 40, 43, 43, 47, + 36, 38, 38, 40, 40, 43, 43, 47, 47, + 41, 42, 42, 42, 42, 45, 45, 47, 47, 48, + 41, 42, 42, 42, 42, 45, 45, 47, 47, 48, 48, + 49, 47, 47, 46, 46, 47, 47, 48, 48, 50, 50, 53, + 49, 47, 47, 46, 46, 47, 47, 48, 48, 50, 50, 53, 53, + 48, 47, 47, 45, 45, 46, 46, 46, 46, 49, 49, 53, 53, 54, + 48, 47, 47, 45, 45, 46, 46, 46, 46, 49, 49, 53, 53, 54, 54, + 49, 47, 47, 45, 45, 45, 45, 45, 45, 49, 49, 53, 53, 55, 55, 58, + 49, 47, 47, 45, 45, 45, 45, 45, 45, 49, 49, 53, 53, 55, 55, 58, 58, + 50, 48, 48, 46, 46, 46, 46, 46, 46, 50, 50, 54, 54, 56, 56, 60, 60, 61, + 50, 48, 48, 46, 46, 46, 46, 46, 46, 50, 50, 54, 54, 56, 56, 60, 60, 61, 61, + 52, 50, 50, 47, 47, 47, 47, 47, 47, 50, 50, 54, 54, 57, 57, 61, 61, 63, 63, 66, + 52, 50, 50, 47, 47, 47, 47, 47, 47, 50, 50, 54, 54, 57, 57, 61, 61, 63, 63, 66, 66, + 54, 52, 52, 49, 49, 49, 49, 48, 48, 52, 52, 55, 55, 58, 58, 62, 62, 65, 65, 68, 68, 71, + 54, 52, 52, 49, 49, 49, 49, 48, 48, 52, 52, 55, 55, 58, 58, 62, 62, 65, 65, 68, 68, 71, 71, + 57, 54, 54, 52, 52, 51, 51, 50, 50, 53, 53, 56, 56, 60, 60, 63, 63, 67, 67, 70, 70, 73, 73, 76, + 57, 54, 54, 52, 52, 51, 51, 50, 50, 53, 53, 56, 56, 60, 60, 63, 63, 67, 67, 70, 70, 73, 73, 76, 76, + 60, 57, 57, 54, 54, 53, 53, 52, 52, 55, 55, 58, 58, 61, 61, 65, 65, 68, 68, 72, 72, 75, 75, 79, 79, 82, + 60, 57, 57, 54, 54, 53, 53, 52, 52, 55, 55, 58, 58, 61, 61, 65, 65, 68, 68, 72, 72, 75, 75, 79, 79, 82, 82, + 63, 60, 60, 57, 57, 56, 56, 54, 54, 57, 57, 60, 60, 63, 63, 67, 67, 71, 71, 75, 75, 78, 78, 82, 82, 85, 85, 89, + 63, 60, 60, 57, 57, 56, 56, 54, 54, 57, 57, 60, 60, 63, 63, 67, 67, 71, 71, 75, 75, 78, 78, 82, 82, 85, 85, 89, 89, + 65, 61, 61, 58, 58, 57, 57, 55, 55, 58, 58, 61, 61, 64, 64, 68, 68, 71, 71, 75, 75, 79, 79, 83, 83, 86, 86, 90, 90, 91, + 65, 61, 61, 58, 58, 57, 57, 55, 55, 58, 58, 61, 61, 64, 64, 68, 68, 71, 71, 75, 75, 79, 79, 83, 83, 86, 86, 90, 90, 91, 91, + 67, 63, 63, 60, 60, 59, 59, 57, 57, 60, 60, 62, 62, 66, 66, 69, 69, 72, 72, 76, 76, 80, 80, 84, 84, 88, 88, 92, 92, 93, 93, 95, + }, + }, { + { + 32, + 31, 31, + 31, 32, 32, + 31, 32, 32, 32, + 31, 32, 32, 32, 32, + 31, 32, 32, 32, 32, 32, + 31, 32, 32, 32, 32, 33, 33, + 32, 32, 32, 32, 32, 33, 33, 34, + 32, 32, 32, 32, 32, 33, 34, 34, 35, + 32, 32, 32, 32, 33, 33, 34, 34, 35, 35, + 34, 34, 34, 33, 33, 34, 35, 35, 37, 37, 39, + 34, 34, 34, 33, 33, 34, 35, 35, 37, 37, 39, 39, + 35, 35, 35, 34, 34, 35, 36, 36, 38, 38, 42, 42, 46, + 36, 35, 35, 34, 34, 35, 36, 37, 38, 38, 42, 42, 47, 48, + 38, 37, 37, 36, 36, 37, 38, 38, 39, 40, 44, 44, 48, 50, 51, + 39, 38, 38, 38, 37, 38, 39, 39, 40, 41, 45, 45, 49, 50, 52, 54, + 41, 40, 40, 39, 38, 39, 40, 40, 41, 41, 46, 46, 50, 52, 54, 55, 57, + 44, 42, 42, 41, 41, 41, 42, 42, 42, 43, 47, 47, 52, 54, 56, 58, 60, 63, + 45, 43, 43, 42, 41, 42, 42, 43, 43, 43, 48, 48, 53, 54, 57, 58, 60, 64, 65, + 48, 46, 46, 45, 44, 45, 45, 45, 46, 46, 51, 51, 55, 57, 59, 61, 63, 67, 68, 71, + 48, 46, 46, 45, 44, 45, 45, 45, 46, 46, 51, 51, 55, 57, 59, 61, 63, 67, 68, 71, 71, + 53, 51, 51, 49, 49, 49, 49, 49, 49, 49, 54, 54, 58, 59, 62, 64, 67, 71, 72, 75, 75, 81, + 54, 52, 51, 50, 49, 49, 50, 49, 49, 50, 54, 54, 59, 60, 63, 65, 67, 71, 72, 76, 76, 81, 82, + 57, 55, 55, 53, 52, 52, 52, 52, 52, 52, 57, 57, 61, 62, 65, 67, 70, 74, 75, 79, 79, 85, 85, 89, + 59, 56, 56, 54, 54, 54, 54, 54, 53, 54, 58, 58, 62, 64, 67, 69, 71, 75, 76, 80, 80, 86, 87, 90, 92, + 62, 59, 59, 57, 56, 56, 56, 56, 55, 56, 60, 60, 64, 66, 69, 71, 73, 77, 78, 83, 83, 89, 89, 93, 95, 98, + 65, 62, 62, 60, 59, 59, 59, 59, 58, 58, 63, 63, 67, 68, 71, 73, 75, 79, 81, 85, 85, 91, 92, 96, 98, 101, 105, + 67, 64, 64, 62, 61, 61, 60, 60, 59, 60, 64, 64, 68, 69, 72, 74, 77, 81, 82, 87, 87, 93, 94, 98, 99, 103, 106, 108, + 71, 68, 68, 66, 65, 64, 64, 64, 63, 63, 68, 68, 72, 73, 76, 78, 80, 84, 85, 90, 90, 97, 97, 102, 103, 107, 111, 113, 117, + 72, 69, 69, 66, 65, 65, 65, 64, 63, 64, 68, 68, 72, 73, 76, 78, 81, 85, 86, 91, 91, 97, 98, 102, 104, 108, 111, 113, 118, 119, + 80, 76, 76, 73, 72, 72, 71, 70, 69, 70, 74, 74, 78, 79, 82, 84, 86, 90, 91, 96, 96, 103, 104, 108, 110, 114, 118, 120, 125, 126, 134, + 80, 76, 76, 73, 72, 72, 71, 70, 69, 70, 74, 74, 78, 79, 82, 84, 86, 90, 91, 96, 96, 103, 104, 108, 110, 114, 118, 120, 125, 126, 134, 134, + }, { + 32, + 31, 31, + 31, 31, 31, + 30, 31, 31, 31, + 30, 31, 31, 31, 32, + 32, 32, 33, 33, 33, 35, + 33, 34, 34, 35, 35, 37, 39, + 34, 35, 35, 36, 36, 38, 40, 41, + 36, 38, 38, 39, 40, 41, 43, 44, 47, + 37, 38, 39, 40, 40, 42, 43, 44, 47, 47, + 41, 42, 42, 42, 42, 43, 45, 45, 47, 47, 48, + 41, 42, 42, 42, 42, 43, 45, 45, 47, 47, 48, 48, + 47, 46, 46, 46, 45, 46, 47, 47, 47, 48, 50, 50, 52, + 49, 48, 47, 47, 46, 47, 47, 47, 48, 48, 50, 50, 52, 53, + 49, 47, 47, 46, 46, 46, 46, 47, 47, 47, 50, 50, 52, 53, 53, + 48, 47, 47, 46, 45, 46, 46, 46, 46, 47, 49, 49, 52, 53, 54, 54, + 49, 47, 47, 46, 45, 45, 46, 46, 46, 46, 49, 49, 52, 53, 54, 55, 55, + 49, 47, 47, 45, 45, 45, 45, 45, 45, 45, 49, 49, 52, 53, 55, 55, 57, 58, + 49, 47, 47, 46, 45, 45, 45, 45, 45, 46, 49, 49, 52, 53, 55, 56, 57, 59, 59, + 50, 48, 48, 47, 46, 46, 46, 46, 46, 46, 50, 50, 53, 54, 55, 56, 58, 60, 60, 61, + 50, 48, 48, 47, 46, 46, 46, 46, 46, 46, 50, 50, 53, 54, 55, 56, 58, 60, 60, 61, 61, + 52, 50, 49, 48, 47, 47, 47, 47, 46, 47, 50, 50, 53, 54, 56, 57, 59, 61, 61, 63, 63, 66, + 52, 50, 50, 48, 47, 47, 47, 47, 47, 47, 50, 50, 53, 54, 56, 57, 59, 61, 61, 63, 63, 66, 66, + 54, 51, 51, 50, 49, 49, 49, 48, 48, 48, 51, 51, 54, 55, 57, 58, 60, 62, 62, 65, 65, 67, 68, 69, + 54, 52, 52, 50, 49, 49, 49, 49, 48, 48, 52, 52, 55, 55, 57, 58, 60, 62, 63, 65, 65, 68, 68, 70, 71, + 56, 53, 53, 51, 51, 50, 50, 50, 49, 49, 52, 52, 55, 56, 58, 59, 61, 63, 63, 66, 66, 69, 69, 71, 72, 73, + 57, 54, 54, 52, 52, 51, 51, 51, 50, 50, 53, 53, 56, 56, 58, 60, 61, 63, 64, 67, 67, 70, 70, 72, 73, 75, 76, + 58, 55, 55, 53, 52, 52, 52, 51, 50, 51, 54, 54, 56, 57, 59, 60, 62, 64, 65, 67, 67, 71, 71, 73, 74, 75, 77, 78, + 60, 57, 57, 55, 54, 54, 53, 53, 52, 52, 55, 55, 58, 58, 60, 61, 63, 65, 66, 68, 68, 72, 72, 74, 75, 77, 79, 80, 82, + 60, 57, 57, 55, 54, 54, 54, 53, 52, 52, 55, 55, 58, 58, 60, 62, 63, 65, 66, 69, 69, 72, 73, 75, 76, 77, 79, 80, 82, 82, + 63, 60, 60, 58, 57, 57, 56, 55, 54, 55, 57, 57, 60, 60, 62, 63, 65, 67, 68, 71, 71, 74, 75, 77, 78, 80, 82, 83, 85, 85, 89, + 63, 60, 60, 58, 57, 57, 56, 55, 54, 55, 57, 57, 60, 60, 62, 63, 65, 67, 68, 71, 71, 74, 75, 77, 78, 80, 82, 83, 85, 85, 89, 89, + }, + }, { + { + 32, + 31, 31, + 31, 31, 32, + 31, 32, 32, 32, + 31, 32, 32, 32, 32, + 31, 32, 32, 32, 32, 32, + 31, 32, 32, 32, 32, 32, 33, + 31, 32, 32, 32, 32, 32, 33, 33, + 32, 32, 32, 32, 32, 32, 33, 33, 34, + 32, 32, 32, 32, 32, 32, 33, 34, 34, 35, + 32, 32, 32, 32, 32, 32, 33, 34, 34, 35, 35, + 33, 33, 33, 33, 33, 33, 34, 35, 35, 36, 36, 38, + 34, 34, 34, 34, 33, 33, 35, 35, 36, 37, 37, 39, 39, + 34, 34, 34, 34, 34, 34, 35, 36, 36, 37, 37, 40, 41, 42, + 36, 35, 35, 35, 34, 34, 36, 36, 37, 38, 38, 42, 42, 45, 48, + 36, 35, 35, 35, 34, 34, 36, 36, 37, 38, 38, 42, 42, 45, 48, 48, + 38, 38, 38, 37, 37, 37, 38, 38, 39, 40, 40, 43, 44, 46, 50, 50, 52, + 39, 38, 38, 38, 37, 37, 39, 39, 39, 40, 40, 44, 45, 47, 50, 50, 53, 54, + 41, 40, 40, 39, 38, 38, 40, 40, 40, 41, 41, 45, 46, 48, 52, 52, 54, 55, 57, + 44, 42, 42, 42, 41, 41, 42, 42, 42, 42, 42, 46, 47, 50, 54, 54, 57, 58, 60, 63, + 44, 42, 42, 42, 41, 41, 42, 42, 42, 42, 42, 46, 47, 50, 54, 54, 57, 58, 60, 63, 63, + 47, 46, 45, 45, 44, 44, 44, 45, 45, 45, 45, 49, 50, 52, 56, 56, 59, 60, 62, 66, 66, 69, + 48, 47, 46, 45, 44, 44, 45, 45, 45, 46, 46, 50, 51, 53, 57, 57, 60, 61, 63, 67, 67, 70, 71, + 50, 49, 48, 47, 46, 46, 47, 47, 47, 47, 47, 51, 52, 54, 58, 58, 61, 62, 65, 68, 68, 72, 73, 75, + 54, 52, 51, 50, 49, 49, 49, 50, 49, 49, 49, 53, 54, 56, 60, 60, 64, 65, 67, 71, 71, 75, 76, 78, 82, + 54, 52, 51, 50, 49, 49, 49, 50, 49, 49, 49, 53, 54, 56, 60, 60, 64, 65, 67, 71, 71, 75, 76, 78, 82, 82, + 58, 56, 55, 54, 53, 53, 53, 53, 53, 52, 52, 56, 57, 59, 63, 63, 67, 68, 70, 74, 74, 78, 79, 82, 86, 86, 90, + 59, 57, 56, 55, 54, 54, 54, 54, 54, 53, 53, 57, 58, 60, 64, 64, 68, 69, 71, 75, 75, 79, 80, 83, 87, 87, 91, 92, + 61, 59, 58, 57, 56, 56, 56, 56, 55, 55, 55, 59, 60, 62, 65, 65, 69, 70, 73, 77, 77, 81, 82, 85, 89, 89, 93, 94, 97, + 65, 63, 62, 61, 59, 59, 59, 59, 59, 58, 58, 62, 63, 65, 68, 68, 72, 73, 75, 79, 79, 84, 85, 88, 92, 92, 97, 98, 101, 105, + 65, 63, 62, 61, 59, 59, 59, 59, 59, 58, 58, 62, 63, 65, 68, 68, 72, 73, 75, 79, 79, 84, 85, 88, 92, 92, 97, 98, 101, 105, 105, + 70, 67, 67, 65, 64, 64, 63, 63, 63, 62, 62, 66, 67, 69, 72, 72, 76, 77, 79, 83, 83, 88, 89, 92, 96, 96, 101, 102, 105, 109, 109, 114, + }, { + 32, + 31, 31, + 31, 31, 31, + 31, 31, 31, 31, + 30, 31, 31, 31, 32, + 30, 31, 31, 31, 32, 32, + 33, 33, 34, 34, 34, 34, 37, + 33, 34, 34, 35, 35, 35, 38, 39, + 34, 36, 36, 36, 37, 37, 40, 40, 42, + 36, 38, 38, 39, 40, 40, 42, 43, 45, 47, + 36, 38, 38, 39, 40, 40, 42, 43, 45, 47, 47, + 40, 41, 41, 41, 42, 42, 44, 44, 45, 47, 47, 48, + 41, 42, 42, 42, 42, 42, 44, 45, 46, 47, 47, 48, 48, + 44, 44, 44, 44, 44, 44, 45, 46, 46, 47, 47, 49, 49, 50, + 49, 48, 47, 47, 46, 46, 47, 47, 47, 48, 48, 50, 50, 51, 53, + 49, 48, 47, 47, 46, 46, 47, 47, 47, 48, 48, 50, 50, 51, 53, 53, + 48, 47, 47, 46, 45, 45, 46, 46, 46, 47, 47, 49, 50, 51, 53, 53, 54, + 48, 47, 47, 46, 45, 45, 46, 46, 46, 46, 46, 49, 49, 51, 53, 53, 54, 54, + 49, 47, 47, 46, 45, 45, 46, 46, 46, 46, 46, 49, 49, 51, 53, 53, 54, 55, 55, + 49, 47, 47, 46, 45, 45, 45, 45, 45, 45, 45, 48, 49, 51, 53, 53, 55, 55, 57, 58, + 49, 47, 47, 46, 45, 45, 45, 45, 45, 45, 45, 48, 49, 51, 53, 53, 55, 55, 57, 58, 58, + 50, 48, 48, 47, 46, 46, 46, 46, 46, 46, 46, 49, 50, 51, 54, 54, 56, 56, 57, 59, 59, 61, + 50, 49, 48, 47, 46, 46, 46, 46, 46, 46, 46, 49, 50, 51, 54, 54, 56, 56, 58, 60, 60, 61, 61, + 51, 49, 49, 48, 47, 47, 47, 47, 47, 46, 46, 49, 50, 51, 54, 54, 56, 57, 58, 60, 60, 62, 62, 63, + 52, 50, 50, 49, 47, 47, 47, 47, 47, 47, 47, 49, 50, 52, 54, 54, 57, 57, 59, 61, 61, 63, 63, 65, 66, + 52, 50, 50, 49, 47, 47, 47, 47, 47, 47, 47, 49, 50, 52, 54, 54, 57, 57, 59, 61, 61, 63, 63, 65, 66, 66, + 54, 52, 51, 50, 49, 49, 49, 49, 48, 48, 48, 51, 51, 53, 55, 55, 58, 58, 60, 62, 62, 64, 65, 66, 68, 68, 70, + 54, 52, 52, 51, 49, 49, 49, 49, 49, 48, 48, 51, 52, 53, 55, 55, 58, 58, 60, 62, 62, 64, 65, 66, 68, 68, 70, 71, + 55, 53, 53, 52, 50, 50, 50, 50, 49, 49, 49, 51, 52, 54, 56, 56, 58, 59, 60, 63, 63, 65, 66, 67, 69, 69, 71, 72, 73, + 57, 55, 54, 53, 52, 52, 51, 51, 50, 50, 50, 52, 53, 54, 56, 56, 59, 60, 61, 63, 63, 66, 67, 68, 70, 70, 73, 73, 74, 76, + 57, 55, 54, 53, 52, 52, 51, 51, 50, 50, 50, 52, 53, 54, 56, 56, 59, 60, 61, 63, 63, 66, 67, 68, 70, 70, 73, 73, 74, 76, 76, + 59, 57, 56, 55, 54, 54, 53, 53, 52, 51, 51, 54, 55, 56, 58, 58, 60, 61, 63, 65, 65, 67, 68, 70, 72, 72, 74, 75, 76, 78, 78, 80, + }, + }, { + { + 32, + 31, 31, + 31, 31, 32, + 31, 31, 32, 32, + 31, 32, 32, 32, 32, + 31, 32, 32, 32, 32, 32, + 31, 32, 32, 32, 32, 32, 32, + 31, 32, 32, 32, 32, 32, 32, 33, + 31, 32, 32, 32, 32, 32, 32, 33, 33, + 32, 32, 32, 32, 32, 32, 33, 33, 33, 34, + 32, 32, 32, 32, 32, 32, 33, 34, 34, 34, 35, + 32, 32, 32, 32, 32, 32, 33, 34, 34, 34, 35, 35, + 32, 33, 33, 33, 33, 33, 33, 34, 34, 35, 36, 36, 36, + 34, 34, 34, 34, 33, 33, 34, 35, 35, 35, 37, 37, 38, 39, + 34, 34, 34, 34, 33, 33, 34, 35, 35, 35, 37, 37, 38, 39, 39, + 35, 34, 34, 34, 34, 34, 34, 35, 36, 36, 37, 37, 39, 41, 41, 43, + 36, 35, 35, 35, 34, 34, 35, 36, 36, 37, 38, 38, 40, 42, 42, 45, 48, + 36, 35, 35, 35, 34, 34, 35, 36, 36, 37, 38, 38, 40, 42, 42, 45, 48, 48, + 38, 37, 37, 37, 36, 36, 36, 38, 38, 38, 39, 39, 41, 44, 44, 47, 50, 50, 51, + 39, 39, 38, 38, 37, 37, 38, 39, 39, 39, 40, 40, 42, 45, 45, 47, 50, 50, 52, 54, + 39, 39, 38, 38, 37, 37, 38, 39, 39, 39, 40, 40, 42, 45, 45, 47, 50, 50, 52, 54, 54, + 42, 41, 41, 41, 40, 40, 40, 41, 41, 41, 42, 42, 44, 47, 47, 49, 53, 53, 55, 56, 56, 60, + 44, 43, 42, 42, 41, 41, 41, 42, 42, 42, 42, 42, 44, 47, 47, 50, 54, 54, 56, 58, 58, 61, 63, + 44, 43, 43, 42, 41, 41, 41, 42, 42, 42, 43, 43, 45, 48, 48, 51, 54, 54, 56, 58, 58, 62, 64, 64, + 47, 46, 45, 45, 44, 44, 44, 44, 45, 45, 45, 45, 47, 50, 50, 53, 56, 56, 58, 60, 60, 64, 66, 66, 69, + 48, 47, 46, 46, 45, 44, 45, 45, 45, 45, 46, 46, 47, 51, 51, 53, 57, 57, 59, 61, 61, 65, 67, 67, 70, 71, + 49, 48, 47, 47, 46, 45, 45, 46, 46, 46, 46, 46, 48, 51, 51, 54, 57, 57, 60, 62, 62, 66, 68, 68, 71, 72, 73, + 53, 51, 51, 51, 49, 49, 49, 49, 49, 49, 49, 49, 51, 54, 54, 57, 59, 59, 62, 64, 64, 69, 71, 71, 74, 75, 77, 81, + 54, 52, 51, 51, 50, 49, 49, 50, 50, 49, 49, 49, 51, 54, 54, 57, 60, 60, 63, 65, 65, 69, 71, 72, 75, 76, 77, 81, 82, + 55, 53, 53, 52, 51, 50, 50, 51, 51, 51, 50, 50, 52, 55, 55, 58, 61, 61, 64, 66, 66, 70, 72, 73, 76, 77, 78, 83, 83, 85, + 59, 57, 56, 56, 54, 54, 54, 54, 54, 54, 53, 53, 55, 58, 58, 61, 64, 64, 67, 69, 69, 73, 75, 76, 79, 80, 81, 86, 87, 88, 92, + 59, 57, 56, 56, 54, 54, 54, 54, 54, 54, 53, 53, 55, 58, 58, 61, 64, 64, 67, 69, 69, 73, 75, 76, 79, 80, 81, 86, 87, 88, 92, 92, + }, { + 32, + 31, 31, + 31, 31, 31, + 31, 31, 31, 31, + 30, 31, 31, 31, 31, + 30, 31, 31, 31, 31, 32, + 31, 31, 32, 32, 32, 32, 33, + 33, 34, 34, 34, 35, 35, 35, 38, + 33, 34, 34, 34, 35, 35, 36, 38, 39, + 34, 35, 35, 36, 36, 36, 37, 40, 40, 41, + 36, 38, 38, 38, 39, 40, 40, 43, 43, 44, 47, + 36, 38, 38, 38, 39, 40, 40, 43, 43, 44, 47, 47, + 38, 39, 40, 40, 41, 41, 41, 43, 44, 45, 47, 47, 47, + 41, 42, 42, 42, 42, 42, 43, 44, 45, 45, 47, 47, 48, 48, + 41, 42, 42, 42, 42, 42, 43, 44, 45, 45, 47, 47, 48, 48, 48, + 45, 45, 45, 45, 44, 44, 44, 46, 46, 46, 47, 47, 48, 49, 49, 50, + 49, 48, 47, 47, 46, 46, 46, 47, 47, 47, 48, 48, 49, 50, 50, 51, 53, + 49, 48, 47, 47, 46, 46, 46, 47, 47, 47, 48, 48, 49, 50, 50, 51, 53, 53, + 49, 47, 47, 47, 46, 46, 46, 46, 46, 47, 47, 47, 48, 50, 50, 51, 53, 53, 53, + 48, 47, 47, 47, 46, 45, 45, 46, 46, 46, 46, 46, 48, 49, 49, 51, 53, 53, 54, 54, + 48, 47, 47, 47, 46, 45, 45, 46, 46, 46, 46, 46, 48, 49, 49, 51, 53, 53, 54, 54, 54, + 49, 47, 47, 47, 45, 45, 45, 45, 45, 45, 45, 45, 47, 49, 49, 51, 53, 53, 54, 55, 55, 57, + 49, 47, 47, 46, 45, 45, 45, 45, 45, 45, 45, 45, 47, 49, 49, 51, 53, 53, 55, 55, 55, 57, 58, + 49, 47, 47, 47, 45, 45, 45, 45, 45, 45, 45, 45, 47, 49, 49, 51, 53, 53, 55, 56, 56, 58, 58, 59, + 50, 49, 48, 48, 46, 46, 46, 46, 46, 46, 46, 46, 47, 50, 50, 52, 54, 54, 55, 56, 56, 58, 59, 59, 61, + 50, 49, 48, 48, 47, 46, 46, 46, 46, 46, 46, 46, 47, 50, 50, 52, 54, 54, 55, 56, 56, 59, 60, 60, 61, 61, + 51, 49, 48, 48, 47, 46, 46, 47, 47, 46, 46, 46, 47, 50, 50, 52, 54, 54, 55, 56, 56, 59, 60, 60, 61, 62, 62, + 52, 50, 49, 49, 48, 47, 47, 47, 47, 47, 46, 46, 48, 50, 50, 52, 54, 54, 56, 57, 57, 60, 61, 61, 63, 63, 64, 66, + 52, 50, 50, 49, 48, 47, 47, 47, 47, 47, 47, 47, 48, 50, 50, 52, 54, 54, 56, 57, 57, 60, 61, 61, 63, 63, 64, 66, 66, + 53, 51, 50, 50, 48, 48, 48, 48, 48, 48, 47, 47, 48, 51, 51, 52, 54, 54, 56, 58, 58, 60, 61, 62, 63, 64, 64, 67, 67, 68, + 54, 53, 52, 52, 50, 49, 49, 49, 49, 49, 48, 48, 49, 52, 52, 53, 55, 55, 57, 58, 58, 61, 62, 63, 64, 65, 66, 68, 68, 69, 71, + 54, 53, 52, 52, 50, 49, 49, 49, 49, 49, 48, 48, 49, 52, 52, 53, 55, 55, 57, 58, 58, 61, 62, 63, 64, 65, 66, 68, 68, 69, 71, 71, + }, + }, { + { + 32, + 31, 31, + 31, 31, 32, + 31, 31, 32, 32, + 31, 31, 32, 32, 32, + 31, 31, 32, 32, 32, 32, + 31, 31, 32, 32, 32, 32, 32, + 31, 32, 32, 32, 32, 32, 32, 32, + 31, 32, 32, 32, 32, 32, 32, 32, 33, + 31, 32, 32, 32, 32, 32, 32, 32, 33, 33, + 31, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, + 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 34, + 32, 32, 32, 32, 32, 32, 32, 33, 33, 34, 34, 35, 35, + 32, 32, 32, 32, 32, 32, 32, 33, 33, 34, 34, 35, 35, 35, + 32, 33, 33, 33, 33, 33, 33, 33, 34, 34, 34, 35, 36, 36, 36, + 34, 34, 34, 34, 34, 33, 33, 34, 35, 35, 35, 36, 37, 37, 38, 39, + 34, 34, 34, 34, 34, 33, 33, 34, 35, 35, 35, 36, 37, 37, 38, 39, 39, + 34, 34, 34, 34, 34, 34, 34, 34, 35, 35, 35, 36, 37, 37, 38, 40, 40, 41, + 35, 35, 35, 35, 34, 34, 34, 34, 36, 36, 36, 37, 38, 38, 39, 42, 42, 43, 46, + 36, 35, 35, 35, 35, 34, 34, 35, 36, 36, 36, 37, 38, 38, 40, 42, 42, 44, 47, 48, + 36, 35, 35, 35, 35, 34, 34, 35, 36, 36, 36, 37, 38, 38, 40, 42, 42, 44, 47, 48, 48, + 38, 37, 37, 37, 36, 36, 36, 36, 37, 38, 38, 39, 39, 39, 41, 44, 44, 45, 48, 50, 50, 51, + 39, 39, 38, 38, 38, 37, 37, 38, 39, 39, 39, 40, 40, 40, 42, 45, 45, 46, 49, 50, 50, 52, 54, + 39, 39, 38, 38, 38, 37, 37, 38, 39, 39, 39, 40, 40, 40, 42, 45, 45, 46, 49, 50, 50, 52, 54, 54, + 41, 40, 40, 40, 39, 38, 38, 39, 40, 40, 40, 41, 41, 41, 43, 46, 46, 47, 50, 52, 52, 54, 55, 55, 57, + 44, 43, 42, 42, 42, 41, 41, 41, 42, 42, 42, 42, 42, 42, 44, 47, 47, 49, 52, 54, 54, 56, 58, 58, 60, 63, + 44, 43, 42, 42, 42, 41, 41, 41, 42, 42, 42, 42, 42, 42, 44, 47, 47, 49, 52, 54, 54, 56, 58, 58, 60, 63, 63, + 45, 44, 43, 43, 42, 41, 41, 42, 42, 42, 42, 43, 43, 43, 45, 48, 48, 49, 53, 54, 54, 57, 58, 58, 60, 64, 64, 65, + 47, 46, 45, 45, 45, 44, 44, 44, 44, 45, 45, 45, 45, 45, 47, 50, 50, 51, 55, 56, 56, 58, 60, 60, 62, 66, 66, 67, 69, + 48, 47, 46, 46, 45, 44, 44, 45, 45, 45, 45, 45, 46, 46, 47, 51, 51, 52, 55, 57, 57, 59, 61, 61, 63, 67, 67, 68, 70, 71, + 48, 47, 46, 46, 45, 44, 44, 45, 45, 45, 45, 45, 46, 46, 47, 51, 51, 52, 55, 57, 57, 59, 61, 61, 63, 67, 67, 68, 70, 71, 71, + 51, 50, 49, 49, 48, 47, 47, 47, 48, 48, 48, 48, 48, 48, 50, 53, 53, 54, 57, 58, 58, 61, 63, 63, 66, 69, 69, 70, 73, 74, 74, 77, + }, { + 32, + 31, 31, + 31, 31, 31, + 31, 31, 31, 31, + 31, 31, 31, 31, 31, + 30, 31, 31, 31, 31, 32, + 30, 31, 31, 31, 31, 32, 32, + 31, 31, 32, 32, 32, 32, 32, 33, + 33, 33, 34, 34, 34, 34, 34, 35, 37, + 33, 34, 34, 34, 35, 35, 35, 36, 38, 39, + 33, 34, 34, 34, 35, 35, 35, 36, 38, 39, 39, + 35, 36, 37, 37, 37, 38, 38, 38, 41, 41, 41, 44, + 36, 37, 38, 38, 39, 40, 40, 40, 42, 43, 43, 46, 47, + 36, 37, 38, 38, 39, 40, 40, 40, 42, 43, 43, 46, 47, 47, + 38, 39, 40, 40, 40, 41, 41, 41, 43, 44, 44, 46, 47, 47, 47, + 41, 42, 42, 42, 42, 42, 42, 43, 44, 45, 45, 46, 47, 47, 48, 48, + 41, 42, 42, 42, 42, 42, 42, 43, 44, 45, 45, 46, 47, 47, 48, 48, 48, + 43, 43, 43, 43, 43, 43, 43, 43, 45, 45, 45, 46, 47, 47, 48, 49, 49, 49, + 47, 47, 46, 46, 46, 45, 45, 46, 46, 47, 47, 47, 47, 47, 48, 50, 50, 50, 52, + 49, 48, 47, 47, 47, 46, 46, 46, 47, 47, 47, 47, 48, 48, 49, 50, 50, 51, 52, 53, + 49, 48, 47, 47, 47, 46, 46, 46, 47, 47, 47, 47, 48, 48, 49, 50, 50, 51, 52, 53, 53, + 49, 48, 47, 47, 46, 46, 46, 46, 46, 46, 46, 47, 47, 47, 48, 50, 50, 50, 52, 53, 53, 53, + 48, 47, 47, 47, 46, 45, 45, 45, 46, 46, 46, 46, 46, 46, 48, 49, 49, 50, 52, 53, 53, 54, 54, + 48, 47, 47, 47, 46, 45, 45, 45, 46, 46, 46, 46, 46, 46, 48, 49, 49, 50, 52, 53, 53, 54, 54, 54, + 49, 47, 47, 47, 46, 45, 45, 45, 46, 46, 46, 46, 46, 46, 47, 49, 49, 50, 52, 53, 53, 54, 55, 55, 55, + 49, 47, 47, 47, 46, 45, 45, 45, 45, 45, 45, 45, 45, 45, 47, 49, 49, 50, 52, 53, 53, 55, 55, 55, 57, 58, + 49, 47, 47, 47, 46, 45, 45, 45, 45, 45, 45, 45, 45, 45, 47, 49, 49, 50, 52, 53, 53, 55, 55, 55, 57, 58, 58, + 49, 48, 47, 47, 46, 45, 45, 45, 45, 45, 45, 45, 45, 45, 47, 49, 49, 50, 52, 53, 53, 55, 56, 56, 57, 59, 59, 59, + 50, 49, 48, 48, 47, 46, 46, 46, 46, 46, 46, 46, 46, 46, 47, 50, 50, 50, 53, 54, 54, 55, 56, 56, 57, 59, 59, 60, 61, + 50, 49, 48, 48, 47, 46, 46, 46, 46, 46, 46, 46, 46, 46, 47, 50, 50, 50, 53, 54, 54, 55, 56, 56, 58, 60, 60, 60, 61, 61, + 50, 49, 48, 48, 47, 46, 46, 46, 46, 46, 46, 46, 46, 46, 47, 50, 50, 50, 53, 54, 54, 55, 56, 56, 58, 60, 60, 60, 61, 61, 61, + 51, 50, 49, 49, 48, 47, 47, 47, 47, 47, 47, 47, 46, 46, 48, 50, 50, 51, 53, 54, 54, 56, 57, 57, 58, 60, 60, 61, 62, 63, 63, 64, + }, + }, { + { + 32, + 31, 31, + 31, 31, 32, + 31, 31, 32, 32, + 31, 31, 32, 32, 32, + 31, 31, 32, 32, 32, 32, + 31, 31, 32, 32, 32, 32, 32, + 31, 31, 32, 32, 32, 32, 32, 32, + 31, 31, 32, 32, 32, 32, 32, 32, 32, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 34, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 34, 34, 34, 34, 35, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 34, 34, 34, 34, 35, 35, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 34, 34, 34, 34, 35, 35, 35, + 33, 33, 33, 33, 33, 33, 33, 33, 33, 34, 34, 34, 34, 35, 36, 36, 36, 37, + 34, 34, 34, 34, 34, 34, 33, 33, 33, 34, 35, 35, 35, 36, 37, 37, 37, 38, 39, + 34, 34, 34, 34, 34, 34, 33, 33, 33, 34, 35, 35, 35, 36, 37, 37, 37, 38, 39, 39, + 34, 34, 34, 34, 34, 34, 33, 33, 33, 34, 35, 35, 35, 36, 37, 37, 37, 38, 39, 39, 39, + 35, 34, 34, 34, 34, 34, 34, 34, 34, 35, 36, 36, 36, 36, 37, 37, 37, 39, 41, 41, 41, 43, + 36, 35, 35, 35, 35, 35, 34, 34, 34, 35, 36, 36, 36, 37, 38, 38, 38, 40, 42, 42, 42, 45, 48, + 36, 35, 35, 35, 35, 35, 34, 34, 34, 35, 36, 36, 36, 37, 38, 38, 38, 40, 42, 42, 42, 45, 48, 48, + 36, 35, 35, 35, 35, 35, 34, 34, 34, 35, 36, 36, 36, 37, 38, 38, 38, 40, 42, 42, 42, 45, 48, 48, 48, + 37, 37, 37, 37, 37, 36, 36, 36, 36, 37, 38, 38, 38, 38, 39, 39, 39, 41, 44, 44, 44, 46, 49, 49, 49, 51, + 39, 39, 38, 38, 38, 38, 37, 37, 37, 38, 39, 39, 39, 40, 40, 40, 40, 42, 45, 45, 45, 47, 50, 50, 50, 52, 54, + 39, 39, 38, 38, 38, 38, 37, 37, 37, 38, 39, 39, 39, 40, 40, 40, 40, 42, 45, 45, 45, 47, 50, 50, 50, 52, 54, 54, + 39, 39, 38, 38, 38, 38, 37, 37, 37, 38, 39, 39, 39, 40, 40, 40, 40, 42, 45, 45, 45, 47, 50, 50, 50, 52, 54, 54, 54, + 41, 41, 40, 40, 40, 39, 39, 39, 39, 40, 40, 40, 40, 41, 41, 41, 41, 44, 46, 46, 46, 49, 52, 52, 52, 54, 56, 56, 56, 58, + 44, 43, 42, 42, 42, 41, 41, 41, 41, 41, 42, 42, 42, 42, 42, 42, 42, 45, 47, 47, 47, 50, 54, 54, 54, 56, 58, 58, 58, 60, 63, + 44, 43, 42, 42, 42, 41, 41, 41, 41, 41, 42, 42, 42, 42, 42, 42, 42, 45, 47, 47, 47, 50, 54, 54, 54, 56, 58, 58, 58, 60, 63, 63, + }, { + 32, + 31, 31, + 31, 31, 31, + 31, 31, 31, 31, + 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, + 30, 31, 31, 31, 31, 31, 32, + 30, 31, 31, 31, 31, 31, 32, 32, + 30, 31, 31, 31, 31, 31, 32, 32, 32, + 32, 32, 33, 33, 33, 33, 33, 33, 33, 35, + 33, 34, 34, 34, 34, 35, 35, 35, 35, 37, 39, + 33, 34, 34, 34, 34, 35, 35, 35, 35, 37, 39, 39, + 33, 34, 34, 34, 34, 35, 35, 35, 35, 37, 39, 39, 39, + 35, 35, 36, 36, 36, 37, 37, 37, 37, 39, 41, 41, 41, 43, + 36, 37, 38, 38, 38, 39, 40, 40, 40, 41, 43, 43, 43, 45, 47, + 36, 37, 38, 38, 38, 39, 40, 40, 40, 41, 43, 43, 43, 45, 47, 47, + 36, 37, 38, 38, 38, 39, 40, 40, 40, 41, 43, 43, 43, 45, 47, 47, 47, + 39, 39, 40, 40, 40, 41, 41, 41, 41, 42, 44, 44, 44, 45, 47, 47, 47, 47, + 41, 42, 42, 42, 42, 42, 42, 42, 42, 43, 45, 45, 45, 46, 47, 47, 47, 48, 48, + 41, 42, 42, 42, 42, 42, 42, 42, 42, 43, 45, 45, 45, 46, 47, 47, 47, 48, 48, 48, + 41, 42, 42, 42, 42, 42, 42, 42, 42, 43, 45, 45, 45, 46, 47, 47, 47, 48, 48, 48, 48, + 45, 45, 45, 45, 45, 44, 44, 44, 44, 45, 46, 46, 46, 47, 47, 47, 47, 48, 49, 49, 49, 50, + 49, 48, 47, 47, 47, 47, 46, 46, 46, 47, 47, 47, 47, 47, 48, 48, 48, 49, 50, 50, 50, 51, 53, + 49, 48, 47, 47, 47, 47, 46, 46, 46, 47, 47, 47, 47, 47, 48, 48, 48, 49, 50, 50, 50, 51, 53, 53, + 49, 48, 47, 47, 47, 47, 46, 46, 46, 47, 47, 47, 47, 47, 48, 48, 48, 49, 50, 50, 50, 51, 53, 53, 53, + 49, 48, 47, 47, 47, 46, 46, 46, 46, 46, 47, 47, 47, 47, 47, 47, 47, 48, 50, 50, 50, 51, 53, 53, 53, 53, + 48, 48, 47, 47, 47, 46, 45, 45, 45, 46, 46, 46, 46, 46, 46, 46, 46, 48, 49, 49, 49, 51, 53, 53, 53, 53, 54, + 48, 48, 47, 47, 47, 46, 45, 45, 45, 46, 46, 46, 46, 46, 46, 46, 46, 48, 49, 49, 49, 51, 53, 53, 53, 53, 54, 54, + 48, 48, 47, 47, 47, 46, 45, 45, 45, 46, 46, 46, 46, 46, 46, 46, 46, 48, 49, 49, 49, 51, 53, 53, 53, 53, 54, 54, 54, + 49, 48, 47, 47, 47, 46, 45, 45, 45, 45, 46, 46, 46, 46, 46, 46, 46, 47, 49, 49, 49, 51, 53, 53, 53, 54, 55, 55, 55, 56, + 49, 48, 47, 47, 47, 46, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 47, 49, 49, 49, 51, 53, 53, 53, 54, 55, 55, 55, 57, 58, + 49, 48, 47, 47, 47, 46, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 47, 49, 49, 49, 51, 53, 53, 53, 54, 55, 55, 55, 57, 58, 58, + }, + }, { + { + 32, + 31, 31, + 31, 31, 31, + 31, 31, 31, 32, + 31, 31, 31, 32, 32, + 31, 31, 31, 32, 32, 32, + 31, 31, 32, 32, 32, 32, 32, + 31, 31, 32, 32, 32, 32, 32, 32, + 31, 31, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 34, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 34, 34, 34, 34, 35, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 34, 34, 34, 34, 35, 35, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 34, 34, 34, 34, 35, 35, 35, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 34, 34, 34, 34, 35, 35, 35, 35, + 32, 32, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 34, 34, 34, 34, 35, 35, 36, 36, 36, 36, + 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 34, 34, 35, 35, 35, 35, 36, 36, 36, 36, 37, 38, + 34, 34, 34, 34, 34, 34, 34, 33, 33, 33, 33, 34, 35, 35, 35, 35, 36, 36, 37, 37, 37, 38, 39, 39, + 34, 34, 34, 34, 34, 34, 34, 33, 33, 33, 33, 34, 35, 35, 35, 35, 36, 36, 37, 37, 37, 38, 39, 39, 39, + 34, 34, 34, 34, 34, 34, 34, 33, 33, 33, 33, 34, 35, 35, 35, 35, 36, 36, 37, 37, 37, 38, 39, 39, 39, 39, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 35, 36, 36, 36, 36, 37, 37, 37, 37, 38, 40, 41, 41, 41, 42, + 35, 35, 35, 35, 35, 35, 34, 34, 34, 34, 34, 35, 36, 36, 36, 36, 37, 37, 38, 38, 38, 39, 41, 42, 42, 42, 44, 46, + 36, 35, 35, 35, 35, 35, 35, 34, 34, 34, 34, 35, 36, 36, 36, 36, 37, 38, 38, 38, 38, 40, 42, 42, 42, 42, 45, 47, 48, + 36, 35, 35, 35, 35, 35, 35, 34, 34, 34, 34, 35, 36, 36, 36, 36, 37, 38, 38, 38, 38, 40, 42, 42, 42, 42, 45, 47, 48, 48, + 36, 35, 35, 35, 35, 35, 35, 34, 34, 34, 34, 35, 36, 36, 36, 36, 37, 38, 38, 38, 38, 40, 42, 42, 42, 42, 45, 47, 48, 48, 48, + 37, 37, 36, 36, 36, 36, 36, 35, 35, 35, 35, 36, 37, 37, 37, 37, 38, 39, 39, 39, 39, 41, 42, 43, 43, 43, 45, 48, 49, 49, 49, 50, + }, { + 32, + 31, 31, + 31, 31, 31, + 31, 31, 31, 31, + 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, + 30, 31, 31, 31, 31, 31, 31, 31, + 30, 30, 31, 31, 31, 31, 31, 31, 32, + 30, 30, 31, 31, 31, 31, 31, 31, 32, 32, + 30, 30, 31, 31, 31, 31, 31, 31, 32, 32, 32, + 31, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 34, + 33, 33, 33, 34, 34, 34, 34, 34, 34, 34, 34, 36, 37, + 33, 34, 34, 34, 34, 34, 35, 35, 35, 35, 35, 37, 38, 39, + 33, 34, 34, 34, 34, 34, 35, 35, 35, 35, 35, 37, 38, 39, 39, + 33, 34, 34, 34, 34, 34, 35, 35, 35, 35, 35, 37, 38, 39, 39, 39, + 34, 35, 36, 36, 36, 36, 36, 37, 37, 37, 37, 38, 40, 40, 40, 40, 42, + 36, 36, 37, 37, 37, 37, 38, 38, 39, 39, 39, 40, 41, 42, 42, 42, 44, 46, + 36, 37, 38, 38, 38, 38, 39, 39, 40, 40, 40, 41, 42, 43, 43, 43, 45, 46, 47, + 36, 37, 38, 38, 38, 38, 39, 39, 40, 40, 40, 41, 42, 43, 43, 43, 45, 46, 47, 47, + 36, 37, 38, 38, 38, 38, 39, 39, 40, 40, 40, 41, 42, 43, 43, 43, 45, 46, 47, 47, 47, + 38, 39, 39, 40, 40, 40, 40, 41, 41, 41, 41, 42, 43, 44, 44, 44, 45, 47, 47, 47, 47, 47, + 40, 41, 41, 41, 41, 41, 41, 42, 42, 42, 42, 43, 44, 44, 44, 44, 45, 47, 47, 47, 47, 48, 48, + 41, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 43, 44, 45, 45, 45, 46, 47, 47, 47, 47, 48, 48, 48, + 41, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 43, 44, 45, 45, 45, 46, 47, 47, 47, 47, 48, 48, 48, 48, + 41, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 43, 44, 45, 45, 45, 46, 47, 47, 47, 47, 48, 48, 48, 48, 48, + 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 45, 46, 46, 46, 46, 47, 47, 47, 47, 48, 49, 49, 49, 49, 50, + 47, 47, 46, 46, 46, 46, 46, 46, 45, 45, 45, 46, 46, 47, 47, 47, 47, 47, 47, 47, 47, 48, 49, 50, 50, 50, 51, 52, + 49, 48, 48, 47, 47, 47, 47, 46, 46, 46, 46, 46, 47, 47, 47, 47, 47, 47, 48, 48, 48, 49, 50, 50, 50, 50, 51, 52, 53, + 49, 48, 48, 47, 47, 47, 47, 46, 46, 46, 46, 46, 47, 47, 47, 47, 47, 47, 48, 48, 48, 49, 50, 50, 50, 50, 51, 52, 53, 53, + 49, 48, 48, 47, 47, 47, 47, 46, 46, 46, 46, 46, 47, 47, 47, 47, 47, 47, 48, 48, 48, 49, 50, 50, 50, 50, 51, 52, 53, 53, 53, + 49, 48, 47, 47, 47, 47, 47, 46, 46, 46, 46, 46, 46, 47, 47, 47, 47, 47, 47, 47, 47, 48, 49, 50, 50, 50, 51, 52, 53, 53, 53, 53, + }, + }, { + { + 32, + 31, 31, + 31, 31, 31, + 31, 31, 31, 31, + 31, 31, 31, 32, 32, + 31, 31, 31, 32, 32, 32, + 31, 31, 31, 32, 32, 32, 32, + 31, 31, 31, 32, 32, 32, 32, 32, + 31, 31, 31, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 33, 34, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 33, 34, 34, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 34, 34, 34, 34, 34, 34, 35, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 34, 34, 34, 34, 34, 35, 35, 35, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 34, 34, 34, 34, 34, 35, 35, 35, 35, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 34, 34, 34, 34, 34, 35, 35, 35, 35, 35, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 35, 35, 35, 35, 35, 35, + 32, 32, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 35, 35, 35, 36, 36, 36, 36, 36, + 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 34, 34, 35, 35, 35, 35, 35, 35, 36, 36, 36, 36, 36, 37, 38, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 33, 33, 33, 33, 33, 34, 34, 35, 35, 35, 35, 35, 35, 36, 36, 37, 37, 37, 37, 38, 38, 39, + 34, 34, 34, 34, 34, 34, 34, 34, 34, 33, 33, 33, 33, 33, 34, 34, 35, 35, 35, 35, 35, 35, 36, 36, 37, 37, 37, 37, 38, 38, 39, 39, + }, { + 32, + 31, 31, + 31, 31, 31, + 31, 31, 31, 31, + 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, + 30, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 30, 30, 31, 31, 31, 31, 31, 31, 31, 31, 32, + 30, 30, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, + 30, 30, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, + 30, 30, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, + 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, + 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 34, 35, + 33, 33, 33, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 35, 36, 37, + 33, 34, 34, 34, 34, 34, 34, 34, 35, 35, 35, 35, 35, 35, 36, 37, 38, 39, + 33, 34, 34, 34, 34, 34, 34, 34, 35, 35, 35, 35, 35, 35, 36, 37, 38, 39, 39, + 33, 34, 34, 34, 34, 34, 34, 34, 35, 35, 35, 35, 35, 35, 36, 37, 38, 39, 39, 39, + 33, 34, 34, 34, 34, 34, 34, 34, 35, 35, 35, 35, 35, 35, 36, 37, 38, 39, 39, 39, 39, + 34, 35, 35, 35, 35, 35, 35, 36, 36, 36, 36, 36, 36, 36, 37, 38, 39, 40, 40, 40, 40, 41, + 35, 36, 36, 36, 37, 37, 37, 37, 37, 37, 38, 38, 38, 38, 38, 39, 41, 41, 41, 41, 41, 42, 44, + 36, 37, 37, 38, 38, 38, 38, 38, 38, 39, 39, 39, 39, 39, 40, 41, 42, 43, 43, 43, 43, 44, 45, 46, + 36, 37, 37, 38, 38, 38, 38, 38, 39, 39, 40, 40, 40, 40, 40, 41, 42, 43, 43, 43, 43, 44, 46, 47, 47, + 36, 37, 37, 38, 38, 38, 38, 38, 39, 39, 40, 40, 40, 40, 40, 41, 42, 43, 43, 43, 43, 44, 46, 47, 47, 47, + 36, 37, 37, 38, 38, 38, 38, 38, 39, 39, 40, 40, 40, 40, 40, 41, 42, 43, 43, 43, 43, 44, 46, 47, 47, 47, 47, + 37, 37, 38, 38, 39, 39, 39, 39, 39, 40, 40, 40, 40, 40, 41, 42, 43, 43, 43, 43, 43, 44, 46, 47, 47, 47, 47, 47, + 38, 39, 39, 40, 40, 40, 40, 40, 40, 40, 41, 41, 41, 41, 41, 42, 43, 44, 44, 44, 44, 45, 46, 47, 47, 47, 47, 47, 47, + 40, 40, 40, 41, 41, 41, 41, 41, 41, 41, 42, 42, 42, 42, 42, 43, 44, 44, 44, 44, 44, 45, 46, 47, 47, 47, 47, 47, 48, 48, + 41, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 43, 43, 44, 45, 45, 45, 45, 45, 46, 47, 47, 47, 47, 47, 48, 48, 48, + 41, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 43, 43, 44, 45, 45, 45, 45, 45, 46, 47, 47, 47, 47, 47, 48, 48, 48, 48, + }, + }, { + { + 32, + 31, 31, + 31, 31, 31, + 31, 31, 31, 31, + 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 32, + 31, 31, 31, 31, 31, 32, 32, + 31, 31, 31, 31, 31, 32, 32, 32, + 31, 31, 31, 31, 31, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 33, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 33, 33, + 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 33, 33, 33, + 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, + }, { + 32, + 31, 31, + 31, 31, 31, + 31, 31, 31, 31, + 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 30, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 30, 30, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 30, 30, 30, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, + 30, 30, 30, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, + 30, 30, 30, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, + 30, 30, 30, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, + 30, 30, 30, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, + 30, 30, 30, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, + 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 33, 33, 33, 33, 33, 33, 33, 33, 33, 34, 34, + 32, 32, 32, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 34, 34, 35, 36, + 33, 33, 33, 33, 33, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 35, 36, 37, 37, + 33, 33, 34, 34, 34, 34, 34, 34, 34, 34, 34, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 36, 37, 37, 38, 39, + 33, 33, 34, 34, 34, 34, 34, 34, 34, 34, 34, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 36, 37, 37, 38, 39, 39, + 33, 33, 34, 34, 34, 34, 34, 34, 34, 34, 34, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 36, 37, 37, 38, 39, 39, 39, + 33, 33, 34, 34, 34, 34, 34, 34, 34, 34, 34, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 36, 37, 37, 38, 39, 39, 39, 39, + 33, 33, 34, 34, 34, 34, 34, 34, 34, 34, 34, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 36, 37, 37, 38, 39, 39, 39, 39, 39, + 33, 33, 34, 34, 34, 34, 34, 34, 34, 34, 34, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 36, 37, 37, 38, 39, 39, 39, 39, 39, 39, + 34, 34, 34, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 36, 36, 36, 36, 36, 36, 36, 36, 37, 37, 38, 39, 40, 40, 40, 40, 40, 40, 40, + }, + }, { + { + 32, + 31, 31, + 31, 31, 31, + 31, 31, 31, 31, + 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + 31, 31, 31, 31, 31, 31, 31, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, + }, { + 32, + 31, 31, + 31, 31, 31, + 31, 31, 31, 31, + 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 30, 30, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 30, 30, 30, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 30, 30, 30, 30, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 30, 30, 30, 30, 30, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, + 30, 30, 30, 30, 30, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, + 30, 30, 30, 30, 30, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 32, 32, + }, + }, +}; + +const uint8_t *av1_qm_tbl[16][2][N_RECT_TX_SIZES]; +static uint8_t pb_32x32[32 * 32]; +static uint8_t qm_tbl_4x4[15][2][16]; +static uint8_t qm_tbl_4x8[15][2][32]; +static uint8_t qm_tbl_4x16[15][2][64]; +static uint8_t qm_tbl_8x8[15][2][64]; +static uint8_t qm_tbl_8x16[15][2][128]; +static uint8_t qm_tbl_8x32[15][2][256]; +static uint8_t qm_tbl_16x16[15][2][256]; +static uint8_t qm_tbl_16x32[15][2][512]; +static uint8_t qm_tbl_32x32[15][2][1024]; + +static void subsample(uint8_t *const dst, const uint8_t *const src, + const int sz, const int step) +{ + for (int y = 0; y < sz; y++) + for (int x = 0; x < sz; x++) + dst[y * sz + x] = src[y * sz * step * step + x * step]; +} + +static void transpose(uint8_t *const dst, const uint8_t *const src, + const int w, const int h) +{ + for (int y = 0, y_off = 0; y < h; y++, y_off += w) + for (int x = 0, x_off = 0; x < w; x++, x_off += h) + dst[x_off + y] = src[y_off + x]; +} + +static void untriangle(uint8_t *dst, const uint8_t *src, const int sz) { + for (int y = 0; y < sz; y++) { + memcpy(dst, src, y + 1); + const uint8_t *src_ptr = &src[y]; + for (int x = y + 1; x < sz; x++) { + src_ptr += x; + dst[x] = *src_ptr; + } + dst += sz; + src += y + 1; + } +} + +void av1_init_qm_tables(void) { + static int done = 0; + if (done) return; + done = 1; + + for (int i = 0; i < 15; i++) + for (int j = 0; j < 2; j++) { + // note that the w/h in the assignment is inverted, this is on purpose + // because we store coefficients transposed + av1_qm_tbl[i][j][RTX_4X8 ] = qm_tbl_8x4[i][j]; + av1_qm_tbl[i][j][RTX_8X4 ] = qm_tbl_4x8[i][j]; + transpose(qm_tbl_4x8[i][j], qm_tbl_8x4[i][j], 8, 4); + av1_qm_tbl[i][j][RTX_4X16 ] = qm_tbl_16x4[i][j]; + av1_qm_tbl[i][j][RTX_16X4 ] = qm_tbl_4x16[i][j]; + transpose(qm_tbl_4x16[i][j], qm_tbl_16x4[i][j], 16, 4); + av1_qm_tbl[i][j][RTX_8X16 ] = qm_tbl_16x8[i][j]; + av1_qm_tbl[i][j][RTX_16X8 ] = qm_tbl_8x16[i][j]; + transpose(qm_tbl_8x16[i][j], qm_tbl_16x8[i][j], 16, 8); + av1_qm_tbl[i][j][RTX_8X32 ] = qm_tbl_32x8[i][j]; + av1_qm_tbl[i][j][RTX_32X8 ] = qm_tbl_8x32[i][j]; + transpose(qm_tbl_8x32[i][j], qm_tbl_32x8[i][j], 32, 8); + av1_qm_tbl[i][j][RTX_16X32] = qm_tbl_32x16[i][j]; + av1_qm_tbl[i][j][RTX_32X16] = qm_tbl_16x32[i][j]; + transpose(qm_tbl_16x32[i][j], qm_tbl_32x16[i][j], 32, 16); + + av1_qm_tbl[i][j][ TX_4X4 ] = qm_tbl_4x4[i][j]; + av1_qm_tbl[i][j][ TX_8X8 ] = qm_tbl_8x8[i][j]; + av1_qm_tbl[i][j][ TX_16X16] = qm_tbl_16x16[i][j]; + av1_qm_tbl[i][j][ TX_32X32] = qm_tbl_32x32[i][j]; + untriangle(qm_tbl_4x4[i][j], qm_tbl_4x4_t[i][j], 4); + untriangle(qm_tbl_8x8[i][j], qm_tbl_8x8_t[i][j], 8); + untriangle(qm_tbl_32x32[i][j], qm_tbl_32x32_t[i][j], 32); + subsample(qm_tbl_16x16[i][j], qm_tbl_32x32[i][j], 16, 2); + + av1_qm_tbl[i][j][ TX_64X64] = av1_qm_tbl[i][j][ TX_32X32]; + av1_qm_tbl[i][j][RTX_64X32] = av1_qm_tbl[i][j][ TX_32X32]; + av1_qm_tbl[i][j][RTX_64X16] = av1_qm_tbl[i][j][RTX_32X16]; + av1_qm_tbl[i][j][RTX_32X64] = av1_qm_tbl[i][j][ TX_32X32]; + av1_qm_tbl[i][j][RTX_16X64] = av1_qm_tbl[i][j][RTX_16X32]; + } + + memset(pb_32x32, 32, sizeof(pb_32x32)); + for (int j = 0; j < 2; j++) + for (int k = 0; k < N_RECT_TX_SIZES; k++) + av1_qm_tbl[15][j][k] = pb_32x32; +} diff --git a/src/qm.h b/src/qm.h new file mode 100644 index 0000000..94565a7 --- /dev/null +++ b/src/qm.h @@ -0,0 +1,37 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_SRC_QM_H__ +#define __DAV1D_SRC_QM_H__ + +#include "src/levels.h" + +extern const uint8_t *av1_qm_tbl[16][2][N_RECT_TX_SIZES]; + +void av1_init_qm_tables(void); + +#endif /* __DAV1D_SRC_QM_H__ */ diff --git a/src/recon.c b/src/recon.c new file mode 100644 index 0000000..4d61565 --- /dev/null +++ b/src/recon.c @@ -0,0 +1,1503 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <string.h> +#include <stdio.h> + +#include "common/attributes.h" +#include "common/bitdepth.h" +#include "common/dump.h" +#include "common/intops.h" +#include "common/mem.h" + +#include "src/cdef_apply.h" +#include "src/ipred_prepare.h" +#include "src/lf_apply.h" +#include "src/lr_apply.h" +#include "src/recon.h" +#include "src/scan.h" +#include "src/tables.h" +#include "src/wedge.h" + +static unsigned read_golomb(MsacContext *const msac) { + int len = 0; + unsigned val = 1; + + while (!msac_decode_bool(msac, 128 << 7) && len < 32) len++; + while (len--) val = (val << 1) | msac_decode_bool(msac, 128 << 7); + + return val - 1; +} + +static int decode_coefs(Dav1dTileContext *const t, + uint8_t *const a, uint8_t *const l, + const enum RectTxfmSize tx, const enum BlockSize bs, + const Av1Block *const b, const int intra, + const int plane, coef *cf, + enum TxfmType *const txtp, uint8_t *res_ctx) +{ + Dav1dTileState *const ts = t->ts; + const int chroma = !!plane; + const Dav1dFrameContext *const f = t->f; + const TxfmInfo *const t_dim = &av1_txfm_dimensions[tx]; + const int dbg = DEBUG_BLOCK_INFO && plane && 0; + + if (dbg) printf("Start: r=%d\n", ts->msac.rng); + + // does this block have any non-zero coefficients + const int sctx = get_coef_skip_ctx(t_dim, bs, a, l, chroma, f->cur.p.p.layout); + const int all_skip = + msac_decode_bool_adapt(&ts->msac, ts->cdf.coef.skip[t_dim->ctx][sctx]); + if (dbg) + printf("Post-non-zero[%d][%d][%d]: r=%d\n", + t_dim->ctx, sctx, all_skip, ts->msac.rng); + if (all_skip) { + *res_ctx = 0x40; + *txtp = f->frame_hdr.segmentation.lossless[b->seg_id] ? WHT_WHT : + DCT_DCT; + return -1; + } + + // transform type (chroma: derived, luma: explicitly coded) + if (chroma) { + if (intra) { + *txtp = get_uv_intra_txtp(b->uv_mode, tx, &f->frame_hdr, b->seg_id); + } else { + const enum TxfmType y_txtp = *txtp; + *txtp = get_uv_inter_txtp(t_dim, y_txtp, &f->frame_hdr, b->seg_id); + } + } else { + const enum TxfmTypeSet set = get_ext_txtp_set(tx, !intra, + &f->frame_hdr, b->seg_id); + const unsigned set_cnt = av1_tx_type_count[set]; + unsigned idx; + if (set_cnt == 1) { + idx = 0; + } else { + const int set_idx = av1_tx_type_set_index[!intra][set]; + const enum IntraPredMode y_mode_nofilt = b->y_mode == FILTER_PRED ? + av1_filter_mode_to_y_mode[b->y_angle] : b->y_mode; + uint16_t *const txtp_cdf = intra ? + ts->cdf.m.txtp_intra[set_idx][t_dim->min][y_mode_nofilt] : + ts->cdf.m.txtp_inter[set_idx][t_dim->min]; + idx = msac_decode_symbol_adapt(&ts->msac, txtp_cdf, set_cnt); + if (dbg) + printf("Post-txtp[%d->%d][%d->%d][%d][%d->%d]: r=%d\n", + set, set_idx, tx, t_dim->min, b->intra ? y_mode_nofilt : -1, + idx, av1_tx_types_per_set[set][idx], ts->msac.rng); + } + *txtp = av1_tx_types_per_set[set][idx]; + } + + // find end-of-block (eob) + int eob_bin; + const int tx2dszctx = imin(t_dim->lw, TX_32X32) + imin(t_dim->lh, TX_32X32); + const enum TxClass tx_class = av1_tx_type_class[*txtp]; + const int is_1d = tx_class != TX_CLASS_2D; + switch (tx2dszctx) { +#define case_sz(sz, bin) \ + case sz: { \ + uint16_t *const eob_bin_cdf = ts->cdf.coef.eob_bin_##bin[chroma][is_1d]; \ + eob_bin = msac_decode_symbol_adapt(&ts->msac, eob_bin_cdf, 5 + sz); \ + break; \ + } + case_sz(0, 16); + case_sz(1, 32); + case_sz(2, 64); + case_sz(3, 128); + case_sz(4, 256); + case_sz(5, 512); + case_sz(6, 1024); +#undef case_sz + } + if (dbg) + printf("Post-eob_bin_%d[%d][%d][%d]: r=%d\n", + 16 << tx2dszctx, chroma, is_1d, eob_bin, ts->msac.rng); + int eob; + if (eob_bin > 1) { + eob = 1 << (eob_bin - 1); + uint16_t *const eob_hi_bit_cdf = + ts->cdf.coef.eob_hi_bit[t_dim->ctx][chroma][eob_bin]; + const int eob_hi_bit = msac_decode_bool_adapt(&ts->msac, eob_hi_bit_cdf); + if (dbg) + printf("Post-eob_hi_bit[%d][%d][%d][%d]: r=%d\n", + t_dim->ctx, chroma, eob_bin, eob_hi_bit, ts->msac.rng); + unsigned mask = eob >> 1; + if (eob_hi_bit) eob |= mask; + for (mask >>= 1; mask; mask >>= 1) { + const int eob_bit = msac_decode_bool(&ts->msac, 128 << 7); + if (eob_bit) eob |= mask; + } + if (dbg) + printf("Post-eob[%d]: r=%d\n", eob, ts->msac.rng); + } else { + eob = eob_bin; + } + + // base tokens + uint16_t (*const br_cdf)[5] = + ts->cdf.coef.br_tok[imin(t_dim->ctx, 3)][chroma]; + const int16_t *const scan = av1_scans[tx][tx_class]; + uint8_t levels[36 * 36]; + ptrdiff_t stride = 4 * (imin(t_dim->h, 8) + 1); + memset(levels, 0, stride * 4 * (imin(t_dim->w, 8) + 1)); + const int shift = 2 + imin(t_dim->lh, 3), mask = 4 * imin(t_dim->h, 8) - 1; + unsigned cul_level = 0; + for (int i = eob, is_last = 1; i >= 0; i--, is_last = 0) { + const int rc = scan[i], x = rc >> shift, y = rc & mask; + + // lo tok + const int ctx = get_coef_nz_ctx(levels, i, rc, is_last, tx, tx_class); + uint16_t *const lo_cdf = is_last ? + ts->cdf.coef.eob_base_tok[t_dim->ctx][chroma][ctx] : + ts->cdf.coef.base_tok[t_dim->ctx][chroma][ctx]; + int tok = msac_decode_symbol_adapt(&ts->msac, lo_cdf, + 4 - is_last) + is_last; + if (dbg) + printf("Post-lo_tok[%d][%d][%d][%d=%d=%d]: r=%d\n", + t_dim->ctx, chroma, ctx, i, rc, tok, ts->msac.rng); + if (!tok) continue; + + // hi tok + if (tok == 3) { + const int br_ctx = get_br_ctx(levels, rc, tx, tx_class); + do { + const int tok_br = + msac_decode_symbol_adapt(&ts->msac, br_cdf[br_ctx], 4); + if (dbg) + printf("Post-hi_tok[%d][%d][%d][%d=%d=%d->%d]: r=%d\n", + imin(t_dim->ctx, 3), chroma, br_ctx, + i, rc, tok_br, tok, ts->msac.rng); + tok += tok_br; + if (tok_br < 3) break; + } while (tok < 15); + } + + levels[x * stride + y] = cf[rc] = tok; + } + + // residual and sign + int dc_sign = 1; + const uint16_t *const dq_tbl = ts->dq[b->seg_id][plane]; + const uint8_t *const qm_tbl = f->qm[is_1d || *txtp == IDTX][tx][plane]; + const int dq_shift = imax(0, t_dim->ctx - 2); + for (int i = 0; i <= eob; i++) { + const int rc = scan[i]; + int tok = cf[rc]; + if (!tok) continue; + int dq; + + // sign + int sign; + if (i == 0) { + const int dc_sign_ctx = get_dc_sign_ctx(t_dim, a, l); + uint16_t *const dc_sign_cdf = + ts->cdf.coef.dc_sign[chroma][dc_sign_ctx]; + sign = msac_decode_bool_adapt(&ts->msac, dc_sign_cdf); + if (dbg) + printf("Post-dc_sign[%d][%d][%d]: r=%d\n", + chroma, dc_sign_ctx, sign, ts->msac.rng); + dc_sign = sign ? 0 : 2; + dq = (dq_tbl[0] * qm_tbl[0] + 16) >> 5; + } else { + sign = msac_decode_bool(&ts->msac, 128 << 7); + if (dbg) + printf("Post-sign[%d=%d=%d]: r=%d\n", i, rc, sign, ts->msac.rng); + dq = (dq_tbl[1] * qm_tbl[rc] + 16) >> 5; + } + + // residual + if (tok == 15) { + tok += read_golomb(&ts->msac); + if (dbg) + printf("Post-residual[%d=%d=%d->%d]: r=%d\n", + i, rc, tok - 15, tok, ts->msac.rng); + } + + // dequant + cul_level += tok; + tok *= dq; + tok >>= dq_shift; + cf[rc] = sign ? -tok : tok; + } + + // context + *res_ctx = imin(cul_level, 63) | (dc_sign << 6); + + return eob; +} + +static void read_coef_tree(Dav1dTileContext *const t, + const enum BlockSize bs, const Av1Block *const b, + const enum RectTxfmSize ytx, const int depth, + const uint16_t *const tx_split, + const int x_off, const int y_off, pixel *dst) +{ + const Dav1dFrameContext *const f = t->f; + Dav1dTileState *const ts = t->ts; + const Dav1dDSPContext *const dsp = f->dsp; + const TxfmInfo *const t_dim = &av1_txfm_dimensions[ytx]; + const int txw = t_dim->w, txh = t_dim->h; + + if (depth < 2 && tx_split[depth] & (1 << (y_off * 4 + x_off))) { + const enum RectTxfmSize sub = t_dim->sub; + const TxfmInfo *const sub_t_dim = &av1_txfm_dimensions[sub]; + const int txsw = sub_t_dim->w, txsh = sub_t_dim->h; + + read_coef_tree(t, bs, b, sub, depth + 1, tx_split, + x_off * 2 + 0, y_off * 2 + 0, dst); + t->bx += txsw; + if (txw >= txh && t->bx < f->bw) + read_coef_tree(t, bs, b, sub, depth + 1, tx_split, x_off * 2 + 1, + y_off * 2 + 0, dst ? &dst[4 * txsw] : NULL); + t->bx -= txsw; + t->by += txsh; + if (txh >= txw && t->by < f->bh) { + if (dst) + dst += 4 * txsh * PXSTRIDE(f->cur.p.stride[0]); + read_coef_tree(t, bs, b, sub, depth + 1, tx_split, + x_off * 2 + 0, y_off * 2 + 1, dst); + t->bx += txsw; + if (txw >= txh && t->bx < f->bw) + read_coef_tree(t, bs, b, sub, depth + 1, tx_split, x_off * 2 + 1, + y_off * 2 + 1, dst ? &dst[4 * txsw] : NULL); + t->bx -= txsw; + } + t->by -= txsh; + } else { + const int bx4 = t->bx & 31, by4 = t->by & 31; + enum TxfmType txtp; + uint8_t cf_ctx; + int eob; + coef *cf; + struct CodedBlockInfo *cbi; + + if (f->frame_thread.pass) { + cf = ts->frame_thread.cf; + ts->frame_thread.cf += imin(t_dim->w, 8) * imin(t_dim->h, 8) * 16; + cbi = &f->frame_thread.cbi[t->by * f->b4_stride + t->bx]; + } else { + cf = t->cf; + } + if (f->frame_thread.pass != 2) { + eob = decode_coefs(t, &t->a->lcoef[bx4], &t->l.lcoef[by4], + ytx, bs, b, 0, 0, cf, &txtp, &cf_ctx); + if (DEBUG_BLOCK_INFO) + printf("Post-y-cf-blk[tx=%d,txtp=%d,eob=%d]: r=%d\n", + ytx, txtp, eob, ts->msac.rng); + memset(&t->a->lcoef[bx4], cf_ctx, imin(txw, f->bw - t->bx)); + memset(&t->l.lcoef[by4], cf_ctx, imin(txh, f->bh - t->by)); + for (int y = 0; y < txh; y++) + memset(&t->txtp_map[(by4 + y) * 32 + bx4], txtp, txw); + if (f->frame_thread.pass == 1) { + cbi->eob[0] = eob; + cbi->txtp[0] = txtp; + } + } else { + eob = cbi->eob[0]; + txtp = cbi->txtp[0]; + } + if (!(f->frame_thread.pass & 1)) { + assert(dst); + if (eob >= 0) { + if (DEBUG_BLOCK_INFO && DEBUG_B_PIXELS) + coef_dump(cf, imin(t_dim->h, 8) * 4, imin(t_dim->w, 8) * 4, 3, "dq"); + dsp->itx.itxfm_add[ytx][txtp](dst, f->cur.p.stride[0], cf, eob); + if (DEBUG_BLOCK_INFO && DEBUG_B_PIXELS) + hex_dump(dst, f->cur.p.stride[0], t_dim->w * 4, t_dim->h * 4, "recon"); + } + } + } +} + +void bytefn(read_coef_blocks)(Dav1dTileContext *const t, + const enum BlockSize bs, const Av1Block *const b) +{ + const Dav1dFrameContext *const f = t->f; + const int ss_ver = f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I420; + const int ss_hor = f->cur.p.p.layout != DAV1D_PIXEL_LAYOUT_I444; + const int bx4 = t->bx & 31, by4 = t->by & 31; + const int cbx4 = bx4 >> ss_hor, cby4 = by4 >> ss_ver; + const uint8_t *const b_dim = av1_block_dimensions[bs]; + const int bw4 = b_dim[0], bh4 = b_dim[1]; + const int cbw4 = (bw4 + 1) >> ss_hor, cbh4 = (bh4 + 1) >> ss_ver; + const int has_chroma = f->seq_hdr.layout != DAV1D_PIXEL_LAYOUT_I400 && + (bw4 > ss_hor || t->bx & 1) && + (bh4 > ss_ver || t->by & 1); + + if (b->skip) { + memset(&t->a->lcoef[bx4], 0x40, bw4); + memset(&t->l.lcoef[by4], 0x40, bh4); + if (has_chroma) for (int pl = 0; pl < 2; pl++) { + memset(&t->a->ccoef[pl][cbx4], 0x40, cbw4); + memset(&t->l.ccoef[pl][cby4], 0x40, cbh4); + } + return; + } + + Dav1dTileState *const ts = t->ts; + const int w4 = imin(bw4, f->bw - t->bx), h4 = imin(bh4, f->bh - t->by); + const int cw4 = (w4 + ss_hor) >> ss_hor, ch4 = (h4 + ss_ver) >> ss_ver; + assert(f->frame_thread.pass == 1); + assert(!b->skip); + const TxfmInfo *const uv_t_dim = &av1_txfm_dimensions[b->uvtx]; + const TxfmInfo *const t_dim = &av1_txfm_dimensions[b->intra ? b->tx : b->max_ytx]; + + for (int init_y = 0; init_y < h4; init_y += 16) { + for (int init_x = 0; init_x < w4; init_x += 16) { + const int sub_h4 = imin(h4, 16 + init_y); + const int sub_w4 = imin(w4, init_x + 16); + int y_off = !!init_y, y, x; + for (y = init_y, t->by += init_y; y < sub_h4; + y += t_dim->h, t->by += t_dim->h, y_off++) + { + struct CodedBlockInfo *const cbi = + &f->frame_thread.cbi[t->by * f->b4_stride]; + int x_off = !!init_x; + for (x = init_x, t->bx += init_x; x < sub_w4; + x += t_dim->w, t->bx += t_dim->w, x_off++) + { + if (!b->intra) { + read_coef_tree(t, bs, b, b->max_ytx, 0, b->tx_split, + x_off, y_off, NULL); + } else { + uint8_t cf_ctx = 0x40; + enum TxfmType txtp; + const int eob = cbi[t->bx].eob[0] = + decode_coefs(t, &t->a->lcoef[bx4 + x], + &t->l.lcoef[by4 + y], b->tx, bs, b, 1, + 0, ts->frame_thread.cf, &txtp, &cf_ctx); + if (DEBUG_BLOCK_INFO) + printf("Post-y-cf-blk[tx=%d,txtp=%d,eob=%d]: r=%d\n", + b->tx, txtp, eob, ts->msac.rng); + cbi[t->bx].txtp[0] = txtp; + ts->frame_thread.cf += imin(t_dim->w, 8) * imin(t_dim->h, 8) * 16; + memset(&t->a->lcoef[bx4 + x], cf_ctx, + imin(t_dim->w, f->bw - t->bx)); + memset(&t->l.lcoef[by4 + y], cf_ctx, + imin(t_dim->h, f->bh - t->by)); + } + } + t->bx -= x; + } + t->by -= y; + + if (!has_chroma) continue; + + const int sub_ch4 = imin(ch4, (init_y + 16) >> ss_ver); + const int sub_cw4 = imin(cw4, (init_x + 16) >> ss_hor); + for (int pl = 0; pl < 2; pl++) { + for (y = init_y >> ss_ver, t->by += init_y; y < sub_ch4; + y += uv_t_dim->h, t->by += uv_t_dim->h << ss_ver) + { + struct CodedBlockInfo *const cbi = + &f->frame_thread.cbi[t->by * f->b4_stride]; + for (x = init_x >> ss_hor, t->bx += init_x; x < sub_cw4; + x += uv_t_dim->w, t->bx += uv_t_dim->w << ss_hor) + { + uint8_t cf_ctx = 0x40; + enum TxfmType txtp; + if (!b->intra) + txtp = t->txtp_map[(by4 + (y << ss_ver)) * 32 + + bx4 + (x << ss_hor)]; + const int eob = cbi[t->bx].eob[1 + pl] = + decode_coefs(t, &t->a->ccoef[pl][cbx4 + x], + &t->l.ccoef[pl][cby4 + y], b->uvtx, bs, + b, b->intra, 1 + pl, ts->frame_thread.cf, + &txtp, &cf_ctx); + if (DEBUG_BLOCK_INFO) + printf("Post-uv-cf-blk[pl=%d,tx=%d," + "txtp=%d,eob=%d]: r=%d\n", + pl, b->uvtx, txtp, eob, ts->msac.rng); + cbi[t->bx].txtp[1 + pl] = txtp; + ts->frame_thread.cf += uv_t_dim->w * uv_t_dim->h * 16; + memset(&t->a->ccoef[pl][cbx4 + x], cf_ctx, + imin(uv_t_dim->w, (f->bw - t->bx + ss_hor) >> ss_hor)); + memset(&t->l.ccoef[pl][cby4 + y], cf_ctx, + imin(uv_t_dim->h, (f->bh - t->by + ss_ver) >> ss_ver)); + } + t->bx -= x << ss_hor; + } + t->by -= y << ss_ver; + } + } + } +} + +static void emu_edge(pixel *dst, const ptrdiff_t dst_stride, + const pixel *ref, const ptrdiff_t ref_stride, + const int bw, const int bh, + const int iw, const int ih, + const int x, const int y) +{ + // find offset in reference of visible block to copy + ref += iclip(y, 0, ih - 1) * PXSTRIDE(ref_stride) + iclip(x, 0, iw - 1); + + // number of pixels to extend (left, right, top, bottom) + const int left_ext = iclip(-x, 0, bw - 1); + const int right_ext = iclip(x + bw - iw, 0, bw - 1); + assert(left_ext + right_ext < bw); + const int top_ext = iclip(-y, 0, bh - 1); + const int bottom_ext = iclip(y + bh - ih, 0, bh - 1); + assert(top_ext + bottom_ext < bh); + + // copy visible portion first + pixel *blk = dst + top_ext * PXSTRIDE(dst_stride); + const int center_w = bw - left_ext - right_ext; + const int center_h = bh - top_ext - bottom_ext; + for (int y = 0; y < center_h; y++) { + pixel_copy(blk + left_ext, ref, center_w); + // extend left edge for this line + if (left_ext) + pixel_set(blk, blk[left_ext], left_ext); + // extend right edge for this line + if (right_ext) + pixel_set(blk + left_ext + center_w, blk[left_ext + center_w - 1], + right_ext); + ref += PXSTRIDE(ref_stride); + blk += PXSTRIDE(dst_stride); + } + + // copy top + blk = dst + top_ext * PXSTRIDE(dst_stride); + for (int y = 0; y < top_ext; y++) { + pixel_copy(dst, blk, bw); + dst += PXSTRIDE(dst_stride); + } + + // copy bottom + dst += center_h * PXSTRIDE(dst_stride); + for (int y = 0; y < bottom_ext; y++) { + pixel_copy(dst, &dst[-PXSTRIDE(dst_stride)], bw); + dst += PXSTRIDE(dst_stride); + } +} + +static void mc(Dav1dTileContext *const t, + pixel *const dst8, coef *const dst16, const ptrdiff_t dst_stride, + const int bw4, const int bh4, + const int bx, const int by, const int pl, + const mv mv, const Dav1dThreadPicture *const refp, + const enum Filter2d filter_2d) +{ + assert((dst8 != NULL) ^ (dst16 != NULL)); + const Dav1dFrameContext *const f = t->f; + const int ss_ver = !!pl && f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I420; + const int ss_hor = !!pl && f->cur.p.p.layout != DAV1D_PIXEL_LAYOUT_I444; + const int h_mul = 4 >> ss_hor, v_mul = 4 >> ss_ver; + const int mvx = mv.x, mvy = mv.y; + const int mx = mvx & (15 >> !ss_hor), my = mvy & (15 >> !ss_ver); + const int dx = bx * h_mul + (mvx >> (3 + ss_hor)); + const int dy = by * v_mul + (mvy >> (3 + ss_ver)); + ptrdiff_t ref_stride = refp->p.stride[!!pl]; + const pixel *ref; + + dav1d_thread_picture_wait(refp, dy + bh4 * v_mul + !!my * 4, + PLANE_TYPE_Y + !!pl); + if (dx < 3 || dx + bw4 * h_mul + 4 > f->bw * h_mul || + dy < 3 || dy + bh4 * v_mul + 4 > f->bh * v_mul) + { + emu_edge(t->emu_edge, 160 * sizeof(pixel), refp->p.data[pl], ref_stride, + bw4 * h_mul + 7, bh4 * v_mul + 7, f->bw * h_mul, f->bh * v_mul, + dx - 3, dy - 3); + ref = &t->emu_edge[160 * 3 + 3]; + ref_stride = 160 * sizeof(pixel); + } else { + ref = ((pixel *) refp->p.data[pl]) + PXSTRIDE(ref_stride) * dy + dx; + } + + if (dst8 != NULL) { + f->dsp->mc.mc[filter_2d](dst8, dst_stride, ref, ref_stride, bw4 * h_mul, + bh4 * v_mul, mx << !ss_hor, my << !ss_ver); + } else { + f->dsp->mc.mct[filter_2d](dst16, ref, ref_stride, bw4 * h_mul, + bh4 * v_mul, mx << !ss_hor, my << !ss_ver); + } +} + +static void obmc(Dav1dTileContext *const t, + pixel *const dst, const ptrdiff_t dst_stride, + const uint8_t *const b_dim, const int pl, + const int bx4, const int by4, const int w4, const int h4) +{ + assert(!(t->bx & 1) && !(t->by & 1)); + const Dav1dFrameContext *const f = t->f; + const refmvs *const r = &f->mvs[t->by * f->b4_stride + t->bx]; + pixel *const lap = t->scratch.lap; + static const uint8_t obmc_mask_2[2] = { 19, 0 }; + static const uint8_t obmc_mask_4[4] = { 25, 14, 5, 0 }; + static const uint8_t obmc_mask_8[8] = { 28, 22, 16, 11, 7, 3, 0, 0 }; + static const uint8_t obmc_mask_16[16] = { 30, 27, 24, 21, 18, 15, 12, 10, + 8, 6, 4, 3, 0, 0, 0, 0 }; + static const uint8_t obmc_mask_32[32] = { 31, 29, 28, 26, 24, 23, 21, 20, + 19, 17, 16, 14, 13, 12, 11, 9, + 8, 7, 6, 5, 4, 4, 3, 2, + 0, 0, 0, 0, 0, 0, 0, 0 }; + static const uint8_t *const obmc_masks[] = { + obmc_mask_2, obmc_mask_4, obmc_mask_8, obmc_mask_16, obmc_mask_32 + }; + const int ss_ver = !!pl && f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I420; + const int ss_hor = !!pl && f->cur.p.p.layout != DAV1D_PIXEL_LAYOUT_I444; + const int h_mul = 4 >> ss_hor, v_mul = 4 >> ss_ver; + + if (t->by > t->ts->tiling.row_start && + (!pl || b_dim[0] * h_mul + b_dim[1] * v_mul >= 16)) + { + for (int i = 0, x = 0; x < w4 && i < imin(b_dim[2], 4); ) { + // only odd blocks are considered for overlap handling, hence +1 + const refmvs *const a_r = &r[x - f->b4_stride + 1]; + const uint8_t *const a_b_dim = + av1_block_dimensions[sbtype_to_bs[a_r->sb_type]]; + + if (a_r->ref[0] > 0) { + mc(t, lap, NULL, 128 * sizeof(pixel), + iclip(a_b_dim[0], 2, b_dim[0]), imin(b_dim[1], 16) >> 1, + t->bx + x, t->by, pl, a_r->mv[0], + &f->refp[a_r->ref[0] - 1], + av1_filter_2d[t->a->filter[1][bx4 + x + 1]][t->a->filter[0][bx4 + x + 1]]); + f->dsp->mc.blend(&dst[x * h_mul], dst_stride, + lap, 128 * sizeof(pixel), + h_mul * iclip(a_b_dim[0], 2, b_dim[0]), + v_mul * imin(b_dim[1], 16) >> 1, + obmc_masks[imin(b_dim[3], 4) - ss_ver], 1); + i++; + } + x += imax(a_b_dim[0], 2); + } + } + + if (t->bx > t->ts->tiling.col_start) + for (int i = 0, y = 0; y < h4 && i < imin(b_dim[3], 4); ) { + // only odd blocks are considered for overlap handling, hence +1 + const refmvs *const l_r = &r[(y + 1) * f->b4_stride - 1]; + const uint8_t *const l_b_dim = + av1_block_dimensions[sbtype_to_bs[l_r->sb_type]]; + + if (l_r->ref[0] > 0) { + mc(t, lap, NULL, 32 * sizeof(pixel), + imin(b_dim[0], 16) >> 1, + iclip(l_b_dim[1], 2, b_dim[1]), + t->bx, t->by + y, pl, l_r->mv[0], + &f->refp[l_r->ref[0] - 1], + av1_filter_2d[t->l.filter[1][by4 + y + 1]][t->l.filter[0][by4 + y + 1]]); + f->dsp->mc.blend(&dst[y * v_mul * PXSTRIDE(dst_stride)], dst_stride, + lap, 32 * sizeof(pixel), + h_mul * imin(b_dim[0], 16) >> 1, + v_mul * iclip(l_b_dim[1], 2, b_dim[1]), + obmc_masks[imin(b_dim[2], 4) - ss_hor], 0); + i++; + } + y += imax(l_b_dim[1], 2); + } +} + +static void warp_affine(Dav1dTileContext *const t, + pixel *dst8, coef *dst16, const ptrdiff_t dstride, + const uint8_t *const b_dim, const int pl, + const Dav1dThreadPicture *const refp, + const WarpedMotionParams *const wmp) +{ + assert((dst8 != NULL) ^ (dst16 != NULL)); + const Dav1dFrameContext *const f = t->f; + const Dav1dDSPContext *const dsp = f->dsp; + const int ss_ver = !!pl && f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I420; + const int ss_hor = !!pl && f->cur.p.p.layout != DAV1D_PIXEL_LAYOUT_I444; + const int h_mul = 4 >> ss_hor, v_mul = 4 >> ss_ver; + assert(!((b_dim[0] * h_mul) & 7) && !((b_dim[1] * v_mul) & 7)); + const int32_t *const mat = wmp->matrix; + const int width = f->bw * h_mul, height = f->bh * v_mul; + + for (int y = 0; y < b_dim[1] * v_mul; y += 8) { + for (int x = 0; x < b_dim[0] * h_mul; x += 8) { + // calculate transformation relative to center of 8x8 block in + // luma pixel units + const int src_x = t->bx * 4 + ((x + 4) << ss_hor); + const int src_y = t->by * 4 + ((y + 4) << ss_ver); + const int mvx = (mat[2] * src_x + mat[3] * src_y + mat[0]) >> ss_hor; + const int mvy = (mat[4] * src_x + mat[5] * src_y + mat[1]) >> ss_ver; + + const int dx = (mvx >> 16) - 4; + const int mx = ((mvx & 0xffff) - wmp->alpha * 4 - + wmp->beta * 7) & ~0x3f; + const int dy = (mvy >> 16) - 4; + const int my = ((mvy & 0xffff) - wmp->gamma * 4 - + wmp->delta * 4) & ~0x3f; + + const pixel *ref_ptr; + ptrdiff_t ref_stride = refp->p.stride[!!pl]; + + dav1d_thread_picture_wait(refp, dy + 4 + 8, + PLANE_TYPE_Y + !!pl); + if (dx < 3 || dx + 8 + 4 > width || dy < 3 || dy + 8 + 4 > height) { + emu_edge(t->emu_edge, 160 * sizeof(pixel), refp->p.data[pl], + ref_stride, 15, 15, width, height, dx - 3, dy - 3); + ref_ptr = &t->emu_edge[160 * 3 + 3]; + ref_stride = 160 * sizeof(pixel); + } else { + ref_ptr = ((pixel *) refp->p.data[pl]) + PXSTRIDE(ref_stride) * dy + dx; + } + if (dst16 != NULL) + dsp->mc.warp8x8t(&dst16[x], dstride, ref_ptr, ref_stride, + wmp->abcd, mx, my); + else + dsp->mc.warp8x8(&dst8[x], dstride, ref_ptr, ref_stride, + wmp->abcd, mx, my); + } + if (dst8) dst8 += 8 * PXSTRIDE(dstride); + else dst16 += 8 * dstride; + } +} + +void bytefn(recon_b_intra)(Dav1dTileContext *const t, const enum BlockSize bs, + const enum EdgeFlags intra_edge_flags, + const Av1Block *const b) +{ + Dav1dTileState *const ts = t->ts; + const Dav1dFrameContext *const f = t->f; + const Dav1dDSPContext *const dsp = f->dsp; + const int bx4 = t->bx & 31, by4 = t->by & 31; + const int ss_ver = f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I420; + const int ss_hor = f->cur.p.p.layout != DAV1D_PIXEL_LAYOUT_I444; + const int cbx4 = bx4 >> ss_hor, cby4 = by4 >> ss_ver; + const uint8_t *const b_dim = av1_block_dimensions[bs]; + const int bw4 = b_dim[0], bh4 = b_dim[1]; + const int w4 = imin(bw4, f->bw - t->bx), h4 = imin(bh4, f->bh - t->by); + const int cw4 = (w4 + ss_hor) >> ss_hor, ch4 = (h4 + ss_ver) >> ss_ver; + const int has_chroma = f->seq_hdr.layout != DAV1D_PIXEL_LAYOUT_I400 && + (bw4 > ss_hor || t->bx & 1) && + (bh4 > ss_ver || t->by & 1); + const TxfmInfo *const t_dim = &av1_txfm_dimensions[b->tx]; + const TxfmInfo *const uv_t_dim = &av1_txfm_dimensions[b->uvtx]; + + // coefficient coding + pixel edge_mem[257], *const edge = &edge_mem[128]; + const int cbw4 = (bw4 + ss_hor) >> ss_hor, cbh4 = (bh4 + ss_ver) >> ss_ver; + + for (int init_y = 0; init_y < h4; init_y += 16) { + for (int init_x = 0; init_x < w4; init_x += 16) { + if (b->pal_sz[0]) { + pixel *dst = ((pixel *) f->cur.p.data[0]) + + 4 * (t->by * PXSTRIDE(f->cur.p.stride[0]) + t->bx); + const uint8_t *pal_idx; + if (f->frame_thread.pass) { + pal_idx = ts->frame_thread.pal_idx; + ts->frame_thread.pal_idx += bw4 * bh4 * 16; + } else { + pal_idx = t->scratch.pal_idx; + } + const uint16_t *const pal = f->frame_thread.pass ? + f->frame_thread.pal[((t->by >> 1) + (t->bx & 1)) * (f->b4_stride >> 1) + + ((t->bx >> 1) + (t->by & 1))][0] : t->pal[0]; + f->dsp->ipred.pal_pred(dst, f->cur.p.stride[0], pal, + pal_idx, bw4 * 4, bh4 * 4); + if (DEBUG_BLOCK_INFO && DEBUG_B_PIXELS) + hex_dump(dst, PXSTRIDE(f->cur.p.stride[0]), + bw4 * 4, bh4 * 4, "y-pal-pred"); + } + + const int sm_fl = sm_flag(t->a, bx4) | sm_flag(&t->l, by4); + const int sb_has_tr = init_x + 16 < w4 ? 1 : init_y ? 0 : + intra_edge_flags & EDGE_I444_TOP_HAS_RIGHT; + const int sb_has_bl = init_x ? 0 : init_y + 16 < h4 ? 1 : + intra_edge_flags & EDGE_I444_LEFT_HAS_BOTTOM; + int y, x; + const int sub_h4 = imin(h4, 16 + init_y); + const int sub_w4 = imin(w4, init_x + 16); + for (y = init_y, t->by += init_y; y < sub_h4; + y += t_dim->h, t->by += t_dim->h) + { + pixel *dst = ((pixel *) f->cur.p.data[0]) + + 4 * (t->by * PXSTRIDE(f->cur.p.stride[0]) + + t->bx + init_x); + for (x = init_x, t->bx += init_x; x < sub_w4; + x += t_dim->w, t->bx += t_dim->w) + { + if (b->pal_sz[0]) goto skip_y_pred; + + int angle = b->y_angle; + const enum EdgeFlags edge_flags = + (((y > init_y || !sb_has_tr) && (x + t_dim->w >= sub_w4)) ? + 0 : EDGE_I444_TOP_HAS_RIGHT) | + ((x > init_x || (!sb_has_bl && y + t_dim->h >= sub_h4)) ? + 0 : EDGE_I444_LEFT_HAS_BOTTOM); + const pixel *top_sb_edge = NULL; + if (!(t->by & (f->sb_step - 1))) { + top_sb_edge = f->ipred_edge[0]; + const int sby = t->by >> f->sb_shift; + top_sb_edge += f->sb128w * 128 * (sby - 1); + } + const enum IntraPredMode m = + bytefn(prepare_intra_edges)(t->bx, + t->bx > ts->tiling.col_start, + t->by, + t->by > ts->tiling.row_start, + ts->tiling.col_end, + ts->tiling.row_end, + edge_flags, dst, + f->cur.p.stride[0], top_sb_edge, + b->y_mode, &angle, + t_dim->w, t_dim->h, edge); + dsp->ipred.intra_pred[b->tx][m](dst, f->cur.p.stride[0], + edge, angle | sm_fl); + + if (DEBUG_BLOCK_INFO && DEBUG_B_PIXELS) { + hex_dump(edge - t_dim->h * 4, t_dim->h * 4, + t_dim->h * 4, 2, "l"); + hex_dump(edge, 0, 1, 1, "tl"); + hex_dump(edge + 1, t_dim->w * 4, + t_dim->w * 4, 2, "t"); + hex_dump(dst, f->cur.p.stride[0], + t_dim->w * 4, t_dim->h * 4, "y-intra-pred"); + } + + skip_y_pred: {} + if (!b->skip) { + coef *cf; + int eob; + enum TxfmType txtp; + if (f->frame_thread.pass) { + cf = ts->frame_thread.cf; + ts->frame_thread.cf += imin(t_dim->w, 8) * imin(t_dim->h, 8) * 16; + const struct CodedBlockInfo *const cbi = + &f->frame_thread.cbi[t->by * f->b4_stride + t->bx]; + eob = cbi->eob[0]; + txtp = cbi->txtp[0]; + } else { + uint8_t cf_ctx; + cf = t->cf; + eob = decode_coefs(t, &t->a->lcoef[bx4 + x], + &t->l.lcoef[by4 + y], b->tx, bs, + b, 1, 0, cf, &txtp, &cf_ctx); + if (DEBUG_BLOCK_INFO) + printf("Post-y-cf-blk[tx=%d,txtp=%d,eob=%d]: r=%d\n", + b->tx, txtp, eob, ts->msac.rng); + memset(&t->a->lcoef[bx4 + x], cf_ctx, + imin(t_dim->w, f->bw - t->bx)); + memset(&t->l.lcoef[by4 + y], cf_ctx, + imin(t_dim->h, f->bh - t->by)); + } + if (eob >= 0) { + if (DEBUG_BLOCK_INFO && DEBUG_B_PIXELS) + coef_dump(cf, imin(t_dim->h, 8) * 4, + imin(t_dim->w, 8) * 4, 3, "dq"); + dsp->itx.itxfm_add[b->tx] + [txtp](dst, + f->cur.p.stride[0], + cf, eob); + if (DEBUG_BLOCK_INFO && DEBUG_B_PIXELS) + hex_dump(dst, f->cur.p.stride[0], + t_dim->w * 4, t_dim->h * 4, "recon"); + } + } else if (!f->frame_thread.pass) { + memset(&t->a->lcoef[bx4 + x], 0x40, t_dim->w); + memset(&t->l.lcoef[by4 + y], 0x40, t_dim->h); + } + dst += 4 * t_dim->w; + } + t->bx -= x; + } + t->by -= y; + + if (!has_chroma) continue; + + const ptrdiff_t stride = f->cur.p.stride[1]; + + if (b->uv_mode == CFL_PRED) { + assert(!init_x && !init_y); + + int16_t *const ac = t->scratch.ac; + ALIGN_STK_32(pixel, uv_pred, 2 * 32,); + pixel *y_src = ((pixel *) f->cur.p.data[0]) + 4 * (t->bx & ~ss_hor) + + 4 * (t->by & ~ss_ver) * PXSTRIDE(f->cur.p.stride[0]); + const ptrdiff_t uv_off = 4 * ((t->bx >> ss_hor) + + (t->by >> ss_ver) * PXSTRIDE(stride)); + pixel *const uv_dst[2] = { ((pixel *) f->cur.p.data[1]) + uv_off, + ((pixel *) f->cur.p.data[2]) + uv_off }; + // cfl_uvtx can be different from uvtx in case of lossless + const enum RectTxfmSize cfl_uvtx = + av1_max_txfm_size_for_bs[bs][f->cur.p.p.layout]; + const TxfmInfo *const cfl_uv_t_dim = + &av1_txfm_dimensions[cfl_uvtx]; + + for (int pl = 0; pl < 2; pl++) { + int angle = 0; + const pixel *top_sb_edge = NULL; + if (!((t->by & ~ss_ver) & (f->sb_step - 1))) { + top_sb_edge = f->ipred_edge[pl + 1]; + const int sby = t->by >> f->sb_shift; + top_sb_edge += f->sb128w * 128 * (sby - 1); + } + const enum IntraPredMode m = + bytefn(prepare_intra_edges)(t->bx >> ss_hor, + (t->bx >> ss_hor) > + (ts->tiling.col_start >> ss_hor), + t->by >> ss_ver, + (t->by >> ss_ver) > + (ts->tiling.row_start >> ss_ver), + ts->tiling.col_end >> ss_hor, + ts->tiling.row_end >> ss_ver, + 0, uv_dst[pl], stride, + top_sb_edge, DC_PRED, &angle, + cfl_uv_t_dim->w, + cfl_uv_t_dim->h, edge); + dsp->ipred.intra_pred[cfl_uvtx][m](&uv_pred[32 * pl], + 0, edge, 0); + } + const int furthest_r = + ((cw4 << ss_hor) + t_dim->w - 1) & ~(t_dim->w - 1); + const int furthest_b = + ((ch4 << ss_ver) + t_dim->h - 1) & ~(t_dim->h - 1); + dsp->ipred.cfl_ac[f->cur.p.p.layout - 1] + [cfl_uvtx](ac, y_src, f->cur.p.stride[0], + cbw4 - (furthest_r >> ss_hor), + cbh4 - (furthest_b >> ss_ver)); + dsp->ipred.cfl_pred[cfl_uv_t_dim->lw](uv_dst[0], + uv_dst[1], stride, + ac, uv_pred, + b->cfl_alpha, + cbh4 * 4); + if (DEBUG_BLOCK_INFO && DEBUG_B_PIXELS) { + hex_dump(uv_dst[0], stride, cbw4 * 4, cbh4 * 4, "u-cfl-pred"); + hex_dump(uv_dst[1], stride, cbw4 * 4, cbh4 * 4, "v-cfl-pred"); + } + } else if (b->pal_sz[1]) { + ptrdiff_t uv_dstoff = 4 * ((t->bx >> ss_hor) + + (t->by >> ss_ver) * PXSTRIDE(f->cur.p.stride[1])); + const uint8_t *pal_idx; + if (f->frame_thread.pass) { + pal_idx = ts->frame_thread.pal_idx; + ts->frame_thread.pal_idx += cbw4 * cbh4 * 16; + } else { + pal_idx = &t->scratch.pal_idx[bw4 * bh4 * 16]; + } + const uint16_t *const pal_u = f->frame_thread.pass ? + f->frame_thread.pal[((t->by >> 1) + (t->bx & 1)) * (f->b4_stride >> 1) + + ((t->bx >> 1) + (t->by & 1))][1] : t->pal[1]; + f->dsp->ipred.pal_pred(((pixel *) f->cur.p.data[1]) + uv_dstoff, + f->cur.p.stride[1], pal_u, + pal_idx, cbw4 * 4, cbh4 * 4); + const uint16_t *const pal_v = f->frame_thread.pass ? + f->frame_thread.pal[((t->by >> 1) + (t->bx & 1)) * (f->b4_stride >> 1) + + ((t->bx >> 1) + (t->by & 1))][2] : t->pal[2]; + f->dsp->ipred.pal_pred(((pixel *) f->cur.p.data[2]) + uv_dstoff, + f->cur.p.stride[1], pal_v, + pal_idx, cbw4 * 4, cbh4 * 4); + if (DEBUG_BLOCK_INFO && DEBUG_B_PIXELS) { + hex_dump(((pixel *) f->cur.p.data[1]) + uv_dstoff, + PXSTRIDE(f->cur.p.stride[1]), + cbw4 * 4, cbh4 * 4, "u-pal-pred"); + hex_dump(((pixel *) f->cur.p.data[2]) + uv_dstoff, + PXSTRIDE(f->cur.p.stride[1]), + cbw4 * 4, cbh4 * 4, "v-pal-pred"); + } + } + + const int sm_uv_fl = sm_uv_flag(t->a, cbx4) | + sm_uv_flag(&t->l, cby4); + const int uv_sb_has_tr = + ((init_x + 16) >> ss_hor) < cw4 ? 1 : init_y ? 0 : + intra_edge_flags & (EDGE_I420_TOP_HAS_RIGHT >> (f->cur.p.p.layout - 1)); + const int uv_sb_has_bl = + init_x ? 0 : ((init_y + 16) >> ss_ver) < ch4 ? 1 : + intra_edge_flags & (EDGE_I420_LEFT_HAS_BOTTOM >> (f->cur.p.p.layout - 1)); + const int sub_ch4 = imin(ch4, (init_y + 16) >> ss_ver); + const int sub_cw4 = imin(cw4, (init_x + 16) >> ss_hor); + for (int pl = 0; pl < 2; pl++) { + for (y = init_y >> ss_ver, t->by += init_y; y < sub_ch4; + y += uv_t_dim->h, t->by += uv_t_dim->h << ss_ver) + { + pixel *dst = ((pixel *) f->cur.p.data[1 + pl]) + + 4 * ((t->by >> ss_ver) * PXSTRIDE(stride) + + ((t->bx + init_x) >> ss_hor)); + for (x = init_x >> ss_hor, t->bx += init_x; x < sub_cw4; + x += uv_t_dim->w, t->bx += uv_t_dim->w << ss_hor) + { + if (b->uv_mode == CFL_PRED || b->pal_sz[1]) + goto skip_uv_pred; + + int angle = b->uv_angle; + // this probably looks weird because we're using + // luma flags in a chroma loop, but that's because + // prepare_intra_edges() expects luma flags as input + const enum EdgeFlags edge_flags = + (((y > (init_y >> ss_ver) || !uv_sb_has_tr) && + (x + uv_t_dim->w >= sub_cw4)) ? + 0 : EDGE_I444_TOP_HAS_RIGHT) | + ((x > (init_x >> ss_hor) || + (!uv_sb_has_bl && y + uv_t_dim->h >= sub_ch4)) ? + 0 : EDGE_I444_LEFT_HAS_BOTTOM); + const pixel *top_sb_edge = NULL; + if (!((t->by & ~ss_ver) & (f->sb_step - 1))) { + top_sb_edge = f->ipred_edge[1 + pl]; + const int sby = t->by >> f->sb_shift; + top_sb_edge += f->sb128w * 128 * (sby - 1); + } + const enum IntraPredMode m = + bytefn(prepare_intra_edges)(t->bx >> ss_hor, + (t->bx >> ss_hor) > + (ts->tiling.col_start >> ss_hor), + t->by >> ss_ver, + (t->by >> ss_ver) > + (ts->tiling.row_start >> ss_ver), + ts->tiling.col_end >> ss_hor, + ts->tiling.row_end >> ss_ver, + edge_flags, dst, stride, + top_sb_edge, b->uv_mode, + &angle, uv_t_dim->w, + uv_t_dim->h, edge); + dsp->ipred.intra_pred[b->uvtx][m](dst, stride, + edge, angle | sm_uv_fl); + if (DEBUG_BLOCK_INFO && DEBUG_B_PIXELS) { + hex_dump(edge - uv_t_dim->h * 4, uv_t_dim->h * 4, + uv_t_dim->h * 4, 2, "l"); + hex_dump(edge, 0, 1, 1, "tl"); + hex_dump(edge + 1, uv_t_dim->w * 4, + uv_t_dim->w * 4, 2, "t"); + hex_dump(dst, stride, uv_t_dim->w * 4, + uv_t_dim->h * 4, pl ? "v-intra-pred" : "u-intra-pred"); + } + + skip_uv_pred: {} + if (!b->skip) { + enum TxfmType txtp; + int eob; + coef *cf; + if (f->frame_thread.pass) { + cf = ts->frame_thread.cf; + ts->frame_thread.cf += uv_t_dim->w * uv_t_dim->h * 16; + const struct CodedBlockInfo *const cbi = + &f->frame_thread.cbi[t->by * f->b4_stride + t->bx]; + eob = cbi->eob[pl + 1]; + txtp = cbi->txtp[pl + 1]; + } else { + uint8_t cf_ctx; + cf = t->cf; + eob = decode_coefs(t, &t->a->ccoef[pl][cbx4 + x], + &t->l.ccoef[pl][cby4 + y], + b->uvtx, bs, b, 1, 1 + pl, cf, + &txtp, &cf_ctx); + if (DEBUG_BLOCK_INFO) + printf("Post-uv-cf-blk[pl=%d,tx=%d," + "txtp=%d,eob=%d]: r=%d [x=%d,cbx4=%d]\n", + pl, b->uvtx, txtp, eob, ts->msac.rng, x, cbx4); + memset(&t->a->ccoef[pl][cbx4 + x], cf_ctx, + imin(uv_t_dim->w, (f->bw - t->bx + ss_hor) >> ss_hor)); + memset(&t->l.ccoef[pl][cby4 + y], cf_ctx, + imin(uv_t_dim->h, (f->bh - t->by + ss_ver) >> ss_ver)); + } + if (eob >= 0) { + if (DEBUG_BLOCK_INFO && DEBUG_B_PIXELS) + coef_dump(cf, uv_t_dim->h * 4, + uv_t_dim->w * 4, 3, "dq"); + dsp->itx.itxfm_add[b->uvtx] + [txtp](dst, stride, + cf, eob); + if (DEBUG_BLOCK_INFO && DEBUG_B_PIXELS) + hex_dump(dst, stride, uv_t_dim->w * 4, + uv_t_dim->h * 4, "recon"); + } + } else if (!f->frame_thread.pass) { + memset(&t->a->ccoef[pl][cbx4 + x], 0x40, uv_t_dim->w); + memset(&t->l.ccoef[pl][cby4 + y], 0x40, uv_t_dim->h); + } + dst += uv_t_dim->w * 4; + } + t->bx -= x << ss_hor; + } + t->by -= y << ss_ver; + } + } + } +} + +void bytefn(recon_b_inter)(Dav1dTileContext *const t, const enum BlockSize bs, + const Av1Block *const b) +{ + Dav1dTileState *const ts = t->ts; + const Dav1dFrameContext *const f = t->f; + const Dav1dDSPContext *const dsp = f->dsp; + const int bx4 = t->bx & 31, by4 = t->by & 31; + const int ss_ver = f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I420; + const int ss_hor = f->cur.p.p.layout != DAV1D_PIXEL_LAYOUT_I444; + const int cbx4 = bx4 >> ss_hor, cby4 = by4 >> ss_ver; + const uint8_t *const b_dim = av1_block_dimensions[bs]; + const int bw4 = b_dim[0], bh4 = b_dim[1]; + const int w4 = imin(bw4, f->bw - t->bx), h4 = imin(bh4, f->bh - t->by); + const int has_chroma = f->seq_hdr.layout != DAV1D_PIXEL_LAYOUT_I400 && + (bw4 > ss_hor || t->bx & 1) && + (bh4 > ss_ver || t->by & 1); + const int chr_layout_idx = f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I400 ? 0 : + DAV1D_PIXEL_LAYOUT_I444 - f->cur.p.p.layout; + + // prediction + const int cbh4 = (bh4 + ss_ver) >> ss_ver, cbw4 = (bw4 + ss_hor) >> ss_hor; + pixel *dst = ((pixel *) f->cur.p.data[0]) + + 4 * (t->by * PXSTRIDE(f->cur.p.stride[0]) + t->bx); + const ptrdiff_t uvdstoff = + 4 * ((t->bx >> ss_hor) + (t->by >> ss_ver) * PXSTRIDE(f->cur.p.stride[1])); + if (!(f->frame_hdr.frame_type & 1)) { + // intrabc + mc(t, dst, NULL, f->cur.p.stride[0], + bw4, bh4, t->bx, t->by, 0, b->mv[0], &f->cur, FILTER_2D_BILINEAR); + if (has_chroma) for (int pl = 1; pl < 3; pl++) + mc(t, ((pixel *) f->cur.p.data[pl]) + uvdstoff, NULL, f->cur.p.stride[1], + bw4 << (bw4 == ss_hor), bh4 << (bh4 == ss_ver), + t->bx & ~ss_hor, t->by & ~ss_ver, + pl, b->mv[0], &f->cur, FILTER_2D_BILINEAR); + } else if (b->comp_type == COMP_INTER_NONE) { + const Dav1dThreadPicture *const refp = &f->refp[b->ref[0]]; + const enum Filter2d filter_2d = b->filter2d; + + if (imin(bw4, bh4) > 1 && + ((b->inter_mode == GLOBALMV && + f->frame_hdr.gmv[b->ref[0]].type > WM_TYPE_TRANSLATION) || + (b->motion_mode == MM_WARP && + t->warpmv.type > WM_TYPE_TRANSLATION))) + { + warp_affine(t, dst, NULL, f->cur.p.stride[0], b_dim, 0, refp, + b->motion_mode == MM_WARP ? &t->warpmv : + &f->frame_hdr.gmv[b->ref[0]]); + } else { + mc(t, dst, NULL, f->cur.p.stride[0], + bw4, bh4, t->bx, t->by, 0, b->mv[0], refp, filter_2d); + if (b->motion_mode == MM_OBMC) + obmc(t, dst, f->cur.p.stride[0], b_dim, 0, bx4, by4, w4, h4); + } + if (b->interintra_type) { + const enum RectTxfmSize ii_tx = av1_max_txfm_size_for_bs[bs][0]; + pixel tl_edge_px[65], *const tl_edge = &tl_edge_px[32]; + enum IntraPredMode m = b->interintra_mode == II_SMOOTH_PRED ? + SMOOTH_PRED : b->interintra_mode; + pixel *const tmp = t->scratch.interintra; + int angle = 0; + const pixel *top_sb_edge = NULL; + if (!(t->by & (f->sb_step - 1))) { + top_sb_edge = f->ipred_edge[0]; + const int sby = t->by >> f->sb_shift; + top_sb_edge += f->sb128w * 128 * (sby - 1); + } + m = bytefn(prepare_intra_edges)(t->bx, t->bx > ts->tiling.col_start, + t->by, t->by > ts->tiling.row_start, + ts->tiling.col_end, ts->tiling.row_end, + 0, dst, f->cur.p.stride[0], top_sb_edge, + m, &angle, bw4, bh4, tl_edge); + dsp->ipred.intra_pred[ii_tx][m](tmp, 4 * bw4 * sizeof(pixel), tl_edge, 0); + const uint8_t *const ii_mask = + b->interintra_type == INTER_INTRA_BLEND ? + ii_masks[bs][0][b->interintra_mode] : + wedge_masks[bs][0][0][b->wedge_idx]; + dsp->mc.blend(dst, f->cur.p.stride[0], tmp, bw4 * 4 * sizeof(pixel), + bw4 * 4, bh4 * 4, ii_mask, bw4 * 4); + } + + if (!has_chroma) goto skip_inter_chroma_pred; + + // sub8x8 derivation + int is_sub8x8 = bw4 == ss_hor || bh4 == ss_ver; + refmvs *r; + if (is_sub8x8) { + assert(ss_hor == 1); + r = &f->mvs[t->by * f->b4_stride + t->bx]; + if (bw4 == 1) is_sub8x8 &= r[-1].ref[0] > 0; + if (bh4 == ss_ver) is_sub8x8 &= r[-f->b4_stride].ref[0] > 0; + if (bw4 == 1 && bh4 == ss_ver) + is_sub8x8 &= r[-(1 + f->b4_stride)].ref[0] > 0; + } + + // chroma prediction + if (is_sub8x8) { + assert(ss_hor == 1); + int h_off = 0, v_off = 0; + if (bw4 == 1 && bh4 == ss_ver) { + for (int pl = 0; pl < 2; pl++) + mc(t, ((pixel *) f->cur.p.data[1 + pl]) + uvdstoff, + NULL, f->cur.p.stride[1], + bw4, bh4, t->bx - 1, t->by - 1, 1 + pl, + r[-(f->b4_stride + 1)].mv[0], + &f->refp[r[-(f->b4_stride + 1)].ref[0] - 1], + f->frame_thread.pass != 2 ? t->tl_4x4_filter : + f->frame_thread.b[((t->by - 1) * f->b4_stride) + t->bx - 1].filter2d); + v_off = 2 * PXSTRIDE(f->cur.p.stride[1]); + h_off = 2; + } + if (bw4 == 1) { + const enum Filter2d left_filter_2d = + av1_filter_2d[t->l.filter[1][by4]][t->l.filter[0][by4]]; + for (int pl = 0; pl < 2; pl++) + mc(t, ((pixel *) f->cur.p.data[1 + pl]) + uvdstoff + v_off, NULL, + f->cur.p.stride[1], bw4, bh4, t->bx - 1, + t->by, 1 + pl, r[-1].mv[0], &f->refp[r[-1].ref[0] - 1], + f->frame_thread.pass != 2 ? left_filter_2d : + f->frame_thread.b[(t->by * f->b4_stride) + t->bx - 1].filter2d); + h_off = 2; + } + if (bh4 == ss_ver) { + const enum Filter2d top_filter_2d = + av1_filter_2d[t->a->filter[1][bx4]][t->a->filter[0][bx4]]; + for (int pl = 0; pl < 2; pl++) + mc(t, ((pixel *) f->cur.p.data[1 + pl]) + uvdstoff + h_off, NULL, + f->cur.p.stride[1], bw4, bh4, t->bx, t->by - 1, + 1 + pl, r[-f->b4_stride].mv[0], + &f->refp[r[-f->b4_stride].ref[0] - 1], + f->frame_thread.pass != 2 ? top_filter_2d : + f->frame_thread.b[((t->by - 1) * f->b4_stride) + t->bx].filter2d); + v_off = 2 * PXSTRIDE(f->cur.p.stride[1]); + } + for (int pl = 0; pl < 2; pl++) + mc(t, ((pixel *) f->cur.p.data[1 + pl]) + uvdstoff + h_off + v_off, NULL, f->cur.p.stride[1], + bw4, bh4, t->bx, t->by, 1 + pl, b->mv[0], refp, filter_2d); + } else { + if (imin(cbw4, cbh4) > 1 && + ((b->inter_mode == GLOBALMV && + f->frame_hdr.gmv[b->ref[0]].type > WM_TYPE_TRANSLATION) || + (b->motion_mode == MM_WARP && + t->warpmv.type > WM_TYPE_TRANSLATION))) + { + for (int pl = 0; pl < 2; pl++) + warp_affine(t, ((pixel *) f->cur.p.data[1 + pl]) + uvdstoff, NULL, + f->cur.p.stride[1], b_dim, 1 + pl, refp, + b->motion_mode == MM_WARP ? &t->warpmv : + &f->frame_hdr.gmv[b->ref[0]]); + } else { + for (int pl = 0; pl < 2; pl++) { + mc(t, ((pixel *) f->cur.p.data[1 + pl]) + uvdstoff, + NULL, f->cur.p.stride[1], + bw4 << (bw4 == ss_hor), bh4 << (bh4 == ss_ver), + t->bx & ~ss_hor, t->by & ~ss_ver, + 1 + pl, b->mv[0], refp, filter_2d); + if (b->motion_mode == MM_OBMC) + obmc(t, ((pixel *) f->cur.p.data[1 + pl]) + uvdstoff, + f->cur.p.stride[1], b_dim, 1 + pl, bx4, by4, w4, h4); + } + } + if (b->interintra_type) { + // FIXME for 8x32 with 4:2:2 subsampling, this probably does + // the wrong thing since it will select 4x16, not 4x32, as a + // transform size... + const enum RectTxfmSize ii_tx = + av1_max_txfm_size_for_bs[bs][f->cur.p.p.layout]; + const uint8_t *const ii_mask = + b->interintra_type == INTER_INTRA_BLEND ? + ii_masks[bs][chr_layout_idx][b->interintra_mode] : + wedge_masks[bs][chr_layout_idx][0][b->wedge_idx]; + + for (int pl = 0; pl < 2; pl++) { + pixel *const tmp = t->scratch.interintra; + pixel tl_edge_px[65], *const tl_edge = &tl_edge_px[32]; + enum IntraPredMode m = + b->interintra_mode == II_SMOOTH_PRED ? + SMOOTH_PRED : b->interintra_mode; + int angle = 0; + pixel *const uvdst = ((pixel *) f->cur.p.data[1 + pl]) + uvdstoff; + const pixel *top_sb_edge = NULL; + if (!(t->by & (f->sb_step - 1))) { + top_sb_edge = f->ipred_edge[pl + 1]; + const int sby = t->by >> f->sb_shift; + top_sb_edge += f->sb128w * 128 * (sby - 1); + } + m = bytefn(prepare_intra_edges)(t->bx >> ss_hor, + (t->bx >> ss_hor) > + (ts->tiling.col_start >> ss_hor), + t->by >> ss_ver, + (t->by >> ss_ver) > + (ts->tiling.row_start >> ss_ver), + ts->tiling.col_end >> ss_hor, + ts->tiling.row_end >> ss_ver, + 0, uvdst, f->cur.p.stride[1], + top_sb_edge, m, + &angle, cbw4, cbh4, tl_edge); + dsp->ipred.intra_pred[ii_tx][m](tmp, cbw4 * 4, tl_edge, 0); + dsp->mc.blend(uvdst, f->cur.p.stride[1], tmp, cbw4 * 4, + cbw4 * 4, cbh4 * 4, ii_mask, cbw4 * 4); + } + } + } + + skip_inter_chroma_pred: {} + t->tl_4x4_filter = filter_2d; + } else { + const enum Filter2d filter_2d = b->filter2d; + coef (*tmp)[bw4 * bh4 * 16] = (coef (*)[bw4 * bh4 * 16]) t->scratch.compinter; + int jnt_weight; + uint8_t *const seg_mask = t->scratch_seg_mask; + const uint8_t *mask; + + for (int i = 0; i < 2; i++) { + const Dav1dThreadPicture *const refp = &f->refp[b->ref[i]]; + + if (b->inter_mode == GLOBALMV_GLOBALMV && + f->frame_hdr.gmv[b->ref[i]].type > WM_TYPE_TRANSLATION) + { + warp_affine(t, NULL, tmp[i], bw4 * 4, b_dim, 0, refp, + &f->frame_hdr.gmv[b->ref[i]]); + } else { + mc(t, NULL, tmp[i], 0, bw4, bh4, t->bx, t->by, 0, + b->mv[i], refp, filter_2d); + } + } + switch (b->comp_type) { + case COMP_INTER_AVG: + dsp->mc.avg(dst, f->cur.p.stride[0], tmp[0], tmp[1], + bw4 * 4, bh4 * 4); + break; + case COMP_INTER_WEIGHTED_AVG: + jnt_weight = f->jnt_weights[b->ref[0]][b->ref[1]]; + dsp->mc.w_avg(dst, f->cur.p.stride[0], tmp[0], tmp[1], + bw4 * 4, bh4 * 4, jnt_weight); + break; + case COMP_INTER_SEG: + dsp->mc.w_mask[chr_layout_idx](dst, f->cur.p.stride[0], + tmp[b->mask_sign], tmp[!b->mask_sign], + bw4 * 4, bh4 * 4, seg_mask, b->mask_sign); + mask = seg_mask; + break; + case COMP_INTER_WEDGE: + mask = wedge_masks[bs][0][0][b->wedge_idx]; + dsp->mc.mask(dst, f->cur.p.stride[0], + tmp[b->mask_sign], tmp[!b->mask_sign], + bw4 * 4, bh4 * 4, mask); + if (has_chroma) + mask = wedge_masks[bs][chr_layout_idx][b->mask_sign][b->wedge_idx]; + break; + } + + // chroma + if (has_chroma) for (int pl = 0; pl < 2; pl++) { + for (int i = 0; i < 2; i++) { + const Dav1dThreadPicture *const refp = &f->refp[b->ref[i]]; + if (b->inter_mode == GLOBALMV_GLOBALMV && + imin(cbw4, cbh4) > 1 && + f->frame_hdr.gmv[b->ref[i]].type > WM_TYPE_TRANSLATION) + { + warp_affine(t, NULL, tmp[i], bw4 * 2, b_dim, 1 + pl, + refp, &f->frame_hdr.gmv[b->ref[i]]); + } else { + mc(t, NULL, tmp[i], 0, bw4, bh4, t->bx, t->by, + 1 + pl, b->mv[i], refp, filter_2d); + } + } + pixel *const uvdst = ((pixel *) f->cur.p.data[1 + pl]) + uvdstoff; + switch (b->comp_type) { + case COMP_INTER_AVG: + dsp->mc.avg(uvdst, f->cur.p.stride[1], tmp[0], tmp[1], + bw4 * 4 >> ss_hor, bh4 * 4 >> ss_ver); + break; + case COMP_INTER_WEIGHTED_AVG: + dsp->mc.w_avg(uvdst, f->cur.p.stride[1], tmp[0], tmp[1], + bw4 * 4 >> ss_hor, bh4 * 4 >> ss_ver, jnt_weight); + break; + case COMP_INTER_WEDGE: + case COMP_INTER_SEG: + dsp->mc.mask(uvdst, f->cur.p.stride[1], + tmp[b->mask_sign], tmp[!b->mask_sign], + bw4 * 4 >> ss_hor, bh4 * 4 >> ss_ver, mask); + break; + } + } + } + + if (DEBUG_BLOCK_INFO && DEBUG_B_PIXELS) { + hex_dump(dst, f->cur.p.stride[0], b_dim[0] * 4, b_dim[1] * 4, "y-pred"); + if (has_chroma) { + hex_dump(&((pixel *) f->cur.p.data[1])[uvdstoff], f->cur.p.stride[1], + cbw4 * 4, cbh4 * 4, "u-pred"); + hex_dump(&((pixel *) f->cur.p.data[2])[uvdstoff], f->cur.p.stride[1], + cbw4 * 4, cbh4 * 4, "v-pred"); + } + } + + const int cw4 = (w4 + ss_hor) >> ss_hor, ch4 = (h4 + ss_ver) >> ss_ver; + + if (b->skip) { + // reset coef contexts + memset(&t->a->lcoef[bx4], 0x40, w4); + memset(&t->l.lcoef[by4], 0x40, h4); + if (has_chroma) { + memset(&t->a->ccoef[0][cbx4], 0x40, cw4); + memset(&t->l.ccoef[0][cby4], 0x40, ch4); + memset(&t->a->ccoef[1][cbx4], 0x40, cw4); + memset(&t->l.ccoef[1][cby4], 0x40, ch4); + } + return; + } + + const TxfmInfo *const uvtx = &av1_txfm_dimensions[b->uvtx]; + const TxfmInfo *const ytx = &av1_txfm_dimensions[b->max_ytx]; + + for (int init_y = 0; init_y < bh4; init_y += 16) { + for (int init_x = 0; init_x < bw4; init_x += 16) { + // coefficient coding & inverse transforms + int y_off = !!init_y, y; + dst += PXSTRIDE(f->cur.p.stride[0]) * 4 * init_y; + for (y = init_y, t->by += init_y; y < imin(h4, init_y + 16); + y += ytx->h, y_off++) + { + int x, x_off = !!init_x; + for (x = init_x, t->bx += init_x; x < imin(w4, init_x + 16); + x += ytx->w, x_off++) + { + read_coef_tree(t, bs, b, b->max_ytx, 0, b->tx_split, + x_off, y_off, &dst[x * 4]); + t->bx += ytx->w; + } + dst += PXSTRIDE(f->cur.p.stride[0]) * 4 * ytx->h; + t->bx -= x; + t->by += ytx->h; + } + dst -= PXSTRIDE(f->cur.p.stride[0]) * 4 * y; + t->by -= y; + + // chroma coefs and inverse transform + if (has_chroma) for (int pl = 0; pl < 2; pl++) { + pixel *uvdst = ((pixel *) f->cur.p.data[1 + pl]) + uvdstoff + + (PXSTRIDE(f->cur.p.stride[1]) * init_y * 4 >> ss_ver); + for (y = init_y >> ss_ver, t->by += init_y; + y < imin(ch4, (init_y + 16) >> ss_ver); y += uvtx->h) + { + int x; + for (x = init_x >> ss_hor, t->bx += init_x; + x < imin(cw4, (init_x + 16) >> ss_hor); x += uvtx->w) + { + coef *cf; + int eob; + enum TxfmType txtp; + if (f->frame_thread.pass) { + cf = ts->frame_thread.cf; + ts->frame_thread.cf += uvtx->w * uvtx->h * 16; + const struct CodedBlockInfo *const cbi = + &f->frame_thread.cbi[t->by * f->b4_stride + t->bx]; + eob = cbi->eob[1 + pl]; + txtp = cbi->txtp[1 + pl]; + } else { + uint8_t cf_ctx; + cf = t->cf; + txtp = t->txtp_map[(by4 + (y << ss_ver)) * 32 + + bx4 + (x << ss_hor)]; + eob = decode_coefs(t, &t->a->ccoef[pl][cbx4 + x], + &t->l.ccoef[pl][cby4 + y], + b->uvtx, bs, b, 0, 1 + pl, + cf, &txtp, &cf_ctx); + if (DEBUG_BLOCK_INFO) + printf("Post-uv-cf-blk[pl=%d,tx=%d," + "txtp=%d,eob=%d]: r=%d\n", + pl, b->uvtx, txtp, eob, ts->msac.rng); + memset(&t->a->ccoef[pl][cbx4 + x], cf_ctx, + imin(uvtx->w, (f->bw - t->bx + ss_hor) >> ss_hor)); + memset(&t->l.ccoef[pl][cby4 + y], cf_ctx, + imin(uvtx->h, (f->bh - t->by + ss_ver) >> ss_ver)); + } + if (eob >= 0) { + if (DEBUG_BLOCK_INFO && DEBUG_B_PIXELS) + coef_dump(cf, uvtx->h * 4, uvtx->w * 4, 3, "dq"); + dsp->itx.itxfm_add[b->uvtx] + [txtp](&uvdst[4 * x], + f->cur.p.stride[1], + cf, eob); + if (DEBUG_BLOCK_INFO && DEBUG_B_PIXELS) + hex_dump(&uvdst[4 * x], f->cur.p.stride[1], + uvtx->w * 4, uvtx->h * 4, "recon"); + } + t->bx += uvtx->w << ss_hor; + } + uvdst += PXSTRIDE(f->cur.p.stride[1]) * 4 * uvtx->h; + t->bx -= x << ss_hor; + t->by += uvtx->h << ss_ver; + } + t->by -= y << ss_ver; + } + } + } +} + +void bytefn(filter_sbrow)(Dav1dFrameContext *const f, const int sby) { + const int ss_ver = f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I420; + const int sbsz = f->sb_step, sbh = f->sbh; + + if (f->frame_hdr.loopfilter.level_y[0] || + f->frame_hdr.loopfilter.level_y[1]) + { + int start_of_tile_row = 0; + if (f->frame_hdr.tiling.row_start_sb[f->lf.tile_row] == sby) + start_of_tile_row = f->lf.tile_row++; + bytefn(dav1d_loopfilter_sbrow)(f, f->lf.p, f->lf.mask_ptr, sby, + start_of_tile_row); + } + + if (f->seq_hdr.restoration) { + // Store loop filtered pixels required by loop restoration + bytefn(dav1d_lr_copy_lpf)(f, f->lf.p, sby); + } + if (f->seq_hdr.cdef) { + if (sby) { + pixel *p_up[3] = { + f->lf.p[0] - 8 * PXSTRIDE(f->cur.p.stride[0]), + f->lf.p[1] - (8 * PXSTRIDE(f->cur.p.stride[1]) >> ss_ver), + f->lf.p[2] - (8 * PXSTRIDE(f->cur.p.stride[1]) >> ss_ver), + }; + bytefn(dav1d_cdef_brow)(f, p_up, f->lf.prev_mask_ptr, + sby * sbsz - 2, sby * sbsz); + } + const int n_blks = sbsz - 2 * (sby + 1 < sbh); + bytefn(dav1d_cdef_brow)(f, f->lf.p, f->lf.mask_ptr, sby * sbsz, + imin(sby * sbsz + n_blks, f->bh)); + } + if (f->seq_hdr.restoration) { + bytefn(dav1d_lr_sbrow)(f, f->lf.p, sby); + } + + f->lf.p[0] += sbsz * 4 * PXSTRIDE(f->cur.p.stride[0]); + f->lf.p[1] += sbsz * 4 * PXSTRIDE(f->cur.p.stride[1]) >> ss_ver; + f->lf.p[2] += sbsz * 4 * PXSTRIDE(f->cur.p.stride[1]) >> ss_ver; + f->lf.prev_mask_ptr = f->lf.mask_ptr; + if ((sby & 1) || f->seq_hdr.sb128) { + f->lf.mask_ptr += f->sb128w; + } +} + +void bytefn(backup_ipred_edge)(Dav1dTileContext *const t) { + const Dav1dFrameContext *const f = t->f; + Dav1dTileState *const ts = t->ts; + const int ss_ver = f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I420; + const int ss_hor = f->cur.p.p.layout != DAV1D_PIXEL_LAYOUT_I444; + const int sby = t->by >> f->sb_shift; + const int sby_off = f->sb128w * 128 * sby; + const int x_off = ts->tiling.col_start; + + const pixel *const y = + ((const pixel *) f->cur.p.data[0]) + x_off * 4 + + ((t->by + f->sb_step) * 4 - 1) * PXSTRIDE(f->cur.p.stride[0]); + pixel_copy(&f->ipred_edge[0][sby_off + x_off * 4], y, + 4 * (ts->tiling.col_end - x_off)); + const ptrdiff_t uv_off = (x_off * 4 >> ss_hor) + + (((t->by + f->sb_step) * 4 >> ss_ver) - 1) * PXSTRIDE(f->cur.p.stride[1]); + for (int pl = 1; pl <= 2; pl++) + pixel_copy(&f->ipred_edge[pl][sby_off + (x_off * 4 >> ss_hor)], + &((const pixel *) f->cur.p.data[pl])[uv_off], + 4 * (ts->tiling.col_end - x_off) >> ss_hor); +} diff --git a/src/recon.h b/src/recon.h new file mode 100644 index 0000000..73bc61c --- /dev/null +++ b/src/recon.h @@ -0,0 +1,75 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_SRC_RECON_H__ +#define __DAV1D_SRC_RECON_H__ + +#include "src/internal.h" +#include "src/levels.h" + +#define DEBUG_BLOCK_INFO 0 && \ + f->frame_hdr.frame_offset == 2 && t->by >= 0 && t->by < 4 && \ + t->bx >= 8 && t->bx < 12 +#define DEBUG_B_PIXELS 0 + +#define decl_recon_b_intra_fn(name) \ +void (name)(Dav1dTileContext *t, enum BlockSize bs, \ + enum EdgeFlags intra_edge_flags, const Av1Block *b) +typedef decl_recon_b_intra_fn(*recon_b_intra_fn); + +#define decl_recon_b_inter_fn(name) \ +void (name)(Dav1dTileContext *t, enum BlockSize bs, const Av1Block *b) +typedef decl_recon_b_inter_fn(*recon_b_inter_fn); + +#define decl_filter_sbrow_fn(name) \ +void (name)(Dav1dFrameContext *f, int sby) +typedef decl_filter_sbrow_fn(*filter_sbrow_fn); + +#define decl_backup_ipred_edge_fn(name) \ +void (name)(Dav1dTileContext *t) +typedef decl_backup_ipred_edge_fn(*backup_ipred_edge_fn); + +#define decl_read_coef_blocks_fn(name) \ +void (name)(Dav1dTileContext *t, enum BlockSize bs, const Av1Block *b) +typedef decl_read_coef_blocks_fn(*read_coef_blocks_fn); + +decl_recon_b_intra_fn(recon_b_intra_8bpc); +decl_recon_b_intra_fn(recon_b_intra_16bpc); + +decl_recon_b_inter_fn(recon_b_inter_8bpc); +decl_recon_b_inter_fn(recon_b_inter_16bpc); + +decl_filter_sbrow_fn(filter_sbrow_8bpc); +decl_filter_sbrow_fn(filter_sbrow_16bpc); + +decl_backup_ipred_edge_fn(backup_ipred_edge_8bpc); +decl_backup_ipred_edge_fn(backup_ipred_edge_16bpc); + +decl_read_coef_blocks_fn(read_coef_blocks_8bpc); +decl_read_coef_blocks_fn(read_coef_blocks_16bpc); + +#endif /* __DAV1D_SRC_RECON_H__ */ diff --git a/src/ref.c b/src/ref.c new file mode 100644 index 0000000..b0bf7ac --- /dev/null +++ b/src/ref.c @@ -0,0 +1,60 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include "common/mem.h" + +#include "src/ref.h" + +Dav1dRef *dav1d_ref_create(const size_t size) { + Dav1dRef *res = malloc(sizeof(Dav1dRef)); + void *data = dav1d_alloc_aligned(size, 32); + + if (!res || !data) { + if (res) free(res); + if (data) free(data); + return NULL; + } + + res->size = size; + atomic_init(&res->ref_cnt, 1); + res->data = data; + + return res; +} + +void dav1d_ref_inc(Dav1dRef *const ref) { + atomic_fetch_add(&ref->ref_cnt, 1); +} + +void dav1d_ref_dec(Dav1dRef *const ref) { + if (atomic_fetch_sub(&ref->ref_cnt, 1) == 1) { + dav1d_free_aligned(ref->data); + free(ref); + } +} diff --git a/src/ref.h b/src/ref.h new file mode 100644 index 0000000..499966b --- /dev/null +++ b/src/ref.h @@ -0,0 +1,46 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_SRC_REF_H__ +#define __DAV1D_SRC_REF_H__ + +#include "dav1d/dav1d.h" + +#include <stdatomic.h> +#include <stddef.h> + +struct Dav1dRef { + void *data; + size_t size; + atomic_int ref_cnt; +}; + +Dav1dRef *dav1d_ref_create(size_t size); +void dav1d_ref_inc(Dav1dRef *ref); +void dav1d_ref_dec(Dav1dRef *ref); + +#endif /* __DAV1D_SRC_REF_H__ */ diff --git a/src/ref_mvs.c b/src/ref_mvs.c new file mode 100644 index 0000000..997c0af --- /dev/null +++ b/src/ref_mvs.c @@ -0,0 +1,3550 @@ +/* + * Copyright (c) 2001-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. + */ + +/* + * Changes made compared to libaom version: + * - we disable TMV and enable MV_COMPRESS so that the + * input array for prev_frames can be at 4x4 instead of + * 8x8 resolution, and therefore shared between cur_frame + * and prev_frame. To make enc/dec behave consistent, we + * also make this change around line 2580: +#if 0 + AOMMIN(((mi_row >> 1) << 1) + 1 + (((xd->n8_h - 1) >> 1) << 1), + mi_row_end - 1) * + prev_frame_mvs_stride + + AOMMIN(((mi_col >> 1) << 1) + 1 + (((xd->n8_w - 1) >> 1) << 1), + mi_col_end - 1) +#else + (((mi_row >> 1) << 1) + 1) * prev_frame_mvs_stride + + (((mi_col >> 1) << 1) + 1) +#endif + * and the same change (swap mi_cols from prev_frame.mv_stride) on line 2407 + * - we disable rect-block overhanging edge inclusion (see + * line 2642): + if (num_8x8_blocks_wide == num_8x8_blocks_high || 1) { + mv_ref_search[5].row = -1; + mv_ref_search[5].col = 0; + mv_ref_search[6].row = 0; + mv_ref_search[6].col = -1; + } else { + mv_ref_search[5].row = -1; + mv_ref_search[5].col = num_8x8_blocks_wide; + mv_ref_search[6].row = num_8x8_blocks_high; + mv_ref_search[6].col = -1; + } + * Note that this is a bitstream change and needs the same + * change on the decoder side also. + * - we change xd->mi to be a pointer instead of a double ptr. + */ + +#include "config.h" + +#include <assert.h> +#include <limits.h> +#include <stddef.h> +#include <stdint.h> +#include <stdlib.h> +#include <string.h> + +#include "common/intops.h" + +#define av1_zero(a) memset(a, 0, sizeof(a)) + +#define ATTRIBUTE_PACKED +#define INLINE inline +#define IMPLIES(a, b) (!(a) || (b)) // Logical 'a implies b' (or 'a -> b') + +#define ROUND_POWER_OF_TWO(value, n) (((value) + (((1 << (n)) >> 1))) >> (n)) +#define ROUND_POWER_OF_TWO_SIGNED(value, n) \ + (((value) < 0) ? -ROUND_POWER_OF_TWO(-(value), (n)) \ + : ROUND_POWER_OF_TWO((value), (n))) +#define NELEMENTS(x) (int)(sizeof(x) / sizeof(x[0])) + +#define MAX_MV_REF_CANDIDATES 2 + +#define MAX_REF_MV_STACK_SIZE 8 +#define REF_CAT_LEVEL 640 + +#define FRAME_OFFSET_BITS 5 +#define MAX_FRAME_DISTANCE ((1 << FRAME_OFFSET_BITS) - 1) +#define INVALID_MV 0x80008000 + +#define COMP_NEWMV_CTXS 5 +#define REFMV_OFFSET 4 +#define REFMV_CTX_MASK ((1 << (8 - REFMV_OFFSET)) - 1) + +#define MV_IN_USE_BITS 14 +#define MV_UPP (1 << MV_IN_USE_BITS) +#define MV_LOW (-(1 << MV_IN_USE_BITS)) + +typedef struct MV { + int16_t row; + int16_t col; +} MV; +typedef union int_mv { + uint32_t as_int; + MV as_mv; +} int_mv; +typedef int8_t MV_REFERENCE_FRAME; +#define MFMV_STACK_SIZE 3 +typedef struct { + int_mv mfmv0; + uint8_t ref_frame_offset; +} TPL_MV_REF; +typedef struct { + int_mv mv[2]; + MV_REFERENCE_FRAME ref_frame[2]; + int8_t mode, sb_type; +} MV_REF; +#define MB_MODE_INFO MV_REF + +#define AOMMAX(a,b) ((a)>(b)?(a):(b)) +#define AOMMIN(a,b) ((a)<(b)?(a):(b)) + +typedef struct candidate_mv { + int_mv this_mv; + int_mv comp_mv; + int weight; +} CANDIDATE_MV; +#define NONE_FRAME -1 +#define INTRA_FRAME 0 +#define LAST_FRAME 1 + +#define LAST2_FRAME 2 +#define LAST3_FRAME 3 +#define GOLDEN_FRAME 4 +#define BWDREF_FRAME 5 +#define ALTREF2_FRAME 6 +#define ALTREF_FRAME 7 +#define LAST_REF_FRAMES (LAST3_FRAME - LAST_FRAME + 1) + +#define INTER_REFS_PER_FRAME (ALTREF_FRAME - LAST_FRAME + 1) +#define TOTAL_REFS_PER_FRAME (ALTREF_FRAME - INTRA_FRAME + 1) + +#define FWD_REFS (GOLDEN_FRAME - LAST_FRAME + 1) +#define FWD_RF_OFFSET(ref) (ref - LAST_FRAME) +#define BWD_REFS (ALTREF_FRAME - BWDREF_FRAME + 1) +#define BWD_RF_OFFSET(ref) (ref - BWDREF_FRAME) +#define FWD_REFS (GOLDEN_FRAME - LAST_FRAME + 1) +#define SINGLE_REFS (FWD_REFS + BWD_REFS) +typedef enum ATTRIBUTE_PACKED { + LAST_LAST2_FRAMES, // { LAST_FRAME, LAST2_FRAME } + LAST_LAST3_FRAMES, // { LAST_FRAME, LAST3_FRAME } + LAST_GOLDEN_FRAMES, // { LAST_FRAME, GOLDEN_FRAME } + BWDREF_ALTREF_FRAMES, // { BWDREF_FRAME, ALTREF_FRAME } + LAST2_LAST3_FRAMES, // { LAST2_FRAME, LAST3_FRAME } + LAST2_GOLDEN_FRAMES, // { LAST2_FRAME, GOLDEN_FRAME } + LAST3_GOLDEN_FRAMES, // { LAST3_FRAME, GOLDEN_FRAME } + BWDREF_ALTREF2_FRAMES, // { BWDREF_FRAME, ALTREF2_FRAME } + ALTREF2_ALTREF_FRAMES, // { ALTREF2_FRAME, ALTREF_FRAME } + TOTAL_UNIDIR_COMP_REFS, + // NOTE: UNIDIR_COMP_REFS is the number of uni-directional reference pairs + // that are explicitly signaled. + UNIDIR_COMP_REFS = BWDREF_ALTREF_FRAMES + 1, +} UNIDIR_COMP_REF; +#define TOTAL_COMP_REFS (FWD_REFS * BWD_REFS + TOTAL_UNIDIR_COMP_REFS) +#define MODE_CTX_REF_FRAMES (TOTAL_REFS_PER_FRAME + TOTAL_COMP_REFS) + +#define GLOBALMV_OFFSET 3 +#define NEWMV_CTX_MASK ((1 << GLOBALMV_OFFSET) - 1) +#define GLOBALMV_CTX_MASK ((1 << (REFMV_OFFSET - GLOBALMV_OFFSET)) - 1) +#define MI_SIZE_LOG2 2 +#define MI_SIZE (1 << MI_SIZE_LOG2) +#define MAX_SB_SIZE_LOG2 7 +#define MAX_MIB_SIZE_LOG2 (MAX_SB_SIZE_LOG2 - MI_SIZE_LOG2) +#define MIN_MIB_SIZE_LOG2 (MIN_SB_SIZE_LOG2 - MI_SIZE_LOG2) +#define MAX_MIB_SIZE (1 << MAX_MIB_SIZE_LOG2) +#define MI_SIZE_64X64 (64 >> MI_SIZE_LOG2) +#define MI_SIZE_128X128 (128 >> MI_SIZE_LOG2) +#define REFMV_OFFSET 4 + +typedef enum ATTRIBUTE_PACKED { + BLOCK_4X4, + BLOCK_4X8, + BLOCK_8X4, + BLOCK_8X8, + BLOCK_8X16, + BLOCK_16X8, + BLOCK_16X16, + BLOCK_16X32, + BLOCK_32X16, + BLOCK_32X32, + BLOCK_32X64, + BLOCK_64X32, + BLOCK_64X64, + BLOCK_64X128, + BLOCK_128X64, + BLOCK_128X128, + BLOCK_4X16, + BLOCK_16X4, + BLOCK_8X32, + BLOCK_32X8, + BLOCK_16X64, + BLOCK_64X16, + BLOCK_32X128, + BLOCK_128X32, + BLOCK_SIZES_ALL, + BLOCK_SIZES = BLOCK_4X16, + BLOCK_INVALID = 255, + BLOCK_LARGEST = (BLOCK_SIZES - 1) +} BLOCK_SIZE; + +typedef enum ATTRIBUTE_PACKED { + PARTITION_NONE, + PARTITION_HORZ, + PARTITION_VERT, + PARTITION_SPLIT, + PARTITION_HORZ_A, // HORZ split and the top partition is split again + PARTITION_HORZ_B, // HORZ split and the bottom partition is split again + PARTITION_VERT_A, // VERT split and the left partition is split again + PARTITION_VERT_B, // VERT split and the right partition is split again + PARTITION_HORZ_4, // 4:1 horizontal partition + PARTITION_VERT_4, // 4:1 vertical partition + EXT_PARTITION_TYPES, + PARTITION_TYPES = PARTITION_SPLIT + 1, + PARTITION_INVALID = 255 +} PARTITION_TYPE; +typedef struct CUR_MODE_INFO { + PARTITION_TYPE partition; +} CUR_MODE_INFO ; + +typedef enum ATTRIBUTE_PACKED { + DC_PRED, // Average of above and left pixels + V_PRED, // Vertical + H_PRED, // Horizontal + D45_PRED, // Directional 45 deg = round(arctan(1/1) * 180/pi) + D135_PRED, // Directional 135 deg = 180 - 45 + D117_PRED, // Directional 117 deg = 180 - 63 + D153_PRED, // Directional 153 deg = 180 - 27 + D207_PRED, // Directional 207 deg = 180 + 27 + D63_PRED, // Directional 63 deg = round(arctan(2/1) * 180/pi) + SMOOTH_PRED, // Combination of horizontal and vertical interpolation + SMOOTH_V_PRED, // Vertical interpolation + SMOOTH_H_PRED, // Horizontal interpolation + PAETH_PRED, // Predict from the direction of smallest gradient + NEARESTMV, + NEARMV, + GLOBALMV, + NEWMV, + // Compound ref compound modes + NEAREST_NEARESTMV, + NEAR_NEARMV, + NEAREST_NEWMV, + NEW_NEARESTMV, + NEAR_NEWMV, + NEW_NEARMV, + GLOBAL_GLOBALMV, + NEW_NEWMV, + MB_MODE_COUNT, + INTRA_MODES = PAETH_PRED + 1, // PAETH_PRED has to be the last intra mode. + INTRA_INVALID = MB_MODE_COUNT // For uv_mode in inter blocks +} PREDICTION_MODE; +typedef enum { + IDENTITY = 0, // identity transformation, 0-parameter + TRANSLATION = 1, // translational motion 2-parameter + ROTZOOM = 2, // simplified affine with rotation + zoom only, 4-parameter + AFFINE = 3, // affine, 6-parameter + TRANS_TYPES, +} TransformationType; +#if 0 +typedef enum { + KEY_FRAME = 0, + INTER_FRAME = 1, +#if CONFIG_OBU + INTRA_ONLY_FRAME = 2, // replaces intra-only + S_FRAME = 3, +#endif + FRAME_TYPES, +} FRAME_TYPE; +#endif + +#define LEAST_SQUARES_SAMPLES_MAX_BITS 3 +#define LEAST_SQUARES_SAMPLES_MAX (1 << LEAST_SQUARES_SAMPLES_MAX_BITS) +#define SAMPLES_ARRAY_SIZE (LEAST_SQUARES_SAMPLES_MAX * 2) + +static const uint8_t mi_size_wide[BLOCK_SIZES_ALL] = { + 1, 1, 2, 2, 2, 4, 4, 4, 8, 8, 8, 16, 16, + 16, 32, 32, 1, 4, 2, 8, 4, 16, 8, 32 +}; +static const uint8_t mi_size_high[BLOCK_SIZES_ALL] = { + 1, 2, 1, 2, 4, 2, 4, 8, 4, 8, 16, 8, 16, + 32, 16, 32, 4, 1, 8, 2, 16, 4, 32, 8 +}; + +static const uint8_t block_size_wide[BLOCK_SIZES_ALL] = { + 4, 4, + 8, 8, + 8, 16, + 16, 16, + 32, 32, + 32, 64, + 64, 64, 128, 128, 4, + 16, 8, + 32, 16, + 64, 32, 128 +}; + +static const uint8_t block_size_high[BLOCK_SIZES_ALL] = { + 4, 8, + 4, 8, + 16, 8, + 16, 32, + 16, 32, + 64, 32, + 64, 128, 64, 128, 16, + 4, 32, + 8, 64, + 16, 128, 32 +}; + +static const uint8_t num_8x8_blocks_wide_lookup[BLOCK_SIZES_ALL] = { + 1, 1, + 1, 1, + 1, 2, + 2, 2, + 4, 4, + 4, 8, + 8, 8, 16, 16, 1, + 2, 1, + 4, 2, + 8, 4, 16 +}; +static const uint8_t num_8x8_blocks_high_lookup[BLOCK_SIZES_ALL] = { + 1, 1, + 1, 1, + 2, 1, + 2, 4, + 2, 4, + 8, 4, + 8, 16, 8, 16, 2, + 1, 4, + 1, 8, + 2, 16, 4 +}; + +static INLINE int is_global_mv_block(const MB_MODE_INFO *const mbmi, + TransformationType type) { + const PREDICTION_MODE mode = mbmi->mode; + const BLOCK_SIZE bsize = mbmi->sb_type; + const int block_size_allowed = + AOMMIN(block_size_wide[bsize], block_size_high[bsize]) >= 8; + return (mode == GLOBALMV || mode == GLOBAL_GLOBALMV) && type > TRANSLATION && + block_size_allowed; +} + +typedef struct { + TransformationType wmtype; + int32_t wmmat[6]; + int16_t alpha, beta, gamma, delta; +} WarpedMotionParams; + +#define WARPEDMODEL_PREC_BITS 16 +static const WarpedMotionParams default_warp_params = { + IDENTITY, + { 0, 0, (1 << WARPEDMODEL_PREC_BITS), 0, 0, (1 << WARPEDMODEL_PREC_BITS) }, + 0, 0, 0, 0, +}; + +#define REF_FRAMES_LOG2 3 +#define REF_FRAMES (1 << REF_FRAMES_LOG2) +#define FRAME_BUFFERS (REF_FRAMES + 7) +typedef struct { +#if 0 + int ref_count; +#endif + + unsigned int cur_frame_offset; + unsigned int ref_frame_offset[INTER_REFS_PER_FRAME]; + + MV_REF *mvs; + ptrdiff_t mv_stride; +#if 0 +#if CONFIG_SEGMENT_PRED_LAST + uint8_t *seg_map; +#endif +#endif + int mi_rows; + int mi_cols; +#if 0 + // Width and height give the size of the buffer (before any upscaling, unlike + // the sizes that can be derived from the buf structure) + int width; + int height; + WarpedMotionParams global_motion[TOTAL_REFS_PER_FRAME]; +#if CONFIG_FILM_GRAIN_SHOWEX + int showable_frame; // frame can be used as show existing frame in future +#endif +#if CONFIG_FILM_GRAIN + int film_grain_params_present; + aom_film_grain_t film_grain_params; +#endif + aom_codec_frame_buffer_t raw_frame_buffer; + YV12_BUFFER_CONFIG buf; +#if CONFIG_HASH_ME + hash_table hash_table; +#endif +#endif + uint8_t intra_only; +#if 0 + FRAME_TYPE frame_type; + // The Following variables will only be used in frame parallel decode. + + // frame_worker_owner indicates which FrameWorker owns this buffer. NULL means + // that no FrameWorker owns, or is decoding, this buffer. + AVxWorker *frame_worker_owner; + + // row and col indicate which position frame has been decoded to in real + // pixel unit. They are reset to -1 when decoding begins and set to INT_MAX + // when the frame is fully decoded. + int row; + int col; +#endif +} RefCntBuffer; + +#define INVALID_IDX -1 // Invalid buffer index. +typedef struct TileInfo { + int mi_row_start, mi_row_end; + int mi_col_start, mi_col_end; + int tg_horz_boundary; +} TileInfo; +typedef struct macroblockd { +#if 0 + struct macroblockd_plane plane[MAX_MB_PLANE]; + uint8_t bmode_blocks_wl; + uint8_t bmode_blocks_hl; + + FRAME_COUNTS *counts; +#endif + TileInfo tile; + int mi_stride; + + CUR_MODE_INFO cur_mi; + MB_MODE_INFO *mi; +#if 0 + MODE_INFO *left_mi; + MODE_INFO *above_mi; + MB_MODE_INFO *left_mbmi; + MB_MODE_INFO *above_mbmi; + MB_MODE_INFO *chroma_left_mbmi; + MB_MODE_INFO *chroma_above_mbmi; +#endif + int up_available; + int left_available; +#if 0 + int chroma_up_available; + int chroma_left_available; +#endif + /* Distance of MB away from frame edges in subpixels (1/8th pixel) */ + int mb_to_left_edge; + int mb_to_right_edge; + int mb_to_top_edge; + int mb_to_bottom_edge; +#if 0 + FRAME_CONTEXT *fc; + + /* pointers to reference frames */ + const RefBuffer *block_refs[2]; + + /* pointer to current frame */ + const YV12_BUFFER_CONFIG *cur_buf; + + ENTROPY_CONTEXT *above_context[MAX_MB_PLANE]; + ENTROPY_CONTEXT left_context[MAX_MB_PLANE][2 * MAX_MIB_SIZE]; + + PARTITION_CONTEXT *above_seg_context; + PARTITION_CONTEXT left_seg_context[MAX_MIB_SIZE]; + + TXFM_CONTEXT *above_txfm_context; + TXFM_CONTEXT *left_txfm_context; + TXFM_CONTEXT left_txfm_context_buffer[2 * MAX_MIB_SIZE]; + +#if CONFIG_LOOP_RESTORATION + WienerInfo wiener_info[MAX_MB_PLANE]; + SgrprojInfo sgrproj_info[MAX_MB_PLANE]; +#endif // CONFIG_LOOP_RESTORATION +#endif + // block dimension in the unit of mode_info. + uint8_t n8_w, n8_h; +#if 0 + uint8_t ref_mv_count[MODE_CTX_REF_FRAMES]; + CANDIDATE_MV ref_mv_stack[MODE_CTX_REF_FRAMES][MAX_REF_MV_STACK_SIZE]; +#endif + uint8_t is_sec_rect; + +#if 0 + // Counts of each reference frame in the above and left neighboring blocks. + // NOTE: Take into account both single and comp references. + uint8_t neighbors_ref_counts[TOTAL_REFS_PER_FRAME]; + + FRAME_CONTEXT *tile_ctx; + /* Bit depth: 8, 10, 12 */ + int bd; + + int qindex[MAX_SEGMENTS]; + int lossless[MAX_SEGMENTS]; + int corrupted; + int cur_frame_force_integer_mv; +// same with that in AV1_COMMON + struct aom_internal_error_info *error_info; + const WarpedMotionParams *global_motion; + int prev_qindex; + int delta_qindex; + int current_qindex; +#if CONFIG_EXT_DELTA_Q + // Since actual frame level loop filtering level value is not available + // at the beginning of the tile (only available during actual filtering) + // at encoder side.we record the delta_lf (against the frame level loop + // filtering level) and code the delta between previous superblock's delta + // lf and current delta lf. It is equivalent to the delta between previous + // superblock's actual lf and current lf. + int prev_delta_lf_from_base; + int current_delta_lf_from_base; + // For this experiment, we have four frame filter levels for different plane + // and direction. So, to support the per superblock update, we need to add + // a few more params as below. + // 0: delta loop filter level for y plane vertical + // 1: delta loop filter level for y plane horizontal + // 2: delta loop filter level for u plane + // 3: delta loop filter level for v plane + // To make it consistent with the reference to each filter level in segment, + // we need to -1, since + // SEG_LVL_ALT_LF_Y_V = 1; + // SEG_LVL_ALT_LF_Y_H = 2; + // SEG_LVL_ALT_LF_U = 3; + // SEG_LVL_ALT_LF_V = 4; + int prev_delta_lf[FRAME_LF_COUNT]; + int curr_delta_lf[FRAME_LF_COUNT]; +#endif + + DECLARE_ALIGNED(16, uint8_t, seg_mask[2 * MAX_SB_SQUARE]); + + CFL_CTX cfl; + + JNT_COMP_PARAMS jcp_param; + + int all_one_sided_refs; +#endif +} MACROBLOCKD; +typedef struct RefBuffer { + int idx; // frame buf idx +#if 0 + int map_idx; // frame map idx + YV12_BUFFER_CONFIG *buf; + struct scale_factors sf; +#endif +} RefBuffer; +typedef struct BufferPool { +#if 0 +// Protect BufferPool from being accessed by several FrameWorkers at +// the same time during frame parallel decode. +// TODO(hkuang): Try to use atomic variable instead of locking the whole pool. +#if CONFIG_MULTITHREAD + pthread_mutex_t pool_mutex; +#endif + + // Private data associated with the frame buffer callbacks. + void *cb_priv; + + aom_get_frame_buffer_cb_fn_t get_fb_cb; + aom_release_frame_buffer_cb_fn_t release_fb_cb; +#endif + RefCntBuffer frame_bufs[FRAME_BUFFERS]; +#if 0 + // Frame buffers allocated internally by the codec. + InternalFrameBufferList int_frame_buffers; +#endif +} BufferPool; +typedef struct AV1Common { +#if 0 + struct aom_internal_error_info error; + aom_color_primaries_t color_primaries; + aom_transfer_characteristics_t transfer_characteristics; + aom_matrix_coefficients_t matrix_coefficients; + int color_range; + int width; + int height; + int render_width; + int render_height; + int last_width; + int last_height; + int timing_info_present; + uint32_t num_units_in_tick; + uint32_t time_scale; + int equal_picture_interval; + uint32_t num_ticks_per_picture; + + // TODO(jkoleszar): this implies chroma ss right now, but could vary per + // plane. Revisit as part of the future change to YV12_BUFFER_CONFIG to + // support additional planes. + int subsampling_x; + int subsampling_y; + + int largest_tile_id; + size_t largest_tile_size; + + // Scale of the current frame with respect to itself. + struct scale_factors sf_identity; + + // Marks if we need to use 16bit frame buffers (1: yes, 0: no). + int use_highbitdepth; + YV12_BUFFER_CONFIG *frame_to_show; +#endif + + // TODO(hkuang): Combine this with cur_buf in macroblockd. + RefCntBuffer cur_frame; +#if 0 + int ref_frame_map[REF_FRAMES]; /* maps fb_idx to reference slot */ + + // Prepare ref_frame_map for the next frame. + // Only used in frame parallel decode. + int next_ref_frame_map[REF_FRAMES]; + + // TODO(jkoleszar): could expand active_ref_idx to 4, with 0 as intra, and + // roll new_fb_idx into it. +#endif + + // Each Inter frame can reference INTER_REFS_PER_FRAME buffers + RefBuffer frame_refs[INTER_REFS_PER_FRAME]; + +#if 0 + int is_skip_mode_allowed; + int skip_mode_flag; + int ref_frame_idx_0; + int ref_frame_idx_1; + + int new_fb_idx; + + FRAME_TYPE last_frame_type; /* last frame's frame type for motion search.*/ + FRAME_TYPE frame_type; + + int show_frame; +#if CONFIG_FILM_GRAIN_SHOWEX + int showable_frame; // frame can be used as show existing frame in future +#endif + int last_show_frame; + int show_existing_frame; + // Flag for a frame used as a reference - not written to the bitstream + int is_reference_frame; + +#if CONFIG_FWD_KF + int reset_decoder_state; +#endif // CONFIG_FWD_KF + + // Flag signaling that the frame is encoded using only INTRA modes. + uint8_t intra_only; + uint8_t last_intra_only; + +#if CONFIG_CDF_UPDATE_MODE + uint8_t disable_cdf_update; +#endif // CONFIG_CDF_UPDATE_MODE +#endif + int allow_high_precision_mv; + int cur_frame_force_integer_mv; // 0 the default in AOM, 1 only integer +#if 0 + int disable_intra_edge_filter; // 1 - disable corner/edge/upsampling + int allow_screen_content_tools; + int allow_intrabc; + int allow_interintra_compound; + int allow_masked_compound; + +#if !CONFIG_NO_FRAME_CONTEXT_SIGNALING + // Flag signaling which frame contexts should be reset to default values. + RESET_FRAME_CONTEXT_MODE reset_frame_context; +#endif + + // MBs, mb_rows/cols is in 16-pixel units; mi_rows/cols is in + // MODE_INFO (8-pixel) units. + int MBs; + int mb_rows, mi_rows; + int mb_cols, mi_cols; +#endif + int mi_rows; + int mi_cols; + int mi_stride; + +#if 0 + /* profile settings */ + TX_MODE tx_mode; + + int base_qindex; + int y_dc_delta_q; + int u_dc_delta_q; + int v_dc_delta_q; + int u_ac_delta_q; + int v_ac_delta_q; + + int separate_uv_delta_q; + + // The dequantizers below are true dequntizers used only in the + // dequantization process. They have the same coefficient + // shift/scale as TX. + int16_t y_dequant_QTX[MAX_SEGMENTS][2]; + int16_t u_dequant_QTX[MAX_SEGMENTS][2]; + int16_t v_dequant_QTX[MAX_SEGMENTS][2]; + + // Global quant matrix tables + const qm_val_t *giqmatrix[NUM_QM_LEVELS][3][TX_SIZES_ALL]; + const qm_val_t *gqmatrix[NUM_QM_LEVELS][3][TX_SIZES_ALL]; + + // Local quant matrix tables for each frame + const qm_val_t *y_iqmatrix[MAX_SEGMENTS][TX_SIZES_ALL]; + const qm_val_t *u_iqmatrix[MAX_SEGMENTS][TX_SIZES_ALL]; + const qm_val_t *v_iqmatrix[MAX_SEGMENTS][TX_SIZES_ALL]; + + // Encoder + int using_qmatrix; +#if CONFIG_AOM_QM_EXT + int qm_y; + int qm_u; + int qm_v; +#endif // CONFIG_AOM_QM_EXT + int min_qmlevel; + int max_qmlevel; + + /* We allocate a MODE_INFO struct for each macroblock, together with + an extra row on top and column on the left to simplify prediction. */ + int mi_alloc_size; + MODE_INFO *mip; /* Base of allocated array */ + MODE_INFO *mi; /* Corresponds to upper left visible macroblock */ + + // TODO(agrange): Move prev_mi into encoder structure. + // prev_mip and prev_mi will only be allocated in encoder. + MODE_INFO *prev_mip; /* MODE_INFO array 'mip' from last decoded frame */ + MODE_INFO *prev_mi; /* 'mi' from last frame (points into prev_mip) */ + + // Separate mi functions between encoder and decoder. + int (*alloc_mi)(struct AV1Common *cm, int mi_size); + void (*free_mi)(struct AV1Common *cm); + void (*setup_mi)(struct AV1Common *cm); + + // Grid of pointers to 8x8 MODE_INFO structs. Any 8x8 not in the visible + // area will be NULL. + MODE_INFO **mi_grid_base; + MODE_INFO **mi_grid_visible; + MODE_INFO **prev_mi_grid_base; + MODE_INFO **prev_mi_grid_visible; +#endif + // Whether to use previous frame's motion vectors for prediction. + int allow_ref_frame_mvs; + +#if 0 +#if !CONFIG_SEGMENT_PRED_LAST + // Persistent mb segment id map used in prediction. + int seg_map_idx; + int prev_seg_map_idx; + + uint8_t *seg_map_array[NUM_PING_PONG_BUFFERS]; +#endif + uint8_t *last_frame_seg_map; + uint8_t *current_frame_seg_map; + int seg_map_alloc_size; + + InterpFilter interp_filter; + + int switchable_motion_mode; + + loop_filter_info_n lf_info; + // The denominator of the superres scale; the numerator is fixed. + uint8_t superres_scale_denominator; + int superres_upscaled_width; + int superres_upscaled_height; + RestorationInfo rst_info[MAX_MB_PLANE]; + + // rst_end_stripe[i] is one more than the index of the bottom stripe + // for tile row i. + int rst_end_stripe[MAX_TILE_ROWS]; + + // Pointer to a scratch buffer used by self-guided restoration + int32_t *rst_tmpbuf; + + // Flag signaling how frame contexts should be updated at the end of + // a frame decode + REFRESH_FRAME_CONTEXT_MODE refresh_frame_context; +#endif + int ref_frame_sign_bias[TOTAL_REFS_PER_FRAME]; /* Two state 0, 1 */ +#if 0 + struct loopfilter lf; + struct segmentation seg; + int all_lossless; +#endif + int frame_parallel_decode; // frame-based threading. +#if 0 + int reduced_tx_set_used; + + // Context probabilities for reference frame prediction + MV_REFERENCE_FRAME comp_fwd_ref[FWD_REFS]; + MV_REFERENCE_FRAME comp_bwd_ref[BWD_REFS]; + REFERENCE_MODE reference_mode; + + FRAME_CONTEXT *fc; /* this frame entropy */ + FRAME_CONTEXT *frame_contexts; // FRAME_CONTEXTS + FRAME_CONTEXT *pre_fc; // Context referenced in this frame + unsigned int frame_context_idx; /* Context to use/update */ +#if CONFIG_NO_FRAME_CONTEXT_SIGNALING + int fb_of_context_type[REF_FRAMES]; + int primary_ref_frame; +#endif + FRAME_COUNTS counts; +#endif + + unsigned int frame_offset; + +#if 0 + unsigned int current_video_frame; + BITSTREAM_PROFILE profile; + + // AOM_BITS_8 in profile 0 or 1, AOM_BITS_10 or AOM_BITS_12 in profile 2 or 3. + aom_bit_depth_t bit_depth; + aom_bit_depth_t dequant_bit_depth; // bit_depth of current dequantizer + + int error_resilient_mode; + + int tile_cols, tile_rows; + int last_tile_cols, last_tile_rows; + + BOUNDARY_TYPE *boundary_info; + int boundary_info_alloc_size; + +#if CONFIG_MAX_TILE + int min_log2_tile_cols; + int max_log2_tile_cols; + int max_log2_tile_rows; + int min_log2_tile_rows; + int min_log2_tiles; + int max_tile_width_sb; + int max_tile_height_sb; + int uniform_tile_spacing_flag; + int log2_tile_cols; // only valid for uniform tiles + int log2_tile_rows; // only valid for uniform tiles + int tile_col_start_sb[MAX_TILE_COLS + 1]; // valid for 0 <= i <= tile_cols + int tile_row_start_sb[MAX_TILE_ROWS + 1]; // valid for 0 <= i <= tile_rows +#if CONFIG_DEPENDENT_HORZTILES + int tile_row_independent[MAX_TILE_ROWS]; // valid for 0 <= i < tile_rows +#endif + int tile_width, tile_height; // In MI units +#else + int log2_tile_cols, log2_tile_rows; // Used in non-large_scale_tile_coding. + int tile_width, tile_height; // In MI units +#endif // CONFIG_MAX_TILE + +#if CONFIG_EXT_TILE + unsigned int large_scale_tile; + unsigned int single_tile_decoding; +#endif // CONFIG_EXT_TILE + +#if CONFIG_DEPENDENT_HORZTILES + int dependent_horz_tiles; + int tile_group_start_row[MAX_TILE_ROWS][MAX_TILE_COLS]; + int tile_group_start_col[MAX_TILE_ROWS][MAX_TILE_COLS]; +#endif +#if CONFIG_LOOPFILTERING_ACROSS_TILES +#if CONFIG_LOOPFILTERING_ACROSS_TILES_EXT + int loop_filter_across_tiles_v_enabled; + int loop_filter_across_tiles_h_enabled; +#else + int loop_filter_across_tiles_enabled; +#endif // CONFIG_LOOPFILTERING_ACROSS_TILES_EXT +#endif // CONFIG_LOOPFILTERING_ACROSS_TILES + + int byte_alignment; + int skip_loop_filter; + + // Private data associated with the frame buffer callbacks. + void *cb_priv; + aom_get_frame_buffer_cb_fn_t get_fb_cb; + aom_release_frame_buffer_cb_fn_t release_fb_cb; + + // Handles memory for the codec. + InternalFrameBufferList int_frame_buffers; +#endif + // External BufferPool passed from outside. + BufferPool buffer_pool; +#if 0 + PARTITION_CONTEXT *above_seg_context; + ENTROPY_CONTEXT *above_context[MAX_MB_PLANE]; + TXFM_CONTEXT *above_txfm_context; + TXFM_CONTEXT *top_txfm_context[MAX_MB_PLANE]; + TXFM_CONTEXT left_txfm_context[MAX_MB_PLANE][2 * MAX_MIB_SIZE]; + int above_context_alloc_cols; +#endif + + WarpedMotionParams global_motion[TOTAL_REFS_PER_FRAME]; +#if 0 +#if CONFIG_FILM_GRAIN + int film_grain_params_present; + aom_film_grain_t film_grain_params; +#endif + int cdef_pri_damping; + int cdef_sec_damping; + int nb_cdef_strengths; + int cdef_strengths[CDEF_MAX_STRENGTHS]; + int cdef_uv_strengths[CDEF_MAX_STRENGTHS]; + int cdef_bits; + int cdef_preset[4]; + + int delta_q_present_flag; + // Resolution of delta quant + int delta_q_res; +#if CONFIG_EXT_DELTA_Q + int delta_lf_present_flag; + // Resolution of delta lf level + int delta_lf_res; + // This is a flag for number of deltas of loop filter level + // 0: use 1 delta, for y_vertical, y_horizontal, u, and v + // 1: use separate deltas for each filter level + int delta_lf_multi; +#endif + int num_tg; +#endif + struct { + BLOCK_SIZE sb_size; + int enable_order_hint; + int order_hint_bits_minus1; + } seq_params; +#if 0 + SequenceHeader seq_params; + int current_frame_id; + int ref_frame_id[REF_FRAMES]; + int valid_for_referencing[REF_FRAMES]; + int refresh_mask; + int invalid_delta_frame_id_minus1; + LV_MAP_CTX_TABLE coeff_ctx_table; +#endif + TPL_MV_REF *tpl_mvs; +#if 0 + int tpl_mvs_mem_size; +#endif + // TODO(jingning): This can be combined with sign_bias later. + int8_t ref_frame_side[TOTAL_REFS_PER_FRAME]; + +#if 0 + int frame_refs_short_signaling; + +#if CONFIG_SCALABILITY + int temporal_layer_id; + int enhancement_layer_id; + int enhancement_layers_cnt; +#endif +#if TXCOEFF_TIMER + int64_t cum_txcoeff_timer; + int64_t txcoeff_timer; + int txb_count; +#endif + +#if TXCOEFF_COST_TIMER + int64_t cum_txcoeff_cost_timer; + int64_t txcoeff_cost_timer; + int64_t txcoeff_cost_count; +#endif + const cfg_options_t *options; +#endif + + int ref_buf_idx[INTER_REFS_PER_FRAME]; + int ref_order_hint[INTER_REFS_PER_FRAME]; +} AV1_COMMON; + +static INLINE void integer_mv_precision(MV *mv) { + int mod = (mv->row % 8); + if (mod != 0) { + mv->row -= mod; + if (abs(mod) > 4) { + if (mod > 0) { + mv->row += 8; + } else { + mv->row -= 8; + } + } + } + + mod = (mv->col % 8); + if (mod != 0) { + mv->col -= mod; + if (abs(mod) > 4) { + if (mod > 0) { + mv->col += 8; + } else { + mv->col -= 8; + } + } + } +} + +static INLINE int clamp(int value, int low, int high) { + return value < low ? low : (value > high ? high : value); +} + +static INLINE void clamp_mv(MV *mv, int min_col, int max_col, int min_row, + int max_row) { + mv->col = clamp(mv->col, min_col, max_col); + mv->row = clamp(mv->row, min_row, max_row); +} + +#if 0 +static INLINE int frame_is_intra_only(const AV1_COMMON *const cm) { + return cm->frame_type == KEY_FRAME || cm->intra_only; +} +#endif + +static INLINE int is_intrabc_block(const MB_MODE_INFO *mbmi) { + return mbmi->ref_frame[0] == INTRA_FRAME && mbmi->mv[0].as_mv.row != -0x8000; + //return mbmi->use_intrabc; +} + +static INLINE int is_inter_block(const MB_MODE_INFO *mbmi) { + if (is_intrabc_block(mbmi)) return 1; + return mbmi->ref_frame[0] > INTRA_FRAME; +} + +static INLINE int has_second_ref(const MB_MODE_INFO *mbmi) { + return mbmi->ref_frame[1] > INTRA_FRAME; +} + +static INLINE MV_REFERENCE_FRAME comp_ref0(int ref_idx) { + static const MV_REFERENCE_FRAME lut[] = { + LAST_FRAME, // LAST_LAST2_FRAMES, + LAST_FRAME, // LAST_LAST3_FRAMES, + LAST_FRAME, // LAST_GOLDEN_FRAMES, + BWDREF_FRAME, // BWDREF_ALTREF_FRAMES, + LAST2_FRAME, // LAST2_LAST3_FRAMES + LAST2_FRAME, // LAST2_GOLDEN_FRAMES, + LAST3_FRAME, // LAST3_GOLDEN_FRAMES, + BWDREF_FRAME, // BWDREF_ALTREF2_FRAMES, + ALTREF2_FRAME, // ALTREF2_ALTREF_FRAMES, + }; + assert(NELEMENTS(lut) == TOTAL_UNIDIR_COMP_REFS); + return lut[ref_idx]; +} + +static INLINE MV_REFERENCE_FRAME comp_ref1(int ref_idx) { + static const MV_REFERENCE_FRAME lut[] = { + LAST2_FRAME, // LAST_LAST2_FRAMES, + LAST3_FRAME, // LAST_LAST3_FRAMES, + GOLDEN_FRAME, // LAST_GOLDEN_FRAMES, + ALTREF_FRAME, // BWDREF_ALTREF_FRAMES, + LAST3_FRAME, // LAST2_LAST3_FRAMES + GOLDEN_FRAME, // LAST2_GOLDEN_FRAMES, + GOLDEN_FRAME, // LAST3_GOLDEN_FRAMES, + ALTREF2_FRAME, // BWDREF_ALTREF2_FRAMES, + ALTREF_FRAME, // ALTREF2_ALTREF_FRAMES, + }; + assert(NELEMENTS(lut) == TOTAL_UNIDIR_COMP_REFS); + return lut[ref_idx]; +} + +#define WARPEDMODEL_PREC_BITS 16 +#define GM_TRANS_ONLY_PREC_DIFF (WARPEDMODEL_PREC_BITS - 3) +#define WARPEDMODEL_ROW3HOMO_PREC_BITS 16 + +static INLINE int convert_to_trans_prec(int allow_hp, int coor) { + if (allow_hp) + return ROUND_POWER_OF_TWO_SIGNED(coor, WARPEDMODEL_PREC_BITS - 3); + else + return ROUND_POWER_OF_TWO_SIGNED(coor, WARPEDMODEL_PREC_BITS - 2) * 2; +} + +static INLINE int block_center_x(int mi_col, BLOCK_SIZE bs) { + const int bw = block_size_wide[bs]; + return mi_col * MI_SIZE + bw / 2 - 1; +} + +static INLINE int block_center_y(int mi_row, BLOCK_SIZE bs) { + const int bh = block_size_high[bs]; + return mi_row * MI_SIZE + bh / 2 - 1; +} + +#if 0 +static INLINE MV_REFERENCE_FRAME comp_ref0(int ref_idx) { + static const MV_REFERENCE_FRAME lut[] = { + LAST_FRAME, // LAST_LAST2_FRAMES, + LAST_FRAME, // LAST_LAST3_FRAMES, + LAST_FRAME, // LAST_GOLDEN_FRAMES, + BWDREF_FRAME, // BWDREF_ALTREF_FRAMES, + }; + assert(NELEMENTS(lut) == UNIDIR_COMP_REFS); + return lut[ref_idx]; +} + +static INLINE MV_REFERENCE_FRAME comp_ref1(int ref_idx) { + static const MV_REFERENCE_FRAME lut[] = { + LAST2_FRAME, // LAST_LAST2_FRAMES, + LAST3_FRAME, // LAST_LAST3_FRAMES, + GOLDEN_FRAME, // LAST_GOLDEN_FRAMES, + ALTREF_FRAME, // BWDREF_ALTREF_FRAMES, + }; + assert(NELEMENTS(lut) == UNIDIR_COMP_REFS); + return lut[ref_idx]; +} +#endif + +// Convert a global motion vector into a motion vector at the centre of the +// given block. +// +// The resulting motion vector will have three fractional bits of precision. If +// allow_hp is zero, the bottom bit will always be zero. If CONFIG_AMVR and +// is_integer is true, the bottom three bits will be zero (so the motion vector +// represents an integer) +static INLINE int_mv gm_get_motion_vector(const WarpedMotionParams *gm, + int allow_hp, BLOCK_SIZE bsize, + int mi_col, int mi_row, + int is_integer) { + int_mv res; + const int32_t *mat = gm->wmmat; + int x, y, tx, ty; + + if (gm->wmtype == TRANSLATION) { + // All global motion vectors are stored with WARPEDMODEL_PREC_BITS (16) + // bits of fractional precision. The offset for a translation is stored in + // entries 0 and 1. For translations, all but the top three (two if + // cm->allow_high_precision_mv is false) fractional bits are always zero. + // + // After the right shifts, there are 3 fractional bits of precision. If + // allow_hp is false, the bottom bit is always zero (so we don't need a + // call to convert_to_trans_prec here) + res.as_mv.row = gm->wmmat[0] >> GM_TRANS_ONLY_PREC_DIFF; + res.as_mv.col = gm->wmmat[1] >> GM_TRANS_ONLY_PREC_DIFF; + assert(IMPLIES(1 & (res.as_mv.row | res.as_mv.col), allow_hp)); + if (is_integer) { + integer_mv_precision(&res.as_mv); + } + return res; + } + + x = block_center_x(mi_col, bsize); + y = block_center_y(mi_row, bsize); + + if (gm->wmtype == ROTZOOM) { + assert(gm->wmmat[5] == gm->wmmat[2]); + assert(gm->wmmat[4] == -gm->wmmat[3]); + } + if (gm->wmtype > AFFINE) { + int xc = (int)((int64_t)mat[2] * x + (int64_t)mat[3] * y + mat[0]); + int yc = (int)((int64_t)mat[4] * x + (int64_t)mat[5] * y + mat[1]); + const int Z = (int)((int64_t)mat[6] * x + (int64_t)mat[7] * y + + (1 << WARPEDMODEL_ROW3HOMO_PREC_BITS)); + xc *= 1 << (WARPEDMODEL_ROW3HOMO_PREC_BITS - WARPEDMODEL_PREC_BITS); + yc *= 1 << (WARPEDMODEL_ROW3HOMO_PREC_BITS - WARPEDMODEL_PREC_BITS); + xc = (int)(xc > 0 ? ((int64_t)xc + Z / 2) / Z : ((int64_t)xc - Z / 2) / Z); + yc = (int)(yc > 0 ? ((int64_t)yc + Z / 2) / Z : ((int64_t)yc - Z / 2) / Z); + tx = convert_to_trans_prec(allow_hp, xc) - (x << 3); + ty = convert_to_trans_prec(allow_hp, yc) - (y << 3); + } else { + const int xc = + (mat[2] - (1 << WARPEDMODEL_PREC_BITS)) * x + mat[3] * y + mat[0]; + const int yc = + mat[4] * x + (mat[5] - (1 << WARPEDMODEL_PREC_BITS)) * y + mat[1]; + tx = convert_to_trans_prec(allow_hp, xc); + ty = convert_to_trans_prec(allow_hp, yc); + } + + res.as_mv.row = ty; + res.as_mv.col = tx; + + if (is_integer) { + integer_mv_precision(&res.as_mv); + } + return res; +} + +static INLINE int have_newmv_in_inter_mode(PREDICTION_MODE mode) { + return (mode == NEWMV || mode == NEW_NEWMV || mode == NEAREST_NEWMV || + mode == NEW_NEARESTMV || mode == NEAR_NEWMV || mode == NEW_NEARMV); +} + +/* + * 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 AV1_COMMON_MVREF_COMMON_H_ +#define AV1_COMMON_MVREF_COMMON_H_ + +//#include "av1/common/onyxc_int.h" +//#include "av1/common/blockd.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define MVREF_ROW_COLS 3 + +// Set the upper limit of the motion vector component magnitude. +// This would make a motion vector fit in 26 bits. Plus 3 bits for the +// reference frame index. A tuple of motion vector can hence be stored within +// 32 bit range for efficient load/store operations. +#define REFMVS_LIMIT ((1 << 12) - 1) + +typedef struct position { + int row; + int col; +} POSITION; + +// clamp_mv_ref +#define MV_BORDER (16 << 3) // Allow 16 pels in 1/8th pel units + +static INLINE int get_relative_dist(const AV1_COMMON *cm, int a, int b) { + if (!cm->seq_params.enable_order_hint) return 0; + + const int bits = cm->seq_params.order_hint_bits_minus1 + 1; + + assert(bits >= 1); + assert(a >= 0 && a < (1 << bits)); + assert(b >= 0 && b < (1 << bits)); + + int diff = a - b; + int m = 1 << (bits - 1); + diff = (diff & (m - 1)) - (diff & m); + return diff; +} + +static INLINE void clamp_mv_ref(MV *mv, int bw, int bh, const MACROBLOCKD *xd) { + clamp_mv(mv, xd->mb_to_left_edge - bw * 8 - MV_BORDER, + xd->mb_to_right_edge + bw * 8 + MV_BORDER, + xd->mb_to_top_edge - bh * 8 - MV_BORDER, + xd->mb_to_bottom_edge + bh * 8 + MV_BORDER); +} + +// This function returns either the appropriate sub block or block's mv +// on whether the block_size < 8x8 and we have check_sub_blocks set. +static INLINE int_mv get_sub_block_mv(const MB_MODE_INFO *candidate, + int which_mv, int search_col) { + (void)search_col; + return candidate->mv[which_mv]; +} + +static INLINE int_mv get_sub_block_pred_mv(const MB_MODE_INFO *candidate, + int which_mv, int search_col) { + (void)search_col; + return candidate->mv[which_mv]; +} + +// Performs mv sign inversion if indicated by the reference frame combination. +static INLINE int_mv scale_mv(const MB_MODE_INFO *mbmi, int ref, + const MV_REFERENCE_FRAME this_ref_frame, + const int *ref_sign_bias) { + int_mv mv = mbmi->mv[ref]; + if (ref_sign_bias[mbmi->ref_frame[ref]] != ref_sign_bias[this_ref_frame]) { + mv.as_mv.row *= -1; + mv.as_mv.col *= -1; + } + return mv; +} + +// Checks that the given mi_row, mi_col and search point +// are inside the borders of the tile. +static INLINE int is_inside(const TileInfo *const tile, int mi_col, int mi_row, + int mi_rows, const POSITION *mi_pos) { + const int dependent_horz_tile_flag = 0; + if (dependent_horz_tile_flag && !tile->tg_horz_boundary) { + return !(mi_row + mi_pos->row < 0 || + mi_col + mi_pos->col < tile->mi_col_start || + mi_row + mi_pos->row >= mi_rows || + mi_col + mi_pos->col >= tile->mi_col_end); + } else { + return !(mi_row + mi_pos->row < tile->mi_row_start || + mi_col + mi_pos->col < tile->mi_col_start || + mi_row + mi_pos->row >= tile->mi_row_end || + mi_col + mi_pos->col >= tile->mi_col_end); + } +} + +static INLINE int find_valid_row_offset(const TileInfo *const tile, int mi_row, + int mi_rows, int row_offset) { + const int dependent_horz_tile_flag = 0; + if (dependent_horz_tile_flag && !tile->tg_horz_boundary) + return clamp(row_offset, -mi_row, mi_rows - mi_row - 1); + else + return clamp(row_offset, tile->mi_row_start - mi_row, + tile->mi_row_end - mi_row - 1); +} + +static INLINE int find_valid_col_offset(const TileInfo *const tile, int mi_col, + int col_offset) { + return clamp(col_offset, tile->mi_col_start - mi_col, + tile->mi_col_end - mi_col - 1); +} + +static INLINE void lower_mv_precision(MV *mv, int allow_hp, + int is_integer) { + if (is_integer) { + integer_mv_precision(mv); + } else { + if (!allow_hp) { + if (mv->row & 1) mv->row += (mv->row > 0 ? -1 : 1); + if (mv->col & 1) mv->col += (mv->col > 0 ? -1 : 1); + } + } +} + +static INLINE int8_t get_uni_comp_ref_idx(const MV_REFERENCE_FRAME *const rf) { + // Single ref pred + if (rf[1] <= INTRA_FRAME) return -1; + + // Bi-directional comp ref pred + if ((rf[0] < BWDREF_FRAME) && (rf[1] >= BWDREF_FRAME)) return -1; + + for (int8_t ref_idx = 0; ref_idx < TOTAL_UNIDIR_COMP_REFS; ++ref_idx) { + if (rf[0] == comp_ref0(ref_idx) && rf[1] == comp_ref1(ref_idx)) + return ref_idx; + } + return -1; +} + +static INLINE int8_t av1_ref_frame_type(const MV_REFERENCE_FRAME *const rf) { + if (rf[1] > INTRA_FRAME) { + const int8_t uni_comp_ref_idx = get_uni_comp_ref_idx(rf); + if (uni_comp_ref_idx >= 0) { + assert((REF_FRAMES + FWD_REFS * BWD_REFS + uni_comp_ref_idx) < + MODE_CTX_REF_FRAMES); + return REF_FRAMES + FWD_REFS * BWD_REFS + uni_comp_ref_idx; + } else { + return REF_FRAMES + FWD_RF_OFFSET(rf[0]) + + BWD_RF_OFFSET(rf[1]) * FWD_REFS; + } + } + + return rf[0]; +} + +// clang-format off +static MV_REFERENCE_FRAME ref_frame_map[TOTAL_COMP_REFS][2] = { + { LAST_FRAME, BWDREF_FRAME }, { LAST2_FRAME, BWDREF_FRAME }, + { LAST3_FRAME, BWDREF_FRAME }, { GOLDEN_FRAME, BWDREF_FRAME }, + + { LAST_FRAME, ALTREF2_FRAME }, { LAST2_FRAME, ALTREF2_FRAME }, + { LAST3_FRAME, ALTREF2_FRAME }, { GOLDEN_FRAME, ALTREF2_FRAME }, + + { LAST_FRAME, ALTREF_FRAME }, { LAST2_FRAME, ALTREF_FRAME }, + { LAST3_FRAME, ALTREF_FRAME }, { GOLDEN_FRAME, ALTREF_FRAME }, + + { LAST_FRAME, LAST2_FRAME }, { LAST_FRAME, LAST3_FRAME }, + { LAST_FRAME, GOLDEN_FRAME }, { BWDREF_FRAME, ALTREF_FRAME }, + + // NOTE: Following reference frame pairs are not supported to be explicitly + // signalled, but they are possibly chosen by the use of skip_mode, + // which may use the most recent one-sided reference frame pair. + { LAST2_FRAME, LAST3_FRAME }, { LAST2_FRAME, GOLDEN_FRAME }, + { LAST3_FRAME, GOLDEN_FRAME }, {BWDREF_FRAME, ALTREF2_FRAME}, + { ALTREF2_FRAME, ALTREF_FRAME } +}; +// clang-format on + +static INLINE void av1_set_ref_frame(MV_REFERENCE_FRAME *rf, + int8_t ref_frame_type) { + if (ref_frame_type >= REF_FRAMES) { + rf[0] = ref_frame_map[ref_frame_type - REF_FRAMES][0]; + rf[1] = ref_frame_map[ref_frame_type - REF_FRAMES][1]; + } else { + rf[0] = ref_frame_type; + rf[1] = NONE_FRAME; + assert(ref_frame_type > NONE_FRAME); + } +} + +static uint16_t compound_mode_ctx_map[3][COMP_NEWMV_CTXS] = { + { 0, 1, 1, 1, 1 }, + { 1, 2, 3, 4, 4 }, + { 4, 4, 5, 6, 7 }, +}; + +static INLINE int16_t av1_mode_context_analyzer( + const int16_t *const mode_context, const MV_REFERENCE_FRAME *const rf) { + const int8_t ref_frame = av1_ref_frame_type(rf); + + if (rf[1] <= INTRA_FRAME) return mode_context[ref_frame]; + + const int16_t newmv_ctx = mode_context[ref_frame] & NEWMV_CTX_MASK; + const int16_t refmv_ctx = + (mode_context[ref_frame] >> REFMV_OFFSET) & REFMV_CTX_MASK; + + const int16_t comp_ctx = compound_mode_ctx_map[refmv_ctx >> 1][AOMMIN( + newmv_ctx, COMP_NEWMV_CTXS - 1)]; + return comp_ctx; +} + +static INLINE uint8_t av1_drl_ctx(const CANDIDATE_MV *ref_mv_stack, + int ref_idx) { + if (ref_mv_stack[ref_idx].weight >= REF_CAT_LEVEL && + ref_mv_stack[ref_idx + 1].weight >= REF_CAT_LEVEL) + return 0; + + if (ref_mv_stack[ref_idx].weight >= REF_CAT_LEVEL && + ref_mv_stack[ref_idx + 1].weight < REF_CAT_LEVEL) + return 1; + + if (ref_mv_stack[ref_idx].weight < REF_CAT_LEVEL && + ref_mv_stack[ref_idx + 1].weight < REF_CAT_LEVEL) + return 2; + + return 0; +} + +void av1_setup_frame_buf_refs(AV1_COMMON *cm); +void av1_setup_frame_sign_bias(AV1_COMMON *cm); +void av1_setup_skip_mode_allowed(AV1_COMMON *cm); + +#if 0 +void av1_setup_motion_field(AV1_COMMON *cm); +void av1_set_frame_refs(AV1_COMMON *const cm, int lst_map_idx, int gld_map_idx); +#endif // CONFIG_FRAME_REFS_SIGNALING + +#if 0 +static INLINE void av1_collect_neighbors_ref_counts(MACROBLOCKD *const xd) { + av1_zero(xd->neighbors_ref_counts); + + uint8_t *const ref_counts = xd->neighbors_ref_counts; + + const MB_MODE_INFO *const above_mbmi = xd->above_mbmi; + const MB_MODE_INFO *const left_mbmi = xd->left_mbmi; + const int above_in_image = xd->up_available; + const int left_in_image = xd->left_available; + + // Above neighbor + if (above_in_image && is_inter_block(above_mbmi)) { + ref_counts[above_mbmi->ref_frame[0]]++; + if (has_second_ref(above_mbmi)) { + ref_counts[above_mbmi->ref_frame[1]]++; + } + } + + // Left neighbor + if (left_in_image && is_inter_block(left_mbmi)) { + ref_counts[left_mbmi->ref_frame[0]]++; + if (has_second_ref(left_mbmi)) { + ref_counts[left_mbmi->ref_frame[1]]++; + } + } +} +#endif + +void av1_copy_frame_mvs(const AV1_COMMON *const cm, MB_MODE_INFO *mi, + int mi_row, int mi_col, int x_mis, int y_mis); + +void av1_find_mv_refs(const AV1_COMMON *cm, const MACROBLOCKD *xd, + MB_MODE_INFO *mi, MV_REFERENCE_FRAME ref_frame, + uint8_t ref_mv_count[MODE_CTX_REF_FRAMES], + CANDIDATE_MV ref_mv_stack[][MAX_REF_MV_STACK_SIZE], + int_mv mv_ref_list[][MAX_MV_REF_CANDIDATES], + int_mv *global_mvs, int mi_row, int mi_col, + int16_t *mode_context); + +// check a list of motion vectors by sad score using a number rows of pixels +// above and a number cols of pixels in the left to select the one with best +// score to use as ref motion vector +void av1_find_best_ref_mvs(int allow_hp, int_mv *mvlist, int_mv *nearest_mv, + int_mv *near_mv, int is_integer); + +int selectSamples(MV *mv, int *pts, int *pts_inref, int len, BLOCK_SIZE bsize); +int findSamples(const AV1_COMMON *cm, MACROBLOCKD *xd, int mi_row, int mi_col, + int *pts, int *pts_inref); + +#define INTRABC_DELAY_PIXELS 256 // Delay of 256 pixels +#define INTRABC_DELAY_SB64 (INTRABC_DELAY_PIXELS / 64) +#define USE_WAVE_FRONT 1 // Use only top left area of frame for reference. + +static INLINE void av1_find_ref_dv(int_mv *ref_dv, const TileInfo *const tile, + int mib_size, int mi_row, int mi_col) { + (void)mi_col; + if (mi_row - mib_size < tile->mi_row_start) { + ref_dv->as_mv.row = 0; + ref_dv->as_mv.col = -MI_SIZE * mib_size - INTRABC_DELAY_PIXELS; + } else { + ref_dv->as_mv.row = -MI_SIZE * mib_size; + ref_dv->as_mv.col = 0; + } + ref_dv->as_mv.row *= 8; + ref_dv->as_mv.col *= 8; +} + +static INLINE int av1_is_dv_valid(const MV dv, const AV1_COMMON *cm, + const MACROBLOCKD *xd, int mi_row, int mi_col, + BLOCK_SIZE bsize, int mib_size_log2) { + const int bw = block_size_wide[bsize]; + const int bh = block_size_high[bsize]; + const int SCALE_PX_TO_MV = 8; + // Disallow subpixel for now + // SUBPEL_MASK is not the correct scale + if (((dv.row & (SCALE_PX_TO_MV - 1)) || (dv.col & (SCALE_PX_TO_MV - 1)))) + return 0; + + const TileInfo *const tile = &xd->tile; + // Is the source top-left inside the current tile? + const int src_top_edge = mi_row * MI_SIZE * SCALE_PX_TO_MV + dv.row; + const int tile_top_edge = tile->mi_row_start * MI_SIZE * SCALE_PX_TO_MV; + if (src_top_edge < tile_top_edge) return 0; + const int src_left_edge = mi_col * MI_SIZE * SCALE_PX_TO_MV + dv.col; + const int tile_left_edge = tile->mi_col_start * MI_SIZE * SCALE_PX_TO_MV; + if (src_left_edge < tile_left_edge) return 0; + // Is the bottom right inside the current tile? + const int src_bottom_edge = (mi_row * MI_SIZE + bh) * SCALE_PX_TO_MV + dv.row; + const int tile_bottom_edge = tile->mi_row_end * MI_SIZE * SCALE_PX_TO_MV; + if (src_bottom_edge > tile_bottom_edge) return 0; + const int src_right_edge = (mi_col * MI_SIZE + bw) * SCALE_PX_TO_MV + dv.col; + const int tile_right_edge = tile->mi_col_end * MI_SIZE * SCALE_PX_TO_MV; + if (src_right_edge > tile_right_edge) return 0; + +#if 0 + // Special case for sub 8x8 chroma cases, to prevent referring to chroma + // pixels outside current tile. + for (int plane = 1; plane < av1_num_planes(cm); ++plane) { + const struct macroblockd_plane *const pd = &xd->plane[plane]; + if (is_chroma_reference(mi_row, mi_col, bsize, pd->subsampling_x, + pd->subsampling_y)) { + if (bw < 8 && pd->subsampling_x) + if (src_left_edge < tile_left_edge + 4 * SCALE_PX_TO_MV) return 0; + if (bh < 8 && pd->subsampling_y) + if (src_top_edge < tile_top_edge + 4 * SCALE_PX_TO_MV) return 0; + } + } +#endif + + // Is the bottom right within an already coded SB? Also consider additional + // constraints to facilitate HW decoder. + const int max_mib_size = 1 << mib_size_log2; + const int active_sb_row = mi_row >> mib_size_log2; + const int active_sb64_col = (mi_col * MI_SIZE) >> 6; + const int sb_size = max_mib_size * MI_SIZE; + const int src_sb_row = ((src_bottom_edge >> 3) - 1) / sb_size; + const int src_sb64_col = ((src_right_edge >> 3) - 1) >> 6; + const int total_sb64_per_row = + ((tile->mi_col_end - tile->mi_col_start - 1) >> 4) + 1; + const int active_sb64 = active_sb_row * total_sb64_per_row + active_sb64_col; + const int src_sb64 = src_sb_row * total_sb64_per_row + src_sb64_col; + if (src_sb64 >= active_sb64 - INTRABC_DELAY_SB64) return 0; + +#if USE_WAVE_FRONT + const int gradient = 1 + INTRABC_DELAY_SB64 + (sb_size > 64); + const int wf_offset = gradient * (active_sb_row - src_sb_row); + if (src_sb_row > active_sb_row || + src_sb64_col >= active_sb64_col - INTRABC_DELAY_SB64 + wf_offset) + return 0; +#endif + + return 1; +} + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // AV1_COMMON_MVREF_COMMON_H_ + +/* + * 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 <stdlib.h> + +//#include "av1/common/mvref_common.h" +//#include "av1/common/warped_motion.h" + +// Although we assign 32 bit integers, all the values are strictly under 14 +// bits. +static int div_mult[32] = { 0, 16384, 8192, 5461, 4096, 3276, 2730, 2340, + 2048, 1820, 1638, 1489, 1365, 1260, 1170, 1092, + 1024, 963, 910, 862, 819, 780, 744, 712, + 682, 655, 630, 606, 585, 564, 546, 528 }; + +// TODO(jingning): Consider the use of lookup table for (num / den) +// altogether. +static void get_mv_projection(MV *output, MV ref, int num, int den) { + den = AOMMIN(den, MAX_FRAME_DISTANCE); + num = num > 0 ? AOMMIN(num, MAX_FRAME_DISTANCE) + : AOMMAX(num, -MAX_FRAME_DISTANCE); + int mv_row = ROUND_POWER_OF_TWO_SIGNED(ref.row * num * div_mult[den], 14); + int mv_col = ROUND_POWER_OF_TWO_SIGNED(ref.col * num * div_mult[den], 14); + const int clamp_max = MV_UPP - 1; + const int clamp_min = MV_LOW + 1; + output->row = (int16_t)clamp(mv_row, clamp_min, clamp_max); + output->col = (int16_t)clamp(mv_col, clamp_min, clamp_max); +} + +#if 0 +void av1_copy_frame_mvs(const AV1_COMMON *const cm, MB_MODE_INFO *mi, + int mi_row, int mi_col, int x_mis, int y_mis) { + const int frame_mvs_stride = ROUND_POWER_OF_TWO(cm->mi_cols, 1); + MV_REF *frame_mvs = + cm->cur_frame.mvs + (mi_row >> 1) * frame_mvs_stride + (mi_col >> 1); + x_mis = ROUND_POWER_OF_TWO(x_mis, 1); + y_mis = ROUND_POWER_OF_TWO(y_mis, 1); + int w, h; + + for (h = 0; h < y_mis; h++) { + MV_REF *mv = frame_mvs; + for (w = 0; w < x_mis; w++) { + mv->ref_frame = NONE_FRAME; + mv->mv.as_int = 0; + + for (int idx = 0; idx < 2; ++idx) { + MV_REFERENCE_FRAME ref_frame = mi->ref_frame[idx]; + if (ref_frame > INTRA_FRAME) { + int8_t ref_idx = cm->ref_frame_side[ref_frame]; + if (ref_idx) continue; + if ((abs(mi->mv[idx].as_mv.row) > REFMVS_LIMIT) || + (abs(mi->mv[idx].as_mv.col) > REFMVS_LIMIT)) + continue; + mv->ref_frame = ref_frame; + mv->mv.as_int = mi->mv[idx].as_int; + } + } + mv++; + } + frame_mvs += frame_mvs_stride; + } +} +#endif + +static void add_ref_mv_candidate( + const MB_MODE_INFO *const candidate, const MV_REFERENCE_FRAME rf[2], + uint8_t *refmv_count, uint8_t *ref_match_count, uint8_t *newmv_count, + CANDIDATE_MV *ref_mv_stack, int_mv *gm_mv_candidates, + const WarpedMotionParams *gm_params, int col, int weight) { + if (!is_inter_block(candidate)) return; // for intrabc + int index = 0, ref; + assert(weight % 2 == 0); + + if (rf[1] == NONE_FRAME) { + // single reference frame + for (ref = 0; ref < 2; ++ref) { + if (candidate->ref_frame[ref] == rf[0]) { + int_mv this_refmv; + if (is_global_mv_block(candidate, gm_params[rf[0]].wmtype)) + this_refmv = gm_mv_candidates[0]; + else + this_refmv = get_sub_block_mv(candidate, ref, col); + + for (index = 0; index < *refmv_count; ++index) + if (ref_mv_stack[index].this_mv.as_int == this_refmv.as_int) break; + + if (index < *refmv_count) ref_mv_stack[index].weight += weight; + + // Add a new item to the list. + if (index == *refmv_count && *refmv_count < MAX_REF_MV_STACK_SIZE) { + ref_mv_stack[index].this_mv = this_refmv; + ref_mv_stack[index].weight = weight; + ++(*refmv_count); + } + if (have_newmv_in_inter_mode(candidate->mode)) ++*newmv_count; + ++*ref_match_count; + } + } + } else { + // compound reference frame + if (candidate->ref_frame[0] == rf[0] && candidate->ref_frame[1] == rf[1]) { + int_mv this_refmv[2]; + + for (ref = 0; ref < 2; ++ref) { + if (is_global_mv_block(candidate, gm_params[rf[ref]].wmtype)) + this_refmv[ref] = gm_mv_candidates[ref]; + else + this_refmv[ref] = get_sub_block_mv(candidate, ref, col); + } + + for (index = 0; index < *refmv_count; ++index) + if ((ref_mv_stack[index].this_mv.as_int == this_refmv[0].as_int) && + (ref_mv_stack[index].comp_mv.as_int == this_refmv[1].as_int)) + break; + + if (index < *refmv_count) ref_mv_stack[index].weight += weight; + + // Add a new item to the list. + if (index == *refmv_count && *refmv_count < MAX_REF_MV_STACK_SIZE) { + ref_mv_stack[index].this_mv = this_refmv[0]; + ref_mv_stack[index].comp_mv = this_refmv[1]; + ref_mv_stack[index].weight = weight; + ++(*refmv_count); + } + if (have_newmv_in_inter_mode(candidate->mode)) ++*newmv_count; + ++*ref_match_count; + } + } +} + +static void scan_row_mbmi(const AV1_COMMON *cm, const MACROBLOCKD *xd, + int mi_row, int mi_col, + const MV_REFERENCE_FRAME rf[2], int row_offset, + CANDIDATE_MV *ref_mv_stack, uint8_t *refmv_count, + uint8_t *ref_match_count, uint8_t *newmv_count, + int_mv *gm_mv_candidates, int max_row_offset, + int *processed_rows) { + int end_mi = AOMMIN(xd->n8_w, cm->mi_cols - mi_col); + end_mi = AOMMIN(end_mi, mi_size_wide[BLOCK_64X64]); + const int n8_w_8 = mi_size_wide[BLOCK_8X8]; + const int n8_w_16 = mi_size_wide[BLOCK_16X16]; + int i; + int col_offset = 0; + const int shift = 0; + // TODO(jingning): Revisit this part after cb4x4 is stable. + if (abs(row_offset) > 1) { + col_offset = 1; + if ((mi_col & 0x01) && xd->n8_w < n8_w_8) --col_offset; + } + const int use_step_16 = (xd->n8_w >= 16); + MB_MODE_INFO *const candidate_mi0 = xd->mi + row_offset * xd->mi_stride; + (void)mi_row; + + for (i = 0; i < end_mi;) { + const MB_MODE_INFO *const candidate = &candidate_mi0[col_offset + i]; + const int candidate_bsize = candidate->sb_type; + const int n8_w = mi_size_wide[candidate_bsize]; + int len = AOMMIN(xd->n8_w, n8_w); + if (use_step_16) + len = AOMMAX(n8_w_16, len); + else if (abs(row_offset) > 1) + len = AOMMAX(len, n8_w_8); + + int weight = 2; + if (xd->n8_w >= n8_w_8 && xd->n8_w <= n8_w) { + int inc = AOMMIN(-max_row_offset + row_offset + 1, + mi_size_high[candidate_bsize]); + // Obtain range used in weight calculation. + weight = AOMMAX(weight, (inc << shift)); + // Update processed rows. + *processed_rows = inc - row_offset - 1; + } + + add_ref_mv_candidate(candidate, rf, refmv_count, ref_match_count, + newmv_count, ref_mv_stack, gm_mv_candidates, + cm->global_motion, col_offset + i, len * weight); + + i += len; + } +} + +static void scan_col_mbmi(const AV1_COMMON *cm, const MACROBLOCKD *xd, + int mi_row, int mi_col, + const MV_REFERENCE_FRAME rf[2], int col_offset, + CANDIDATE_MV *ref_mv_stack, uint8_t *refmv_count, + uint8_t *ref_match_count, uint8_t *newmv_count, + int_mv *gm_mv_candidates, int max_col_offset, + int *processed_cols) { + int end_mi = AOMMIN(xd->n8_h, cm->mi_rows - mi_row); + end_mi = AOMMIN(end_mi, mi_size_high[BLOCK_64X64]); + const int n8_h_8 = mi_size_high[BLOCK_8X8]; + const int n8_h_16 = mi_size_high[BLOCK_16X16]; + int i; + int row_offset = 0; + const int shift = 0; + if (abs(col_offset) > 1) { + row_offset = 1; + if ((mi_row & 0x01) && xd->n8_h < n8_h_8) --row_offset; + } + const int use_step_16 = (xd->n8_h >= 16); + (void)mi_col; + + for (i = 0; i < end_mi;) { + const MB_MODE_INFO *const candidate = + &xd->mi[(row_offset + i) * xd->mi_stride + col_offset]; + const int candidate_bsize = candidate->sb_type; + const int n8_h = mi_size_high[candidate_bsize]; + int len = AOMMIN(xd->n8_h, n8_h); + if (use_step_16) + len = AOMMAX(n8_h_16, len); + else if (abs(col_offset) > 1) + len = AOMMAX(len, n8_h_8); + + int weight = 2; + if (xd->n8_h >= n8_h_8 && xd->n8_h <= n8_h) { + int inc = AOMMIN(-max_col_offset + col_offset + 1, + mi_size_wide[candidate_bsize]); + // Obtain range used in weight calculation. + weight = AOMMAX(weight, (inc << shift)); + // Update processed cols. + *processed_cols = inc - col_offset - 1; + } + + add_ref_mv_candidate(candidate, rf, refmv_count, ref_match_count, + newmv_count, ref_mv_stack, gm_mv_candidates, + cm->global_motion, col_offset, len * weight); + + i += len; + } +} + +static void scan_blk_mbmi(const AV1_COMMON *cm, const MACROBLOCKD *xd, + const int mi_row, const int mi_col, + const MV_REFERENCE_FRAME rf[2], int row_offset, + int col_offset, CANDIDATE_MV *ref_mv_stack, + uint8_t *ref_match_count, uint8_t *newmv_count, + int_mv *gm_mv_candidates, + uint8_t refmv_count[MODE_CTX_REF_FRAMES]) { + const TileInfo *const tile = &xd->tile; + POSITION mi_pos; + + mi_pos.row = row_offset; + mi_pos.col = col_offset; + + if (is_inside(tile, mi_col, mi_row, cm->mi_rows, &mi_pos)) { + const MB_MODE_INFO *const candidate = + &xd->mi[mi_pos.row * xd->mi_stride + mi_pos.col]; + const int len = mi_size_wide[BLOCK_8X8]; + + add_ref_mv_candidate(candidate, rf, refmv_count, ref_match_count, + newmv_count, ref_mv_stack, gm_mv_candidates, + cm->global_motion, mi_pos.col, 2 * len); + } // Analyze a single 8x8 block motion information. +} + +static int has_top_right(const AV1_COMMON *cm, const MACROBLOCKD *xd, + int mi_row, int mi_col, int bs) { + const int sb_mi_size = mi_size_wide[cm->seq_params.sb_size]; + const int mask_row = mi_row & (sb_mi_size - 1); + const int mask_col = mi_col & (sb_mi_size - 1); + + if (bs > mi_size_wide[BLOCK_64X64]) return 0; + + // In a split partition all apart from the bottom right has a top right + int has_tr = !((mask_row & bs) && (mask_col & bs)); + + // bs > 0 and bs is a power of 2 + assert(bs > 0 && !(bs & (bs - 1))); + + // For each 4x4 group of blocks, when the bottom right is decoded the blocks + // to the right have not been decoded therefore the bottom right does + // not have a top right + while (bs < sb_mi_size) { + if (mask_col & bs) { + if ((mask_col & (2 * bs)) && (mask_row & (2 * bs))) { + has_tr = 0; + break; + } + } else { + break; + } + bs <<= 1; + } + + // The left hand of two vertical rectangles always has a top right (as the + // block above will have been decoded) + if (xd->n8_w < xd->n8_h) + if (!xd->is_sec_rect) has_tr = 1; + + // The bottom of two horizontal rectangles never has a top right (as the block + // to the right won't have been decoded) + if (xd->n8_w > xd->n8_h) + if (xd->is_sec_rect) has_tr = 0; + + // The bottom left square of a Vertical A (in the old format) does + // not have a top right as it is decoded before the right hand + // rectangle of the partition + if (xd->cur_mi.partition == PARTITION_VERT_A) { + if (xd->n8_w == xd->n8_h) + if (mask_row & bs) has_tr = 0; + } + + return has_tr; +} + +static int check_sb_border(const int mi_row, const int mi_col, + const int row_offset, const int col_offset) { + const int sb_mi_size = mi_size_wide[BLOCK_64X64]; + const int row = mi_row & (sb_mi_size - 1); + const int col = mi_col & (sb_mi_size - 1); + + if (row + row_offset < 0 || row + row_offset >= sb_mi_size || + col + col_offset < 0 || col + col_offset >= sb_mi_size) + return 0; + + return 1; +} + +static int add_tpl_ref_mv(const AV1_COMMON *cm, const MACROBLOCKD *xd, + int mi_row, int mi_col, MV_REFERENCE_FRAME ref_frame, + int blk_row, int blk_col, int_mv *gm_mv_candidates, + uint8_t refmv_count[MODE_CTX_REF_FRAMES], + CANDIDATE_MV ref_mv_stacks[][MAX_REF_MV_STACK_SIZE], + int16_t *mode_context) { + POSITION mi_pos; + int idx; + const int weight_unit = 1; // mi_size_wide[BLOCK_8X8]; + + mi_pos.row = (mi_row & 0x01) ? blk_row : blk_row + 1; + mi_pos.col = (mi_col & 0x01) ? blk_col : blk_col + 1; + + if (!is_inside(&xd->tile, mi_col, mi_row, cm->mi_rows, &mi_pos)) return 0; + + const TPL_MV_REF *prev_frame_mvs = + cm->tpl_mvs + ((mi_row + mi_pos.row) >> 1) * (cm->mi_stride >> 1) + + ((mi_col + mi_pos.col) >> 1); + + MV_REFERENCE_FRAME rf[2]; + av1_set_ref_frame(rf, ref_frame); + + if (rf[1] == NONE_FRAME) { + int cur_frame_index = cm->cur_frame.cur_frame_offset; + int buf_idx_0 = cm->frame_refs[FWD_RF_OFFSET(rf[0])].idx; + int frame0_index = cm->buffer_pool.frame_bufs[buf_idx_0].cur_frame_offset; + int cur_offset_0 = get_relative_dist(cm, cur_frame_index, frame0_index); + CANDIDATE_MV *ref_mv_stack = ref_mv_stacks[rf[0]]; + + if (prev_frame_mvs->mfmv0.as_int != INVALID_MV) { + int_mv this_refmv; + + get_mv_projection(&this_refmv.as_mv, prev_frame_mvs->mfmv0.as_mv, + cur_offset_0, prev_frame_mvs->ref_frame_offset); + lower_mv_precision(&this_refmv.as_mv, cm->allow_high_precision_mv, + cm->cur_frame_force_integer_mv); + + if (blk_row == 0 && blk_col == 0) + if (abs(this_refmv.as_mv.row - gm_mv_candidates[0].as_mv.row) >= 16 || + abs(this_refmv.as_mv.col - gm_mv_candidates[0].as_mv.col) >= 16) + mode_context[ref_frame] |= (1 << GLOBALMV_OFFSET); + + for (idx = 0; idx < refmv_count[rf[0]]; ++idx) + if (this_refmv.as_int == ref_mv_stack[idx].this_mv.as_int) break; + + if (idx < refmv_count[rf[0]]) ref_mv_stack[idx].weight += 2 * weight_unit; + + if (idx == refmv_count[rf[0]] && + refmv_count[rf[0]] < MAX_REF_MV_STACK_SIZE) { + ref_mv_stack[idx].this_mv.as_int = this_refmv.as_int; + ref_mv_stack[idx].weight = 2 * weight_unit; + ++(refmv_count[rf[0]]); + } + + return 1; + } + } else { + // Process compound inter mode + int cur_frame_index = cm->cur_frame.cur_frame_offset; + int buf_idx_0 = cm->frame_refs[FWD_RF_OFFSET(rf[0])].idx; + int frame0_index = cm->buffer_pool.frame_bufs[buf_idx_0].cur_frame_offset; + + int cur_offset_0 = get_relative_dist(cm, cur_frame_index, frame0_index); + int buf_idx_1 = cm->frame_refs[FWD_RF_OFFSET(rf[1])].idx; + int frame1_index = cm->buffer_pool.frame_bufs[buf_idx_1].cur_frame_offset; + int cur_offset_1 = get_relative_dist(cm, cur_frame_index, frame1_index); + CANDIDATE_MV *ref_mv_stack = ref_mv_stacks[ref_frame]; + + if (prev_frame_mvs->mfmv0.as_int != INVALID_MV) { + int_mv this_refmv; + int_mv comp_refmv; + get_mv_projection(&this_refmv.as_mv, prev_frame_mvs->mfmv0.as_mv, + cur_offset_0, prev_frame_mvs->ref_frame_offset); + get_mv_projection(&comp_refmv.as_mv, prev_frame_mvs->mfmv0.as_mv, + cur_offset_1, prev_frame_mvs->ref_frame_offset); + + lower_mv_precision(&this_refmv.as_mv, cm->allow_high_precision_mv, + cm->cur_frame_force_integer_mv); + lower_mv_precision(&comp_refmv.as_mv, cm->allow_high_precision_mv, + cm->cur_frame_force_integer_mv); + + if (blk_row == 0 && blk_col == 0) + if (abs(this_refmv.as_mv.row - gm_mv_candidates[0].as_mv.row) >= 16 || + abs(this_refmv.as_mv.col - gm_mv_candidates[0].as_mv.col) >= 16 || + abs(comp_refmv.as_mv.row - gm_mv_candidates[1].as_mv.row) >= 16 || + abs(comp_refmv.as_mv.col - gm_mv_candidates[1].as_mv.col) >= 16) + mode_context[ref_frame] |= (1 << GLOBALMV_OFFSET); + + for (idx = 0; idx < refmv_count[ref_frame]; ++idx) + if (this_refmv.as_int == ref_mv_stack[idx].this_mv.as_int && + comp_refmv.as_int == ref_mv_stack[idx].comp_mv.as_int) + break; + + if (idx < refmv_count[ref_frame]) + ref_mv_stack[idx].weight += 2 * weight_unit; + + if (idx == refmv_count[ref_frame] && + refmv_count[ref_frame] < MAX_REF_MV_STACK_SIZE) { + ref_mv_stack[idx].this_mv.as_int = this_refmv.as_int; + ref_mv_stack[idx].comp_mv.as_int = comp_refmv.as_int; + ref_mv_stack[idx].weight = 2 * weight_unit; + ++(refmv_count[ref_frame]); + } + return 1; + } + } + return 0; +} + +static void setup_ref_mv_list( + const AV1_COMMON *cm, const MACROBLOCKD *xd, MV_REFERENCE_FRAME ref_frame, + uint8_t refmv_count[MODE_CTX_REF_FRAMES], + CANDIDATE_MV ref_mv_stack[][MAX_REF_MV_STACK_SIZE], + int_mv mv_ref_list[][MAX_MV_REF_CANDIDATES], int_mv *gm_mv_candidates, + int mi_row, int mi_col, int16_t *mode_context) { + const int bs = AOMMAX(xd->n8_w, xd->n8_h); + const int has_tr = has_top_right(cm, xd, mi_row, mi_col, bs); + MV_REFERENCE_FRAME rf[2]; + + const TileInfo *const tile = &xd->tile; + int max_row_offset = 0, max_col_offset = 0; + const int row_adj = (xd->n8_h < mi_size_high[BLOCK_8X8]) && (mi_row & 0x01); + const int col_adj = (xd->n8_w < mi_size_wide[BLOCK_8X8]) && (mi_col & 0x01); + int processed_rows = 0; + int processed_cols = 0; + + av1_set_ref_frame(rf, ref_frame); + mode_context[ref_frame] = 0; + refmv_count[ref_frame] = 0; + + // Find valid maximum row/col offset. + if (xd->up_available) { + max_row_offset = -(MVREF_ROW_COLS << 1) + row_adj; + + if (xd->n8_h < mi_size_high[BLOCK_8X8]) + max_row_offset = -(2 << 1) + row_adj; + + max_row_offset = + find_valid_row_offset(tile, mi_row, cm->mi_rows, max_row_offset); + } + + if (xd->left_available) { + max_col_offset = -(MVREF_ROW_COLS << 1) + col_adj; + + if (xd->n8_w < mi_size_wide[BLOCK_8X8]) + max_col_offset = -(2 << 1) + col_adj; + + max_col_offset = find_valid_col_offset(tile, mi_col, max_col_offset); + } + + uint8_t col_match_count = 0; + uint8_t row_match_count = 0; + uint8_t newmv_count = 0; + + // Scan the first above row mode info. row_offset = -1; + if (abs(max_row_offset) >= 1) + scan_row_mbmi(cm, xd, mi_row, mi_col, rf, -1, ref_mv_stack[ref_frame], + &refmv_count[ref_frame], &row_match_count, &newmv_count, + gm_mv_candidates, max_row_offset, &processed_rows); + // Scan the first left column mode info. col_offset = -1; + if (abs(max_col_offset) >= 1) + scan_col_mbmi(cm, xd, mi_row, mi_col, rf, -1, ref_mv_stack[ref_frame], + &refmv_count[ref_frame], &col_match_count, &newmv_count, + gm_mv_candidates, max_col_offset, &processed_cols); + // Check top-right boundary + if (has_tr) + scan_blk_mbmi(cm, xd, mi_row, mi_col, rf, -1, xd->n8_w, + ref_mv_stack[ref_frame], &row_match_count, &newmv_count, + gm_mv_candidates, &refmv_count[ref_frame]); + + uint8_t nearest_match = (row_match_count > 0) + (col_match_count > 0); + uint8_t nearest_refmv_count = refmv_count[ref_frame]; + + // TODO(yunqing): for comp_search, do it for all 3 cases. + for (int idx = 0; idx < nearest_refmv_count; ++idx) + ref_mv_stack[ref_frame][idx].weight += REF_CAT_LEVEL; + + if (cm->allow_ref_frame_mvs) { + int is_available = 0; + const int voffset = AOMMAX(mi_size_high[BLOCK_8X8], xd->n8_h); + const int hoffset = AOMMAX(mi_size_wide[BLOCK_8X8], xd->n8_w); + const int blk_row_end = AOMMIN(xd->n8_h, mi_size_high[BLOCK_64X64]); + const int blk_col_end = AOMMIN(xd->n8_w, mi_size_wide[BLOCK_64X64]); + + const int tpl_sample_pos[3][2] = { + { voffset, -2 }, + { voffset, hoffset }, + { voffset - 2, hoffset }, + }; + const int allow_extension = (xd->n8_h >= mi_size_high[BLOCK_8X8]) && + (xd->n8_h < mi_size_high[BLOCK_64X64]) && + (xd->n8_w >= mi_size_wide[BLOCK_8X8]) && + (xd->n8_w < mi_size_wide[BLOCK_64X64]); + + int step_h = (xd->n8_h >= mi_size_high[BLOCK_64X64]) + ? mi_size_high[BLOCK_16X16] + : mi_size_high[BLOCK_8X8]; + int step_w = (xd->n8_w >= mi_size_wide[BLOCK_64X64]) + ? mi_size_wide[BLOCK_16X16] + : mi_size_wide[BLOCK_8X8]; + + for (int blk_row = 0; blk_row < blk_row_end; blk_row += step_h) { + for (int blk_col = 0; blk_col < blk_col_end; blk_col += step_w) { + int ret = add_tpl_ref_mv(cm, xd, mi_row, mi_col, ref_frame, blk_row, + blk_col, gm_mv_candidates, refmv_count, + ref_mv_stack, mode_context); + if (blk_row == 0 && blk_col == 0) is_available = ret; + } + } + + if (is_available == 0) mode_context[ref_frame] |= (1 << GLOBALMV_OFFSET); + + for (int i = 0; i < 3 && allow_extension; ++i) { + const int blk_row = tpl_sample_pos[i][0]; + const int blk_col = tpl_sample_pos[i][1]; + + if (!check_sb_border(mi_row, mi_col, blk_row, blk_col)) continue; + add_tpl_ref_mv(cm, xd, mi_row, mi_col, ref_frame, blk_row, blk_col, + gm_mv_candidates, refmv_count, ref_mv_stack, mode_context); + } + } + + uint8_t dummy_newmv_count = 0; + + // Scan the second outer area. + scan_blk_mbmi(cm, xd, mi_row, mi_col, rf, -1, -1, ref_mv_stack[ref_frame], + &row_match_count, &dummy_newmv_count, gm_mv_candidates, + &refmv_count[ref_frame]); + + for (int idx = 2; idx <= MVREF_ROW_COLS; ++idx) { + const int row_offset = -(idx << 1) + 1 + row_adj; + const int col_offset = -(idx << 1) + 1 + col_adj; + + if (abs(row_offset) <= abs(max_row_offset) && + abs(row_offset) > processed_rows) + scan_row_mbmi(cm, xd, mi_row, mi_col, rf, row_offset, + ref_mv_stack[ref_frame], &refmv_count[ref_frame], + &row_match_count, &dummy_newmv_count, gm_mv_candidates, + max_row_offset, &processed_rows); + + if (abs(col_offset) <= abs(max_col_offset) && + abs(col_offset) > processed_cols) + scan_col_mbmi(cm, xd, mi_row, mi_col, rf, col_offset, + ref_mv_stack[ref_frame], &refmv_count[ref_frame], + &col_match_count, &dummy_newmv_count, gm_mv_candidates, + max_col_offset, &processed_cols); + } + + uint8_t ref_match_count = (row_match_count > 0) + (col_match_count > 0); + + switch (nearest_match) { + case 0: + mode_context[ref_frame] |= 0; + if (ref_match_count >= 1) mode_context[ref_frame] |= 1; + if (ref_match_count == 1) + mode_context[ref_frame] |= (1 << REFMV_OFFSET); + else if (ref_match_count >= 2) + mode_context[ref_frame] |= (2 << REFMV_OFFSET); + break; + case 1: + mode_context[ref_frame] |= (newmv_count > 0) ? 2 : 3; + if (ref_match_count == 1) + mode_context[ref_frame] |= (3 << REFMV_OFFSET); + else if (ref_match_count >= 2) + mode_context[ref_frame] |= (4 << REFMV_OFFSET); + break; + case 2: + default: + if (newmv_count >= 1) + mode_context[ref_frame] |= 4; + else + mode_context[ref_frame] |= 5; + + mode_context[ref_frame] |= (5 << REFMV_OFFSET); + break; + } + + // Rank the likelihood and assign nearest and near mvs. + int len = nearest_refmv_count; + while (len > 0) { + int nr_len = 0; + for (int idx = 1; idx < len; ++idx) { + if (ref_mv_stack[ref_frame][idx - 1].weight < + ref_mv_stack[ref_frame][idx].weight) { + CANDIDATE_MV tmp_mv = ref_mv_stack[ref_frame][idx - 1]; + ref_mv_stack[ref_frame][idx - 1] = ref_mv_stack[ref_frame][idx]; + ref_mv_stack[ref_frame][idx] = tmp_mv; + nr_len = idx; + } + } + len = nr_len; + } + + len = refmv_count[ref_frame]; + while (len > nearest_refmv_count) { + int nr_len = nearest_refmv_count; + for (int idx = nearest_refmv_count + 1; idx < len; ++idx) { + if (ref_mv_stack[ref_frame][idx - 1].weight < + ref_mv_stack[ref_frame][idx].weight) { + CANDIDATE_MV tmp_mv = ref_mv_stack[ref_frame][idx - 1]; + ref_mv_stack[ref_frame][idx - 1] = ref_mv_stack[ref_frame][idx]; + ref_mv_stack[ref_frame][idx] = tmp_mv; + nr_len = idx; + } + } + len = nr_len; + } + + if (rf[1] > NONE_FRAME) { + // TODO(jingning, yunqing): Refactor and consolidate the compound and + // single reference frame modes. Reduce unnecessary redundancy. + if (refmv_count[ref_frame] < MAX_MV_REF_CANDIDATES) { + int_mv ref_id[2][2], ref_diff[2][2]; + int ref_id_count[2] = { 0 }, ref_diff_count[2] = { 0 }; + + int mi_width = AOMMIN(mi_size_wide[BLOCK_64X64], xd->n8_w); + mi_width = AOMMIN(mi_width, cm->mi_cols - mi_col); + int mi_height = AOMMIN(mi_size_high[BLOCK_64X64], xd->n8_h); + mi_height = AOMMIN(mi_height, cm->mi_rows - mi_row); + int mi_size = AOMMIN(mi_width, mi_height); + + for (int idx = 0; abs(max_row_offset) >= 1 && idx < mi_size;) { + const MB_MODE_INFO *const candidate = &xd->mi[-xd->mi_stride + idx]; + const int candidate_bsize = candidate->sb_type; + + for (int rf_idx = 0; rf_idx < 2; ++rf_idx) { + MV_REFERENCE_FRAME can_rf = candidate->ref_frame[rf_idx]; + + for (int cmp_idx = 0; cmp_idx < 2; ++cmp_idx) { + if (can_rf == rf[cmp_idx] && ref_id_count[cmp_idx] < 2) { + ref_id[cmp_idx][ref_id_count[cmp_idx]] = candidate->mv[rf_idx]; + ++ref_id_count[cmp_idx]; + } else if (can_rf > INTRA_FRAME && ref_diff_count[cmp_idx] < 2) { + int_mv this_mv = candidate->mv[rf_idx]; + if (cm->ref_frame_sign_bias[can_rf] != + cm->ref_frame_sign_bias[rf[cmp_idx]]) { + this_mv.as_mv.row = -this_mv.as_mv.row; + this_mv.as_mv.col = -this_mv.as_mv.col; + } + ref_diff[cmp_idx][ref_diff_count[cmp_idx]] = this_mv; + ++ref_diff_count[cmp_idx]; + } + } + } + idx += mi_size_wide[candidate_bsize]; + } + + for (int idx = 0; abs(max_col_offset) >= 1 && idx < mi_size;) { + const MB_MODE_INFO *const candidate = &xd->mi[idx * xd->mi_stride - 1]; + const int candidate_bsize = candidate->sb_type; + + for (int rf_idx = 0; rf_idx < 2; ++rf_idx) { + MV_REFERENCE_FRAME can_rf = candidate->ref_frame[rf_idx]; + + for (int cmp_idx = 0; cmp_idx < 2; ++cmp_idx) { + if (can_rf == rf[cmp_idx] && ref_id_count[cmp_idx] < 2) { + ref_id[cmp_idx][ref_id_count[cmp_idx]] = candidate->mv[rf_idx]; + ++ref_id_count[cmp_idx]; + } else if (can_rf > INTRA_FRAME && ref_diff_count[cmp_idx] < 2) { + int_mv this_mv = candidate->mv[rf_idx]; + if (cm->ref_frame_sign_bias[can_rf] != + cm->ref_frame_sign_bias[rf[cmp_idx]]) { + this_mv.as_mv.row = -this_mv.as_mv.row; + this_mv.as_mv.col = -this_mv.as_mv.col; + } + ref_diff[cmp_idx][ref_diff_count[cmp_idx]] = this_mv; + ++ref_diff_count[cmp_idx]; + } + } + } + idx += mi_size_high[candidate_bsize]; + } + + // Build up the compound mv predictor + int_mv comp_list[3][2]; + + for (int idx = 0; idx < 2; ++idx) { + int comp_idx = 0; + for (int list_idx = 0; list_idx < ref_id_count[idx] && comp_idx < 2; + ++list_idx, ++comp_idx) + comp_list[comp_idx][idx] = ref_id[idx][list_idx]; + for (int list_idx = 0; list_idx < ref_diff_count[idx] && comp_idx < 2; + ++list_idx, ++comp_idx) + comp_list[comp_idx][idx] = ref_diff[idx][list_idx]; + for (; comp_idx < 3; ++comp_idx) + comp_list[comp_idx][idx] = gm_mv_candidates[idx]; + } + + if (refmv_count[ref_frame]) { + assert(refmv_count[ref_frame] == 1); + if (comp_list[0][0].as_int == + ref_mv_stack[ref_frame][0].this_mv.as_int && + comp_list[0][1].as_int == + ref_mv_stack[ref_frame][0].comp_mv.as_int) { + ref_mv_stack[ref_frame][refmv_count[ref_frame]].this_mv = + comp_list[1][0]; + ref_mv_stack[ref_frame][refmv_count[ref_frame]].comp_mv = + comp_list[1][1]; + } else { + ref_mv_stack[ref_frame][refmv_count[ref_frame]].this_mv = + comp_list[0][0]; + ref_mv_stack[ref_frame][refmv_count[ref_frame]].comp_mv = + comp_list[0][1]; + } + ref_mv_stack[ref_frame][refmv_count[ref_frame]].weight = 2; + ++refmv_count[ref_frame]; + } else { + for (int idx = 0; idx < MAX_MV_REF_CANDIDATES; ++idx) { + ref_mv_stack[ref_frame][refmv_count[ref_frame]].this_mv = + comp_list[idx][0]; + ref_mv_stack[ref_frame][refmv_count[ref_frame]].comp_mv = + comp_list[idx][1]; + ref_mv_stack[ref_frame][refmv_count[ref_frame]].weight = 2; + ++refmv_count[ref_frame]; + } + } + } + + assert(refmv_count[ref_frame] >= 2); + + for (int idx = 0; idx < refmv_count[ref_frame]; ++idx) { + clamp_mv_ref(&ref_mv_stack[ref_frame][idx].this_mv.as_mv, + xd->n8_w << MI_SIZE_LOG2, xd->n8_h << MI_SIZE_LOG2, xd); + clamp_mv_ref(&ref_mv_stack[ref_frame][idx].comp_mv.as_mv, + xd->n8_w << MI_SIZE_LOG2, xd->n8_h << MI_SIZE_LOG2, xd); + } + } else { + // Handle single reference frame extension + int mi_width = AOMMIN(mi_size_wide[BLOCK_64X64], xd->n8_w); + mi_width = AOMMIN(mi_width, cm->mi_cols - mi_col); + int mi_height = AOMMIN(mi_size_high[BLOCK_64X64], xd->n8_h); + mi_height = AOMMIN(mi_height, cm->mi_rows - mi_row); + int mi_size = AOMMIN(mi_width, mi_height); + + for (int idx = 0; abs(max_row_offset) >= 1 && idx < mi_size && + refmv_count[ref_frame] < MAX_MV_REF_CANDIDATES;) { + const MB_MODE_INFO *const candidate = &xd->mi[-xd->mi_stride + idx]; + const int candidate_bsize = candidate->sb_type; + + // TODO(jingning): Refactor the following code. + for (int rf_idx = 0; rf_idx < 2; ++rf_idx) { + if (candidate->ref_frame[rf_idx] > INTRA_FRAME) { + int_mv this_mv = candidate->mv[rf_idx]; + if (cm->ref_frame_sign_bias[candidate->ref_frame[rf_idx]] != + cm->ref_frame_sign_bias[ref_frame]) { + this_mv.as_mv.row = -this_mv.as_mv.row; + this_mv.as_mv.col = -this_mv.as_mv.col; + } + int stack_idx; + for (stack_idx = 0; stack_idx < refmv_count[ref_frame]; ++stack_idx) { + int_mv stack_mv = ref_mv_stack[ref_frame][stack_idx].this_mv; + if (this_mv.as_int == stack_mv.as_int) break; + } + + if (stack_idx == refmv_count[ref_frame]) { + ref_mv_stack[ref_frame][stack_idx].this_mv = this_mv; + + // TODO(jingning): Set an arbitrary small number here. The weight + // doesn't matter as long as it is properly initialized. + ref_mv_stack[ref_frame][stack_idx].weight = 2; + ++refmv_count[ref_frame]; + } + } + } + idx += mi_size_wide[candidate_bsize]; + } + + for (int idx = 0; abs(max_col_offset) >= 1 && idx < mi_size && + refmv_count[ref_frame] < MAX_MV_REF_CANDIDATES;) { + const MB_MODE_INFO *const candidate = &xd->mi[idx * xd->mi_stride - 1]; + const int candidate_bsize = candidate->sb_type; + + // TODO(jingning): Refactor the following code. + for (int rf_idx = 0; rf_idx < 2; ++rf_idx) { + if (candidate->ref_frame[rf_idx] > INTRA_FRAME) { + int_mv this_mv = candidate->mv[rf_idx]; + if (cm->ref_frame_sign_bias[candidate->ref_frame[rf_idx]] != + cm->ref_frame_sign_bias[ref_frame]) { + this_mv.as_mv.row = -this_mv.as_mv.row; + this_mv.as_mv.col = -this_mv.as_mv.col; + } + int stack_idx; + for (stack_idx = 0; stack_idx < refmv_count[ref_frame]; ++stack_idx) { + int_mv stack_mv = ref_mv_stack[ref_frame][stack_idx].this_mv; + if (this_mv.as_int == stack_mv.as_int) break; + } + + if (stack_idx == refmv_count[ref_frame]) { + ref_mv_stack[ref_frame][stack_idx].this_mv = this_mv; + + // TODO(jingning): Set an arbitrary small number here. The weight + // doesn't matter as long as it is properly initialized. + ref_mv_stack[ref_frame][stack_idx].weight = 2; + ++refmv_count[ref_frame]; + } + } + } + idx += mi_size_high[candidate_bsize]; + } + + for (int idx = 0; idx < refmv_count[ref_frame]; ++idx) { + clamp_mv_ref(&ref_mv_stack[ref_frame][idx].this_mv.as_mv, + xd->n8_w << MI_SIZE_LOG2, xd->n8_h << MI_SIZE_LOG2, xd); + } + + if (mv_ref_list != NULL) { + for (int idx = refmv_count[ref_frame]; idx < MAX_MV_REF_CANDIDATES; ++idx) + mv_ref_list[rf[0]][idx].as_int = gm_mv_candidates[0].as_int; + + for (int idx = 0; + idx < AOMMIN(MAX_MV_REF_CANDIDATES, refmv_count[ref_frame]); ++idx) { + mv_ref_list[rf[0]][idx].as_int = + ref_mv_stack[ref_frame][idx].this_mv.as_int; + } + } + } +} + +void av1_find_mv_refs(const AV1_COMMON *cm, const MACROBLOCKD *xd, + MB_MODE_INFO *mi, MV_REFERENCE_FRAME ref_frame, + uint8_t ref_mv_count[MODE_CTX_REF_FRAMES], + CANDIDATE_MV ref_mv_stack[][MAX_REF_MV_STACK_SIZE], + int_mv mv_ref_list[][MAX_MV_REF_CANDIDATES], + int_mv *global_mvs, int mi_row, int mi_col, + int16_t *mode_context) { + int_mv zeromv[2]; + BLOCK_SIZE bsize = mi->sb_type; + MV_REFERENCE_FRAME rf[2]; + av1_set_ref_frame(rf, ref_frame); + + if (ref_frame < REF_FRAMES) { + if (ref_frame != INTRA_FRAME) { + global_mvs[ref_frame] = gm_get_motion_vector( + &cm->global_motion[ref_frame], cm->allow_high_precision_mv, bsize, + mi_col, mi_row, cm->cur_frame_force_integer_mv); + } else { + global_mvs[ref_frame].as_int = INVALID_MV; + } + } + + if (ref_frame != INTRA_FRAME) { + zeromv[0].as_int = + gm_get_motion_vector(&cm->global_motion[rf[0]], + cm->allow_high_precision_mv, bsize, mi_col, mi_row, + cm->cur_frame_force_integer_mv) + .as_int; + zeromv[1].as_int = + (rf[1] != NONE_FRAME) + ? gm_get_motion_vector(&cm->global_motion[rf[1]], + cm->allow_high_precision_mv, bsize, mi_col, + mi_row, cm->cur_frame_force_integer_mv) + .as_int + : 0; + } else { + zeromv[0].as_int = zeromv[1].as_int = 0; + } + + setup_ref_mv_list(cm, xd, ref_frame, ref_mv_count, ref_mv_stack, mv_ref_list, + zeromv, mi_row, mi_col, mode_context); +} + +void av1_find_best_ref_mvs(int allow_hp, int_mv *mvlist, int_mv *nearest_mv, + int_mv *near_mv, int is_integer) { + int i; + // Make sure all the candidates are properly clamped etc + for (i = 0; i < MAX_MV_REF_CANDIDATES; ++i) { + lower_mv_precision(&mvlist[i].as_mv, allow_hp, is_integer); + } + *nearest_mv = mvlist[0]; + *near_mv = mvlist[1]; +} + +void av1_setup_frame_buf_refs(AV1_COMMON *cm) { + cm->cur_frame.cur_frame_offset = cm->frame_offset; + + MV_REFERENCE_FRAME ref_frame; + for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) { + const int buf_idx = cm->frame_refs[ref_frame - LAST_FRAME].idx; + if (buf_idx >= 0) + cm->cur_frame.ref_frame_offset[ref_frame - LAST_FRAME] = + cm->buffer_pool.frame_bufs[buf_idx].cur_frame_offset; + } +} + +#if 0 +void av1_setup_frame_sign_bias(AV1_COMMON *cm) { + MV_REFERENCE_FRAME ref_frame; + for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) { + const int buf_idx = cm->frame_refs[ref_frame - LAST_FRAME].idx; + if (cm->seq_params.enable_order_hint && buf_idx != INVALID_IDX) { + const int ref_frame_offset = + cm->buffer_pool->frame_bufs[buf_idx].cur_frame_offset; + cm->ref_frame_sign_bias[ref_frame] = + (get_relative_dist(cm, ref_frame_offset, (int)cm->frame_offset) <= 0) + ? 0 + : 1; + } else { + cm->ref_frame_sign_bias[ref_frame] = 0; + } + } +} +#endif + +#define MAX_OFFSET_WIDTH 64 +#define MAX_OFFSET_HEIGHT 0 + +static int get_block_position(AV1_COMMON *cm, int *mi_r, int *mi_c, int blk_row, + int blk_col, MV mv, int sign_bias) { + const int base_blk_row = (blk_row >> 3) << 3; + const int base_blk_col = (blk_col >> 3) << 3; + + const int row_offset = (mv.row >= 0) ? (mv.row >> (4 + MI_SIZE_LOG2)) + : -((-mv.row) >> (4 + MI_SIZE_LOG2)); + + const int col_offset = (mv.col >= 0) ? (mv.col >> (4 + MI_SIZE_LOG2)) + : -((-mv.col) >> (4 + MI_SIZE_LOG2)); + + int row = (sign_bias == 1) ? blk_row - row_offset : blk_row + row_offset; + int col = (sign_bias == 1) ? blk_col - col_offset : blk_col + col_offset; + + if (row < 0 || row >= (cm->mi_rows >> 1) || col < 0 || + col >= (cm->mi_cols >> 1)) + return 0; + + if (row < base_blk_row - (MAX_OFFSET_HEIGHT >> 3) || + row >= base_blk_row + 8 + (MAX_OFFSET_HEIGHT >> 3) || + col < base_blk_col - (MAX_OFFSET_WIDTH >> 3) || + col >= base_blk_col + 8 + (MAX_OFFSET_WIDTH >> 3)) + return 0; + + *mi_r = row; + *mi_c = col; + + return 1; +} + +static int motion_field_projection(AV1_COMMON *cm, MV_REFERENCE_FRAME ref_frame, + int dir, + const int from_x4, const int to_x4, + const int from_y4, const int to_y4) { + TPL_MV_REF *tpl_mvs_base = cm->tpl_mvs; + int ref_offset[TOTAL_REFS_PER_FRAME] = { 0 }; + int ref_sign[TOTAL_REFS_PER_FRAME] = { 0 }; + + (void)dir; + + int ref_frame_idx = cm->frame_refs[FWD_RF_OFFSET(ref_frame)].idx; + if (ref_frame_idx < 0) return 0; + + if (cm->buffer_pool.frame_bufs[ref_frame_idx].intra_only) return 0; + + if (cm->buffer_pool.frame_bufs[ref_frame_idx].mi_rows != cm->mi_rows || + cm->buffer_pool.frame_bufs[ref_frame_idx].mi_cols != cm->mi_cols) + return 0; + + int ref_frame_index = + cm->buffer_pool.frame_bufs[ref_frame_idx].cur_frame_offset; + unsigned int *ref_rf_idx = + &cm->buffer_pool.frame_bufs[ref_frame_idx].ref_frame_offset[0]; + int cur_frame_index = cm->cur_frame.cur_frame_offset; + int ref_to_cur = get_relative_dist(cm, ref_frame_index, cur_frame_index); + + for (MV_REFERENCE_FRAME rf = LAST_FRAME; rf <= INTER_REFS_PER_FRAME; ++rf) { + ref_offset[rf] = + get_relative_dist(cm, ref_frame_index, ref_rf_idx[rf - LAST_FRAME]); + // note the inverted sign + ref_sign[rf] = + get_relative_dist(cm, ref_rf_idx[rf - LAST_FRAME], ref_frame_index) < 0; + } + + if (dir == 2) ref_to_cur = -ref_to_cur; + + MV_REF *mv_ref_base = cm->buffer_pool.frame_bufs[ref_frame_idx].mvs; + const ptrdiff_t mv_stride = + cm->buffer_pool.frame_bufs[ref_frame_idx].mv_stride; + const int mvs_rows = (cm->mi_rows + 1) >> 1; + const int mvs_cols = (cm->mi_cols + 1) >> 1; + + assert(from_y4 >= 0); + const int row_start8 = from_y4 >> 1; + const int row_end8 = imin(to_y4 >> 1, mvs_rows); + const int col_start8 = imax((from_x4 - (MAX_OFFSET_WIDTH >> 2)) >> 1, 0); + const int col_end8 = imin((to_x4 + (MAX_OFFSET_WIDTH >> 2)) >> 1, mvs_cols); + for (int blk_row = row_start8; blk_row < row_end8; ++blk_row) { + for (int blk_col = col_start8; blk_col < col_end8; ++blk_col) { + MV_REF *mv_ref = &mv_ref_base[((blk_row << 1) + 1) * mv_stride + + (blk_col << 1) + 1]; + int diridx; + const int ref0 = mv_ref->ref_frame[0], ref1 = mv_ref->ref_frame[1]; + if (ref1 > 0 && ref_sign[ref1] && + abs(mv_ref->mv[1].as_mv.row) < (1 << 12) && + abs(mv_ref->mv[1].as_mv.col) < (1 << 12)) + { + diridx = 1; + } else if (ref0 > 0 && ref_sign[ref0] && + abs(mv_ref->mv[0].as_mv.row) < (1 << 12) && + abs(mv_ref->mv[0].as_mv.col) < (1 << 12)) + { + diridx = 0; + } else { + continue; + } + MV fwd_mv = mv_ref->mv[diridx].as_mv; + + if (mv_ref->ref_frame[diridx] > INTRA_FRAME) { + int_mv this_mv; + int mi_r, mi_c; + const int ref_frame_offset = ref_offset[mv_ref->ref_frame[diridx]]; + + int pos_valid = abs(ref_frame_offset) <= MAX_FRAME_DISTANCE && + ref_frame_offset > 0 && + abs(ref_to_cur) <= MAX_FRAME_DISTANCE; + + if (pos_valid) { + get_mv_projection(&this_mv.as_mv, fwd_mv, ref_to_cur, + ref_frame_offset); + pos_valid = get_block_position(cm, &mi_r, &mi_c, blk_row, blk_col, + this_mv.as_mv, dir >> 1); + } + + if (pos_valid && mi_c >= (from_x4 >> 1) && mi_c < (to_x4 >> 1)) { + int mi_offset = mi_r * (cm->mi_stride >> 1) + mi_c; + + tpl_mvs_base[mi_offset].mfmv0.as_mv.row = fwd_mv.row; + tpl_mvs_base[mi_offset].mfmv0.as_mv.col = fwd_mv.col; + tpl_mvs_base[mi_offset].ref_frame_offset = ref_frame_offset; + } + } + } + } + + return 1; +} + +#if 0 +void av1_setup_motion_field(AV1_COMMON *cm) { + memset(cm->ref_frame_side, 0, sizeof(cm->ref_frame_side)); + if (!cm->seq_params.enable_order_hint) return; + + TPL_MV_REF *tpl_mvs_base = cm->tpl_mvs; + int size = ((cm->mi_rows + MAX_MIB_SIZE) >> 1) * (cm->mi_stride >> 1); + for (int idx = 0; idx < size; ++idx) { + tpl_mvs_base[idx].mfmv0.as_int = INVALID_MV; + tpl_mvs_base[idx].ref_frame_offset = 0; + } + + const int cur_order_hint = cm->cur_frame.cur_frame_offset; + RefCntBuffer *const frame_bufs = cm->buffer_pool->frame_bufs; + + int ref_buf_idx[INTER_REFS_PER_FRAME]; + int ref_order_hint[INTER_REFS_PER_FRAME]; + + for (int ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ref_frame++) { + const int ref_idx = ref_frame - LAST_FRAME; + const int buf_idx = cm->frame_refs[ref_idx].idx; + int order_hint = 0; + + if (buf_idx >= 0) order_hint = frame_bufs[buf_idx].cur_frame_offset; + + ref_buf_idx[ref_idx] = buf_idx; + ref_order_hint[ref_idx] = order_hint; + + if (get_relative_dist(cm, order_hint, cur_order_hint) > 0) + cm->ref_frame_side[ref_frame] = 1; + else if (order_hint == cur_order_hint) + cm->ref_frame_side[ref_frame] = -1; + } + + int ref_stamp = MFMV_STACK_SIZE - 1; + + if (ref_buf_idx[LAST_FRAME - LAST_FRAME] >= 0) { + const int alt_of_lst_order_hint = + frame_bufs[ref_buf_idx[LAST_FRAME - LAST_FRAME]] + .ref_frame_offset[ALTREF_FRAME - LAST_FRAME]; + + const int is_lst_overlay = + (alt_of_lst_order_hint == ref_order_hint[GOLDEN_FRAME - LAST_FRAME]); + if (!is_lst_overlay) motion_field_projection(cm, LAST_FRAME, 2); + --ref_stamp; + } + + if (get_relative_dist(cm, ref_order_hint[BWDREF_FRAME - LAST_FRAME], + cur_order_hint) > 0) { + if (motion_field_projection(cm, BWDREF_FRAME, 0)) --ref_stamp; + } + + if (get_relative_dist(cm, ref_order_hint[ALTREF2_FRAME - LAST_FRAME], + cur_order_hint) > 0) { + if (motion_field_projection(cm, ALTREF2_FRAME, 0)) --ref_stamp; + } + + if (get_relative_dist(cm, ref_order_hint[ALTREF_FRAME - LAST_FRAME], + cur_order_hint) > 0 && + ref_stamp >= 0) + if (motion_field_projection(cm, ALTREF_FRAME, 0)) --ref_stamp; + + if (ref_stamp >= 0 && ref_buf_idx[LAST2_FRAME - LAST_FRAME] >= 0) + if (motion_field_projection(cm, LAST2_FRAME, 2)) --ref_stamp; +} +#endif + +void av1_setup_motion_field(AV1_COMMON *cm) { + if (!cm->seq_params.enable_order_hint) return; + + TPL_MV_REF *tpl_mvs_base = cm->tpl_mvs; + int size = (((cm->mi_rows + 31) & ~31) >> 1) * (cm->mi_stride >> 1); + for (int idx = 0; idx < size; ++idx) { + tpl_mvs_base[idx].mfmv0.as_int = INVALID_MV; + tpl_mvs_base[idx].ref_frame_offset = 0; + } + + memset(cm->ref_frame_side, 0, sizeof(cm->ref_frame_side)); + RefCntBuffer *const frame_bufs = cm->buffer_pool.frame_bufs; + + const int cur_order_hint = cm->cur_frame.cur_frame_offset; + int *const ref_buf_idx = cm->ref_buf_idx; + int *const ref_order_hint = cm->ref_order_hint; + + for (int ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ref_frame++) { + const int ref_idx = ref_frame - LAST_FRAME; + const int buf_idx = cm->frame_refs[ref_idx].idx; + int order_hint = 0; + + if (buf_idx >= 0) order_hint = frame_bufs[buf_idx].cur_frame_offset; + + ref_buf_idx[ref_idx] = buf_idx; + ref_order_hint[ref_idx] = order_hint; + + if (get_relative_dist(cm, order_hint, cur_order_hint) > 0) + cm->ref_frame_side[ref_frame] = 1; + else if (order_hint == cur_order_hint) + cm->ref_frame_side[ref_frame] = -1; + } +} + +void av1_fill_motion_field(AV1_COMMON *cm, + const int tile_col_start4, const int tile_col_end4, + const int row_start4, int row_end4) +{ + RefCntBuffer *const frame_bufs = cm->buffer_pool.frame_bufs; + const int cur_order_hint = cm->cur_frame.cur_frame_offset; + int *const ref_buf_idx = cm->ref_buf_idx; + int *const ref_order_hint = cm->ref_order_hint; + + int ref_stamp = MFMV_STACK_SIZE - 1; + + if (ref_buf_idx[LAST_FRAME - LAST_FRAME] >= 0) { + const int alt_of_lst_order_hint = + frame_bufs[ref_buf_idx[LAST_FRAME - LAST_FRAME]] + .ref_frame_offset[ALTREF_FRAME - LAST_FRAME]; + + const int is_lst_overlay = + (alt_of_lst_order_hint == ref_order_hint[GOLDEN_FRAME - LAST_FRAME]); + if (!is_lst_overlay) motion_field_projection(cm, LAST_FRAME, 2, + tile_col_start4, tile_col_end4, + row_start4, row_end4); + --ref_stamp; + } + + if (get_relative_dist(cm, ref_order_hint[BWDREF_FRAME - LAST_FRAME], + cur_order_hint) > 0) { + if (motion_field_projection(cm, BWDREF_FRAME, 0, + tile_col_start4, tile_col_end4, + row_start4, row_end4)) --ref_stamp; + } + + if (get_relative_dist(cm, ref_order_hint[ALTREF2_FRAME - LAST_FRAME], + cur_order_hint) > 0) { + if (motion_field_projection(cm, ALTREF2_FRAME, 0, + tile_col_start4, tile_col_end4, + row_start4, row_end4)) --ref_stamp; + } + + if (get_relative_dist(cm, ref_order_hint[ALTREF_FRAME - LAST_FRAME], + cur_order_hint) > 0 && + ref_stamp >= 0) + if (motion_field_projection(cm, ALTREF_FRAME, 0, + tile_col_start4, tile_col_end4, + row_start4, row_end4)) --ref_stamp; + + if (ref_stamp >= 0 && ref_buf_idx[LAST2_FRAME - LAST_FRAME] >= 0) + if (motion_field_projection(cm, LAST2_FRAME, 2, + tile_col_start4, tile_col_end4, + row_start4, row_end4)) --ref_stamp; +} + +#if 0 +static INLINE void record_samples(MB_MODE_INFO *mbmi, int *pts, int *pts_inref, + int row_offset, int sign_r, int col_offset, + int sign_c) { + int bw = block_size_wide[mbmi->sb_type]; + int bh = block_size_high[mbmi->sb_type]; + int x = col_offset * MI_SIZE + sign_c * AOMMAX(bw, MI_SIZE) / 2 - 1; + int y = row_offset * MI_SIZE + sign_r * AOMMAX(bh, MI_SIZE) / 2 - 1; + + pts[0] = (x * 8); + pts[1] = (y * 8); + pts_inref[0] = (x * 8) + mbmi->mv[0].as_mv.col; + pts_inref[1] = (y * 8) + mbmi->mv[0].as_mv.row; +} + +// Select samples according to the motion vector difference. +int selectSamples(MV *mv, int *pts, int *pts_inref, int len, BLOCK_SIZE bsize) { + const int bw = block_size_wide[bsize]; + const int bh = block_size_high[bsize]; + const int thresh = clamp(AOMMAX(bw, bh), 16, 112); + int pts_mvd[SAMPLES_ARRAY_SIZE] = { 0 }; + int i, j, k, l = len; + int ret = 0; + assert(len <= LEAST_SQUARES_SAMPLES_MAX); + + // Obtain the motion vector difference. + for (i = 0; i < len; ++i) { + pts_mvd[i] = abs(pts_inref[2 * i] - pts[2 * i] - mv->col) + + abs(pts_inref[2 * i + 1] - pts[2 * i + 1] - mv->row); + + if (pts_mvd[i] > thresh) + pts_mvd[i] = -1; + else + ret++; + } + + // Keep at least 1 sample. + if (!ret) return 1; + + i = 0; + j = l - 1; + for (k = 0; k < l - ret; k++) { + while (pts_mvd[i] != -1) i++; + while (pts_mvd[j] == -1) j--; + assert(i != j); + if (i > j) break; + + // Replace the discarded samples; + pts_mvd[i] = pts_mvd[j]; + pts[2 * i] = pts[2 * j]; + pts[2 * i + 1] = pts[2 * j + 1]; + pts_inref[2 * i] = pts_inref[2 * j]; + pts_inref[2 * i + 1] = pts_inref[2 * j + 1]; + i++; + j--; + } + + return ret; +} + +// Note: Samples returned are at 1/8-pel precision +// Sample are the neighbor block center point's coordinates relative to the +// left-top pixel of current block. +int findSamples(const AV1_COMMON *cm, MACROBLOCKD *xd, int mi_row, int mi_col, + int *pts, int *pts_inref) { + MB_MODE_INFO *const mbmi0 = xd->mi[0]; + int ref_frame = mbmi0->ref_frame[0]; + int up_available = xd->up_available; + int left_available = xd->left_available; + int i, mi_step = 1, np = 0; + + const TileInfo *const tile = &xd->tile; + int do_tl = 1; + int do_tr = 1; + + // scan the nearest above rows + if (up_available) { + int mi_row_offset = -1; + MB_MODE_INFO *mbmi = xd->mi[mi_row_offset * xd->mi_stride]; + uint8_t n8_w = mi_size_wide[mbmi->sb_type]; + + if (xd->n8_w <= n8_w) { + // Handle "current block width <= above block width" case. + int col_offset = -mi_col % n8_w; + + if (col_offset < 0) do_tl = 0; + if (col_offset + n8_w > xd->n8_w) do_tr = 0; + + if (mbmi->ref_frame[0] == ref_frame && mbmi->ref_frame[1] == NONE_FRAME) { + record_samples(mbmi, pts, pts_inref, 0, -1, col_offset, 1); + pts += 2; + pts_inref += 2; + np++; + if (np >= LEAST_SQUARES_SAMPLES_MAX) return LEAST_SQUARES_SAMPLES_MAX; + } + } else { + // Handle "current block width > above block width" case. + for (i = 0; i < AOMMIN(xd->n8_w, cm->mi_cols - mi_col); i += mi_step) { + int mi_col_offset = i; + mi = xd->mi[mi_col_offset + mi_row_offset * xd->mi_stride]; + mbmi = &mi->mbmi; + n8_w = mi_size_wide[mbmi->sb_type]; + mi_step = AOMMIN(xd->n8_w, n8_w); + + if (mbmi->ref_frame[0] == ref_frame && + mbmi->ref_frame[1] == NONE_FRAME) { + record_samples(mbmi, pts, pts_inref, 0, -1, i, 1); + pts += 2; + pts_inref += 2; + np++; + if (np >= LEAST_SQUARES_SAMPLES_MAX) return LEAST_SQUARES_SAMPLES_MAX; + } + } + } + } + assert(np <= LEAST_SQUARES_SAMPLES_MAX); + + // scan the nearest left columns + if (left_available) { + int mi_col_offset = -1; + + MB_MODE_INFO *mi = xd->mi[mi_col_offset]; + uint8_t n8_h = mi_size_high[mbmi->sb_type]; + + if (xd->n8_h <= n8_h) { + // Handle "current block height <= above block height" case. + int row_offset = -mi_row % n8_h; + + if (row_offset < 0) do_tl = 0; + + if (mbmi->ref_frame[0] == ref_frame && mbmi->ref_frame[1] == NONE_FRAME) { + record_samples(mbmi, pts, pts_inref, row_offset, 1, 0, -1); + pts += 2; + pts_inref += 2; + np++; + if (np >= LEAST_SQUARES_SAMPLES_MAX) return LEAST_SQUARES_SAMPLES_MAX; + } + } else { + // Handle "current block height > above block height" case. + for (i = 0; i < AOMMIN(xd->n8_h, cm->mi_rows - mi_row); i += mi_step) { + int mi_row_offset = i; + mbmi = xd->mi[mi_col_offset + mi_row_offset * xd->mi_stride]; + n8_h = mi_size_high[mbmi->sb_type]; + mi_step = AOMMIN(xd->n8_h, n8_h); + + if (mbmi->ref_frame[0] == ref_frame && + mbmi->ref_frame[1] == NONE_FRAME) { + record_samples(mbmi, pts, pts_inref, i, 1, 0, -1); + pts += 2; + pts_inref += 2; + np++; + if (np >= LEAST_SQUARES_SAMPLES_MAX) return LEAST_SQUARES_SAMPLES_MAX; + } + } + } + } + assert(np <= LEAST_SQUARES_SAMPLES_MAX); + + // Top-left block + if (do_tl && left_available && up_available) { + int mi_row_offset = -1; + int mi_col_offset = -1; + + MB_MODE_INFO *mbmi = xd->mi[mi_col_offset + mi_row_offset * xd->mi_stride]; + + if (mbmi->ref_frame[0] == ref_frame && mbmi->ref_frame[1] == NONE_FRAME) { + record_samples(mbmi, pts, pts_inref, 0, -1, 0, -1); + pts += 2; + pts_inref += 2; + np++; + if (np >= LEAST_SQUARES_SAMPLES_MAX) return LEAST_SQUARES_SAMPLES_MAX; + } + } + assert(np <= LEAST_SQUARES_SAMPLES_MAX); + + // Top-right block + if (do_tr && + has_top_right(cm, xd, mi_row, mi_col, AOMMAX(xd->n8_w, xd->n8_h))) { + POSITION trb_pos = { -1, xd->n8_w }; + + if (is_inside(tile, mi_col, mi_row, cm->mi_rows, &trb_pos)) { + int mi_row_offset = -1; + int mi_col_offset = xd->n8_w; + + MB_MODE_INFO *mbmi = + xd->mi[mi_col_offset + mi_row_offset * xd->mi_stride]; + + if (mbmi->ref_frame[0] == ref_frame && mbmi->ref_frame[1] == NONE_FRAME) { + record_samples(mbmi, pts, pts_inref, 0, -1, xd->n8_w, 1); + np++; + if (np >= LEAST_SQUARES_SAMPLES_MAX) return LEAST_SQUARES_SAMPLES_MAX; + } + } + } + assert(np <= LEAST_SQUARES_SAMPLES_MAX); + + return np; +} + +void av1_setup_skip_mode_allowed(AV1_COMMON *cm) { + cm->is_skip_mode_allowed = 0; + cm->ref_frame_idx_0 = cm->ref_frame_idx_1 = INVALID_IDX; + + if (!cm->seq_params.enable_order_hint || frame_is_intra_only(cm) || + cm->reference_mode == SINGLE_REFERENCE) + return; + + RefCntBuffer *const frame_bufs = cm->buffer_pool->frame_bufs; + const int cur_frame_offset = cm->frame_offset; + int ref_frame_offset[2] = { -1, INT_MAX }; + int ref_idx[2] = { INVALID_IDX, INVALID_IDX }; + + // Identify the nearest forward and backward references. + for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) { + const int buf_idx = cm->frame_refs[i].idx; + if (buf_idx == INVALID_IDX) continue; + + const int ref_offset = frame_bufs[buf_idx].cur_frame_offset; + if (get_relative_dist(cm, ref_offset, cur_frame_offset) < 0) { + // Forward reference + if (ref_frame_offset[0] == -1 || + get_relative_dist(cm, ref_offset, ref_frame_offset[0]) > 0) { + ref_frame_offset[0] = ref_offset; + ref_idx[0] = i; + } + } else if (get_relative_dist(cm, ref_offset, cur_frame_offset) > 0) { + // Backward reference + if (ref_frame_offset[1] == INT_MAX || + get_relative_dist(cm, ref_offset, ref_frame_offset[1]) < 0) { + ref_frame_offset[1] = ref_offset; + ref_idx[1] = i; + } + } + } + + if (ref_idx[0] != INVALID_IDX && ref_idx[1] != INVALID_IDX) { + // == Bi-directional prediction == + cm->is_skip_mode_allowed = 1; + cm->ref_frame_idx_0 = AOMMIN(ref_idx[0], ref_idx[1]); + cm->ref_frame_idx_1 = AOMMAX(ref_idx[0], ref_idx[1]); + } else if (ref_idx[0] != INVALID_IDX && ref_idx[1] == INVALID_IDX) { + // == Forward prediction only == + // Identify the second nearest forward reference. + ref_frame_offset[1] = -1; + for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) { + const int buf_idx = cm->frame_refs[i].idx; + if (buf_idx == INVALID_IDX) continue; + + const int ref_offset = frame_bufs[buf_idx].cur_frame_offset; + if ((ref_frame_offset[0] != -1 && + get_relative_dist(cm, ref_offset, ref_frame_offset[0]) < 0) && + (ref_frame_offset[1] == -1 || + get_relative_dist(cm, ref_offset, ref_frame_offset[1]) > 0)) { + // Second closest forward reference + ref_frame_offset[1] = ref_offset; + ref_idx[1] = i; + } + } + if (ref_frame_offset[1] != -1) { + cm->is_skip_mode_allowed = 1; + cm->ref_frame_idx_0 = AOMMIN(ref_idx[0], ref_idx[1]); + cm->ref_frame_idx_1 = AOMMAX(ref_idx[0], ref_idx[1]); + } + } +} + +typedef struct { + int map_idx; // frame map index + int buf_idx; // frame buffer index + int sort_idx; // index based on the offset to be used for sorting +} REF_FRAME_INFO; + +static int compare_ref_frame_info(const void *arg_a, const void *arg_b) { + const REF_FRAME_INFO *info_a = (REF_FRAME_INFO *)arg_a; + const REF_FRAME_INFO *info_b = (REF_FRAME_INFO *)arg_b; + + if (info_a->sort_idx < info_b->sort_idx) return -1; + if (info_a->sort_idx > info_b->sort_idx) return 1; + return (info_a->map_idx < info_b->map_idx) + ? -1 + : ((info_a->map_idx > info_b->map_idx) ? 1 : 0); +} + +static void set_ref_frame_info(AV1_COMMON *const cm, int frame_idx, + REF_FRAME_INFO *ref_info) { + assert(frame_idx >= 0 && frame_idx <= INTER_REFS_PER_FRAME); + + const int buf_idx = ref_info->buf_idx; + + cm->frame_refs[frame_idx].idx = buf_idx; + cm->frame_refs[frame_idx].buf = &cm->buffer_pool->frame_bufs[buf_idx].buf; + cm->frame_refs[frame_idx].map_idx = ref_info->map_idx; +} + +void av1_set_frame_refs(AV1_COMMON *const cm, int lst_map_idx, + int gld_map_idx) { + BufferPool *const pool = cm->buffer_pool; + RefCntBuffer *const frame_bufs = pool->frame_bufs; + + assert(cm->seq_params.enable_order_hint); + assert(cm->seq_params.order_hint_bits_minus_1 >= 0); + const int cur_frame_offset = (int)cm->frame_offset; + const int cur_frame_sort_idx = 1 << cm->seq_params.order_hint_bits_minus_1; + + REF_FRAME_INFO ref_frame_info[REF_FRAMES]; + int ref_flag_list[INTER_REFS_PER_FRAME] = { 0, 0, 0, 0, 0, 0, 0 }; + + for (int i = 0; i < REF_FRAMES; ++i) { + const int map_idx = i; + + ref_frame_info[i].map_idx = map_idx; + ref_frame_info[i].sort_idx = -1; + + const int buf_idx = cm->ref_frame_map[map_idx]; + ref_frame_info[i].buf_idx = buf_idx; + + if (buf_idx < 0 || buf_idx >= FRAME_BUFFERS) continue; + // TODO(zoeliu@google.com): To verify the checking on ref_count. + if (frame_bufs[buf_idx].ref_count <= 0) continue; + + const int offset = (int)frame_bufs[buf_idx].cur_frame_offset; + ref_frame_info[i].sort_idx = + (offset == -1) ? -1 + : cur_frame_sort_idx + + get_relative_dist(cm, offset, cur_frame_offset); + assert(ref_frame_info[i].sort_idx >= -1); + + if (map_idx == lst_map_idx) lst_frame_sort_idx = ref_frame_info[i].sort_idx; + if (map_idx == gld_map_idx) gld_frame_sort_idx = ref_frame_info[i].sort_idx; + } + + // Confirm both LAST_FRAME and GOLDEN_FRAME are valid forward reference + // frames. + if (lst_frame_sort_idx == -1 || lst_frame_sort_idx >= cur_frame_sort_idx) { + aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, + "Inter frame requests a look-ahead frame as LAST"); + } + if (gld_frame_sort_idx == -1 || gld_frame_sort_idx >= cur_frame_sort_idx) { + aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME, + "Inter frame requests a look-ahead frame as GOLDEN"); + } + + // Sort ref frames based on their frame_offset values. + qsort(ref_frame_info, REF_FRAMES, sizeof(REF_FRAME_INFO), + compare_ref_frame_info); + + // Identify forward and backward reference frames. + // Forward reference: offset < cur_frame_offset + // Backward reference: offset >= cur_frame_offset + int fwd_start_idx = 0, fwd_end_idx = REF_FRAMES - 1; + + for (int i = 0; i < REF_FRAMES; i++) { + if (ref_frame_info[i].sort_idx == -1) { + fwd_start_idx++; + continue; + } + + if (ref_frame_info[i].sort_idx >= cur_frame_sort_idx) { + fwd_end_idx = i - 1; + break; + } + } + + int bwd_start_idx = fwd_end_idx + 1; + int bwd_end_idx = REF_FRAMES - 1; + + // === Backward Reference Frames === + + // == ALTREF_FRAME == + if (bwd_start_idx <= bwd_end_idx) { + set_ref_frame_info(cm, ALTREF_FRAME - LAST_FRAME, + &ref_frame_info[bwd_end_idx]); + ref_flag_list[ALTREF_FRAME - LAST_FRAME] = 1; + bwd_end_idx--; + } + + // == BWDREF_FRAME == + if (bwd_start_idx <= bwd_end_idx) { + set_ref_frame_info(cm, BWDREF_FRAME - LAST_FRAME, + &ref_frame_info[bwd_start_idx]); + ref_flag_list[BWDREF_FRAME - LAST_FRAME] = 1; + bwd_start_idx++; + } + + // == ALTREF2_FRAME == + if (bwd_start_idx <= bwd_end_idx) { + set_ref_frame_info(cm, ALTREF2_FRAME - LAST_FRAME, + &ref_frame_info[bwd_start_idx]); + ref_flag_list[ALTREF2_FRAME - LAST_FRAME] = 1; + } + + // === Forward Reference Frames === + + for (int i = fwd_start_idx; i <= fwd_end_idx; ++i) { + // == LAST_FRAME == + if (ref_frame_info[i].map_idx == lst_map_idx) { + set_ref_frame_info(cm, LAST_FRAME - LAST_FRAME, &ref_frame_info[i]); + ref_flag_list[LAST_FRAME - LAST_FRAME] = 1; + } + + // == GOLDEN_FRAME == + if (ref_frame_info[i].map_idx == gld_map_idx) { + set_ref_frame_info(cm, GOLDEN_FRAME - LAST_FRAME, &ref_frame_info[i]); + ref_flag_list[GOLDEN_FRAME - LAST_FRAME] = 1; + } + } + + assert(ref_flag_list[LAST_FRAME - LAST_FRAME] == 1 && + ref_flag_list[GOLDEN_FRAME - LAST_FRAME] == 1); + + // == LAST2_FRAME == + // == LAST3_FRAME == + // == BWDREF_FRAME == + // == ALTREF2_FRAME == + // == ALTREF_FRAME == + + // Set up the reference frames in the anti-chronological order. + static const MV_REFERENCE_FRAME ref_frame_list[INTER_REFS_PER_FRAME - 2] = { + LAST2_FRAME, LAST3_FRAME, BWDREF_FRAME, ALTREF2_FRAME, ALTREF_FRAME + }; + + int ref_idx; + for (ref_idx = 0; ref_idx < (INTER_REFS_PER_FRAME - 2); ref_idx++) { + const MV_REFERENCE_FRAME ref_frame = ref_frame_list[ref_idx]; + + if (ref_flag_list[ref_frame - LAST_FRAME] == 1) continue; + + while (fwd_start_idx <= fwd_end_idx && + (ref_frame_info[fwd_end_idx].map_idx == lst_map_idx || + ref_frame_info[fwd_end_idx].map_idx == gld_map_idx)) { + fwd_end_idx--; + } + if (fwd_start_idx > fwd_end_idx) break; + + set_ref_frame_info(cm, ref_frame - LAST_FRAME, + &ref_frame_info[fwd_end_idx]); + ref_flag_list[ref_frame - LAST_FRAME] = 1; + + fwd_end_idx--; + } + + // Assign all the remaining frame(s), if any, to the earliest reference frame. + for (; ref_idx < (INTER_REFS_PER_FRAME - 2); ref_idx++) { + const MV_REFERENCE_FRAME ref_frame = ref_frame_list[ref_idx]; + if (ref_flag_list[ref_frame - LAST_FRAME] == 1) continue; + set_ref_frame_info(cm, ref_frame - LAST_FRAME, + &ref_frame_info[fwd_start_idx]); + ref_flag_list[ref_frame - LAST_FRAME] = 1; + } + + for (int i = 0; i < INTER_REFS_PER_FRAME; i++) { + assert(ref_flag_list[i] == 1); + } +} +#endif + +enum BlockSize { + BS_128x128, + BS_128x64, + BS_64x128, + BS_64x64, + BS_64x32, + BS_64x16, + BS_32x64, + BS_32x32, + BS_32x16, + BS_32x8, + BS_16x64, + BS_16x32, + BS_16x16, + BS_16x8, + BS_16x4, + BS_8x32, + BS_8x16, + BS_8x8, + BS_8x4, + BS_4x16, + BS_4x8, + BS_4x4, + N_BS_SIZES, +}; +extern const uint8_t av1_block_dimensions[N_BS_SIZES][4]; +const uint8_t bs_to_sbtype[N_BS_SIZES] = { + [BS_128x128] = BLOCK_128X128, + [BS_128x64] = BLOCK_128X64, + [BS_64x128] = BLOCK_64X128, + [BS_64x64] = BLOCK_64X64, + [BS_64x32] = BLOCK_64X32, + [BS_64x16] = BLOCK_64X16, + [BS_32x64] = BLOCK_32X64, + [BS_32x32] = BLOCK_32X32, + [BS_32x16] = BLOCK_32X16, + [BS_32x8] = BLOCK_32X8, + [BS_16x64] = BLOCK_16X64, + [BS_16x32] = BLOCK_16X32, + [BS_16x16] = BLOCK_16X16, + [BS_16x8] = BLOCK_16X8, + [BS_16x4] = BLOCK_16X4, + [BS_8x32] = BLOCK_8X32, + [BS_8x16] = BLOCK_8X16, + [BS_8x8] = BLOCK_8X8, + [BS_8x4] = BLOCK_8X4, + [BS_4x16] = BLOCK_4X16, + [BS_4x8] = BLOCK_4X8, + [BS_4x4] = BLOCK_4X4, +}; +const uint8_t sbtype_to_bs[BLOCK_SIZES_ALL] = { + [BLOCK_128X128] = BS_128x128, + [BLOCK_128X64] = BS_128x64, + [BLOCK_64X128] = BS_64x128, + [BLOCK_64X64] = BS_64x64, + [BLOCK_64X32] = BS_64x32, + [BLOCK_64X16] = BS_64x16, + [BLOCK_32X64] = BS_32x64, + [BLOCK_32X32] = BS_32x32, + [BLOCK_32X16] = BS_32x16, + [BLOCK_32X8] = BS_32x8, + [BLOCK_16X64] = BS_16x64, + [BLOCK_16X32] = BS_16x32, + [BLOCK_16X16] = BS_16x16, + [BLOCK_16X8] = BS_16x8, + [BLOCK_16X4] = BS_16x4, + [BLOCK_8X32] = BS_8x32, + [BLOCK_8X16] = BS_8x16, + [BLOCK_8X8] = BS_8x8, + [BLOCK_8X4] = BS_8x4, + [BLOCK_4X16] = BS_4x16, + [BLOCK_4X8] = BS_4x8, + [BLOCK_4X4] = BS_4x4, +}; + +static inline struct MV av1_clamp_mv(const struct MV mv, + const int bx4, const int by4, + const int bw4, const int bh4, + const int iw4, const int ih4) +{ + const int left = -(bx4 + bw4 + 4) * 4 * 8; + const int right = (iw4 - bx4 + 0 * bw4 + 4) * 4 * 8; + const int top = -(by4 + bh4 + 4) * 4 * 8; + const int bottom = (ih4 - by4 + 0 * bh4 + 4) * 4 * 8; + + return (struct MV) { .col = iclip(mv.col, left, right), + .row = iclip(mv.row, top, bottom) }; +} + +#include <stdio.h> + +void av1_find_ref_mvs(CANDIDATE_MV *mvstack, int *cnt, int_mv (*mvlist)[2], + int *ctx, int refidx_dav1d[2], + int w4, int h4, int bs, int bp, int by4, int bx4, + int tile_col_start4, int tile_col_end4, + int tile_row_start4, int tile_row_end4, + AV1_COMMON *cm) +{ + const int bw4 = av1_block_dimensions[bs][0]; + const int bh4 = av1_block_dimensions[bs][1]; + int stride = cm->cur_frame.mv_stride; + MACROBLOCKD xd = (MACROBLOCKD) { + .n8_w = bw4, + .n8_h = bh4, + .mi_stride = stride, + .up_available = by4 > tile_row_start4, + .left_available = bx4 > tile_col_start4, + .tile = { + .mi_col_end = AOMMIN(w4, tile_col_end4), + .mi_row_end = AOMMIN(h4, tile_row_end4), + .tg_horz_boundary = 0, + .mi_row_start = tile_row_start4, + .mi_col_start = tile_col_start4, + }, + .mi = (MB_MODE_INFO *) &cm->cur_frame.mvs[by4 * stride + bx4], + .mb_to_bottom_edge = (h4 - bh4 - by4) * 32, + .mb_to_left_edge = -bx4 * 32, + .mb_to_right_edge = (w4 - bw4 - bx4) * 32, + .mb_to_top_edge = -by4 * 32, + .is_sec_rect = 0, + .cur_mi = { + .partition = bp, + }, + }; + xd.mi->sb_type = bs_to_sbtype[bs]; + if (xd.n8_w < xd.n8_h) { + // Only mark is_sec_rect as 1 for the last block. + // For PARTITION_VERT_4, it would be (0, 0, 0, 1); + // For other partitions, it would be (0, 1). + if (!((bx4 + xd.n8_w) & (xd.n8_h - 1))) xd.is_sec_rect = 1; + } + + if (xd.n8_w > xd.n8_h) + if (by4 & (xd.n8_w - 1)) xd.is_sec_rect = 1; + + MV_REFERENCE_FRAME rf[2] = { refidx_dav1d[0] + 1, refidx_dav1d[1] + 1 }; + const int refidx = av1_ref_frame_type(rf); + int16_t single_context[MODE_CTX_REF_FRAMES]; + uint8_t mv_cnt[MODE_CTX_REF_FRAMES] = { 0 }; + CANDIDATE_MV mv_stack[MODE_CTX_REF_FRAMES][MAX_REF_MV_STACK_SIZE]; + memset(mv_stack, 0, sizeof(mv_stack)); + int_mv mv_list[MODE_CTX_REF_FRAMES][MAX_MV_REF_CANDIDATES] = { { { 0 } } }; + int_mv gmvs[MODE_CTX_REF_FRAMES]; +#if 0 + void av1_find_mv_refs(const AV1_COMMON *cm, const MACROBLOCKD *xd, + MB_MODE_INFO *mi, MV_REFERENCE_FRAME ref_frame, + uint8_t ref_mv_count[MODE_CTX_REF_FRAMES], + CANDIDATE_MV ref_mv_stack[][MAX_REF_MV_STACK_SIZE], + int_mv mv_ref_list[][MAX_MV_REF_CANDIDATES], + int_mv *global_mvs, int mi_row, int mi_col, + int16_t *mode_context) +#endif + av1_find_mv_refs(cm, &xd, xd.mi, refidx, mv_cnt, + mv_stack, mv_list, gmvs, by4, bx4, + single_context); +#if !defined(NDEBUG) + if (refidx_dav1d[1] == -1 && mv_cnt[refidx] >= 1) { + int_mv tmpa = { .as_int = mv_stack[refidx][0].this_mv.as_int }; + clamp_mv_ref(&tmpa.as_mv, bw4 * 4, bh4 * 4, &xd); + int_mv tmp1 = { .as_mv = + av1_clamp_mv(mv_stack[refidx][0].this_mv.as_mv, + bx4, by4, bw4, bh4, w4, h4) }; + assert(tmpa.as_int == tmp1.as_int); + assert(tmp1.as_int == mv_list[refidx][0].as_int); + if (mv_cnt[refidx] >= 2) { + int_mv tmpb = { .as_int = mv_stack[refidx][1].this_mv.as_int }; + clamp_mv_ref(&tmpb.as_mv, bw4 * 4, bh4 * 4, &xd); + int_mv tmp2 = { .as_mv = + av1_clamp_mv(mv_stack[refidx][1].this_mv.as_mv, + bx4, by4, bw4, bh4, w4, h4) }; + assert(tmp2.as_int == tmpb.as_int); + assert(tmp2.as_int == mv_list[refidx][1].as_int); + } + } +#endif + for (int i = 0; i < mv_cnt[refidx]; i++) + mvstack[i] = mv_stack[refidx][i]; + *cnt = mv_cnt[refidx]; + + mvlist[0][0] = mv_list[refidx_dav1d[0] + 1][0]; + mvlist[0][1] = mv_list[refidx_dav1d[0] + 1][1]; + if (refidx_dav1d[1] != -1) { + mvlist[1][0] = mv_list[refidx_dav1d[1] + 1][0]; + mvlist[1][1] = mv_list[refidx_dav1d[1] + 1][1]; + } + + if (ctx) { + if (refidx_dav1d[1] == -1) + *ctx = single_context[refidx_dav1d[0] + 1]; + else + *ctx = av1_mode_context_analyzer(single_context, rf); + } + + if (0 && bx4 == 38 && by4 == 15 && cm->frame_offset == 3 && + refidx_dav1d[1] == -1 && refidx_dav1d[0] == 4 && + bw4 == 1 && bh4 == 1 && bp == 3) + { + MV_REF *l = bx4 ? &cm->cur_frame.mvs[by4*stride+bx4-1] : NULL; + MV_REF *a = by4 ? &cm->cur_frame.mvs[by4*stride+bx4-stride] : NULL; + printf("Input: left=[0]y:%d,x:%d,r:%d,[1]y:%d,x:%d,r:%d,mode=%d, " + "above=[0]y:%d,x:%d,r:%d,[1]y:%d,x:%d,r:%d,mode=%d, " + "temp=y:%d,x:%d,r:%d [use_ref=%d]\n", + l ? l->mv[0].as_mv.row : -1, + l ? l->mv[0].as_mv.col : -1, + l ? l->ref_frame[0]: -1, + l ? l->mv[1].as_mv.row : -1, + l ? l->mv[1].as_mv.col : -1, + l ? l->ref_frame[1]: -1, + l ? l->mode : -1, + a ? a->mv[0].as_mv.row: -1, + a ? a->mv[0].as_mv.col : -1, + a ? a->ref_frame[0] : -1, + a ? a->mv[1].as_mv.row: -1, + a ? a->mv[1].as_mv.col : -1, + a ? a->ref_frame[1] : -1, + a ? a->mode : -1, + cm->tpl_mvs[(by4 >> 1) * (cm->mi_stride >> 1) + (bx4 >> 1)].mfmv0.as_mv.row, + cm->tpl_mvs[(by4 >> 1) * (cm->mi_stride >> 1) + (bx4 >> 1)].mfmv0.as_mv.col, + cm->tpl_mvs[(by4 >> 1) * (cm->mi_stride >> 1) + + (bx4 >> 1)].ref_frame_offset, + cm->allow_ref_frame_mvs); + printf("Edges: l=%d,t=%d,r=%d,b=%d,w=%d,h=%d,border=%d\n", + xd.mb_to_left_edge, + xd.mb_to_top_edge, + xd.mb_to_right_edge, + xd.mb_to_bottom_edge, + xd.n8_w << MI_SIZE_LOG2, + xd.n8_h << MI_SIZE_LOG2, + MV_BORDER); + printf("bp=%d, x=%d, y=%d, refs=%d/%d, n_mvs: %d, " + "first mv: y=%d,x=%d | y=%d,x=%d, " + "first comp mv: y=%d,x=%d | y=%d,x=%d, " + "second mv: y=%d, x=%d | y=%d, x=%d, " + "second comp mv: y=%d, x=%d | y=%d, x=%d, " + "third mv: y=%d, x=%d, " + "ctx=%d\n", + bp, bx4, by4, refidx_dav1d[0], refidx_dav1d[1], mv_cnt[refidx], + mv_stack[refidx][0].this_mv.as_mv.row, + mv_stack[refidx][0].this_mv.as_mv.col, + mv_list[refidx_dav1d[0] + 1][0].as_mv.row, + mv_list[refidx_dav1d[0] + 1][0].as_mv.col, + mv_stack[refidx][0].comp_mv.as_mv.row, + mv_stack[refidx][0].comp_mv.as_mv.col, + mv_list[refidx_dav1d[1] + 1][0].as_mv.row, + mv_list[refidx_dav1d[1] + 1][0].as_mv.col, + mv_stack[refidx][1].this_mv.as_mv.row, + mv_stack[refidx][1].this_mv.as_mv.col, + mv_list[refidx_dav1d[0] + 1][1].as_mv.row, + mv_list[refidx_dav1d[0] + 1][1].as_mv.col, + mv_stack[refidx][1].comp_mv.as_mv.row, + mv_stack[refidx][1].comp_mv.as_mv.col, + mv_list[refidx_dav1d[1] + 1][1].as_mv.row, + mv_list[refidx_dav1d[1] + 1][1].as_mv.col, + mv_stack[refidx][2].this_mv.as_mv.row, + mv_stack[refidx][2].this_mv.as_mv.col, + *ctx); + } +} + +void av1_init_ref_mv_common(AV1_COMMON *cm, + const int w8, const int h8, + const ptrdiff_t stride, + const int allow_sb128, + MV_REF *cur, + MV_REF *ref_mvs[7], + const unsigned cur_poc, + const unsigned ref_poc[7], + const unsigned ref_ref_poc[7][7], + const WarpedMotionParams gmv[7], + const int allow_hp, + const int force_int_mv, + const int allow_ref_frame_mvs, + const int order_hint) +{ + if (cm->mi_cols != (w8 << 1) || cm->mi_rows != (h8 << 1)) { + const int align_h = (h8 + 15) & ~15; + if (cm->tpl_mvs) free(cm->tpl_mvs); + cm->tpl_mvs = malloc(sizeof(*cm->tpl_mvs) * (stride >> 1) * align_h); + for (int i = 0; i < 7; i++) + cm->frame_refs[i].idx = i; + cm->mi_cols = w8 << 1; + cm->mi_rows = h8 << 1; + cm->mi_stride = stride; + for (int i = 0; i < 7; i++) { + cm->buffer_pool.frame_bufs[i].mi_rows = cm->mi_rows; + cm->buffer_pool.frame_bufs[i].mi_cols = cm->mi_cols; + cm->buffer_pool.frame_bufs[i].mv_stride = stride; + } + cm->cur_frame.mv_stride = stride; + } + + cm->allow_high_precision_mv = allow_hp; + cm->seq_params.sb_size = allow_sb128 ? BLOCK_128X128 : BLOCK_64X64; + + cm->seq_params.enable_order_hint = !!order_hint; + cm->seq_params.order_hint_bits_minus1 = order_hint - 1; + // FIXME get these from the sequence/frame headers instead of hardcoding + cm->frame_parallel_decode = 0; + cm->cur_frame_force_integer_mv = force_int_mv; + + memcpy(&cm->global_motion[1], gmv, sizeof(*gmv) * 7); + + cm->frame_offset = cur_poc; + cm->allow_ref_frame_mvs = allow_ref_frame_mvs; + cm->cur_frame.mvs = cur; + for (int i = 0; i < 7; i++) { + cm->buffer_pool.frame_bufs[i].mvs = ref_mvs[i]; + cm->buffer_pool.frame_bufs[i].intra_only = ref_mvs[i] == NULL; + cm->buffer_pool.frame_bufs[i].cur_frame_offset = ref_poc[i]; + for (int j = 0; j < 7; j++) + cm->buffer_pool.frame_bufs[i].ref_frame_offset[j] = + ref_ref_poc[i][j]; + } + av1_setup_frame_buf_refs(cm); + for (int i = 0; i < 7; i++) { + const int ref_poc = cm->buffer_pool.frame_bufs[i].cur_frame_offset; + cm->ref_frame_sign_bias[1 + i] = get_relative_dist(cm, ref_poc, cur_poc) > 0; + } + av1_setup_motion_field(cm); +} + +void av1_init_ref_mv_tile_row(AV1_COMMON *cm, + int tile_col_start4, int tile_col_end4, + int row_start4, int row_end4) +{ + av1_fill_motion_field(cm, tile_col_start4, tile_col_end4, + row_start4, row_end4); +} + +AV1_COMMON *av1_alloc_ref_mv_common(void) { + AV1_COMMON *cm = malloc(sizeof(*cm)); + memset(cm, 0, sizeof(*cm)); + return cm; +} + +void av1_free_ref_mv_common(AV1_COMMON *cm) { + if (cm->tpl_mvs) free(cm->tpl_mvs); + free(cm); +} diff --git a/src/ref_mvs.h b/src/ref_mvs.h new file mode 100644 index 0000000..743ffb9 --- /dev/null +++ b/src/ref_mvs.h @@ -0,0 +1,185 @@ +/* + * Copyright (c) 2001-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 __DAV1D_SRC_REF_MVS_H__ +#define __DAV1D_SRC_REF_MVS_H__ + +#include <stddef.h> + +#include "src/levels.h" +#include "src/tables.h" + +typedef struct refmvs { + mv mv[2]; + int8_t ref[2]; // [0] = 0: intra=1, [1] = -1: comp=0 + int8_t mode, sb_type; +} refmvs; + +typedef struct candidate_mv { + mv this_mv; + mv comp_mv; + int weight; +} candidate_mv; + +typedef struct AV1_COMMON AV1_COMMON; + +// call once per frame thread +AV1_COMMON *av1_alloc_ref_mv_common(void); +void av1_free_ref_mv_common(AV1_COMMON *cm); + +// call once per frame +void av1_init_ref_mv_common(AV1_COMMON *cm, + int w8, int h8, + ptrdiff_t stride, + int allow_sb128, + refmvs *cur, + refmvs *ref_mvs[7], + unsigned cur_poc, + const unsigned ref_poc[7], + const unsigned ref_ref_poc[7][7], + const WarpedMotionParams gmv[7], + int allow_hp, int force_int_mv, + int allow_ref_frame_mvs, int order_hint); + +// call for start of each sbrow per tile +void av1_init_ref_mv_tile_row(AV1_COMMON *cm, + int tile_col_start4, int tile_col_end4, + int row_start4, int row_end4); + +// call for each block +void av1_find_ref_mvs(candidate_mv *mvstack, int *cnt, mv (*mvlist)[2], + int *ctx, int refidx[2], int w4, int h4, + enum BlockSize bs, enum BlockPartition bp, + int by4, int bx4, int tile_col_start4, + int tile_col_end4, int tile_row_start4, + int tile_row_end4, AV1_COMMON *cm); + +extern const uint8_t bs_to_sbtype[]; +extern const uint8_t sbtype_to_bs[]; +static inline void splat_oneref_mv(refmvs *r, const ptrdiff_t stride, + const int by4, const int bx4, + const enum BlockSize bs, + const enum InterPredMode mode, + const int ref, const mv mv, + const int is_interintra) +{ + const int bw4 = av1_block_dimensions[bs][0]; + int bh4 = av1_block_dimensions[bs][1]; + + r += by4 * stride + bx4; + const refmvs tmpl = (refmvs) { + .ref = { ref + 1, is_interintra ? 0 : -1 }, + .mv = { mv }, + .sb_type = bs_to_sbtype[bs], + .mode = N_INTRA_PRED_MODES + mode, + }; + do { + for (int x = 0; x < bw4; x++) + r[x] = tmpl; + r += stride; + } while (--bh4); +} + +static inline void splat_intrabc_mv(refmvs *r, const ptrdiff_t stride, + const int by4, const int bx4, + const enum BlockSize bs, const mv mv) +{ + const int bw4 = av1_block_dimensions[bs][0]; + int bh4 = av1_block_dimensions[bs][1]; + + r += by4 * stride + bx4; + const refmvs tmpl = (refmvs) { + .ref = { 0, -1 }, + .mv = { mv }, + .sb_type = bs_to_sbtype[bs], + .mode = DC_PRED, + }; + do { + for (int x = 0; x < bw4; x++) + r[x] = tmpl; + r += stride; + } while (--bh4); +} + +static inline void splat_tworef_mv(refmvs *r, const ptrdiff_t stride, + const int by4, const int bx4, + const enum BlockSize bs, + const enum CompInterPredMode mode, + const int ref1, const int ref2, + const mv mv1, const mv mv2) +{ + const int bw4 = av1_block_dimensions[bs][0]; + int bh4 = av1_block_dimensions[bs][1]; + + r += by4 * stride + bx4; + const refmvs tmpl = (refmvs) { + .ref = { ref1 + 1, ref2 + 1 }, + .mv = { mv1, mv2 }, + .sb_type = bs_to_sbtype[bs], + .mode = N_INTRA_PRED_MODES + N_INTER_PRED_MODES + mode, + }; + do { + for (int x = 0; x < bw4; x++) + r[x] = tmpl; + r += stride; + } while (--bh4); +} + +static inline void splat_intraref(refmvs *r, const ptrdiff_t stride, + const int by4, const int bx4, + const enum BlockSize bs, + const enum IntraPredMode mode) +{ + const int bw4 = av1_block_dimensions[bs][0]; + int bh4 = av1_block_dimensions[bs][1]; + + r += by4 * stride + bx4; + do { + int x; + + for (x = 0; x < bw4; x++) + r[x] = (refmvs) { + .ref = { 0, -1 }, + .mv = { [0] = { .y = -0x8000, .x = -0x8000 }, }, + .sb_type = bs_to_sbtype[bs], + .mode = mode, + }; + r += stride; + } while (--bh4); +} + +// FIXME integer_mv +static inline void unset_hp_bit(mv *const a) { + if (a->x & 1) { + if (a->x < 0) a->x++; + else a->x--; + } + if (a->y & 1) { + if (a->y < 0) a->y++; + else a->y--; + } +} + +static inline mv av1_clamp_mv(const mv mv, + const int bx4, const int by4, + const int bw4, const int bh4, + const int iw4, const int ih4) +{ + const int left = -(bx4 + bw4 + 4) * 4 * 8; + const int right = (iw4 - bx4 + 0 * bw4 + 4) * 4 * 8; + const int top = -(by4 + bh4 + 4) * 4 * 8; + const int bottom = (ih4 - by4 + 0 * bh4 + 4) * 4 * 8; + + return (struct mv) { .x = iclip(mv.x, left, right), + .y = iclip(mv.y, top, bottom) }; +} + +#endif /* __DAV1D_SRC_REF_MVS_H__ */ diff --git a/src/scan.c b/src/scan.c new file mode 100644 index 0000000..942ffa5 --- /dev/null +++ b/src/scan.c @@ -0,0 +1,527 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include "src/scan.h" + +static const int16_t av1_default_scan_4x4[] __attribute__((aligned(32))) = { + 0, 4, 1, 2, + 5, 8, 12, 9, + 6, 3, 7, 10, + 13, 14, 11, 15, +}; +static const int16_t av1_mrow_scan_4x4[] __attribute__((aligned(32))) = { + 0, 4, 8, 12, + 1, 5, 9, 13, + 2, 6, 10, 14, + 3, 7, 11, 15, +}; +static const int16_t av1_mcol_scan_4x4[] __attribute__((aligned(32))) = { + 0, 1, 2, 3, + 4, 5, 6, 7, + 8, 9, 10, 11, + 12, 13, 14, 15, +}; +static const int16_t av1_default_scan_4x8[] __attribute__((aligned(32))) = { + 0, 8, 1, 16, + 9, 2, 24, 17, + 10, 3, 25, 18, + 11, 4, 26, 19, + 12, 5, 27, 20, + 13, 6, 28, 21, + 14, 7, 29, 22, + 15, 30, 23, 31, +}; +static const int16_t av1_mrow_scan_4x8[] __attribute__((aligned(32))) = { + 0, 8, 16, 24, + 1, 9, 17, 25, + 2, 10, 18, 26, + 3, 11, 19, 27, + 4, 12, 20, 28, + 5, 13, 21, 29, + 6, 14, 22, 30, + 7, 15, 23, 31, +}; +static const int16_t av1_mcol_scan_4x8[] __attribute__((aligned(32))) = { + 0, 1, 2, 3, + 4, 5, 6, 7, + 8, 9, 10, 11, + 12, 13, 14, 15, + 16, 17, 18, 19, + 20, 21, 22, 23, + 24, 25, 26, 27, + 28, 29, 30, 31, +}; +static const int16_t av1_default_scan_4x16[] __attribute__((aligned(32))) = { + 0, 16, 1, 32, + 17, 2, 48, 33, + 18, 3, 49, 34, + 19, 4, 50, 35, + 20, 5, 51, 36, + 21, 6, 52, 37, + 22, 7, 53, 38, + 23, 8, 54, 39, + 24, 9, 55, 40, + 25, 10, 56, 41, + 26, 11, 57, 42, + 27, 12, 58, 43, + 28, 13, 59, 44, + 29, 14, 60, 45, + 30, 15, 61, 46, + 31, 62, 47, 63, +}; +static const int16_t av1_mrow_scan_4x16[] __attribute__((aligned(32))) = { + 0, 16, 32, 48, + 1, 17, 33, 49, + 2, 18, 34, 50, + 3, 19, 35, 51, + 4, 20, 36, 52, + 5, 21, 37, 53, + 6, 22, 38, 54, + 7, 23, 39, 55, + 8, 24, 40, 56, + 9, 25, 41, 57, + 10, 26, 42, 58, + 11, 27, 43, 59, + 12, 28, 44, 60, + 13, 29, 45, 61, + 14, 30, 46, 62, + 15, 31, 47, 63, +}; +static const int16_t av1_mcol_scan_4x16[] __attribute__((aligned(32))) = { + 0, 1, 2, 3, + 4, 5, 6, 7, + 8, 9, 10, 11, + 12, 13, 14, 15, + 16, 17, 18, 19, + 20, 21, 22, 23, + 24, 25, 26, 27, + 28, 29, 30, 31, + 32, 33, 34, 35, + 36, 37, 38, 39, + 40, 41, 42, 43, + 44, 45, 46, 47, + 48, 49, 50, 51, + 52, 53, 54, 55, + 56, 57, 58, 59, + 60, 61, 62, 63, +}; +static const int16_t av1_default_scan_8x4[] __attribute__((aligned(32))) = { + 0, 1, 4, 2, 5, 8, 3, 6, + 9, 12, 7, 10, 13, 16, 11, 14, + 17, 20, 15, 18, 21, 24, 19, 22, + 25, 28, 23, 26, 29, 27, 30, 31, +}; +static const int16_t av1_mrow_scan_8x4[] __attribute__((aligned(32))) = { + 0, 4, 8, 12, 16, 20, 24, 28, + 1, 5, 9, 13, 17, 21, 25, 29, + 2, 6, 10, 14, 18, 22, 26, 30, + 3, 7, 11, 15, 19, 23, 27, 31, +}; +static const int16_t av1_mcol_scan_8x4[] __attribute__((aligned(32))) = { + 0, 1, 2, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, +}; +static const int16_t av1_default_scan_8x8[] __attribute__((aligned(32))) = { + 0, 8, 1, 2, 9, 16, 24, 17, + 10, 3, 4, 11, 18, 25, 32, 40, + 33, 26, 19, 12, 5, 6, 13, 20, + 27, 34, 41, 48, 56, 49, 42, 35, + 28, 21, 14, 7, 15, 22, 29, 36, + 43, 50, 57, 58, 51, 44, 37, 30, + 23, 31, 38, 45, 52, 59, 60, 53, + 46, 39, 47, 54, 61, 62, 55, 63, +}; +static const int16_t av1_mrow_scan_8x8[] __attribute__((aligned(32))) = { + 0, 8, 16, 24, 32, 40, 48, 56, + 1, 9, 17, 25, 33, 41, 49, 57, + 2, 10, 18, 26, 34, 42, 50, 58, + 3, 11, 19, 27, 35, 43, 51, 59, + 4, 12, 20, 28, 36, 44, 52, 60, + 5, 13, 21, 29, 37, 45, 53, 61, + 6, 14, 22, 30, 38, 46, 54, 62, + 7, 15, 23, 31, 39, 47, 55, 63, +}; +static const int16_t av1_mcol_scan_8x8[] __attribute__((aligned(32))) = { + 0, 1, 2, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 59, 60, 61, 62, 63, +}; +static const int16_t av1_default_scan_8x16[] __attribute__((aligned(32))) = { + 0, 16, 1, 32, 17, 2, 48, 33, + 18, 3, 64, 49, 34, 19, 4, 80, + 65, 50, 35, 20, 5, 96, 81, 66, + 51, 36, 21, 6, 112, 97, 82, 67, + 52, 37, 22, 7, 113, 98, 83, 68, + 53, 38, 23, 8, 114, 99, 84, 69, + 54, 39, 24, 9, 115, 100, 85, 70, + 55, 40, 25, 10, 116, 101, 86, 71, + 56, 41, 26, 11, 117, 102, 87, 72, + 57, 42, 27, 12, 118, 103, 88, 73, + 58, 43, 28, 13, 119, 104, 89, 74, + 59, 44, 29, 14, 120, 105, 90, 75, + 60, 45, 30, 15, 121, 106, 91, 76, + 61, 46, 31, 122, 107, 92, 77, 62, + 47, 123, 108, 93, 78, 63, 124, 109, + 94, 79, 125, 110, 95, 126, 111, 127, +}; +static const int16_t av1_mrow_scan_8x16[] __attribute__((aligned(32))) = { + 0, 16, 32, 48, 64, 80, 96, 112, + 1, 17, 33, 49, 65, 81, 97, 113, + 2, 18, 34, 50, 66, 82, 98, 114, + 3, 19, 35, 51, 67, 83, 99, 115, + 4, 20, 36, 52, 68, 84, 100, 116, + 5, 21, 37, 53, 69, 85, 101, 117, + 6, 22, 38, 54, 70, 86, 102, 118, + 7, 23, 39, 55, 71, 87, 103, 119, + 8, 24, 40, 56, 72, 88, 104, 120, + 9, 25, 41, 57, 73, 89, 105, 121, + 10, 26, 42, 58, 74, 90, 106, 122, + 11, 27, 43, 59, 75, 91, 107, 123, + 12, 28, 44, 60, 76, 92, 108, 124, + 13, 29, 45, 61, 77, 93, 109, 125, + 14, 30, 46, 62, 78, 94, 110, 126, + 15, 31, 47, 63, 79, 95, 111, 127, +}; +static const int16_t av1_mcol_scan_8x16[] __attribute__((aligned(32))) = { + 0, 1, 2, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, + 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, + 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, + 120, 121, 122, 123, 124, 125, 126, 127, +}; +static const int16_t av1_default_scan_8x32[] __attribute__((aligned(32))) = { + 0, 32, 1, 64, 33, 2, 96, 65, + 34, 3, 128, 97, 66, 35, 4, 160, + 129, 98, 67, 36, 5, 192, 161, 130, + 99, 68, 37, 6, 224, 193, 162, 131, + 100, 69, 38, 7, 225, 194, 163, 132, + 101, 70, 39, 8, 226, 195, 164, 133, + 102, 71, 40, 9, 227, 196, 165, 134, + 103, 72, 41, 10, 228, 197, 166, 135, + 104, 73, 42, 11, 229, 198, 167, 136, + 105, 74, 43, 12, 230, 199, 168, 137, + 106, 75, 44, 13, 231, 200, 169, 138, + 107, 76, 45, 14, 232, 201, 170, 139, + 108, 77, 46, 15, 233, 202, 171, 140, + 109, 78, 47, 16, 234, 203, 172, 141, + 110, 79, 48, 17, 235, 204, 173, 142, + 111, 80, 49, 18, 236, 205, 174, 143, + 112, 81, 50, 19, 237, 206, 175, 144, + 113, 82, 51, 20, 238, 207, 176, 145, + 114, 83, 52, 21, 239, 208, 177, 146, + 115, 84, 53, 22, 240, 209, 178, 147, + 116, 85, 54, 23, 241, 210, 179, 148, + 117, 86, 55, 24, 242, 211, 180, 149, + 118, 87, 56, 25, 243, 212, 181, 150, + 119, 88, 57, 26, 244, 213, 182, 151, + 120, 89, 58, 27, 245, 214, 183, 152, + 121, 90, 59, 28, 246, 215, 184, 153, + 122, 91, 60, 29, 247, 216, 185, 154, + 123, 92, 61, 30, 248, 217, 186, 155, + 124, 93, 62, 31, 249, 218, 187, 156, + 125, 94, 63, 250, 219, 188, 157, 126, + 95, 251, 220, 189, 158, 127, 252, 221, + 190, 159, 253, 222, 191, 254, 223, 255, +}; +static const int16_t av1_default_scan_16x4[] __attribute__((aligned(32))) = { + 0, 1, 4, 2, 5, 8, 3, 6, 9, 12, 7, 10, 13, 16, 11, 14, + 17, 20, 15, 18, 21, 24, 19, 22, 25, 28, 23, 26, 29, 32, 27, 30, + 33, 36, 31, 34, 37, 40, 35, 38, 41, 44, 39, 42, 45, 48, 43, 46, + 49, 52, 47, 50, 53, 56, 51, 54, 57, 60, 55, 58, 61, 59, 62, 63, +}; +static const int16_t av1_mrow_scan_16x4[] __attribute__((aligned(32))) = { + 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60, + 1, 5, 9, 13, 17, 21, 25, 29, 33, 37, 41, 45, 49, 53, 57, 61, + 2, 6, 10, 14, 18, 22, 26, 30, 34, 38, 42, 46, 50, 54, 58, 62, + 3, 7, 11, 15, 19, 23, 27, 31, 35, 39, 43, 47, 51, 55, 59, 63, +}; +static const int16_t av1_mcol_scan_16x4[] __attribute__((aligned(32))) = { + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, +}; +static const int16_t av1_default_scan_16x8[] __attribute__((aligned(32))) = { + 0, 1, 8, 2, 9, 16, 3, 10, 17, 24, 4, 11, 18, 25, 32, 5, + 12, 19, 26, 33, 40, 6, 13, 20, 27, 34, 41, 48, 7, 14, 21, 28, + 35, 42, 49, 56, 15, 22, 29, 36, 43, 50, 57, 64, 23, 30, 37, 44, + 51, 58, 65, 72, 31, 38, 45, 52, 59, 66, 73, 80, 39, 46, 53, 60, + 67, 74, 81, 88, 47, 54, 61, 68, 75, 82, 89, 96, 55, 62, 69, 76, + 83, 90, 97, 104, 63, 70, 77, 84, 91, 98, 105, 112, 71, 78, 85, 92, + 99, 106, 113, 120, 79, 86, 93, 100, 107, 114, 121, 87, 94, 101, 108, 115, + 122, 95, 102, 109, 116, 123, 103, 110, 117, 124, 111, 118, 125, 119, 126, 127, +}; +static const int16_t av1_mrow_scan_16x8[] __attribute__((aligned(32))) = { + 0, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120, + 1, 9, 17, 25, 33, 41, 49, 57, 65, 73, 81, 89, 97, 105, 113, 121, + 2, 10, 18, 26, 34, 42, 50, 58, 66, 74, 82, 90, 98, 106, 114, 122, + 3, 11, 19, 27, 35, 43, 51, 59, 67, 75, 83, 91, 99, 107, 115, 123, + 4, 12, 20, 28, 36, 44, 52, 60, 68, 76, 84, 92, 100, 108, 116, 124, + 5, 13, 21, 29, 37, 45, 53, 61, 69, 77, 85, 93, 101, 109, 117, 125, + 6, 14, 22, 30, 38, 46, 54, 62, 70, 78, 86, 94, 102, 110, 118, 126, + 7, 15, 23, 31, 39, 47, 55, 63, 71, 79, 87, 95, 103, 111, 119, 127, +}; +static const int16_t av1_mcol_scan_16x8[] __attribute__((aligned(32))) = { + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, +}; +static const int16_t av1_default_scan_16x16[] __attribute__((aligned(32))) = { + 0, 16, 1, 2, 17, 32, 48, 33, 18, 3, 4, 19, 34, 49, 64, 80, + 65, 50, 35, 20, 5, 6, 21, 36, 51, 66, 81, 96, 112, 97, 82, 67, + 52, 37, 22, 7, 8, 23, 38, 53, 68, 83, 98, 113, 128, 144, 129, 114, + 99, 84, 69, 54, 39, 24, 9, 10, 25, 40, 55, 70, 85, 100, 115, 130, + 145, 160, 176, 161, 146, 131, 116, 101, 86, 71, 56, 41, 26, 11, 12, 27, + 42, 57, 72, 87, 102, 117, 132, 147, 162, 177, 192, 208, 193, 178, 163, 148, + 133, 118, 103, 88, 73, 58, 43, 28, 13, 14, 29, 44, 59, 74, 89, 104, + 119, 134, 149, 164, 179, 194, 209, 224, 240, 225, 210, 195, 180, 165, 150, 135, + 120, 105, 90, 75, 60, 45, 30, 15, 31, 46, 61, 76, 91, 106, 121, 136, + 151, 166, 181, 196, 211, 226, 241, 242, 227, 212, 197, 182, 167, 152, 137, 122, + 107, 92, 77, 62, 47, 63, 78, 93, 108, 123, 138, 153, 168, 183, 198, 213, + 228, 243, 244, 229, 214, 199, 184, 169, 154, 139, 124, 109, 94, 79, 95, 110, + 125, 140, 155, 170, 185, 200, 215, 230, 245, 246, 231, 216, 201, 186, 171, 156, + 141, 126, 111, 127, 142, 157, 172, 187, 202, 217, 232, 247, 248, 233, 218, 203, + 188, 173, 158, 143, 159, 174, 189, 204, 219, 234, 249, 250, 235, 220, 205, 190, + 175, 191, 206, 221, 236, 251, 252, 237, 222, 207, 223, 238, 253, 254, 239, 255, +}; +static const int16_t av1_mrow_scan_16x16[] __attribute__((aligned(32))) = { + 0, 16, 32, 48, 64, 80, 96, 112, 128, 144, 160, 176, 192, 208, 224, 240, + 1, 17, 33, 49, 65, 81, 97, 113, 129, 145, 161, 177, 193, 209, 225, 241, + 2, 18, 34, 50, 66, 82, 98, 114, 130, 146, 162, 178, 194, 210, 226, 242, + 3, 19, 35, 51, 67, 83, 99, 115, 131, 147, 163, 179, 195, 211, 227, 243, + 4, 20, 36, 52, 68, 84, 100, 116, 132, 148, 164, 180, 196, 212, 228, 244, + 5, 21, 37, 53, 69, 85, 101, 117, 133, 149, 165, 181, 197, 213, 229, 245, + 6, 22, 38, 54, 70, 86, 102, 118, 134, 150, 166, 182, 198, 214, 230, 246, + 7, 23, 39, 55, 71, 87, 103, 119, 135, 151, 167, 183, 199, 215, 231, 247, + 8, 24, 40, 56, 72, 88, 104, 120, 136, 152, 168, 184, 200, 216, 232, 248, + 9, 25, 41, 57, 73, 89, 105, 121, 137, 153, 169, 185, 201, 217, 233, 249, + 10, 26, 42, 58, 74, 90, 106, 122, 138, 154, 170, 186, 202, 218, 234, 250, + 11, 27, 43, 59, 75, 91, 107, 123, 139, 155, 171, 187, 203, 219, 235, 251, + 12, 28, 44, 60, 76, 92, 108, 124, 140, 156, 172, 188, 204, 220, 236, 252, + 13, 29, 45, 61, 77, 93, 109, 125, 141, 157, 173, 189, 205, 221, 237, 253, + 14, 30, 46, 62, 78, 94, 110, 126, 142, 158, 174, 190, 206, 222, 238, 254, + 15, 31, 47, 63, 79, 95, 111, 127, 143, 159, 175, 191, 207, 223, 239, 255, +}; +static const int16_t av1_mcol_scan_16x16[] __attribute__((aligned(32))) = { + 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, + 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, + 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, + 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, + 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, + 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, + 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, + 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, + 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, + 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, + 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, + 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, +}; +static const int16_t av1_default_scan_16x32[] __attribute__((aligned(32))) = { + 0, 32, 1, 64, 33, 2, 96, 65, 34, 3, 128, 97, 66, 35, 4, 160, + 129, 98, 67, 36, 5, 192, 161, 130, 99, 68, 37, 6, 224, 193, 162, 131, + 100, 69, 38, 7, 256, 225, 194, 163, 132, 101, 70, 39, 8, 288, 257, 226, + 195, 164, 133, 102, 71, 40, 9, 320, 289, 258, 227, 196, 165, 134, 103, 72, + 41, 10, 352, 321, 290, 259, 228, 197, 166, 135, 104, 73, 42, 11, 384, 353, + 322, 291, 260, 229, 198, 167, 136, 105, 74, 43, 12, 416, 385, 354, 323, 292, + 261, 230, 199, 168, 137, 106, 75, 44, 13, 448, 417, 386, 355, 324, 293, 262, + 231, 200, 169, 138, 107, 76, 45, 14, 480, 449, 418, 387, 356, 325, 294, 263, + 232, 201, 170, 139, 108, 77, 46, 15, 481, 450, 419, 388, 357, 326, 295, 264, + 233, 202, 171, 140, 109, 78, 47, 16, 482, 451, 420, 389, 358, 327, 296, 265, + 234, 203, 172, 141, 110, 79, 48, 17, 483, 452, 421, 390, 359, 328, 297, 266, + 235, 204, 173, 142, 111, 80, 49, 18, 484, 453, 422, 391, 360, 329, 298, 267, + 236, 205, 174, 143, 112, 81, 50, 19, 485, 454, 423, 392, 361, 330, 299, 268, + 237, 206, 175, 144, 113, 82, 51, 20, 486, 455, 424, 393, 362, 331, 300, 269, + 238, 207, 176, 145, 114, 83, 52, 21, 487, 456, 425, 394, 363, 332, 301, 270, + 239, 208, 177, 146, 115, 84, 53, 22, 488, 457, 426, 395, 364, 333, 302, 271, + 240, 209, 178, 147, 116, 85, 54, 23, 489, 458, 427, 396, 365, 334, 303, 272, + 241, 210, 179, 148, 117, 86, 55, 24, 490, 459, 428, 397, 366, 335, 304, 273, + 242, 211, 180, 149, 118, 87, 56, 25, 491, 460, 429, 398, 367, 336, 305, 274, + 243, 212, 181, 150, 119, 88, 57, 26, 492, 461, 430, 399, 368, 337, 306, 275, + 244, 213, 182, 151, 120, 89, 58, 27, 493, 462, 431, 400, 369, 338, 307, 276, + 245, 214, 183, 152, 121, 90, 59, 28, 494, 463, 432, 401, 370, 339, 308, 277, + 246, 215, 184, 153, 122, 91, 60, 29, 495, 464, 433, 402, 371, 340, 309, 278, + 247, 216, 185, 154, 123, 92, 61, 30, 496, 465, 434, 403, 372, 341, 310, 279, + 248, 217, 186, 155, 124, 93, 62, 31, 497, 466, 435, 404, 373, 342, 311, 280, + 249, 218, 187, 156, 125, 94, 63, 498, 467, 436, 405, 374, 343, 312, 281, 250, + 219, 188, 157, 126, 95, 499, 468, 437, 406, 375, 344, 313, 282, 251, 220, 189, + 158, 127, 500, 469, 438, 407, 376, 345, 314, 283, 252, 221, 190, 159, 501, 470, + 439, 408, 377, 346, 315, 284, 253, 222, 191, 502, 471, 440, 409, 378, 347, 316, + 285, 254, 223, 503, 472, 441, 410, 379, 348, 317, 286, 255, 504, 473, 442, 411, + 380, 349, 318, 287, 505, 474, 443, 412, 381, 350, 319, 506, 475, 444, 413, 382, + 351, 507, 476, 445, 414, 383, 508, 477, 446, 415, 509, 478, 447, 510, 479, 511, +}; +static const int16_t av1_default_scan_32x8[] __attribute__((aligned(32))) = { + 0, 1, 8, 2, 9, 16, 3, 10, 17, 24, 4, 11, 18, 25, 32, 5, 12, 19, 26, 33, 40, 6, 13, 20, 27, 34, 41, 48, 7, 14, 21, 28, + 35, 42, 49, 56, 15, 22, 29, 36, 43, 50, 57, 64, 23, 30, 37, 44, 51, 58, 65, 72, 31, 38, 45, 52, 59, 66, 73, 80, 39, 46, 53, 60, + 67, 74, 81, 88, 47, 54, 61, 68, 75, 82, 89, 96, 55, 62, 69, 76, 83, 90, 97, 104, 63, 70, 77, 84, 91, 98, 105, 112, 71, 78, 85, 92, + 99, 106, 113, 120, 79, 86, 93, 100, 107, 114, 121, 128, 87, 94, 101, 108, 115, 122, 129, 136, 95, 102, 109, 116, 123, 130, 137, 144, 103, 110, 117, 124, + 131, 138, 145, 152, 111, 118, 125, 132, 139, 146, 153, 160, 119, 126, 133, 140, 147, 154, 161, 168, 127, 134, 141, 148, 155, 162, 169, 176, 135, 142, 149, 156, + 163, 170, 177, 184, 143, 150, 157, 164, 171, 178, 185, 192, 151, 158, 165, 172, 179, 186, 193, 200, 159, 166, 173, 180, 187, 194, 201, 208, 167, 174, 181, 188, + 195, 202, 209, 216, 175, 182, 189, 196, 203, 210, 217, 224, 183, 190, 197, 204, 211, 218, 225, 232, 191, 198, 205, 212, 219, 226, 233, 240, 199, 206, 213, 220, + 227, 234, 241, 248, 207, 214, 221, 228, 235, 242, 249, 215, 222, 229, 236, 243, 250, 223, 230, 237, 244, 251, 231, 238, 245, 252, 239, 246, 253, 247, 254, 255, +}; +static const int16_t av1_default_scan_32x16[] __attribute__((aligned(32))) = { + 0, 1, 16, 2, 17, 32, 3, 18, 33, 48, 4, 19, 34, 49, 64, 5, 20, 35, 50, 65, 80, 6, 21, 36, 51, 66, 81, 96, 7, 22, 37, 52, + 67, 82, 97, 112, 8, 23, 38, 53, 68, 83, 98, 113, 128, 9, 24, 39, 54, 69, 84, 99, 114, 129, 144, 10, 25, 40, 55, 70, 85, 100, 115, 130, + 145, 160, 11, 26, 41, 56, 71, 86, 101, 116, 131, 146, 161, 176, 12, 27, 42, 57, 72, 87, 102, 117, 132, 147, 162, 177, 192, 13, 28, 43, 58, 73, + 88, 103, 118, 133, 148, 163, 178, 193, 208, 14, 29, 44, 59, 74, 89, 104, 119, 134, 149, 164, 179, 194, 209, 224, 15, 30, 45, 60, 75, 90, 105, 120, + 135, 150, 165, 180, 195, 210, 225, 240, 31, 46, 61, 76, 91, 106, 121, 136, 151, 166, 181, 196, 211, 226, 241, 256, 47, 62, 77, 92, 107, 122, 137, 152, + 167, 182, 197, 212, 227, 242, 257, 272, 63, 78, 93, 108, 123, 138, 153, 168, 183, 198, 213, 228, 243, 258, 273, 288, 79, 94, 109, 124, 139, 154, 169, 184, + 199, 214, 229, 244, 259, 274, 289, 304, 95, 110, 125, 140, 155, 170, 185, 200, 215, 230, 245, 260, 275, 290, 305, 320, 111, 126, 141, 156, 171, 186, 201, 216, + 231, 246, 261, 276, 291, 306, 321, 336, 127, 142, 157, 172, 187, 202, 217, 232, 247, 262, 277, 292, 307, 322, 337, 352, 143, 158, 173, 188, 203, 218, 233, 248, + 263, 278, 293, 308, 323, 338, 353, 368, 159, 174, 189, 204, 219, 234, 249, 264, 279, 294, 309, 324, 339, 354, 369, 384, 175, 190, 205, 220, 235, 250, 265, 280, + 295, 310, 325, 340, 355, 370, 385, 400, 191, 206, 221, 236, 251, 266, 281, 296, 311, 326, 341, 356, 371, 386, 401, 416, 207, 222, 237, 252, 267, 282, 297, 312, + 327, 342, 357, 372, 387, 402, 417, 432, 223, 238, 253, 268, 283, 298, 313, 328, 343, 358, 373, 388, 403, 418, 433, 448, 239, 254, 269, 284, 299, 314, 329, 344, + 359, 374, 389, 404, 419, 434, 449, 464, 255, 270, 285, 300, 315, 330, 345, 360, 375, 390, 405, 420, 435, 450, 465, 480, 271, 286, 301, 316, 331, 346, 361, 376, + 391, 406, 421, 436, 451, 466, 481, 496, 287, 302, 317, 332, 347, 362, 377, 392, 407, 422, 437, 452, 467, 482, 497, 303, 318, 333, 348, 363, 378, 393, 408, 423, + 438, 453, 468, 483, 498, 319, 334, 349, 364, 379, 394, 409, 424, 439, 454, 469, 484, 499, 335, 350, 365, 380, 395, 410, 425, 440, 455, 470, 485, 500, 351, 366, + 381, 396, 411, 426, 441, 456, 471, 486, 501, 367, 382, 397, 412, 427, 442, 457, 472, 487, 502, 383, 398, 413, 428, 443, 458, 473, 488, 503, 399, 414, 429, 444, + 459, 474, 489, 504, 415, 430, 445, 460, 475, 490, 505, 431, 446, 461, 476, 491, 506, 447, 462, 477, 492, 507, 463, 478, 493, 508, 479, 494, 509, 495, 510, 511, +}; +static const int16_t av1_default_scan_32x32[] __attribute__((aligned(32))) = { + 0, 32, 1, 2, 33, 64, 96, 65, 34, 3, 4, 35, 66, 97, 128, 160, 129, 98, 67, 36, 5, 6, 37, 68, 99, 130, 161, 192, 224, 193, 162, 131, + 100, 69, 38, 7, 8, 39, 70, 101, 132, 163, 194, 225, 256, 288, 257, 226, 195, 164, 133, 102, 71, 40, 9, 10, 41, 72, 103, 134, 165, 196, 227, 258, + 289, 320, 352, 321, 290, 259, 228, 197, 166, 135, 104, 73, 42, 11, 12, 43, 74, 105, 136, 167, 198, 229, 260, 291, 322, 353, 384, 416, 385, 354, 323, 292, + 261, 230, 199, 168, 137, 106, 75, 44, 13, 14, 45, 76, 107, 138, 169, 200, 231, 262, 293, 324, 355, 386, 417, 448, 480, 449, 418, 387, 356, 325, 294, 263, + 232, 201, 170, 139, 108, 77, 46, 15, 16, 47, 78, 109, 140, 171, 202, 233, 264, 295, 326, 357, 388, 419, 450, 481, 512, 544, 513, 482, 451, 420, 389, 358, + 327, 296, 265, 234, 203, 172, 141, 110, 79, 48, 17, 18, 49, 80, 111, 142, 173, 204, 235, 266, 297, 328, 359, 390, 421, 452, 483, 514, 545, 576, 608, 577, + 546, 515, 484, 453, 422, 391, 360, 329, 298, 267, 236, 205, 174, 143, 112, 81, 50, 19, 20, 51, 82, 113, 144, 175, 206, 237, 268, 299, 330, 361, 392, 423, + 454, 485, 516, 547, 578, 609, 640, 672, 641, 610, 579, 548, 517, 486, 455, 424, 393, 362, 331, 300, 269, 238, 207, 176, 145, 114, 83, 52, 21, 22, 53, 84, + 115, 146, 177, 208, 239, 270, 301, 332, 363, 394, 425, 456, 487, 518, 549, 580, 611, 642, 673, 704, 736, 705, 674, 643, 612, 581, 550, 519, 488, 457, 426, 395, + 364, 333, 302, 271, 240, 209, 178, 147, 116, 85, 54, 23, 24, 55, 86, 117, 148, 179, 210, 241, 272, 303, 334, 365, 396, 427, 458, 489, 520, 551, 582, 613, + 644, 675, 706, 737, 768, 800, 769, 738, 707, 676, 645, 614, 583, 552, 521, 490, 459, 428, 397, 366, 335, 304, 273, 242, 211, 180, 149, 118, 87, 56, 25, 26, + 57, 88, 119, 150, 181, 212, 243, 274, 305, 336, 367, 398, 429, 460, 491, 522, 553, 584, 615, 646, 677, 708, 739, 770, 801, 832, 864, 833, 802, 771, 740, 709, + 678, 647, 616, 585, 554, 523, 492, 461, 430, 399, 368, 337, 306, 275, 244, 213, 182, 151, 120, 89, 58, 27, 28, 59, 90, 121, 152, 183, 214, 245, 276, 307, + 338, 369, 400, 431, 462, 493, 524, 555, 586, 617, 648, 679, 710, 741, 772, 803, 834, 865, 896, 928, 897, 866, 835, 804, 773, 742, 711, 680, 649, 618, 587, 556, + 525, 494, 463, 432, 401, 370, 339, 308, 277, 246, 215, 184, 153, 122, 91, 60, 29, 30, 61, 92, 123, 154, 185, 216, 247, 278, 309, 340, 371, 402, 433, 464, + 495, 526, 557, 588, 619, 650, 681, 712, 743, 774, 805, 836, 867, 898, 929, 960, 992, 961, 930, 899, 868, 837, 806, 775, 744, 713, 682, 651, 620, 589, 558, 527, + 496, 465, 434, 403, 372, 341, 310, 279, 248, 217, 186, 155, 124, 93, 62, 31, 63, 94, 125, 156, 187, 218, 249, 280, 311, 342, 373, 404, 435, 466, 497, 528, + 559, 590, 621, 652, 683, 714, 745, 776, 807, 838, 869, 900, 931, 962, 993, 994, 963, 932, 901, 870, 839, 808, 777, 746, 715, 684, 653, 622, 591, 560, 529, 498, + 467, 436, 405, 374, 343, 312, 281, 250, 219, 188, 157, 126, 95, 127, 158, 189, 220, 251, 282, 313, 344, 375, 406, 437, 468, 499, 530, 561, 592, 623, 654, 685, + 716, 747, 778, 809, 840, 871, 902, 933, 964, 995, 996, 965, 934, 903, 872, 841, 810, 779, 748, 717, 686, 655, 624, 593, 562, 531, 500, 469, 438, 407, 376, 345, + 314, 283, 252, 221, 190, 159, 191, 222, 253, 284, 315, 346, 377, 408, 439, 470, 501, 532, 563, 594, 625, 656, 687, 718, 749, 780, 811, 842, 873, 904, 935, 966, + 997, 998, 967, 936, 905, 874, 843, 812, 781, 750, 719, 688, 657, 626, 595, 564, 533, 502, 471, 440, 409, 378, 347, 316, 285, 254, 223, 255, 286, 317, 348, 379, + 410, 441, 472, 503, 534, 565, 596, 627, 658, 689, 720, 751, 782, 813, 844, 875, 906, 937, 968, 999, 1000, 969, 938, 907, 876, 845, 814, 783, 752, 721, 690, 659, + 628, 597, 566, 535, 504, 473, 442, 411, 380, 349, 318, 287, 319, 350, 381, 412, 443, 474, 505, 536, 567, 598, 629, 660, 691, 722, 753, 784, 815, 846, 877, 908, + 939, 970, 1001, 1002, 971, 940, 909, 878, 847, 816, 785, 754, 723, 692, 661, 630, 599, 568, 537, 506, 475, 444, 413, 382, 351, 383, 414, 445, 476, 507, 538, 569, + 600, 631, 662, 693, 724, 755, 786, 817, 848, 879, 910, 941, 972, 1003, 1004, 973, 942, 911, 880, 849, 818, 787, 756, 725, 694, 663, 632, 601, 570, 539, 508, 477, + 446, 415, 447, 478, 509, 540, 571, 602, 633, 664, 695, 726, 757, 788, 819, 850, 881, 912, 943, 974, 1005, 1006, 975, 944, 913, 882, 851, 820, 789, 758, 727, 696, + 665, 634, 603, 572, 541, 510, 479, 511, 542, 573, 604, 635, 666, 697, 728, 759, 790, 821, 852, 883, 914, 945, 976, 1007, 1008, 977, 946, 915, 884, 853, 822, 791, + 760, 729, 698, 667, 636, 605, 574, 543, 575, 606, 637, 668, 699, 730, 761, 792, 823, 854, 885, 916, 947, 978, 1009, 1010, 979, 948, 917, 886, 855, 824, 793, 762, + 731, 700, 669, 638, 607, 639, 670, 701, 732, 763, 794, 825, 856, 887, 918, 949, 980, 1011, 1012, 981, 950, 919, 888, 857, 826, 795, 764, 733, 702, 671, 703, 734, + 765, 796, 827, 858, 889, 920, 951, 982, 1013, 1014, 983, 952, 921, 890, 859, 828, 797, 766, 735, 767, 798, 829, 860, 891, 922, 953, 984, 1015, 1016, 985, 954, 923, + 892, 861, 830, 799, 831, 862, 893, 924, 955, 986, 1017, 1018, 987, 956, 925, 894, 863, 895, 926, 957, 988, 1019, 1020, 989, 958, 927, 959, 990, 1021, 1022, 991, 1023, +}; + +const int16_t *const av1_scans[N_RECT_TX_SIZES][3] = { + [TX_4X4] = { + [TX_CLASS_2D] = av1_default_scan_4x4, + [TX_CLASS_V] = av1_mrow_scan_4x4, + [TX_CLASS_H] = av1_mcol_scan_4x4, + }, [TX_8X8] = { + [TX_CLASS_2D] = av1_default_scan_8x8, + [TX_CLASS_V] = av1_mrow_scan_8x8, + [TX_CLASS_H] = av1_mcol_scan_8x8, + }, [TX_16X16] = { + [TX_CLASS_2D] = av1_default_scan_16x16, + [TX_CLASS_V] = av1_mrow_scan_16x16, + [TX_CLASS_H] = av1_mcol_scan_16x16, + }, [TX_32X32] = { + [TX_CLASS_2D] = av1_default_scan_32x32, + }, [TX_64X64] = { + [TX_CLASS_2D] = av1_default_scan_32x32, + }, [RTX_4X8] = { + [TX_CLASS_2D] = av1_default_scan_4x8, + [TX_CLASS_V] = av1_mrow_scan_4x8, + [TX_CLASS_H] = av1_mcol_scan_4x8, + }, [RTX_8X4] = { + [TX_CLASS_2D] = av1_default_scan_8x4, + [TX_CLASS_V] = av1_mrow_scan_8x4, + [TX_CLASS_H] = av1_mcol_scan_8x4, + }, [RTX_8X16] = { + [TX_CLASS_2D] = av1_default_scan_8x16, + [TX_CLASS_V] = av1_mrow_scan_8x16, + [TX_CLASS_H] = av1_mcol_scan_8x16, + }, [RTX_16X8] = { + [TX_CLASS_2D] = av1_default_scan_16x8, + [TX_CLASS_V] = av1_mrow_scan_16x8, + [TX_CLASS_H] = av1_mcol_scan_16x8, + }, [RTX_16X32] = { + [TX_CLASS_2D] = av1_default_scan_16x32, + }, [RTX_32X16] = { + [TX_CLASS_2D] = av1_default_scan_32x16, + }, [RTX_32X64] = { + [TX_CLASS_2D] = av1_default_scan_32x32, + }, [RTX_64X32] = { + [TX_CLASS_2D] = av1_default_scan_32x32, + }, [RTX_4X16] = { + [TX_CLASS_2D] = av1_default_scan_4x16, + [TX_CLASS_V] = av1_mrow_scan_4x16, + [TX_CLASS_H] = av1_mcol_scan_4x16, + }, [RTX_16X4] = { + [TX_CLASS_2D] = av1_default_scan_16x4, + [TX_CLASS_V] = av1_mrow_scan_16x4, + [TX_CLASS_H] = av1_mcol_scan_16x4, + }, [RTX_8X32] = { + [TX_CLASS_2D] = av1_default_scan_8x32, + }, [RTX_32X8] = { + [TX_CLASS_2D] = av1_default_scan_32x8, + }, [RTX_16X64] = { + [TX_CLASS_2D] = av1_default_scan_16x32, + }, [RTX_64X16] = { + [TX_CLASS_2D] = av1_default_scan_32x16, + }, +}; diff --git a/src/scan.h b/src/scan.h new file mode 100644 index 0000000..c00a64b --- /dev/null +++ b/src/scan.h @@ -0,0 +1,37 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_SCAN_H__ +#define __DAV1D_SCAN_H__ + +#include <stdint.h> + +#include "src/levels.h" + +extern const int16_t *const av1_scans[N_RECT_TX_SIZES][3]; + +#endif /* __DAV1D_SCAN_H__ */ diff --git a/src/tables.c b/src/tables.c new file mode 100644 index 0000000..15f042a --- /dev/null +++ b/src/tables.c @@ -0,0 +1,756 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <stdint.h> + +#include "src/levels.h" +#include "src/tables.h" + +const uint8_t av1_al_part_ctx[2][N_BL_LEVELS][N_PARTITIONS] = { + { + // partitions: + // none, h, v, split, tts, tbs, tls, trs, h4, v4 + { 0x00, 0x00, 0x10, -1, 0x00, 0x10, 0x10, 0x10, -1, -1 }, // bl128 + { 0x10, 0x10, 0x18, -1, 0x10, 0x18, 0x18, 0x18, 0x10, 0x1c }, // bl64 + { 0x18, 0x18, 0x1c, -1, 0x18, 0x1c, 0x1c, 0x1c, 0x18, 0x1e }, // bl32 + { 0x1c, 0x1c, 0x1e, -1, 0x1c, 0x1e, 0x1e, 0x1e, 0x1c, 0x1f }, // bl16 + { 0x1e, 0x1e, 0x1f, 0x1f, -1, -1, -1, -1, -1, -1 }, // bl8 + }, { + { 0x00, 0x10, 0x00, -1, 0x10, 0x10, 0x00, 0x10, -1, -1 }, // bl128 + { 0x10, 0x18, 0x10, -1, 0x18, 0x18, 0x10, 0x18, 0x1c, 0x10 }, // bl64 + { 0x18, 0x1c, 0x18, -1, 0x1c, 0x1c, 0x18, 0x1c, 0x1e, 0x18 }, // bl32 + { 0x1c, 0x1e, 0x1c, -1, 0x1e, 0x1e, 0x1c, 0x1e, 0x1f, 0x1c }, // bl16 + { 0x1e, 0x1f, 0x1e, 0x1f, -1, -1, -1, -1, -1, -1 }, // bl8 + } +}; + +const uint8_t /* enum BlockSize */ + av1_block_sizes[N_BL_LEVELS][N_PARTITIONS][2] = +{ + [BL_128X128] = { + [PARTITION_NONE] = { BS_128x128 }, + [PARTITION_H] = { BS_128x64 }, + [PARTITION_V] = { BS_64x128 }, + [PARTITION_T_TOP_SPLIT] = { BS_64x64, BS_128x64 }, + [PARTITION_T_BOTTOM_SPLIT] = { BS_128x64, BS_64x64 }, + [PARTITION_T_LEFT_SPLIT] = { BS_64x64, BS_64x128 }, + [PARTITION_T_RIGHT_SPLIT] = { BS_64x128, BS_64x64 }, + }, [BL_64X64] = { + [PARTITION_NONE] = { BS_64x64 }, + [PARTITION_H] = { BS_64x32 }, + [PARTITION_V] = { BS_32x64 }, + [PARTITION_T_TOP_SPLIT] = { BS_32x32, BS_64x32 }, + [PARTITION_T_BOTTOM_SPLIT] = { BS_64x32, BS_32x32 }, + [PARTITION_T_LEFT_SPLIT] = { BS_32x32, BS_32x64 }, + [PARTITION_T_RIGHT_SPLIT] = { BS_32x64, BS_32x32 }, + [PARTITION_H4] = { BS_64x16 }, + [PARTITION_V4] = { BS_16x64 }, + }, [BL_32X32] = { + [PARTITION_NONE] = { BS_32x32 }, + [PARTITION_H] = { BS_32x16 }, + [PARTITION_V] = { BS_16x32 }, + [PARTITION_T_TOP_SPLIT] = { BS_16x16, BS_32x16 }, + [PARTITION_T_BOTTOM_SPLIT] = { BS_32x16, BS_16x16 }, + [PARTITION_T_LEFT_SPLIT] = { BS_16x16, BS_16x32 }, + [PARTITION_T_RIGHT_SPLIT] = { BS_16x32, BS_16x16 }, + [PARTITION_H4] = { BS_32x8 }, + [PARTITION_V4] = { BS_8x32 }, + }, [BL_16X16] = { + [PARTITION_NONE] = { BS_16x16 }, + [PARTITION_H] = { BS_16x8 }, + [PARTITION_V] = { BS_8x16 }, + [PARTITION_T_TOP_SPLIT] = { BS_8x8, BS_16x8 }, + [PARTITION_T_BOTTOM_SPLIT] = { BS_16x8, BS_8x8 }, + [PARTITION_T_LEFT_SPLIT] = { BS_8x8, BS_8x16 }, + [PARTITION_T_RIGHT_SPLIT] = { BS_8x16, BS_8x8 }, + [PARTITION_H4] = { BS_16x4 }, + [PARTITION_V4] = { BS_4x16 }, + }, [BL_8X8] = { + [PARTITION_NONE] = { BS_8x8 }, + [PARTITION_H] = { BS_8x4 }, + [PARTITION_V] = { BS_4x8 }, + [PARTITION_SPLIT] = { BS_4x4 }, + } +}; + +const uint8_t av1_block_dimensions[N_BS_SIZES][4] = { + [BS_128x128] = { 32, 32, 5, 5 }, + [BS_128x64] = { 32, 16, 5, 4 }, + [BS_64x128] = { 16, 32, 4, 5 }, + [BS_64x64] = { 16, 16, 4, 4 }, + [BS_64x32] = { 16, 8, 4, 3 }, + [BS_64x16] = { 16, 4, 4, 2 }, + [BS_32x64] = { 8, 16, 3, 4 }, + [BS_32x32] = { 8, 8, 3, 3 }, + [BS_32x16] = { 8, 4, 3, 2 }, + [BS_32x8] = { 8, 2, 3, 1 }, + [BS_16x64] = { 4, 16, 2, 4 }, + [BS_16x32] = { 4, 8, 2, 3 }, + [BS_16x16] = { 4, 4, 2, 2 }, + [BS_16x8] = { 4, 2, 2, 1 }, + [BS_16x4] = { 4, 1, 2, 0 }, + [BS_8x32] = { 2, 8, 1, 3 }, + [BS_8x16] = { 2, 4, 1, 2 }, + [BS_8x8] = { 2, 2, 1, 1 }, + [BS_8x4] = { 2, 1, 1, 0 }, + [BS_4x16] = { 1, 4, 0, 2 }, + [BS_4x8] = { 1, 2, 0, 1 }, + [BS_4x4] = { 1, 1, 0, 0 }, +}; + +const TxfmInfo av1_txfm_dimensions[N_RECT_TX_SIZES] = { + [ TX_4X4] = { .w = 1, .h = 1, .lw = 0, .lh = 0, + .min = 0, .max = 0, .ctx = 0 }, + [ TX_8X8] = { .w = 2, .h = 2, .lw = 1, .lh = 1, + .min = 1, .max = 1, .sub = TX_4X4, .ctx = 1 }, + [ TX_16X16] = { .w = 4, .h = 4, .lw = 2, .lh = 2, + .min = 2, .max = 2, .sub = TX_8X8, .ctx = 2 }, + [ TX_32X32] = { .w = 8, .h = 8, .lw = 3, .lh = 3, + .min = 3, .max = 3, .sub = TX_16X16, .ctx = 3 }, + [ TX_64X64] = { .w = 16, .h = 16, .lw = 4, .lh = 4, + .min = 4, .max = 4, .sub = TX_32X32, .ctx = 4 }, + [RTX_4X8] = { .w = 1, .h = 2, .lw = 0, .lh = 1, + .min = 0, .max = 1, .sub = TX_4X4, .ctx = 1 }, + [RTX_8X4] = { .w = 2, .h = 1, .lw = 1, .lh = 0, + .min = 0, .max = 1, .sub = TX_4X4, .ctx = 1 }, + [RTX_8X16] = { .w = 2, .h = 4, .lw = 1, .lh = 2, + .min = 1, .max = 2, .sub = TX_8X8, .ctx = 2 }, + [RTX_16X8] = { .w = 4, .h = 2, .lw = 2, .lh = 1, + .min = 1, .max = 2, .sub = TX_8X8, .ctx = 2 }, + [RTX_16X32] = { .w = 4, .h = 8, .lw = 2, .lh = 3, + .min = 2, .max = 3, .sub = TX_16X16, .ctx = 3 }, + [RTX_32X16] = { .w = 8, .h = 4, .lw = 3, .lh = 2, + .min = 2, .max = 3, .sub = TX_16X16, .ctx = 3 }, + [RTX_32X64] = { .w = 8, .h = 16, .lw = 3, .lh = 4, + .min = 3, .max = 4, .sub = TX_32X32, .ctx = 4 }, + [RTX_64X32] = { .w = 16, .h = 8, .lw = 4, .lh = 3, + .min = 3, .max = 4, .sub = TX_32X32, .ctx = 4 }, + [RTX_4X16] = { .w = 1, .h = 4, .lw = 0, .lh = 2, + .min = 0, .max = 2, .sub = RTX_4X8, .ctx = 1 }, + [RTX_16X4] = { .w = 4, .h = 1, .lw = 2, .lh = 0, + .min = 0, .max = 2, .sub = RTX_8X4, .ctx = 1 }, + [RTX_8X32] = { .w = 2, .h = 8, .lw = 1, .lh = 3, + .min = 1, .max = 3, .sub = RTX_8X16, .ctx = 2 }, + [RTX_32X8] = { .w = 8, .h = 2, .lw = 3, .lh = 1, + .min = 1, .max = 3, .sub = RTX_16X8, .ctx = 2 }, + [RTX_16X64] = { .w = 4, .h = 16, .lw = 2, .lh = 4, + .min = 2, .max = 4, .sub = RTX_16X32, .ctx = 3 }, + [RTX_64X16] = { .w = 16, .h = 4, .lw = 4, .lh = 2, + .min = 2, .max = 4, .sub = RTX_32X16, .ctx = 3 }, +}; + +const uint8_t /* enum (Rect)TxfmSize */ + av1_max_txfm_size_for_bs[N_BS_SIZES][4 /* y, 420, 422, 444 */] = +{ + [BS_128x128] = { TX_64X64, TX_32X32, TX_32X32, TX_32X32 }, + [BS_128x64] = { TX_64X64, TX_32X32, TX_32X32, TX_32X32 }, + [BS_64x128] = { TX_64X64, TX_32X32, 0, TX_32X32 }, + [BS_64x64] = { TX_64X64, TX_32X32, TX_32X32, TX_32X32 }, + [BS_64x32] = { RTX_64X32, RTX_32X16, TX_32X32, TX_32X32 }, + [BS_64x16] = { RTX_64X16, RTX_32X8, RTX_32X16, RTX_32X16 }, + [BS_32x64] = { RTX_32X64, RTX_16X32, 0, TX_32X32 }, + [BS_32x32] = { TX_32X32, TX_16X16, RTX_16X32, TX_32X32 }, + [BS_32x16] = { RTX_32X16, RTX_16X8, TX_16X16, RTX_32X16 }, + [BS_32x8] = { RTX_32X8, RTX_16X4, RTX_16X8, RTX_32X8 }, + [BS_16x64] = { RTX_16X64, RTX_8X32, 0, RTX_16X32 }, + [BS_16x32] = { RTX_16X32, RTX_8X16, 0, RTX_16X32 }, + [BS_16x16] = { TX_16X16, TX_8X8, RTX_8X16, TX_16X16 }, + [BS_16x8] = { RTX_16X8, RTX_8X4, TX_8X8, RTX_16X8 }, + [BS_16x4] = { RTX_16X4, RTX_8X4, RTX_8X4, RTX_16X4 }, + [BS_8x32] = { RTX_8X32, RTX_4X16, 0, RTX_8X32 }, + [BS_8x16] = { RTX_8X16, RTX_4X8, 0, RTX_8X16 }, + [BS_8x8] = { TX_8X8, TX_4X4, RTX_4X8, TX_8X8 }, + [BS_8x4] = { RTX_8X4, TX_4X4, TX_4X4, RTX_8X4 }, + [BS_4x16] = { RTX_4X16, RTX_4X8, 0, RTX_4X16 }, + [BS_4x8] = { RTX_4X8, TX_4X4, 0, RTX_4X8 }, + [BS_4x4] = { TX_4X4, TX_4X4, TX_4X4, TX_4X4 }, +}; + +const uint8_t /* enum TxfmType */ + av1_txtp_from_uvmode[N_UV_INTRA_PRED_MODES] = +{ + [DC_PRED] = DCT_DCT, + [VERT_PRED] = ADST_DCT, + [HOR_PRED] = DCT_ADST, + [DIAG_DOWN_LEFT_PRED] = DCT_DCT, + [DIAG_DOWN_RIGHT_PRED] = ADST_ADST, + [VERT_RIGHT_PRED] = ADST_DCT, + [HOR_DOWN_PRED] = DCT_ADST, + [HOR_UP_PRED] = DCT_ADST, + [VERT_LEFT_PRED] = ADST_DCT, + [SMOOTH_PRED] = ADST_ADST, + [SMOOTH_V_PRED] = ADST_DCT, + [SMOOTH_H_PRED] = DCT_ADST, + [PAETH_PRED] = ADST_ADST, +}; + +const uint8_t /* enum InterPredMode */ + av1_comp_inter_pred_modes[N_COMP_INTER_PRED_MODES][2] = +{ + [NEARESTMV_NEARESTMV] = { NEARESTMV, NEARESTMV }, + [NEARMV_NEARMV] = { NEARMV, NEARMV }, + [NEWMV_NEWMV] = { NEWMV, NEWMV }, + [GLOBALMV_GLOBALMV] = { GLOBALMV, GLOBALMV }, + [NEWMV_NEARESTMV] = { NEWMV, NEARESTMV }, + [NEWMV_NEARMV] = { NEWMV, NEARMV }, + [NEARESTMV_NEWMV] = { NEARESTMV, NEWMV }, + [NEARMV_NEWMV] = { NEARMV, NEWMV }, +}; + +const uint8_t av1_tx_type_count[N_TXTP_SETS] = { + [TXTP_SET_DCT] = 1, + [TXTP_SET_DCT_ID] = 2, + [TXTP_SET_DT4_ID] = 5, + [TXTP_SET_DT4_ID_1D] = 7, + [TXTP_SET_DT9_ID_1D] = 12, + [TXTP_SET_ALL] = 16, + [TXTP_SET_LOSSLESS] = 1, +}; + +const uint8_t /* enum TxfmType */ + av1_tx_types_per_set[N_TXTP_SETS][N_TX_TYPES] = +{ + [TXTP_SET_DCT] = { DCT_DCT }, + [TXTP_SET_DCT_ID] = { IDTX, DCT_DCT }, + [TXTP_SET_DT4_ID] = { IDTX, DCT_DCT, ADST_ADST, ADST_DCT, DCT_ADST }, + [TXTP_SET_DT4_ID_1D] = { IDTX, DCT_DCT, V_DCT, H_DCT, ADST_ADST, ADST_DCT, + DCT_ADST }, + [TXTP_SET_DT9_ID_1D] = { IDTX, V_DCT, H_DCT, DCT_DCT, ADST_DCT, DCT_ADST, + FLIPADST_DCT, DCT_FLIPADST, ADST_ADST, + FLIPADST_FLIPADST, ADST_FLIPADST, FLIPADST_ADST }, + [TXTP_SET_ALL] = { IDTX, V_DCT, H_DCT, V_ADST, H_ADST, V_FLIPADST, + H_FLIPADST, DCT_DCT, ADST_DCT, DCT_ADST, + FLIPADST_DCT, DCT_FLIPADST, ADST_ADST, + FLIPADST_FLIPADST, ADST_FLIPADST, FLIPADST_ADST }, + [TXTP_SET_LOSSLESS] = { WHT_WHT }, +}; + +const uint8_t av1_tx_type_set_index[2][N_TXTP_SETS] = { + { 0, -1, 2, 1, -1, -1, 3 }, + { 0, 3, -1, -1, 2, 1, 4 }, +}; + +const uint8_t av1_ymode_size_context[N_BS_SIZES] = { + [BS_128x128] = 3, + [BS_128x64] = 3, + [BS_64x128] = 3, + [BS_64x64] = 3, + [BS_64x32] = 3, + [BS_64x16] = 2, + [BS_32x64] = 3, + [BS_32x32] = 3, + [BS_32x16] = 2, + [BS_32x8 ] = 1, + [BS_16x64] = 2, + [BS_16x32] = 2, + [BS_16x16] = 2, + [BS_16x8 ] = 1, + [BS_16x4 ] = 0, + [BS_8x32 ] = 1, + [BS_8x16 ] = 1, + [BS_8x8 ] = 1, + [BS_8x4 ] = 0, + [BS_4x16 ] = 0, + [BS_4x8 ] = 0, + [BS_4x4 ] = 0, +}; + +const uint8_t av1_nz_map_ctx_offset[N_RECT_TX_SIZES][5][5] = { + [TX_4X4] = { + { 0, 1, 6, 6 }, + { 1, 6, 6, 21 }, + { 6, 6, 21, 21 }, + { 6, 21, 21, 21 }, + }, [TX_8X8] = { + { 0, 1, 6, 6, 21 }, + { 1, 6, 6, 21, 21 }, + { 6, 6, 21, 21, 21 }, + { 6, 21, 21, 21, 21 }, + { 21, 21, 21, 21, 21 } + }, [TX_16X16] = { + { 0, 1, 6, 6, 21 }, + { 1, 6, 6, 21, 21 }, + { 6, 6, 21, 21, 21 }, + { 6, 21, 21, 21, 21 }, + { 21, 21, 21, 21, 21 } + }, [TX_32X32] = { + { 0, 1, 6, 6, 21 }, + { 1, 6, 6, 21, 21 }, + { 6, 6, 21, 21, 21 }, + { 6, 21, 21, 21, 21 }, + { 21, 21, 21, 21, 21 } + }, [TX_64X64] = { + { 0, 1, 6, 6, 21 }, + { 1, 6, 6, 21, 21 }, + { 6, 6, 21, 21, 21 }, + { 6, 21, 21, 21, 21 }, + { 21, 21, 21, 21, 21 } + }, [RTX_4X8] = { + { 0, 11, 11, 11 }, + { 11, 11, 11, 11 }, + { 6, 6, 21, 21 }, + { 6, 21, 21, 21 }, + { 21, 21, 21, 21 } + }, [RTX_8X4] = { + { 0, 16, 6, 6, 21 }, + { 16, 16, 6, 21, 21 }, + { 16, 16, 21, 21, 21 }, + { 16, 16, 21, 21, 21 }, + }, [RTX_8X16] = { + { 0, 11, 11, 11, 11 }, + { 11, 11, 11, 11, 11 }, + { 6, 6, 21, 21, 21 }, + { 6, 21, 21, 21, 21 }, + { 21, 21, 21, 21, 21 } + }, [RTX_16X8] = { + { 0, 16, 6, 6, 21 }, + { 16, 16, 6, 21, 21 }, + { 16, 16, 21, 21, 21 }, + { 16, 16, 21, 21, 21 }, + { 16, 16, 21, 21, 21 } + }, [RTX_16X32] = { + { 0, 11, 11, 11, 11 }, + { 11, 11, 11, 11, 11 }, + { 6, 6, 21, 21, 21 }, + { 6, 21, 21, 21, 21 }, + { 21, 21, 21, 21, 21 } + }, [RTX_32X16] = { + { 0, 16, 6, 6, 21 }, + { 16, 16, 6, 21, 21 }, + { 16, 16, 21, 21, 21 }, + { 16, 16, 21, 21, 21 }, + { 16, 16, 21, 21, 21 } + }, [RTX_32X64] = { + { 0, 11, 11, 11, 11 }, + { 11, 11, 11, 11, 11 }, + { 6, 6, 21, 21, 21 }, + { 6, 21, 21, 21, 21 }, + { 21, 21, 21, 21, 21 } + }, [RTX_64X32] = { + { 0, 16, 6, 6, 21 }, + { 16, 16, 6, 21, 21 }, + { 16, 16, 21, 21, 21 }, + { 16, 16, 21, 21, 21 }, + { 16, 16, 21, 21, 21 } + }, [RTX_4X16] = { + { 0, 11, 11, 11 }, + { 11, 11, 11, 11 }, + { 6, 6, 21, 21 }, + { 6, 21, 21, 21 }, + { 21, 21, 21, 21 } + }, [RTX_16X4] = { + { 0, 16, 6, 6, 21 }, + { 16, 16, 6, 21, 21 }, + { 16, 16, 21, 21, 21 }, + { 16, 16, 21, 21, 21 }, + }, [RTX_8X32] = { + { 0, 11, 11, 11, 11 }, + { 11, 11, 11, 11, 11 }, + { 6, 6, 21, 21, 21 }, + { 6, 21, 21, 21, 21 }, + { 21, 21, 21, 21, 21 } + }, [RTX_32X8] = { + { 0, 16, 6, 6, 21 }, + { 16, 16, 6, 21, 21 }, + { 16, 16, 21, 21, 21 }, + { 16, 16, 21, 21, 21 }, + { 16, 16, 21, 21, 21 } + }, [RTX_16X64] = { + { 0, 11, 11, 11, 11 }, + { 11, 11, 11, 11, 11 }, + { 6, 6, 21, 21, 21 }, + { 6, 21, 21, 21, 21 }, + { 21, 21, 21, 21, 21 } + }, [RTX_64X16] = { + { 0, 16, 6, 6, 21 }, + { 16, 16, 6, 21, 21 }, + { 16, 16, 21, 21, 21 }, + { 16, 16, 21, 21, 21 }, + { 16, 16, 21, 21, 21 } + } +}; + +const uint8_t /* enum TxClass */ av1_tx_type_class[N_TX_TYPES_PLUS_LL] = { + [DCT_DCT] = TX_CLASS_2D, + [ADST_DCT] = TX_CLASS_2D, + [DCT_ADST] = TX_CLASS_2D, + [ADST_ADST] = TX_CLASS_2D, + [FLIPADST_DCT] = TX_CLASS_2D, + [DCT_FLIPADST] = TX_CLASS_2D, + [FLIPADST_FLIPADST] = TX_CLASS_2D, + [ADST_FLIPADST] = TX_CLASS_2D, + [FLIPADST_ADST] = TX_CLASS_2D, + [IDTX] = TX_CLASS_2D, + [V_DCT] = TX_CLASS_V, + [H_DCT] = TX_CLASS_H, + [V_ADST] = TX_CLASS_V, + [H_ADST] = TX_CLASS_H, + [V_FLIPADST] = TX_CLASS_V, + [H_FLIPADST] = TX_CLASS_H, + [WHT_WHT] = TX_CLASS_2D, +}; + +const uint8_t /* enum Filter2d */ av1_filter_2d[N_FILTERS][N_FILTERS] = { + [FILTER_8TAP_REGULAR] = { + [FILTER_8TAP_REGULAR] = FILTER_2D_8TAP_REGULAR, + [FILTER_8TAP_SHARP] = FILTER_2D_8TAP_REGULAR_SHARP, + [FILTER_8TAP_SMOOTH] = FILTER_2D_8TAP_REGULAR_SMOOTH, + }, [FILTER_8TAP_SHARP] = { + [FILTER_8TAP_REGULAR] = FILTER_2D_8TAP_SHARP_REGULAR, + [FILTER_8TAP_SHARP] = FILTER_2D_8TAP_SHARP, + [FILTER_8TAP_SMOOTH] = FILTER_2D_8TAP_SHARP_SMOOTH, + }, [FILTER_8TAP_SMOOTH] = { + [FILTER_8TAP_REGULAR] = FILTER_2D_8TAP_SMOOTH_REGULAR, + [FILTER_8TAP_SHARP] = FILTER_2D_8TAP_SMOOTH_SHARP, + [FILTER_8TAP_SMOOTH] = FILTER_2D_8TAP_SMOOTH, + }, [FILTER_BILINEAR] = { + [FILTER_BILINEAR] = FILTER_2D_BILINEAR, + } +}; + +const uint8_t /* enum FilterMode */ eve_av1_filter_dir[N_2D_FILTERS][2] = { + [FILTER_2D_8TAP_REGULAR] = { FILTER_8TAP_REGULAR, FILTER_8TAP_REGULAR }, + [FILTER_2D_8TAP_REGULAR_SMOOTH] = { FILTER_8TAP_SMOOTH, FILTER_8TAP_REGULAR }, + [FILTER_2D_8TAP_REGULAR_SHARP] = { FILTER_8TAP_SHARP, FILTER_8TAP_REGULAR }, + [FILTER_2D_8TAP_SHARP_REGULAR] = { FILTER_8TAP_REGULAR, FILTER_8TAP_SHARP }, + [FILTER_2D_8TAP_SHARP_SMOOTH] = { FILTER_8TAP_SMOOTH, FILTER_8TAP_SHARP }, + [FILTER_2D_8TAP_SHARP] = { FILTER_8TAP_SHARP, FILTER_8TAP_SHARP }, + [FILTER_2D_8TAP_SMOOTH_REGULAR] = { FILTER_8TAP_REGULAR, FILTER_8TAP_SMOOTH }, + [FILTER_2D_8TAP_SMOOTH] = { FILTER_8TAP_SMOOTH, FILTER_8TAP_SMOOTH }, + [FILTER_2D_8TAP_SMOOTH_SHARP] = { FILTER_8TAP_SHARP, FILTER_8TAP_SMOOTH }, + [FILTER_2D_BILINEAR] = { FILTER_2D_BILINEAR, FILTER_2D_BILINEAR }, +}; + +const uint8_t av1_filter_mode_to_y_mode[5] = { + DC_PRED, VERT_PRED, HOR_PRED, HOR_DOWN_PRED, DC_PRED +}; + +const uint8_t intra_mode_context[N_INTRA_PRED_MODES] = { + [DC_PRED] = 0, + [VERT_PRED] = 1, + [HOR_PRED] = 2, + [DIAG_DOWN_LEFT_PRED] = 3, + [DIAG_DOWN_RIGHT_PRED] = 4, + [VERT_RIGHT_PRED] = 4, + [HOR_DOWN_PRED] = 4, + [HOR_UP_PRED] = 4, + [VERT_LEFT_PRED] = 3, + [SMOOTH_PRED] = 0, + [SMOOTH_V_PRED] = 1, + [SMOOTH_H_PRED] = 2, + [PAETH_PRED] = 0, +}; + +const unsigned cfl_allowed_mask = + (1 << BS_32x32) | + (1 << BS_32x16) | + (1 << BS_32x8) | + (1 << BS_16x32) | + (1 << BS_16x16) | + (1 << BS_16x8) | + (1 << BS_16x4) | + (1 << BS_8x32) | + (1 << BS_8x16) | + (1 << BS_8x8) | + (1 << BS_8x4) | + (1 << BS_4x16) | + (1 << BS_4x8) | + (1 << BS_4x4); + +const unsigned wedge_allowed_mask = + (1 << BS_32x32) | + (1 << BS_32x16) | + (1 << BS_32x8) | + (1 << BS_16x32) | + (1 << BS_16x16) | + (1 << BS_16x8) | + (1 << BS_8x32) | + (1 << BS_8x16) | + (1 << BS_8x8); + +const unsigned interintra_allowed_mask = + (1 << BS_32x32) | + (1 << BS_32x16) | + (1 << BS_16x32) | + (1 << BS_16x16) | + (1 << BS_16x8) | + (1 << BS_8x16) | + (1 << BS_8x8); + +const uint8_t av1_wedge_ctx_lut[N_BS_SIZES] = { + [BS_32x32] = 6, + [BS_32x16] = 5, + [BS_32x8] = 8, + [BS_16x32] = 4, + [BS_16x16] = 3, + [BS_16x8] = 2, + [BS_8x32] = 7, + [BS_8x16] = 1, + [BS_8x8] = 0, +}; + +const WarpedMotionParams default_wm_params = { + .type = WM_TYPE_IDENTITY, + .matrix = { + 0, 0, 1 << 16, + 0, 0, 1 << 16, + }, + .alpha = 0, + .beta = 0, + .gamma = 0, + .delta = 0, +}; + +const int16_t sgr_params[16][4] = { // r0, r1, e0, e1 + { 2, 1, 140, 3236 }, { 2, 1, 112, 2158 }, { 2, 1, 93, 1618 }, + { 2, 1, 80, 1438 }, { 2, 1, 70, 1295 }, { 2, 1, 58, 1177 }, + { 2, 1, 47, 1079 }, { 2, 1, 37, 996 }, { 2, 1, 30, 925 }, + { 2, 1, 25, 863 }, { 0, 1, -1, 2589 }, { 0, 1, -1, 1618 }, + { 0, 1, -1, 1177 }, { 0, 1, -1, 925 }, { 2, 0, 56, -1 }, + { 2, 0, 22, -1 }, +}; + +const int16_t sgr_x_by_xplus1[256] = { + 1, 128, 171, 192, 205, 213, 219, 224, 228, 230, 233, 235, 236, 238, 239, + 240, 241, 242, 243, 243, 244, 244, 245, 245, 246, 246, 247, 247, 247, 247, + 248, 248, 248, 248, 249, 249, 249, 249, 249, 250, 250, 250, 250, 250, 250, + 250, 251, 251, 251, 251, 251, 251, 251, 251, 251, 251, 252, 252, 252, 252, + 252, 252, 252, 252, 252, 252, 252, 252, 252, 252, 252, 252, 252, 253, 253, + 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, + 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 254, 254, 254, + 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, + 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, + 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, + 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, + 254, 254, 254, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 256, +}; + +const int16_t sgr_one_by_x[] = { + 4096, 2048, 1365, 1024, 819, 683, 585, 512, 455, 410, 372, 341, 315, + 293, 273, 256, 241, 228, 216, 205, 195, 186, 178, 171, 164, +}; + +const int8_t dav1d_mc_subpel_filters[5][15][8] = { + [FILTER_8TAP_REGULAR] = { + { 0, 2, -6, 126, 8, -2, 0, 0 }, + { 0, 2, -10, 122, 18, -4, 0, 0 }, + { 0, 2, -12, 116, 28, -8, 2, 0 }, + { 0, 2, -14, 110, 38, -10, 2, 0 }, + { 0, 2, -14, 102, 48, -12, 2, 0 }, + { 0, 2, -16, 94, 58, -12, 2, 0 }, + { 0, 2, -14, 84, 66, -12, 2, 0 }, + { 0, 2, -14, 76, 76, -14, 2, 0 }, + { 0, 2, -12, 66, 84, -14, 2, 0 }, + { 0, 2, -12, 58, 94, -16, 2, 0 }, + { 0, 2, -12, 48, 102, -14, 2, 0 }, + { 0, 2, -10, 38, 110, -14, 2, 0 }, + { 0, 2, -8, 28, 116, -12, 2, 0 }, + { 0, 0, -4, 18, 122, -10, 2, 0 }, + { 0, 0, -2, 8, 126, -6, 2, 0 } + }, [FILTER_8TAP_SHARP] = { + { -2, 2, -6, 126, 8, -2, 2, 0 }, + { -2, 6, -12, 124, 16, -6, 4, -2 }, + { -2, 8, -18, 120, 26, -10, 6, -2 }, + { -4, 10, -22, 116, 38, -14, 6, -2 }, + { -4, 10, -22, 108, 48, -18, 8, -2 }, + { -4, 10, -24, 100, 60, -20, 8, -2 }, + { -4, 10, -24, 90, 70, -22, 10, -2 }, + { -4, 12, -24, 80, 80, -24, 12, -4 }, + { -2, 10, -22, 70, 90, -24, 10, -4 }, + { -2, 8, -20, 60, 100, -24, 10, -4 }, + { -2, 8, -18, 48, 108, -22, 10, -4 }, + { -2, 6, -14, 38, 116, -22, 10, -4 }, + { -2, 6, -10, 26, 120, -18, 8, -2 }, + { -2, 4, -6, 16, 124, -12, 6, -2 }, + { 0, 2, -2, 8, 126, -6, 2, -2 } + }, [FILTER_8TAP_SMOOTH] = { + { 0, 2, 28, 62, 34, 2, 0, 0 }, + { 0, 0, 26, 62, 36, 4, 0, 0 }, + { 0, 0, 22, 62, 40, 4, 0, 0 }, + { 0, 0, 20, 60, 42, 6, 0, 0 }, + { 0, 0, 18, 58, 44, 8, 0, 0 }, + { 0, 0, 16, 56, 46, 10, 0, 0 }, + { 0, -2, 16, 54, 48, 12, 0, 0 }, + { 0, -2, 14, 52, 52, 14, -2, 0 }, + { 0, 0, 12, 48, 54, 16, -2, 0 }, + { 0, 0, 10, 46, 56, 16, 0, 0 }, + { 0, 0, 8, 44, 58, 18, 0, 0 }, + { 0, 0, 6, 42, 60, 20, 0, 0 }, + { 0, 0, 4, 40, 62, 22, 0, 0 }, + { 0, 0, 4, 36, 62, 26, 0, 0 }, + { 0, 0, 2, 34, 62, 28, 2, 0 }, + }, + /* width <= 4 */ + [3 + FILTER_8TAP_REGULAR] = { + { 0, 0, -4, 126, 8, -2, 0, 0 }, + { 0, 0, -8, 122, 18, -4, 0, 0 }, + { 0, 0, -10, 116, 28, -6, 0, 0 }, + { 0, 0, -12, 110, 38, -8, 0, 0 }, + { 0, 0, -12, 102, 48, -10, 0, 0 }, + { 0, 0, -14, 94, 58, -10, 0, 0 }, + { 0, 0, -12, 84, 66, -10, 0, 0 }, + { 0, 0, -12, 76, 76, -12, 0, 0 }, + { 0, 0, -10, 66, 84, -12, 0, 0 }, + { 0, 0, -10, 58, 94, -14, 0, 0 }, + { 0, 0, -10, 48, 102, -12, 0, 0 }, + { 0, 0, -8, 38, 110, -12, 0, 0 }, + { 0, 0, -6, 28, 116, -10, 0, 0 }, + { 0, 0, -4, 18, 122, -8, 0, 0 }, + { 0, 0, -2, 8, 126, -4, 0, 0 } + }, [3 + FILTER_8TAP_SMOOTH] = { + { 0, 0, 30, 62, 34, 2, 0, 0 }, + { 0, 0, 26, 62, 36, 4, 0, 0 }, + { 0, 0, 22, 62, 40, 4, 0, 0 }, + { 0, 0, 20, 60, 42, 6, 0, 0 }, + { 0, 0, 18, 58, 44, 8, 0, 0 }, + { 0, 0, 16, 56, 46, 10, 0, 0 }, + { 0, 0, 14, 54, 48, 12, 0, 0 }, + { 0, 0, 12, 52, 52, 12, 0, 0 }, + { 0, 0, 12, 48, 54, 14, 0, 0 }, + { 0, 0, 10, 46, 56, 16, 0, 0 }, + { 0, 0, 8, 44, 58, 18, 0, 0 }, + { 0, 0, 6, 42, 60, 20, 0, 0 }, + { 0, 0, 4, 40, 62, 22, 0, 0 }, + { 0, 0, 4, 36, 62, 26, 0, 0 }, + { 0, 0, 2, 34, 62, 30, 0, 0 } + } +}; + +const int8_t dav1d_mc_warp_filter[][8] = { + // [-1, 0) + { 0, 0, 127, 1, 0, 0, 0, 0 }, { 0, - 1, 127, 2, 0, 0, 0, 0 }, + { 1, - 3, 127, 4, - 1, 0, 0, 0 }, { 1, - 4, 126, 6, - 2, 1, 0, 0 }, + { 1, - 5, 126, 8, - 3, 1, 0, 0 }, { 1, - 6, 125, 11, - 4, 1, 0, 0 }, + { 1, - 7, 124, 13, - 4, 1, 0, 0 }, { 2, - 8, 123, 15, - 5, 1, 0, 0 }, + { 2, - 9, 122, 18, - 6, 1, 0, 0 }, { 2, -10, 121, 20, - 6, 1, 0, 0 }, + { 2, -11, 120, 22, - 7, 2, 0, 0 }, { 2, -12, 119, 25, - 8, 2, 0, 0 }, + { 3, -13, 117, 27, - 8, 2, 0, 0 }, { 3, -13, 116, 29, - 9, 2, 0, 0 }, + { 3, -14, 114, 32, -10, 3, 0, 0 }, { 3, -15, 113, 35, -10, 2, 0, 0 }, + { 3, -15, 111, 37, -11, 3, 0, 0 }, { 3, -16, 109, 40, -11, 3, 0, 0 }, + { 3, -16, 108, 42, -12, 3, 0, 0 }, { 4, -17, 106, 45, -13, 3, 0, 0 }, + { 4, -17, 104, 47, -13, 3, 0, 0 }, { 4, -17, 102, 50, -14, 3, 0, 0 }, + { 4, -17, 100, 52, -14, 3, 0, 0 }, { 4, -18, 98, 55, -15, 4, 0, 0 }, + { 4, -18, 96, 58, -15, 3, 0, 0 }, { 4, -18, 94, 60, -16, 4, 0, 0 }, + { 4, -18, 91, 63, -16, 4, 0, 0 }, { 4, -18, 89, 65, -16, 4, 0, 0 }, + { 4, -18, 87, 68, -17, 4, 0, 0 }, { 4, -18, 85, 70, -17, 4, 0, 0 }, + { 4, -18, 82, 73, -17, 4, 0, 0 }, { 4, -18, 80, 75, -17, 4, 0, 0 }, + { 4, -18, 78, 78, -18, 4, 0, 0 }, { 4, -17, 75, 80, -18, 4, 0, 0 }, + { 4, -17, 73, 82, -18, 4, 0, 0 }, { 4, -17, 70, 85, -18, 4, 0, 0 }, + { 4, -17, 68, 87, -18, 4, 0, 0 }, { 4, -16, 65, 89, -18, 4, 0, 0 }, + { 4, -16, 63, 91, -18, 4, 0, 0 }, { 4, -16, 60, 94, -18, 4, 0, 0 }, + { 3, -15, 58, 96, -18, 4, 0, 0 }, { 4, -15, 55, 98, -18, 4, 0, 0 }, + { 3, -14, 52, 100, -17, 4, 0, 0 }, { 3, -14, 50, 102, -17, 4, 0, 0 }, + { 3, -13, 47, 104, -17, 4, 0, 0 }, { 3, -13, 45, 106, -17, 4, 0, 0 }, + { 3, -12, 42, 108, -16, 3, 0, 0 }, { 3, -11, 40, 109, -16, 3, 0, 0 }, + { 3, -11, 37, 111, -15, 3, 0, 0 }, { 2, -10, 35, 113, -15, 3, 0, 0 }, + { 3, -10, 32, 114, -14, 3, 0, 0 }, { 2, - 9, 29, 116, -13, 3, 0, 0 }, + { 2, - 8, 27, 117, -13, 3, 0, 0 }, { 2, - 8, 25, 119, -12, 2, 0, 0 }, + { 2, - 7, 22, 120, -11, 2, 0, 0 }, { 1, - 6, 20, 121, -10, 2, 0, 0 }, + { 1, - 6, 18, 122, - 9, 2, 0, 0 }, { 1, - 5, 15, 123, - 8, 2, 0, 0 }, + { 1, - 4, 13, 124, - 7, 1, 0, 0 }, { 1, - 4, 11, 125, - 6, 1, 0, 0 }, + { 1, - 3, 8, 126, - 5, 1, 0, 0 }, { 1, - 2, 6, 126, - 4, 1, 0, 0 }, + { 0, - 1, 4, 127, - 3, 1, 0, 0 }, { 0, 0, 2, 127, - 1, 0, 0, 0 }, + + // [0, 1) + { 0, 0, 0, 127, 1, 0, 0, 0}, { 0, 0, -1, 127, 2, 0, 0, 0}, + { 0, 1, -3, 127, 4, -2, 1, 0}, { 0, 1, -5, 127, 6, -2, 1, 0}, + { 0, 2, -6, 126, 8, -3, 1, 0}, {-1, 2, -7, 126, 11, -4, 2, -1}, + {-1, 3, -8, 125, 13, -5, 2, -1}, {-1, 3, -10, 124, 16, -6, 3, -1}, + {-1, 4, -11, 123, 18, -7, 3, -1}, {-1, 4, -12, 122, 20, -7, 3, -1}, + {-1, 4, -13, 121, 23, -8, 3, -1}, {-2, 5, -14, 120, 25, -9, 4, -1}, + {-1, 5, -15, 119, 27, -10, 4, -1}, {-1, 5, -16, 118, 30, -11, 4, -1}, + {-2, 6, -17, 116, 33, -12, 5, -1}, {-2, 6, -17, 114, 35, -12, 5, -1}, + {-2, 6, -18, 113, 38, -13, 5, -1}, {-2, 7, -19, 111, 41, -14, 6, -2}, + {-2, 7, -19, 110, 43, -15, 6, -2}, {-2, 7, -20, 108, 46, -15, 6, -2}, + {-2, 7, -20, 106, 49, -16, 6, -2}, {-2, 7, -21, 104, 51, -16, 7, -2}, + {-2, 7, -21, 102, 54, -17, 7, -2}, {-2, 8, -21, 100, 56, -18, 7, -2}, + {-2, 8, -22, 98, 59, -18, 7, -2}, {-2, 8, -22, 96, 62, -19, 7, -2}, + {-2, 8, -22, 94, 64, -19, 7, -2}, {-2, 8, -22, 91, 67, -20, 8, -2}, + {-2, 8, -22, 89, 69, -20, 8, -2}, {-2, 8, -22, 87, 72, -21, 8, -2}, + {-2, 8, -21, 84, 74, -21, 8, -2}, {-2, 8, -22, 82, 77, -21, 8, -2}, + {-2, 8, -21, 79, 79, -21, 8, -2}, {-2, 8, -21, 77, 82, -22, 8, -2}, + {-2, 8, -21, 74, 84, -21, 8, -2}, {-2, 8, -21, 72, 87, -22, 8, -2}, + {-2, 8, -20, 69, 89, -22, 8, -2}, {-2, 8, -20, 67, 91, -22, 8, -2}, + {-2, 7, -19, 64, 94, -22, 8, -2}, {-2, 7, -19, 62, 96, -22, 8, -2}, + {-2, 7, -18, 59, 98, -22, 8, -2}, {-2, 7, -18, 56, 100, -21, 8, -2}, + {-2, 7, -17, 54, 102, -21, 7, -2}, {-2, 7, -16, 51, 104, -21, 7, -2}, + {-2, 6, -16, 49, 106, -20, 7, -2}, {-2, 6, -15, 46, 108, -20, 7, -2}, + {-2, 6, -15, 43, 110, -19, 7, -2}, {-2, 6, -14, 41, 111, -19, 7, -2}, + {-1, 5, -13, 38, 113, -18, 6, -2}, {-1, 5, -12, 35, 114, -17, 6, -2}, + {-1, 5, -12, 33, 116, -17, 6, -2}, {-1, 4, -11, 30, 118, -16, 5, -1}, + {-1, 4, -10, 27, 119, -15, 5, -1}, {-1, 4, -9, 25, 120, -14, 5, -2}, + {-1, 3, -8, 23, 121, -13, 4, -1}, {-1, 3, -7, 20, 122, -12, 4, -1}, + {-1, 3, -7, 18, 123, -11, 4, -1}, {-1, 3, -6, 16, 124, -10, 3, -1}, + {-1, 2, -5, 13, 125, -8, 3, -1}, {-1, 2, -4, 11, 126, -7, 2, -1}, + { 0, 1, -3, 8, 126, -6, 2, 0}, { 0, 1, -2, 6, 127, -5, 1, 0}, + { 0, 1, -2, 4, 127, -3, 1, 0}, { 0, 0, 0, 2, 127, -1, 0, 0}, + + // [1, 2) + { 0, 0, 0, 1, 127, 0, 0, 0 }, { 0, 0, 0, - 1, 127, 2, 0, 0 }, + { 0, 0, 1, - 3, 127, 4, - 1, 0 }, { 0, 0, 1, - 4, 126, 6, - 2, 1 }, + { 0, 0, 1, - 5, 126, 8, - 3, 1 }, { 0, 0, 1, - 6, 125, 11, - 4, 1 }, + { 0, 0, 1, - 7, 124, 13, - 4, 1 }, { 0, 0, 2, - 8, 123, 15, - 5, 1 }, + { 0, 0, 2, - 9, 122, 18, - 6, 1 }, { 0, 0, 2, -10, 121, 20, - 6, 1 }, + { 0, 0, 2, -11, 120, 22, - 7, 2 }, { 0, 0, 2, -12, 119, 25, - 8, 2 }, + { 0, 0, 3, -13, 117, 27, - 8, 2 }, { 0, 0, 3, -13, 116, 29, - 9, 2 }, + { 0, 0, 3, -14, 114, 32, -10, 3 }, { 0, 0, 3, -15, 113, 35, -10, 2 }, + { 0, 0, 3, -15, 111, 37, -11, 3 }, { 0, 0, 3, -16, 109, 40, -11, 3 }, + { 0, 0, 3, -16, 108, 42, -12, 3 }, { 0, 0, 4, -17, 106, 45, -13, 3 }, + { 0, 0, 4, -17, 104, 47, -13, 3 }, { 0, 0, 4, -17, 102, 50, -14, 3 }, + { 0, 0, 4, -17, 100, 52, -14, 3 }, { 0, 0, 4, -18, 98, 55, -15, 4 }, + { 0, 0, 4, -18, 96, 58, -15, 3 }, { 0, 0, 4, -18, 94, 60, -16, 4 }, + { 0, 0, 4, -18, 91, 63, -16, 4 }, { 0, 0, 4, -18, 89, 65, -16, 4 }, + { 0, 0, 4, -18, 87, 68, -17, 4 }, { 0, 0, 4, -18, 85, 70, -17, 4 }, + { 0, 0, 4, -18, 82, 73, -17, 4 }, { 0, 0, 4, -18, 80, 75, -17, 4 }, + { 0, 0, 4, -18, 78, 78, -18, 4 }, { 0, 0, 4, -17, 75, 80, -18, 4 }, + { 0, 0, 4, -17, 73, 82, -18, 4 }, { 0, 0, 4, -17, 70, 85, -18, 4 }, + { 0, 0, 4, -17, 68, 87, -18, 4 }, { 0, 0, 4, -16, 65, 89, -18, 4 }, + { 0, 0, 4, -16, 63, 91, -18, 4 }, { 0, 0, 4, -16, 60, 94, -18, 4 }, + { 0, 0, 3, -15, 58, 96, -18, 4 }, { 0, 0, 4, -15, 55, 98, -18, 4 }, + { 0, 0, 3, -14, 52, 100, -17, 4 }, { 0, 0, 3, -14, 50, 102, -17, 4 }, + { 0, 0, 3, -13, 47, 104, -17, 4 }, { 0, 0, 3, -13, 45, 106, -17, 4 }, + { 0, 0, 3, -12, 42, 108, -16, 3 }, { 0, 0, 3, -11, 40, 109, -16, 3 }, + { 0, 0, 3, -11, 37, 111, -15, 3 }, { 0, 0, 2, -10, 35, 113, -15, 3 }, + { 0, 0, 3, -10, 32, 114, -14, 3 }, { 0, 0, 2, - 9, 29, 116, -13, 3 }, + { 0, 0, 2, - 8, 27, 117, -13, 3 }, { 0, 0, 2, - 8, 25, 119, -12, 2 }, + { 0, 0, 2, - 7, 22, 120, -11, 2 }, { 0, 0, 1, - 6, 20, 121, -10, 2 }, + { 0, 0, 1, - 6, 18, 122, - 9, 2 }, { 0, 0, 1, - 5, 15, 123, - 8, 2 }, + { 0, 0, 1, - 4, 13, 124, - 7, 1 }, { 0, 0, 1, - 4, 11, 125, - 6, 1 }, + { 0, 0, 1, - 3, 8, 126, - 5, 1 }, { 0, 0, 1, - 2, 6, 126, - 4, 1 }, + { 0, 0, 0, - 1, 4, 127, - 3, 1 }, { 0, 0, 0, 0, 2, 127, - 1, 0 }, + + // dummy (replicate row index 191) + { 0, 0, 0, 0, 2, 127, - 1, 0 }, +}; diff --git a/src/tables.h b/src/tables.h new file mode 100644 index 0000000..6d45d50 --- /dev/null +++ b/src/tables.h @@ -0,0 +1,84 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_SRC_TABLES_H__ +#define __DAV1D_SRC_TABLES_H__ + +#include <stdint.h> + +#include "common/intops.h" + +#include "src/levels.h" + +extern const uint8_t av1_al_part_ctx[2][N_BL_LEVELS][N_PARTITIONS]; +extern const uint8_t /* enum BlockSize */ + av1_block_sizes[N_BL_LEVELS][N_PARTITIONS][2]; +// width, height (in 4px blocks), log2 versions of these two +extern const uint8_t av1_block_dimensions[N_BS_SIZES][4]; +typedef struct TxfmInfo { + // width, height (in 4px blocks), log2 of them, min/max of log2, sub, pad + uint8_t w, h, lw, lh, min, max, sub, ctx; +} TxfmInfo; +extern const TxfmInfo av1_txfm_dimensions[N_RECT_TX_SIZES]; +extern const uint8_t /* enum (Rect)TxfmSize */ + av1_max_txfm_size_for_bs[N_BS_SIZES][4 /* y, 420, 422, 444 */]; +extern const uint8_t /* enum TxfmType */ + av1_txtp_from_uvmode[N_UV_INTRA_PRED_MODES]; + +extern const uint8_t /* enum InterPredMode */ + av1_comp_inter_pred_modes[N_COMP_INTER_PRED_MODES][2]; + +extern const uint8_t av1_tx_type_count[N_TXTP_SETS]; +extern const uint8_t /* enum TxfmType */ + av1_tx_types_per_set[N_TXTP_SETS][N_TX_TYPES]; +extern const uint8_t av1_tx_type_set_index[2][N_TXTP_SETS]; + +extern const uint8_t av1_filter_mode_to_y_mode[5]; +extern const uint8_t av1_ymode_size_context[N_BS_SIZES]; +extern const uint8_t av1_nz_map_ctx_offset[N_RECT_TX_SIZES][5][5]; +extern const uint8_t /* enum TxClass */ + av1_tx_type_class[N_TX_TYPES_PLUS_LL]; +extern const uint8_t /* enum Filter2d */ + av1_filter_2d[N_FILTERS /* h */][N_FILTERS /* v */]; +extern const uint8_t /* enum FilterMode */ eve_av1_filter_dir[N_2D_FILTERS][2]; +extern const uint8_t intra_mode_context[N_INTRA_PRED_MODES]; +extern const uint8_t av1_wedge_ctx_lut[N_BS_SIZES]; + +extern const unsigned cfl_allowed_mask; +extern const unsigned wedge_allowed_mask; +extern const unsigned interintra_allowed_mask; + +extern const WarpedMotionParams default_wm_params; + +extern const int16_t sgr_params[16][4]; +extern const int16_t sgr_x_by_xplus1[256]; +extern const int16_t sgr_one_by_x[25]; + +extern const int8_t dav1d_mc_subpel_filters[5][15][8]; +extern const int8_t dav1d_mc_warp_filter[][8]; + +#endif /* __DAV1D_SRC_TABLES_H__ */ diff --git a/src/thread_data.h b/src/thread_data.h new file mode 100644 index 0000000..8736189 --- /dev/null +++ b/src/thread_data.h @@ -0,0 +1,37 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_SRC_THREAD_DATA_H__ +#define __DAV1D_SRC_THREAD_DATA_H__ + +struct thread_data { + pthread_t thread; + pthread_cond_t cond; + pthread_mutex_t lock; +}; + +#endif /* __DAV1D_SRC_THREAD_DATA_H__ */ diff --git a/src/thread_task.c b/src/thread_task.c new file mode 100644 index 0000000..3ef739f --- /dev/null +++ b/src/thread_task.c @@ -0,0 +1,137 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include "src/thread_task.h" + +void *dav1d_frame_task(void *const data) { + Dav1dFrameContext *const f = data; + + for (;;) { + pthread_mutex_lock(&f->frame_thread.td.lock); + f->n_tile_data = 0; + int did_signal = 0; + while (!f->n_tile_data && !f->frame_thread.die) { + if (!did_signal) { + did_signal = 1; + pthread_cond_signal(&f->frame_thread.td.cond); + } + pthread_cond_wait(&f->frame_thread.td.cond, + &f->frame_thread.td.lock); + } + if (f->frame_thread.die) { + pthread_mutex_unlock(&f->frame_thread.td.lock); + break; + } + pthread_mutex_unlock(&f->frame_thread.td.lock); + + decode_frame(f); + } + + pthread_exit(NULL); + return NULL; +} + +void *dav1d_tile_task(void *const data) { + Dav1dTileContext *const t = data; + struct FrameTileThreadData *const fttd = t->tile_thread.fttd; + const Dav1dFrameContext *const f = t->f; + const int tile_thread_idx = t - f->tc; + const uint64_t mask = 1ULL << tile_thread_idx; + + for (;;) { + pthread_mutex_lock(&fttd->lock); + fttd->available |= mask; + int did_signal = 0; + while (!fttd->tasks_left && !t->tile_thread.die) { + if (!did_signal) { + did_signal = 1; + pthread_cond_signal(&fttd->icond); + } + pthread_cond_wait(&fttd->cond, &fttd->lock); + } + if (t->tile_thread.die) { + pthread_mutex_unlock(&fttd->lock); + break; + } + fttd->available &= ~mask; + const int task_idx = fttd->num_tasks - fttd->tasks_left--; + pthread_mutex_unlock(&fttd->lock); + + if (f->frame_thread.pass == 1 || f->n_tc >= f->frame_hdr.tiling.cols) { + // we can (or in fact, if >, we need to) do full tile decoding. + // loopfilter happens in the main thread + Dav1dTileState *const ts = t->ts = &f->ts[task_idx]; + for (t->by = ts->tiling.row_start; t->by < ts->tiling.row_end; + t->by += f->sb_step) + { + decode_tile_sbrow(t); + + // signal progress + pthread_mutex_lock(&ts->tile_thread.lock); + atomic_store(&ts->progress, 1 + (t->by >> f->sb_shift)); + pthread_cond_signal(&ts->tile_thread.cond); + pthread_mutex_unlock(&ts->tile_thread.lock); + } + } else { + const int sby = f->tile_thread.task_idx_to_sby_and_tile_idx[task_idx][0]; + const int tile_idx = f->tile_thread.task_idx_to_sby_and_tile_idx[task_idx][1]; + Dav1dTileState *const ts = &f->ts[tile_idx]; + + // the interleaved decoding can sometimes cause dependency issues + // if one part of the frame decodes signifcantly faster than others. + // Ideally, we'd "skip" tile_sbrows where dependencies are missing, + // and resume them later as dependencies are met. This also would + // solve the broadcast() below and allow us to use signal(). However, + // for now, we use linear dependency tracking because it's simpler. + if (atomic_load(&ts->progress) < sby) { + pthread_mutex_lock(&ts->tile_thread.lock); + while (atomic_load(&ts->progress) < sby) + pthread_cond_wait(&ts->tile_thread.cond, + &ts->tile_thread.lock); + pthread_mutex_unlock(&ts->tile_thread.lock); + } + + // we need to interleave sbrow decoding for all tile cols in a + // tile row, since otherwise subsequent threads will be blocked + // waiting for the post-filter to complete + t->ts = ts; + t->by = sby << f->sb_shift; + decode_tile_sbrow(t); + + // signal progress + pthread_mutex_lock(&ts->tile_thread.lock); + atomic_store(&ts->progress, 1 + sby); + pthread_cond_broadcast(&ts->tile_thread.cond); + pthread_mutex_unlock(&ts->tile_thread.lock); + } + } + + pthread_exit(NULL); + return NULL; +} diff --git a/src/thread_task.h b/src/thread_task.h new file mode 100644 index 0000000..e94a5b7 --- /dev/null +++ b/src/thread_task.h @@ -0,0 +1,39 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_SRC_THREAD_TASK_H__ +#define __DAV1D_SRC_THREAD_TASK_H__ + +#include "src/internal.h" + +int decode_frame(Dav1dFrameContext *f); +void *dav1d_frame_task(void *data); + +int decode_tile_sbrow(Dav1dTileContext *t); +void *dav1d_tile_task(void *data); + +#endif /* __DAV1D_SRC_THREAD_TASK_H__ */ diff --git a/src/warpmv.c b/src/warpmv.c new file mode 100644 index 0000000..3b81e1f --- /dev/null +++ b/src/warpmv.c @@ -0,0 +1,194 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <assert.h> +#include <stdlib.h> + +#include "common/intops.h" + +#include "src/warpmv.h" + +static const uint16_t div_lut[257] = { + 16384, 16320, 16257, 16194, 16132, 16070, 16009, 15948, 15888, 15828, 15768, + 15709, 15650, 15592, 15534, 15477, 15420, 15364, 15308, 15252, 15197, 15142, + 15087, 15033, 14980, 14926, 14873, 14821, 14769, 14717, 14665, 14614, 14564, + 14513, 14463, 14413, 14364, 14315, 14266, 14218, 14170, 14122, 14075, 14028, + 13981, 13935, 13888, 13843, 13797, 13752, 13707, 13662, 13618, 13574, 13530, + 13487, 13443, 13400, 13358, 13315, 13273, 13231, 13190, 13148, 13107, 13066, + 13026, 12985, 12945, 12906, 12866, 12827, 12788, 12749, 12710, 12672, 12633, + 12596, 12558, 12520, 12483, 12446, 12409, 12373, 12336, 12300, 12264, 12228, + 12193, 12157, 12122, 12087, 12053, 12018, 11984, 11950, 11916, 11882, 11848, + 11815, 11782, 11749, 11716, 11683, 11651, 11619, 11586, 11555, 11523, 11491, + 11460, 11429, 11398, 11367, 11336, 11305, 11275, 11245, 11215, 11185, 11155, + 11125, 11096, 11067, 11038, 11009, 10980, 10951, 10923, 10894, 10866, 10838, + 10810, 10782, 10755, 10727, 10700, 10673, 10645, 10618, 10592, 10565, 10538, + 10512, 10486, 10460, 10434, 10408, 10382, 10356, 10331, 10305, 10280, 10255, + 10230, 10205, 10180, 10156, 10131, 10107, 10082, 10058, 10034, 10010, 9986, + 9963, 9939, 9916, 9892, 9869, 9846, 9823, 9800, 9777, 9754, 9732, + 9709, 9687, 9664, 9642, 9620, 9598, 9576, 9554, 9533, 9511, 9489, + 9468, 9447, 9425, 9404, 9383, 9362, 9341, 9321, 9300, 9279, 9259, + 9239, 9218, 9198, 9178, 9158, 9138, 9118, 9098, 9079, 9059, 9039, + 9020, 9001, 8981, 8962, 8943, 8924, 8905, 8886, 8867, 8849, 8830, + 8812, 8793, 8775, 8756, 8738, 8720, 8702, 8684, 8666, 8648, 8630, + 8613, 8595, 8577, 8560, 8542, 8525, 8508, 8490, 8473, 8456, 8439, + 8422, 8405, 8389, 8372, 8355, 8339, 8322, 8306, 8289, 8273, 8257, + 8240, 8224, 8208, 8192, +}; + +static inline int iclip_wmp(const int v) { + const int cv = iclip(v, INT16_MIN, INT16_MAX); + + return apply_sign((abs(cv) + 32) >> 6, cv) * (1 << 6); +} + +static inline int apply_sign64(const int v, const int64_t s) { + return s < 0 ? -v : v; +} + +static inline int resolve_divisor_32(const unsigned d, int *const shift) { + *shift = ulog2(d); + const int e = d - (1 << *shift); + const int f = *shift > 8 ? (e + (1 << (*shift - 9))) >> (*shift - 8) : + e << (8 - *shift); + assert(f <= 256); + *shift += 14; + // Use f as lookup into the precomputed table of multipliers + return div_lut[f]; +} + +int get_shear_params(WarpedMotionParams *const wm) { + const int32_t *const mat = wm->matrix; + + if (mat[2] <= 0) return 1; + + wm->alpha = iclip_wmp(mat[2] - 0x10000); + wm->beta = iclip_wmp(mat[3]); + + int shift; + const int y = apply_sign(resolve_divisor_32(abs(mat[2]), &shift), mat[2]); + const int64_t v1 = ((int64_t) mat[4] * 0x10000) * y; + const int rnd = (1 << shift) >> 1; + wm->gamma = iclip_wmp(apply_sign64((llabs(v1) + rnd) >> shift, v1)); + const int64_t v2 = ((int64_t) mat[3] * mat[4]) * y; + wm->delta = iclip_wmp(mat[5] - + (int) apply_sign64((llabs(v2) + rnd) >> shift, v2) - + 0x10000); + + return (4 * abs(wm->alpha) + 7 * abs(wm->beta) >= 0x10000) || + (4 * abs(wm->gamma) + 4 * abs(wm->delta) >= 0x10000); +} + +static int resolve_divisor_64(const uint64_t d, int *const shift) { + *shift = u64log2(d); + const int64_t e = d - (1LL << *shift); + const int64_t f = *shift > 8 ? (e + (1LL << (*shift - 9))) >> (*shift - 8) : + e << (8 - *shift); + assert(f <= 256); + *shift += 14; + // Use f as lookup into the precomputed table of multipliers + return div_lut[f]; +} + +static int get_mult_shift_ndiag(const int64_t px, + const int idet, const int shift) +{ + const int64_t v1 = px * idet; + const int v2 = apply_sign64((llabs(v1) + ((1LL << shift) >> 1)) >> shift, v1); + return iclip(v2, -0x1fff, 0x1fff); +} + +static int get_mult_shift_diag(const int64_t px, + const int idet, const int shift) +{ + const int64_t v1 = px * idet; + const int v2 = apply_sign64((llabs(v1) + ((1LL << shift) >> 1)) >> shift, v1); + return iclip(v2, 0xe001, 0x11fff); +} + +int find_affine_int(const int (*pts)[2][2], const int np, + const int bw4, const int bh4, + const mv mv, WarpedMotionParams *const wm, + const int bx4, const int by4) +{ + int32_t *const mat = wm->matrix; + int a[2][2] = { { 0, 0 }, { 0, 0 } }; + int bx[2] = { 0, 0 }; + int by[2] = { 0, 0 }; + const int rsuy = 2 * bh4 - 1; + const int rsux = 2 * bw4 - 1; + const int suy = rsuy * 8; + const int sux = rsux * 8; + const int duy = suy + mv.y; + const int dux = sux + mv.x; + const int isuy = by4 * 4 + rsuy; + const int isux = bx4 * 4 + rsux; + + for (int i = 0; i < np; i++) { + const int dx = pts[i][1][0] - dux; + const int dy = pts[i][1][1] - duy; + const int sx = pts[i][0][0] - sux; + const int sy = pts[i][0][1] - suy; + if (abs(sx - dx) < 256 && abs(sy - dy) < 256) { + a[0][0] += ((sx * sx) >> 2) + sx * 2 + 8; + a[0][1] += ((sx * sy) >> 2) + sx + sy + 4; + a[1][1] += ((sy * sy) >> 2) + sy * 2 + 8; + bx[0] += ((sx * dx) >> 2) + sx + dx + 8; + bx[1] += ((sy * dx) >> 2) + sy + dx + 4; + by[0] += ((sx * dy) >> 2) + sx + dy + 4; + by[1] += ((sy * dy) >> 2) + sy + dy + 8; + } + } + + // compute determinant of a + const int64_t det = (int64_t) a[0][0] * a[1][1] - (int64_t) a[0][1] * a[0][1]; + if (det == 0) return 1; + int shift, idet = apply_sign64(resolve_divisor_64(llabs(det), &shift), det); + shift -= 16; + if (shift < 0) { + idet <<= -shift; + shift = 0; + } + + // solve the least-squares + mat[2] = get_mult_shift_diag((int64_t) a[1][1] * bx[0] - + (int64_t) a[0][1] * bx[1], idet, shift); + mat[3] = get_mult_shift_ndiag((int64_t) a[0][0] * bx[1] - + (int64_t) a[0][1] * bx[0], idet, shift); + mat[4] = get_mult_shift_ndiag((int64_t) a[1][1] * by[0] - + (int64_t) a[0][1] * by[1], idet, shift); + mat[5] = get_mult_shift_diag((int64_t) a[0][0] * by[1] - + (int64_t) a[0][1] * by[0], idet, shift); + + mat[0] = iclip(mv.x * 0x2000 - (isux * (mat[2] - 0x10000) + isuy * mat[3]), + -0x800000, 0x7fffff); + mat[1] = iclip(mv.y * 0x2000 - (isux * mat[4] + isuy * (mat[5] - 0x10000)), + -0x800000, 0x7fffff); + + return 0; +} diff --git a/src/warpmv.h b/src/warpmv.h new file mode 100644 index 0000000..ca9e0df --- /dev/null +++ b/src/warpmv.h @@ -0,0 +1,37 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_SRC_WARPMV_H__ +#define __DAV1D_SRC_WARPMV_H__ + +#include "src/levels.h" + +int get_shear_params(WarpedMotionParams *wm); +int find_affine_int(const int (*pts)[2][2], int np, int bw4, int bh4, + mv mv, WarpedMotionParams *wm, int by, int bx); + +#endif /* __DAV1D_SRC_WARPMV_H__ */ diff --git a/src/wedge.c b/src/wedge.c new file mode 100644 index 0000000..114d493 --- /dev/null +++ b/src/wedge.c @@ -0,0 +1,334 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <stdint.h> +#include <string.h> + +#include "common/intops.h" + +#include "src/wedge.h" + +enum WedgeDirectionType { + WEDGE_HORIZONTAL = 0, + WEDGE_VERTICAL = 1, + WEDGE_OBLIQUE27 = 2, + WEDGE_OBLIQUE63 = 3, + WEDGE_OBLIQUE117 = 4, + WEDGE_OBLIQUE153 = 5, + N_WEDGE_DIRECTIONS +}; + +typedef struct { + enum WedgeDirectionType direction; + int x_offset; + int y_offset; +} wedge_code_type; + +static const wedge_code_type wedge_codebook_16_hgtw[16] = { + { WEDGE_OBLIQUE27, 4, 4 }, { WEDGE_OBLIQUE63, 4, 4 }, + { WEDGE_OBLIQUE117, 4, 4 }, { WEDGE_OBLIQUE153, 4, 4 }, + { WEDGE_HORIZONTAL, 4, 2 }, { WEDGE_HORIZONTAL, 4, 4 }, + { WEDGE_HORIZONTAL, 4, 6 }, { WEDGE_VERTICAL, 4, 4 }, + { WEDGE_OBLIQUE27, 4, 2 }, { WEDGE_OBLIQUE27, 4, 6 }, + { WEDGE_OBLIQUE153, 4, 2 }, { WEDGE_OBLIQUE153, 4, 6 }, + { WEDGE_OBLIQUE63, 2, 4 }, { WEDGE_OBLIQUE63, 6, 4 }, + { WEDGE_OBLIQUE117, 2, 4 }, { WEDGE_OBLIQUE117, 6, 4 }, +}; + +static const wedge_code_type wedge_codebook_16_hltw[16] = { + { WEDGE_OBLIQUE27, 4, 4 }, { WEDGE_OBLIQUE63, 4, 4 }, + { WEDGE_OBLIQUE117, 4, 4 }, { WEDGE_OBLIQUE153, 4, 4 }, + { WEDGE_VERTICAL, 2, 4 }, { WEDGE_VERTICAL, 4, 4 }, + { WEDGE_VERTICAL, 6, 4 }, { WEDGE_HORIZONTAL, 4, 4 }, + { WEDGE_OBLIQUE27, 4, 2 }, { WEDGE_OBLIQUE27, 4, 6 }, + { WEDGE_OBLIQUE153, 4, 2 }, { WEDGE_OBLIQUE153, 4, 6 }, + { WEDGE_OBLIQUE63, 2, 4 }, { WEDGE_OBLIQUE63, 6, 4 }, + { WEDGE_OBLIQUE117, 2, 4 }, { WEDGE_OBLIQUE117, 6, 4 }, +}; + +static const wedge_code_type wedge_codebook_16_heqw[16] = { + { WEDGE_OBLIQUE27, 4, 4 }, { WEDGE_OBLIQUE63, 4, 4 }, + { WEDGE_OBLIQUE117, 4, 4 }, { WEDGE_OBLIQUE153, 4, 4 }, + { WEDGE_HORIZONTAL, 4, 2 }, { WEDGE_HORIZONTAL, 4, 6 }, + { WEDGE_VERTICAL, 2, 4 }, { WEDGE_VERTICAL, 6, 4 }, + { WEDGE_OBLIQUE27, 4, 2 }, { WEDGE_OBLIQUE27, 4, 6 }, + { WEDGE_OBLIQUE153, 4, 2 }, { WEDGE_OBLIQUE153, 4, 6 }, + { WEDGE_OBLIQUE63, 2, 4 }, { WEDGE_OBLIQUE63, 6, 4 }, + { WEDGE_OBLIQUE117, 2, 4 }, { WEDGE_OBLIQUE117, 6, 4 }, +}; + +static uint8_t wedge_masks_444_32x32[2][16][32 * 32]; +static uint8_t wedge_masks_444_32x16[2][16][32 * 16]; +static uint8_t wedge_masks_444_32x8[2][16][32 * 8]; +static uint8_t wedge_masks_444_16x32[2][16][16 * 32]; +static uint8_t wedge_masks_444_16x16[2][16][16 * 16]; +static uint8_t wedge_masks_444_16x8[2][16][16 * 8]; +static uint8_t wedge_masks_444_8x32[2][16][8 * 32]; +static uint8_t wedge_masks_444_8x16[2][16][8 * 16]; +static uint8_t wedge_masks_444_8x8[2][16][8 * 8]; + +static uint8_t wedge_masks_422_16x32[2][16][16 * 32]; +static uint8_t wedge_masks_422_16x16[2][16][16 * 16]; +static uint8_t wedge_masks_422_16x8[2][16][16 * 8]; +static uint8_t wedge_masks_422_8x32[2][16][8 * 32]; +static uint8_t wedge_masks_422_8x16[2][16][8 * 16]; +static uint8_t wedge_masks_422_8x8[2][16][8 * 8]; +static uint8_t wedge_masks_422_4x32[2][16][4 * 32]; +static uint8_t wedge_masks_422_4x16[2][16][4 * 16]; +static uint8_t wedge_masks_422_4x8[2][16][4 * 8]; + +static uint8_t wedge_masks_420_16x16[2][16][16 * 16]; +static uint8_t wedge_masks_420_16x8[2][16][16 * 8]; +static uint8_t wedge_masks_420_16x4[2][16][16 * 4]; +static uint8_t wedge_masks_420_8x16[2][16][8 * 16]; +static uint8_t wedge_masks_420_8x8[2][16][8 * 8]; +static uint8_t wedge_masks_420_8x4[2][16][8 * 4]; +static uint8_t wedge_masks_420_4x16[2][16][4 * 16]; +static uint8_t wedge_masks_420_4x8[2][16][4 * 8]; +static uint8_t wedge_masks_420_4x4[2][16][4 * 4]; + +const uint8_t *wedge_masks[N_BS_SIZES][3][2][16]; + +static void insert_border(uint8_t *const dst, const uint8_t *src, + const int ctr) +{ + if (ctr > 4) memset(dst, 0, ctr - 4); + memcpy(dst + imax(ctr, 4) - 4, src + imax(4 - ctr, 0), imin(64 - ctr, 8)); + if (ctr < 64 - 4) + memset(dst + ctr + 4, 64, 64 - 4 - ctr); +} + +static void transpose(uint8_t *const dst, const uint8_t *const src) { + for (int y = 0, y_off = 0; y < 64; y++, y_off += 64) + for (int x = 0, x_off = 0; x < 64; x++, x_off += 64) + dst[x_off + y] = src[y_off + x]; +} + +static void hflip(uint8_t *const dst, const uint8_t *const src) { + for (int y = 0, y_off = 0; y < 64; y++, y_off += 64) + for (int x = 0; x < 64; x++) + dst[y_off + 64 - 1 - x] = src[y_off + x]; +} + +static void invert(uint8_t *const dst, const uint8_t *const src, + const int w, const int h) +{ + for (int y = 0, y_off = 0; y < h; y++, y_off += w) + for (int x = 0; x < w; x++) + dst[y_off + x] = 64 - src[y_off + x]; +} + +static void copy2d(uint8_t *dst, const uint8_t *src, + const int w, const int h, const int x_off, const int y_off) +{ + src += y_off * 64 + x_off; + for (int y = 0; y < h; y++) { + memcpy(dst, src, w); + src += 64; + dst += w; + } +} + +static void init_chroma(uint8_t *chroma, const uint8_t *luma, + const int sign, const int w, const int h, const int ss_ver) +{ + for (int y = 0; y < h; y += 1 + ss_ver) { + for (int x = 0; x < w; x += 2) { + int sum = luma[x] + luma[x + 1] + 1; + if (ss_ver) sum += luma[w + x] + luma[w + x + 1] + 1; + chroma[x >> 1] = (sum - sign) >> (1 + ss_ver); + } + luma += w << ss_ver; + chroma += w >> 1; + } +} + +static void fill2d_16x2(uint8_t *dst, const int w, const int h, + const enum BlockSize bs, + const uint8_t (*const master)[64 * 64], + const wedge_code_type *const cb, + uint8_t (*masks_444)[16][w * h], + uint8_t (*masks_422)[16][w * h >> 1], + uint8_t (*masks_420)[16][w * h >> 2], + const unsigned signs) +{ + uint8_t *ptr = dst; + for (int n = 0; n < 16; n++) { + copy2d(ptr, master[cb[n].direction], w, h, + 32 - (w * cb[n].x_offset >> 3), 32 - (h * cb[n].y_offset >> 3)); + ptr += w * h; + } + for (int n = 0, off = 0; n < 16; n++, off += w * h) + invert(ptr + off, dst + off, w, h); + // assign pointers in externally visible array + for (int n = 0; n < 16; n++) { + const int sign = (signs >> n) & 1; + wedge_masks[bs][0][0][n] = masks_444[ sign][n]; + wedge_masks[bs][0][1][n] = masks_444[ sign][n]; + wedge_masks[bs][1][0][n] = masks_422[ sign][n]; + wedge_masks[bs][1][1][n] = masks_422[!sign][n]; + wedge_masks[bs][2][0][n] = masks_420[ sign][n]; + wedge_masks[bs][2][1][n] = masks_420[!sign][n]; + } + for (int n = 0; n < 16; n++) { + // since the pointers come from inside, we know that + // violation of the const is OK here. Any other approach + // means we would have to duplicate the sign correction + // logic in two places, which isn't very nice, or mark + // the table faced externally as non-const, which also sucks + init_chroma((uint8_t *) wedge_masks[bs][1][0][n], + wedge_masks[bs][0][0][n], 0, w, h, 0); + init_chroma((uint8_t *) wedge_masks[bs][1][1][n], + wedge_masks[bs][0][0][n], 1, w, h, 0); + init_chroma((uint8_t *) wedge_masks[bs][2][0][n], + wedge_masks[bs][0][0][n], 0, w, h, 1); + init_chroma((uint8_t *) wedge_masks[bs][2][1][n], + wedge_masks[bs][0][0][n], 1, w, h, 1); + } +} + +void av1_init_wedge_masks(void) { + static int done = 0; + if (done) return; + done = 1; + + enum WedgeMasterLineType { + WEDGE_MASTER_LINE_ODD, + WEDGE_MASTER_LINE_EVEN, + WEDGE_MASTER_LINE_VERT, + N_WEDGE_MASTER_LINES, + }; + static const uint8_t wedge_master_border[N_WEDGE_MASTER_LINES][8] = { + [WEDGE_MASTER_LINE_ODD] = { 1, 2, 6, 18, 37, 53, 60, 63 }, + [WEDGE_MASTER_LINE_EVEN] = { 1, 4, 11, 27, 46, 58, 62, 63 }, + [WEDGE_MASTER_LINE_VERT] = { 0, 2, 7, 21, 43, 57, 62, 64 }, + }; + uint8_t master[6][64 * 64]; + + // create master templates + for (int y = 0, off = 0; y < 64; y++, off += 64) + insert_border(&master[WEDGE_VERTICAL][off], + wedge_master_border[WEDGE_MASTER_LINE_VERT], 32); + for (int y = 0, off = 0, ctr = 48; y < 64; y += 2, off += 128, ctr--) + { + insert_border(&master[WEDGE_OBLIQUE63][off], + wedge_master_border[WEDGE_MASTER_LINE_EVEN], ctr); + insert_border(&master[WEDGE_OBLIQUE63][off + 64], + wedge_master_border[WEDGE_MASTER_LINE_ODD], ctr - 1); + } + + transpose(master[WEDGE_OBLIQUE27], master[WEDGE_OBLIQUE63]); + transpose(master[WEDGE_HORIZONTAL], master[WEDGE_VERTICAL]); + hflip(master[WEDGE_OBLIQUE117], master[WEDGE_OBLIQUE63]); + hflip(master[WEDGE_OBLIQUE153], master[WEDGE_OBLIQUE27]); + +#define fill(w, h, sz_422, sz_420, hvsw, signs) \ + fill2d_16x2((uint8_t *) wedge_masks_444_##w##x##h, w, h, BS_##w##x##h, \ + master, wedge_codebook_16_##hvsw, wedge_masks_444_##w##x##h, \ + wedge_masks_422_##sz_422, wedge_masks_420_##sz_420, signs) + + fill(32, 32, 16x32, 16x16, heqw, 0x7bfb); + fill(32, 16, 16x16, 16x8, hltw, 0x7beb); + fill(32, 8, 16x8, 16x4, hltw, 0x6beb); + fill(16, 32, 8x32, 8x16, hgtw, 0x7beb); + fill(16, 16, 8x16, 8x8, heqw, 0x7bfb); + fill(16, 8, 8x8, 8x4, hltw, 0x7beb); + fill( 8, 32, 4x32, 4x16, hgtw, 0x7aeb); + fill( 8, 16, 4x16, 4x8, hgtw, 0x7beb); + fill( 8, 8, 4x8, 4x4, heqw, 0x7bfb); +#undef fill +} + +static uint8_t ii_dc_mask[32 * 32]; +static uint8_t ii_nondc_mask_32x32[N_INTER_INTRA_PRED_MODES - 1][32 * 32]; +static uint8_t ii_nondc_mask_16x32[N_INTER_INTRA_PRED_MODES - 1][16 * 32]; +static uint8_t ii_nondc_mask_16x16[N_INTER_INTRA_PRED_MODES - 1][16 * 16]; +static uint8_t ii_nondc_mask_8x32[N_INTER_INTRA_PRED_MODES - 1][8 * 32]; +static uint8_t ii_nondc_mask_8x16[N_INTER_INTRA_PRED_MODES - 1][8 * 16]; +static uint8_t ii_nondc_mask_8x8[N_INTER_INTRA_PRED_MODES - 1][8 * 8]; +static uint8_t ii_nondc_mask_4x16[N_INTER_INTRA_PRED_MODES - 1][4 * 16]; +static uint8_t ii_nondc_mask_4x8[N_INTER_INTRA_PRED_MODES - 1][4 * 8]; +static uint8_t ii_nondc_mask_4x4[N_INTER_INTRA_PRED_MODES - 1][4 * 4]; + +#define set1(sz) \ + [II_DC_PRED] = ii_dc_mask, \ + [II_VERT_PRED] = ii_nondc_mask_##sz[II_VERT_PRED - 1], \ + [II_HOR_PRED] = ii_nondc_mask_##sz[II_HOR_PRED - 1], \ + [II_SMOOTH_PRED] = ii_nondc_mask_##sz[II_SMOOTH_PRED - 1] +#define set(sz_444, sz_422, sz_420) \ + { { set1(sz_444) }, { set1(sz_422) }, { set1(sz_420) } } +const uint8_t *const ii_masks[N_BS_SIZES][3][N_INTER_INTRA_PRED_MODES] = { + [BS_8x8] = set( 8x8, 4x8, 4x4), + [BS_8x16] = set( 8x16, 4x16, 4x8), + [BS_16x8] = set(16x16, 8x8, 8x8), + [BS_16x16] = set(16x16, 8x16, 8x8), + [BS_16x32] = set(16x32, 8x32, 8x16), + [BS_32x16] = set(32x32, 16x16, 16x16), + [BS_32x32] = set(32x32, 16x32, 16x16), +}; +#undef set +#undef set1 + +static void build_nondc_ii_masks(uint8_t *const mask_v, + uint8_t *const mask_h, + uint8_t *const mask_sm, + const int w, const int h, const int step) +{ + static const uint8_t ii_weights_1d[] = { + 60, 52, 45, 39, 34, 30, 26, 22, 19, 17, 15, 13, 11, 10, 8, 7, + 6, 6, 5, 4, 4, 3, 3, 2, 2, 2, 2, 1, 1, 1, 1, 1, + }; + + for (int y = 0, off = 0; y < h; y++, off += w) { + memset(&mask_v[off], ii_weights_1d[y * step], w); + for (int x = 0; x < w; x++) { + mask_sm[off + x] = ii_weights_1d[imin(x, y) * step]; + mask_h[off + x] = ii_weights_1d[x * step]; + } + } +} + +void av1_init_interintra_masks(void) { + static int done = 0; + if (done) return; + done = 1; + + memset(ii_dc_mask, 32, 32 * 32); +#define set(a) a[II_VERT_PRED - 1], a[II_HOR_PRED - 1], a[II_SMOOTH_PRED - 1] + build_nondc_ii_masks(set(ii_nondc_mask_32x32), 32, 32, 1); + build_nondc_ii_masks(set(ii_nondc_mask_16x32), 16, 32, 1); + build_nondc_ii_masks(set(ii_nondc_mask_16x16), 16, 16, 2); + build_nondc_ii_masks(set(ii_nondc_mask_8x32), 8, 32, 1); + build_nondc_ii_masks(set(ii_nondc_mask_8x16), 8, 16, 2); + build_nondc_ii_masks(set(ii_nondc_mask_8x8), 8, 8, 4); + build_nondc_ii_masks(set(ii_nondc_mask_4x16), 4, 16, 2); + build_nondc_ii_masks(set(ii_nondc_mask_4x8), 4, 8, 4); + build_nondc_ii_masks(set(ii_nondc_mask_4x4), 4, 4, 8); +#undef set +} diff --git a/src/wedge.h b/src/wedge.h new file mode 100644 index 0000000..72a7546 --- /dev/null +++ b/src/wedge.h @@ -0,0 +1,41 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_SRC_WEDGE_H__ +#define __DAV1D_SRC_WEDGE_H__ + +#include "src/levels.h" + +void av1_init_wedge_masks(void); +extern const uint8_t *wedge_masks[N_BS_SIZES][3 /* 444/luma, 422, 420 */] + [2 /* sign */][16 /* wedge_idx */]; + +void av1_init_interintra_masks(void); +extern const uint8_t *const ii_masks[N_BS_SIZES][3 /* 444/luma, 422, 420 */] + [N_INTER_INTRA_PRED_MODES]; + +#endif /* __DAV1D_SRC_WEDGE_H__ */ diff --git a/tools/dav1d.c b/tools/dav1d.c new file mode 100644 index 0000000..9bfd66c --- /dev/null +++ b/tools/dav1d.c @@ -0,0 +1,173 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <assert.h> +#include <errno.h> +#include <math.h> +#include <stdio.h> +#include <string.h> +#include <unistd.h> + +#include "dav1d/data.h" + +#include "include/version.h" + +#include "input/input.h" + +#include "output/output.h" + +#include "dav1d_cli_parse.h" + +static void print_stats(const int istty, const unsigned n, + const unsigned num) +{ + const char *pre_string = istty ? "\r" : ""; + const char *post_string = istty ? "" : "\n"; + + if (num == 0xFFFFFFFFU) { + fprintf(stderr, "%sDecoded %u frames%s", pre_string, n, post_string); + } else { + fprintf(stderr, "%sDecoded %u/%u frames (%.1lf%%)%s", + pre_string, n, num, 100.0 * n / num, post_string); + } +} + +int main(const int argc, char *const *const argv) { + const int istty = isatty(fileno(stderr)); + int res = 0; + CLISettings cli_settings; + Dav1dSettings lib_settings; + DemuxerContext *in; + MuxerContext *out = NULL; + Dav1dPicture p; + Dav1dContext *c; + Dav1dData data; + unsigned n_out = 0, total, fps[2]; + const char *version = dav1d_version(); + + if (strcmp(version, DAV1D_VERSION)) { + fprintf(stderr, "Version mismatch (library: %s, executable: %s)\n", + version, DAV1D_VERSION); + return -1; + } + + dav1d_init(); + init_demuxers(); + init_muxers(); + parse(argc, argv, &cli_settings, &lib_settings); + + if ((res = input_open(&in, cli_settings.inputfile, + fps, &total)) < 0) + { + return res; + } + for (unsigned i = 0; i <= cli_settings.skip; i++) { + if ((res = input_read(in, &data)) < 0) + return res; + if (i < cli_settings.skip) dav1d_data_unref(&data); + } + + if (!cli_settings.quiet) + fprintf(stderr, "Dav1d %s - by Two Orioles\n", DAV1D_VERSION); + + //getc(stdin); + if (cli_settings.limit != 0 && cli_settings.limit < total) + total = cli_settings.limit; + + if ((res = dav1d_open(&c, &lib_settings))) + return res; + + do { + memset(&p, 0, sizeof(p)); + if ((res = dav1d_decode(c, &data, &p)) < 0) { + if (res != -EAGAIN) { + fprintf(stderr, "Error decoding frame: %s\n", + strerror(-res)); + break; + } + res = 0; + } else { + if (!n_out) { + if ((res = output_open(&out, cli_settings.muxer, + cli_settings.outputfile, + &p.p, fps)) < 0) + { + return res; + } + } + if ((res = output_write(out, &p)) < 0) + break; + n_out++; + if (!cli_settings.quiet) + print_stats(istty, n_out, total); + } + + if (cli_settings.limit && n_out == cli_settings.limit) + break; + } while (data.sz > 0 || !input_read(in, &data)); + + // flush + if (res == 0) while (!cli_settings.limit || n_out < cli_settings.limit) { + if ((res = dav1d_decode(c, NULL, &p)) < 0) { + if (res != -EAGAIN) { + fprintf(stderr, "Error decoding frame: %s\n", + strerror(-res)); + } else + res = 0; + break; + } else { + if (!n_out) { + if ((res = output_open(&out, cli_settings.muxer, + cli_settings.outputfile, + &p.p, fps)) < 0) + { + return res; + } + } + if ((res = output_write(out, &p)) < 0) + break; + n_out++; + if (!cli_settings.quiet) + print_stats(istty, n_out, total); + } + } + + input_close(in); + if (out) { + if (!cli_settings.quiet && istty) + fprintf(stderr, "\n"); + output_close(out); + } else { + fprintf(stderr, "No data decoded\n"); + res = 1; + } + dav1d_close(c); + + return res; +} diff --git a/tools/dav1d_cli_parse.c b/tools/dav1d_cli_parse.c new file mode 100644 index 0000000..281c14b --- /dev/null +++ b/tools/dav1d_cli_parse.c @@ -0,0 +1,160 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <assert.h> +#include <getopt.h> +#include <math.h> +#include <stdarg.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +#include "dav1d_cli_parse.h" + +static const char short_opts[] = "i:o:vql:"; + +enum { + ARG_MUXER, + ARG_FRAME_THREADS, + ARG_TILE_THREADS, +}; + +static const struct option long_opts[] = { + { "input", 1, NULL, 'i' }, + { "output", 1, NULL, 'o' }, + { "quiet", 0, NULL, 'q' }, + { "muxer", 1, NULL, ARG_MUXER }, + { "version", 0, NULL, 'v' }, + { "limit", 1, NULL, 'l' }, + { "skip", 1, NULL, 's' }, + { "framethreads", 1, NULL, ARG_FRAME_THREADS }, + { "tilethreads", 1, NULL, ARG_TILE_THREADS }, + { NULL }, +}; + +static void usage(const char *const app, const char *const reason, ...) { + if (reason) { + va_list args; + + va_start(args, reason); + vfprintf(stderr, reason, args); + va_end(args); + fprintf(stderr, "\n\n"); + } + fprintf(stderr, "Usage: %s [options]\n\n", app); + fprintf(stderr, "Supported options:\n" + " --input/-i $file: input file\n" + " --output/-o $file: output file\n" + " --muxer $name: force muxer type (default: detect from extension)\n" + " --quiet/-q: disable status messages\n" + " --limit/-l $num: stop decoding after $num frames\n" + " --skip/-s $num: skip decoding of the first $num frames\n" + " --version/-v: print version and exit\n" + " --framethreads $num: number of frame threads (default: 1)\n" + " --tilethreads $num: number of tile threads (default: 1)\n"); + exit(1); +} + +static void error(const char *const app, const char *const optarg, + const int option, const char *const shouldbe) +{ + char optname[256]; + int n; + + for (n = 0; long_opts[n].name; n++) + if (long_opts[n].val == option) + break; + assert(long_opts[n].name); + if (long_opts[n].val < 256) { + sprintf(optname, "-%c/--%s", long_opts[n].val, long_opts[n].name); + } else { + sprintf(optname, "--%s", long_opts[n].name); + } + + usage(app, "Invalid argument \"%s\" for option %s; should be %s", + optarg, optname, shouldbe); +} + +static unsigned parse_unsigned(char *optarg, const int option, const char *app) { + char *end; + const double res = strtoul(optarg, &end, 0); + if (*end || end == optarg) error(app, optarg, option, "an integer"); + return res; +} + +void parse(const int argc, char *const *const argv, + CLISettings *const cli_settings, Dav1dSettings *const lib_settings) +{ + int o; + + memset(cli_settings, 0, sizeof(*cli_settings)); + dav1d_default_settings(lib_settings); + + while ((o = getopt_long(argc, argv, short_opts, long_opts, NULL)) >= 0) { + switch (o) { + case 'o': + cli_settings->outputfile = optarg; + break; + case 'i': + cli_settings->inputfile = optarg; + break; + case 'q': + cli_settings->quiet = 1; + break; + case 'l': + cli_settings->limit = parse_unsigned(optarg, 'l', argv[0]); + break; + case 's': + cli_settings->skip = parse_unsigned(optarg, 's', argv[0]); + break; + case ARG_MUXER: + cli_settings->muxer = optarg; + break; + case ARG_FRAME_THREADS: + lib_settings->n_frame_threads = + parse_unsigned(optarg, ARG_FRAME_THREADS, argv[0]); + break; + case ARG_TILE_THREADS: + lib_settings->n_tile_threads = + parse_unsigned(optarg, ARG_TILE_THREADS, argv[0]); + break; + case 'v': + fprintf(stderr, "%s\n", dav1d_version()); + exit(0); + default: + break; + } + } + + if (!cli_settings->inputfile) + usage(argv[0], "Input file (-i/--input) is required"); + if (!cli_settings->outputfile) + usage(argv[0], "Output file (-o/--output) is required"); +} diff --git a/tools/dav1d_cli_parse.h b/tools/dav1d_cli_parse.h new file mode 100644 index 0000000..272c1c2 --- /dev/null +++ b/tools/dav1d_cli_parse.h @@ -0,0 +1,44 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_CLI_PARSE_H__ +#define __DAV1D_CLI_PARSE_H__ + +#include "dav1d.h" + +typedef struct { + const char *outputfile; + const char *inputfile; + const char *muxer; + unsigned limit, skip; + int quiet; +} CLISettings; + +void parse(const int argc, char *const *const argv, + CLISettings *const cli_settings, Dav1dSettings *const lib_settings); + +#endif /* __DAV1D_CLI_PARSE_H__ */ diff --git a/tools/input/demuxer.h b/tools/input/demuxer.h new file mode 100644 index 0000000..8fdf6ed --- /dev/null +++ b/tools/input/demuxer.h @@ -0,0 +1,44 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_INPUT_DEMUXER_H__ +#define __DAV1D_INPUT_DEMUXER_H__ + +#include "data.h" + +typedef struct DemuxerPriv DemuxerPriv; +typedef struct Demuxer { + int priv_data_size; + const char *name; + const char *extension; + int (*open)(DemuxerPriv *ctx, const char *filename, + unsigned fps[2], unsigned *num_frames); + int (*read)(DemuxerPriv *ctx, Dav1dData *data); + void (*close)(DemuxerPriv *ctx); +} Demuxer; + +#endif /* __DAV1D_INPUT_DEMUXER_H__ */ diff --git a/tools/input/input.c b/tools/input/input.c new file mode 100644 index 0000000..e00c21c --- /dev/null +++ b/tools/input/input.c @@ -0,0 +1,124 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <assert.h> +#include <errno.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "input/input.h" +#include "input/demuxer.h" + +struct DemuxerContext { + DemuxerPriv *data; + const Demuxer *impl; +}; + +#define MAX_NUM_DEMUXERS 1 +static const Demuxer *demuxers[MAX_NUM_DEMUXERS]; +static int num_demuxers = 0; + +#define register_demuxer(impl) { \ + extern const Demuxer impl; \ + assert(num_demuxers < MAX_NUM_DEMUXERS); \ + demuxers[num_demuxers++] = &impl; \ +} + +void init_demuxers(void) { + register_demuxer(ivf_demuxer); +} + +static const char *find_extension(const char *const f) { + const int l = strlen(f); + + if (l == 0) return NULL; + + const char *const end = &f[l - 1], *step = end; + while ((*step >= 'a' && *step <= 'z') || + (*step >= 'A' && *step <= 'Z') || + (*step >= '0' && *step <= '9')) + { + step--; + } + + return (step < end && step > f && *step == '.' && step[-1] != '/') ? + &step[1] : NULL; +} + +int input_open(DemuxerContext **const c_out, const char *const filename, + unsigned fps[2], unsigned *const num_frames) +{ + const Demuxer *impl; + DemuxerContext *c; + int res, i; + + const char *const ext = find_extension(filename); + if (!ext) { + fprintf(stderr, "No extension found for file %s\n", filename); + return -1; + } + + for (i = 0; i < num_demuxers; i++) { + if (!strcmp(demuxers[i]->extension, ext)) { + impl = demuxers[i]; + break; + } + } + if (i == num_demuxers) { + fprintf(stderr, + "Failed to find demuxer for file %s (\"%s\")\n", + filename, ext); + return -ENOPROTOOPT; + } + + if (!(c = malloc(sizeof(DemuxerContext) + impl->priv_data_size))) { + fprintf(stderr, "Failed to allocate memory\n"); + return -ENOMEM; + } + memset(c, 0, sizeof(DemuxerContext) + impl->priv_data_size); + c->impl = impl; + c->data = (DemuxerPriv *) &c[1]; + if ((res = impl->open(c->data, filename, fps, num_frames)) < 0) { + free(c); + return res; + } + *c_out = c; + + return 0; +} + +int input_read(DemuxerContext *const ctx, Dav1dData *const data) { + return ctx->impl->read(ctx->data, data); +} + +void input_close(DemuxerContext *const ctx) { + ctx->impl->close(ctx->data); + free(ctx); +} diff --git a/tools/input/input.h b/tools/input/input.h new file mode 100644 index 0000000..ad0f0ef --- /dev/null +++ b/tools/input/input.h @@ -0,0 +1,41 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_INPUT_INPUT_H__ +#define __DAV1D_INPUT_INPUT_H__ + +#include "data.h" + +typedef struct DemuxerContext DemuxerContext; + +void init_demuxers(void); +int input_open(DemuxerContext **c, const char *filename, + unsigned fps[2], unsigned *num_frames); +int input_read(DemuxerContext *ctx, Dav1dData *data); +void input_close(DemuxerContext *ctx); + +#endif /* __DAV1D_INPUT_INPUT_H__ */ diff --git a/tools/input/ivf.c b/tools/input/ivf.c new file mode 100644 index 0000000..2e47d32 --- /dev/null +++ b/tools/input/ivf.c @@ -0,0 +1,113 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <assert.h> +#include <errno.h> +#include <stdio.h> +#include <stdint.h> +#include <stdlib.h> +#include <string.h> + +#include "common/intops.h" + +#include "input/demuxer.h" + +typedef struct DemuxerPriv { + FILE *f; +} IvfInputContext; + +static int ivf_open(IvfInputContext *const c, const char *const file, + unsigned fps[2], unsigned *const num_frames) +{ + int res; + uint8_t hdr[32]; + + memset(c, 0, sizeof(*c)); + if (!(c->f = fopen(file, "r"))) { + fprintf(stderr, "Failed to open %s: %s\n", file, strerror(errno)); + return -1; + } else if ((res = fread(hdr, 32, 1, c->f)) != 1) { + fprintf(stderr, "Failed to read stream header: %s\n", strerror(errno)); + fclose(c->f); + return -1; + } else if (memcmp(hdr, "DKIF", 4)) { + fprintf(stderr, "%s is not an IVF file [tag=%4s|0x%02x%02x%02x%02x]\n", + file, hdr, hdr[0], hdr[1], hdr[2], hdr[3]); + fclose(c->f); + return -1; + } else if (memcmp(&hdr[8], "AV01", 4)) { + fprintf(stderr, "%s is not an AV1 file [tag=%4s|0x%02x%02x%02x%02x]\n", + file, &hdr[8], hdr[8], hdr[9], hdr[10], hdr[11]); + fclose(c->f); + return -1; + } + + fps[0] = rl32(&hdr[16]); + fps[1] = rl32(&hdr[20]); + const unsigned duration = rl32(&hdr[24]); + uint8_t data[4]; + for (*num_frames = 0;; (*num_frames)++) { + if ((res = fread(data, 4, 1, c->f)) != 1) + break; // EOF + fseek(c->f, rl32(data) + 8, SEEK_CUR); + } + fps[0] *= *num_frames; + fps[1] *= duration; + fseek(c->f, 32, SEEK_SET); + + return 0; +} + +static int ivf_read(IvfInputContext *const c, Dav1dData *const buf) { + uint8_t data[4]; + int res; + + if ((res = fread(data, 4, 1, c->f)) != 1) + return -1; // EOF + fseek(c->f, 8, SEEK_CUR); // skip timestamp + const ptrdiff_t sz = rl32(data); + dav1d_data_create(buf, sz); + if ((res = fread(buf->data, sz, 1, c->f)) != 1) + fprintf(stderr, "Failed to read frame data: %s\n", strerror(errno)); + + return 0; +} + +static void ivf_close(IvfInputContext *const c) { + fclose(c->f); +} + +const Demuxer ivf_demuxer = { + .priv_data_size = sizeof(IvfInputContext), + .name = "ivf", + .extension = "ivf", + .open = ivf_open, + .read = ivf_read, + .close = ivf_close, +}; diff --git a/tools/output/md5.c b/tools/output/md5.c new file mode 100644 index 0000000..e297f66 --- /dev/null +++ b/tools/output/md5.c @@ -0,0 +1,220 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <errno.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sys/stat.h> + +#include "common/intops.h" + +#include "output/muxer.h" + +static const uint8_t s[][4] = { + { 7, 12, 17, 22, }, + { 5, 9, 14, 20, }, + { 4, 11, 16, 23, }, + { 6, 10, 15, 21, }, +}; + +static const unsigned k[] = { + 0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, + 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501, + 0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be, + 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821, + 0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa, + 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8, + 0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed, + 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a, + 0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c, + 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70, + 0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05, + 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665, + 0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, + 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1, + 0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1, + 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391, +}; + +typedef struct MuxerPriv { + unsigned abcd[4]; + uint8_t data[64]; + uint64_t len; + FILE *f; +} MD5Context; + +static int md5_open(MD5Context *const md5, const char *const file, + const Dav1dPictureParameters *const p, + const unsigned fps[2]) +{ + if (!strcmp(file, "-")) { + md5->f = stdout; + } else if (!(md5->f = fopen(file, "w"))) { + fprintf(stderr, "Failed to open %s: %s\n", file, strerror(errno)); + return -1; + } + + md5->abcd[0] = 0x67452301; + md5->abcd[1] = 0xefcdab89; + md5->abcd[2] = 0x98badcfe; + md5->abcd[3] = 0x10325476; + md5->len = 0; + + return 0; +} + +static inline unsigned leftrotate(const unsigned x, const unsigned c) { + return (x << c) | (x >> (32 - c)); +} + +static void md5_body(MD5Context *md5, const uint8_t *const _data) { + const uint32_t *data = (uint32_t *) _data; + + unsigned a = md5->abcd[0]; + unsigned b = md5->abcd[1]; + unsigned c = md5->abcd[2]; + unsigned d = md5->abcd[3]; + unsigned i; + + for (i = 0; i < 64; i++) { + unsigned f, g, tmp; + + if (i < 16) { + f = (b & c) | (~b & d); + g = i; + } else if (i < 32) { + f = (d & b) | (~d & c); + g = (5 * i + 1) & 15; + } else if (i < 48) { + f = b ^ c ^ d; + g = (3 * i + 5) & 15; + } else { + f = c ^ (b | ~d); + g = (7 * i) & 15; + } + + tmp = d; + d = c; + c = b; + b += leftrotate(a + f + k[i] + data[g], s[i >> 4][i & 3]); + a = tmp; + } + + md5->abcd[0] += a; + md5->abcd[1] += b; + md5->abcd[2] += c; + md5->abcd[3] += d; +} + +static void md5_update(MD5Context *const md5, const uint8_t *data, unsigned len) { + if (!len) return; + + if (md5->len & 63) { + const unsigned tmp = imin(len, 64 - (md5->len & 63)); + + memcpy(&md5->data[md5->len & 63], data, tmp); + len -= tmp; + data += tmp; + md5->len += tmp; + if (!(md5->len & 63)) + md5_body(md5, md5->data); + } + + while (len >= 64) { + md5_body(md5, data); + md5->len += 64; + data += 64; + len -= 64; + } + + if (len) { + memcpy(md5->data, data, len); + md5->len += len; + } +} + +static int md5_write(MD5Context *const md5, Dav1dPicture *const p) { + const int hbd = p->p.bpc > 8; + const int w = p->p.w, h = p->p.h; + uint8_t *yptr = p->data[0]; + + for (int y = 0; y < h; y++) { + md5_update(md5, yptr, w << hbd); + yptr += p->stride[0]; + } + + if (p->p.layout != DAV1D_PIXEL_LAYOUT_I400) { + const int ss_ver = p->p.layout == DAV1D_PIXEL_LAYOUT_I420; + const int ss_hor = p->p.layout != DAV1D_PIXEL_LAYOUT_I444; + const int cw = (w + ss_hor) >> ss_hor; + const int ch = (h + ss_ver) >> ss_ver; + for (int pl = 1; pl <= 2; pl++) { + uint8_t *uvptr = p->data[pl]; + + for (int y = 0; y < ch; y++) { + md5_update(md5, uvptr, cw << hbd); + uvptr += p->stride[1]; + } + } + } + + dav1d_picture_unref(p); + + return 0; +} + +static void md5_close(MD5Context *const md5) { + static const uint8_t bit[2] = { 0x80, 0x00 }; + uint64_t len = md5->len << 3; + + md5_update(md5, &bit[0], 1); + while ((md5->len & 63) != 56) + md5_update(md5, &bit[1], 1); + md5_update(md5, (uint8_t *) &len, 8); + for (int i = 0; i < 4; i++) + fprintf(md5->f, "%2.2x%2.2x%2.2x%2.2x", + md5->abcd[i] & 0xff, + (md5->abcd[i] >> 8) & 0xff, + (md5->abcd[i] >> 16) & 0xff, + md5->abcd[i] >> 24); + fprintf(md5->f, "\n"); + + if (md5->f != stdin) + fclose(md5->f); +} + +const Muxer md5_muxer = { + .priv_data_size = sizeof(MD5Context), + .name = "md5", + .extension = "md5", + .write_header = md5_open, + .write_picture = md5_write, + .write_trailer = md5_close, +}; diff --git a/tools/output/muxer.h b/tools/output/muxer.h new file mode 100644 index 0000000..bd79a34 --- /dev/null +++ b/tools/output/muxer.h @@ -0,0 +1,44 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_OUTPUT_MUXER_H__ +#define __DAV1D_OUTPUT_MUXER_H__ + +#include "picture.h" + +typedef struct MuxerPriv MuxerPriv; +typedef struct Muxer { + int priv_data_size; + const char *name; + const char *extension; + int (*write_header)(MuxerPriv *ctx, const char *filename, + const Dav1dPictureParameters *p, const unsigned fps[2]); + int (*write_picture)(MuxerPriv *ctx, Dav1dPicture *p); + void (*write_trailer)(MuxerPriv *ctx); +} Muxer; + +#endif /* __DAV1D_OUTPUT_MUXER_H__ */ diff --git a/tools/output/output.c b/tools/output/output.c new file mode 100644 index 0000000..8767188 --- /dev/null +++ b/tools/output/output.c @@ -0,0 +1,141 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <assert.h> +#include <errno.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "output/output.h" +#include "output/muxer.h" + +struct MuxerContext { + MuxerPriv *data; + const Muxer *impl; +}; + +#define MAX_NUM_MUXERS 3 +static const Muxer *muxers[MAX_NUM_MUXERS]; +static int num_muxers = 0; + +#define register_muxer(impl) { \ + extern const Muxer impl; \ + assert(num_muxers < MAX_NUM_MUXERS); \ + muxers[num_muxers++] = &impl; \ +} + +void init_muxers(void) { + register_muxer(md5_muxer); + register_muxer(yuv_muxer); + register_muxer(y4m2_muxer); +} + +static const char *find_extension(const char *const f) { + const int l = strlen(f); + + if (l == 0) return NULL; + + const char *const end = &f[l - 1], *step = end; + while ((*step >= 'a' && *step <= 'z') || + (*step >= 'A' && *step <= 'Z') || + (*step >= '0' && *step <= '9')) + { + step--; + } + + return (step < end && step > f && *step == '.' && step[-1] != '/') ? + &step[1] : NULL; +} + +int output_open(MuxerContext **const c_out, + const char *const name, const char *const filename, + const Dav1dPictureParameters *const p, const unsigned fps[2]) +{ + const Muxer *impl; + MuxerContext *c; + int res, i; + + if (name) { + for (i = 0; i < num_muxers; i++) { + if (!strcmp(muxers[i]->name, name)) { + impl = muxers[i]; + break; + } + } + if (i == num_muxers) { + fprintf(stderr, "Failed to find muxer named \"%s\"\n", name); + return -ENOPROTOOPT; + } + } else { + const char *ext = find_extension(filename); + if (!ext) { + fprintf(stderr, "No extension found for file %s\n", filename); + return -1; + } + for (i = 0; i < num_muxers; i++) { + if (!strcmp(muxers[i]->extension, ext)) { + impl = muxers[i]; + break; + } + } + if (i == num_muxers) { + fprintf(stderr, "Failed to find muxer for extension \"%s\"\n", ext); + return -ENOPROTOOPT; + } + } + + if (!(c = malloc(sizeof(MuxerContext) + impl->priv_data_size))) { + fprintf(stderr, "Failed to allocate memory\n"); + return -ENOMEM; + } + c->impl = impl; + c->data = (MuxerPriv *) &c[1]; + if ((res = impl->write_header(c->data, filename, p, fps)) < 0) { + free(c); + return res; + } + *c_out = c; + + return 0; +} + +int output_write(MuxerContext *const ctx, Dav1dPicture *const p) { + int res; + + if ((res = ctx->impl->write_picture(ctx->data, p)) < 0) + return res; + + return 0; +} + +void output_close(MuxerContext *const ctx) { + ctx->impl->write_trailer(ctx->data); + free(ctx); +} diff --git a/tools/output/output.h b/tools/output/output.h new file mode 100644 index 0000000..ecba50b --- /dev/null +++ b/tools/output/output.h @@ -0,0 +1,41 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __DAV1D_OUTPUT_OUTPUT_H__ +#define __DAV1D_OUTPUT_OUTPUT_H__ + +#include "picture.h" + +typedef struct MuxerContext MuxerContext; + +void init_muxers(void); +int output_open(MuxerContext **c, const char *name, const char *filename, + const Dav1dPictureParameters *p, const unsigned fps[2]); +int output_write(MuxerContext *ctx, Dav1dPicture *pic); +void output_close(MuxerContext *ctx); + +#endif /* __DAV1D_OUTPUT_OUTPUT_H__ */ diff --git a/tools/output/y4m2.c b/tools/output/y4m2.c new file mode 100644 index 0000000..c183548 --- /dev/null +++ b/tools/output/y4m2.c @@ -0,0 +1,114 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <errno.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sys/stat.h> + +#include "output/muxer.h" + +typedef struct MuxerPriv { + FILE *f; +} Y4m2OutputContext; + +static int y4m2_open(Y4m2OutputContext *const c, const char *const file, + const Dav1dPictureParameters *p, const unsigned fps[2]) +{ + if (!strcmp(file, "-")) { + c->f = stdin; + } else if (!(c->f = fopen(file, "w"))) { + fprintf(stderr, "Failed to open %s: %s\n", file, strerror(errno)); + return -1; + } + + static const char *const ss_name[][2] = { + [DAV1D_PIXEL_LAYOUT_I400] = { "mono", "mono10" }, + [DAV1D_PIXEL_LAYOUT_I420] = { "420jpeg", "420p10" }, + [DAV1D_PIXEL_LAYOUT_I422] = { "422", "422p10" }, + [DAV1D_PIXEL_LAYOUT_I444] = { "444", "444p10" } + }; + fprintf(c->f, "YUV4MPEG2 W%d H%d C%s Ip F%d:%d\n", + p->w, p->h, ss_name[p->layout][p->bpc > 8], fps[0], fps[1]); + + return 0; +} + +static int y4m2_write(Y4m2OutputContext *const c, Dav1dPicture *const p) { + fprintf(c->f, "FRAME\n"); + + uint8_t *ptr; + const int hbd = p->p.bpc > 8; + + ptr = p->data[0]; + for (int y = 0; y < p->p.h; y++) { + if (fwrite(ptr, p->p.w << hbd, 1, c->f) != 1) + goto error; + ptr += p->stride[0]; + } + + if (p->p.layout != DAV1D_PIXEL_LAYOUT_I400) { + // u/v + const int ss_ver = p->p.layout == DAV1D_PIXEL_LAYOUT_I420; + const int ss_hor = p->p.layout != DAV1D_PIXEL_LAYOUT_I444; + const int cw = (p->p.w + ss_hor) >> ss_hor; + const int ch = (p->p.h + ss_ver) >> ss_ver; + for (int pl = 1; pl <= 2; pl++) { + ptr = p->data[pl]; + for (int y = 0; y < ch; y++) { + if (fwrite(ptr, cw << hbd, 1, c->f) != 1) + goto error; + ptr += p->stride[1]; + } + } + } + + dav1d_picture_unref(p); + return 0; + +error: + dav1d_picture_unref(p); + fprintf(stderr, "Failed to write frame data: %s\n", strerror(errno)); + return -1; +} + +static void y4m2_close(Y4m2OutputContext *const c) { + if (c->f != stdin) + fclose(c->f); +} + +const Muxer y4m2_muxer = { + .priv_data_size = sizeof(Y4m2OutputContext), + .name = "yuv4mpeg2", + .extension = "y4m", + .write_header = y4m2_open, + .write_picture = y4m2_write, + .write_trailer = y4m2_close, +}; diff --git a/tools/output/yuv.c b/tools/output/yuv.c new file mode 100644 index 0000000..726868f --- /dev/null +++ b/tools/output/yuv.c @@ -0,0 +1,104 @@ +/* + * Copyright © 2018, VideoLAN and dav1d authors + * Copyright © 2018, Two Orioles, LLC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" + +#include <errno.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sys/stat.h> + +#include "output/muxer.h" + +typedef struct MuxerPriv { + FILE *f; +} YuvOutputContext; + +static int yuv_open(YuvOutputContext *const c, const char *const file, + const Dav1dPictureParameters *const p, + const unsigned fps[2]) +{ + if (!strcmp(file, "-")) { + c->f = stdin; + } else if (!(c->f = fopen(file, "w"))) { + fprintf(stderr, "Failed to open %s: %s\n", file, strerror(errno)); + return -1; + } + + return 0; +} + +static int yuv_write(YuvOutputContext *const c, Dav1dPicture *const p) { + uint8_t *ptr; + const int hbd = p->p.bpc > 8; + + ptr = p->data[0]; + for (int y = 0; y < p->p.h; y++) { + if (fwrite(ptr, p->p.w << hbd, 1, c->f) != 1) + goto error; + ptr += p->stride[0]; + } + + if (p->p.layout != DAV1D_PIXEL_LAYOUT_I400) { + // u/v + const int ss_ver = p->p.layout == DAV1D_PIXEL_LAYOUT_I420; + const int ss_hor = p->p.layout != DAV1D_PIXEL_LAYOUT_I444; + const int cw = (p->p.w + ss_hor) >> ss_hor; + const int ch = (p->p.h + ss_ver) >> ss_ver; + for (int pl = 1; pl <= 2; pl++) { + ptr = p->data[pl]; + for (int y = 0; y < ch; y++) { + if (fwrite(ptr, cw << hbd, 1, c->f) != 1) + goto error; + ptr += p->stride[1]; + } + } + } + + dav1d_picture_unref(p); + return 0; + +error: + dav1d_picture_unref(p); + fprintf(stderr, "Failed to write frame data: %s\n", strerror(errno)); + return -1; +} + +static void yuv_close(YuvOutputContext *const c) { + if (c->f != stdin) + fclose(c->f); +} + +const Muxer yuv_muxer = { + .priv_data_size = sizeof(YuvOutputContext), + .name = "yuv", + .extension = "yuv", + .write_header = yuv_open, + .write_picture = yuv_write, + .write_trailer = yuv_close, +}; |