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

Rev	Author	Line No.	Line
6147	serge	1	/*
		2	* Duck TrueMotion 1.0 Decoder
		3	* Copyright (C) 2003 Alex Beregszaszi & Mike Melanson
		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	* Duck TrueMotion v1 Video Decoder by
		25	* Alex Beregszaszi and
		26	* Mike Melanson (melanson@pcisys.net)
		27	*
		28	* The TrueMotion v1 decoder presently only decodes 16-bit TM1 data and
		29	* outputs RGB555 (or RGB565) data. 24-bit TM1 data is not supported yet.
		30	*/
		31
		32	#include
		33	#include
		34	#include
		35
		36	#include "avcodec.h"
		37	#include "internal.h"
		38	#include "libavutil/imgutils.h"
		39	#include "libavutil/internal.h"
		40	#include "libavutil/intreadwrite.h"
		41	#include "libavutil/mem.h"
		42
		43	#include "truemotion1data.h"
		44
		45	typedef struct TrueMotion1Context {
		46	AVCodecContext *avctx;
		47	AVFrame *frame;
		48
		49	const uint8_t *buf;
		50	int size;
		51
		52	const uint8_t *mb_change_bits;
		53	int mb_change_bits_row_size;
		54	const uint8_t *index_stream;
		55	int index_stream_size;
		56
		57	int flags;
		58	int x, y, w, h;
		59
		60	uint32_t y_predictor_table[1024];
		61	uint32_t c_predictor_table[1024];
		62	uint32_t fat_y_predictor_table[1024];
		63	uint32_t fat_c_predictor_table[1024];
		64
		65	int compression;
		66	int block_type;
		67	int block_width;
		68	int block_height;
		69
		70	int16_t ydt[8];
		71	int16_t cdt[8];
		72	int16_t fat_ydt[8];
		73	int16_t fat_cdt[8];
		74
		75	int last_deltaset, last_vectable;
		76
		77	unsigned int *vert_pred;
		78	int vert_pred_size;
		79
		80	} TrueMotion1Context;
		81
		82	#define FLAG_SPRITE 32
		83	#define FLAG_KEYFRAME 16
		84	#define FLAG_INTERFRAME 8
		85	#define FLAG_INTERPOLATED 4
		86
		87	struct frame_header {
		88	uint8_t header_size;
		89	uint8_t compression;
		90	uint8_t deltaset;
		91	uint8_t vectable;
		92	uint16_t ysize;
		93	uint16_t xsize;
		94	uint16_t checksum;
		95	uint8_t version;
		96	uint8_t header_type;
		97	uint8_t flags;
		98	uint8_t control;
		99	uint16_t xoffset;
		100	uint16_t yoffset;
		101	uint16_t width;
		102	uint16_t height;
		103	};
		104
		105	#define ALGO_NOP 0
		106	#define ALGO_RGB16V 1
		107	#define ALGO_RGB16H 2
		108	#define ALGO_RGB24H 3
		109
		110	/* these are the various block sizes that can occupy a 4x4 block */
		111	#define BLOCK_2x2 0
		112	#define BLOCK_2x4 1
		113	#define BLOCK_4x2 2
		114	#define BLOCK_4x4 3
		115
		116	typedef struct comp_types {
		117	int algorithm;
		118	int block_width; // vres
		119	int block_height; // hres
		120	int block_type;
		121	} comp_types;
		122
		123	/* { valid for metatype }, algorithm, num of deltas, vert res, horiz res */
		124	static const comp_types compression_types[17] = {
		125	{ ALGO_NOP, 0, 0, 0 },
		126
		127	{ ALGO_RGB16V, 4, 4, BLOCK_4x4 },
		128	{ ALGO_RGB16H, 4, 4, BLOCK_4x4 },
		129	{ ALGO_RGB16V, 4, 2, BLOCK_4x2 },
		130	{ ALGO_RGB16H, 4, 2, BLOCK_4x2 },
		131
		132	{ ALGO_RGB16V, 2, 4, BLOCK_2x4 },
		133	{ ALGO_RGB16H, 2, 4, BLOCK_2x4 },
		134	{ ALGO_RGB16V, 2, 2, BLOCK_2x2 },
		135	{ ALGO_RGB16H, 2, 2, BLOCK_2x2 },
		136
		137	{ ALGO_NOP, 4, 4, BLOCK_4x4 },
		138	{ ALGO_RGB24H, 4, 4, BLOCK_4x4 },
		139	{ ALGO_NOP, 4, 2, BLOCK_4x2 },
		140	{ ALGO_RGB24H, 4, 2, BLOCK_4x2 },
		141
		142	{ ALGO_NOP, 2, 4, BLOCK_2x4 },
		143	{ ALGO_RGB24H, 2, 4, BLOCK_2x4 },
		144	{ ALGO_NOP, 2, 2, BLOCK_2x2 },
		145	{ ALGO_RGB24H, 2, 2, BLOCK_2x2 }
		146	};
		147
		148	static void select_delta_tables(TrueMotion1Context *s, int delta_table_index)
		149	{
		150	int i;
		151
		152	if (delta_table_index > 3)
		153	return;
		154
		155	memcpy(s->ydt, ydts[delta_table_index], 8 * sizeof(int16_t));
		156	memcpy(s->cdt, cdts[delta_table_index], 8 * sizeof(int16_t));
		157	memcpy(s->fat_ydt, fat_ydts[delta_table_index], 8 * sizeof(int16_t));
		158	memcpy(s->fat_cdt, fat_cdts[delta_table_index], 8 * sizeof(int16_t));
		159
		160	/* Y skinny deltas need to be halved for some reason; maybe the
		161	* skinny Y deltas should be modified */
		162	for (i = 0; i < 8; i++)
		163	{
		164	/* drop the lsb before dividing by 2-- net effect: round down
		165	* when dividing a negative number (e.g., -3/2 = -2, not -1) */
		166	s->ydt[i] &= 0xFFFE;
		167	s->ydt[i] /= 2;
		168	}
		169	}
		170
		171	#if HAVE_BIGENDIAN
		172	static int make_ydt15_entry(int p2, int p1, int16_t *ydt)
		173	#else
		174	static int make_ydt15_entry(int p1, int p2, int16_t *ydt)
		175	#endif
		176	{
		177	int lo, hi;
		178
		179	lo = ydt[p1];
		180	lo += (lo << 5) + (lo << 10);
		181	hi = ydt[p2];
		182	hi += (hi << 5) + (hi << 10);
		183	return (lo + (hi << 16)) << 1;
		184	}
		185
		186	static int make_cdt15_entry(int p1, int p2, int16_t *cdt)
		187	{
		188	int r, b, lo;
		189
		190	b = cdt[p2];
		191	r = cdt[p1] << 10;
		192	lo = b + r;
		193	return (lo + (lo << 16)) << 1;
		194	}
		195
		196	#if HAVE_BIGENDIAN
		197	static int make_ydt16_entry(int p2, int p1, int16_t *ydt)
		198	#else
		199	static int make_ydt16_entry(int p1, int p2, int16_t *ydt)
		200	#endif
		201	{
		202	int lo, hi;
		203
		204	lo = ydt[p1];
		205	lo += (lo << 6) + (lo << 11);
		206	hi = ydt[p2];
		207	hi += (hi << 6) + (hi << 11);
		208	return (lo + (hi << 16)) << 1;
		209	}
		210
		211	static int make_cdt16_entry(int p1, int p2, int16_t *cdt)
		212	{
		213	int r, b, lo;
		214
		215	b = cdt[p2];
		216	r = cdt[p1] << 11;
		217	lo = b + r;
		218	return (lo + (lo * (1 << 16))) * 2;
		219	}
		220
		221	static int make_ydt24_entry(int p1, int p2, int16_t *ydt)
		222	{
		223	int lo, hi;
		224
		225	lo = ydt[p1];
		226	hi = ydt[p2];
		227	return (lo + (hi * (1 << 8)) + (hi * (1 << 16))) * 2;
		228	}
		229
		230	static int make_cdt24_entry(int p1, int p2, int16_t *cdt)
		231	{
		232	int r, b;
		233
		234	b = cdt[p2];
		235	r = cdt[p1] * (1 << 16);
		236	return (b+r) * 2;
		237	}
		238
		239	static void gen_vector_table15(TrueMotion1Context s, const uint8_t sel_vector_table)
		240	{
		241	int len, i, j;
		242	unsigned char delta_pair;
		243
		244	for (i = 0; i < 1024; i += 4)
		245	{
		246	len = *sel_vector_table++ / 2;
		247	for (j = 0; j < len; j++)
		248	{
		249	delta_pair = *sel_vector_table++;
		250	s->y_predictor_table[i+j] = 0xfffffffe &
		251	make_ydt15_entry(delta_pair >> 4, delta_pair & 0xf, s->ydt);
		252	s->c_predictor_table[i+j] = 0xfffffffe &
		253	make_cdt15_entry(delta_pair >> 4, delta_pair & 0xf, s->cdt);
		254	}
		255	s->y_predictor_table[i+(j-1)] \|= 1;
		256	s->c_predictor_table[i+(j-1)] \|= 1;
		257	}
		258	}
		259
		260	static void gen_vector_table16(TrueMotion1Context s, const uint8_t sel_vector_table)
		261	{
		262	int len, i, j;
		263	unsigned char delta_pair;
		264
		265	for (i = 0; i < 1024; i += 4)
		266	{
		267	len = *sel_vector_table++ / 2;
		268	for (j = 0; j < len; j++)
		269	{
		270	delta_pair = *sel_vector_table++;
		271	s->y_predictor_table[i+j] = 0xfffffffe &
		272	make_ydt16_entry(delta_pair >> 4, delta_pair & 0xf, s->ydt);
		273	s->c_predictor_table[i+j] = 0xfffffffe &
		274	make_cdt16_entry(delta_pair >> 4, delta_pair & 0xf, s->cdt);
		275	}
		276	s->y_predictor_table[i+(j-1)] \|= 1;
		277	s->c_predictor_table[i+(j-1)] \|= 1;
		278	}
		279	}
		280
		281	static void gen_vector_table24(TrueMotion1Context s, const uint8_t sel_vector_table)
		282	{
		283	int len, i, j;
		284	unsigned char delta_pair;
		285
		286	for (i = 0; i < 1024; i += 4)
		287	{
		288	len = *sel_vector_table++ / 2;
		289	for (j = 0; j < len; j++)
		290	{
		291	delta_pair = *sel_vector_table++;
		292	s->y_predictor_table[i+j] = 0xfffffffe &
		293	make_ydt24_entry(delta_pair >> 4, delta_pair & 0xf, s->ydt);
		294	s->c_predictor_table[i+j] = 0xfffffffe &
		295	make_cdt24_entry(delta_pair >> 4, delta_pair & 0xf, s->cdt);
		296	s->fat_y_predictor_table[i+j] = 0xfffffffe &
		297	make_ydt24_entry(delta_pair >> 4, delta_pair & 0xf, s->fat_ydt);
		298	s->fat_c_predictor_table[i+j] = 0xfffffffe &
		299	make_cdt24_entry(delta_pair >> 4, delta_pair & 0xf, s->fat_cdt);
		300	}
		301	s->y_predictor_table[i+(j-1)] \|= 1;
		302	s->c_predictor_table[i+(j-1)] \|= 1;
		303	s->fat_y_predictor_table[i+(j-1)] \|= 1;
		304	s->fat_c_predictor_table[i+(j-1)] \|= 1;
		305	}
		306	}
		307
		308	/* Returns the number of bytes consumed from the bytestream. Returns -1 if
		309	* there was an error while decoding the header */
		310	static int truemotion1_decode_header(TrueMotion1Context *s)
		311	{
		312	int i, ret;
		313	int width_shift = 0;
		314	int new_pix_fmt;
		315	struct frame_header header;
		316	uint8_t header_buffer[128] = { 0 }; /* logical maximum size of the header */
		317	const uint8_t *sel_vector_table;
		318
		319	header.header_size = ((s->buf[0] >> 5) \| (s->buf[0] << 3)) & 0x7f;
		320	if (s->buf[0] < 0x10)
		321	{
		322	av_log(s->avctx, AV_LOG_ERROR, "invalid header size (%d)\n", s->buf[0]);
		323	return AVERROR_INVALIDDATA;
		324	}
		325
		326	if (header.header_size + 1 > s->size) {
		327	av_log(s->avctx, AV_LOG_ERROR, "Input packet too small.\n");
		328	return AVERROR_INVALIDDATA;
		329	}
		330
		331	/* unscramble the header bytes with a XOR operation */
		332	for (i = 1; i < header.header_size; i++)
		333	header_buffer[i - 1] = s->buf[i] ^ s->buf[i + 1];
		334
		335	header.compression = header_buffer[0];
		336	header.deltaset = header_buffer[1];
		337	header.vectable = header_buffer[2];
		338	header.ysize = AV_RL16(&header_buffer[3]);
		339	header.xsize = AV_RL16(&header_buffer[5]);
		340	header.checksum = AV_RL16(&header_buffer[7]);
		341	header.version = header_buffer[9];
		342	header.header_type = header_buffer[10];
		343	header.flags = header_buffer[11];
		344	header.control = header_buffer[12];
		345
		346	/* Version 2 */
		347	if (header.version >= 2)
		348	{
		349	if (header.header_type > 3)
		350	{
		351	av_log(s->avctx, AV_LOG_ERROR, "invalid header type (%d)\n", header.header_type);
		352	return AVERROR_INVALIDDATA;
		353	} else if ((header.header_type == 2) \|\| (header.header_type == 3)) {
		354	s->flags = header.flags;
		355	if (!(s->flags & FLAG_INTERFRAME))
		356	s->flags \|= FLAG_KEYFRAME;
		357	} else
		358	s->flags = FLAG_KEYFRAME;
		359	} else /* Version 1 */
		360	s->flags = FLAG_KEYFRAME;
		361
		362	if (s->flags & FLAG_SPRITE) {
		363	avpriv_request_sample(s->avctx, "Frame with sprite");
		364	/* FIXME header.width, height, xoffset and yoffset aren't initialized */
		365	return AVERROR_PATCHWELCOME;
		366	} else {
		367	s->w = header.xsize;
		368	s->h = header.ysize;
		369	if (header.header_type < 2) {
		370	if ((s->w < 213) && (s->h >= 176))
		371	{
		372	s->flags \|= FLAG_INTERPOLATED;
		373	avpriv_request_sample(s->avctx, "Interpolated frame");
		374	}
		375	}
		376	}
		377
		378	if (header.compression >= 17) {
		379	av_log(s->avctx, AV_LOG_ERROR, "invalid compression type (%d)\n", header.compression);
		380	return AVERROR_INVALIDDATA;
		381	}
		382
		383	if ((header.deltaset != s->last_deltaset) \|\|
		384	(header.vectable != s->last_vectable))
		385	select_delta_tables(s, header.deltaset);
		386
		387	if ((header.compression & 1) && header.header_type)
		388	sel_vector_table = pc_tbl2;
		389	else {
		390	if (header.vectable > 0 && header.vectable < 4)
		391	sel_vector_table = tables[header.vectable - 1];
		392	else {
		393	av_log(s->avctx, AV_LOG_ERROR, "invalid vector table id (%d)\n", header.vectable);
		394	return AVERROR_INVALIDDATA;
		395	}
		396	}
		397
		398	if (compression_types[header.compression].algorithm == ALGO_RGB24H) {
		399	new_pix_fmt = AV_PIX_FMT_RGB32;
		400	width_shift = 1;
		401	} else
		402	new_pix_fmt = AV_PIX_FMT_RGB555; // RGB565 is supported as well
		403
		404	s->w >>= width_shift;
		405	if (s->w & 1) {
		406	avpriv_request_sample(s->avctx, "Frame with odd width");
		407	return AVERROR_PATCHWELCOME;
		408	}
		409
		410	if (s->w != s->avctx->width \|\| s->h != s->avctx->height \|\|
		411	new_pix_fmt != s->avctx->pix_fmt) {
		412	av_frame_unref(s->frame);
		413	s->avctx->sample_aspect_ratio = (AVRational){ 1 << width_shift, 1 };
		414	s->avctx->pix_fmt = new_pix_fmt;
		415
		416	if ((ret = ff_set_dimensions(s->avctx, s->w, s->h)) < 0)
		417	return ret;
		418
		419	ff_set_sar(s->avctx, s->avctx->sample_aspect_ratio);
		420
		421	av_fast_malloc(&s->vert_pred, &s->vert_pred_size, s->avctx->width * sizeof(unsigned int));
		422	if (!s->vert_pred)
		423	return AVERROR(ENOMEM);
		424	}
		425
		426	/* There is 1 change bit per 4 pixels, so each change byte represents
		427	* 32 pixels; divide width by 4 to obtain the number of change bits and
		428	* then round up to the nearest byte. */
		429	s->mb_change_bits_row_size = ((s->avctx->width >> (2 - width_shift)) + 7) >> 3;
		430
		431	if ((header.deltaset != s->last_deltaset) \|\| (header.vectable != s->last_vectable))
		432	{
		433	if (compression_types[header.compression].algorithm == ALGO_RGB24H)
		434	gen_vector_table24(s, sel_vector_table);
		435	else
		436	if (s->avctx->pix_fmt == AV_PIX_FMT_RGB555)
		437	gen_vector_table15(s, sel_vector_table);
		438	else
		439	gen_vector_table16(s, sel_vector_table);
		440	}
		441
		442	/* set up pointers to the other key data chunks */
		443	s->mb_change_bits = s->buf + header.header_size;
		444	if (s->flags & FLAG_KEYFRAME) {
		445	/* no change bits specified for a keyframe; only index bytes */
		446	s->index_stream = s->mb_change_bits;
		447	} else {
		448	/* one change bit per 4x4 block */
		449	s->index_stream = s->mb_change_bits +
		450	(s->mb_change_bits_row_size * (s->avctx->height >> 2));
		451	}
		452	s->index_stream_size = s->size - (s->index_stream - s->buf);
		453
		454	s->last_deltaset = header.deltaset;
		455	s->last_vectable = header.vectable;
		456	s->compression = header.compression;
		457	s->block_width = compression_types[header.compression].block_width;
		458	s->block_height = compression_types[header.compression].block_height;
		459	s->block_type = compression_types[header.compression].block_type;
		460
		461	if (s->avctx->debug & FF_DEBUG_PICT_INFO)
		462	av_log(s->avctx, AV_LOG_INFO, "tables: %d / %d c:%d %dx%d t:%d %s%s%s%s\n",
		463	s->last_deltaset, s->last_vectable, s->compression, s->block_width,
		464	s->block_height, s->block_type,
		465	s->flags & FLAG_KEYFRAME ? " KEY" : "",
		466	s->flags & FLAG_INTERFRAME ? " INTER" : "",
		467	s->flags & FLAG_SPRITE ? " SPRITE" : "",
		468	s->flags & FLAG_INTERPOLATED ? " INTERPOL" : "");
		469
		470	return header.header_size;
		471	}
		472
		473	static av_cold int truemotion1_decode_init(AVCodecContext *avctx)
		474	{
		475	TrueMotion1Context *s = avctx->priv_data;
		476
		477	s->avctx = avctx;
		478
		479	// FIXME: it may change ?
		480	// if (avctx->bits_per_sample == 24)
		481	// avctx->pix_fmt = AV_PIX_FMT_RGB24;
		482	// else
		483	// avctx->pix_fmt = AV_PIX_FMT_RGB555;
		484
		485	s->frame = av_frame_alloc();
		486	if (!s->frame)
		487	return AVERROR(ENOMEM);
		488
		489	/* there is a vertical predictor for each pixel in a line; each vertical
		490	* predictor is 0 to start with */
		491	av_fast_malloc(&s->vert_pred, &s->vert_pred_size, s->avctx->width * sizeof(unsigned int));
		492	if (!s->vert_pred)
		493	return AVERROR(ENOMEM);
		494
		495	return 0;
		496	}
		497
		498	/*
		499	Block decoding order:
		500
		501	dxi: Y-Y
		502	dxic: Y-C-Y
		503	dxic2: Y-C-Y-C
		504
		505	hres,vres,i,i%vres (0 < i < 4)
		506	2x2 0: 0 dxic2
		507	2x2 1: 1 dxi
		508	2x2 2: 0 dxic2
		509	2x2 3: 1 dxi
		510	2x4 0: 0 dxic2
		511	2x4 1: 1 dxi
		512	2x4 2: 2 dxi
		513	2x4 3: 3 dxi
		514	4x2 0: 0 dxic
		515	4x2 1: 1 dxi
		516	4x2 2: 0 dxic
		517	4x2 3: 1 dxi
		518	4x4 0: 0 dxic
		519	4x4 1: 1 dxi
		520	4x4 2: 2 dxi
		521	4x4 3: 3 dxi
		522	*/
		523
		524	#define GET_NEXT_INDEX() \
		525	{\
		526	if (index_stream_index >= s->index_stream_size) { \
		527	av_log(s->avctx, AV_LOG_INFO, " help! truemotion1 decoder went out of bounds\n"); \
		528	return; \
		529	} \
		530	index = s->index_stream[index_stream_index++] * 4; \
		531	}
		532
		533	#define INC_INDEX \
		534	do { \
		535	if (index >= 1023) { \
		536	av_log(s->avctx, AV_LOG_ERROR, "Invalid index value.\n"); \
		537	return; \
		538	} \
		539	index++; \
		540	} while (0)
		541
		542	#define APPLY_C_PREDICTOR() \
		543	predictor_pair = s->c_predictor_table[index]; \
		544	horiz_pred += (predictor_pair >> 1); \
		545	if (predictor_pair & 1) { \
		546	GET_NEXT_INDEX() \
		547	if (!index) { \
		548	GET_NEXT_INDEX() \
		549	predictor_pair = s->c_predictor_table[index]; \
		550	horiz_pred += ((predictor_pair >> 1) * 5); \
		551	if (predictor_pair & 1) \
		552	GET_NEXT_INDEX() \
		553	else \
		554	INC_INDEX; \
		555	} \
		556	} else \
		557	INC_INDEX;
		558
		559	#define APPLY_C_PREDICTOR_24() \
		560	predictor_pair = s->c_predictor_table[index]; \
		561	horiz_pred += (predictor_pair >> 1); \
		562	if (predictor_pair & 1) { \
		563	GET_NEXT_INDEX() \
		564	if (!index) { \
		565	GET_NEXT_INDEX() \
		566	predictor_pair = s->fat_c_predictor_table[index]; \
		567	horiz_pred += (predictor_pair >> 1); \
		568	if (predictor_pair & 1) \
		569	GET_NEXT_INDEX() \
		570	else \
		571	INC_INDEX; \
		572	} \
		573	} else \
		574	INC_INDEX;
		575
		576
		577	#define APPLY_Y_PREDICTOR() \
		578	predictor_pair = s->y_predictor_table[index]; \
		579	horiz_pred += (predictor_pair >> 1); \
		580	if (predictor_pair & 1) { \
		581	GET_NEXT_INDEX() \
		582	if (!index) { \
		583	GET_NEXT_INDEX() \
		584	predictor_pair = s->y_predictor_table[index]; \
		585	horiz_pred += ((predictor_pair >> 1) * 5); \
		586	if (predictor_pair & 1) \
		587	GET_NEXT_INDEX() \
		588	else \
		589	INC_INDEX; \
		590	} \
		591	} else \
		592	INC_INDEX;
		593
		594	#define APPLY_Y_PREDICTOR_24() \
		595	predictor_pair = s->y_predictor_table[index]; \
		596	horiz_pred += (predictor_pair >> 1); \
		597	if (predictor_pair & 1) { \
		598	GET_NEXT_INDEX() \
		599	if (!index) { \
		600	GET_NEXT_INDEX() \
		601	predictor_pair = s->fat_y_predictor_table[index]; \
		602	horiz_pred += (predictor_pair >> 1); \
		603	if (predictor_pair & 1) \
		604	GET_NEXT_INDEX() \
		605	else \
		606	INC_INDEX; \
		607	} \
		608	} else \
		609	INC_INDEX;
		610
		611	#define OUTPUT_PIXEL_PAIR() \
		612	current_pixel_pair = vert_pred + horiz_pred; \
		613	vert_pred++ = current_pixel_pair++;
		614
		615	static void truemotion1_decode_16bit(TrueMotion1Context *s)
		616	{
		617	int y;
		618	int pixels_left; /* remaining pixels on this line */
		619	unsigned int predictor_pair;
		620	unsigned int horiz_pred;
		621	unsigned int *vert_pred;
		622	unsigned int *current_pixel_pair;
		623	unsigned char *current_line = s->frame->data[0];
		624	int keyframe = s->flags & FLAG_KEYFRAME;
		625
		626	/* these variables are for managing the stream of macroblock change bits */
		627	const unsigned char *mb_change_bits = s->mb_change_bits;
		628	unsigned char mb_change_byte;
		629	unsigned char mb_change_byte_mask;
		630	int mb_change_index;
		631
		632	/* these variables are for managing the main index stream */
		633	int index_stream_index = 0; /* yes, the index into the index stream */
		634	int index;
		635
		636	/* clean out the line buffer */
		637	memset(s->vert_pred, 0, s->avctx->width * sizeof(unsigned int));
		638
		639	GET_NEXT_INDEX();
		640
		641	for (y = 0; y < s->avctx->height; y++) {
		642
		643	/* re-init variables for the next line iteration */
		644	horiz_pred = 0;
		645	current_pixel_pair = (unsigned int *)current_line;
		646	vert_pred = s->vert_pred;
		647	mb_change_index = 0;
		648	mb_change_byte = mb_change_bits[mb_change_index++];
		649	mb_change_byte_mask = 0x01;
		650	pixels_left = s->avctx->width;
		651
		652	while (pixels_left > 0) {
		653
		654	if (keyframe \|\| ((mb_change_byte & mb_change_byte_mask) == 0)) {
		655
		656	switch (y & 3) {
		657	case 0:
		658	/* if macroblock width is 2, apply C-Y-C-Y; else
		659	* apply C-Y-Y */
		660	if (s->block_width == 2) {
		661	APPLY_C_PREDICTOR();
		662	APPLY_Y_PREDICTOR();
		663	OUTPUT_PIXEL_PAIR();
		664	APPLY_C_PREDICTOR();
		665	APPLY_Y_PREDICTOR();
		666	OUTPUT_PIXEL_PAIR();
		667	} else {
		668	APPLY_C_PREDICTOR();
		669	APPLY_Y_PREDICTOR();
		670	OUTPUT_PIXEL_PAIR();
		671	APPLY_Y_PREDICTOR();
		672	OUTPUT_PIXEL_PAIR();
		673	}
		674	break;
		675
		676	case 1:
		677	case 3:
		678	/* always apply 2 Y predictors on these iterations */
		679	APPLY_Y_PREDICTOR();
		680	OUTPUT_PIXEL_PAIR();
		681	APPLY_Y_PREDICTOR();
		682	OUTPUT_PIXEL_PAIR();
		683	break;
		684
		685	case 2:
		686	/* this iteration might be C-Y-C-Y, Y-Y, or C-Y-Y
		687	* depending on the macroblock type */
		688	if (s->block_type == BLOCK_2x2) {
		689	APPLY_C_PREDICTOR();
		690	APPLY_Y_PREDICTOR();
		691	OUTPUT_PIXEL_PAIR();
		692	APPLY_C_PREDICTOR();
		693	APPLY_Y_PREDICTOR();
		694	OUTPUT_PIXEL_PAIR();
		695	} else if (s->block_type == BLOCK_4x2) {
		696	APPLY_C_PREDICTOR();
		697	APPLY_Y_PREDICTOR();
		698	OUTPUT_PIXEL_PAIR();
		699	APPLY_Y_PREDICTOR();
		700	OUTPUT_PIXEL_PAIR();
		701	} else {
		702	APPLY_Y_PREDICTOR();
		703	OUTPUT_PIXEL_PAIR();
		704	APPLY_Y_PREDICTOR();
		705	OUTPUT_PIXEL_PAIR();
		706	}
		707	break;
		708	}
		709
		710	} else {
		711
		712	/* skip (copy) four pixels, but reassign the horizontal
		713	* predictor */
		714	vert_pred++ = current_pixel_pair++;
		715	horiz_pred = current_pixel_pair - vert_pred;
		716	vert_pred++ = current_pixel_pair++;
		717
		718	}
		719
		720	if (!keyframe) {
		721	mb_change_byte_mask <<= 1;
		722
		723	/* next byte */
		724	if (!mb_change_byte_mask) {
		725	mb_change_byte = mb_change_bits[mb_change_index++];
		726	mb_change_byte_mask = 0x01;
		727	}
		728	}
		729
		730	pixels_left -= 4;
		731	}
		732
		733	/* next change row */
		734	if (((y + 1) & 3) == 0)
		735	mb_change_bits += s->mb_change_bits_row_size;
		736
		737	current_line += s->frame->linesize[0];
		738	}
		739	}
		740
		741	static void truemotion1_decode_24bit(TrueMotion1Context *s)
		742	{
		743	int y;
		744	int pixels_left; /* remaining pixels on this line */
		745	unsigned int predictor_pair;
		746	unsigned int horiz_pred;
		747	unsigned int *vert_pred;
		748	unsigned int *current_pixel_pair;
		749	unsigned char *current_line = s->frame->data[0];
		750	int keyframe = s->flags & FLAG_KEYFRAME;
		751
		752	/* these variables are for managing the stream of macroblock change bits */
		753	const unsigned char *mb_change_bits = s->mb_change_bits;
		754	unsigned char mb_change_byte;
		755	unsigned char mb_change_byte_mask;
		756	int mb_change_index;
		757
		758	/* these variables are for managing the main index stream */
		759	int index_stream_index = 0; /* yes, the index into the index stream */
		760	int index;
		761
		762	/* clean out the line buffer */
		763	memset(s->vert_pred, 0, s->avctx->width * sizeof(unsigned int));
		764
		765	GET_NEXT_INDEX();
		766
		767	for (y = 0; y < s->avctx->height; y++) {
		768
		769	/* re-init variables for the next line iteration */
		770	horiz_pred = 0;
		771	current_pixel_pair = (unsigned int *)current_line;
		772	vert_pred = s->vert_pred;
		773	mb_change_index = 0;
		774	mb_change_byte = mb_change_bits[mb_change_index++];
		775	mb_change_byte_mask = 0x01;
		776	pixels_left = s->avctx->width;
		777
		778	while (pixels_left > 0) {
		779
		780	if (keyframe \|\| ((mb_change_byte & mb_change_byte_mask) == 0)) {
		781
		782	switch (y & 3) {
		783	case 0:
		784	/* if macroblock width is 2, apply C-Y-C-Y; else
		785	* apply C-Y-Y */
		786	if (s->block_width == 2) {
		787	APPLY_C_PREDICTOR_24();
		788	APPLY_Y_PREDICTOR_24();
		789	OUTPUT_PIXEL_PAIR();
		790	APPLY_C_PREDICTOR_24();
		791	APPLY_Y_PREDICTOR_24();
		792	OUTPUT_PIXEL_PAIR();
		793	} else {
		794	APPLY_C_PREDICTOR_24();
		795	APPLY_Y_PREDICTOR_24();
		796	OUTPUT_PIXEL_PAIR();
		797	APPLY_Y_PREDICTOR_24();
		798	OUTPUT_PIXEL_PAIR();
		799	}
		800	break;
		801
		802	case 1:
		803	case 3:
		804	/* always apply 2 Y predictors on these iterations */
		805	APPLY_Y_PREDICTOR_24();
		806	OUTPUT_PIXEL_PAIR();
		807	APPLY_Y_PREDICTOR_24();
		808	OUTPUT_PIXEL_PAIR();
		809	break;
		810
		811	case 2:
		812	/* this iteration might be C-Y-C-Y, Y-Y, or C-Y-Y
		813	* depending on the macroblock type */
		814	if (s->block_type == BLOCK_2x2) {
		815	APPLY_C_PREDICTOR_24();
		816	APPLY_Y_PREDICTOR_24();
		817	OUTPUT_PIXEL_PAIR();
		818	APPLY_C_PREDICTOR_24();
		819	APPLY_Y_PREDICTOR_24();
		820	OUTPUT_PIXEL_PAIR();
		821	} else if (s->block_type == BLOCK_4x2) {
		822	APPLY_C_PREDICTOR_24();
		823	APPLY_Y_PREDICTOR_24();
		824	OUTPUT_PIXEL_PAIR();
		825	APPLY_Y_PREDICTOR_24();
		826	OUTPUT_PIXEL_PAIR();
		827	} else {
		828	APPLY_Y_PREDICTOR_24();
		829	OUTPUT_PIXEL_PAIR();
		830	APPLY_Y_PREDICTOR_24();
		831	OUTPUT_PIXEL_PAIR();
		832	}
		833	break;
		834	}
		835
		836	} else {
		837
		838	/* skip (copy) four pixels, but reassign the horizontal
		839	* predictor */
		840	vert_pred++ = current_pixel_pair++;
		841	horiz_pred = current_pixel_pair - vert_pred;
		842	vert_pred++ = current_pixel_pair++;
		843
		844	}
		845
		846	if (!keyframe) {
		847	mb_change_byte_mask <<= 1;
		848
		849	/* next byte */
		850	if (!mb_change_byte_mask) {
		851	mb_change_byte = mb_change_bits[mb_change_index++];
		852	mb_change_byte_mask = 0x01;
		853	}
		854	}
		855
		856	pixels_left -= 2;
		857	}
		858
		859	/* next change row */
		860	if (((y + 1) & 3) == 0)
		861	mb_change_bits += s->mb_change_bits_row_size;
		862
		863	current_line += s->frame->linesize[0];
		864	}
		865	}
		866
		867
		868	static int truemotion1_decode_frame(AVCodecContext *avctx,
		869	void data, int got_frame,
		870	AVPacket *avpkt)
		871	{
		872	const uint8_t *buf = avpkt->data;
		873	int ret, buf_size = avpkt->size;
		874	TrueMotion1Context *s = avctx->priv_data;
		875
		876	s->buf = buf;
		877	s->size = buf_size;
		878
		879	if ((ret = truemotion1_decode_header(s)) < 0)
		880	return ret;
		881
		882	if ((ret = ff_reget_buffer(avctx, s->frame)) < 0)
		883	return ret;
		884
		885	if (compression_types[s->compression].algorithm == ALGO_RGB24H) {
		886	truemotion1_decode_24bit(s);
		887	} else if (compression_types[s->compression].algorithm != ALGO_NOP) {
		888	truemotion1_decode_16bit(s);
		889	}
		890
		891	if ((ret = av_frame_ref(data, s->frame)) < 0)
		892	return ret;
		893
		894	*got_frame = 1;
		895
		896	/* report that the buffer was completely consumed */
		897	return buf_size;
		898	}
		899
		900	static av_cold int truemotion1_decode_end(AVCodecContext *avctx)
		901	{
		902	TrueMotion1Context *s = avctx->priv_data;
		903
		904	av_frame_free(&s->frame);
		905	av_freep(&s->vert_pred);
		906
		907	return 0;
		908	}
		909
		910	AVCodec ff_truemotion1_decoder = {
		911	.name = "truemotion1",
		912	.long_name = NULL_IF_CONFIG_SMALL("Duck TrueMotion 1.0"),
		913	.type = AVMEDIA_TYPE_VIDEO,
		914	.id = AV_CODEC_ID_TRUEMOTION1,
		915	.priv_data_size = sizeof(TrueMotion1Context),
		916	.init = truemotion1_decode_init,
		917	.close = truemotion1_decode_end,
		918	.decode = truemotion1_decode_frame,
		919	.capabilities = AV_CODEC_CAP_DR1,
		920	};

Subversion Repositories Kolibri OS

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