Parent Directory | Revision Log
Revision 1142 - (view) (download)
1 : | edgomez | 1142 | /***************************************************************************** |
2 : | * | ||
3 : | * XVID MPEG-4 VIDEO CODEC | ||
4 : | * - ME-based Frame Type Decision - | ||
5 : | * | ||
6 : | * Copyright(C) 2002-2003 Radoslaw Czyz <xvid@syskin.cjb.net> | ||
7 : | * | ||
8 : | * This program is free software ; you can redistribute it and/or modify | ||
9 : | * it under the terms of the GNU General Public License as published by | ||
10 : | * the Free Software Foundation ; either version 2 of the License, or | ||
11 : | * (at your option) any later version. | ||
12 : | * | ||
13 : | * This program is distributed in the hope that it will be useful, | ||
14 : | * but WITHOUT ANY WARRANTY ; without even the implied warranty of | ||
15 : | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
16 : | * GNU General Public License for more details. | ||
17 : | * | ||
18 : | * You should have received a copy of the GNU General Public License | ||
19 : | * along with this program ; if not, write to the Free Software | ||
20 : | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
21 : | * | ||
22 : | * $Id: vop_type_decision.c,v 1.1.2.1 2003-09-10 22:19:00 edgomez Exp $ | ||
23 : | * | ||
24 : | ****************************************************************************/ | ||
25 : | |||
26 : | #include "../encoder.h" | ||
27 : | #include "../prediction/mbprediction.h" | ||
28 : | #include "estimation.h" | ||
29 : | #include "motion.h" | ||
30 : | #include "sad.h" | ||
31 : | #include "gmc.h" | ||
32 : | #include "../utils/emms.h" | ||
33 : | #include "motion_inlines.h" | ||
34 : | |||
35 : | |||
36 : | #define INTRA_THRESH 2200 | ||
37 : | #define INTER_THRESH 40 | ||
38 : | #define INTRA_THRESH2 95 | ||
39 : | |||
40 : | static void | ||
41 : | CheckCandidate32I(const int x, const int y, const SearchData * const data, const unsigned int Direction) | ||
42 : | { | ||
43 : | /* maximum speed */ | ||
44 : | int32_t sad; | ||
45 : | |||
46 : | if ( (x > data->max_dx) || (x < data->min_dx) | ||
47 : | || (y > data->max_dy) || (y < data->min_dy) ) return; | ||
48 : | |||
49 : | sad = sad32v_c(data->Cur, data->RefP[0] + x + y*((int)data->iEdgedWidth), | ||
50 : | data->iEdgedWidth, data->temp); | ||
51 : | |||
52 : | if (sad < *(data->iMinSAD)) { | ||
53 : | *(data->iMinSAD) = sad; | ||
54 : | data->currentMV[0].x = x; data->currentMV[0].y = y; | ||
55 : | *data->dir = Direction; | ||
56 : | } | ||
57 : | if (data->temp[0] < data->iMinSAD[1]) { | ||
58 : | data->iMinSAD[1] = data->temp[0]; data->currentMV[1].x = x; data->currentMV[1].y = y; } | ||
59 : | if (data->temp[1] < data->iMinSAD[2]) { | ||
60 : | data->iMinSAD[2] = data->temp[1]; data->currentMV[2].x = x; data->currentMV[2].y = y; } | ||
61 : | if (data->temp[2] < data->iMinSAD[3]) { | ||
62 : | data->iMinSAD[3] = data->temp[2]; data->currentMV[3].x = x; data->currentMV[3].y = y; } | ||
63 : | if (data->temp[3] < data->iMinSAD[4]) { | ||
64 : | data->iMinSAD[4] = data->temp[3]; data->currentMV[4].x = x; data->currentMV[4].y = y; } | ||
65 : | } | ||
66 : | |||
67 : | static __inline void | ||
68 : | MEanalyzeMB ( const uint8_t * const pRef, | ||
69 : | const uint8_t * const pCur, | ||
70 : | const int x, | ||
71 : | const int y, | ||
72 : | const MBParam * const pParam, | ||
73 : | MACROBLOCK * const pMBs, | ||
74 : | SearchData * const Data) | ||
75 : | { | ||
76 : | |||
77 : | int i; | ||
78 : | VECTOR pmv[3]; | ||
79 : | MACROBLOCK * const pMB = &pMBs[x + y * pParam->mb_width]; | ||
80 : | |||
81 : | unsigned int simplicity = 0; | ||
82 : | |||
83 : | for (i = 0; i < 5; i++) Data->iMinSAD[i] = MV_MAX_ERROR; | ||
84 : | |||
85 : | get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 4, | ||
86 : | pParam->width, pParam->height, Data->iFcode - Data->qpel - 1, 0, 0); | ||
87 : | |||
88 : | Data->Cur = pCur + (x + y * pParam->edged_width) * 16; | ||
89 : | Data->RefP[0] = pRef + (x + y * pParam->edged_width) * 16; | ||
90 : | |||
91 : | pmv[0].x = pMB->mvs[0].x; | ||
92 : | pmv[0].y = pMB->mvs[0].y; | ||
93 : | |||
94 : | CheckCandidate32I(pmv[0].x, pmv[0].y, Data, 0); | ||
95 : | |||
96 : | if (*Data->iMinSAD > 200) { | ||
97 : | |||
98 : | pmv[1].x = pmv[1].y = 0; | ||
99 : | |||
100 : | /* median is only used as prediction. it doesn't have to be real */ | ||
101 : | if (x == 1 && y == 1) Data->predMV.x = Data->predMV.y = 0; | ||
102 : | else | ||
103 : | if (x == 1) /* left macroblock does not have any vector now */ | ||
104 : | Data->predMV = (pMB - pParam->mb_width)->mvs[0]; /* top instead of median */ | ||
105 : | else if (y == 1) /* top macroblock doesn't have it's vector */ | ||
106 : | Data->predMV = (pMB - 1)->mvs[0]; /* left instead of median */ | ||
107 : | else Data->predMV = get_pmv2(pMBs, pParam->mb_width, 0, x, y, 0); /* else median */ | ||
108 : | |||
109 : | pmv[2].x = Data->predMV.x; | ||
110 : | pmv[2].y = Data->predMV.y; | ||
111 : | |||
112 : | if (!vector_repeats(pmv, 1)) | ||
113 : | CheckCandidate32I(pmv[1].x, pmv[1].y, Data, 1); | ||
114 : | if (!vector_repeats(pmv, 2)) | ||
115 : | CheckCandidate32I(pmv[2].x, pmv[2].y, Data, 2); | ||
116 : | |||
117 : | if (*Data->iMinSAD > 500) { /* diamond only if needed */ | ||
118 : | unsigned int mask = make_mask(pmv, 3, *Data->dir); | ||
119 : | xvid_me_DiamondSearch(Data->currentMV->x, Data->currentMV->y, Data, mask, CheckCandidate32I); | ||
120 : | } else simplicity++; | ||
121 : | |||
122 : | if (*Data->iMinSAD > 500) /* refinement from 2-pixel to 1-pixel */ | ||
123 : | xvid_me_SubpelRefine(Data, CheckCandidate32I); | ||
124 : | else simplicity++; | ||
125 : | } else simplicity++; | ||
126 : | |||
127 : | for (i = 0; i < 4; i++) { | ||
128 : | MACROBLOCK * MB = &pMBs[x + (i&1) + (y+(i>>1)) * pParam->mb_width]; | ||
129 : | MB->mvs[0] = MB->mvs[1] = MB->mvs[2] = MB->mvs[3] = Data->currentMV[i]; | ||
130 : | MB->mode = MODE_INTER; | ||
131 : | /* if we skipped some search steps, we have to assume that SAD would be lower with them */ | ||
132 : | MB->sad16 = Data->iMinSAD[i+1] - (simplicity<<7); | ||
133 : | } | ||
134 : | } | ||
135 : | |||
136 : | int | ||
137 : | MEanalysis( const IMAGE * const pRef, | ||
138 : | const FRAMEINFO * const Current, | ||
139 : | const MBParam * const pParam, | ||
140 : | const int maxIntra, //maximum number if non-I frames | ||
141 : | const int intraCount, //number of non-I frames after last I frame; 0 if we force P/B frame | ||
142 : | const int bCount, // number of B frames in a row | ||
143 : | const int b_thresh) | ||
144 : | { | ||
145 : | uint32_t x, y, intra = 0; | ||
146 : | int sSAD = 0; | ||
147 : | MACROBLOCK * const pMBs = Current->mbs; | ||
148 : | const IMAGE * const pCurrent = &Current->image; | ||
149 : | int IntraThresh = INTRA_THRESH, InterThresh = INTER_THRESH + b_thresh; | ||
150 : | int blocks = 0; | ||
151 : | int complexity = 0; | ||
152 : | |||
153 : | int32_t iMinSAD[5], temp[5]; | ||
154 : | uint32_t dir; | ||
155 : | VECTOR currentMV[5]; | ||
156 : | SearchData Data; | ||
157 : | Data.iEdgedWidth = pParam->edged_width; | ||
158 : | Data.currentMV = currentMV; | ||
159 : | Data.iMinSAD = iMinSAD; | ||
160 : | Data.iFcode = Current->fcode; | ||
161 : | Data.temp = temp; | ||
162 : | Data.dir = &dir; | ||
163 : | Data.qpel = (pParam->vol_flags & XVID_VOL_QUARTERPEL)? 1: 0; | ||
164 : | Data.qpel_precision = 0; | ||
165 : | |||
166 : | if (intraCount != 0) { | ||
167 : | if (intraCount < 10) // we're right after an I frame | ||
168 : | IntraThresh += 15* (intraCount - 10) * (intraCount - 10); | ||
169 : | else | ||
170 : | if ( 5*(maxIntra - intraCount) < maxIntra) // we're close to maximum. 2 sec when max is 10 sec | ||
171 : | IntraThresh -= (IntraThresh * (maxIntra - 8*(maxIntra - intraCount)))/maxIntra; | ||
172 : | } | ||
173 : | |||
174 : | InterThresh -= 20 * bCount; | ||
175 : | if (InterThresh < 10 + b_thresh) InterThresh = 10 + b_thresh; | ||
176 : | |||
177 : | if (sadInit) (*sadInit) (); | ||
178 : | |||
179 : | for (y = 1; y < pParam->mb_height-1; y += 2) { | ||
180 : | for (x = 1; x < pParam->mb_width-1; x += 2) { | ||
181 : | int i; | ||
182 : | blocks += 10; | ||
183 : | |||
184 : | if (bCount == 0) pMBs[x + y * pParam->mb_width].mvs[0] = zeroMV; | ||
185 : | else { //extrapolation of the vector found for last frame | ||
186 : | pMBs[x + y * pParam->mb_width].mvs[0].x = | ||
187 : | (pMBs[x + y * pParam->mb_width].mvs[0].x * (bCount+1) ) / bCount; | ||
188 : | pMBs[x + y * pParam->mb_width].mvs[0].y = | ||
189 : | (pMBs[x + y * pParam->mb_width].mvs[0].y * (bCount+1) ) / bCount; | ||
190 : | } | ||
191 : | |||
192 : | MEanalyzeMB(pRef->y, pCurrent->y, x, y, pParam, pMBs, &Data); | ||
193 : | |||
194 : | for (i = 0; i < 4; i++) { | ||
195 : | int dev; | ||
196 : | MACROBLOCK *pMB = &pMBs[x+(i&1) + (y+(i>>1)) * pParam->mb_width]; | ||
197 : | dev = dev16(pCurrent->y + (x + (i&1) + (y + (i>>1)) * pParam->edged_width) * 16, | ||
198 : | pParam->edged_width); | ||
199 : | |||
200 : | complexity += MAX(dev, 300); | ||
201 : | if (dev + IntraThresh < pMB->sad16) { | ||
202 : | pMB->mode = MODE_INTRA; | ||
203 : | if (++intra > ((pParam->mb_height-2)*(pParam->mb_width-2))/2) return I_VOP; | ||
204 : | } | ||
205 : | |||
206 : | if (pMB->mvs[0].x == 0 && pMB->mvs[0].y == 0) | ||
207 : | if (dev > 1000 && pMB->sad16 < 1000) | ||
208 : | sSAD += 1000; | ||
209 : | |||
210 : | sSAD += (dev < 4000) ? pMB->sad16 : pMB->sad16/2; /* blocks with big contrast differences usually have large SAD - while they look very good in b-frames */ | ||
211 : | } | ||
212 : | } | ||
213 : | } | ||
214 : | complexity >>= 7; | ||
215 : | |||
216 : | sSAD /= complexity + 4*blocks; | ||
217 : | |||
218 : | if (intraCount > 80 && sSAD > INTRA_THRESH2 ) return I_VOP; | ||
219 : | if (sSAD > InterThresh ) return P_VOP; | ||
220 : | emms(); | ||
221 : | return B_VOP; | ||
222 : | } |
No admin address has been configured | ViewVC Help |
Powered by ViewVC 1.0.4 |