Bink video decoder

Originally committed as revision 21937 to svn://svn.ffmpeg.org/ffmpeg/trunk

Kostya Shishkov committed 16 years ago

Commit 342c7df1 parent 336ce9111 files · +1790 −2Browse files

Unified · Split

11 files

Changelog +1 −1
MAINTAINERS +1 −0
doc/general.texi +2 −0
libavcodec/Makefile +1 −0
libavcodec/allcodecs.c +1 −0
libavcodec/avcodec.h +2 −1
libavcodec/bink.c +979 −0
libavcodec/binkdata.h +612 −0
libavcodec/binkidct.c +112 −0
libavcodec/dsputil.c +72 −0
libavcodec/dsputil.h +7 −0

@@ -51,7 +51,7 @@ version <next>: · 50 unmodified lines
51	- SIPR decoder	51	- SIPR decoder
52	- Adobe Filmstrip muxer and demuxer	52	- Adobe Filmstrip muxer and demuxer
53	- RTP depacketization of H.263	53	- RTP depacketization of H.263
54	- Bink demuxer and Bink Audio decoder	54	- Bink demuxer and audio/video decoders
55	- enable symbol versioning by default for linkers that support it	55	- enable symbol versioning by default for linkers that support it
56	- IFF PBM/ILBM bitmap decoder	56	- IFF PBM/ILBM bitmap decoder
57	- concat protocol	57	- concat protocol

MAINTAINERS+1−0

@@ -112,6 +112,7 @@ Codecs: · 111 unmodified lines
112	asv* Michael Niedermayer	112	asv* Michael Niedermayer
113	atrac3* Benjamin Larsson	113	atrac3* Benjamin Larsson
114	bgmc.c, bgmc.h Thilo Borgmann	114	bgmc.c, bgmc.h Thilo Borgmann
		115	bink.c Kostya Shishkov
115	bmp.c Mans Rullgard, Kostya Shishkov	116	bmp.c Mans Rullgard, Kostya Shishkov
116	cavs* Stefan Gehrer	117	cavs* Stefan Gehrer
117	celp_filters.* Vitor Sessak	118	celp_filters.* Vitor Sessak

doc/general.texi+2−0

 @item Beam Software VB       @tab     @tab  X
 @item Bethesda VID video     @tab     @tab  X
     @tab Used in some games from Bethesda Softworks.
+@item Bink Video             @tab     @tab  X
+    @tab Support for version 'b' is missing.
 @item Brute Force & Ignorance   @tab   @tab X
     @tab Used in the game Flash Traffic: City of Angels.
 @item C93 video              @tab     @tab  X

libavcodec/Makefile+1−0

@@ -65,6 +65,7 @@ OBJS-$(CONFIG_AURA2_DECODER) += aura.o · 64 unmodified lines
65	OBJS-$(CONFIG_AVS_DECODER) += avs.o	65	OBJS-$(CONFIG_AVS_DECODER) += avs.o
66	OBJS-$(CONFIG_BETHSOFTVID_DECODER) += bethsoftvideo.o	66	OBJS-$(CONFIG_BETHSOFTVID_DECODER) += bethsoftvideo.o
67	OBJS-$(CONFIG_BFI_DECODER) += bfi.o	67	OBJS-$(CONFIG_BFI_DECODER) += bfi.o
		68	OBJS-$(CONFIG_BINK_DECODER) += bink.o binkidct.o
68	OBJS-$(CONFIG_BINKAUDIO_DCT_DECODER) += binkaudio.o wma.o	69	OBJS-$(CONFIG_BINKAUDIO_DCT_DECODER) += binkaudio.o wma.o
69	OBJS-$(CONFIG_BINKAUDIO_RDFT_DECODER) += binkaudio.o wma.o	70	OBJS-$(CONFIG_BINKAUDIO_RDFT_DECODER) += binkaudio.o wma.o
70	OBJS-$(CONFIG_BMP_DECODER) += bmp.o msrledec.o	71	OBJS-$(CONFIG_BMP_DECODER) += bmp.o msrledec.o

libavcodec/allcodecs.c+1−0

@@ -75,6 +75,7 @@ void avcodec_register_all(void) · 74 unmodified lines
75	REGISTER_DECODER (AVS, avs);	75	REGISTER_DECODER (AVS, avs);
76	REGISTER_DECODER (BETHSOFTVID, bethsoftvid);	76	REGISTER_DECODER (BETHSOFTVID, bethsoftvid);
77	REGISTER_DECODER (BFI, bfi);	77	REGISTER_DECODER (BFI, bfi);
		78	REGISTER_DECODER (BINK, bink);
78	REGISTER_ENCDEC (BMP, bmp);	79	REGISTER_ENCDEC (BMP, bmp);
79	REGISTER_DECODER (C93, c93);	80	REGISTER_DECODER (C93, c93);
80	REGISTER_DECODER (CAVS, cavs);	81	REGISTER_DECODER (CAVS, cavs);

libavcodec/avcodec.h+2−1

 #include "libavutil/avutil.h"
 #define LIBAVCODEC_VERSION_MAJOR 52
-#define LIBAVCODEC_VERSION_MINOR 54
+#define LIBAVCODEC_VERSION_MINOR 55
 #define LIBAVCODEC_VERSION_MICRO  0
 #define LIBAVCODEC_VERSION_INT  AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
 #define FF_IDCT_EA            21
 #define FF_IDCT_SIMPLENEON    22
 #define FF_IDCT_SIMPLEALPHA   23
+#define FF_IDCT_BINK          24
     /**
      * slice count

libavcodec/bink.c+979−0

@@ -0,0 +1,979 @@
	1	/*
	2	* Bink video decoder
	3	* Copyright (c) 2009 Konstantin Shishkov
	4	*
	5	* This file is part of FFmpeg.
	6	*
	7	* FFmpeg is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU Lesser General Public
	9	* License as published by the Free Software Foundation; either
	10	* version 2.1 of the License, or (at your option) any later version.
	11	*
	12	* FFmpeg is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* Lesser General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU Lesser General Public
	18	* License along with FFmpeg; if not, write to the Free Software
	19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	20	*/
	21
	22	#include "avcodec.h"
	23	#include "dsputil.h"
	24	#include "binkdata.h"
	25	#include "mathops.h"
	26
	27	#define ALT_BITSTREAM_READER_LE
	28	#include "get_bits.h"
	29
	30	static VLC bink_trees[16];
	31
	32	/**
	33	* IDs for different data types used in Bink video codec
	34	*/
	35	enum Sources {
	36	BINK_SRC_BLOCK_TYPES = 0, ///< 8x8 block types
	37	BINK_SRC_SUB_BLOCK_TYPES, ///< 16x16 block types (a subset of 8x8 block types)
	38	BINK_SRC_COLORS, ///< pixel values used for different block types
	39	BINK_SRC_PATTERN, ///< 8-bit values for 2-colour pattern fill
	40	BINK_SRC_X_OFF, ///< X components of motion value
	41	BINK_SRC_Y_OFF, ///< Y components of motion value
	42	BINK_SRC_INTRA_DC, ///< DC values for intrablocks with DCT
	43	BINK_SRC_INTER_DC, ///< DC values for intrablocks with DCT
	44	BINK_SRC_RUN, ///< run lengths for special fill block
	45
	46	BINK_NB_SRC
	47	};
	48
	49	/**
	50	* data needed to decode 4-bit Huffman-coded value
	51	*/
	52	typedef struct Tree {
	53	int vlc_num; ///< tree number (in bink_trees[])
	54	uint8_t syms[16]; ///< leaf value to symbol mapping
	55	} Tree;
	56
	57	#define GET_HUFF(gb, tree) (tree).syms[get_vlc2(gb, bink_trees[(tree).vlc_num].table,\
	58	bink_trees[(tree).vlc_num].bits, 1)]
	59
	60	/**
	61	* data structure used for decoding single Bink data type
	62	*/
	63	typedef struct Bundle {
	64	int len; ///< length of number of entries to decode (in bits)
	65	Tree tree; ///< Huffman tree-related data
	66	uint8_t *data; ///< buffer for decoded symbols
	67	uint8_t *data_end; ///< buffer end
	68	uint8_t *cur_dec; ///< pointer to the not yet decoded part of the buffer
	69	uint8_t *cur_ptr; ///< pointer to the data that is not read from buffer yet
	70	} Bundle;
	71
	72	/*
	73	* Decoder context
	74	*/
	75	typedef struct BinkContext {
	76	AVCodecContext *avctx;
	77	DSPContext dsp;
	78	AVFrame pic, last;
	79	int version; ///< internal Bink file version
	80	int swap_planes;
	81	ScanTable scantable; ///< permutated scantable for DCT coeffs decoding
	82
	83	Bundle bundle[BINK_NB_SRC]; ///< bundles for decoding all data types
	84	Tree col_high[16]; ///< trees for decoding high nibble in "colours" data type
	85	int col_lastval; ///< value of last decoded high nibble in "colours" data type
	86	} BinkContext;
	87
	88	/**
	89	* Bink video block types
	90	*/
	91	enum BlockTypes {
	92	SKIP_BLOCK = 0, ///< skipped block
	93	SCALED_BLOCK, ///< block has size 16x16
	94	MOTION_BLOCK, ///< block is copied from previous frame with some offset
	95	RUN_BLOCK, ///< block is composed from runs of colours with custom scan order
	96	RESIDUE_BLOCK, ///< motion block with some difference added
	97	INTRA_BLOCK, ///< intra DCT block
	98	FILL_BLOCK, ///< block is filled with single colour
	99	INTER_BLOCK, ///< motion block with DCT applied to the difference
	100	PATTERN_BLOCK, ///< block is filled with two colours following custom pattern
	101	RAW_BLOCK, ///< uncoded 8x8 block
	102	};
	103
	104	/**
	105	* Initializes length length in all bundles.
	106	*
	107	* @param c decoder context
	108	* @param width plane width
	109	* @param bw plane width in 8x8 blocks
	110	*/
	111	static void init_lengths(BinkContext *c, int width, int bw)
	112	{
	113	c->bundle[BINK_SRC_BLOCK_TYPES].len = av_log2((width >> 3) + 511) + 1;
	114
	115	c->bundle[BINK_SRC_SUB_BLOCK_TYPES].len = av_log2((width >> 4) + 511) + 1;
	116
	117	c->bundle[BINK_SRC_COLORS].len = av_log2((width >> 3)*64 + 511) + 1;
	118
	119	c->bundle[BINK_SRC_INTRA_DC].len =
	120	c->bundle[BINK_SRC_INTER_DC].len =
	121	c->bundle[BINK_SRC_X_OFF].len =
	122	c->bundle[BINK_SRC_Y_OFF].len = av_log2((width >> 3) + 511) + 1;
	123
	124	c->bundle[BINK_SRC_PATTERN].len = av_log2((bw << 3) + 511) + 1;
	125
	126	c->bundle[BINK_SRC_RUN].len = av_log2((width >> 3)*48 + 511) + 1;
	127	}
	128
	129	/**
	130	* Allocates memory for bundles.
	131	*
	132	* @param c decoder context
	133	*/
	134	static av_cold void init_bundles(BinkContext *c)
	135	{
	136	int bw, bh, blocks;
	137	int i;
	138
	139	bw = (c->avctx->width + 7) >> 3;
	140	bh = (c->avctx->height + 7) >> 3;
	141	blocks = bw * bh;
	142
	143	for (i = 0; i < BINK_NB_SRC; i++) {
	144	c->bundle[i].data = av_malloc(blocks * 64);
	145	c->bundle[i].data_end = c->bundle[i].data + blocks * 64;
	146	}
	147	}
	148
	149	/**
	150	* Frees memory used by bundles.
	151	*
	152	* @param c decoder context
	153	*/
	154	static av_cold void free_bundles(BinkContext *c)
	155	{
	156	int i;
	157	for (i = 0; i < BINK_NB_SRC; i++)
	158	av_freep(&c->bundle[i].data);
	159	}
	160
	161	/**
	162	* Merges two consequent lists of equal size depending on bits read.
	163	*
	164	* @param gb context for reading bits
	165	* @param dst buffer where merged list will be written to
	166	* @param src pointer to the head of the first list (the second lists starts at src+size)
	167	* @param size input lists size
	168	*/
	169	static void merge(GetBitContext gb, uint8_t dst, uint8_t *src, int size)
	170	{
	171	uint8_t *src2 = src + size;
	172	int size2 = size;
	173
	174	do {
	175	if (!get_bits1(gb)) {
	176	dst++ = src++;
	177	size--;
	178	} else {
	179	dst++ = src2++;
	180	size2--;
	181	}
	182	} while (size && size2);
	183
	184	while (size--)
	185	dst++ = src++;
	186	while (size2--)
	187	dst++ = src2++;
	188	}
	189
	190	/**
	191	* Reads information about Huffman tree used to decode data.
	192	*
	193	* @param gb context for reading bits
	194	* @param tree pointer for storing tree data
	195	*/
	196	static void read_tree(GetBitContext gb, Tree tree)
	197	{
	198	uint8_t tmp1[16], tmp2[16], in = tmp1, out = tmp2;
	199	int i, t, len;
	200
	201	tree->vlc_num = get_bits(gb, 4);
	202	if (!tree->vlc_num) {
	203	for (i = 0; i < 16; i++)
	204	tree->syms[i] = i;
	205	return;
	206	}
	207	if (get_bits1(gb)) {
	208	len = get_bits(gb, 3);
	209	memset(tmp1, 0, sizeof(tmp1));
	210	for (i = 0; i <= len; i++) {
	211	tree->syms[i] = get_bits(gb, 4);
	212	tmp1[tree->syms[i]] = 1;
	213	}
	214	for (i = 0; i < 16; i++)
	215	if (!tmp1[i])
	216	tree->syms[++len] = i;
	217	} else {
	218	len = get_bits(gb, 2);
	219	for (i = 0; i < 16; i++)
	220	in[i] = i;
	221	for (i = 0; i <= len; i++) {
	222	int size = 1 << i;
	223	for (t = 0; t < 16; t += size << 1)
	224	merge(gb, out + t, in + t, size);
	225	FFSWAP(uint8_t*, in, out);
	226	}
	227	memcpy(tree->syms, in, 16);
	228	}
	229	}
	230
	231	/**
	232	* Prepares bundle for decoding data.
	233	*
	234	* @param gb context for reading bits
	235	* @param c decoder context
	236	* @param bundle_num number of the bundle to initialize
	237	*/
	238	static void read_bundle(GetBitContext gb, BinkContext c, int bundle_num)
	239	{
	240	int i;
	241
	242	if (bundle_num == BINK_SRC_COLORS) {
	243	for (i = 0; i < 16; i++)
	244	read_tree(gb, &c->col_high[i]);
	245	c->col_lastval = 0;
	246	}
	247	if (bundle_num != BINK_SRC_INTRA_DC && bundle_num != BINK_SRC_INTER_DC)
	248	read_tree(gb, &c->bundle[bundle_num].tree);
	249	c->bundle[bundle_num].cur_dec =
	250	c->bundle[bundle_num].cur_ptr = c->bundle[bundle_num].data;
	251	}
	252
	253	/**
	254	* common check before starting decoding bundle data
	255	*
	256	* @param gb context for reading bits
	257	* @param b bundle
	258	* @param t variable where number of elements to decode will be stored
	259	*/
	260	#define CHECK_READ_VAL(gb, b, t) \
	261	if (!b->cur_dec \|\| (b->cur_dec > b->cur_ptr)) \
	262	return 0; \
	263	t = get_bits(gb, b->len); \
	264	if (!t) { \
	265	b->cur_dec = NULL; \
	266	return 0; \
	267	} \
	268
	269	static int read_runs(AVCodecContext avctx, GetBitContext gb, Bundle *b)
	270	{
	271	int t, v;
	272	const uint8_t *dec_end;
	273
	274	CHECK_READ_VAL(gb, b, t);
	275	dec_end = b->cur_dec + t;
	276	if (dec_end > b->data_end) {
	277	av_log(avctx, AV_LOG_ERROR, "Run value went out of bounds\n");
	278	return -1;
	279	}
	280	if (get_bits1(gb)) {
	281	v = get_bits(gb, 4);
	282	memset(b->cur_dec, v, t);
	283	b->cur_dec += t;
	284	} else {
	285	while (b->cur_dec < dec_end)
	286	*b->cur_dec++ = GET_HUFF(gb, b->tree);
	287	}
	288	return 0;
	289	}
	290
	291	static int read_motion_values(AVCodecContext avctx, GetBitContext gb, Bundle *b)
	292	{
	293	int t, sign, v;
	294	const uint8_t *dec_end;
	295
	296	CHECK_READ_VAL(gb, b, t);
	297	dec_end = b->cur_dec + t;
	298	if (dec_end > b->data_end) {
	299	av_log(avctx, AV_LOG_ERROR, "Too many motion values\n");
	300	return -1;
	301	}
	302	if (get_bits1(gb)) {
	303	v = get_bits(gb, 4);
	304	if (v) {
	305	sign = -get_bits1(gb);
	306	v = (v ^ sign) - sign;
	307	}
	308	memset(b->cur_dec, v, t);
	309	b->cur_dec += t;
	310	} else {
	311	do {
	312	v = GET_HUFF(gb, b->tree);
	313	if (v) {
	314	sign = -get_bits1(gb);
	315	v = (v ^ sign) - sign;
	316	}
	317	*b->cur_dec++ = v;
	318	} while (b->cur_dec < dec_end);
	319	}
	320	return 0;
	321	}
	322
	323	const uint8_t bink_rlelens[4] = { 4, 8, 12, 32 };
	324
	325	static int read_block_types(AVCodecContext avctx, GetBitContext gb, Bundle *b)
	326	{
	327	int t, v;
	328	int last = 0;
	329	const uint8_t *dec_end;
	330
	331	CHECK_READ_VAL(gb, b, t);
	332	dec_end = b->cur_dec + t;
	333	if (dec_end > b->data_end) {
	334	av_log(avctx, AV_LOG_ERROR, "Too many block type values\n");
	335	return -1;
	336	}
	337	if (get_bits1(gb)) {
	338	v = get_bits(gb, 4);
	339	memset(b->cur_dec, v, t);
	340	b->cur_dec += t;
	341	} else {
	342	do {
	343	v = GET_HUFF(gb, b->tree);
	344	if (v < 12) {
	345	last = v;
	346	*b->cur_dec++ = v;
	347	} else {
	348	int run = bink_rlelens[v - 12];
	349
	350	memset(b->cur_dec, last, run);
	351	b->cur_dec += run;
	352	}
	353	} while (b->cur_dec < dec_end);
	354	}
	355	return 0;
	356	}
	357
	358	static int read_patterns(AVCodecContext avctx, GetBitContext gb, Bundle *b)
	359	{
	360	int t, v;
	361	const uint8_t *dec_end;
	362
	363	CHECK_READ_VAL(gb, b, t);
	364	dec_end = b->cur_dec + t;
	365	if (dec_end > b->data_end) {
	366	av_log(avctx, AV_LOG_ERROR, "Too many pattern values\n");
	367	return -1;
	368	}
	369	while (b->cur_dec < dec_end) {
	370	v = GET_HUFF(gb, b->tree);
	371	v \|= GET_HUFF(gb, b->tree) << 4;
	372	*b->cur_dec++ = v;
	373	}
	374
	375	return 0;
	376	}
	377
	378	static int read_colors(GetBitContext gb, Bundle b, BinkContext *c)
	379	{
	380	int t, sign, v;
	381	const uint8_t *dec_end;
	382
	383	CHECK_READ_VAL(gb, b, t);
	384	dec_end = b->cur_dec + t;
	385	if (dec_end > b->data_end) {
	386	av_log(c->avctx, AV_LOG_ERROR, "Too many color values\n");
	387	return -1;
	388	}
	389	if (get_bits1(gb)) {
	390	c->col_lastval = GET_HUFF(gb, c->col_high[c->col_lastval]);
	391	v = GET_HUFF(gb, b->tree);
	392	v = (c->col_lastval << 4) \| v;
	393	if (c->version < 'i') {
	394	sign = ((int8_t) v) >> 7;
	395	v = ((v & 0x7F) ^ sign) - sign;
	396	v += 0x80;
	397	}
	398	memset(b->cur_dec, v, t);
	399	b->cur_dec += t;
	400	} else {
	401	while (b->cur_dec < dec_end) {
	402	c->col_lastval = GET_HUFF(gb, c->col_high[c->col_lastval]);
	403	v = GET_HUFF(gb, b->tree);
	404	v = (c->col_lastval << 4) \| v;
	405	if (c->version < 'i') {
	406	sign = ((int8_t) v) >> 7;
	407	v = ((v & 0x7F) ^ sign) - sign;
	408	v += 0x80;
	409	}
	410	*b->cur_dec++ = v;
	411	}
	412	}
	413	return 0;
	414	}
	415
	416	/** number of bits used to store first DC value in bundle */
	417	#define DC_START_BITS 11
	418
	419	static int read_dcs(AVCodecContext avctx, GetBitContext gb, Bundle *b,
	420	int start_bits, int has_sign)
	421	{
	422	int i, j, len, len2, bsize, sign, v, v2;
	423	int16_t dst = (int16_t)b->cur_dec;
	424
	425	CHECK_READ_VAL(gb, b, len);
	426	v = get_bits(gb, start_bits - has_sign);
	427	if (v && has_sign) {
	428	sign = -get_bits1(gb);
	429	v = (v ^ sign) - sign;
	430	}
	431	*dst++ = v;
	432	len--;
	433	for (i = 0; i < len; i += 8) {
	434	len2 = FFMIN(len - i, 8);
	435	bsize = get_bits(gb, 4);
	436	if (bsize) {
	437	for (j = 0; j < len2; j++) {
	438	v2 = get_bits(gb, bsize);
	439	if (v2) {
	440	sign = -get_bits1(gb);
	441	v2 = (v2 ^ sign) - sign;
	442	}
	443	v += v2;
	444	*dst++ = v;
	445	if (v < -32768 \|\| v > 32767) {
	446	av_log(avctx, AV_LOG_ERROR, "DC value went out of bounds: %d\n", v);
	447	return -1;
	448	}
	449	}
	450	} else {
	451	for (j = 0; j < len2; j++)
	452	*dst++ = v;
	453	}
	454	}
	455
	456	b->cur_dec = (uint8_t*)dst;
	457	return 0;
	458	}
	459
	460	/**
	461	* Retrieves next value from bundle.
	462	*
	463	* @param c decoder context
	464	* @param bundle bundle number
	465	*/
	466	static inline int get_value(BinkContext *c, int bundle)
	467	{
	468	int16_t ret;
	469
	470	if (bundle < BINK_SRC_X_OFF \|\| bundle == BINK_SRC_RUN)
	471	return *c->bundle[bundle].cur_ptr++;
	472	if (bundle == BINK_SRC_X_OFF \|\| bundle == BINK_SRC_Y_OFF)
	473	return (int8_t)*c->bundle[bundle].cur_ptr++;
	474	ret = (int16_t)c->bundle[bundle].cur_ptr;
	475	c->bundle[bundle].cur_ptr += 2;
	476	return ret;
	477	}
	478
	479	/**
	480	* Reads 8x8 block of DCT coefficients.
	481	*
	482	* @param gb context for reading bits
	483	* @param block place for storing coefficients
	484	* @param scan scan order table
	485	* @param is_intra tells what set of quantizer matrices to use
	486	* @return 0 for success, negative value in other cases
	487	*/
	488	static int read_dct_coeffs(GetBitContext gb, DCTELEM block[64], const uint8_t scan,
	489	int is_intra)
	490	{
	491	int coef_list[128];
	492	int mode_list[128];
	493	int i, t, mask, bits, ccoef, mode, sign;
	494	int list_start = 64, list_end = 64, list_pos;
	495	int coef_count = 0;
	496	int coef_idx[64];
	497	int quant_idx;
	498	const uint32_t *quant;
	499
	500	coef_list[list_end] = 4; mode_list[list_end++] = 0;
	501	coef_list[list_end] = 24; mode_list[list_end++] = 0;
	502	coef_list[list_end] = 44; mode_list[list_end++] = 0;
	503	coef_list[list_end] = 1; mode_list[list_end++] = 3;
	504	coef_list[list_end] = 2; mode_list[list_end++] = 3;
	505	coef_list[list_end] = 3; mode_list[list_end++] = 3;
	506
	507	bits = get_bits(gb, 4) - 1;
	508	for (mask = 1 << bits; bits >= 0; mask >>= 1, bits--) {
	509	list_pos = list_start;
	510	while (list_pos < list_end) {
	511	if (!(mode_list[list_pos] \| coef_list[list_pos]) \|\| !get_bits1(gb)) {
	512	list_pos++;
	513	continue;
	514	}
	515	ccoef = coef_list[list_pos];
	516	mode = mode_list[list_pos];
	517	switch (mode) {
	518	case 0:
	519	coef_list[list_pos] = ccoef + 4;
	520	mode_list[list_pos] = 1;
	521	case 2:
	522	if (mode == 2) {
	523	coef_list[list_pos] = 0;
	524	mode_list[list_pos++] = 0;
	525	}
	526	for (i = 0; i < 4; i++, ccoef++) {
	527	if (get_bits1(gb)) {
	528	coef_list[--list_start] = ccoef;
	529	mode_list[ list_start] = 3;
	530	} else {
	531	int t;
	532	if (!bits) {
	533	t = 1 - (get_bits1(gb) << 1);
	534	} else {
	535	t = get_bits(gb, bits) \| mask;
	536	sign = -get_bits1(gb);
	537	t = (t ^ sign) - sign;
	538	}
	539	block[scan[ccoef]] = t;
	540	coef_idx[coef_count++] = ccoef;
	541	}
	542	}
	543	break;
	544	case 1:
	545	mode_list[list_pos] = 2;
	546	for (i = 0; i < 3; i++) {
	547	ccoef += 4;
	548	coef_list[list_end] = ccoef;
	549	mode_list[list_end++] = 2;
	550	}
	551	break;
	552	case 3:
	553	if (!bits) {
	554	t = 1 - (get_bits1(gb) << 1);
	555	} else {
	556	t = get_bits(gb, bits) \| mask;
	557	sign = -get_bits1(gb);
	558	t = (t ^ sign) - sign;
	559	}
	560	block[scan[ccoef]] = t;
	561	coef_idx[coef_count++] = ccoef;
	562	coef_list[list_pos] = 0;
	563	mode_list[list_pos++] = 0;
	564	break;
	565	}
	566	}
	567	}
	568
	569	quant_idx = get_bits(gb, 4);
	570	quant = is_intra ? bink_intra_quant[quant_idx]
	571	: bink_inter_quant[quant_idx];
	572	block[0] = (block[0] * quant[0]) >> 11;
	573	for (i = 0; i < coef_count; i++) {
	574	int idx = coef_idx[i];
	575	block[scan[idx]] = (block[scan[idx]] * quant[idx]) >> 11;
	576	}
	577
	578	return 0;
	579	}
	580
	581	/**
	582	* Reads 8x8 block with residue after motion compensation.
	583	*
	584	* @param gb context for reading bits
	585	* @param block place to store read data
	586	* @param masks_count number of masks to decode
	587	* @return 0 on success, negative value in other cases
	588	*/
	589	static int read_residue(GetBitContext *gb, DCTELEM block[64], int masks_count)
	590	{
	591	int coef_list[128];
	592	int mode_list[128];
	593	int i, sign, mask, ccoef, mode;
	594	int list_start = 64, list_end = 64, list_pos;
	595	int nz_coeff[64];
	596	int nz_coeff_count = 0;
	597
	598	coef_list[list_end] = 4; mode_list[list_end++] = 0;
	599	coef_list[list_end] = 24; mode_list[list_end++] = 0;
	600	coef_list[list_end] = 44; mode_list[list_end++] = 0;
	601	coef_list[list_end] = 0; mode_list[list_end++] = 2;
	602
	603	for (mask = 1 << get_bits(gb, 3); mask; mask >>= 1) {
	604	for (i = 0; i < nz_coeff_count; i++) {
	605	if (!get_bits1(gb))
	606	continue;
	607	if (block[nz_coeff[i]] < 0)
	608	block[nz_coeff[i]] -= mask;
	609	else
	610	block[nz_coeff[i]] += mask;
	611	masks_count--;
	612	if (masks_count < 0)
	613	return 0;
	614	}
	615	list_pos = list_start;
	616	while (list_pos < list_end) {
	617	if (!(coef_list[list_pos] \| mode_list[list_pos]) \|\| !get_bits1(gb)) {
	618	list_pos++;
	619	continue;
	620	}
	621	ccoef = coef_list[list_pos];
	622	mode = mode_list[list_pos];
	623	switch (mode) {
	624	case 0:
	625	coef_list[list_pos] = ccoef + 4;
	626	mode_list[list_pos] = 1;
	627	case 2:
	628	if (mode == 2) {
	629	coef_list[list_pos] = 0;
	630	mode_list[list_pos++] = 0;
	631	}
	632	for (i = 0; i < 4; i++, ccoef++) {
	633	if (get_bits1(gb)) {
	634	coef_list[--list_start] = ccoef;
	635	mode_list[ list_start] = 3;
	636	} else {
	637	nz_coeff[nz_coeff_count++] = bink_scan[ccoef];
	638	sign = -get_bits1(gb);
	639	block[bink_scan[ccoef]] = (mask ^ sign) - sign;
	640	masks_count--;
	641	if (masks_count < 0)
	642	return 0;
	643	}
	644	}
	645	break;
	646	case 1:
	647	mode_list[list_pos] = 2;
	648	for (i = 0; i < 3; i++) {
	649	ccoef += 4;
	650	coef_list[list_end] = ccoef;
	651	mode_list[list_end++] = 2;
	652	}
	653	break;
	654	case 3:
	655	nz_coeff[nz_coeff_count++] = bink_scan[ccoef];
	656	sign = -get_bits1(gb);
	657	block[bink_scan[ccoef]] = (mask ^ sign) - sign;
	658	coef_list[list_pos] = 0;
	659	mode_list[list_pos++] = 0;
	660	masks_count--;
	661	if (masks_count < 0)
	662	return 0;
	663	break;
	664	}
	665	}
	666	}
	667
	668	return 0;
	669	}
	670
	671	static int decode_frame(AVCodecContext avctx, void data, int data_size, AVPacket pkt)
	672	{
	673	BinkContext * const c = avctx->priv_data;
	674	GetBitContext gb;
	675	int blk;
	676	int i, j, plane, plane_idx, bx, by;
	677	uint8_t dst, prev, ref, ref_start, *ref_end;
	678	int v, col[2];
	679	const uint8_t *scan;
	680	int xoff, yoff;
	681	DECLARE_ALIGNED_16(DCTELEM, block[64]);
	682	DECLARE_ALIGNED_16(uint8_t, ublock[64]);
	683	int coordmap[64];
	684
	685	if(c->pic.data[0])
	686	avctx->release_buffer(avctx, &c->pic);
	687
	688	if(avctx->get_buffer(avctx, &c->pic) < 0){
	689	av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
	690	return -1;
	691	}
	692
	693	init_get_bits(&gb, pkt->data, pkt->size*8);
	694	if (c->version >= 'i')
	695	skip_bits_long(&gb, 32);
	696
	697	for (plane = 0; plane < 3; plane++) {
	698	const int stride = c->pic.linesize[plane];
	699	int bw = plane ? (avctx->width + 15) >> 4 : (avctx->width + 7) >> 3;
	700	int bh = plane ? (avctx->height + 15) >> 4 : (avctx->height + 7) >> 3;
	701
	702	init_lengths(c, avctx->width >> !!plane, bw);
	703	for (i = 0; i < BINK_NB_SRC; i++)
	704	read_bundle(&gb, c, i);
	705
	706	plane_idx = (!plane \|\| !c->swap_planes) ? plane : (plane ^ 3);
	707	ref_start = c->last.data[plane_idx];
	708	ref_end = c->last.data[plane_idx]
	709	+ (bw - 1 + c->last.linesize[plane_idx] * (bh - 1)) * 8;
	710
	711	for (i = 0; i < 64; i++)
	712	coordmap[i] = (i & 7) + (i >> 3) * stride;
	713
	714	for (by = 0; by < bh; by++) {
	715	if (read_block_types(avctx, &gb, &c->bundle[BINK_SRC_BLOCK_TYPES]) < 0)
	716	return -1;
	717	if (read_block_types(avctx, &gb, &c->bundle[BINK_SRC_SUB_BLOCK_TYPES]) < 0)
	718	return -1;
	719	if (read_colors(&gb, &c->bundle[BINK_SRC_COLORS], c) < 0)
	720	return -1;
	721	if (read_patterns(avctx, &gb, &c->bundle[BINK_SRC_PATTERN]) < 0)
	722	return -1;
	723	if (read_motion_values(avctx, &gb, &c->bundle[BINK_SRC_X_OFF]) < 0)
	724	return -1;
	725	if (read_motion_values(avctx, &gb, &c->bundle[BINK_SRC_Y_OFF]) < 0)
	726	return -1;
	727	if (read_dcs(avctx, &gb, &c->bundle[BINK_SRC_INTRA_DC], DC_START_BITS, 0) < 0)
	728	return -1;
	729	if (read_dcs(avctx, &gb, &c->bundle[BINK_SRC_INTER_DC], DC_START_BITS, 1) < 0)
	730	return -1;
	731	if (read_runs(avctx, &gb, &c->bundle[BINK_SRC_RUN]) < 0)
	732	return -1;
	733
	734	if (by == bh)
	735	break;
	736	dst = c->pic.data[plane_idx] + 8bystride;
	737	prev = c->last.data[plane_idx] + 8bystride;
	738	for (bx = 0; bx < bw; bx++, dst += 8, prev += 8) {
	739	blk = get_value(c, BINK_SRC_BLOCK_TYPES);
	740	// 16x16 block type on odd line means part of the already decoded block, so skip it
	741	if ((by & 1) && blk == SCALED_BLOCK) {
	742	bx++;
	743	dst += 8;
	744	prev += 8;
	745	continue;
	746	}
	747	switch (blk) {
	748	case SKIP_BLOCK:
	749	c->dsp.put_pixels_tab[1][0](dst, prev, stride, 8);
	750	break;
	751	case SCALED_BLOCK:
	752	blk = get_value(c, BINK_SRC_SUB_BLOCK_TYPES);
	753	switch (blk) {
	754	case RUN_BLOCK:
	755	scan = bink_patterns[get_bits(&gb, 4)];
	756	i = 0;
	757	do {
	758	int run = get_value(c, BINK_SRC_RUN) + 1;
	759
	760	i += run;
	761	if (i > 64) {
	762	av_log(avctx, AV_LOG_ERROR, "Run went out of bounds\n");
	763	return -1;
	764	}
	765	if (get_bits1(&gb)) {
	766	v = get_value(c, BINK_SRC_COLORS);
	767	for (j = 0; j < run; j++)
	768	ublock[*scan++] = v;
	769	} else {
	770	for (j = 0; j < run; j++)
	771	ublock[*scan++] = get_value(c, BINK_SRC_COLORS);
	772	}
	773	} while (i < 63);
	774	if (i == 63)
	775	ublock[*scan++] = get_value(c, BINK_SRC_COLORS);
	776	break;
	777	case INTRA_BLOCK:
	778	c->dsp.clear_block(block);
	779	block[0] = get_value(c, BINK_SRC_INTRA_DC);
	780	read_dct_coeffs(&gb, block, c->scantable.permutated, 1);
	781	c->dsp.idct(block);
	782	c->dsp.put_pixels_nonclamped(block, ublock, 8);
	783	break;
	784	case FILL_BLOCK:
	785	v = get_value(c, BINK_SRC_COLORS);
	786	c->dsp.fill_block_tab[0](dst, v, stride, 16);
	787	break;
	788	case PATTERN_BLOCK:
	789	for (i = 0; i < 2; i++)
	790	col[i] = get_value(c, BINK_SRC_COLORS);
	791	for (j = 0; j < 8; j++) {
	792	v = get_value(c, BINK_SRC_PATTERN);
	793	for (i = 0; i < 8; i++, v >>= 1)
	794	ublock[i + j*8] = col[v & 1];
	795	}
	796	break;
	797	case RAW_BLOCK:
	798	for (j = 0; j < 8; j++)
	799	for (i = 0; i < 8; i++)
	800	ublock[i + j*8] = get_value(c, BINK_SRC_COLORS);
	801	break;
	802	default:
	803	av_log(avctx, AV_LOG_ERROR, "Incorrect 16x16 block type %d\n", blk);
	804	return -1;
	805	}
	806	if (blk != FILL_BLOCK)
	807	c->dsp.scale_block(ublock, dst, stride);
	808	bx++;
	809	dst += 8;
	810	prev += 8;
	811	break;
	812	case MOTION_BLOCK:
	813	xoff = get_value(c, BINK_SRC_X_OFF);
	814	yoff = get_value(c, BINK_SRC_Y_OFF);
	815	ref = prev + xoff + yoff * stride;
	816	if (ref < ref_start \|\| ref > ref_end) {
	817	av_log(avctx, AV_LOG_ERROR, "Copy out of bounds @%d, %d\n",
	818	bx8 + xoff, by8 + yoff);
	819	return -1;
	820	}
	821	c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8);
	822	break;
	823	case RUN_BLOCK:
	824	scan = bink_patterns[get_bits(&gb, 4)];
	825	i = 0;
	826	do {
	827	int run = get_value(c, BINK_SRC_RUN) + 1;
	828
	829	i += run;
	830	if (i > 64) {
	831	av_log(avctx, AV_LOG_ERROR, "Run went out of bounds\n");
	832	return -1;
	833	}
	834	if (get_bits1(&gb)) {
	835	v = get_value(c, BINK_SRC_COLORS);
	836	for (j = 0; j < run; j++)
	837	dst[coordmap[*scan++]] = v;
	838	} else {
	839	for (j = 0; j < run; j++)
	840	dst[coordmap[*scan++]] = get_value(c, BINK_SRC_COLORS);
	841	}
	842	} while (i < 63);
	843	if (i == 63)
	844	dst[coordmap[*scan++]] = get_value(c, BINK_SRC_COLORS);
	845	break;
	846	case RESIDUE_BLOCK:
	847	xoff = get_value(c, BINK_SRC_X_OFF);
	848	yoff = get_value(c, BINK_SRC_Y_OFF);
	849	ref = prev + xoff + yoff * stride;
	850	if (ref < ref_start \|\| ref > ref_end) {
	851	av_log(avctx, AV_LOG_ERROR, "Copy out of bounds @%d, %d\n",
	852	bx8 + xoff, by8 + yoff);
	853	return -1;
	854	}
	855	c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8);
	856	c->dsp.clear_block(block);
	857	v = get_bits(&gb, 7);
	858	read_residue(&gb, block, v);
	859	c->dsp.add_pixels8(dst, block, stride);
	860	break;
	861	case INTRA_BLOCK:
	862	c->dsp.clear_block(block);
	863	block[0] = get_value(c, BINK_SRC_INTRA_DC);
	864	read_dct_coeffs(&gb, block, c->scantable.permutated, 1);
	865	c->dsp.idct_put(dst, stride, block);
	866	break;
	867	case FILL_BLOCK:
	868	v = get_value(c, BINK_SRC_COLORS);
	869	c->dsp.fill_block_tab[1](dst, v, stride, 8);
	870	break;
	871	case INTER_BLOCK:
	872	xoff = get_value(c, BINK_SRC_X_OFF);
	873	yoff = get_value(c, BINK_SRC_Y_OFF);
	874	ref = prev + xoff + yoff * stride;
	875	c->dsp.put_pixels_tab[1][0](dst, ref, stride, 8);
	876	c->dsp.clear_block(block);
	877	block[0] = get_value(c, BINK_SRC_INTER_DC);
	878	read_dct_coeffs(&gb, block, c->scantable.permutated, 0);
	879	c->dsp.idct_add(dst, stride, block);
	880	break;
	881	case PATTERN_BLOCK:
	882	for (i = 0; i < 2; i++)
	883	col[i] = get_value(c, BINK_SRC_COLORS);
	884	for (i = 0; i < 8; i++) {
	885	v = get_value(c, BINK_SRC_PATTERN);
	886	for (j = 0; j < 8; j++, v >>= 1)
	887	dst[i*stride + j] = col[v & 1];
	888	}
	889	break;
	890	case RAW_BLOCK:
	891	for (i = 0; i < 8; i++)
	892	memcpy(dst + istride, c->bundle[BINK_SRC_COLORS].cur_ptr + i8, 8);
	893	c->bundle[BINK_SRC_COLORS].cur_ptr += 64;
	894	break;
	895	default:
	896	av_log(avctx, AV_LOG_ERROR, "Unknown block type %d\n", blk);
	897	return -1;
	898	}
	899	}
	900	}
	901	if (get_bits_count(&gb) & 0x1F) //next plane data starts at 32-bit boundary
	902	skip_bits_long(&gb, 32 - (get_bits_count(&gb) & 0x1F));
	903	}
	904	emms_c();
	905
	906	*data_size = sizeof(AVFrame);
	907	(AVFrame)data = c->pic;
	908
	909	FFSWAP(AVFrame, c->pic, c->last);
	910
	911	/* always report that the buffer was completely consumed */
	912	return pkt->size;
	913	}
	914
	915	static av_cold int decode_init(AVCodecContext *avctx)
	916	{
	917	BinkContext * const c = avctx->priv_data;
	918	static VLC_TYPE table[16 * 128][2];
	919	int i;
	920
	921	c->version = avctx->codec_tag >> 24;
	922	if (c->version < 'c') {
	923	av_log(avctx, AV_LOG_ERROR, "Too old version '%c'\n", c->version);
	924	return -1;
	925	}
	926	c->swap_planes = c->version >= 'i';
	927	if (!bink_trees[15].table) {
	928	for (i = 0; i < 16; i++) {
	929	const int maxbits = bink_tree_lens[i][15];
	930	bink_trees[i].table = table + i*128;
	931	bink_trees[i].table_allocated = 1 << maxbits;
	932	init_vlc(&bink_trees[i], maxbits, 16,
	933	bink_tree_lens[i], 1, 1,
	934	bink_tree_bits[i], 1, 1, INIT_VLC_USE_NEW_STATIC \| INIT_VLC_LE);
	935	}
	936	}
	937	c->avctx = avctx;
	938
	939	c->pic.data[0] = NULL;
	940
	941	if (avcodec_check_dimensions(avctx, avctx->width, avctx->height) < 0) {
	942	return 1;
	943	}
	944
	945	avctx->pix_fmt = PIX_FMT_YUV420P;
	946
	947	avctx->idct_algo = FF_IDCT_BINK;
	948	dsputil_init(&c->dsp, avctx);
	949	ff_init_scantable(c->dsp.idct_permutation, &c->scantable, bink_scan);
	950
	951	init_bundles(c);
	952
	953	return 0;
	954	}
	955
	956	static av_cold int decode_end(AVCodecContext *avctx)
	957	{
	958	BinkContext * const c = avctx->priv_data;
	959
	960	if (c->pic.data[0])
	961	avctx->release_buffer(avctx, &c->pic);
	962	if (c->last.data[0])
	963	avctx->release_buffer(avctx, &c->last);
	964
	965	free_bundles(c);
	966	return 0;
	967	}
	968
	969	AVCodec bink_decoder = {
	970	"binkvideo",
	971	CODEC_TYPE_VIDEO,
	972	CODEC_ID_BINKVIDEO,
	973	sizeof(BinkContext),
	974	decode_init,
	975	NULL,
	976	decode_end,
	977	decode_frame,
	978	.long_name = NULL_IF_CONFIG_SMALL("Bink video"),
	979	};

libavcodec/binkdata.h+612−0

@@ -0,0 +1,612 @@
	1	/*
	2	* Bink video decoder
	3	* Copyright (C) 2009 Kostya Shishkov
	4	*
	5	* This file is part of FFmpeg.
	6	*
	7	* FFmpeg is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU Lesser General Public
	9	* License as published by the Free Software Foundation; either
	10	* version 2.1 of the License, or (at your option) any later version.
	11	*
	12	* FFmpeg is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* Lesser General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU Lesser General Public
	18	* License along with FFmpeg; if not, write to the Free Software
	19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	20	*/
	21
	22	#ifndef AVCODEC_BINKDATA_H
	23	#define AVCODEC_BINKDATA_H
	24
	25	/** Bink DCT and residue 8x8 block scan order */
	26	static const uint8_t bink_scan[64] = {
	27	0, 1, 8, 9, 2, 3, 10, 11,
	28	4, 5, 12, 13, 6, 7, 14, 15,
	29	20, 21, 28, 29, 22, 23, 30, 31,
	30	16, 17, 24, 25, 32, 33, 40, 41,
	31	34, 35, 42, 43, 48, 49, 56, 57,
	32	50, 51, 58, 59, 18, 19, 26, 27,
	33	36, 37, 44, 45, 38, 39, 46, 47,
	34	52, 53, 60, 61, 54, 55, 62, 63
	35	};
	36
	37	static const uint8_t bink_tree_bits[16][16] = {
	38	{
	39	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
	40	0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
	41	},
	42	{
	43	0x00, 0x01, 0x03, 0x05, 0x07, 0x09, 0x0B, 0x0D,
	44	0x0F, 0x13, 0x15, 0x17, 0x19, 0x1B, 0x1D, 0x1F,
	45	},
	46	{
	47	0x00, 0x02, 0x01, 0x09, 0x05, 0x15, 0x0D, 0x1D,
	48	0x03, 0x13, 0x0B, 0x1B, 0x07, 0x17, 0x0F, 0x1F,
	49	},
	50	{
	51	0x00, 0x02, 0x06, 0x01, 0x09, 0x05, 0x0D, 0x1D,
	52	0x03, 0x13, 0x0B, 0x1B, 0x07, 0x17, 0x0F, 0x1F,
	53	},
	54	{
	55	0x00, 0x04, 0x02, 0x06, 0x01, 0x09, 0x05, 0x0D,
	56	0x03, 0x13, 0x0B, 0x1B, 0x07, 0x17, 0x0F, 0x1F,
	57	},
	58	{
	59	0x00, 0x04, 0x02, 0x0A, 0x06, 0x0E, 0x01, 0x09,
	60	0x05, 0x0D, 0x03, 0x0B, 0x07, 0x17, 0x0F, 0x1F,
	61	},
	62	{
	63	0x00, 0x02, 0x0A, 0x06, 0x0E, 0x01, 0x09, 0x05,
	64	0x0D, 0x03, 0x0B, 0x1B, 0x07, 0x17, 0x0F, 0x1F,
	65	},
	66	{
	67	0x00, 0x01, 0x05, 0x03, 0x13, 0x0B, 0x1B, 0x3B,
	68	0x07, 0x27, 0x17, 0x37, 0x0F, 0x2F, 0x1F, 0x3F,
	69	},
	70	{
	71	0x00, 0x01, 0x03, 0x13, 0x0B, 0x2B, 0x1B, 0x3B,
	72	0x07, 0x27, 0x17, 0x37, 0x0F, 0x2F, 0x1F, 0x3F,
	73	},
	74	{
	75	0x00, 0x01, 0x05, 0x0D, 0x03, 0x13, 0x0B, 0x1B,
	76	0x07, 0x27, 0x17, 0x37, 0x0F, 0x2F, 0x1F, 0x3F,
	77	},
	78	{
	79	0x00, 0x02, 0x01, 0x05, 0x0D, 0x03, 0x13, 0x0B,
	80	0x1B, 0x07, 0x17, 0x37, 0x0F, 0x2F, 0x1F, 0x3F,
	81	},
	82	{
	83	0x00, 0x01, 0x09, 0x05, 0x0D, 0x03, 0x13, 0x0B,
	84	0x1B, 0x07, 0x17, 0x37, 0x0F, 0x2F, 0x1F, 0x3F,
	85	},
	86	{
	87	0x00, 0x02, 0x01, 0x03, 0x13, 0x0B, 0x1B, 0x3B,
	88	0x07, 0x27, 0x17, 0x37, 0x0F, 0x2F, 0x1F, 0x3F,
	89	},
	90	{
	91	0x00, 0x01, 0x05, 0x03, 0x07, 0x27, 0x17, 0x37,
	92	0x0F, 0x4F, 0x2F, 0x6F, 0x1F, 0x5F, 0x3F, 0x7F,
	93	},
	94	{
	95	0x00, 0x01, 0x05, 0x03, 0x07, 0x17, 0x37, 0x77,
	96	0x0F, 0x4F, 0x2F, 0x6F, 0x1F, 0x5F, 0x3F, 0x7F,
	97	},
	98	{
	99	0x00, 0x02, 0x01, 0x05, 0x03, 0x07, 0x27, 0x17,
	100	0x37, 0x0F, 0x2F, 0x6F, 0x1F, 0x5F, 0x3F, 0x7F,
	101	},
	102	};
	103
	104	static const uint8_t bink_tree_lens[16][16] = {
	105	{ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4 },
	106	{ 1, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 },
	107	{ 2, 2, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 },
	108	{ 2, 3, 3, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 },
	109	{ 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5 },
	110	{ 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5 },
	111	{ 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5 },
	112	{ 1, 3, 3, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6 },
	113	{ 1, 2, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6 },
	114	{ 1, 3, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6 },
	115	{ 2, 2, 3, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6 },
	116	{ 1, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6 },
	117	{ 2, 2, 2, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6 },
	118	{ 1, 3, 3, 3, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7 },
	119	{ 1, 3, 3, 3, 5, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7 },
	120	{ 2, 2, 3, 3, 3, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7 },
	121	};
	122
	123	static const uint8_t bink_patterns[16][64] = {
	124	{
	125	0x00, 0x08, 0x10, 0x18, 0x20, 0x28, 0x30, 0x38,
	126	0x39, 0x31, 0x29, 0x21, 0x19, 0x11, 0x09, 0x01,
	127	0x02, 0x0A, 0x12, 0x1A, 0x22, 0x2A, 0x32, 0x3A,
	128	0x3B, 0x33, 0x2B, 0x23, 0x1B, 0x13, 0x0B, 0x03,
	129	0x04, 0x0C, 0x14, 0x1C, 0x24, 0x2C, 0x34, 0x3C,
	130	0x3D, 0x35, 0x2D, 0x25, 0x1D, 0x15, 0x0D, 0x05,
	131	0x06, 0x0E, 0x16, 0x1E, 0x26, 0x2E, 0x36, 0x3E,
	132	0x3F, 0x37, 0x2F, 0x27, 0x1F, 0x17, 0x0F, 0x07,
	133	},
	134	{
	135	0x3B, 0x3A, 0x39, 0x38, 0x30, 0x31, 0x32, 0x33,
	136	0x2B, 0x2A, 0x29, 0x28, 0x20, 0x21, 0x22, 0x23,
	137	0x1B, 0x1A, 0x19, 0x18, 0x10, 0x11, 0x12, 0x13,
	138	0x0B, 0x0A, 0x09, 0x08, 0x00, 0x01, 0x02, 0x03,
	139	0x04, 0x05, 0x06, 0x07, 0x0F, 0x0E, 0x0D, 0x0C,
	140	0x14, 0x15, 0x16, 0x17, 0x1F, 0x1E, 0x1D, 0x1C,
	141	0x24, 0x25, 0x26, 0x27, 0x2F, 0x2E, 0x2D, 0x2C,
	142	0x34, 0x35, 0x36, 0x37, 0x3F, 0x3E, 0x3D, 0x3C,
	143	},
	144	{
	145	0x19, 0x11, 0x12, 0x1A, 0x1B, 0x13, 0x0B, 0x03,
	146	0x02, 0x0A, 0x09, 0x01, 0x00, 0x08, 0x10, 0x18,
	147	0x20, 0x28, 0x30, 0x38, 0x39, 0x31, 0x29, 0x2A,
	148	0x32, 0x3A, 0x3B, 0x33, 0x2B, 0x23, 0x22, 0x21,
	149	0x1D, 0x15, 0x16, 0x1E, 0x1F, 0x17, 0x0F, 0x07,
	150	0x06, 0x0E, 0x0D, 0x05, 0x04, 0x0C, 0x14, 0x1C,
	151	0x24, 0x2C, 0x34, 0x3C, 0x3D, 0x35, 0x2D, 0x2E,
	152	0x36, 0x3E, 0x3F, 0x37, 0x2F, 0x27, 0x26, 0x25,
	153	},
	154	{
	155	0x03, 0x0B, 0x02, 0x0A, 0x01, 0x09, 0x00, 0x08,
	156	0x10, 0x18, 0x11, 0x19, 0x12, 0x1A, 0x13, 0x1B,
	157	0x23, 0x2B, 0x22, 0x2A, 0x21, 0x29, 0x20, 0x28,
	158	0x30, 0x38, 0x31, 0x39, 0x32, 0x3A, 0x33, 0x3B,
	159	0x3C, 0x34, 0x3D, 0x35, 0x3E, 0x36, 0x3F, 0x37,
	160	0x2F, 0x27, 0x2E, 0x26, 0x2D, 0x25, 0x2C, 0x24,
	161	0x1C, 0x14, 0x1D, 0x15, 0x1E, 0x16, 0x1F, 0x17,
	162	0x0F, 0x07, 0x0E, 0x06, 0x0D, 0x05, 0x0C, 0x04,
	163	},
	164	{
	165	0x18, 0x19, 0x10, 0x11, 0x08, 0x09, 0x00, 0x01,
	166	0x02, 0x03, 0x0A, 0x0B, 0x12, 0x13, 0x1A, 0x1B,
	167	0x1C, 0x1D, 0x14, 0x15, 0x0C, 0x0D, 0x04, 0x05,
	168	0x06, 0x07, 0x0E, 0x0F, 0x16, 0x17, 0x1E, 0x1F,
	169	0x27, 0x26, 0x2F, 0x2E, 0x37, 0x36, 0x3F, 0x3E,
	170	0x3D, 0x3C, 0x35, 0x34, 0x2D, 0x2C, 0x25, 0x24,
	171	0x23, 0x22, 0x2B, 0x2A, 0x33, 0x32, 0x3B, 0x3A,
	172	0x39, 0x38, 0x31, 0x30, 0x29, 0x28, 0x21, 0x20,
	173	},
	174	{
	175	0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0A, 0x0B,
	176	0x10, 0x11, 0x12, 0x13, 0x18, 0x19, 0x1A, 0x1B,
	177	0x20, 0x21, 0x22, 0x23, 0x28, 0x29, 0x2A, 0x2B,
	178	0x30, 0x31, 0x32, 0x33, 0x38, 0x39, 0x3A, 0x3B,
	179	0x04, 0x05, 0x06, 0x07, 0x0C, 0x0D, 0x0E, 0x0F,
	180	0x14, 0x15, 0x16, 0x17, 0x1C, 0x1D, 0x1E, 0x1F,
	181	0x24, 0x25, 0x26, 0x27, 0x2C, 0x2D, 0x2E, 0x2F,
	182	0x34, 0x35, 0x36, 0x37, 0x3C, 0x3D, 0x3E, 0x3F,
	183	},
	184	{
	185	0x06, 0x07, 0x0F, 0x0E, 0x0D, 0x05, 0x0C, 0x04,
	186	0x03, 0x0B, 0x02, 0x0A, 0x09, 0x01, 0x00, 0x08,
	187	0x10, 0x18, 0x11, 0x19, 0x12, 0x1A, 0x13, 0x1B,
	188	0x14, 0x1C, 0x15, 0x1D, 0x16, 0x1E, 0x17, 0x1F,
	189	0x27, 0x2F, 0x26, 0x2E, 0x25, 0x2D, 0x24, 0x2C,
	190	0x23, 0x2B, 0x22, 0x2A, 0x21, 0x29, 0x20, 0x28,
	191	0x31, 0x30, 0x38, 0x39, 0x3A, 0x32, 0x3B, 0x33,
	192	0x3C, 0x34, 0x3D, 0x35, 0x36, 0x37, 0x3F, 0x3E,
	193	},
	194	{
	195	0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
	196	0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08,
	197	0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
	198	0x1F, 0x1E, 0x1D, 0x1C, 0x1B, 0x1A, 0x19, 0x18,
	199	0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
	200	0x2F, 0x2E, 0x2D, 0x2C, 0x2B, 0x2A, 0x29, 0x28,
	201	0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
	202	0x3F, 0x3E, 0x3D, 0x3C, 0x3B, 0x3A, 0x39, 0x38,
	203	},
	204	{
	205	0x00, 0x08, 0x09, 0x01, 0x02, 0x03, 0x0B, 0x0A,
	206	0x12, 0x13, 0x1B, 0x1A, 0x19, 0x11, 0x10, 0x18,
	207	0x20, 0x28, 0x29, 0x21, 0x22, 0x23, 0x2B, 0x2A,
	208	0x32, 0x31, 0x30, 0x38, 0x39, 0x3A, 0x3B, 0x33,
	209	0x34, 0x3C, 0x3D, 0x3E, 0x3F, 0x37, 0x36, 0x35,
	210	0x2D, 0x2C, 0x24, 0x25, 0x26, 0x2E, 0x2F, 0x27,
	211	0x1F, 0x17, 0x16, 0x1E, 0x1D, 0x1C, 0x14, 0x15,
	212	0x0D, 0x0C, 0x04, 0x05, 0x06, 0x0E, 0x0F, 0x07,
	213	},
	214	{
	215	0x18, 0x19, 0x10, 0x11, 0x08, 0x09, 0x00, 0x01,
	216	0x02, 0x03, 0x0A, 0x0B, 0x12, 0x13, 0x1A, 0x1B,
	217	0x1C, 0x1D, 0x14, 0x15, 0x0C, 0x0D, 0x04, 0x05,
	218	0x06, 0x07, 0x0E, 0x0F, 0x16, 0x17, 0x1E, 0x1F,
	219	0x26, 0x27, 0x2E, 0x2F, 0x36, 0x37, 0x3E, 0x3F,
	220	0x3C, 0x3D, 0x34, 0x35, 0x2C, 0x2D, 0x24, 0x25,
	221	0x22, 0x23, 0x2A, 0x2B, 0x32, 0x33, 0x3A, 0x3B,
	222	0x38, 0x39, 0x30, 0x31, 0x28, 0x29, 0x20, 0x21,
	223	},
	224	{
	225	0x00, 0x08, 0x01, 0x09, 0x02, 0x0A, 0x03, 0x0B,
	226	0x13, 0x1B, 0x12, 0x1A, 0x11, 0x19, 0x10, 0x18,
	227	0x20, 0x28, 0x21, 0x29, 0x22, 0x2A, 0x23, 0x2B,
	228	0x33, 0x3B, 0x32, 0x3A, 0x31, 0x39, 0x30, 0x38,
	229	0x3C, 0x34, 0x3D, 0x35, 0x3E, 0x36, 0x3F, 0x37,
	230	0x2F, 0x27, 0x2E, 0x26, 0x2D, 0x25, 0x2C, 0x24,
	231	0x1F, 0x17, 0x1E, 0x16, 0x1D, 0x15, 0x1C, 0x14,
	232	0x0C, 0x04, 0x0D, 0x05, 0x0E, 0x06, 0x0F, 0x07,
	233	},
	234	{
	235	0x00, 0x08, 0x10, 0x18, 0x19, 0x1A, 0x1B, 0x13,
	236	0x0B, 0x03, 0x02, 0x01, 0x09, 0x11, 0x12, 0x0A,
	237	0x04, 0x0C, 0x14, 0x1C, 0x1D, 0x1E, 0x1F, 0x17,
	238	0x0F, 0x07, 0x06, 0x05, 0x0D, 0x15, 0x16, 0x0E,
	239	0x24, 0x2C, 0x34, 0x3C, 0x3D, 0x3E, 0x3F, 0x37,
	240	0x2F, 0x27, 0x26, 0x25, 0x2D, 0x35, 0x36, 0x2E,
	241	0x20, 0x28, 0x30, 0x38, 0x39, 0x3A, 0x3B, 0x33,
	242	0x2B, 0x23, 0x22, 0x21, 0x29, 0x31, 0x32, 0x2A,
	243	},
	244	{
	245	0x00, 0x08, 0x09, 0x01, 0x02, 0x03, 0x0B, 0x0A,
	246	0x13, 0x1B, 0x1A, 0x12, 0x11, 0x10, 0x18, 0x19,
	247	0x21, 0x20, 0x28, 0x29, 0x2A, 0x22, 0x23, 0x2B,
	248	0x33, 0x3B, 0x3A, 0x32, 0x31, 0x39, 0x38, 0x30,
	249	0x34, 0x3C, 0x3D, 0x35, 0x36, 0x3E, 0x3F, 0x37,
	250	0x2F, 0x27, 0x26, 0x2E, 0x2D, 0x2C, 0x24, 0x25,
	251	0x1D, 0x1C, 0x14, 0x15, 0x16, 0x1E, 0x1F, 0x17,
	252	0x0E, 0x0F, 0x07, 0x06, 0x05, 0x0D, 0x0C, 0x04,
	253	},
	254	{
	255	0x18, 0x10, 0x08, 0x00, 0x01, 0x02, 0x03, 0x0B,
	256	0x13, 0x1B, 0x1A, 0x19, 0x11, 0x0A, 0x09, 0x12,
	257	0x1C, 0x14, 0x0C, 0x04, 0x05, 0x06, 0x07, 0x0F,
	258	0x17, 0x1F, 0x1E, 0x1D, 0x15, 0x0E, 0x0D, 0x16,
	259	0x3C, 0x34, 0x2C, 0x24, 0x25, 0x26, 0x27, 0x2F,
	260	0x37, 0x3F, 0x3E, 0x3D, 0x35, 0x2E, 0x2D, 0x36,
	261	0x38, 0x30, 0x28, 0x20, 0x21, 0x22, 0x23, 0x2B,
	262	0x33, 0x3B, 0x3A, 0x39, 0x31, 0x2A, 0x29, 0x32,
	263	},
	264	{
	265	0x00, 0x08, 0x09, 0x01, 0x02, 0x0A, 0x12, 0x11,
	266	0x10, 0x18, 0x19, 0x1A, 0x1B, 0x13, 0x0B, 0x03,
	267	0x07, 0x06, 0x0E, 0x0F, 0x17, 0x16, 0x15, 0x0D,
	268	0x05, 0x04, 0x0C, 0x14, 0x1C, 0x1D, 0x1E, 0x1F,
	269	0x3F, 0x3E, 0x36, 0x37, 0x2F, 0x2E, 0x2D, 0x35,
	270	0x3D, 0x3C, 0x34, 0x2C, 0x24, 0x25, 0x26, 0x27,
	271	0x38, 0x30, 0x31, 0x39, 0x3A, 0x32, 0x2A, 0x29,
	272	0x28, 0x20, 0x21, 0x22, 0x23, 0x2B, 0x33, 0x3B,
	273	},
	274	{
	275	0x00, 0x01, 0x08, 0x09, 0x10, 0x11, 0x18, 0x19,
	276	0x20, 0x21, 0x28, 0x29, 0x30, 0x31, 0x38, 0x39,
	277	0x3A, 0x3B, 0x32, 0x33, 0x2A, 0x2B, 0x22, 0x23,
	278	0x1A, 0x1B, 0x12, 0x13, 0x0A, 0x0B, 0x02, 0x03,
	279	0x04, 0x05, 0x0C, 0x0D, 0x14, 0x15, 0x1C, 0x1D,
	280	0x24, 0x25, 0x2C, 0x2D, 0x34, 0x35, 0x3C, 0x3D,
	281	0x3E, 0x3F, 0x36, 0x37, 0x2E, 0x2F, 0x26, 0x27,
	282	0x1E, 0x1F, 0x16, 0x17, 0x0E, 0x0F, 0x06, 0x07,
	283	}
	284	};
	285
	286	static const uint32_t bink_intra_quant[16][64] = {
	287	{
	288	0x010000, 0x016315, 0x01E83D, 0x02A535, 0x014E7B, 0x016577, 0x02F1E6, 0x02724C,
	289	0x010000, 0x00EEDA, 0x024102, 0x017F9B, 0x00BE80, 0x00611E, 0x01083C, 0x00A552,
	290	0x021F88, 0x01DC53, 0x027FAD, 0x01F697, 0x014819, 0x00A743, 0x015A31, 0x009688,
	291	0x02346F, 0x030EE5, 0x01FBFA, 0x02C096, 0x01D000, 0x028396, 0x019247, 0x01F9AA,
	292	0x02346F, 0x01FBFA, 0x01DC53, 0x0231B8, 0x012F12, 0x01E06C, 0x00CB10, 0x0119A8,
	293	0x01C48C, 0x019748, 0x014E86, 0x0122AF, 0x02C628, 0x027F20, 0x0297B5, 0x023F32,
	294	0x025000, 0x01AB6B, 0x01D122, 0x0159B3, 0x012669, 0x008D43, 0x00EE1F, 0x0075ED,
	295	0x01490C, 0x010288, 0x00F735, 0x00EF51, 0x00E0F1, 0x0072AD, 0x00A4D8, 0x006517,
	296	},
	297	{
	298	0x015555, 0x01D971, 0x028AFC, 0x0386F1, 0x01BDF9, 0x01DC9F, 0x03ED33, 0x034311,
	299	0x015555, 0x013E78, 0x030158, 0x01FF7A, 0x00FE00, 0x00817D, 0x01604F, 0x00DC6D,
	300	0x02D4B5, 0x027B19, 0x0354E7, 0x029E1F, 0x01B577, 0x00DF04, 0x01CD96, 0x00C8B6,
	301	0x02F095, 0x0413DC, 0x02A54E, 0x03AB73, 0x026AAB, 0x035A1E, 0x02185E, 0x02A238,
	302	0x02F095, 0x02A54E, 0x027B19, 0x02ECF5, 0x019418, 0x028090, 0x010EC0, 0x01778A,
	303	0x025B66, 0x021F0B, 0x01BE09, 0x018394, 0x03B2E0, 0x03542A, 0x0374F1, 0x02FEEE,
	304	0x031555, 0x0239E4, 0x026C2D, 0x01CCEE, 0x01888C, 0x00BC59, 0x013D7E, 0x009D3C,
	305	0x01B6BB, 0x0158B5, 0x01499C, 0x013F17, 0x012BEC, 0x0098E6, 0x00DBCB, 0x0086C9,
	306	},
	307	{
	308	0x01AAAB, 0x024FCE, 0x032DBB, 0x0468AD, 0x022D78, 0x0253C7, 0x04E87F, 0x0413D5,
	309	0x01AAAB, 0x018E16, 0x03C1AE, 0x027F58, 0x013D80, 0x00A1DC, 0x01B863, 0x011388,
	310	0x0389E2, 0x0319DF, 0x042A21, 0x0345A7, 0x0222D4, 0x0116C5, 0x0240FC, 0x00FAE3,
	311	0x03ACBA, 0x0518D3, 0x034EA1, 0x04964F, 0x030555, 0x0430A5, 0x029E76, 0x034AC5,
	312	0x03ACBA, 0x034EA1, 0x0319DF, 0x03A833, 0x01F91E, 0x0320B4, 0x015270, 0x01D56D,
	313	0x02F23F, 0x02A6CE, 0x022D8B, 0x01E479, 0x049F98, 0x042935, 0x04522D, 0x03BEA9,
	314	0x03DAAB, 0x02C85D, 0x030738, 0x02402A, 0x01EAAF, 0x00EB6F, 0x018CDE, 0x00C48A,
	315	0x022469, 0x01AEE2, 0x019C02, 0x018EDD, 0x0176E7, 0x00BF20, 0x0112BE, 0x00A87B,
	316	},
	317	{
	318	0x020000, 0x02C62A, 0x03D07A, 0x054A69, 0x029CF6, 0x02CAEF, 0x05E3CC, 0x04E499,
	319	0x020000, 0x01DDB4, 0x048204, 0x02FF36, 0x017D01, 0x00C23C, 0x021077, 0x014AA3,
	320	0x043F0F, 0x03B8A6, 0x04FF5A, 0x03ED2E, 0x029032, 0x014E86, 0x02B461, 0x012D11,
	321	0x0468DF, 0x061DCA, 0x03F7F5, 0x05812C, 0x03A000, 0x05072C, 0x03248D, 0x03F353,
	322	0x0468DF, 0x03F7F5, 0x03B8A6, 0x046370, 0x025E24, 0x03C0D8, 0x019620, 0x02334F,
	323	0x038919, 0x032E91, 0x029D0D, 0x02455E, 0x058C50, 0x04FE3F, 0x052F69, 0x047E65,
	324	0x04A000, 0x0356D6, 0x03A243, 0x02B365, 0x024CD2, 0x011A85, 0x01DC3E, 0x00EBD9,
	325	0x029218, 0x020510, 0x01EE69, 0x01DEA2, 0x01C1E2, 0x00E559, 0x0149B0, 0x00CA2D,
	326	},
	327	{
	328	0x02AAAB, 0x03B2E3, 0x0515F8, 0x070DE2, 0x037BF2, 0x03B93E, 0x07DA65, 0x068621,
	329	0x02AAAB, 0x027CF0, 0x0602B1, 0x03FEF3, 0x01FC01, 0x0102FA, 0x02C09F, 0x01B8DA,
	330	0x05A96A, 0x04F632, 0x06A9CE, 0x053C3E, 0x036AED, 0x01BE09, 0x039B2D, 0x01916B,
	331	0x05E129, 0x0827B8, 0x054A9C, 0x0756E5, 0x04D555, 0x06B43B, 0x0430BC, 0x05446F,
	332	0x05E129, 0x054A9C, 0x04F632, 0x05D9EB, 0x032830, 0x050121, 0x021D80, 0x02EF14,
	333	0x04B6CC, 0x043E16, 0x037C11, 0x030728, 0x0765C0, 0x06A855, 0x06E9E2, 0x05FDDB,
	334	0x062AAB, 0x0473C8, 0x04D85A, 0x0399DC, 0x031118, 0x0178B2, 0x027AFD, 0x013A77,
	335	0x036D76, 0x02B16A, 0x029337, 0x027E2E, 0x0257D8, 0x0131CC, 0x01B796, 0x010D91,
	336	},
	337	{
	338	0x038000, 0x04DACA, 0x06ACD5, 0x094238, 0x0492AE, 0x04E322, 0x0A4EA5, 0x08900C,
	339	0x038000, 0x0343FB, 0x07E388, 0x053E9F, 0x029AC1, 0x0153E8, 0x039CD0, 0x02429E,
	340	0x076E5B, 0x068322, 0x08BEDE, 0x06DF11, 0x047C57, 0x02496B, 0x04BBAB, 0x020EDD,
	341	0x07B786, 0x0AB421, 0x06F1ED, 0x09A20D, 0x065800, 0x08CC8E, 0x057FF7, 0x06E9D2,
	342	0x07B786, 0x06F1ED, 0x068322, 0x07AE04, 0x0424BF, 0x06917B, 0x02C6B8, 0x03D9CB,
	343	0x062FEB, 0x05917D, 0x0492D7, 0x03F964, 0x09B58C, 0x08BCEF, 0x0912F8, 0x07DD30,
	344	0x081800, 0x05D7F7, 0x065BF6, 0x04B9F1, 0x040670, 0x01EE69, 0x03416C, 0x019CBC,
	345	0x047FAA, 0x0388DC, 0x036138, 0x03459C, 0x03134C, 0x01915C, 0x0240F5, 0x0161CF,
	346	},
	347	{
	348	0x040000, 0x058C54, 0x07A0F4, 0x0A94D3, 0x0539EC, 0x0595DD, 0x0BC798, 0x09C932,
	349	0x040000, 0x03BB68, 0x090409, 0x05FE6D, 0x02FA01, 0x018477, 0x0420EE, 0x029547,
	350	0x087E1F, 0x07714C, 0x09FEB5, 0x07DA5D, 0x052064, 0x029D0D, 0x0568C3, 0x025A21,
	351	0x08D1BE, 0x0C3B94, 0x07EFEA, 0x0B0258, 0x074000, 0x0A0E59, 0x06491A, 0x07E6A7,
	352	0x08D1BE, 0x07EFEA, 0x07714C, 0x08C6E0, 0x04BC48, 0x0781B1, 0x032C3F, 0x04669F,
	353	0x071232, 0x065D22, 0x053A1A, 0x048ABC, 0x0B18A0, 0x09FC7F, 0x0A5ED3, 0x08FCC9,
	354	0x094000, 0x06ADAC, 0x074487, 0x0566CA, 0x0499A5, 0x02350B, 0x03B87B, 0x01D7B3,
	355	0x052430, 0x040A20, 0x03DCD3, 0x03BD45, 0x0383C5, 0x01CAB3, 0x029361, 0x01945A,
	356	},
	357	{
	358	0x050000, 0x06EF69, 0x098931, 0x0D3A07, 0x068867, 0x06FB55, 0x0EB97E, 0x0C3B7E,
	359	0x050000, 0x04AA42, 0x0B450B, 0x077E08, 0x03B881, 0x01E595, 0x05292A, 0x033A99,
	360	0x0A9DA7, 0x094D9F, 0x0C7E62, 0x09D0F4, 0x06687D, 0x034450, 0x06C2F4, 0x02F0AA,
	361	0x0B062D, 0x0F4A78, 0x09EBE4, 0x0DC2EE, 0x091000, 0x0C91EF, 0x07DB61, 0x09E050,
	362	0x0B062D, 0x09EBE4, 0x094D9F, 0x0AF898, 0x05EB59, 0x09621D, 0x03F74F, 0x058046,
	363	0x08D6BE, 0x07F46A, 0x0688A0, 0x05AD6B, 0x0DDEC8, 0x0C7B9F, 0x0CF687, 0x0B3BFB,
	364	0x0B9000, 0x085917, 0x0915A8, 0x06C07D, 0x05C00E, 0x02C24D, 0x04A69A, 0x024D9F,
	365	0x066D3C, 0x050CA7, 0x04D407, 0x04AC96, 0x0464B6, 0x023D5F, 0x033839, 0x01F971,
	366	},
	367	{
	368	0x060000, 0x08527E, 0x0B716E, 0x0FDF3C, 0x07D6E1, 0x0860CC, 0x11AB63, 0x0EADCB,
	369	0x060000, 0x05991C, 0x0D860D, 0x08FDA3, 0x047702, 0x0246B3, 0x063165, 0x03DFEA,
	370	0x0CBD2E, 0x0B29F1, 0x0EFE0F, 0x0BC78B, 0x07B096, 0x03EB93, 0x081D24, 0x038732,
	371	0x0D3A9C, 0x12595D, 0x0BE7DF, 0x108384, 0x0AE000, 0x0F1585, 0x096DA8, 0x0BD9FA,
	372	0x0D3A9C, 0x0BE7DF, 0x0B29F1, 0x0D2A50, 0x071A6B, 0x0B4289, 0x04C25F, 0x0699EE,
	373	0x0A9B4A, 0x098BB2, 0x07D727, 0x06D01A, 0x10A4F0, 0x0EFABE, 0x0F8E3C, 0x0D7B2E,
	374	0x0DE000, 0x0A0482, 0x0AE6CA, 0x081A2F, 0x06E677, 0x034F90, 0x0594B9, 0x02C38C,
	375	0x07B649, 0x060F2F, 0x05CB3C, 0x059BE7, 0x0545A7, 0x02B00C, 0x03DD11, 0x025E87,
	376	},
	377	{
	378	0x080000, 0x0B18A8, 0x0F41E8, 0x1529A5, 0x0A73D7, 0x0B2BBB, 0x178F2F, 0x139264,
	379	0x080000, 0x0776CF, 0x120812, 0x0BFCD9, 0x05F402, 0x0308EF, 0x0841DC, 0x052A8E,
	380	0x10FC3E, 0x0EE297, 0x13FD69, 0x0FB4B9, 0x0A40C8, 0x053A1A, 0x0AD186, 0x04B442,
	381	0x11A37B, 0x187727, 0x0FDFD4, 0x1604B0, 0x0E8000, 0x141CB1, 0x0C9235, 0x0FCD4D,
	382	0x11A37B, 0x0FDFD4, 0x0EE297, 0x118DC0, 0x09788F, 0x0F0362, 0x06587F, 0x08CD3D,
	383	0x0E2463, 0x0CBA43, 0x0A7434, 0x091577, 0x163140, 0x13F8FE, 0x14BDA5, 0x11F992,
	384	0x128000, 0x0D5B58, 0x0E890D, 0x0ACD94, 0x093349, 0x046A15, 0x0770F7, 0x03AF65,
	385	0x0A4861, 0x08143F, 0x07B9A6, 0x077A89, 0x070789, 0x039565, 0x0526C2, 0x0328B4,
	386	},
	387	{
	388	0x0C0000, 0x10A4FD, 0x16E2DB, 0x1FBE78, 0x0FADC3, 0x10C198, 0x2356C7, 0x1D5B96,
	389	0x0C0000, 0x0B3237, 0x1B0C1A, 0x11FB46, 0x08EE03, 0x048D66, 0x0C62CA, 0x07BFD5,
	390	0x197A5D, 0x1653E3, 0x1DFC1E, 0x178F16, 0x0F612C, 0x07D727, 0x103A49, 0x070E64,
	391	0x1A7539, 0x24B2BB, 0x17CFBD, 0x210709, 0x15C000, 0x1E2B0A, 0x12DB4F, 0x17B3F4,
	392	0x1A7539, 0x17CFBD, 0x1653E3, 0x1A54A0, 0x0E34D7, 0x168513, 0x0984BE, 0x0D33DC,
	393	0x153695, 0x131765, 0x0FAE4E, 0x0DA033, 0x2149E1, 0x1DF57D, 0x1F1C78, 0x1AF65B,
	394	0x1BC000, 0x140904, 0x15CD94, 0x10345E, 0x0DCCEE, 0x069F20, 0x0B2972, 0x058718,
	395	0x0F6C91, 0x0C1E5E, 0x0B9678, 0x0B37CE, 0x0A8B4E, 0x056018, 0x07BA22, 0x04BD0E,
	396	},
	397	{
	398	0x110000, 0x179466, 0x206C0C, 0x2CF87F, 0x16362A, 0x17BCED, 0x321044, 0x299714,
	399	0x110000, 0x0FDC79, 0x265125, 0x19794E, 0x0CA685, 0x0672FB, 0x118BF4, 0x0AFA6D,
	400	0x241804, 0x1FA181, 0x2A7A80, 0x21600A, 0x15C9A9, 0x0B1B77, 0x16FD3C, 0x09FF0D,
	401	0x257B66, 0x33FD33, 0x21BBA2, 0x2EC9F7, 0x1ED000, 0x2ABCF9, 0x1AB6B0, 0x219444,
	402	0x257B66, 0x21BBA2, 0x1FA181, 0x254D38, 0x142030, 0x1FE730, 0x0D7C0E, 0x12B423,
	403	0x1E0D52, 0x1B0BCF, 0x1636EE, 0x134D9E, 0x2F28A9, 0x2A711B, 0x2C12FF, 0x263256,
	404	0x275000, 0x1C621B, 0x1EE33C, 0x16F4DB, 0x138CFB, 0x09616E, 0x0FD00C, 0x07D4B7,
	405	0x15D9CE, 0x112B06, 0x106A80, 0x0FE464, 0x0EF004, 0x079D77, 0x0AF25B, 0x06B67F,
	406	},
	407	{
	408	0x160000, 0x1E83CF, 0x29F53D, 0x3A3286, 0x1CBE90, 0x1EB842, 0x40C9C2, 0x35D293,
	409	0x160000, 0x1486BA, 0x319630, 0x20F756, 0x105F06, 0x085891, 0x16B51E, 0x0E3506,
	410	0x2EB5AA, 0x28EF20, 0x36F8E1, 0x2B30FE, 0x1C3225, 0x0E5FC7, 0x1DC030, 0x0CEFB7,
	411	0x308193, 0x4347AC, 0x2BA786, 0x3C8CE5, 0x27E000, 0x374EE7, 0x229212, 0x2B7494,
	412	0x308193, 0x2BA786, 0x28EF20, 0x3045D0, 0x1A0B89, 0x29494D, 0x11735D, 0x183469,
	413	0x26E410, 0x230039, 0x1CBF8F, 0x18FB09, 0x3D0771, 0x36ECBA, 0x390986, 0x316E52,
	414	0x32E000, 0x24BB33, 0x27F8E4, 0x1DB557, 0x194D09, 0x0C23BB, 0x1476A6, 0x0A2256,
	415	0x1C470A, 0x1637AD, 0x153E87, 0x1490FA, 0x1354B9, 0x09DAD6, 0x0E2A94, 0x08AFF0,
	416	},
	417	{
	418	0x1C0000, 0x26D64D, 0x3566AA, 0x4A11C2, 0x249572, 0x27190E, 0x527525, 0x44805E,
	419	0x1C0000, 0x1A1FD6, 0x3F1C3E, 0x29F4F9, 0x14D607, 0x0A9F44, 0x1CE683, 0x1214F0,
	420	0x3B72D9, 0x341911, 0x45F6F0, 0x36F889, 0x23E2BB, 0x124B5B, 0x25DD54, 0x1076E9,
	421	0x3DBC30, 0x55A109, 0x378F64, 0x4D1069, 0x32C000, 0x46646C, 0x2BFFB9, 0x374E8E,
	422	0x3DBC30, 0x378F64, 0x341911, 0x3D7020, 0x2125F5, 0x348BD6, 0x1635BC, 0x1ECE57,
	423	0x317F5B, 0x2C8BEB, 0x2496B6, 0x1FCB22, 0x4DAC61, 0x45E778, 0x4897C2, 0x3EE97F,
	424	0x40C000, 0x2EBFB5, 0x32DFAE, 0x25CF86, 0x203380, 0x0F734B, 0x1A0B5F, 0x0CE5E2,
	425	0x23FD53, 0x1C46DC, 0x1B09C4, 0x1A2CE1, 0x189A60, 0x0C8AE2, 0x1207A5, 0x0B0E77,
	426	},
	427	{
	428	0x220000, 0x2F28CC, 0x40D818, 0x59F0FE, 0x2C6C53, 0x2F79DA, 0x642089, 0x532E29,
	429	0x220000, 0x1FB8F1, 0x4CA24B, 0x32F29C, 0x194D09, 0x0CE5F7, 0x2317E8, 0x15F4DB,
	430	0x483007, 0x3F4303, 0x54F4FF, 0x42C014, 0x2B9351, 0x1636EE, 0x2DFA79, 0x13FE1A,
	431	0x4AF6CC, 0x67FA67, 0x437743, 0x5D93EE, 0x3DA000, 0x5579F1, 0x356D61, 0x432888,
	432	0x4AF6CC, 0x437743, 0x3F4303, 0x4A9A70, 0x284060, 0x3FCE60, 0x1AF81B, 0x256845,
	433	0x3C1AA5, 0x36179D, 0x2C6DDD, 0x269B3C, 0x5E5152, 0x54E237, 0x5825FE, 0x4C64AD,
	434	0x4EA000, 0x38C437, 0x3DC678, 0x2DE9B5, 0x2719F7, 0x12C2DB, 0x1FA018, 0x0FA96E,
	435	0x2BB39B, 0x22560C, 0x20D500, 0x1FC8C8, 0x1DE007, 0x0F3AEE, 0x15E4B7, 0x0D6CFE,
	436	},
	437	{
	438	0x2C0000, 0x3D079E, 0x53EA79, 0x74650C, 0x397D20, 0x3D7083, 0x819383, 0x6BA525,
	439	0x2C0000, 0x290D75, 0x632C61, 0x41EEAC, 0x20BE0C, 0x10B121, 0x2D6A3B, 0x1C6A0C,
	440	0x5D6B54, 0x51DE40, 0x6DF1C2, 0x5661FB, 0x38644B, 0x1CBF8F, 0x3B8060, 0x19DF6D,
	441	0x610326, 0x868F57, 0x574F0B, 0x7919CA, 0x4FC000, 0x6E9DCE, 0x452423, 0x56E928,
	442	0x610326, 0x574F0B, 0x51DE40, 0x608BA0, 0x341713, 0x52929A, 0x22E6BA, 0x3068D2,
	443	0x4DC821, 0x460071, 0x397F1E, 0x31F611, 0x7A0EE2, 0x6DD974, 0x72130C, 0x62DCA3,
	444	0x65C000, 0x497665, 0x4FF1C9, 0x3B6AAE, 0x329A12, 0x184776, 0x28ED4D, 0x1444AC,
	445	0x388E14, 0x2C6F5A, 0x2A7D0F, 0x2921F4, 0x26A973, 0x13B5AD, 0x1C5528, 0x115FDF,
	446	},
	447	};
	448
	449	static const uint32_t bink_inter_quant[16][64] = {
	450	{
	451	0x010000, 0x017946, 0x01A5A9, 0x0248DC, 0x016363, 0x0152A7, 0x0243EC, 0x0209EA,
	452	0x012000, 0x00E248, 0x01BBDA, 0x015CBC, 0x00A486, 0x0053E0, 0x00F036, 0x008095,
	453	0x01B701, 0x016959, 0x01B0B9, 0x0153FD, 0x00F8E7, 0x007EE4, 0x00EA30, 0x007763,
	454	0x01B701, 0x0260EB, 0x019DE9, 0x023E1B, 0x017000, 0x01FE6E, 0x012DB5, 0x01A27B,
	455	0x01E0D1, 0x01B0B9, 0x018A33, 0x01718D, 0x00D87A, 0x014449, 0x007B9A, 0x00AB71,
	456	0x013178, 0x0112EA, 0x00AD08, 0x009BB9, 0x023D97, 0x020437, 0x021CCC, 0x01E6B4,
	457	0x018000, 0x012DB5, 0x0146D9, 0x0100CE, 0x00CFD2, 0x006E5C, 0x00B0E4, 0x005A2D,
	458	0x00E9CC, 0x00B7B1, 0x00846F, 0x006B85, 0x008337, 0x0042E5, 0x004A10, 0x002831,
	459	},
	460	{
	461	0x015555, 0x01F708, 0x023237, 0x030BD0, 0x01D9D9, 0x01C389, 0x03053B, 0x02B7E3,
	462	0x018000, 0x012DB5, 0x024FCE, 0x01D0FA, 0x00DB5D, 0x006FD5, 0x014048, 0x00AB71,
	463	0x024957, 0x01E1CC, 0x0240F7, 0x01C551, 0x014BDE, 0x00A92F, 0x013840, 0x009F2F,
	464	0x024957, 0x032BE4, 0x0227E1, 0x02FD7A, 0x01EAAB, 0x02A893, 0x019247, 0x022DF9,
	465	0x028116, 0x0240F7, 0x020D99, 0x01ECBC, 0x0120A3, 0x01B061, 0x00A4CE, 0x00E497,
	466	0x01974B, 0x016E8E, 0x00E6B5, 0x00CFA2, 0x02FCC9, 0x02B04A, 0x02D110, 0x0288F1,
	467	0x020000, 0x019247, 0x01B3CC, 0x015668, 0x011518, 0x009325, 0x00EBDA, 0x00783D,
	468	0x0137BB, 0x00F4ED, 0x00B093, 0x008F5C, 0x00AEF4, 0x005931, 0x0062BF, 0x003597,
	469	},
	470	{
	471	0x01AAAB, 0x0274CB, 0x02BEC4, 0x03CEC4, 0x02504F, 0x02346C, 0x03C689, 0x0365DC,
	472	0x01E000, 0x017922, 0x02E3C1, 0x024539, 0x011235, 0x008BCA, 0x01905A, 0x00D64D,
	473	0x02DBAD, 0x025A40, 0x02D134, 0x0236A5, 0x019ED6, 0x00D37B, 0x018650, 0x00C6FB,
	474	0x02DBAD, 0x03F6DD, 0x02B1D9, 0x03BCD8, 0x026555, 0x0352B8, 0x01F6D8, 0x02B977,
	475	0x03215C, 0x02D134, 0x029100, 0x0267EB, 0x0168CC, 0x021C7A, 0x00CE01, 0x011DBD,
	476	0x01FD1E, 0x01CA31, 0x012062, 0x01038A, 0x03BBFB, 0x035C5C, 0x038554, 0x032B2D,
	477	0x028000, 0x01F6D8, 0x0220C0, 0x01AC02, 0x015A5E, 0x00B7EF, 0x0126D1, 0x00964C,
	478	0x0185A9, 0x013228, 0x00DCB8, 0x00B333, 0x00DAB2, 0x006F7D, 0x007B6F, 0x0042FC,
	479	},
	480	{
	481	0x020000, 0x02F28D, 0x034B52, 0x0491B8, 0x02C6C5, 0x02A54E, 0x0487D8, 0x0413D5,
	482	0x024000, 0x01C48F, 0x0377B5, 0x02B977, 0x01490C, 0x00A7BF, 0x01E06C, 0x01012A,
	483	0x036E03, 0x02D2B3, 0x036172, 0x02A7FA, 0x01F1CE, 0x00FDC7, 0x01D460, 0x00EEC7,
	484	0x036E03, 0x04C1D6, 0x033BD1, 0x047C37, 0x02E000, 0x03FCDD, 0x025B6A, 0x0344F5,
	485	0x03C1A1, 0x036172, 0x031466, 0x02E31B, 0x01B0F5, 0x028892, 0x00F735, 0x0156E2,
	486	0x0262F1, 0x0225D5, 0x015A10, 0x013772, 0x047B2D, 0x04086E, 0x043998, 0x03CD69,
	487	0x030000, 0x025B6A, 0x028DB3, 0x02019B, 0x019FA3, 0x00DCB8, 0x0161C7, 0x00B45B,
	488	0x01D398, 0x016F63, 0x0108DD, 0x00D70A, 0x01066F, 0x0085C9, 0x00941F, 0x005062,
	489	},
	490	{
	491	0x02AAAB, 0x03EE11, 0x04646D, 0x0617A0, 0x03B3B2, 0x038713, 0x060A75, 0x056FC6,
	492	0x030000, 0x025B6A, 0x049F9B, 0x03A1F4, 0x01B6BB, 0x00DFAA, 0x028090, 0x0156E2,
	493	0x0492AE, 0x03C399, 0x0481ED, 0x038AA2, 0x0297BD, 0x01525F, 0x027080, 0x013E5E,
	494	0x0492AE, 0x0657C8, 0x044FC1, 0x05FAF4, 0x03D555, 0x055126, 0x03248D, 0x045BF2,
	495	0x05022D, 0x0481ED, 0x041B33, 0x03D979, 0x024147, 0x0360C3, 0x01499C, 0x01C92E,
	496	0x032E96, 0x02DD1C, 0x01CD6A, 0x019F43, 0x05F991, 0x056093, 0x05A220, 0x0511E1,
	497	0x040000, 0x03248D, 0x036799, 0x02ACCF, 0x022A2F, 0x01264B, 0x01D7B5, 0x00F079,
	498	0x026F75, 0x01E9D9, 0x016127, 0x011EB8, 0x015DE9, 0x00B262, 0x00C57F, 0x006B2D,
	499	},
	500	{
	501	0x038000, 0x052876, 0x05C3CF, 0x07FF02, 0x04DBD9, 0x04A148, 0x07EDBA, 0x0722B4,
	502	0x03F000, 0x0317FB, 0x06117C, 0x04C491, 0x023FD5, 0x01258F, 0x0348BD, 0x01C209,
	503	0x060085, 0x04F0B9, 0x05EA87, 0x04A5F5, 0x036728, 0x01BC1C, 0x0333A8, 0x01A1DB,
	504	0x060085, 0x085336, 0x05A8AE, 0x07D960, 0x050800, 0x06FA82, 0x041FF9, 0x05B8AE,
	505	0x0692DA, 0x05EA87, 0x0563B2, 0x050D6E, 0x02F5AD, 0x046F00, 0x01B09C, 0x02580C,
	506	0x042D25, 0x03C235, 0x025D9B, 0x022108, 0x07D78F, 0x070EC1, 0x0764CA, 0x06A777,
	507	0x054000, 0x041FF9, 0x0477F9, 0x0382D0, 0x02D75E, 0x018242, 0x026B1D, 0x013B9F,
	508	0x03324A, 0x0282ED, 0x01CF83, 0x017851, 0x01CB42, 0x00EA21, 0x010336, 0x008CAC,
	509	},
	510	{
	511	0x040000, 0x05E519, 0x0696A4, 0x092370, 0x058D8A, 0x054A9C, 0x090FB0, 0x0827AA,
	512	0x048000, 0x03891F, 0x06EF69, 0x0572EE, 0x029218, 0x014F7E, 0x03C0D8, 0x020254,
	513	0x06DC05, 0x05A565, 0x06C2E4, 0x054FF3, 0x03E39B, 0x01FB8E, 0x03A8C0, 0x01DD8D,
	514	0x06DC05, 0x0983AC, 0x0677A2, 0x08F86E, 0x05C000, 0x07F9B9, 0x04B6D4, 0x0689EB,
	515	0x078343, 0x06C2E4, 0x0628CC, 0x05C635, 0x0361EA, 0x051124, 0x01EE69, 0x02ADC5,
	516	0x04C5E1, 0x044BAA, 0x02B41F, 0x026EE5, 0x08F65A, 0x0810DD, 0x087330, 0x079AD1,
	517	0x060000, 0x04B6D4, 0x051B65, 0x040337, 0x033F47, 0x01B970, 0x02C38F, 0x0168B6,
	518	0x03A730, 0x02DEC6, 0x0211BA, 0x01AE14, 0x020CDD, 0x010B93, 0x01283E, 0x00A0C4,
	519	},
	520	{
	521	0x050000, 0x075E60, 0x083C4D, 0x0B6C4C, 0x06F0ED, 0x069D43, 0x0B539C, 0x0A3194,
	522	0x05A000, 0x046B67, 0x08AB44, 0x06CFAA, 0x03369E, 0x01A35E, 0x04B10F, 0x0282E8,
	523	0x089307, 0x070EBF, 0x08739C, 0x06A3F0, 0x04DC82, 0x027A72, 0x0492F0, 0x0254F0,
	524	0x089307, 0x0BE497, 0x08158B, 0x0B3689, 0x073000, 0x09F827, 0x05E489, 0x082C66,
	525	0x096413, 0x08739C, 0x07B2FF, 0x0737C2, 0x043A64, 0x06556D, 0x026A04, 0x035936,
	526	0x05F75A, 0x055E94, 0x036127, 0x030A9E, 0x0B33F1, 0x0A1514, 0x0A8FFC, 0x098186,
	527	0x078000, 0x05E489, 0x06623F, 0x050405, 0x040F19, 0x0227CC, 0x037473, 0x01C2E3,
	528	0x0490FC, 0x039677, 0x029629, 0x021999, 0x029015, 0x014E78, 0x01724E, 0x00C8F5,
	529	},
	530	{
	531	0x060000, 0x08D7A6, 0x09E1F6, 0x0DB528, 0x085450, 0x07EFEA, 0x0D9788, 0x0C3B7E,
	532	0x06C000, 0x054DAE, 0x0A671E, 0x082C66, 0x03DB24, 0x01F73E, 0x05A145, 0x03037D,
	533	0x0A4A08, 0x087818, 0x0A2455, 0x07F7ED, 0x05D569, 0x02F955, 0x057D20, 0x02CC54,
	534	0x0A4A08, 0x0E4582, 0x09B373, 0x0D74A5, 0x08A000, 0x0BF696, 0x07123E, 0x09CEE0,
	535	0x0B44E4, 0x0A2455, 0x093D32, 0x08A950, 0x0512DF, 0x0799B6, 0x02E59E, 0x0404A7,
	536	0x0728D2, 0x06717F, 0x040E2F, 0x03A657, 0x0D7187, 0x0C194B, 0x0CACC8, 0x0B683A,
	537	0x090000, 0x07123E, 0x07A918, 0x0604D2, 0x04DEEA, 0x029629, 0x042556, 0x021D11,
	538	0x057AC8, 0x044E28, 0x031A97, 0x02851E, 0x03134C, 0x01915C, 0x01BC5D, 0x00F126,
	539	},
	540	{
	541	0x080000, 0x0BCA33, 0x0D2D48, 0x1246E0, 0x0B1B15, 0x0A9538, 0x121F5F, 0x104F53,
	542	0x090000, 0x07123E, 0x0DDED2, 0x0AE5DD, 0x052430, 0x029EFD, 0x0781B1, 0x0404A7,
	543	0x0DB80B, 0x0B4ACB, 0x0D85C7, 0x0A9FE7, 0x07C736, 0x03F71D, 0x075180, 0x03BB1A,
	544	0x0DB80B, 0x130757, 0x0CEF44, 0x11F0DC, 0x0B8000, 0x0FF372, 0x096DA8, 0x0D13D6,
	545	0x0F0686, 0x0D85C7, 0x0C5198, 0x0B8C6A, 0x06C3D4, 0x0A2248, 0x03DCD3, 0x055B8A,
	546	0x098BC3, 0x089754, 0x05683E, 0x04DDC9, 0x11ECB4, 0x1021B9, 0x10E661, 0x0F35A3,
	547	0x0C0000, 0x096DA8, 0x0A36CB, 0x08066E, 0x067E8E, 0x0372E1, 0x05871E, 0x02D16B,
	548	0x074E60, 0x05BD8B, 0x042374, 0x035C28, 0x0419BB, 0x021726, 0x02507C, 0x014188,
	549	},
	550	{
	551	0x0C0000, 0x11AF4C, 0x13C3EC, 0x1B6A50, 0x10A89F, 0x0FDFD4, 0x1B2F0F, 0x1876FD,
	552	0x0D8000, 0x0A9B5D, 0x14CE3C, 0x1058CB, 0x07B649, 0x03EE7B, 0x0B4289, 0x0606FB,
	553	0x149410, 0x10F030, 0x1448AB, 0x0FEFDA, 0x0BAAD2, 0x05F2AB, 0x0AFA40, 0x0598A7,
	554	0x149410, 0x1C8B03, 0x1366E6, 0x1AE949, 0x114000, 0x17ED2B, 0x0E247C, 0x139DC1,
	555	0x1689C8, 0x1448AB, 0x127A63, 0x11529F, 0x0A25BE, 0x0F336D, 0x05CB3C, 0x08094E,
	556	0x0E51A4, 0x0CE2FE, 0x081C5D, 0x074CAE, 0x1AE30E, 0x183296, 0x195991, 0x16D074,
	557	0x120000, 0x0E247C, 0x0F5230, 0x0C09A5, 0x09BDD5, 0x052C51, 0x084AAC, 0x043A21,
	558	0x0AF590, 0x089C51, 0x06352E, 0x050A3B, 0x062698, 0x0322B9, 0x0378BA, 0x01E24D,
	559	},
	560	{
	561	0x110000, 0x190DAC, 0x1C0039, 0x26D69C, 0x17998C, 0x167D16, 0x2682AB, 0x22A891,
	562	0x132000, 0x0F06C3, 0x1D797F, 0x172876, 0x0AECE7, 0x0591D9, 0x0FF398, 0x0889E3,
	563	0x1D2717, 0x17FEEF, 0x1CBC47, 0x1693CA, 0x108754, 0x086D1D, 0x0F8D30, 0x07ED98,
	564	0x1D2717, 0x286F9A, 0x1B7C71, 0x261FD3, 0x187000, 0x21E552, 0x140904, 0x1BCA27,
	565	0x1FEDDC, 0x1CBC47, 0x1A2D62, 0x188A62, 0x0E6022, 0x1588DA, 0x083540, 0x0B6284,
	566	0x1448FE, 0x124192, 0x0B7D84, 0x0A574B, 0x2616FF, 0x2247AA, 0x23E98D, 0x2051FA,
	567	0x198000, 0x140904, 0x15B46F, 0x110DAA, 0x0DCCEE, 0x07541E, 0x0BBF1F, 0x05FD04,
	568	0x0F868B, 0x0C32C8, 0x08CB57, 0x0723D4, 0x08B6AD, 0x047130, 0x04EB08, 0x02AB42,
	569	},
	570	{
	571	0x160000, 0x206C0C, 0x243C86, 0x3242E8, 0x1E8A79, 0x1D1A59, 0x31D646, 0x2CDA25,
	572	0x18C000, 0x13722A, 0x2624C3, 0x1DF820, 0x0E2385, 0x073537, 0x14A4A7, 0x0B0CCC,
	573	0x25BA1D, 0x1F0DAE, 0x252FE4, 0x1D37BB, 0x1563D6, 0x0AE78E, 0x142021, 0x0A4288,
	574	0x25BA1D, 0x345430, 0x2391FB, 0x31565C, 0x1FA000, 0x2BDD7A, 0x19ED8D, 0x23F68C,
	575	0x2951EF, 0x252FE4, 0x21E061, 0x1FC224, 0x129A87, 0x1BDE47, 0x0A9F44, 0x0EBBBA,
	576	0x1A4058, 0x17A026, 0x0EDEAB, 0x0D61E9, 0x314AEF, 0x2C5CBE, 0x2E798A, 0x29D380,
	577	0x210000, 0x19ED8D, 0x1C16AE, 0x1611AE, 0x11DC06, 0x097BEA, 0x0F3391, 0x07BFE7,
	578	0x141787, 0x0FC93E, 0x0B617F, 0x093D6D, 0x0B46C1, 0x05BFA8, 0x065D55, 0x037437,
	579	},
	580	{
	581	0x1C0000, 0x2943B2, 0x2E1E7C, 0x3FF810, 0x26DEC9, 0x250A43, 0x3F6DCE, 0x3915A3,
	582	0x1F8000, 0x18BFD8, 0x308BE1, 0x262485, 0x11FEA9, 0x092C75, 0x1A45EB, 0x0E1049,
	583	0x300425, 0x2785C6, 0x2F5439, 0x252FA8, 0x1B393F, 0x0DE0E4, 0x199D41, 0x0D0EDC,
	584	0x300425, 0x4299B2, 0x2D456E, 0x3ECB00, 0x284000, 0x37D40F, 0x20FFCB, 0x2DC56D,
	585	0x3496D3, 0x2F5439, 0x2B1D93, 0x286B74, 0x17AD66, 0x2377FE, 0x0D84E2, 0x12C062,
	586	0x21692A, 0x1E11A5, 0x12ECDA, 0x110840, 0x3EBC76, 0x387608, 0x3B2652, 0x353BBA,
	587	0x2A0000, 0x20FFCB, 0x23BFC6, 0x1C1681, 0x16BAF1, 0x0C1213, 0x1358E8, 0x09DCF8,
	588	0x19924F, 0x141767, 0x0E7C16, 0x0BC28A, 0x0E5A0D, 0x075104, 0x0819B2, 0x04655D,
	589	},
	590	{
	591	0x220000, 0x321B58, 0x380072, 0x4DAD38, 0x2F3318, 0x2CFA2D, 0x4D0556, 0x455122,
	592	0x264000, 0x1E0D86, 0x3AF2FE, 0x2E50EB, 0x15D9CE, 0x0B23B2, 0x1FE730, 0x1113C7,
	593	0x3A4E2D, 0x2FFDDF, 0x39788E, 0x2D2795, 0x210EA8, 0x10DA39, 0x1F1A61, 0x0FDB2F,
	594	0x3A4E2D, 0x50DF33, 0x36F8E1, 0x4C3FA5, 0x30E000, 0x43CAA5, 0x281209, 0x37944D,
	595	0x3FDBB7, 0x39788E, 0x345AC4, 0x3114C3, 0x1CC044, 0x2B11B4, 0x106A80, 0x16C509,
	596	0x2891FC, 0x248324, 0x16FB08, 0x14AE97, 0x4C2DFD, 0x448F54, 0x47D31B, 0x40A3F5,
	597	0x330000, 0x281209, 0x2B68DF, 0x221B53, 0x1B99DB, 0x0EA83B, 0x177E3E, 0x0BFA09,
	598	0x1F0D17, 0x18658F, 0x1196AE, 0x0E47A8, 0x116D5A, 0x08E260, 0x09D60F, 0x055684,
	599	},
	600	{
	601	0x2C0000, 0x40D818, 0x48790C, 0x6485D0, 0x3D14F2, 0x3A34B2, 0x63AC8D, 0x59B44A,
	602	0x318000, 0x26E454, 0x4C4986, 0x3BF03F, 0x1C470A, 0x0E6A6E, 0x29494D, 0x161998,
	603	0x4B743A, 0x3E1B5C, 0x4A5FC7, 0x3A6F75, 0x2AC7AC, 0x15CF1D, 0x284041, 0x148510,
	604	0x4B743A, 0x68A861, 0x4723F6, 0x62ACB8, 0x3F4000, 0x57BAF3, 0x33DB1A, 0x47ED19,
	605	0x52A3DE, 0x4A5FC7, 0x43C0C2, 0x3F8448, 0x25350D, 0x37BC8E, 0x153E87, 0x1D7775,
	606	0x3480B0, 0x2F404C, 0x1DBD56, 0x1AC3D2, 0x6295DE, 0x58B97B, 0x5CF313, 0x53A701,
	607	0x420000, 0x33DB1A, 0x382D5C, 0x2C235D, 0x23B80D, 0x12F7D4, 0x1E6723, 0x0F7FCF,
	608	0x282F0E, 0x1F927D, 0x16C2FF, 0x127AD9, 0x168D83, 0x0B7F50, 0x0CBAAA, 0x06E86E,
	609	},
	610	};
	611
	612	#endif /* AVCODEC_BINKDATA_H */

libavcodec/binkidct.c+112−0

@@ -0,0 +1,112 @@
	1	/*
	2	* Bink IDCT algorithm
	3	* Copyright (c) 2009 Kostya Shishkov
	4	*
	5	* This file is part of FFmpeg.
	6	*
	7	* FFmpeg is free software; you can redistribute it and/or
	8	* modify it under the terms of the GNU Lesser General Public
	9	* License as published by the Free Software Foundation; either
	10	* version 2.1 of the License, or (at your option) any later version.
	11	*
	12	* FFmpeg is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* Lesser General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU Lesser General Public
	18	* License along with FFmpeg; if not, write to the Free Software
	19	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	20	*/
	21
	22	/**
	23	* @file libavcodec/binkidct.c
	24	* Bink IDCT algorithm
	25	*/
	26
	27	#include "dsputil.h"
	28
	29	#define A1 2896 /* (1/sqrt(2))<<12 */
	30	#define A2 2217
	31	#define A3 3784
	32	#define A4 -5352
	33
	34	#define IDCT_TRANSFORM(dest,s0,s1,s2,s3,s4,s5,s6,s7,d0,d1,d2,d3,d4,d5,d6,d7,munge,src) {\
	35	const int a0 = (src)[s0] + (src)[s4]; \
	36	const int a1 = (src)[s0] - (src)[s4]; \
	37	const int a2 = (src)[s2] + (src)[s6]; \
	38	const int a3 = (A1*((src)[s2] - (src)[s6])) >> 11; \
	39	const int a4 = (src)[s5] + (src)[s3]; \
	40	const int a5 = (src)[s5] - (src)[s3]; \
	41	const int a6 = (src)[s1] + (src)[s7]; \
	42	const int a7 = (src)[s1] - (src)[s7]; \
	43	const int b0 = a4 + a6; \
	44	const int b1 = (A3*(a5 + a7)) >> 11; \
	45	const int b2 = ((A4*a5) >> 11) - b0 + b1; \
	46	const int b3 = (A1*(a6 - a4) >> 11) - b2; \
	47	const int b4 = ((A2*a7) >> 11) + b3 - b1; \
	48	(dest)[d0] = munge(a0+a2 +b0); \
	49	(dest)[d1] = munge(a1+a3-a2+b2); \
	50	(dest)[d2] = munge(a1-a3+a2+b3); \
	51	(dest)[d3] = munge(a0-a2 -b4); \
	52	(dest)[d4] = munge(a0-a2 +b4); \
	53	(dest)[d5] = munge(a1-a3+a2-b3); \
	54	(dest)[d6] = munge(a1+a3-a2-b2); \
	55	(dest)[d7] = munge(a0+a2 -b0); \
	56	}
	57	/* end IDCT_TRANSFORM macro */
	58
	59	#define MUNGE_NONE(x) (x)
	60	#define IDCT_COL(dest,src) IDCT_TRANSFORM(dest,0,8,16,24,32,40,48,56,0,8,16,24,32,40,48,56,MUNGE_NONE,src)
	61
	62	#define MUNGE_ROW(x) (((x) + 0x7F)>>8)
	63	#define IDCT_ROW(dest,src) IDCT_TRANSFORM(dest,0,1,2,3,4,5,6,7,0,1,2,3,4,5,6,7,MUNGE_ROW,src)
	64
	65	static inline void bink_idct_col(DCTELEM dest, const DCTELEM src)
	66	{
	67	if ((src[8]\|src[16]\|src[24]\|src[32]\|src[40]\|src[48]\|src[56])==0) {
	68	dest[0] =
	69	dest[8] =
	70	dest[16] =
	71	dest[24] =
	72	dest[32] =
	73	dest[40] =
	74	dest[48] =
	75	dest[56] = src[0];
	76	} else {
	77	IDCT_COL(dest, src);
	78	}
	79	}
	80
	81	void ff_bink_idct_c(DCTELEM *block)
	82	{
	83	int i;
	84	DCTELEM temp[64];
	85
	86	for (i = 0; i < 8; i++)
	87	bink_idct_col(&temp[i], &block[i]);
	88	for (i = 0; i < 8; i++) {
	89	IDCT_ROW( (&block[8i]), (&temp[8i]) );
	90	}
	91	}
	92
	93	void ff_bink_idct_add_c(uint8_t dest, int linesize, DCTELEM block)
	94	{
	95	int i, j;
	96
	97	ff_bink_idct_c(block);
	98	for (i = 0; i < 8; i++, dest += linesize, block += 8)
	99	for (j = 0; j < 8; j++)
	100	dest[j] += block[j];
	101	}
	102
	103	void ff_bink_idct_put_c(uint8_t dest, int linesize, DCTELEM block)
	104	{
	105	int i;
	106	DCTELEM temp[64];
	107	for (i = 0; i < 8; i++)
	108	bink_idct_col(&temp[i], &block[i]);
	109	for (i = 0; i < 8; i++) {
	110	IDCT_ROW( (&dest[ilinesize]), (&temp[8i]) );
	111	}
	112	}

libavcodec/dsputil.c+72−0

@@ -55,6 +55,11 @@ void ff_add_png_paeth_prediction(uint8_t dst, uint8_t src, uint8_t *top, int w · 54 unmodified lines
55	/* eaidct.c */	55	/* eaidct.c */
56	void ff_ea_idct_put_c(uint8_t dest, int linesize, DCTELEM block);	56	void ff_ea_idct_put_c(uint8_t dest, int linesize, DCTELEM block);
57		57
		58	/* binkidct.c */
		59	void ff_bink_idct_c (DCTELEM *block);
		60	void ff_bink_idct_add_c(uint8_t dest, int linesize, DCTELEM block);
		61	void ff_bink_idct_put_c(uint8_t dest, int linesize, DCTELEM block);
		62
58	uint8_t ff_cropTbl[256 + 2 * MAX_NEG_CROP] = {0, };	63	uint8_t ff_cropTbl[256 + 2 * MAX_NEG_CROP] = {0, };
59	uint32_t ff_squareTbl[512] = {0, };	64	uint32_t ff_squareTbl[512] = {0, };
60		65
@@ -656,6 +661,27 @@ static void put_signed_pixels_clamped_c(const DCTELEM *block, · 595 unmodified lines
656	}	661	}
657	}	662	}
658		663
		664	static void put_pixels_nonclamped_c(const DCTELEM block, uint8_t restrict pixels,
		665	int line_size)
		666	{
		667	int i;
		668
		669	/* read the pixels */
		670	for(i=0;i<8;i++) {
		671	pixels[0] = block[0];
		672	pixels[1] = block[1];
		673	pixels[2] = block[2];
		674	pixels[3] = block[3];
		675	pixels[4] = block[4];
		676	pixels[5] = block[5];
		677	pixels[6] = block[6];
		678	pixels[7] = block[7];
		679
		680	pixels += line_size;
		681	block += 8;
		682	}
		683	}
		684
659	static void add_pixels_clamped_c(const DCTELEM block, uint8_t restrict pixels,	685	static void add_pixels_clamped_c(const DCTELEM block, uint8_t restrict pixels,
660	int line_size)	686	int line_size)
661	{	687	{
@@ -747,6 +773,42 @@ static int sum_abs_dctelem_c(DCTELEM *block) · 85 unmodified lines
747	return sum;	773	return sum;
748	}	774	}
749		775
		776	static void fill_block16_c(uint8_t *block, uint8_t value, int line_size, int h)
		777	{
		778	int i;
		779
		780	for (i = 0; i < h; i++) {
		781	memset(block, value, 16);
		782	block += line_size;
		783	}
		784	}
		785
		786	static void fill_block8_c(uint8_t *block, uint8_t value, int line_size, int h)
		787	{
		788	int i;
		789
		790	for (i = 0; i < h; i++) {
		791	memset(block, value, 8);
		792	block += line_size;
		793	}
		794	}
		795
		796	static void scale_block_c(const uint8_t src[64]/align 8/, uint8_t dst/align 8*/, int linesize)
		797	{
		798	int i, j;
		799	uint16_t *dst1 = dst;
		800	uint16_t *dst2 = dst + linesize;
		801
		802	for (j = 0; j < 8; j++) {
		803	for (i = 0; i < 8; i++) {
		804	dst1[i] = dst2[i] = src[i] * 0x0101;
		805	}
		806	src += 8;
		807	dst1 += linesize;
		808	dst2 += linesize;
		809	}
		810	}
		811
750	#if 0	812	#if 0
751		813
752	#define PIXOP2(OPNAME, OP) \	814	#define PIXOP2(OPNAME, OP) \
@@ -4557,6 +4619,11 @@ av_cold void dsputil_init(DSPContext* c, AVCodecContext *avctx) · 3804 unmodified lines
4557	}else if(CONFIG_EATGQ_DECODER && avctx->idct_algo==FF_IDCT_EA) {	4619	}else if(CONFIG_EATGQ_DECODER && avctx->idct_algo==FF_IDCT_EA) {
4558	c->idct_put= ff_ea_idct_put_c;	4620	c->idct_put= ff_ea_idct_put_c;
4559	c->idct_permutation_type= FF_NO_IDCT_PERM;	4621	c->idct_permutation_type= FF_NO_IDCT_PERM;
		4622	}else if(CONFIG_BINK_DECODER && avctx->idct_algo==FF_IDCT_BINK) {
		4623	c->idct = ff_bink_idct_c;
		4624	c->idct_add = ff_bink_idct_add_c;
		4625	c->idct_put = ff_bink_idct_put_c;
		4626	c->idct_permutation_type = FF_NO_IDCT_PERM;
4560	}else{ //accurate/default	4627	}else{ //accurate/default
4561	c->idct_put= ff_simple_idct_put;	4628	c->idct_put= ff_simple_idct_put;
4562	c->idct_add= ff_simple_idct_add;	4629	c->idct_add= ff_simple_idct_add;
@@ -4580,6 +4647,7 @@ av_cold void dsputil_init(DSPContext* c, AVCodecContext *avctx) · 17 unmodified lines
4580	c->diff_pixels = diff_pixels_c;	4647	c->diff_pixels = diff_pixels_c;
4581	c->put_pixels_clamped = put_pixels_clamped_c;	4648	c->put_pixels_clamped = put_pixels_clamped_c;
4582	c->put_signed_pixels_clamped = put_signed_pixels_clamped_c;	4649	c->put_signed_pixels_clamped = put_signed_pixels_clamped_c;
		4650	c->put_pixels_nonclamped = put_pixels_nonclamped_c;
4583	c->add_pixels_clamped = add_pixels_clamped_c;	4651	c->add_pixels_clamped = add_pixels_clamped_c;
4584	c->add_pixels8 = add_pixels8_c;	4652	c->add_pixels8 = add_pixels8_c;
4585	c->add_pixels4 = add_pixels4_c;	4653	c->add_pixels4 = add_pixels4_c;
@@ -4591,6 +4659,10 @@ av_cold void dsputil_init(DSPContext* c, AVCodecContext *avctx) · 5 unmodified lines
4591	c->pix_sum = pix_sum_c;	4659	c->pix_sum = pix_sum_c;
4592	c->pix_norm1 = pix_norm1_c;	4660	c->pix_norm1 = pix_norm1_c;
4593		4661
		4662	c->fill_block_tab[0] = fill_block16_c;
		4663	c->fill_block_tab[1] = fill_block8_c;
		4664	c->scale_block = scale_block_c;
		4665
4594	/* TODO [0] 16 [1] 8 */	4666	/* TODO [0] 16 [1] 8 */
4595	c->pix_abs[0][0] = pix_abs16_c;	4667	c->pix_abs[0][0] = pix_abs16_c;
4596	c->pix_abs[0][1] = pix_abs16_x2_c;	4668	c->pix_abs[0][1] = pix_abs16_x2_c;

libavcodec/dsputil.h+7−0

 typedef void (*h264_weight_func)(uint8_t *block, int stride, int log2_denom, int weight, int offset);
 typedef void (*h264_biweight_func)(uint8_t *dst, uint8_t *src, int stride, int log2_denom, int weightd, int weights, int offset);
+typedef void (*op_fill_func)(uint8_t *block/*align width (8 or 16)*/, uint8_t value, int line_size, int h);
 #define DEF_OLD_QPEL(name)\
 void ff_put_        ## name (uint8_t *dst/*align width (8 or 16)*/, uint8_t *src/*align 1*/, int stride);\
 void ff_put_no_rnd_ ## name (uint8_t *dst/*align width (8 or 16)*/, uint8_t *src/*align 1*/, int stride);\
     void (*diff_pixels)(DCTELEM *block/*align 16*/, const uint8_t *s1/*align 8*/, const uint8_t *s2/*align 8*/, int stride);
     void (*put_pixels_clamped)(const DCTELEM *block/*align 16*/, uint8_t *pixels/*align 8*/, int line_size);
     void (*put_signed_pixels_clamped)(const DCTELEM *block/*align 16*/, uint8_t *pixels/*align 8*/, int line_size);
+    void (*put_pixels_nonclamped)(const DCTELEM *block/*align 16*/, uint8_t *pixels/*align 8*/, int line_size);
     void (*add_pixels_clamped)(const DCTELEM *block/*align 16*/, uint8_t *pixels/*align 8*/, int line_size);
     void (*add_pixels8)(uint8_t *pixels, DCTELEM *block, int line_size);
     void (*add_pixels4)(uint8_t *pixels, DCTELEM *block, int line_size);
     qpel_mc_func avg_rv40_qpel_pixels_tab[4][16];
     h264_chroma_mc_func put_rv40_chroma_pixels_tab[3];
     h264_chroma_mc_func avg_rv40_chroma_pixels_tab[3];
+    /* bink functions */
+    op_fill_func fill_block_tab[2];
+    void (*scale_block)(const uint8_t src[64]/*align 8*/, uint8_t *dst/*align 8*/, int linesize);
 } DSPContext;
 void dsputil_static_init(void);

Bink video decoder

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code