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

Rev	Author	Line No.	Line
6147	serge	1	/*
		2	* 4XM codec
		3	* Copyright (c) 2003 Michael Niedermayer
		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	* 4XM codec.
		25	*/
		26
		27	#include
		28
		29	#include "libavutil/avassert.h"
		30	#include "libavutil/frame.h"
		31	#include "libavutil/imgutils.h"
		32	#include "libavutil/intreadwrite.h"
		33	#include "avcodec.h"
		34	#include "blockdsp.h"
		35	#include "bswapdsp.h"
		36	#include "bytestream.h"
		37	#include "get_bits.h"
		38	#include "internal.h"
		39
		40
		41	#define BLOCK_TYPE_VLC_BITS 5
		42	#define ACDC_VLC_BITS 9
		43
		44	#define CFRAME_BUFFER_COUNT 100
		45
		46	static const uint8_t block_type_tab[2][4][8][2] = {
		47	{
		48	{ // { 8, 4, 2 } x { 8, 4, 2}
		49	{ 0, 1 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 30, 5 }, { 31, 5 }, { 0, 0 }
		50	}, { // { 8, 4 } x 1
		51	{ 0, 1 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
		52	}, { // 1 x { 8, 4 }
		53	{ 0, 1 }, { 2, 2 }, { 0, 0 }, { 6, 3 }, { 14, 4 }, { 15, 4 }, { 0, 0 }
		54	}, { // 1 x 2, 2 x 1
		55	{ 0, 1 }, { 0, 0 }, { 0, 0 }, { 2, 2 }, { 6, 3 }, { 14, 4 }, { 15, 4 }
		56	}
		57	}, {
		58	{ // { 8, 4, 2 } x { 8, 4, 2}
		59	{ 1, 2 }, { 4, 3 }, { 5, 3 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
		60	}, {// { 8, 4 } x 1
		61	{ 1, 2 }, { 0, 0 }, { 2, 2 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
		62	}, {// 1 x { 8, 4 }
		63	{ 1, 2 }, { 2, 2 }, { 0, 0 }, { 0, 2 }, { 6, 3 }, { 7, 3 }, { 0, 0 }
		64	}, {// 1 x 2, 2 x 1
		65	{ 1, 2 }, { 0, 0 }, { 0, 0 }, { 0, 2 }, { 2, 2 }, { 6, 3 }, { 7, 3 }
		66	}
		67	}
		68	};
		69
		70	static const uint8_t size2index[4][4] = {
		71	{ -1, 3, 1, 1 },
		72	{ 3, 0, 0, 0 },
		73	{ 2, 0, 0, 0 },
		74	{ 2, 0, 0, 0 },
		75	};
		76
		77	static const int8_t mv[256][2] = {
		78	{ 0, 0 }, { 0, -1 }, { -1, 0 }, { 1, 0 }, { 0, 1 }, { -1, -1 }, { 1, -1 }, { -1, 1 },
		79	{ 1, 1 }, { 0, -2 }, { -2, 0 }, { 2, 0 }, { 0, 2 }, { -1, -2 }, { 1, -2 }, { -2, -1 },
		80	{ 2, -1 }, { -2, 1 }, { 2, 1 }, { -1, 2 }, { 1, 2 }, { -2, -2 }, { 2, -2 }, { -2, 2 },
		81	{ 2, 2 }, { 0, -3 }, { -3, 0 }, { 3, 0 }, { 0, 3 }, { -1, -3 }, { 1, -3 }, { -3, -1 },
		82	{ 3, -1 }, { -3, 1 }, { 3, 1 }, { -1, 3 }, { 1, 3 }, { -2, -3 }, { 2, -3 }, { -3, -2 },
		83	{ 3, -2 }, { -3, 2 }, { 3, 2 }, { -2, 3 }, { 2, 3 }, { 0, -4 }, { -4, 0 }, { 4, 0 },
		84	{ 0, 4 }, { -1, -4 }, { 1, -4 }, { -4, -1 }, { 4, -1 }, { 4, 1 }, { -1, 4 }, { 1, 4 },
		85	{ -3, -3 }, { -3, 3 }, { 3, 3 }, { -2, -4 }, { -4, -2 }, { 4, -2 }, { -4, 2 }, { -2, 4 },
		86	{ 2, 4 }, { -3, -4 }, { 3, -4 }, { 4, -3 }, { -5, 0 }, { -4, 3 }, { -3, 4 }, { 3, 4 },
		87	{ -1, -5 }, { -5, -1 }, { -5, 1 }, { -1, 5 }, { -2, -5 }, { 2, -5 }, { 5, -2 }, { 5, 2 },
		88	{ -4, -4 }, { -4, 4 }, { -3, -5 }, { -5, -3 }, { -5, 3 }, { 3, 5 }, { -6, 0 }, { 0, 6 },
		89	{ -6, -1 }, { -6, 1 }, { 1, 6 }, { 2, -6 }, { -6, 2 }, { 2, 6 }, { -5, -4 }, { 5, 4 },
		90	{ 4, 5 }, { -6, -3 }, { 6, 3 }, { -7, 0 }, { -1, -7 }, { 5, -5 }, { -7, 1 }, { -1, 7 },
		91	{ 4, -6 }, { 6, 4 }, { -2, -7 }, { -7, 2 }, { -3, -7 }, { 7, -3 }, { 3, 7 }, { 6, -5 },
		92	{ 0, -8 }, { -1, -8 }, { -7, -4 }, { -8, 1 }, { 4, 7 }, { 2, -8 }, { -2, 8 }, { 6, 6 },
		93	{ -8, 3 }, { 5, -7 }, { -5, 7 }, { 8, -4 }, { 0, -9 }, { -9, -1 }, { 1, 9 }, { 7, -6 },
		94	{ -7, 6 }, { -5, -8 }, { -5, 8 }, { -9, 3 }, { 9, -4 }, { 7, -7 }, { 8, -6 }, { 6, 8 },
		95	{ 10, 1 }, { -10, 2 }, { 9, -5 }, { 10, -3 }, { -8, -7 }, { -10, -4 }, { 6, -9 }, { -11, 0 },
		96	{ 11, 1 }, { -11, -2 }, { -2, 11 }, { 7, -9 }, { -7, 9 }, { 10, 6 }, { -4, 11 }, { 8, -9 },
		97	{ 8, 9 }, { 5, 11 }, { 7, -10 }, { 12, -3 }, { 11, 6 }, { -9, -9 }, { 8, 10 }, { 5, 12 },
		98	{ -11, 7 }, { 13, 2 }, { 6, -12 }, { 10, 9 }, { -11, 8 }, { -7, 12 }, { 0, 14 }, { 14, -2 },
		99	{ -9, 11 }, { -6, 13 }, { -14, -4 }, { -5, -14 }, { 5, 14 }, { -15, -1 }, { -14, -6 }, { 3, -15 },
		100	{ 11, -11 }, { -7, 14 }, { -5, 15 }, { 8, -14 }, { 15, 6 }, { 3, 16 }, { 7, -15 }, { -16, 5 },
		101	{ 0, 17 }, { -16, -6 }, { -10, 14 }, { -16, 7 }, { 12, 13 }, { -16, 8 }, { -17, 6 }, { -18, 3 },
		102	{ -7, 17 }, { 15, 11 }, { 16, 10 }, { 2, -19 }, { 3, -19 }, { -11, -16 }, { -18, 8 }, { -19, -6 },
		103	{ 2, -20 }, { -17, -11 }, { -10, -18 }, { 8, 19 }, { -21, -1 }, { -20, 7 }, { -4, 21 }, { 21, 5 },
		104	{ 15, 16 }, { 2, -22 }, { -10, -20 }, { -22, 5 }, { 20, -11 }, { -7, -22 }, { -12, 20 }, { 23, -5 },
		105	{ 13, -20 }, { 24, -2 }, { -15, 19 }, { -11, 22 }, { 16, 19 }, { 23, -10 }, { -18, -18 }, { -9, -24 },
		106	{ 24, -10 }, { -3, 26 }, { -23, 13 }, { -18, -20 }, { 17, 21 }, { -4, 27 }, { 27, 6 }, { 1, -28 },
		107	{ -11, 26 }, { -17, -23 }, { 7, 28 }, { 11, -27 }, { 29, 5 }, { -23, -19 }, { -28, -11 }, { -21, 22 },
		108	{ -30, 7 }, { -17, 26 }, { -27, 16 }, { 13, 29 }, { 19, -26 }, { 10, -31 }, { -14, -30 }, { 20, -27 },
		109	{ -29, 18 }, { -16, -31 }, { -28, -22 }, { 21, -30 }, { -25, 28 }, { 26, -29 }, { 25, -32 }, { -32, -32 }
		110	};
		111
		112	/* This is simply the scaled down elementwise product of the standard JPEG
		113	* quantizer table and the AAN premul table. */
		114	static const uint8_t dequant_table[64] = {
		115	16, 15, 13, 19, 24, 31, 28, 17,
		116	17, 23, 25, 31, 36, 63, 45, 21,
		117	18, 24, 27, 37, 52, 59, 49, 20,
		118	16, 28, 34, 40, 60, 80, 51, 20,
		119	18, 31, 48, 66, 68, 86, 56, 21,
		120	19, 38, 56, 59, 64, 64, 48, 20,
		121	27, 48, 55, 55, 56, 51, 35, 15,
		122	20, 35, 34, 32, 31, 22, 15, 8,
		123	};
		124
		125	static VLC block_type_vlc[2][4];
		126
		127
		128	typedef struct CFrameBuffer {
		129	unsigned int allocated_size;
		130	unsigned int size;
		131	int id;
		132	uint8_t *data;
		133	} CFrameBuffer;
		134
		135	typedef struct FourXContext {
		136	AVCodecContext *avctx;
		137	BlockDSPContext bdsp;
		138	BswapDSPContext bbdsp;
		139	uint16_t *frame_buffer;
		140	uint16_t *last_frame_buffer;
		141	GetBitContext pre_gb; ///< ac/dc prefix
		142	GetBitContext gb;
		143	GetByteContext g;
		144	GetByteContext g2;
		145	int mv[256];
		146	VLC pre_vlc;
		147	int last_dc;
		148	DECLARE_ALIGNED(16, int16_t, block)[6][64];
		149	void *bitstream_buffer;
		150	unsigned int bitstream_buffer_size;
		151	int version;
		152	CFrameBuffer cfrm[CFRAME_BUFFER_COUNT];
		153	} FourXContext;
		154
		155
		156	#define FIX_1_082392200 70936
		157	#define FIX_1_414213562 92682
		158	#define FIX_1_847759065 121095
		159	#define FIX_2_613125930 171254
		160
		161	#define MULTIPLY(var, const) (((var) * (const)) >> 16)
		162
		163	static void idct(int16_t block[64])
		164	{
		165	int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
		166	int tmp10, tmp11, tmp12, tmp13;
		167	int z5, z10, z11, z12, z13;
		168	int i;
		169	int temp[64];
		170
		171	for (i = 0; i < 8; i++) {
		172	tmp10 = block[8 * 0 + i] + block[8 * 4 + i];
		173	tmp11 = block[8 * 0 + i] - block[8 * 4 + i];
		174
		175	tmp13 = block[8 * 2 + i] + block[8 * 6 + i];
		176	tmp12 = MULTIPLY(block[8 * 2 + i] - block[8 * 6 + i], FIX_1_414213562) - tmp13;
		177
		178	tmp0 = tmp10 + tmp13;
		179	tmp3 = tmp10 - tmp13;
		180	tmp1 = tmp11 + tmp12;
		181	tmp2 = tmp11 - tmp12;
		182
		183	z13 = block[8 * 5 + i] + block[8 * 3 + i];
		184	z10 = block[8 * 5 + i] - block[8 * 3 + i];
		185	z11 = block[8 * 1 + i] + block[8 * 7 + i];
		186	z12 = block[8 * 1 + i] - block[8 * 7 + i];
		187
		188	tmp7 = z11 + z13;
		189	tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
		190
		191	z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
		192	tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
		193	tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
		194
		195	tmp6 = tmp12 - tmp7;
		196	tmp5 = tmp11 - tmp6;
		197	tmp4 = tmp10 + tmp5;
		198
		199	temp[8 * 0 + i] = tmp0 + tmp7;
		200	temp[8 * 7 + i] = tmp0 - tmp7;
		201	temp[8 * 1 + i] = tmp1 + tmp6;
		202	temp[8 * 6 + i] = tmp1 - tmp6;
		203	temp[8 * 2 + i] = tmp2 + tmp5;
		204	temp[8 * 5 + i] = tmp2 - tmp5;
		205	temp[8 * 4 + i] = tmp3 + tmp4;
		206	temp[8 * 3 + i] = tmp3 - tmp4;
		207	}
		208
		209	for (i = 0; i < 8 * 8; i += 8) {
		210	tmp10 = temp[0 + i] + temp[4 + i];
		211	tmp11 = temp[0 + i] - temp[4 + i];
		212
		213	tmp13 = temp[2 + i] + temp[6 + i];
		214	tmp12 = MULTIPLY(temp[2 + i] - temp[6 + i], FIX_1_414213562) - tmp13;
		215
		216	tmp0 = tmp10 + tmp13;
		217	tmp3 = tmp10 - tmp13;
		218	tmp1 = tmp11 + tmp12;
		219	tmp2 = tmp11 - tmp12;
		220
		221	z13 = temp[5 + i] + temp[3 + i];
		222	z10 = temp[5 + i] - temp[3 + i];
		223	z11 = temp[1 + i] + temp[7 + i];
		224	z12 = temp[1 + i] - temp[7 + i];
		225
		226	tmp7 = z11 + z13;
		227	tmp11 = MULTIPLY(z11 - z13, FIX_1_414213562);
		228
		229	z5 = MULTIPLY(z10 + z12, FIX_1_847759065);
		230	tmp10 = MULTIPLY(z12, FIX_1_082392200) - z5;
		231	tmp12 = MULTIPLY(z10, -FIX_2_613125930) + z5;
		232
		233	tmp6 = tmp12 - tmp7;
		234	tmp5 = tmp11 - tmp6;
		235	tmp4 = tmp10 + tmp5;
		236
		237	block[0 + i] = (tmp0 + tmp7) >> 6;
		238	block[7 + i] = (tmp0 - tmp7) >> 6;
		239	block[1 + i] = (tmp1 + tmp6) >> 6;
		240	block[6 + i] = (tmp1 - tmp6) >> 6;
		241	block[2 + i] = (tmp2 + tmp5) >> 6;
		242	block[5 + i] = (tmp2 - tmp5) >> 6;
		243	block[4 + i] = (tmp3 + tmp4) >> 6;
		244	block[3 + i] = (tmp3 - tmp4) >> 6;
		245	}
		246	}
		247
		248	static av_cold void init_vlcs(FourXContext *f)
		249	{
		250	static VLC_TYPE table[2][4][32][2];
		251	int i, j;
		252
		253	for (i = 0; i < 2; i++) {
		254	for (j = 0; j < 4; j++) {
		255	block_type_vlc[i][j].table = table[i][j];
		256	block_type_vlc[i][j].table_allocated = 32;
		257	init_vlc(&block_type_vlc[i][j], BLOCK_TYPE_VLC_BITS, 7,
		258	&block_type_tab[i][j][0][1], 2, 1,
		259	&block_type_tab[i][j][0][0], 2, 1,
		260	INIT_VLC_USE_NEW_STATIC);
		261	}
		262	}
		263	}
		264
		265	static void init_mv(FourXContext *f, int linesize)
		266	{
		267	int i;
		268
		269	for (i = 0; i < 256; i++) {
		270	if (f->version > 1)
		271	f->mv[i] = mv[i][0] + mv[i][1] * linesize / 2;
		272	else
		273	f->mv[i] = (i & 15) - 8 + ((i >> 4) - 8) * linesize / 2;
		274	}
		275	}
		276
		277	#if HAVE_BIGENDIAN
		278	#define LE_CENTRIC_MUL(dst, src, scale, dc) \
		279	{ \
		280	unsigned tmpval = AV_RN32(src); \
		281	tmpval = (tmpval << 16) \| (tmpval >> 16); \
		282	tmpval = tmpval * (scale) + (dc); \
		283	tmpval = (tmpval << 16) \| (tmpval >> 16); \
		284	AV_WN32A(dst, tmpval); \
		285	}
		286	#else
		287	#define LE_CENTRIC_MUL(dst, src, scale, dc) \
		288	{ \
		289	unsigned tmpval = AV_RN32(src) * (scale) + (dc); \
		290	AV_WN32A(dst, tmpval); \
		291	}
		292	#endif
		293
		294	static inline void mcdc(uint16_t dst, const uint16_t src, int log2w,
		295	int h, int stride, int scale, unsigned dc)
		296	{
		297	int i;
		298	dc *= 0x10001;
		299
		300	switch (log2w) {
		301	case 0:
		302	for (i = 0; i < h; i++) {
		303	dst[0] = scale * src[0] + dc;
		304	if (scale)
		305	src += stride;
		306	dst += stride;
		307	}
		308	break;
		309	case 1:
		310	for (i = 0; i < h; i++) {
		311	LE_CENTRIC_MUL(dst, src, scale, dc);
		312	if (scale)
		313	src += stride;
		314	dst += stride;
		315	}
		316	break;
		317	case 2:
		318	for (i = 0; i < h; i++) {
		319	LE_CENTRIC_MUL(dst, src, scale, dc);
		320	LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
		321	if (scale)
		322	src += stride;
		323	dst += stride;
		324	}
		325	break;
		326	case 3:
		327	for (i = 0; i < h; i++) {
		328	LE_CENTRIC_MUL(dst, src, scale, dc);
		329	LE_CENTRIC_MUL(dst + 2, src + 2, scale, dc);
		330	LE_CENTRIC_MUL(dst + 4, src + 4, scale, dc);
		331	LE_CENTRIC_MUL(dst + 6, src + 6, scale, dc);
		332	if (scale)
		333	src += stride;
		334	dst += stride;
		335	}
		336	break;
		337	default:
		338	av_assert0(0);
		339	}
		340	}
		341
		342	static int decode_p_block(FourXContext f, uint16_t dst, const uint16_t *src,
		343	int log2w, int log2h, int stride)
		344	{
		345	int index, h, code, ret, scale = 1;
		346	uint16_t start, end;
		347	unsigned dc = 0;
		348
		349	av_assert0(log2w >= 0 && log2h >= 0);
		350
		351	index = size2index[log2h][log2w];
		352	av_assert0(index >= 0);
		353
		354	h = 1 << log2h;
		355	code = get_vlc2(&f->gb, block_type_vlc[1 - (f->version > 1)][index].table,
		356	BLOCK_TYPE_VLC_BITS, 1);
		357	av_assert0(code >= 0 && code <= 6);
		358
		359	start = f->last_frame_buffer;
		360	end = start + stride * (f->avctx->height - h + 1) - (1 << log2w);
		361
		362	if (code == 1) {
		363	log2h--;
		364	if ((ret = decode_p_block(f, dst, src, log2w, log2h, stride)) < 0)
		365	return ret;
		366	return decode_p_block(f, dst + (stride << log2h),
		367	src + (stride << log2h),
		368	log2w, log2h, stride);
		369	} else if (code == 2) {
		370	log2w--;
		371	if ((ret = decode_p_block(f, dst , src, log2w, log2h, stride)) < 0)
		372	return ret;
		373	return decode_p_block(f, dst + (1 << log2w),
		374	src + (1 << log2w),
		375	log2w, log2h, stride);
		376	} else if (code == 6) {
		377	if (bytestream2_get_bytes_left(&f->g2) < 4) {
		378	av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
		379	return AVERROR_INVALIDDATA;
		380	}
		381	if (log2w) {
		382	dst[0] = bytestream2_get_le16u(&f->g2);
		383	dst[1] = bytestream2_get_le16u(&f->g2);
		384	} else {
		385	dst[0] = bytestream2_get_le16u(&f->g2);
		386	dst[stride] = bytestream2_get_le16u(&f->g2);
		387	}
		388	return 0;
		389	}
		390
		391	if ((code&3)==0 && bytestream2_get_bytes_left(&f->g) < 1) {
		392	av_log(f->avctx, AV_LOG_ERROR, "bytestream overread\n");
		393	return AVERROR_INVALIDDATA;
		394	}
		395
		396	if (code == 0) {
		397	src += f->mv[bytestream2_get_byte(&f->g)];
		398	} else if (code == 3 && f->version >= 2) {
		399	return 0;
		400	} else if (code == 4) {
		401	src += f->mv[bytestream2_get_byte(&f->g)];
		402	if (bytestream2_get_bytes_left(&f->g2) < 2){
		403	av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
		404	return AVERROR_INVALIDDATA;
		405	}
		406	dc = bytestream2_get_le16(&f->g2);
		407	} else if (code == 5) {
		408	if (bytestream2_get_bytes_left(&f->g2) < 2){
		409	av_log(f->avctx, AV_LOG_ERROR, "wordstream overread\n");
		410	return AVERROR_INVALIDDATA;
		411	}
		412	av_assert0(start <= src && src <= end);
		413	scale = 0;
		414	dc = bytestream2_get_le16(&f->g2);
		415	}
		416
		417	if (start > src \|\| src > end) {
		418	av_log(f->avctx, AV_LOG_ERROR, "mv out of pic\n");
		419	return AVERROR_INVALIDDATA;
		420	}
		421
		422	mcdc(dst, src, log2w, h, stride, scale, dc);
		423
		424	return 0;
		425	}
		426
		427	static int decode_p_frame(FourXContext f, const uint8_t buf, int length)
		428	{
		429	int x, y;
		430	const int width = f->avctx->width;
		431	const int height = f->avctx->height;
		432	uint16_t *dst = f->frame_buffer;
		433	uint16_t *src;
		434	unsigned int bitstream_size, bytestream_size, wordstream_size, extra,
		435	bytestream_offset, wordstream_offset;
		436	int ret;
		437
		438	src = f->last_frame_buffer;
		439
		440	if (f->version > 1) {
		441	extra = 20;
		442	if (length < extra)
		443	return AVERROR_INVALIDDATA;
		444	bitstream_size = AV_RL32(buf + 8);
		445	wordstream_size = AV_RL32(buf + 12);
		446	bytestream_size = AV_RL32(buf + 16);
		447	} else {
		448	extra = 0;
		449	bitstream_size = AV_RL16(buf - 4);
		450	wordstream_size = AV_RL16(buf - 2);
		451	bytestream_size = FFMAX(length - bitstream_size - wordstream_size, 0);
		452	}
		453
		454	if (bitstream_size > length \|\| bitstream_size >= INT_MAX/8 \|\|
		455	bytestream_size > length - bitstream_size \|\|
		456	wordstream_size > length - bytestream_size - bitstream_size \|\|
		457	extra > length - bytestream_size - bitstream_size - wordstream_size) {
		458	av_log(f->avctx, AV_LOG_ERROR, "lengths %d %d %d %d\n", bitstream_size, bytestream_size, wordstream_size,
		459	bitstream_size+ bytestream_size+ wordstream_size - length);
		460	return AVERROR_INVALIDDATA;
		461	}
		462
		463	av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
		464	bitstream_size);
		465	if (!f->bitstream_buffer)
		466	return AVERROR(ENOMEM);
		467	f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) (buf + extra),
		468	bitstream_size / 4);
		469	init_get_bits(&f->gb, f->bitstream_buffer, 8 * bitstream_size);
		470
		471	wordstream_offset = extra + bitstream_size;
		472	bytestream_offset = extra + bitstream_size + wordstream_size;
		473	bytestream2_init(&f->g2, buf + wordstream_offset,
		474	length - wordstream_offset);
		475	bytestream2_init(&f->g, buf + bytestream_offset,
		476	length - bytestream_offset);
		477
		478	init_mv(f, width * 2);
		479
		480	for (y = 0; y < height; y += 8) {
		481	for (x = 0; x < width; x += 8)
		482	if ((ret = decode_p_block(f, dst + x, src + x, 3, 3, width)) < 0)
		483	return ret;
		484	src += 8 * width;
		485	dst += 8 * width;
		486	}
		487
		488	return 0;
		489	}
		490
		491	/**
		492	* decode block and dequantize.
		493	* Note this is almost identical to MJPEG.
		494	*/
		495	static int decode_i_block(FourXContext f, int16_t block)
		496	{
		497	int code, i, j, level, val;
		498
		499	if (get_bits_left(&f->gb) < 2){
		500	av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->gb));
		501	return -1;
		502	}
		503
		504	/* DC coef */
		505	val = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
		506	if (val >> 4) {
		507	av_log(f->avctx, AV_LOG_ERROR, "error dc run != 0\n");
		508	return AVERROR_INVALIDDATA;
		509	}
		510
		511	if (val)
		512	val = get_xbits(&f->gb, val);
		513
		514	val = val * dequant_table[0] + f->last_dc;
		515	f->last_dc = block[0] = val;
		516	/* AC coefs */
		517	i = 1;
		518	for (;;) {
		519	code = get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3);
		520
		521	/* EOB */
		522	if (code == 0)
		523	break;
		524	if (code == 0xf0) {
		525	i += 16;
		526	} else {
		527	if (code & 0xf) {
		528	level = get_xbits(&f->gb, code & 0xf);
		529	} else {
		530	av_log(f->avctx, AV_LOG_ERROR, "0 coeff\n");
		531	return AVERROR_INVALIDDATA;
		532	}
		533	i += code >> 4;
		534	if (i >= 64) {
		535	av_log(f->avctx, AV_LOG_ERROR, "run %d oveflow\n", i);
		536	return 0;
		537	}
		538
		539	j = ff_zigzag_direct[i];
		540	block[j] = level * dequant_table[j];
		541	i++;
		542	if (i >= 64)
		543	break;
		544	}
		545	}
		546
		547	return 0;
		548	}
		549
		550	static inline void idct_put(FourXContext *f, int x, int y)
		551	{
		552	int16_t (*block)[64] = f->block;
		553	int stride = f->avctx->width;
		554	int i;
		555	uint16_t dst = f->frame_buffer + y stride + x;
		556
		557	for (i = 0; i < 4; i++) {
		558	block[i][0] += 0x80 * 8 * 8;
		559	idct(block[i]);
		560	}
		561
		562	if (!(f->avctx->flags & AV_CODEC_FLAG_GRAY)) {
		563	for (i = 4; i < 6; i++)
		564	idct(block[i]);
		565	}
		566
		567	/* Note transform is:
		568	* y = ( 1b + 4g + 2r) / 14
		569	* cb = ( 3b - 2g - 1r) / 14
		570	* cr = (-1b - 4g + 5r) / 14 */
		571	for (y = 0; y < 8; y++) {
		572	for (x = 0; x < 8; x++) {
		573	int16_t temp = block[(x >> 2) + 2 (y >> 2)] +
		574	2 * (x & 3) + 2 * 8 * (y & 3); // FIXME optimize
		575	int cb = block[4][x + 8 * y];
		576	int cr = block[5][x + 8 * y];
		577	int cg = (cb + cr) >> 1;
		578	int y;
		579
		580	cb += cb;
		581
		582	y = temp[0];
		583	dst[0] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
		584	y = temp[1];
		585	dst[1] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
		586	y = temp[8];
		587	dst[stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
		588	y = temp[9];
		589	dst[1 + stride] = ((y + cb) >> 3) + (((y - cg) & 0xFC) << 3) + (((y + cr) & 0xF8) << 8);
		590	dst += 2;
		591	}
		592	dst += 2 * stride - 2 * 8;
		593	}
		594	}
		595
		596	static int decode_i_mb(FourXContext *f)
		597	{
		598	int ret;
		599	int i;
		600
		601	f->bdsp.clear_blocks(f->block[0]);
		602
		603	for (i = 0; i < 6; i++)
		604	if ((ret = decode_i_block(f, f->block[i])) < 0)
		605	return ret;
		606
		607	return 0;
		608	}
		609
		610	static const uint8_t read_huffman_tables(FourXContext f,
		611	const uint8_t * const buf,
		612	int buf_size)
		613	{
		614	int frequency[512] = { 0 };
		615	uint8_t flag[512];
		616	int up[512];
		617	uint8_t len_tab[257];
		618	int bits_tab[257];
		619	int start, end;
		620	const uint8_t *ptr = buf;
		621	const uint8_t *ptr_end = buf + buf_size;
		622	int j;
		623
		624	memset(up, -1, sizeof(up));
		625
		626	start = *ptr++;
		627	end = *ptr++;
		628	for (;;) {
		629	int i;
		630
		631	if (ptr_end - ptr < FFMAX(end - start + 1, 0) + 1) {
		632	av_log(f->avctx, AV_LOG_ERROR, "invalid data in read_huffman_tables\n");
		633	return NULL;
		634	}
		635
		636	for (i = start; i <= end; i++)
		637	frequency[i] = *ptr++;
		638	start = *ptr++;
		639	if (start == 0)
		640	break;
		641
		642	end = *ptr++;
		643	}
		644	frequency[256] = 1;
		645
		646	while ((ptr - buf) & 3)
		647	ptr++; // 4byte align
		648
		649	if (ptr > ptr_end) {
		650	av_log(f->avctx, AV_LOG_ERROR, "ptr overflow in read_huffman_tables\n");
		651	return NULL;
		652	}
		653
		654	for (j = 257; j < 512; j++) {
		655	int min_freq[2] = { 256 * 256, 256 * 256 };
		656	int smallest[2] = { 0, 0 };
		657	int i;
		658	for (i = 0; i < j; i++) {
		659	if (frequency[i] == 0)
		660	continue;
		661	if (frequency[i] < min_freq[1]) {
		662	if (frequency[i] < min_freq[0]) {
		663	min_freq[1] = min_freq[0];
		664	smallest[1] = smallest[0];
		665	min_freq[0] = frequency[i];
		666	smallest[0] = i;
		667	} else {
		668	min_freq[1] = frequency[i];
		669	smallest[1] = i;
		670	}
		671	}
		672	}
		673	if (min_freq[1] == 256 * 256)
		674	break;
		675
		676	frequency[j] = min_freq[0] + min_freq[1];
		677	flag[smallest[0]] = 0;
		678	flag[smallest[1]] = 1;
		679	up[smallest[0]] =
		680	up[smallest[1]] = j;
		681	frequency[smallest[0]] = frequency[smallest[1]] = 0;
		682	}
		683
		684	for (j = 0; j < 257; j++) {
		685	int node, len = 0, bits = 0;
		686
		687	for (node = j; up[node] != -1; node = up[node]) {
		688	bits += flag[node] << len;
		689	len++;
		690	if (len > 31)
		691	// can this happen at all ?
		692	av_log(f->avctx, AV_LOG_ERROR,
		693	"vlc length overflow\n");
		694	}
		695
		696	bits_tab[j] = bits;
		697	len_tab[j] = len;
		698	}
		699
		700	if (init_vlc(&f->pre_vlc, ACDC_VLC_BITS, 257, len_tab, 1, 1,
		701	bits_tab, 4, 4, 0))
		702	return NULL;
		703
		704	return ptr;
		705	}
		706
		707	static int mix(int c0, int c1)
		708	{
		709	int blue = 2 * (c0 & 0x001F) + (c1 & 0x001F);
		710	int green = (2 * (c0 & 0x03E0) + (c1 & 0x03E0)) >> 5;
		711	int red = 2 * (c0 >> 10) + (c1 >> 10);
		712	return red / 3 * 1024 + green / 3 * 32 + blue / 3;
		713	}
		714
		715	static int decode_i2_frame(FourXContext f, const uint8_t buf, int length)
		716	{
		717	int x, y, x2, y2;
		718	const int width = f->avctx->width;
		719	const int height = f->avctx->height;
		720	const int mbs = (FFALIGN(width, 16) >> 4) * (FFALIGN(height, 16) >> 4);
		721	uint16_t *dst = f->frame_buffer;
		722	const uint8_t *buf_end = buf + length;
		723	GetByteContext g3;
		724
		725	if (length < mbs * 8) {
		726	av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
		727	return AVERROR_INVALIDDATA;
		728	}
		729	bytestream2_init(&g3, buf, length);
		730
		731	for (y = 0; y < height; y += 16) {
		732	for (x = 0; x < width; x += 16) {
		733	unsigned int color[4] = { 0 }, bits;
		734	if (buf_end - buf < 8)
		735	return -1;
		736	// warning following is purely guessed ...
		737	color[0] = bytestream2_get_le16u(&g3);
		738	color[1] = bytestream2_get_le16u(&g3);
		739
		740	if (color[0] & 0x8000)
		741	av_log(f->avctx, AV_LOG_ERROR, "unk bit 1\n");
		742	if (color[1] & 0x8000)
		743	av_log(f->avctx, AV_LOG_ERROR, "unk bit 2\n");
		744
		745	color[2] = mix(color[0], color[1]);
		746	color[3] = mix(color[1], color[0]);
		747
		748	bits = bytestream2_get_le32u(&g3);
		749	for (y2 = 0; y2 < 16; y2++) {
		750	for (x2 = 0; x2 < 16; x2++) {
		751	int index = 2 * (x2 >> 2) + 8 * (y2 >> 2);
		752	dst[y2 * width + x2] = color[(bits >> index) & 3];
		753	}
		754	}
		755	dst += 16;
		756	}
		757	dst += 16 * width - x;
		758	}
		759
		760	return 0;
		761	}
		762
		763	static int decode_i_frame(FourXContext f, const uint8_t buf, int length)
		764	{
		765	int x, y, ret;
		766	const int width = f->avctx->width;
		767	const int height = f->avctx->height;
		768	const unsigned int bitstream_size = AV_RL32(buf);
		769	unsigned int prestream_size;
		770	const uint8_t *prestream;
		771
		772	if (bitstream_size > (1 << 26))
		773	return AVERROR_INVALIDDATA;
		774
		775	if (length < bitstream_size + 12) {
		776	av_log(f->avctx, AV_LOG_ERROR, "packet size too small\n");
		777	return AVERROR_INVALIDDATA;
		778	}
		779
		780	prestream_size = 4 * AV_RL32(buf + bitstream_size + 4);
		781	prestream = buf + bitstream_size + 12;
		782
		783	if (prestream_size + bitstream_size + 12 != length
		784	\|\| prestream_size > (1 << 26)) {
		785	av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %d %d\n",
		786	prestream_size, bitstream_size, length);
		787	return AVERROR_INVALIDDATA;
		788	}
		789
		790	prestream = read_huffman_tables(f, prestream, prestream_size);
		791	if (!prestream) {
		792	av_log(f->avctx, AV_LOG_ERROR, "Error reading Huffman tables.\n");
		793	return AVERROR_INVALIDDATA;
		794	}
		795
		796	av_assert0(prestream <= buf + length);
		797
		798	init_get_bits(&f->gb, buf + 4, 8 * bitstream_size);
		799
		800	prestream_size = length + buf - prestream;
		801
		802	av_fast_padded_malloc(&f->bitstream_buffer, &f->bitstream_buffer_size,
		803	prestream_size);
		804	if (!f->bitstream_buffer)
		805	return AVERROR(ENOMEM);
		806	f->bbdsp.bswap_buf(f->bitstream_buffer, (const uint32_t *) prestream,
		807	prestream_size / 4);
		808	init_get_bits(&f->pre_gb, f->bitstream_buffer, 8 * prestream_size);
		809
		810	f->last_dc = 0 * 128 * 8 * 8;
		811
		812	for (y = 0; y < height; y += 16) {
		813	for (x = 0; x < width; x += 16) {
		814	if ((ret = decode_i_mb(f)) < 0)
		815	return ret;
		816
		817	idct_put(f, x, y);
		818	}
		819	}
		820
		821	if (get_vlc2(&f->pre_gb, f->pre_vlc.table, ACDC_VLC_BITS, 3) != 256)
		822	av_log(f->avctx, AV_LOG_ERROR, "end mismatch\n");
		823
		824	return 0;
		825	}
		826
		827	static int decode_frame(AVCodecContext avctx, void data,
		828	int got_frame, AVPacket avpkt)
		829	{
		830	const uint8_t *buf = avpkt->data;
		831	int buf_size = avpkt->size;
		832	FourXContext *const f = avctx->priv_data;
		833	AVFrame *picture = data;
		834	int i, frame_4cc, frame_size, ret;
		835
		836	if (buf_size < 20)
		837	return AVERROR_INVALIDDATA;
		838
		839	av_assert0(avctx->width % 16 == 0 && avctx->height % 16 == 0);
		840
		841	if (buf_size < AV_RL32(buf + 4) + 8) {
		842	av_log(f->avctx, AV_LOG_ERROR, "size mismatch %d %"PRIu32"\n",
		843	buf_size, AV_RL32(buf + 4));
		844	return AVERROR_INVALIDDATA;
		845	}
		846
		847	frame_4cc = AV_RL32(buf);
		848
		849	if (frame_4cc == AV_RL32("cfrm")) {
		850	int free_index = -1;
		851	int id, whole_size;
		852	const int data_size = buf_size - 20;
		853	CFrameBuffer *cfrm;
		854
		855	if (f->version <= 1) {
		856	av_log(f->avctx, AV_LOG_ERROR, "cfrm in version %d\n", f->version);
		857	return AVERROR_INVALIDDATA;
		858	}
		859
		860	id = AV_RL32(buf + 12);
		861	whole_size = AV_RL32(buf + 16);
		862
		863	if (data_size < 0 \|\| whole_size < 0) {
		864	av_log(f->avctx, AV_LOG_ERROR, "sizes invalid\n");
		865	return AVERROR_INVALIDDATA;
		866	}
		867
		868	for (i = 0; i < CFRAME_BUFFER_COUNT; i++)
		869	if (f->cfrm[i].id && f->cfrm[i].id < avctx->frame_number)
		870	av_log(f->avctx, AV_LOG_ERROR, "lost c frame %d\n",
		871	f->cfrm[i].id);
		872
		873	for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
		874	if (f->cfrm[i].id == id)
		875	break;
		876	if (f->cfrm[i].size == 0)
		877	free_index = i;
		878	}
		879
		880	if (i >= CFRAME_BUFFER_COUNT) {
		881	i = free_index;
		882	f->cfrm[i].id = id;
		883	}
		884	cfrm = &f->cfrm[i];
		885
		886	if (data_size > UINT_MAX - cfrm->size - AV_INPUT_BUFFER_PADDING_SIZE)
		887	return AVERROR_INVALIDDATA;
		888
		889	cfrm->data = av_fast_realloc(cfrm->data, &cfrm->allocated_size,
		890	cfrm->size + data_size + AV_INPUT_BUFFER_PADDING_SIZE);
		891	// explicit check needed as memcpy below might not catch a NULL
		892	if (!cfrm->data) {
		893	av_log(f->avctx, AV_LOG_ERROR, "realloc failure\n");
		894	return AVERROR(ENOMEM);
		895	}
		896
		897	memcpy(cfrm->data + cfrm->size, buf + 20, data_size);
		898	cfrm->size += data_size;
		899
		900	if (cfrm->size >= whole_size) {
		901	buf = cfrm->data;
		902	frame_size = cfrm->size;
		903
		904	if (id != avctx->frame_number)
		905	av_log(f->avctx, AV_LOG_ERROR, "cframe id mismatch %d %d\n",
		906	id, avctx->frame_number);
		907
		908	if (f->version <= 1)
		909	return AVERROR_INVALIDDATA;
		910
		911	cfrm->size = cfrm->id = 0;
		912	frame_4cc = AV_RL32("pfrm");
		913	} else
		914	return buf_size;
		915	} else {
		916	buf = buf + 12;
		917	frame_size = buf_size - 12;
		918	}
		919
		920	if ((ret = ff_get_buffer(avctx, picture, 0)) < 0)
		921	return ret;
		922
		923	if (frame_4cc == AV_RL32("ifr2")) {
		924	picture->pict_type = AV_PICTURE_TYPE_I;
		925	if ((ret = decode_i2_frame(f, buf - 4, frame_size + 4)) < 0) {
		926	av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
		927	return ret;
		928	}
		929	} else if (frame_4cc == AV_RL32("ifrm")) {
		930	picture->pict_type = AV_PICTURE_TYPE_I;
		931	if ((ret = decode_i_frame(f, buf, frame_size)) < 0) {
		932	av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
		933	return ret;
		934	}
		935	} else if (frame_4cc == AV_RL32("pfrm") \|\| frame_4cc == AV_RL32("pfr2")) {
		936	picture->pict_type = AV_PICTURE_TYPE_P;
		937	if ((ret = decode_p_frame(f, buf, frame_size)) < 0) {
		938	av_log(f->avctx, AV_LOG_ERROR, "decode p frame failed\n");
		939	return ret;
		940	}
		941	} else if (frame_4cc == AV_RL32("snd_")) {
		942	av_log(avctx, AV_LOG_ERROR, "ignoring snd_ chunk length:%d\n",
		943	buf_size);
		944	} else {
		945	av_log(avctx, AV_LOG_ERROR, "ignoring unknown chunk length:%d\n",
		946	buf_size);
		947	}
		948
		949	picture->key_frame = picture->pict_type == AV_PICTURE_TYPE_I;
		950
		951	av_image_copy_plane(picture->data[0], picture->linesize[0],
		952	(const uint8_t)f->frame_buffer, avctx->width 2,
		953	avctx->width * 2, avctx->height);
		954	FFSWAP(uint16_t *, f->frame_buffer, f->last_frame_buffer);
		955
		956	*got_frame = 1;
		957
		958	emms_c();
		959
		960	return buf_size;
		961	}
		962
		963	static av_cold int decode_end(AVCodecContext *avctx)
		964	{
		965	FourXContext * const f = avctx->priv_data;
		966	int i;
		967
		968	av_freep(&f->frame_buffer);
		969	av_freep(&f->last_frame_buffer);
		970	av_freep(&f->bitstream_buffer);
		971	f->bitstream_buffer_size = 0;
		972	for (i = 0; i < CFRAME_BUFFER_COUNT; i++) {
		973	av_freep(&f->cfrm[i].data);
		974	f->cfrm[i].allocated_size = 0;
		975	}
		976	ff_free_vlc(&f->pre_vlc);
		977
		978	return 0;
		979	}
		980
		981	static av_cold int decode_init(AVCodecContext *avctx)
		982	{
		983	FourXContext * const f = avctx->priv_data;
		984	int ret;
		985
		986	if (avctx->extradata_size != 4 \|\| !avctx->extradata) {
		987	av_log(avctx, AV_LOG_ERROR, "extradata wrong or missing\n");
		988	return AVERROR_INVALIDDATA;
		989	}
		990	if((avctx->width % 16) \|\| (avctx->height % 16)) {
		991	av_log(avctx, AV_LOG_ERROR, "unsupported width/height\n");
		992	return AVERROR_INVALIDDATA;
		993	}
		994
		995	ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
		996	if (ret < 0)
		997	return ret;
		998
		999	f->frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
		1000	f->last_frame_buffer = av_mallocz(avctx->width * avctx->height * 2);
		1001	if (!f->frame_buffer \|\| !f->last_frame_buffer) {
		1002	decode_end(avctx);
		1003	return AVERROR(ENOMEM);
		1004	}
		1005
		1006	f->version = AV_RL32(avctx->extradata) >> 16;
		1007	ff_blockdsp_init(&f->bdsp, avctx);
		1008	ff_bswapdsp_init(&f->bbdsp);
		1009	f->avctx = avctx;
		1010	init_vlcs(f);
		1011
		1012	if (f->version > 2)
		1013	avctx->pix_fmt = AV_PIX_FMT_RGB565;
		1014	else
		1015	avctx->pix_fmt = AV_PIX_FMT_BGR555;
		1016
		1017	return 0;
		1018	}
		1019
		1020	AVCodec ff_fourxm_decoder = {
		1021	.name = "4xm",
		1022	.long_name = NULL_IF_CONFIG_SMALL("4X Movie"),
		1023	.type = AVMEDIA_TYPE_VIDEO,
		1024	.id = AV_CODEC_ID_4XM,
		1025	.priv_data_size = sizeof(FourXContext),
		1026	.init = decode_init,
		1027	.close = decode_end,
		1028	.decode = decode_frame,
		1029	.capabilities = AV_CODEC_CAP_DR1,
		1030	};

Subversion Repositories Kolibri OS

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