WebSVN – Kolibri OS – Blame – /contrib/sdk/sources/ffmpeg/libavcodec/indeo4.c

Rev	Author	Line No.	Line
4349	Serge	1	/*
		2	* Indeo Video Interactive v4 compatible decoder
		3	* Copyright (c) 2009-2011 Maxim Poliakovski
		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	* Indeo Video Interactive version 4 decoder
		25	*
		26	* Indeo 4 data is usually transported within .avi or .mov files.
		27	* Known FOURCCs: 'IV41'
		28	*/
		29
		30	#define BITSTREAM_READER_LE
		31	#include "avcodec.h"
		32	#include "get_bits.h"
		33	#include "ivi_dsp.h"
		34	#include "ivi_common.h"
		35	#include "indeo4data.h"
		36
		37	/**
		38	* Indeo 4 frame types.
		39	*/
		40	enum {
		41	FRAMETYPE_INTRA = 0,
		42	FRAMETYPE_INTRA1 = 1, ///< intra frame with slightly different bitstream coding
		43	FRAMETYPE_INTER = 2, ///< non-droppable P-frame
		44	FRAMETYPE_BIDIR = 3, ///< bidirectional frame
		45	FRAMETYPE_INTER_NOREF = 4, ///< droppable P-frame
		46	FRAMETYPE_NULL_FIRST = 5, ///< empty frame with no data
		47	FRAMETYPE_NULL_LAST = 6 ///< empty frame with no data
		48	};
		49
		50	#define IVI4_PIC_SIZE_ESC 7
		51
		52
		53	static const struct {
		54	InvTransformPtr *inv_trans;
		55	DCTransformPtr *dc_trans;
		56	int is_2d_trans;
		57	} transforms[18] = {
		58	{ ff_ivi_inverse_haar_8x8, ff_ivi_dc_haar_2d, 1 },
		59	{ ff_ivi_row_haar8, ff_ivi_dc_haar_2d, 0 },
		60	{ ff_ivi_col_haar8, ff_ivi_dc_haar_2d, 0 },
		61	{ ff_ivi_put_pixels_8x8, ff_ivi_put_dc_pixel_8x8, 1 },
		62	{ ff_ivi_inverse_slant_8x8, ff_ivi_dc_slant_2d, 1 },
		63	{ ff_ivi_row_slant8, ff_ivi_dc_row_slant, 1 },
		64	{ ff_ivi_col_slant8, ff_ivi_dc_col_slant, 1 },
		65	{ NULL, NULL, 0 }, /* inverse DCT 8x8 */
		66	{ NULL, NULL, 0 }, /* inverse DCT 8x1 */
		67	{ NULL, NULL, 0 }, /* inverse DCT 1x8 */
		68	{ ff_ivi_inverse_haar_4x4, ff_ivi_dc_haar_2d, 1 },
		69	{ ff_ivi_inverse_slant_4x4, ff_ivi_dc_slant_2d, 1 },
		70	{ NULL, NULL, 0 }, /* no transform 4x4 */
		71	{ ff_ivi_row_haar4, ff_ivi_dc_haar_2d, 0 },
		72	{ ff_ivi_col_haar4, ff_ivi_dc_haar_2d, 0 },
		73	{ ff_ivi_row_slant4, ff_ivi_dc_row_slant, 0 },
		74	{ ff_ivi_col_slant4, ff_ivi_dc_col_slant, 0 },
		75	{ NULL, NULL, 0 }, /* inverse DCT 4x4 */
		76	};
		77
		78	/**
		79	* Decode subdivision of a plane.
		80	* This is a simplified version that checks for two supported subdivisions:
		81	* - 1 wavelet band per plane, size factor 1:1, code pattern: 3
		82	* - 4 wavelet bands per plane, size factor 1:4, code pattern: 2,3,3,3,3
		83	* Anything else is either unsupported or corrupt.
		84	*
		85	* @param[in,out] gb the GetBit context
		86	* @return number of wavelet bands or 0 on error
		87	*/
		88	static int decode_plane_subdivision(GetBitContext *gb)
		89	{
		90	int i;
		91
		92	switch (get_bits(gb, 2)) {
		93	case 3:
		94	return 1;
		95	case 2:
		96	for (i = 0; i < 4; i++)
		97	if (get_bits(gb, 2) != 3)
		98	return 0;
		99	return 4;
		100	default:
		101	return 0;
		102	}
		103	}
		104
		105	static inline int scale_tile_size(int def_size, int size_factor)
		106	{
		107	return size_factor == 15 ? def_size : (size_factor + 1) << 5;
		108	}
		109
		110	/**
		111	* Decode Indeo 4 picture header.
		112	*
		113	* @param[in,out] ctx pointer to the decoder context
		114	* @param[in] avctx pointer to the AVCodecContext
		115	* @return result code: 0 = OK, negative number = error
		116	*/
		117	static int decode_pic_hdr(IVI45DecContext ctx, AVCodecContext avctx)
		118	{
		119	int pic_size_indx, i, p;
		120	IVIPicConfig pic_conf;
		121
		122	if (get_bits(&ctx->gb, 18) != 0x3FFF8) {
		123	av_log(avctx, AV_LOG_ERROR, "Invalid picture start code!\n");
		124	return AVERROR_INVALIDDATA;
		125	}
		126
		127	ctx->prev_frame_type = ctx->frame_type;
		128	ctx->frame_type = get_bits(&ctx->gb, 3);
		129	if (ctx->frame_type == 7) {
		130	av_log(avctx, AV_LOG_ERROR, "Invalid frame type: %d\n", ctx->frame_type);
		131	return AVERROR_INVALIDDATA;
		132	}
		133
		134	#if IVI4_STREAM_ANALYSER
		135	if (ctx->frame_type == FRAMETYPE_BIDIR)
		136	ctx->has_b_frames = 1;
		137	#endif
		138
		139	ctx->transp_status = get_bits1(&ctx->gb);
		140	#if IVI4_STREAM_ANALYSER
		141	if (ctx->transp_status) {
		142	ctx->has_transp = 1;
		143	}
		144	#endif
		145
		146	/* unknown bit: Mac decoder ignores this bit, XANIM returns error */
		147	if (get_bits1(&ctx->gb)) {
		148	av_log(avctx, AV_LOG_ERROR, "Sync bit is set!\n");
		149	return AVERROR_INVALIDDATA;
		150	}
		151
		152	ctx->data_size = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 24) : 0;
		153
		154	/* null frames don't contain anything else so we just return */
		155	if (ctx->frame_type >= FRAMETYPE_NULL_FIRST) {
		156	av_dlog(avctx, "Null frame encountered!\n");
		157	return 0;
		158	}
		159
		160	/* Check key lock status. If enabled - ignore lock word. */
		161	/* Usually we have to prompt the user for the password, but */
		162	/* we don't do that because Indeo 4 videos can be decoded anyway */
		163	if (get_bits1(&ctx->gb)) {
		164	skip_bits_long(&ctx->gb, 32);
		165	av_dlog(avctx, "Password-protected clip!\n");
		166	}
		167
		168	pic_size_indx = get_bits(&ctx->gb, 3);
		169	if (pic_size_indx == IVI4_PIC_SIZE_ESC) {
		170	pic_conf.pic_height = get_bits(&ctx->gb, 16);
		171	pic_conf.pic_width = get_bits(&ctx->gb, 16);
		172	} else {
		173	pic_conf.pic_height = ivi4_common_pic_sizes[pic_size_indx * 2 + 1];
		174	pic_conf.pic_width = ivi4_common_pic_sizes[pic_size_indx * 2 ];
		175	}
		176
		177	/* Decode tile dimensions. */
		178	if (get_bits1(&ctx->gb)) {
		179	pic_conf.tile_height = scale_tile_size(pic_conf.pic_height, get_bits(&ctx->gb, 4));
		180	pic_conf.tile_width = scale_tile_size(pic_conf.pic_width, get_bits(&ctx->gb, 4));
		181	#if IVI4_STREAM_ANALYSER
		182	ctx->uses_tiling = 1;
		183	#endif
		184	} else {
		185	pic_conf.tile_height = pic_conf.pic_height;
		186	pic_conf.tile_width = pic_conf.pic_width;
		187	}
		188
		189	/* Decode chroma subsampling. We support only 4:4 aka YVU9. */
		190	if (get_bits(&ctx->gb, 2)) {
		191	av_log(avctx, AV_LOG_ERROR, "Only YVU9 picture format is supported!\n");
		192	return AVERROR_INVALIDDATA;
		193	}
		194	pic_conf.chroma_height = (pic_conf.pic_height + 3) >> 2;
		195	pic_conf.chroma_width = (pic_conf.pic_width + 3) >> 2;
		196
		197	/* decode subdivision of the planes */
		198	pic_conf.luma_bands = decode_plane_subdivision(&ctx->gb);
		199	pic_conf.chroma_bands = 0;
		200	if (pic_conf.luma_bands)
		201	pic_conf.chroma_bands = decode_plane_subdivision(&ctx->gb);
		202	ctx->is_scalable = pic_conf.luma_bands != 1 \|\| pic_conf.chroma_bands != 1;
		203	if (ctx->is_scalable && (pic_conf.luma_bands != 4 \|\| pic_conf.chroma_bands != 1)) {
		204	av_log(avctx, AV_LOG_ERROR, "Scalability: unsupported subdivision! Luma bands: %d, chroma bands: %d\n",
		205	pic_conf.luma_bands, pic_conf.chroma_bands);
		206	return AVERROR_INVALIDDATA;
		207	}
		208
		209	/* check if picture layout was changed and reallocate buffers */
		210	if (ivi_pic_config_cmp(&pic_conf, &ctx->pic_conf)) {
		211	if (ff_ivi_init_planes(ctx->planes, &pic_conf)) {
		212	av_log(avctx, AV_LOG_ERROR, "Couldn't reallocate color planes!\n");
		213	ctx->pic_conf.luma_bands = 0;
		214	return AVERROR(ENOMEM);
		215	}
		216
		217	ctx->pic_conf = pic_conf;
		218
		219	/* set default macroblock/block dimensions */
		220	for (p = 0; p <= 2; p++) {
		221	for (i = 0; i < (!p ? pic_conf.luma_bands : pic_conf.chroma_bands); i++) {
		222	ctx->planes[p].bands[i].mb_size = !p ? (!ctx->is_scalable ? 16 : 8) : 4;
		223	ctx->planes[p].bands[i].blk_size = !p ? 8 : 4;
		224	}
		225	}
		226
		227	if (ff_ivi_init_tiles(ctx->planes, ctx->pic_conf.tile_width,
		228	ctx->pic_conf.tile_height)) {
		229	av_log(avctx, AV_LOG_ERROR,
		230	"Couldn't reallocate internal structures!\n");
		231	return AVERROR(ENOMEM);
		232	}
		233	}
		234
		235	ctx->frame_num = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 20) : 0;
		236
		237	/* skip decTimeEst field if present */
		238	if (get_bits1(&ctx->gb))
		239	skip_bits(&ctx->gb, 8);
		240
		241	/* decode macroblock and block huffman codebooks */
		242	if (ff_ivi_dec_huff_desc(&ctx->gb, get_bits1(&ctx->gb), IVI_MB_HUFF, &ctx->mb_vlc, avctx) \|\|
		243	ff_ivi_dec_huff_desc(&ctx->gb, get_bits1(&ctx->gb), IVI_BLK_HUFF, &ctx->blk_vlc, avctx))
		244	return AVERROR_INVALIDDATA;
		245
		246	ctx->rvmap_sel = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 3) : 8;
		247
		248	ctx->in_imf = get_bits1(&ctx->gb);
		249	ctx->in_q = get_bits1(&ctx->gb);
		250
		251	ctx->pic_glob_quant = get_bits(&ctx->gb, 5);
		252
		253	/* TODO: ignore this parameter if unused */
		254	ctx->unknown1 = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 3) : 0;
		255
		256	ctx->checksum = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 16) : 0;
		257
		258	/* skip picture header extension if any */
		259	while (get_bits1(&ctx->gb)) {
		260	av_dlog(avctx, "Pic hdr extension encountered!\n");
		261	skip_bits(&ctx->gb, 8);
		262	}
		263
		264	if (get_bits1(&ctx->gb)) {
		265	av_log(avctx, AV_LOG_ERROR, "Bad blocks bits encountered!\n");
		266	}
		267
		268	align_get_bits(&ctx->gb);
		269
		270	return 0;
		271	}
		272
		273
		274	/**
		275	* Decode Indeo 4 band header.
		276	*
		277	* @param[in,out] ctx pointer to the decoder context
		278	* @param[in,out] band pointer to the band descriptor
		279	* @param[in] avctx pointer to the AVCodecContext
		280	* @return result code: 0 = OK, negative number = error
		281	*/
		282	static int decode_band_hdr(IVI45DecContext ctx, IVIBandDesc band,
		283	AVCodecContext *avctx)
		284	{
		285	int plane, band_num, indx, transform_id, scan_indx;
		286	int i;
		287
		288	plane = get_bits(&ctx->gb, 2);
		289	band_num = get_bits(&ctx->gb, 4);
		290	if (band->plane != plane \|\| band->band_num != band_num) {
		291	av_log(avctx, AV_LOG_ERROR, "Invalid band header sequence!\n");
		292	return AVERROR_INVALIDDATA;
		293	}
		294
		295	band->is_empty = get_bits1(&ctx->gb);
		296	if (!band->is_empty) {
		297	int old_blk_size = band->blk_size;
		298	/* skip header size
		299	* If header size is not given, header size is 4 bytes. */
		300	if (get_bits1(&ctx->gb))
		301	skip_bits(&ctx->gb, 16);
		302
		303	band->is_halfpel = get_bits(&ctx->gb, 2);
		304	if (band->is_halfpel >= 2) {
		305	av_log(avctx, AV_LOG_ERROR, "Invalid/unsupported mv resolution: %d!\n",
		306	band->is_halfpel);
		307	return AVERROR_INVALIDDATA;
		308	}
		309	#if IVI4_STREAM_ANALYSER
		310	if (!band->is_halfpel)
		311	ctx->uses_fullpel = 1;
		312	#endif
		313
		314	band->checksum_present = get_bits1(&ctx->gb);
		315	if (band->checksum_present)
		316	band->checksum = get_bits(&ctx->gb, 16);
		317
		318	indx = get_bits(&ctx->gb, 2);
		319	if (indx == 3) {
		320	av_log(avctx, AV_LOG_ERROR, "Invalid block size!\n");
		321	return AVERROR_INVALIDDATA;
		322	}
		323	band->mb_size = 16 >> indx;
		324	band->blk_size = 8 >> (indx >> 1);
		325
		326	band->inherit_mv = get_bits1(&ctx->gb);
		327	band->inherit_qdelta = get_bits1(&ctx->gb);
		328
		329	band->glob_quant = get_bits(&ctx->gb, 5);
		330
		331	if (!get_bits1(&ctx->gb) \|\| ctx->frame_type == FRAMETYPE_INTRA) {
		332	transform_id = get_bits(&ctx->gb, 5);
		333	if (transform_id >= FF_ARRAY_ELEMS(transforms) \|\|
		334	!transforms[transform_id].inv_trans) {
		335	avpriv_request_sample(avctx, "Transform %d", transform_id);
		336	return AVERROR_PATCHWELCOME;
		337	}
		338	if ((transform_id >= 7 && transform_id <= 9) \|\|
		339	transform_id == 17) {
		340	avpriv_request_sample(avctx, "DCT transform");
		341	return AVERROR_PATCHWELCOME;
		342	}
		343
		344	if (transform_id < 10 && band->blk_size < 8) {
		345	av_log(avctx, AV_LOG_ERROR, "wrong transform size!\n");
		346	return AVERROR_INVALIDDATA;
		347	}
		348	#if IVI4_STREAM_ANALYSER
		349	if ((transform_id >= 0 && transform_id <= 2) \|\| transform_id == 10)
		350	ctx->uses_haar = 1;
		351	#endif
		352
		353	band->inv_transform = transforms[transform_id].inv_trans;
		354	band->dc_transform = transforms[transform_id].dc_trans;
		355	band->is_2d_trans = transforms[transform_id].is_2d_trans;
		356
		357	if (transform_id < 10)
		358	band->transform_size = 8;
		359	else
		360	band->transform_size = 4;
		361
		362	if (band->blk_size != band->transform_size) {
		363	av_log(avctx, AV_LOG_ERROR, "transform and block size mismatch (%d != %d)\n", band->transform_size, band->blk_size);
		364	return AVERROR_INVALIDDATA;
		365	}
		366
		367	scan_indx = get_bits(&ctx->gb, 4);
		368	if (scan_indx == 15) {
		369	av_log(avctx, AV_LOG_ERROR, "Custom scan pattern encountered!\n");
		370	return AVERROR_INVALIDDATA;
		371	}
		372	if (scan_indx > 4 && scan_indx < 10) {
		373	if (band->blk_size != 4) {
		374	av_log(avctx, AV_LOG_ERROR, "mismatching scan table!\n");
		375	return AVERROR_INVALIDDATA;
		376	}
		377	} else if (band->blk_size != 8) {
		378	av_log(avctx, AV_LOG_ERROR, "mismatching scan table!\n");
		379	return AVERROR_INVALIDDATA;
		380	}
		381
		382	band->scan = scan_index_to_tab[scan_indx];
		383	band->scan_size = band->blk_size;
		384
		385	band->quant_mat = get_bits(&ctx->gb, 5);
		386	if (band->quant_mat >= FF_ARRAY_ELEMS(quant_index_to_tab)) {
		387
		388	if (band->quant_mat == 31)
		389	av_log(avctx, AV_LOG_ERROR,
		390	"Custom quant matrix encountered!\n");
		391	else
		392	avpriv_request_sample(avctx, "Quantization matrix %d",
		393	band->quant_mat);
		394	band->quant_mat = -1;
		395	return AVERROR_INVALIDDATA;
		396	}
		397	} else {
		398	if (old_blk_size != band->blk_size) {
		399	av_log(avctx, AV_LOG_ERROR,
		400	"The band block size does not match the configuration "
		401	"inherited\n");
		402	return AVERROR_INVALIDDATA;
		403	}
		404	if (band->quant_mat < 0) {
		405	av_log(avctx, AV_LOG_ERROR, "Invalid quant_mat inherited\n");
		406	return AVERROR_INVALIDDATA;
		407	}
		408	}
		409	if (quant_index_to_tab[band->quant_mat] > 4 && band->blk_size == 4) {
		410	av_log(avctx, AV_LOG_ERROR, "Invalid quant matrix for 4x4 block encountered!\n");
		411	band->quant_mat = 0;
		412	return AVERROR_INVALIDDATA;
		413	}
		414	if (band->scan_size != band->blk_size) {
		415	av_log(avctx, AV_LOG_ERROR, "mismatching scan table!\n");
		416	return AVERROR_INVALIDDATA;
		417	}
		418	if (band->transform_size == 8 && band->blk_size < 8) {
		419	av_log(avctx, AV_LOG_ERROR, "mismatching transform_size!\n");
		420	return AVERROR_INVALIDDATA;
		421	}
		422
		423	/* decode block huffman codebook */
		424	if (!get_bits1(&ctx->gb))
		425	band->blk_vlc.tab = ctx->blk_vlc.tab;
		426	else
		427	if (ff_ivi_dec_huff_desc(&ctx->gb, 1, IVI_BLK_HUFF,
		428	&band->blk_vlc, avctx))
		429	return AVERROR_INVALIDDATA;
		430
		431	/* select appropriate rvmap table for this band */
		432	band->rvmap_sel = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 3) : 8;
		433
		434	/* decode rvmap probability corrections if any */
		435	band->num_corr = 0; /* there is no corrections */
		436	if (get_bits1(&ctx->gb)) {
		437	band->num_corr = get_bits(&ctx->gb, 8); /* get number of correction pairs */
		438	if (band->num_corr > 61) {
		439	av_log(avctx, AV_LOG_ERROR, "Too many corrections: %d\n",
		440	band->num_corr);
		441	return AVERROR_INVALIDDATA;
		442	}
		443
		444	/* read correction pairs */
		445	for (i = 0; i < band->num_corr * 2; i++)
		446	band->corr[i] = get_bits(&ctx->gb, 8);
		447	}
		448	}
		449
		450	if (band->blk_size == 8) {
		451	band->intra_base = &ivi4_quant_8x8_intra[quant_index_to_tab[band->quant_mat]][0];
		452	band->inter_base = &ivi4_quant_8x8_inter[quant_index_to_tab[band->quant_mat]][0];
		453	} else {
		454	band->intra_base = &ivi4_quant_4x4_intra[quant_index_to_tab[band->quant_mat]][0];
		455	band->inter_base = &ivi4_quant_4x4_inter[quant_index_to_tab[band->quant_mat]][0];
		456	}
		457
		458	/* Indeo 4 doesn't use scale tables */
		459	band->intra_scale = NULL;
		460	band->inter_scale = NULL;
		461
		462	align_get_bits(&ctx->gb);
		463
		464	if (!band->scan) {
		465	av_log(avctx, AV_LOG_ERROR, "band->scan not set\n");
		466	return AVERROR_INVALIDDATA;
		467	}
		468
		469	return 0;
		470	}
		471
		472
		473	/**
		474	* Decode information (block type, cbp, quant delta, motion vector)
		475	* for all macroblocks in the current tile.
		476	*
		477	* @param[in,out] ctx pointer to the decoder context
		478	* @param[in,out] band pointer to the band descriptor
		479	* @param[in,out] tile pointer to the tile descriptor
		480	* @param[in] avctx pointer to the AVCodecContext
		481	* @return result code: 0 = OK, negative number = error
		482	*/
		483	static int decode_mb_info(IVI45DecContext ctx, IVIBandDesc band,
		484	IVITile tile, AVCodecContext avctx)
		485	{
		486	int x, y, mv_x, mv_y, mv_delta, offs, mb_offset, blks_per_mb,
		487	mv_scale, mb_type_bits, s;
		488	IVIMbInfo mb, ref_mb;
		489	int row_offset = band->mb_size * band->pitch;
		490
		491	mb = tile->mbs;
		492	ref_mb = tile->ref_mbs;
		493	offs = tile->ypos * band->pitch + tile->xpos;
		494
		495	blks_per_mb = band->mb_size != band->blk_size ? 4 : 1;
		496	mb_type_bits = ctx->frame_type == FRAMETYPE_BIDIR ? 2 : 1;
		497
		498	/* scale factor for motion vectors */
		499	mv_scale = (ctx->planes[0].bands[0].mb_size >> 3) - (band->mb_size >> 3);
		500	mv_x = mv_y = 0;
		501
		502	if (((tile->width + band->mb_size-1)/band->mb_size) * ((tile->height + band->mb_size-1)/band->mb_size) != tile->num_MBs) {
		503	av_log(avctx, AV_LOG_ERROR, "num_MBs mismatch %d %d %d %d\n", tile->width, tile->height, band->mb_size, tile->num_MBs);
		504	return -1;
		505	}
		506
		507	for (y = tile->ypos; y < tile->ypos + tile->height; y += band->mb_size) {
		508	mb_offset = offs;
		509
		510	for (x = tile->xpos; x < tile->xpos + tile->width; x += band->mb_size) {
		511	mb->xpos = x;
		512	mb->ypos = y;
		513	mb->buf_offs = mb_offset;
		514
		515	if (get_bits1(&ctx->gb)) {
		516	if (ctx->frame_type == FRAMETYPE_INTRA) {
		517	av_log(avctx, AV_LOG_ERROR, "Empty macroblock in an INTRA picture!\n");
		518	return AVERROR_INVALIDDATA;
		519	}
		520	mb->type = 1; /* empty macroblocks are always INTER */
		521	mb->cbp = 0; /* all blocks are empty */
		522
		523	mb->q_delta = 0;
		524	if (!band->plane && !band->band_num && ctx->in_q) {
		525	mb->q_delta = get_vlc2(&ctx->gb, ctx->mb_vlc.tab->table,
		526	IVI_VLC_BITS, 1);
		527	mb->q_delta = IVI_TOSIGNED(mb->q_delta);
		528	}
		529
		530	mb->mv_x = mb->mv_y = 0; /* no motion vector coded */
		531	if (band->inherit_mv && ref_mb) {
		532	/* motion vector inheritance */
		533	if (mv_scale) {
		534	mb->mv_x = ivi_scale_mv(ref_mb->mv_x, mv_scale);
		535	mb->mv_y = ivi_scale_mv(ref_mb->mv_y, mv_scale);
		536	} else {
		537	mb->mv_x = ref_mb->mv_x;
		538	mb->mv_y = ref_mb->mv_y;
		539	}
		540	}
		541	} else {
		542	if (band->inherit_mv) {
		543	/* copy mb_type from corresponding reference mb */
		544	if (!ref_mb) {
		545	av_log(avctx, AV_LOG_ERROR, "ref_mb unavailable\n");
		546	return AVERROR_INVALIDDATA;
		547	}
		548	mb->type = ref_mb->type;
		549	} else if (ctx->frame_type == FRAMETYPE_INTRA \|\|
		550	ctx->frame_type == FRAMETYPE_INTRA1) {
		551	mb->type = 0; /* mb_type is always INTRA for intra-frames */
		552	} else {
		553	mb->type = get_bits(&ctx->gb, mb_type_bits);
		554	}
		555
		556	mb->cbp = get_bits(&ctx->gb, blks_per_mb);
		557
		558	mb->q_delta = 0;
		559	if (band->inherit_qdelta) {
		560	if (ref_mb) mb->q_delta = ref_mb->q_delta;
		561	} else if (mb->cbp \|\| (!band->plane && !band->band_num &&
		562	ctx->in_q)) {
		563	mb->q_delta = get_vlc2(&ctx->gb, ctx->mb_vlc.tab->table,
		564	IVI_VLC_BITS, 1);
		565	mb->q_delta = IVI_TOSIGNED(mb->q_delta);
		566	}
		567
		568	if (!mb->type) {
		569	mb->mv_x = mb->mv_y = 0; /* there is no motion vector in intra-macroblocks */
		570	} else {
		571	if (band->inherit_mv) {
		572	if (ref_mb)
		573	/* motion vector inheritance */
		574	if (mv_scale) {
		575	mb->mv_x = ivi_scale_mv(ref_mb->mv_x, mv_scale);
		576	mb->mv_y = ivi_scale_mv(ref_mb->mv_y, mv_scale);
		577	} else {
		578	mb->mv_x = ref_mb->mv_x;
		579	mb->mv_y = ref_mb->mv_y;
		580	}
		581	} else {
		582	/* decode motion vector deltas */
		583	mv_delta = get_vlc2(&ctx->gb, ctx->mb_vlc.tab->table,
		584	IVI_VLC_BITS, 1);
		585	mv_y += IVI_TOSIGNED(mv_delta);
		586	mv_delta = get_vlc2(&ctx->gb, ctx->mb_vlc.tab->table,
		587	IVI_VLC_BITS, 1);
		588	mv_x += IVI_TOSIGNED(mv_delta);
		589	mb->mv_x = mv_x;
		590	mb->mv_y = mv_y;
		591	}
		592	}
		593	}
		594
		595	s= band->is_halfpel;
		596	if (mb->type)
		597	if ( x + (mb->mv_x >>s) + (y+ (mb->mv_y >>s))*band->pitch < 0 \|\|
		598	x + ((mb->mv_x+s)>>s) + band->mb_size - 1
		599	+ (y+band->mb_size - 1 +((mb->mv_y+s)>>s))*band->pitch > band->bufsize -1) {
		600	av_log(avctx, AV_LOG_ERROR, "motion vector %d %d outside reference\n", xs + mb->mv_x, ys + mb->mv_y);
		601	return AVERROR_INVALIDDATA;
		602	}
		603
		604	mb++;
		605	if (ref_mb)
		606	ref_mb++;
		607	mb_offset += band->mb_size;
		608	}
		609
		610	offs += row_offset;
		611	}
		612
		613	align_get_bits(&ctx->gb);
		614
		615	return 0;
		616	}
		617
		618
		619	/**
		620	* Rearrange decoding and reference buffers.
		621	*
		622	* @param[in,out] ctx pointer to the decoder context
		623	*/
		624	static void switch_buffers(IVI45DecContext *ctx)
		625	{
		626	switch (ctx->prev_frame_type) {
		627	case FRAMETYPE_INTRA:
		628	case FRAMETYPE_INTRA1:
		629	case FRAMETYPE_INTER:
		630	ctx->buf_switch ^= 1;
		631	ctx->dst_buf = ctx->buf_switch;
		632	ctx->ref_buf = ctx->buf_switch ^ 1;
		633	break;
		634	case FRAMETYPE_INTER_NOREF:
		635	break;
		636	}
		637
		638	switch (ctx->frame_type) {
		639	case FRAMETYPE_INTRA:
		640	case FRAMETYPE_INTRA1:
		641	ctx->buf_switch = 0;
		642	/* FALLTHROUGH */
		643	case FRAMETYPE_INTER:
		644	ctx->dst_buf = ctx->buf_switch;
		645	ctx->ref_buf = ctx->buf_switch ^ 1;
		646	break;
		647	case FRAMETYPE_INTER_NOREF:
		648	case FRAMETYPE_NULL_FIRST:
		649	case FRAMETYPE_NULL_LAST:
		650	break;
		651	}
		652	}
		653
		654
		655	static int is_nonnull_frame(IVI45DecContext *ctx)
		656	{
		657	return ctx->frame_type < FRAMETYPE_NULL_FIRST;
		658	}
		659
		660
		661	static av_cold int decode_init(AVCodecContext *avctx)
		662	{
		663	IVI45DecContext *ctx = avctx->priv_data;
		664
		665	ff_ivi_init_static_vlc();
		666
		667	/* copy rvmap tables in our context so we can apply changes to them */
		668	memcpy(ctx->rvmap_tabs, ff_ivi_rvmap_tabs, sizeof(ff_ivi_rvmap_tabs));
		669
		670	/* Force allocation of the internal buffers */
		671	/* during picture header decoding. */
		672	ctx->pic_conf.pic_width = 0;
		673	ctx->pic_conf.pic_height = 0;
		674
		675	avctx->pix_fmt = AV_PIX_FMT_YUV410P;
		676
		677	ctx->decode_pic_hdr = decode_pic_hdr;
		678	ctx->decode_band_hdr = decode_band_hdr;
		679	ctx->decode_mb_info = decode_mb_info;
		680	ctx->switch_buffers = switch_buffers;
		681	ctx->is_nonnull_frame = is_nonnull_frame;
		682
		683	return 0;
		684	}
		685
		686
		687	AVCodec ff_indeo4_decoder = {
		688	.name = "indeo4",
		689	.long_name = NULL_IF_CONFIG_SMALL("Intel Indeo Video Interactive 4"),
		690	.type = AVMEDIA_TYPE_VIDEO,
		691	.id = AV_CODEC_ID_INDEO4,
		692	.priv_data_size = sizeof(IVI45DecContext),
		693	.init = decode_init,
		694	.close = ff_ivi_decode_close,
		695	.decode = ff_ivi_decode_frame,
		696	.capabilities = CODEC_CAP_DR1,
		697	};

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/ffmpeg/libavcodec/indeo4.c – Rev 5192