WebSVN – Kolibri OS – Blame – /contrib/sdk/sources/ffmpeg/ffmpeg-2.8/libavcodec/mss4.c

Rev	Author	Line No.	Line
6147	serge	1	/*
		2	* Microsoft Screen 4 (aka Microsoft Expression Encoder Screen) decoder
		3	* Copyright (c) 2012 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	/**
		23	* @file
		24	* Microsoft Screen 4 (aka Microsoft Titanium Screen 2,
		25	* aka Microsoft Expression Encoder Screen) decoder
		26	*/
		27
		28	#include "avcodec.h"
		29	#include "bytestream.h"
		30	#include "get_bits.h"
		31	#include "internal.h"
		32	#include "mss34dsp.h"
		33	#include "unary.h"
		34
		35	#define HEADER_SIZE 8
		36
		37	enum FrameType {
		38	INTRA_FRAME = 0,
		39	INTER_FRAME,
		40	SKIP_FRAME
		41	};
		42
		43	enum BlockType {
		44	SKIP_BLOCK = 0,
		45	DCT_BLOCK,
		46	IMAGE_BLOCK,
		47	};
		48
		49	enum CachePos {
		50	LEFT = 0,
		51	TOP_LEFT,
		52	TOP,
		53	};
		54
		55	static const uint8_t mss4_dc_vlc_lens[2][16] = {
		56	{ 0, 1, 5, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0 },
		57	{ 0, 3, 1, 1, 1, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 0 }
		58	};
		59
		60	static const uint8_t mss4_ac_vlc_lens[2][16] = {
		61	{ 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 125 },
		62	{ 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 119 }
		63	};
		64
		65	static const uint8_t mss4_ac_vlc_syms[2][162] = {
		66	{ 0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
		67	0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
		68	0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1, 0x08,
		69	0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0,
		70	0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0A, 0x16,
		71	0x17, 0x18, 0x19, 0x1A, 0x25, 0x26, 0x27, 0x28,
		72	0x29, 0x2A, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
		73	0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
		74	0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
		75	0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
		76	0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
		77	0x7A, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
		78	0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
		79	0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7,
		80	0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6,
		81	0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5,
		82	0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 0xD4,
		83	0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE1, 0xE2,
		84	0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA,
		85	0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8,
		86	0xF9, 0xFA },
		87	{ 0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
		88	0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
		89	0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
		90	0xA1, 0xB1, 0xC1, 0x09, 0x23, 0x33, 0x52, 0xF0,
		91	0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16, 0x24, 0x34,
		92	0xE1, 0x25, 0xF1, 0x17, 0x18, 0x19, 0x1A, 0x26,
		93	0x27, 0x28, 0x29, 0x2A, 0x35, 0x36, 0x37, 0x38,
		94	0x39, 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
		95	0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
		96	0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
		97	0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
		98	0x79, 0x7A, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
		99	0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96,
		100	0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5,
		101	0xA6, 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4,
		102	0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xC2, 0xC3,
		103	0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2,
		104	0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA,
		105	0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9,
		106	0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8,
		107	0xF9, 0xFA }
		108	};
		109
		110	static const uint8_t vec_len_syms[2][4] = {
		111	{ 4, 2, 3, 1 },
		112	{ 4, 1, 2, 3 }
		113	};
		114
		115	static const uint8_t mss4_vec_entry_vlc_lens[2][16] = {
		116	{ 0, 2, 2, 3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
		117	{ 0, 1, 5, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
		118	};
		119
		120	static const uint8_t mss4_vec_entry_vlc_syms[2][9] = {
		121	{ 0, 7, 6, 5, 8, 4, 3, 1, 2 },
		122	{ 0, 2, 3, 4, 5, 6, 7, 1, 8 }
		123	};
		124
		125	#define MAX_ENTRIES 162
		126
		127	typedef struct MSS4Context {
		128	AVFrame *pic;
		129
		130	VLC dc_vlc[2], ac_vlc[2];
		131	VLC vec_entry_vlc[2];
		132	int block[64];
		133	uint8_t imgbuf[3][16 * 16];
		134
		135	int quality;
		136	uint16_t quant_mat[2][64];
		137
		138	int *prev_dc[3];
		139	int dc_stride[3];
		140	int dc_cache[4][4];
		141
		142	int prev_vec[3][4];
		143	} MSS4Context;
		144
		145	static av_cold int mss4_init_vlc(VLC vlc, const uint8_t lens,
		146	const uint8_t *syms, int num_syms)
		147	{
		148	uint8_t bits[MAX_ENTRIES];
		149	uint16_t codes[MAX_ENTRIES];
		150	int i, j;
		151	int prefix = 0, max_bits = 0, idx = 0;
		152
		153	for (i = 0; i < 16; i++) {
		154	for (j = 0; j < lens[i]; j++) {
		155	bits[idx] = i + 1;
		156	codes[idx] = prefix++;
		157	max_bits = i + 1;
		158	idx++;
		159	}
		160	prefix <<= 1;
		161	}
		162
		163	return ff_init_vlc_sparse(vlc, FFMIN(max_bits, 9), num_syms, bits, 1, 1,
		164	codes, 2, 2, syms, 1, 1, 0);
		165	}
		166
		167	static av_cold int mss4_init_vlcs(MSS4Context *ctx)
		168	{
		169	int ret, i;
		170
		171	for (i = 0; i < 2; i++) {
		172	ret = mss4_init_vlc(&ctx->dc_vlc[i], mss4_dc_vlc_lens[i], NULL, 12);
		173	if (ret)
		174	return ret;
		175	ret = mss4_init_vlc(&ctx->ac_vlc[i], mss4_ac_vlc_lens[i],
		176	mss4_ac_vlc_syms[i], 162);
		177	if (ret)
		178	return ret;
		179	ret = mss4_init_vlc(&ctx->vec_entry_vlc[i], mss4_vec_entry_vlc_lens[i],
		180	mss4_vec_entry_vlc_syms[i], 9);
		181	if (ret)
		182	return ret;
		183	}
		184	return 0;
		185	}
		186
		187	static av_cold void mss4_free_vlcs(MSS4Context *ctx)
		188	{
		189	int i;
		190
		191	for (i = 0; i < 2; i++) {
		192	ff_free_vlc(&ctx->dc_vlc[i]);
		193	ff_free_vlc(&ctx->ac_vlc[i]);
		194	ff_free_vlc(&ctx->vec_entry_vlc[i]);
		195	}
		196	}
		197
		198	/* This function returns values in the range
		199	* (-range + 1; -range/2] U [range/2; range - 1)
		200	* i.e.
		201	* nbits = 0 -> 0
		202	* nbits = 1 -> -1, 1
		203	* nbits = 2 -> -3, -2, 2, 3
		204	*/
		205	static av_always_inline int get_coeff_bits(GetBitContext *gb, int nbits)
		206	{
		207	int val;
		208
		209	if (!nbits)
		210	return 0;
		211
		212	val = get_bits(gb, nbits);
		213	if (val < (1 << (nbits - 1)))
		214	val -= (1 << nbits) - 1;
		215
		216	return val;
		217	}
		218
		219	static inline int get_coeff(GetBitContext gb, VLC vlc)
		220	{
		221	int val = get_vlc2(gb, vlc->table, vlc->bits, 2);
		222
		223	return get_coeff_bits(gb, val);
		224	}
		225
		226	static int mss4_decode_dct(GetBitContext gb, VLC dc_vlc, VLC *ac_vlc,
		227	int block, int dc_cache,
		228	int bx, int by, uint16_t *quant_mat)
		229	{
		230	int skip, val, pos = 1, zz_pos, dc;
		231
		232	memset(block, 0, sizeof(block) 64);
		233
		234	dc = get_coeff(gb, dc_vlc);
		235	// DC prediction is the same as in MSS3
		236	if (by) {
		237	if (bx) {
		238	int l, tl, t;
		239
		240	l = dc_cache[LEFT];
		241	tl = dc_cache[TOP_LEFT];
		242	t = dc_cache[TOP];
		243
		244	if (FFABS(t - tl) <= FFABS(l - tl))
		245	dc += l;
		246	else
		247	dc += t;
		248	} else {
		249	dc += dc_cache[TOP];
		250	}
		251	} else if (bx) {
		252	dc += dc_cache[LEFT];
		253	}
		254	dc_cache[LEFT] = dc;
		255	block[0] = dc * quant_mat[0];
		256
		257	while (pos < 64) {
		258	val = get_vlc2(gb, ac_vlc->table, 9, 2);
		259	if (!val)
		260	return 0;
		261	if (val == -1)
		262	return -1;
		263	if (val == 0xF0) {
		264	pos += 16;
		265	continue;
		266	}
		267	skip = val >> 4;
		268	val = get_coeff_bits(gb, val & 0xF);
		269	pos += skip;
		270	if (pos >= 64)
		271	return -1;
		272
		273	zz_pos = ff_zigzag_direct[pos];
		274	block[zz_pos] = val * quant_mat[zz_pos];
		275	pos++;
		276	}
		277
		278	return pos == 64 ? 0 : -1;
		279	}
		280
		281	static int mss4_decode_dct_block(MSS4Context c, GetBitContext gb,
		282	uint8_t *dst[3], int mb_x, int mb_y)
		283	{
		284	int i, j, k, ret;
		285	uint8_t *out = dst[0];
		286
		287	for (j = 0; j < 2; j++) {
		288	for (i = 0; i < 2; i++) {
		289	int xpos = mb_x * 2 + i;
		290	c->dc_cache[j][TOP_LEFT] = c->dc_cache[j][TOP];
		291	c->dc_cache[j][TOP] = c->prev_dc[0][mb_x * 2 + i];
		292	ret = mss4_decode_dct(gb, c->dc_vlc, c->ac_vlc, c->block,
		293	c->dc_cache[j],
		294	xpos, mb_y * 2 + j, c->quant_mat[0]);
		295	if (ret)
		296	return ret;
		297	c->prev_dc[0][mb_x * 2 + i] = c->dc_cache[j][LEFT];
		298
		299	ff_mss34_dct_put(out + xpos * 8, c->pic->linesize[0],
		300	c->block);
		301	}
		302	out += 8 * c->pic->linesize[0];
		303	}
		304
		305	for (i = 1; i < 3; i++) {
		306	c->dc_cache[i + 1][TOP_LEFT] = c->dc_cache[i + 1][TOP];
		307	c->dc_cache[i + 1][TOP] = c->prev_dc[i][mb_x];
		308	ret = mss4_decode_dct(gb, c->dc_vlc + 1, c->ac_vlc + 1,
		309	c->block, c->dc_cache[i + 1], mb_x, mb_y,
		310	c->quant_mat[1]);
		311	if (ret)
		312	return ret;
		313	c->prev_dc[i][mb_x] = c->dc_cache[i + 1][LEFT];
		314
		315	ff_mss34_dct_put(c->imgbuf[i], 8, c->block);
		316	out = dst[i] + mb_x * 16;
		317	// Since the DCT block is coded as YUV420 and the whole frame as YUV444,
		318	// we need to scale chroma.
		319	for (j = 0; j < 16; j++) {
		320	for (k = 0; k < 8; k++)
		321	AV_WN16A(out + k * 2, c->imgbuf[i][k + (j & ~1) * 4] * 0x101);
		322	out += c->pic->linesize[i];
		323	}
		324	}
		325
		326	return 0;
		327	}
		328
		329	static void read_vec_pos(GetBitContext gb, int vec_pos, int *sel_flag,
		330	int sel_len, int prev)
		331	{
		332	int i, y_flag = 0;
		333
		334	for (i = 2; i >= 0; i--) {
		335	if (!sel_flag[i]) {
		336	vec_pos[i] = 0;
		337	continue;
		338	}
		339	if ((!i && !y_flag) \|\| get_bits1(gb)) {
		340	if (sel_len[i] > 0) {
		341	int pval = prev[i];
		342	vec_pos[i] = get_bits(gb, sel_len[i]);
		343	if (vec_pos[i] >= pval)
		344	vec_pos[i]++;
		345	} else {
		346	vec_pos[i] = !prev[i];
		347	}
		348	y_flag = 1;
		349	} else {
		350	vec_pos[i] = prev[i];
		351	}
		352	}
		353	}
		354
		355	static int get_value_cached(GetBitContext gb, int vec_pos, uint8_t vec,
		356	int vec_size, int component, int shift, int *prev)
		357	{
		358	if (vec_pos < vec_size)
		359	return vec[vec_pos];
		360	if (!get_bits1(gb))
		361	return prev[component];
		362	prev[component] = get_bits(gb, 8 - shift) << shift;
		363	return prev[component];
		364	}
		365
		366	#define MKVAL(vals) ((vals)[0] \| ((vals)[1] << 3) \| ((vals)[2] << 6))
		367
		368	/* Image mode - the hardest to comprehend MSS4 coding mode.
		369	*
		370	* In this mode all three 16x16 blocks are coded together with a method
		371	* remotely similar to the methods employed in MSS1-MSS3.
		372	* The idea is that every component has a vector of 1-4 most common symbols
		373	* and an escape mode for reading new value from the bitstream. Decoding
		374	* consists of retrieving pixel values from the vector or reading new ones
		375	* from the bitstream; depending on flags read from the bitstream, these vector
		376	* positions can be updated or reused from the state of the previous line
		377	* or previous pixel.
		378	*/
		379	static int mss4_decode_image_block(MSS4Context ctx, GetBitContext gb,
		380	uint8_t *picdst[3], int mb_x, int mb_y)
		381	{
		382	uint8_t vec[3][4];
		383	int vec_len[3];
		384	int sel_len[3], sel_flag[3];
		385	int i, j, k, mode, split;
		386	int prev_vec1 = 0, prev_split = 0;
		387	int vals[3] = { 0 };
		388	int prev_pix[3] = { 0 };
		389	int prev_mode[16] = { 0 };
		390	uint8_t *dst[3];
		391
		392	const int val_shift = ctx->quality == 100 ? 0 : 2;
		393
		394	for (i = 0; i < 3; i++)
		395	dst[i] = ctx->imgbuf[i];
		396
		397	for (i = 0; i < 3; i++) {
		398	vec_len[i] = vec_len_syms[!!i][get_unary(gb, 0, 3)];
		399	for (j = 0; j < vec_len[i]; j++) {
		400	vec[i][j] = get_coeff(gb, &ctx->vec_entry_vlc[!!i]);
		401	vec[i][j] += ctx->prev_vec[i][j];
		402	ctx->prev_vec[i][j] = vec[i][j];
		403	}
		404	sel_flag[i] = vec_len[i] > 1;
		405	sel_len[i] = vec_len[i] > 2 ? vec_len[i] - 2 : 0;
		406	}
		407
		408	for (j = 0; j < 16; j++) {
		409	if (get_bits1(gb)) {
		410	split = 0;
		411	if (get_bits1(gb)) {
		412	prev_mode[0] = 0;
		413	vals[0] = vals[1] = vals[2] = 0;
		414	mode = 2;
		415	} else {
		416	mode = get_bits1(gb);
		417	if (mode)
		418	split = get_bits(gb, 4);
		419	}
		420	for (i = 0; i < 16; i++) {
		421	if (mode <= 1) {
		422	vals[0] = prev_mode[i] & 7;
		423	vals[1] = (prev_mode[i] >> 3) & 7;
		424	vals[2] = prev_mode[i] >> 6;
		425	if (mode == 1 && i == split) {
		426	read_vec_pos(gb, vals, sel_flag, sel_len, vals);
		427	}
		428	} else if (mode == 2) {
		429	if (get_bits1(gb))
		430	read_vec_pos(gb, vals, sel_flag, sel_len, vals);
		431	}
		432	for (k = 0; k < 3; k++)
		433	*dst[k]++ = get_value_cached(gb, vals[k], vec[k],
		434	vec_len[k], k,
		435	val_shift, prev_pix);
		436	prev_mode[i] = MKVAL(vals);
		437	}
		438	} else {
		439	if (get_bits1(gb)) {
		440	split = get_bits(gb, 4);
		441	if (split >= prev_split)
		442	split++;
		443	prev_split = split;
		444	} else {
		445	split = prev_split;
		446	}
		447	if (split) {
		448	vals[0] = prev_mode[0] & 7;
		449	vals[1] = (prev_mode[0] >> 3) & 7;
		450	vals[2] = prev_mode[0] >> 6;
		451	for (i = 0; i < 3; i++) {
		452	for (k = 0; k < split; k++) {
		453	*dst[i]++ = get_value_cached(gb, vals[i], vec[i],
		454	vec_len[i], i, val_shift,
		455	prev_pix);
		456	prev_mode[k] = MKVAL(vals);
		457	}
		458	}
		459	}
		460
		461	if (split != 16) {
		462	vals[0] = prev_vec1 & 7;
		463	vals[1] = (prev_vec1 >> 3) & 7;
		464	vals[2] = prev_vec1 >> 6;
		465	if (get_bits1(gb)) {
		466	read_vec_pos(gb, vals, sel_flag, sel_len, vals);
		467	prev_vec1 = MKVAL(vals);
		468	}
		469	for (i = 0; i < 3; i++) {
		470	for (k = 0; k < 16 - split; k++) {
		471	*dst[i]++ = get_value_cached(gb, vals[i], vec[i],
		472	vec_len[i], i, val_shift,
		473	prev_pix);
		474	prev_mode[split + k] = MKVAL(vals);
		475	}
		476	}
		477	}
		478	}
		479	}
		480
		481	for (i = 0; i < 3; i++)
		482	for (j = 0; j < 16; j++)
		483	memcpy(picdst[i] + mb_x * 16 + j * ctx->pic->linesize[i],
		484	ctx->imgbuf[i] + j * 16, 16);
		485
		486	return 0;
		487	}
		488
		489	static inline void mss4_update_dc_cache(MSS4Context *c, int mb_x)
		490	{
		491	int i;
		492
		493	c->dc_cache[0][TOP] = c->prev_dc[0][mb_x * 2 + 1];
		494	c->dc_cache[0][LEFT] = 0;
		495	c->dc_cache[1][TOP] = 0;
		496	c->dc_cache[1][LEFT] = 0;
		497
		498	for (i = 0; i < 2; i++)
		499	c->prev_dc[0][mb_x * 2 + i] = 0;
		500
		501	for (i = 1; i < 3; i++) {
		502	c->dc_cache[i + 1][TOP] = c->prev_dc[i][mb_x];
		503	c->dc_cache[i + 1][LEFT] = 0;
		504	c->prev_dc[i][mb_x] = 0;
		505	}
		506	}
		507
		508	static int mss4_decode_frame(AVCodecContext avctx, void data, int *got_frame,
		509	AVPacket *avpkt)
		510	{
		511	const uint8_t *buf = avpkt->data;
		512	int buf_size = avpkt->size;
		513	MSS4Context *c = avctx->priv_data;
		514	GetBitContext gb;
		515	GetByteContext bc;
		516	uint8_t *dst[3];
		517	int width, height, quality, frame_type;
		518	int x, y, i, mb_width, mb_height, blk_type;
		519	int ret;
		520
		521	if (buf_size < HEADER_SIZE) {
		522	av_log(avctx, AV_LOG_ERROR,
		523	"Frame should have at least %d bytes, got %d instead\n",
		524	HEADER_SIZE, buf_size);
		525	return AVERROR_INVALIDDATA;
		526	}
		527
		528	bytestream2_init(&bc, buf, buf_size);
		529	width = bytestream2_get_be16(&bc);
		530	height = bytestream2_get_be16(&bc);
		531	bytestream2_skip(&bc, 2);
		532	quality = bytestream2_get_byte(&bc);
		533	frame_type = bytestream2_get_byte(&bc);
		534
		535	if (width > avctx->width \|\|
		536	height != avctx->height) {
		537	av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d\n",
		538	width, height);
		539	return AVERROR_INVALIDDATA;
		540	}
		541	if (quality < 1 \|\| quality > 100) {
		542	av_log(avctx, AV_LOG_ERROR, "Invalid quality setting %d\n", quality);
		543	return AVERROR_INVALIDDATA;
		544	}
		545	if ((frame_type & ~3) \|\| frame_type == 3) {
		546	av_log(avctx, AV_LOG_ERROR, "Invalid frame type %d\n", frame_type);
		547	return AVERROR_INVALIDDATA;
		548	}
		549
		550	if (frame_type != SKIP_FRAME && !bytestream2_get_bytes_left(&bc)) {
		551	av_log(avctx, AV_LOG_ERROR,
		552	"Empty frame found but it is not a skip frame.\n");
		553	return AVERROR_INVALIDDATA;
		554	}
		555
		556	if ((ret = ff_reget_buffer(avctx, c->pic)) < 0)
		557	return ret;
		558	c->pic->key_frame = (frame_type == INTRA_FRAME);
		559	c->pic->pict_type = (frame_type == INTRA_FRAME) ? AV_PICTURE_TYPE_I
		560	: AV_PICTURE_TYPE_P;
		561	if (frame_type == SKIP_FRAME) {
		562	*got_frame = 1;
		563	if ((ret = av_frame_ref(data, c->pic)) < 0)
		564	return ret;
		565
		566	return buf_size;
		567	}
		568
		569	if (c->quality != quality) {
		570	c->quality = quality;
		571	for (i = 0; i < 2; i++)
		572	ff_mss34_gen_quant_mat(c->quant_mat[i], quality, !i);
		573	}
		574
		575	if ((ret = init_get_bits8(&gb, buf + HEADER_SIZE, buf_size - HEADER_SIZE)) < 0)
		576	return ret;
		577
		578	mb_width = FFALIGN(width, 16) >> 4;
		579	mb_height = FFALIGN(height, 16) >> 4;
		580	dst[0] = c->pic->data[0];
		581	dst[1] = c->pic->data[1];
		582	dst[2] = c->pic->data[2];
		583
		584	memset(c->prev_vec, 0, sizeof(c->prev_vec));
		585	for (y = 0; y < mb_height; y++) {
		586	memset(c->dc_cache, 0, sizeof(c->dc_cache));
		587	for (x = 0; x < mb_width; x++) {
		588	blk_type = decode012(&gb);
		589	switch (blk_type) {
		590	case DCT_BLOCK:
		591	if (mss4_decode_dct_block(c, &gb, dst, x, y) < 0) {
		592	av_log(avctx, AV_LOG_ERROR,
		593	"Error decoding DCT block %d,%d\n",
		594	x, y);
		595	return AVERROR_INVALIDDATA;
		596	}
		597	break;
		598	case IMAGE_BLOCK:
		599	if (mss4_decode_image_block(c, &gb, dst, x, y) < 0) {
		600	av_log(avctx, AV_LOG_ERROR,
		601	"Error decoding VQ block %d,%d\n",
		602	x, y);
		603	return AVERROR_INVALIDDATA;
		604	}
		605	break;
		606	case SKIP_BLOCK:
		607	if (frame_type == INTRA_FRAME) {
		608	av_log(avctx, AV_LOG_ERROR, "Skip block in intra frame\n");
		609	return AVERROR_INVALIDDATA;
		610	}
		611	break;
		612	}
		613	if (blk_type != DCT_BLOCK)
		614	mss4_update_dc_cache(c, x);
		615	}
		616	dst[0] += c->pic->linesize[0] * 16;
		617	dst[1] += c->pic->linesize[1] * 16;
		618	dst[2] += c->pic->linesize[2] * 16;
		619	}
		620
		621	if ((ret = av_frame_ref(data, c->pic)) < 0)
		622	return ret;
		623
		624	*got_frame = 1;
		625
		626	return buf_size;
		627	}
		628
		629	static av_cold int mss4_decode_end(AVCodecContext *avctx)
		630	{
		631	MSS4Context * const c = avctx->priv_data;
		632	int i;
		633
		634	av_frame_free(&c->pic);
		635	for (i = 0; i < 3; i++)
		636	av_freep(&c->prev_dc[i]);
		637	mss4_free_vlcs(c);
		638
		639	return 0;
		640	}
		641
		642	static av_cold int mss4_decode_init(AVCodecContext *avctx)
		643	{
		644	MSS4Context * const c = avctx->priv_data;
		645	int i;
		646
		647	if (mss4_init_vlcs(c)) {
		648	av_log(avctx, AV_LOG_ERROR, "Cannot initialise VLCs\n");
		649	mss4_free_vlcs(c);
		650	return AVERROR(ENOMEM);
		651	}
		652	for (i = 0; i < 3; i++) {
		653	c->dc_stride[i] = FFALIGN(avctx->width, 16) >> (2 + !!i);
		654	c->prev_dc[i] = av_malloc_array(c->dc_stride[i], sizeof(**c->prev_dc));
		655	if (!c->prev_dc[i]) {
		656	av_log(avctx, AV_LOG_ERROR, "Cannot allocate buffer\n");
		657	mss4_free_vlcs(c);
		658	return AVERROR(ENOMEM);
		659	}
		660	}
		661
		662	c->pic = av_frame_alloc();
		663	if (!c->pic) {
		664	mss4_decode_end(avctx);
		665	return AVERROR(ENOMEM);
		666	}
		667
		668	avctx->pix_fmt = AV_PIX_FMT_YUV444P;
		669
		670	return 0;
		671	}
		672
		673	AVCodec ff_mts2_decoder = {
		674	.name = "mts2",
		675	.long_name = NULL_IF_CONFIG_SMALL("MS Expression Encoder Screen"),
		676	.type = AVMEDIA_TYPE_VIDEO,
		677	.id = AV_CODEC_ID_MTS2,
		678	.priv_data_size = sizeof(MSS4Context),
		679	.init = mss4_decode_init,
		680	.close = mss4_decode_end,
		681	.decode = mss4_decode_frame,
		682	.capabilities = AV_CODEC_CAP_DR1,
		683	};

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/ffmpeg/ffmpeg-2.8/libavcodec/mss4.c – Rev 6147