From df037b615fcc0196386977faae060fdfd9a887a8 Mon Sep 17 00:00:00 2001 From: Dmitry Kovalev Date: Tue, 21 May 2013 15:31:32 -0700 Subject: [PATCH] Adding API to read/write uncompressed frame header bits. The API is not final yet and can be changed. Actual layout of uncompressed frame part will be finalized later. Right now moving clr_type, error_resilient_mode, refresh_frame_context, frame_parallel_decoding_mode from first compressed partition to uncompressed frame part. Change-Id: I3afc5d4ea92c5a114f4c3d88f96858cccc15b76e --- vp9/common/vp9_common.h | 4 ++ vp9/common/vp9_header.h | 40 ------------ vp9/common/vp9_onyxc_int.h | 7 --- vp9/decoder/vp9_decodframe.c | 69 +++++++++++---------- vp9/decoder/vp9_read_bit_buffer.h | 35 +++++++++++ vp9/encoder/vp9_bitstream.c | 98 ++++++++++++------------------ vp9/encoder/vp9_onyx_if.c | 3 - vp9/encoder/vp9_write_bit_buffer.h | 38 ++++++++++++ vp9/vp9_common.mk | 1 - vp9/vp9_dx_iface.c | 2 +- vp9/vp9cx.mk | 3 +- vp9/vp9dx.mk | 3 +- 12 files changed, 160 insertions(+), 143 deletions(-) delete mode 100644 vp9/common/vp9_header.h create mode 100644 vp9/decoder/vp9_read_bit_buffer.h create mode 100644 vp9/encoder/vp9_write_bit_buffer.h diff --git a/vp9/common/vp9_common.h b/vp9/common/vp9_common.h index b6252d93e..bd062ff9b 100644 --- a/vp9/common/vp9_common.h +++ b/vp9/common/vp9_common.h @@ -60,4 +60,8 @@ static INLINE int multiple16(int value) { return (value + 15) & ~15; } +// TODO(dkovalev): remove later +#define HEADER_SIZE_IN_BYTES 4 + + #endif // VP9_COMMON_VP9_COMMON_H_ diff --git a/vp9/common/vp9_header.h b/vp9/common/vp9_header.h deleted file mode 100644 index c51ce135d..000000000 --- a/vp9/common/vp9_header.h +++ /dev/null @@ -1,40 +0,0 @@ -/* - * Copyright (c) 2010 The WebM project authors. All Rights Reserved. - * - * Use of this source code is governed by a BSD-style license - * that can be found in the LICENSE file in the root of the source - * tree. An additional intellectual property rights grant can be found - * in the file PATENTS. All contributing project authors may - * be found in the AUTHORS file in the root of the source tree. - */ - -#ifndef VP9_COMMON_VP9_HEADER_H_ -#define VP9_COMMON_VP9_HEADER_H_ - -/* 24 bits total */ -typedef struct { - unsigned int type: 1; - unsigned int version: 3; - unsigned int show_frame: 1; - - /* Allow 2^20 bytes = 8 megabits for first partition */ - - unsigned int first_partition_length_in_bytes: 19; - -#ifdef PACKET_TESTING - unsigned int frame_number; - unsigned int update_gold: 1; - unsigned int uses_gold: 1; - unsigned int update_last: 1; - unsigned int uses_last: 1; -#endif - -} VP9_HEADER; - -#ifdef PACKET_TESTING -#define VP9_HEADER_SIZE 8 -#else -#define VP9_HEADER_SIZE 3 -#endif - -#endif // VP9_COMMON_VP9_HEADER_H_ diff --git a/vp9/common/vp9_onyxc_int.h b/vp9/common/vp9_onyxc_int.h index 6ddc356fb..7333fc4b1 100644 --- a/vp9/common/vp9_onyxc_int.h +++ b/vp9/common/vp9_onyxc_int.h @@ -24,10 +24,6 @@ #include "vp9/common/vp9_postproc.h" #endif -/*#ifdef PACKET_TESTING*/ -#include "vp9/common/vp9_header.h" -/*#endif*/ - /* Create/destroy static data structures. */ void vp9_initialize_common(void); @@ -270,9 +266,6 @@ typedef struct VP9Common { int near_boffset[3]; int version; -#ifdef PACKET_TESTING - VP9_HEADER oh; -#endif double bitrate; double framerate; diff --git a/vp9/decoder/vp9_decodframe.c b/vp9/decoder/vp9_decodframe.c index 83fb8f9d9..bd0ed4b15 100644 --- a/vp9/decoder/vp9_decodframe.c +++ b/vp9/decoder/vp9_decodframe.c @@ -10,29 +10,31 @@ #include -#include "vp9/decoder/vp9_onyxd_int.h" +#include "./vp9_rtcd.h" + +#include "vpx_scale/vpx_scale.h" +#include "vpx_mem/vpx_mem.h" + #include "vp9/common/vp9_common.h" -#include "vp9/common/vp9_header.h" #include "vp9/common/vp9_reconintra.h" #include "vp9/common/vp9_reconinter.h" #include "vp9/common/vp9_entropy.h" -#include "vp9/decoder/vp9_decodframe.h" -#include "vp9/decoder/vp9_detokenize.h" #include "vp9/common/vp9_invtrans.h" #include "vp9/common/vp9_alloccommon.h" #include "vp9/common/vp9_entropymode.h" #include "vp9/common/vp9_quant_common.h" -#include "vpx_scale/vpx_scale.h" - -#include "vp9/decoder/vp9_decodemv.h" #include "vp9/common/vp9_extend.h" #include "vp9/common/vp9_modecont.h" -#include "vpx_mem/vpx_mem.h" -#include "vp9/decoder/vp9_dboolhuff.h" - #include "vp9/common/vp9_seg_common.h" #include "vp9/common/vp9_tile_common.h" -#include "vp9_rtcd.h" + +#include "vp9/decoder/vp9_decodemv.h" +#include "vp9/decoder/vp9_dboolhuff.h" +#include "vp9/decoder/vp9_read_bit_buffer.h" +#include "vp9/decoder/vp9_onyxd_int.h" +#include "vp9/decoder/vp9_decodframe.h" +#include "vp9/decoder/vp9_detokenize.h" + // #define DEC_DEBUG #ifdef DEC_DEBUG @@ -933,7 +935,7 @@ static void decode_tiles(VP9D_COMP *pbi, int vp9_decode_frame(VP9D_COMP *pbi, const uint8_t **p_data_end) { vp9_reader header_bc, residual_bc; VP9_COMMON *const pc = &pbi->common; - MACROBLOCKD *const xd = &pbi->mb; + MACROBLOCKD *const xd = &pbi->mb; const uint8_t *data = pbi->source; const uint8_t *data_end = data + pbi->source_sz; size_t first_partition_size = 0; @@ -943,24 +945,40 @@ int vp9_decode_frame(VP9D_COMP *pbi, const uint8_t **p_data_end) { xd->corrupted = 0; // start with no corruption of current frame new_fb->corrupted = 0; + + if (data_end - data < 3) { vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME, "Truncated packet"); } else { + struct vp9_read_bit_buffer rb = {data, 0}; + int scaling_active; pc->last_frame_type = pc->frame_type; - pc->frame_type = (FRAME_TYPE)(data[0] & 1); - pc->version = (data[0] >> 1) & 7; - pc->show_frame = (data[0] >> 4) & 1; - scaling_active = (data[0] >> 5) & 1; - pc->subsampling_x = (data[0] >> 6) & 1; - pc->subsampling_y = (data[0] >> 7) & 1; - first_partition_size = read_le16(data + 1); + + pc->frame_type = (FRAME_TYPE) vp9_rb_read_bit(&rb); + pc->version = vp9_rb_read_literal(&rb, 3); + pc->show_frame = vp9_rb_read_bit(&rb); + scaling_active = vp9_rb_read_bit(&rb); + pc->subsampling_x = vp9_rb_read_bit(&rb); + pc->subsampling_y = vp9_rb_read_bit(&rb); + + pc->clr_type = (YUV_TYPE)vp9_rb_read_bit(&rb); + pc->error_resilient_mode = vp9_rb_read_bit(&rb); + if (!pc->error_resilient_mode) { + pc->refresh_frame_context = vp9_rb_read_bit(&rb); + pc->frame_parallel_decoding_mode = vp9_rb_read_bit(&rb); + } else { + pc->refresh_frame_context = 0; + pc->frame_parallel_decoding_mode = 1; + } + + first_partition_size = vp9_rb_read_literal(&rb, 16); if (!read_is_valid(data, first_partition_size, data_end)) vpx_internal_error(&pc->error, VPX_CODEC_CORRUPT_FRAME, "Truncated packet or corrupt partition 0 length"); - data += 3; + data += HEADER_SIZE_IN_BYTES; // header size vp9_setup_version(pc); @@ -994,9 +1012,6 @@ int vp9_decode_frame(VP9D_COMP *pbi, const uint8_t **p_data_end) { vpx_internal_error(&pc->error, VPX_CODEC_MEM_ERROR, "Failed to allocate bool decoder 0"); - pc->clr_type = (YUV_TYPE)vp9_read_bit(&header_bc); - pc->error_resilient_mode = vp9_read_bit(&header_bc); - setup_loopfilter(pc, xd, &header_bc); setup_quantization(pbi, &header_bc); @@ -1043,14 +1058,6 @@ int vp9_decode_frame(VP9D_COMP *pbi, const uint8_t **p_data_end) { vp9_setup_interp_filters(xd, pc->mcomp_filter_type, pc); } - if (!pc->error_resilient_mode) { - pc->refresh_frame_context = vp9_read_bit(&header_bc); - pc->frame_parallel_decoding_mode = vp9_read_bit(&header_bc); - } else { - pc->refresh_frame_context = 0; - pc->frame_parallel_decoding_mode = 1; - } - pc->frame_context_idx = vp9_read_literal(&header_bc, NUM_FRAME_CONTEXTS_LG2); pc->fc = pc->frame_contexts[pc->frame_context_idx]; diff --git a/vp9/decoder/vp9_read_bit_buffer.h b/vp9/decoder/vp9_read_bit_buffer.h new file mode 100644 index 000000000..7141722f3 --- /dev/null +++ b/vp9/decoder/vp9_read_bit_buffer.h @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2013 The WebM project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef VP9_READ_BIT_BUFFER_ +#define VP9_READ_BIT_BUFFER_ + +struct vp9_read_bit_buffer { + const uint8_t *const bit_buffer; + size_t bit_offset; +}; + +static int vp9_rb_read_bit(struct vp9_read_bit_buffer *rb) { + const int off = rb->bit_offset; + const int p = off / CHAR_BIT; + const int q = /*CHAR_BIT - 1 -*/ off % CHAR_BIT; + const int bit = (rb->bit_buffer[p] & (1 << q)) >> q; + rb->bit_offset = off + 1; + return bit; +} + +static int vp9_rb_read_literal(struct vp9_read_bit_buffer *rb, int bits) { + int value = 0, bit; + for (bit = bits - 1; bit >= 0; bit--) + value |= vp9_rb_read_bit(rb) << bit; + return value; +} + +#endif // VP9_READ_BIT_BUFFER_ diff --git a/vp9/encoder/vp9_bitstream.c b/vp9/encoder/vp9_bitstream.c index b5b135576..d8839cd14 100644 --- a/vp9/encoder/vp9_bitstream.c +++ b/vp9/encoder/vp9_bitstream.c @@ -12,28 +12,28 @@ #include #include -#include "vp9/common/vp9_header.h" -#include "vp9/encoder/vp9_encodemv.h" +#include "vpx/vpx_encoder.h" +#include "vpx_mem/vpx_mem.h" + #include "vp9/common/vp9_entropymode.h" #include "vp9/common/vp9_entropymv.h" #include "vp9/common/vp9_findnearmv.h" #include "vp9/common/vp9_tile_common.h" -#include "vp9/encoder/vp9_mcomp.h" #include "vp9/common/vp9_systemdependent.h" #include "vp9/common/vp9_pragmas.h" -#include "vpx/vpx_encoder.h" -#include "vpx_mem/vpx_mem.h" -#include "vp9/encoder/vp9_bitstream.h" -#include "vp9/encoder/vp9_segmentation.h" - #include "vp9/common/vp9_seg_common.h" #include "vp9/common/vp9_pred_common.h" #include "vp9/common/vp9_entropy.h" -#include "vp9/encoder/vp9_encodemv.h" #include "vp9/common/vp9_entropymv.h" #include "vp9/common/vp9_mvref_common.h" #include "vp9/common/vp9_treecoder.h" +#include "vp9/encoder/vp9_encodemv.h" +#include "vp9/encoder/vp9_mcomp.h" +#include "vp9/encoder/vp9_bitstream.h" +#include "vp9/encoder/vp9_segmentation.h" +#include "vp9/encoder/vp9_write_bit_buffer.h" + #if defined(SECTIONBITS_OUTPUT) unsigned __int64 Sectionbits[500]; #endif @@ -1381,10 +1381,6 @@ static void update_coef_probs(VP9_COMP* const cpi, vp9_writer* const bc) { } } -#ifdef PACKET_TESTING -FILE *vpxlogc = 0; -#endif - static void decide_kf_ymode_entropy(VP9_COMP *cpi) { int mode_cost[MB_MODE_COUNT]; int bestcost = INT_MAX; @@ -1595,44 +1591,34 @@ static void encode_segmentation(VP9_COMP *cpi, vp9_writer *w) { void vp9_pack_bitstream(VP9_COMP *cpi, uint8_t *dest, unsigned long *size) { int i; - VP9_HEADER oh; VP9_COMMON *const pc = &cpi->common; - vp9_writer header_bc, residual_bc; MACROBLOCKD *const xd = &cpi->mb.e_mbd; + vp9_writer header_bc, residual_bc; int extra_bytes_packed = 0; - uint8_t *cx_data = dest; - oh.show_frame = (int) pc->show_frame; - oh.type = (int)pc->frame_type; - oh.version = pc->version; - oh.first_partition_length_in_bytes = 0; - - cx_data += 3; + cx_data += HEADER_SIZE_IN_BYTES; #if defined(SECTIONBITS_OUTPUT) - Sectionbits[active_section = 1] += sizeof(VP9_HEADER) * 8 * 256; + Sectionbits[active_section = 1] += HEADER_SIZE_IN_BYTES * 8 * 256; #endif compute_update_table(); - /* every keyframe send startcode, width, height, scale factor, clamp - * and color type. - */ - if (oh.type == KEY_FRAME) { + if (pc->frame_type == KEY_FRAME) { // Start / synch code cx_data[0] = 0x49; cx_data[1] = 0x83; cx_data[2] = 0x42; - extra_bytes_packed = 3; - cx_data += extra_bytes_packed; + extra_bytes_packed += 3; + cx_data += 3; } if (pc->width != pc->display_width || pc->height != pc->display_height) { write_le16(cx_data, pc->display_width); write_le16(cx_data + 2, pc->display_height); - cx_data += 4; extra_bytes_packed += 4; + cx_data += 4; } write_le16(cx_data, pc->width); @@ -1642,12 +1628,6 @@ void vp9_pack_bitstream(VP9_COMP *cpi, uint8_t *dest, unsigned long *size) { vp9_start_encode(&header_bc, cx_data); - // TODO(jkoleszar): remove these two unused bits? - vp9_write_bit(&header_bc, pc->clr_type); - - // error resilient mode - vp9_write_bit(&header_bc, pc->error_resilient_mode); - encode_loopfilter(pc, xd, &header_bc); encode_quantization(pc, &header_bc); @@ -1696,9 +1676,8 @@ void vp9_pack_bitstream(VP9_COMP *cpi, uint8_t *dest, unsigned long *size) { vp9_write_literal(&header_bc, cpi->alt_fb_idx, NUM_REF_FRAMES_LG2); // Indicate the sign bias for each reference frame buffer. - for (i = 0; i < ALLOWED_REFS_PER_FRAME; ++i) { + for (i = 0; i < ALLOWED_REFS_PER_FRAME; ++i) vp9_write_bit(&header_bc, pc->ref_frame_sign_bias[LAST_FRAME + i]); - } // Signal whether to allow high MV precision vp9_write_bit(&header_bc, (xd->allow_high_precision_mv) ? 1 : 0); @@ -1728,11 +1707,6 @@ void vp9_pack_bitstream(VP9_COMP *cpi, uint8_t *dest, unsigned long *size) { vp9_write_literal(&header_bc, (pc->mcomp_filter_type), 2); } - if (!pc->error_resilient_mode) { - vp9_write_bit(&header_bc, pc->refresh_frame_context); - vp9_write_bit(&header_bc, pc->frame_parallel_decoding_mode); - } - vp9_write_literal(&header_bc, pc->frame_context_idx, NUM_FRAME_CONTEXTS_LG2); @@ -1933,27 +1907,35 @@ void vp9_pack_bitstream(VP9_COMP *cpi, uint8_t *dest, unsigned long *size) { vp9_stop_encode(&header_bc); - oh.first_partition_length_in_bytes = header_bc.pos; - /* update frame tag */ { + const int first_partition_length_in_bytes = header_bc.pos; int scaling = (pc->width != pc->display_width || pc->height != pc->display_height); - int v = (oh.first_partition_length_in_bytes << 8) | - (pc->subsampling_y << 7) | - (pc->subsampling_x << 6) | - (scaling << 5) | - (oh.show_frame << 4) | - (oh.version << 1) | - oh.type; - - assert(oh.first_partition_length_in_bytes <= 0xffff); - dest[0] = v; - dest[1] = v >> 8; - dest[2] = v >> 16; + + struct vp9_write_bit_buffer wb = {dest, 0}; + + assert(first_partition_length_in_bytes <= 0xffff); + + vp9_wb_write_bit(&wb, pc->frame_type); + vp9_wb_write_literal(&wb, pc->version, 3); + vp9_wb_write_bit(&wb, pc->show_frame); + vp9_wb_write_bit(&wb, scaling); + vp9_wb_write_bit(&wb, pc->subsampling_x); + vp9_wb_write_bit(&wb, pc->subsampling_y); + + vp9_wb_write_bit(&wb, pc->clr_type); + vp9_wb_write_bit(&wb, pc->error_resilient_mode); + if (!pc->error_resilient_mode) { + vp9_wb_write_bit(&wb, pc->refresh_frame_context); + vp9_wb_write_bit(&wb, pc->frame_parallel_decoding_mode); + } + + + vp9_wb_write_literal(&wb, first_partition_length_in_bytes, 16); } - *size = VP9_HEADER_SIZE + extra_bytes_packed + header_bc.pos; + *size = HEADER_SIZE_IN_BYTES + extra_bytes_packed + header_bc.pos; if (pc->frame_type == KEY_FRAME) { decide_kf_ymode_entropy(cpi); diff --git a/vp9/encoder/vp9_onyx_if.c b/vp9/encoder/vp9_onyx_if.c index 02d46cb7d..e5c4761cc 100644 --- a/vp9/encoder/vp9_onyx_if.c +++ b/vp9/encoder/vp9_onyx_if.c @@ -258,9 +258,6 @@ void vp9_initialize_enc() { init_done = 1; } } -#ifdef PACKET_TESTING -extern FILE *vpxlogc; -#endif static void setup_features(VP9_COMP *cpi) { MACROBLOCKD *xd = &cpi->mb.e_mbd; diff --git a/vp9/encoder/vp9_write_bit_buffer.h b/vp9/encoder/vp9_write_bit_buffer.h new file mode 100644 index 000000000..88da236d0 --- /dev/null +++ b/vp9/encoder/vp9_write_bit_buffer.h @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2013 The WebM project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef VP9_BIT_WRITE_BUFFER_H_ +#define VP9_BIT_WRITE_BUFFER_H_ + +#include "vpx/vpx_integer.h" + +struct vp9_write_bit_buffer { + uint8_t *const bit_buffer; + size_t bit_offset; +}; + +static void vp9_wb_write_bit(struct vp9_write_bit_buffer *wb, int bit) { + const int off = wb->bit_offset; + const int p = off / CHAR_BIT; + const int q = /*CHAR_BIT - 1 -*/ off % CHAR_BIT; + wb->bit_buffer[p] &= ~(1 << q); + wb->bit_buffer[p] |= bit << q; + wb->bit_offset = off + 1; +} + +static void vp9_wb_write_literal(struct vp9_write_bit_buffer *wb, + int data, int bits) { + int bit; + for (bit = bits - 1; bit >= 0; bit--) + vp9_wb_write_bit(wb, (data >> bit) & 1); +} + + +#endif // VP9_BIT_WRITE_BUFFER_H_ diff --git a/vp9/vp9_common.mk b/vp9/vp9_common.mk index 0c5ce1dfe..76254d57b 100644 --- a/vp9/vp9_common.mk +++ b/vp9/vp9_common.mk @@ -38,7 +38,6 @@ VP9_COMMON_SRCS-yes += common/vp9_entropymv.h VP9_COMMON_SRCS-yes += common/vp9_enums.h VP9_COMMON_SRCS-yes += common/vp9_extend.h VP9_COMMON_SRCS-yes += common/vp9_findnearmv.h -VP9_COMMON_SRCS-yes += common/vp9_header.h VP9_COMMON_SRCS-yes += common/vp9_idct.h VP9_COMMON_SRCS-yes += common/vp9_invtrans.h VP9_COMMON_SRCS-yes += common/vp9_loopfilter.h diff --git a/vp9/vp9_dx_iface.c b/vp9/vp9_dx_iface.c index ee1130402..25fd4b34a 100644 --- a/vp9/vp9_dx_iface.c +++ b/vp9/vp9_dx_iface.c @@ -224,7 +224,7 @@ static vpx_codec_err_t vp8_peek_si(const uint8_t *data, si->is_kf = 0; if (data_sz >= 10 && !(data[0] & 0x01)) { /* I-Frame */ - const uint8_t *c = data + 3; + const uint8_t *c = data + HEADER_SIZE_IN_BYTES; si->is_kf = 1; /* vet via sync code */ diff --git a/vp9/vp9cx.mk b/vp9/vp9cx.mk index 42ab02d31..882449d5d 100644 --- a/vp9/vp9cx.mk +++ b/vp9/vp9cx.mk @@ -19,6 +19,8 @@ VP9_CX_SRCS-yes += vp9_cx_iface.c VP9_CX_SRCS-yes += encoder/vp9_bitstream.c VP9_CX_SRCS-yes += encoder/vp9_boolhuff.c +VP9_CX_SRCS-yes += encoder/vp9_boolhuff.h +VP9_CX_SRCS-yes += encoder/vp9_write_bit_buffer.h VP9_CX_SRCS-yes += encoder/vp9_dct.c VP9_CX_SRCS-yes += encoder/vp9_encodeframe.c VP9_CX_SRCS-yes += encoder/vp9_encodeframe.h @@ -27,7 +29,6 @@ VP9_CX_SRCS-yes += encoder/vp9_encodemb.c VP9_CX_SRCS-yes += encoder/vp9_encodemv.c VP9_CX_SRCS-yes += encoder/vp9_firstpass.c VP9_CX_SRCS-yes += encoder/vp9_block.h -VP9_CX_SRCS-yes += encoder/vp9_boolhuff.h VP9_CX_SRCS-yes += encoder/vp9_bitstream.h VP9_CX_SRCS-yes += encoder/vp9_encodeintra.h VP9_CX_SRCS-yes += encoder/vp9_encodemb.h diff --git a/vp9/vp9dx.mk b/vp9/vp9dx.mk index 72cdfebf4..48960c049 100644 --- a/vp9/vp9dx.mk +++ b/vp9/vp9dx.mk @@ -19,11 +19,12 @@ VP9_DX_SRCS-yes += vp9_dx_iface.c VP9_DX_SRCS-yes += decoder/vp9_asm_dec_offsets.c VP9_DX_SRCS-yes += decoder/vp9_dboolhuff.c +VP9_DX_SRCS-yes += decoder/vp9_dboolhuff.h +VP9_DX_SRCS-yes += decoder/vp9_read_bit_buffer.h VP9_DX_SRCS-yes += decoder/vp9_decodemv.c VP9_DX_SRCS-yes += decoder/vp9_decodframe.c VP9_DX_SRCS-yes += decoder/vp9_decodframe.h VP9_DX_SRCS-yes += decoder/vp9_detokenize.c -VP9_DX_SRCS-yes += decoder/vp9_dboolhuff.h VP9_DX_SRCS-yes += decoder/vp9_decodemv.h VP9_DX_SRCS-yes += decoder/vp9_detokenize.h VP9_DX_SRCS-yes += decoder/vp9_onyxd.h -- 2.40.0