src/utils/mbfunctions.h

/*****************************************************************************
 *
 *  XVID MPEG-4 VIDEO CODEC
 *  - Motion estimation fuctions header file -
 *
 *  Copyright(C) 2002 Michael Militzer <isibaar@xvid.org>
 *
 *  This file is part of XviD, a free MPEG-4 video encoder/decoder
 *
 *  XviD is free software; you can redistribute it and/or modify it
 *  under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 *
 *  Under section 8 of the GNU General Public License, the copyright
 *  holders of XVID explicitly forbid distribution in the following
 *  countries:
 *
 *    - Japan
 *    - United States of America
 *
 *  Linking XviD statically or dynamically with other modules is making a
 *  combined work based on XviD.  Thus, the terms and conditions of the
 *  GNU General Public License cover the whole combination.
 *
 *  As a special exception, the copyright holders of XviD give you
 *  permission to link XviD with independent modules that communicate with
 *  XviD solely through the VFW1.1 and DShow interfaces, regardless of the
 *  license terms of these independent modules, and to copy and distribute
 *  the resulting combined work under terms of your choice, provided that
 *  every copy of the combined work is accompanied by a complete copy of
 *  the source code of XviD (the version of XviD used to produce the
 *  combined work), being distributed under the terms of the GNU General
 *  Public License plus this exception.  An independent module is a module
 *  which is not derived from or based on XviD.
 *
 *  Note that people who make modified versions of XviD are not obligated
 *  to grant this special exception for their modified versions; it is
 *  their choice whether to do so.  The GNU General Public License gives
 *  permission to release a modified version without this exception; this
 *  exception also makes it possible to release a modified version which
 *  carries forward this exception.
 *
 * $Id$
 *
 ****************************************************************************/

#ifndef _MBFUNCTIONS_H
#define _MBFUNCTIONS_H

#include "../encoder.h"
#include "../bitstream/bitstream.h"

/*****************************************************************************
 * Prototypes
 ****************************************************************************/


/* MotionEstimation */

bool MotionEstimation(MBParam * const pParam,
                                          FRAMEINFO * const current,
                                          FRAMEINFO * const reference,
                                          const IMAGE * const pRefH,
                                          const IMAGE * const pRefV,
                                          const IMAGE * const pRefHV,
                                          const uint32_t iLimit);


bool SMP_MotionEstimation(MBParam * const pParam,
                                                  FRAMEINFO * const current,
                                                  FRAMEINFO * const reference,
                                                  const IMAGE * const pRefH,
                                                  const IMAGE * const pRefV,
                                                  const IMAGE * const pRefHV,
                                                  const uint32_t iLimit);


/* MBMotionCompensation */

void MBMotionCompensation(MACROBLOCK * const pMB,
                                                  const uint32_t j,
                                                  const uint32_t i,
                                                  const IMAGE * const pRef,
                                                  const IMAGE * const pRefH,
                                                  const IMAGE * const pRefV,
                                                  const IMAGE * const pRefHV,
                                                  IMAGE * const pCurrent,
                                                  int16_t dct_codes[6 * 64],
                                                  const uint32_t width,
                                                  const uint32_t height,
                                                  const uint32_t edged_width,
                                                  const uint32_t rounding);


/* MBTransQuant.c */

void MBTransQuantIntra(const MBParam * pParam,
                                           FRAMEINFO * frame,
                                           MACROBLOCK * pMB,
                                           const uint32_t x_pos,    /* <-- The x position of the MB to be searched */
                                           const uint32_t y_pos,    /* <-- The y position of the MB to be searched */
                                           int16_t data[6 * 64],    /* <-> the data of the MB to be coded */
                                           int16_t qcoeff[6 * 64]); /* <-> the quantized DCT coefficients */
        

void MBTransQuantIntra2(const MBParam * pParam,
                                                FRAMEINFO * frame,
                                                MACROBLOCK * pMB,
                                                const uint32_t x_pos,    /* <-- The x position of the MB to be searched */
                                                const uint32_t y_pos,    /* <-- The y position of the MB to be searched */
                                                int16_t data[6 * 64],    /* <-> the data of the MB to be coded */
                                                int16_t qcoeff[6 * 64]); /* <-> the quantized DCT coefficients */
        

uint8_t MBTransQuantInter(const MBParam * pParam,
                                                  FRAMEINFO * frame,
                                                  MACROBLOCK * pMB,
                                                  const uint32_t x_pos,
                                                  const uint32_t y_pos,
                                                  int16_t data[6 * 64],
                                                  int16_t qcoeff[6 * 64]);


uint8_t MBTransQuantInter2(const MBParam * pParam,
                                                   FRAMEINFO * frame,
                                                   MACROBLOCK * pMB,
                                                   const uint32_t x_pos,
                                                   const uint32_t y_pos,        
                                                   int16_t data[6 * 64],
                                                   int16_t qcoeff[6 * 64]);

uint8_t MBTransQuantInterBVOP(const MBParam * pParam,
                                                          FRAMEINFO * frame,
                                                          MACROBLOCK * pMB,
                                                          int16_t data[6 * 64],
                                                          int16_t qcoeff[6 * 64]);

void MBTrans(const MBParam * pParam,
                         FRAMEINFO * frame,
                         MACROBLOCK * pMB,
                         const uint32_t x_pos,
                         const uint32_t y_pos,
                         int16_t data[6 * 64]);

void MBfDCT(const MBParam * pParam,
                        FRAMEINFO * frame,
                        MACROBLOCK * pMB,
                        int16_t data[6 * 64]);

uint8_t MBQuantInter(const MBParam * pParam,
                                         const int iQuant,
                                         int16_t data[6 * 64],
                                         int16_t qcoeff[6 * 64]);

void MBQuantDeQuantIntra(const MBParam * pParam,
                                                 FRAMEINFO * frame,
                                                 MACROBLOCK *pMB,
                                                 int16_t qcoeff[6 * 64],
                                                 int16_t data[6*64]);

void MBQuantIntra(const MBParam * pParam,
                                  FRAMEINFO * frame,
                                  MACROBLOCK *pMB,
                                  int16_t data[6*64],
                                  int16_t qcoeff[6 * 64]);

void MBDeQuantIntra(const MBParam * pParam,
                                        const int iQuant,
                                        int16_t qcoeff[6 * 64],
                                        int16_t data[6*64]);

void MBDeQuantInter(const MBParam * pParam,
                                        const int iQuant,
                                        int16_t data[6 * 64],
                                        int16_t qcoeff[6 * 64],
                                        const uint8_t cbp);


void MBiDCT(int16_t data[6 * 64], 
                        const uint8_t cbp);


void MBTransAdd(const MBParam * pParam,
                                FRAMEINFO * frame,
                                MACROBLOCK * pMB,
                                const uint32_t x_pos,
                                const uint32_t y_pos,
                                int16_t data[6 * 64],
                                const uint8_t cbp);


/* interlacing */

uint32_t MBDecideFieldDCT(int16_t data[6 * 64]); /* <- decide whether to use field-based DCT for interlacing */

void MBFrameToField(int16_t data[6 * 64]);       /* de-interlace vertical Y blocks */


/* MBCoding.c */

void MBSkip(Bitstream * bs); /* just the bitstream. Since MB is skipped, no info is needed */


void MBCoding(const FRAMEINFO * frame, /* <-- the parameter for coding of the bitstream */
                          MACROBLOCK * pMB,        /* <-- Info of the MB to be coded */
                          int16_t qcoeff[6 * 64],  /* <-- the quantized DCT coefficients */
                          Bitstream * bs,          /* <-> the bitstream */
                          Statistics * pStat);     /* <-> statistical data collected for current frame */

#endif
Revision:	1.15
Committed:	Sun Nov 17 00:51:10 2002 UTC (21 years, 10 months ago) by edgomez
Content type:	text/plain
Branch:	MAIN
CVS Tags:	release-0_9_0
Changes since 1.14:	+33 -11 lines
Log Message:	License changed
#	User	Rev	Content
1	edgomez	1.11	/*****************************************************************************
2	Isibaar	1.1	*
3	edgomez	1.11	* XVID MPEG-4 VIDEO CODEC
4			* - Motion estimation fuctions header file -
5	Isibaar	1.1	*
6	edgomez	1.14	* Copyright(C) 2002 Michael Militzer <isibaar@xvid.org>
7	Isibaar	1.1	*
8	edgomez	1.15	* This file is part of XviD, a free MPEG-4 video encoder/decoder
9	Isibaar	1.1	*
10	edgomez	1.15	* XviD is free software; you can redistribute it and/or modify it
11			* under the terms of the GNU General Public License as published by
12	edgomez	1.11	* the Free Software Foundation; either version 2 of the License, or
13			* (at your option) any later version.
14			*
15			* This program is distributed in the hope that it will be useful,
16			* but WITHOUT ANY WARRANTY; without even the implied warranty of
17			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18			* GNU General Public License for more details.
19			*
20			* You should have received a copy of the GNU General Public License
21			* along with this program; if not, write to the Free Software
22			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23			*
24	edgomez	1.15	* Under section 8 of the GNU General Public License, the copyright
25			* holders of XVID explicitly forbid distribution in the following
26			* countries:
27			*
28			* - Japan
29			* - United States of America
30			*
31			* Linking XviD statically or dynamically with other modules is making a
32			* combined work based on XviD. Thus, the terms and conditions of the
33			* GNU General Public License cover the whole combination.
34			*
35			* As a special exception, the copyright holders of XviD give you
36			* permission to link XviD with independent modules that communicate with
37			* XviD solely through the VFW1.1 and DShow interfaces, regardless of the
38			* license terms of these independent modules, and to copy and distribute
39			* the resulting combined work under terms of your choice, provided that
40			* every copy of the combined work is accompanied by a complete copy of
41			* the source code of XviD (the version of XviD used to produce the
42			* combined work), being distributed under the terms of the GNU General
43			* Public License plus this exception. An independent module is a module
44			* which is not derived from or based on XviD.
45			*
46			* Note that people who make modified versions of XviD are not obligated
47			* to grant this special exception for their modified versions; it is
48			* their choice whether to do so. The GNU General Public License gives
49			* permission to release a modified version without this exception; this
50			* exception also makes it possible to release a modified version which
51			* carries forward this exception.
52			*
53			* $Id$
54	edgomez	1.11	*
55			****************************************************************************/
56	Isibaar	1.1
57	edgomez	1.11	#ifndef _MBFUNCTIONS_H
58			#define _MBFUNCTIONS_H
59	Isibaar	1.1
60			#include "../encoder.h"
61			#include "../bitstream/bitstream.h"
62
63	edgomez	1.11	/*****************************************************************************
64			* Prototypes
65			****************************************************************************/
66	Isibaar	1.1
67
68	edgomez	1.11	/* MotionEstimation */
69	Isibaar	1.1
70	edgomez	1.6	bool MotionEstimation(MBParam * const pParam,
71			FRAMEINFO * const current,
72			FRAMEINFO * const reference,
73			const IMAGE * const pRefH,
74			const IMAGE * const pRefV,
75			const IMAGE * const pRefHV,
76			const uint32_t iLimit);
77	Isibaar	1.1
78
79	chl	1.7	bool SMP_MotionEstimation(MBParam * const pParam,
80	edgomez	1.11	FRAMEINFO * const current,
81			FRAMEINFO * const reference,
82			const IMAGE * const pRefH,
83			const IMAGE * const pRefV,
84			const IMAGE * const pRefHV,
85			const uint32_t iLimit);
86
87	chl	1.7
88
89	edgomez	1.11	/* MBMotionCompensation */
90	chl	1.7
91	edgomez	1.6	void MBMotionCompensation(MACROBLOCK * const pMB,
92			const uint32_t j,
93			const uint32_t i,
94			const IMAGE * const pRef,
95			const IMAGE * const pRefH,
96			const IMAGE * const pRefV,
97			const IMAGE * const pRefHV,
98			IMAGE * const pCurrent,
99			int16_t dct_codes[6 * 64],
100			const uint32_t width,
101			const uint32_t height,
102			const uint32_t edged_width,
103			const uint32_t rounding);
104	Isibaar	1.1
105
106	edgomez	1.11	/* MBTransQuant.c */
107	Isibaar	1.1
108	edgomez	1.6	void MBTransQuantIntra(const MBParam * pParam,
109			FRAMEINFO * frame,
110			MACROBLOCK * pMB,
111	edgomez	1.11	const uint32_t x_pos, /* <-- The x position of the MB to be searched */
112			const uint32_t y_pos, /* <-- The y position of the MB to be searched */
113			int16_t data[6 * 64], /* <-> the data of the MB to be coded */
114			int16_t qcoeff[6 * 64]); /* <-> the quantized DCT coefficients */
115
116	edgomez	1.6
117
118	chl	1.9	void MBTransQuantIntra2(const MBParam * pParam,
119	edgomez	1.11	FRAMEINFO * frame,
120			MACROBLOCK * pMB,
121			const uint32_t x_pos, /* <-- The x position of the MB to be searched */
122			const uint32_t y_pos, /* <-- The y position of the MB to be searched */
123			int16_t data[6 * 64], /* <-> the data of the MB to be coded */
124			int16_t qcoeff[6 * 64]); /* <-> the quantized DCT coefficients */
125
126	chl	1.9
127
128			uint8_t MBTransQuantInter(const MBParam * pParam,
129			FRAMEINFO * frame,
130			MACROBLOCK * pMB,
131			const uint32_t x_pos,
132			const uint32_t y_pos,
133			int16_t data[6 * 64],
134			int16_t qcoeff[6 * 64]);
135
136
137			uint8_t MBTransQuantInter2(const MBParam * pParam,
138	edgomez	1.11	FRAMEINFO * frame,
139			MACROBLOCK * pMB,
140			const uint32_t x_pos,
141			const uint32_t y_pos,
142			int16_t data[6 * 64],
143			int16_t qcoeff[6 * 64]);
144	chl	1.9
145			uint8_t MBTransQuantInterBVOP(const MBParam * pParam,
146	edgomez	1.11	FRAMEINFO * frame,
147			MACROBLOCK * pMB,
148			int16_t data[6 * 64],
149			int16_t qcoeff[6 * 64]);
150	edgomez	1.6
151	chl	1.9	void MBTrans(const MBParam * pParam,
152	edgomez	1.11	FRAMEINFO * frame,
153			MACROBLOCK * pMB,
154			const uint32_t x_pos,
155			const uint32_t y_pos,
156			int16_t data[6 * 64]);
157	chl	1.9
158			void MBfDCT(const MBParam * pParam,
159			FRAMEINFO * frame,
160			MACROBLOCK * pMB,
161			int16_t data[6 * 64]);
162
163	edgomez	1.11	uint8_t MBQuantInter(const MBParam * pParam,
164			const int iQuant,
165			int16_t data[6 * 64],
166			int16_t qcoeff[6 * 64]);
167	chl	1.9
168			void MBQuantDeQuantIntra(const MBParam * pParam,
169			FRAMEINFO * frame,
170			MACROBLOCK *pMB,
171			int16_t qcoeff[6 * 64],
172			int16_t data[6*64]);
173
174	edgomez	1.11	void MBQuantIntra(const MBParam * pParam,
175			FRAMEINFO * frame,
176			MACROBLOCK *pMB,
177	chl	1.13	int16_t data[6*64],
178			int16_t qcoeff[6 * 64]);
179	edgomez	1.6
180	chl	1.9	void MBDeQuantIntra(const MBParam * pParam,
181			const int iQuant,
182			int16_t qcoeff[6 * 64],
183			int16_t data[6*64]);
184
185			void MBDeQuantInter(const MBParam * pParam,
186			const int iQuant,
187			int16_t data[6 * 64],
188			int16_t qcoeff[6 * 64],
189			const uint8_t cbp);
190
191
192	edgomez	1.12	void MBiDCT(int16_t data[6 * 64],
193	edgomez	1.11	const uint8_t cbp);
194	h	1.2
195
196	edgomez	1.11	void MBTransAdd(const MBParam * pParam,
197			FRAMEINFO * frame,
198			MACROBLOCK * pMB,
199			const uint32_t x_pos,
200			const uint32_t y_pos,
201			int16_t data[6 * 64],
202			const uint8_t cbp);
203	h	1.2
204	Isibaar	1.1
205
206	edgomez	1.11	/* interlacing */
207	Isibaar	1.1
208	edgomez	1.11	uint32_t MBDecideFieldDCT(int16_t data[6 * 64]); /* <- decide whether to use field-based DCT for interlacing */
209	chl	1.8
210	edgomez	1.11	void MBFrameToField(int16_t data[6 * 64]); /* de-interlace vertical Y blocks */
211	chl	1.8
212	edgomez	1.6
213	edgomez	1.11	/* MBCoding.c */
214	edgomez	1.6
215	edgomez	1.11	void MBSkip(Bitstream * bs); /* just the bitstream. Since MB is skipped, no info is needed */
216	edgomez	1.6
217
218	edgomez	1.11	void MBCoding(const FRAMEINFO * frame, /* <-- the parameter for coding of the bitstream */
219			MACROBLOCK * pMB, /* <-- Info of the MB to be coded */
220			int16_t qcoeff[6 * 64], /* <-- the quantized DCT coefficients */
221			Bitstream * bs, /* <-> the bitstream */
222			Statistics * pStat); /* <-> statistical data collected for current frame */
223	Isibaar	1.1
224			#endif