[deb_ffmpeg.git] / ffmpeg / libavcodec / mss12.h

/*
 * Copyright (c) 2012 Konstantin Shishkov
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/**
 * @file
 * Common header for Microsoft Screen 1 and 2
 */

#ifndef AVCODEC_MSS12_H
#define AVCODEC_MSS12_H

#include "libavutil/intreadwrite.h"
#include "avcodec.h"
#include "get_bits.h"
#include "bytestream.h"

#define MODEL_MIN_SYMS    2
#define MODEL_MAX_SYMS  256
#define THRESH_ADAPTIVE  -1
#define THRESH_LOW       15
#define THRESH_HIGH      50

typedef struct Model {
    int16_t cum_prob[MODEL_MAX_SYMS + 1];
    int16_t weights[MODEL_MAX_SYMS + 1];
    uint8_t idx2sym[MODEL_MAX_SYMS + 1];
    int num_syms;
    int thr_weight, threshold;
} Model;

typedef struct ArithCoder {
    int low, high, value;
    union {
        GetBitContext *gb;
        GetByteContext *gB;
    } gbc;
    int (*get_model_sym)(struct ArithCoder *c, Model *m);
    int (*get_number)   (struct ArithCoder *c, int n);
} ArithCoder;

typedef struct PixContext {
    int cache_size, num_syms;
    uint8_t cache[12];
    Model cache_model, full_model;
    Model sec_models[15][4];
    int special_initial_cache;
} PixContext;

struct MSS12Context;

typedef struct SliceContext {
    struct MSS12Context *c;
    Model      intra_region, inter_region;
    Model      pivot, edge_mode, split_mode;
    PixContext intra_pix_ctx, inter_pix_ctx;
} SliceContext;

typedef struct MSS12Context {
    AVCodecContext *avctx;
    uint32_t       pal[256];
    uint8_t        *pal_pic;
    uint8_t        *last_pal_pic;
    int            pal_stride;
    uint8_t        *mask;
    int            mask_stride;
    uint8_t        *rgb_pic;
    uint8_t        *last_rgb_pic;
    int            rgb_stride;
    int            free_colours;
    int            keyframe;
    int            mvX, mvY;
    int            corrupted;
    int            slice_split;
    int            full_model_syms;
} MSS12Context;

int ff_mss12_decode_rect(SliceContext *ctx, ArithCoder *acoder,
                         int x, int y, int width, int height);
void ff_mss12_model_update(Model *m, int val);
void ff_mss12_slicecontext_reset(SliceContext *sc);
int ff_mss12_decode_init(MSS12Context *c, int version,
                         SliceContext *sc1, SliceContext *sc2);
int ff_mss12_decode_end(MSS12Context *ctx);

#define ARITH_GET_BIT(prefix)                                           \
static int prefix ## _get_bit(ArithCoder *c)                            \
{                                                                       \
    int range = c->high - c->low + 1;                                   \
    int bit   = 2 * c->value - c->low >= c->high;                       \
                                                                        \
    if (bit)                                                            \
        c->low += range >> 1;                                           \
    else                                                                \
        c->high = c->low + (range >> 1) - 1;                            \
                                                                        \
    prefix ## _normalise(c);                                            \
                                                                        \
    return bit;                                                         \
}

#define ARITH_GET_MODEL_SYM(prefix)                                     \
static int prefix ## _get_model_sym(ArithCoder *c, Model *m)            \
{                                                                       \
    int idx, val;                                                       \
                                                                        \
    idx = prefix ## _get_prob(c, m->cum_prob);                          \
                                                                        \
    val = m->idx2sym[idx];                                              \
    ff_mss12_model_update(m, idx);                                      \
                                                                        \
    prefix ## _normalise(c);                                            \
                                                                        \
    return val;                                                         \
}

#endif /* AVCODEC_MSS12_H */
Commit	Line	Data
2ba45a60 DM	1	/*
	2	* Copyright (c) 2012 Konstantin Shishkov
	3	*
	4	* This file is part of FFmpeg.
	5	*
	6	* FFmpeg is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU Lesser General Public
	8	* License as published by the Free Software Foundation; either
	9	* version 2.1 of the License, or (at your option) any later version.
	10	*
	11	* FFmpeg is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	* Lesser General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU Lesser General Public
	17	* License along with FFmpeg; if not, write to the Free Software
	18	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	19	*/
	20
	21	/**
	22	* @file
	23	* Common header for Microsoft Screen 1 and 2
	24	*/
	25
	26	#ifndef AVCODEC_MSS12_H
	27	#define AVCODEC_MSS12_H
	28
	29	#include "libavutil/intreadwrite.h"
	30	#include "avcodec.h"
	31	#include "get_bits.h"
	32	#include "bytestream.h"
	33
	34	#define MODEL_MIN_SYMS 2
	35	#define MODEL_MAX_SYMS 256
	36	#define THRESH_ADAPTIVE -1
	37	#define THRESH_LOW 15
	38	#define THRESH_HIGH 50
	39
	40	typedef struct Model {
	41	int16_t cum_prob[MODEL_MAX_SYMS + 1];
	42	int16_t weights[MODEL_MAX_SYMS + 1];
	43	uint8_t idx2sym[MODEL_MAX_SYMS + 1];
	44	int num_syms;
	45	int thr_weight, threshold;
	46	} Model;
	47
	48	typedef struct ArithCoder {
	49	int low, high, value;
	50	union {
	51	GetBitContext *gb;
	52	GetByteContext *gB;
	53	} gbc;
	54	int (get_model_sym)(struct ArithCoder c, Model *m);
	55	int (get_number) (struct ArithCoder c, int n);
	56	} ArithCoder;
	57
	58	typedef struct PixContext {
	59	int cache_size, num_syms;
	60	uint8_t cache[12];
	61	Model cache_model, full_model;
	62	Model sec_models[15][4];
	63	int special_initial_cache;
	64	} PixContext;
65
66	struct MSS12Context;
67
68	typedef struct SliceContext {
69	struct MSS12Context *c;
70	Model intra_region, inter_region;
71	Model pivot, edge_mode, split_mode;
72	PixContext intra_pix_ctx, inter_pix_ctx;
73	} SliceContext;
74
75	typedef struct MSS12Context {
76	AVCodecContext *avctx;
77	uint32_t pal[256];
78	uint8_t *pal_pic;
79	uint8_t *last_pal_pic;
80	int pal_stride;
81	uint8_t *mask;
82	int mask_stride;
83	uint8_t *rgb_pic;
84	uint8_t *last_rgb_pic;
85	int rgb_stride;
86	int free_colours;
87	int keyframe;
88	int mvX, mvY;
89	int corrupted;
90	int slice_split;
91	int full_model_syms;
92	} MSS12Context;
93
94	int ff_mss12_decode_rect(SliceContext ctx, ArithCoder acoder,
95	int x, int y, int width, int height);
96	void ff_mss12_model_update(Model *m, int val);
97	void ff_mss12_slicecontext_reset(SliceContext *sc);
98	int ff_mss12_decode_init(MSS12Context *c, int version,
99	SliceContext sc1, SliceContext sc2);
100	int ff_mss12_decode_end(MSS12Context *ctx);
101
102	#define ARITH_GET_BIT(prefix) \
103	static int prefix ## _get_bit(ArithCoder *c) \
104	{ \
105	int range = c->high - c->low + 1; \
106	int bit = 2 * c->value - c->low >= c->high; \
107	\
108	if (bit) \
109	c->low += range >> 1; \
110	else \
111	c->high = c->low + (range >> 1) - 1; \
112	\
113	prefix ## _normalise(c); \
114	\
115	return bit; \
116	}
117
118	#define ARITH_GET_MODEL_SYM(prefix) \
119	static int prefix ## _get_model_sym(ArithCoder c, Model m) \
120	{ \
121	int idx, val; \
122	\
123	idx = prefix ## _get_prob(c, m->cum_prob); \
124	\
125	val = m->idx2sym[idx]; \
126	ff_mss12_model_update(m, idx); \
127	\
128	prefix ## _normalise(c); \
129	\
130	return val; \
131	}
132
133	#endif /* AVCODEC_MSS12_H */