[cvs] / xvidcore / src / encoder.c Repository:
ViewVC logotype

Annotation of /xvidcore/src/encoder.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.1 - (view) (download)

1 : Isibaar 1.1 #include <stdlib.h>
2 :     #include <stdio.h>
3 :     #include <math.h>
4 :    
5 :     #include "encoder.h"
6 :     #include "prediction/mbprediction.h"
7 :     #include "global.h"
8 :     #include "utils/timer.h"
9 :     #include "image/image.h"
10 :     #include "bitstream/cbp.h"
11 :     #include "utils/mbfunctions.h"
12 :     #include "bitstream/bitstream.h"
13 :     #include "bitstream/mbcoding.h"
14 :     #include "utils/ratecontrol.h"
15 :     #include "utils/emms.h"
16 :     #include "bitstream/mbcoding.h"
17 :     #include "quant/adapt_quant.h"
18 :    
19 :     #define ENC_CHECK(X) if(!(X)) return XVID_ERR_FORMAT
20 :    
21 :    
22 :     static int FrameCodeI(Encoder * pEnc, Bitstream * bs, uint32_t *pBits);
23 :     static int FrameCodeP(Encoder * pEnc, Bitstream * bs, uint32_t *pBits, bool force_inter, bool vol_header);
24 :    
25 :     static int DQtab[4] =
26 :     {
27 :     -1, -2, 1, 2
28 :     };
29 :    
30 :     static int iDQtab[5] =
31 :     {
32 :     1, 0, NO_CHANGE, 2, 3
33 :     };
34 :    
35 :    
36 :     int encoder_create(XVID_ENC_PARAM * pParam)
37 :     {
38 :     Encoder *pEnc;
39 :     uint32_t i;
40 :    
41 :     pParam->handle = NULL;
42 :    
43 :     ENC_CHECK(pParam);
44 :    
45 :     ENC_CHECK(pParam->width > 0 && pParam->width <= 1920);
46 :     ENC_CHECK(pParam->height > 0 && pParam->height <= 1280);
47 :     ENC_CHECK(!(pParam->width % 2));
48 :     ENC_CHECK(!(pParam->height % 2));
49 :    
50 :     if (pParam->fincr <= 0 || pParam->fbase <= 0)
51 :     {
52 :     pParam->fincr = 1;
53 :     pParam->fbase = 25;
54 :     }
55 :    
56 :     // simplify the "fincr/fbase" fraction
57 :     // (neccessary, since windows supplies us with huge numbers)
58 :    
59 :     i = pParam->fincr;
60 :     while (i > 1)
61 :     {
62 :     if (pParam->fincr % i == 0 && pParam->fbase % i == 0)
63 :     {
64 :     pParam->fincr /= i;
65 :     pParam->fbase /= i;
66 :     i = pParam->fincr;
67 :     continue;
68 :     }
69 :     i--;
70 :     }
71 :    
72 :     if (pParam->fbase > 65535)
73 :     {
74 :     float div = (float)pParam->fbase / 65535;
75 :     pParam->fbase = (int)(pParam->fbase / div);
76 :     pParam->fincr = (int)(pParam->fincr / div);
77 :     }
78 :    
79 :     if (pParam->bitrate <= 0)
80 :     pParam->bitrate = 900000;
81 :    
82 :     if (pParam->rc_buffersize <= 0)
83 :     pParam->rc_buffersize = pParam->bitrate * pParam->fbase;
84 :    
85 :     if ((pParam->min_quantizer <= 0) || (pParam->min_quantizer > 31))
86 :     pParam->min_quantizer = 1;
87 :    
88 :     if ((pParam->max_quantizer <= 0) || (pParam->max_quantizer > 31))
89 :     pParam->max_quantizer = 31;
90 :    
91 :     if (pParam->max_key_interval == 0) /* 1 keyframe each 10 seconds */
92 :     pParam->max_key_interval = 10 * pParam->fincr / pParam->fbase;
93 :    
94 :     if (pParam->max_quantizer < pParam->min_quantizer)
95 :     pParam->max_quantizer = pParam->min_quantizer;
96 :    
97 :     if ((pEnc = (Encoder *) malloc(sizeof(Encoder))) == NULL)
98 :     return XVID_ERR_MEMORY;
99 :    
100 :     /* Fill members of Encoder structure */
101 :    
102 :     pEnc->mbParam.width = pParam->width;
103 :     pEnc->mbParam.height = pParam->height;
104 :    
105 :     pEnc->mbParam.mb_width = (pEnc->mbParam.width + 15) / 16;
106 :     pEnc->mbParam.mb_height = (pEnc->mbParam.height + 15) / 16;
107 :    
108 :     pEnc->mbParam.edged_width = 16 * pEnc->mbParam.mb_width + 2 * EDGE_SIZE;
109 :     pEnc->mbParam.edged_height = 16 * pEnc->mbParam.mb_height + 2 * EDGE_SIZE;
110 :    
111 :     pEnc->sStat.fMvPrevSigma = -1;
112 :    
113 :     /* Fill rate control parameters */
114 :    
115 :     pEnc->mbParam.quant = 4;
116 :    
117 :     pEnc->bitrate = pParam->bitrate;
118 :    
119 :     pEnc->iFrameNum = 0;
120 :     pEnc->iMaxKeyInterval = pParam->max_key_interval;
121 :    
122 :     if (image_create(&pEnc->sCurrent, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0)
123 :     {
124 :     free(pEnc);
125 :     return XVID_ERR_MEMORY;
126 :     }
127 :    
128 :     if (image_create(&pEnc->sReference, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0)
129 :     {
130 :     image_destroy(&pEnc->sCurrent, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
131 :     free(pEnc);
132 :     return XVID_ERR_MEMORY;
133 :     }
134 :    
135 :     if (image_create(&pEnc->vInterH, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0)
136 :     {
137 :     image_destroy(&pEnc->sCurrent, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
138 :     image_destroy(&pEnc->sReference, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
139 :     free(pEnc);
140 :     return XVID_ERR_MEMORY;
141 :     }
142 :    
143 :     if (image_create(&pEnc->vInterV, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0)
144 :     {
145 :     image_destroy(&pEnc->sCurrent, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
146 :     image_destroy(&pEnc->sReference, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
147 :     image_destroy(&pEnc->vInterH, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
148 :     free(pEnc);
149 :     return XVID_ERR_MEMORY;
150 :     }
151 :    
152 :     if (image_create(&pEnc->vInterHV, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0)
153 :     {
154 :     image_destroy(&pEnc->sCurrent, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
155 :     image_destroy(&pEnc->sReference, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
156 :     image_destroy(&pEnc->vInterH, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
157 :     image_destroy(&pEnc->vInterV, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
158 :     free(pEnc);
159 :     return XVID_ERR_MEMORY;
160 :     }
161 :    
162 :     pEnc->pMBs = malloc(sizeof(MACROBLOCK) * pEnc->mbParam.mb_width * pEnc->mbParam.mb_height);
163 :     if (pEnc->pMBs == NULL)
164 :     {
165 :     image_destroy(&pEnc->sCurrent, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
166 :     image_destroy(&pEnc->sReference, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
167 :     image_destroy(&pEnc->vInterH, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
168 :     image_destroy(&pEnc->vInterV, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
169 :     image_destroy(&pEnc->vInterHV, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
170 :     free(pEnc);
171 :     return XVID_ERR_MEMORY;
172 :     }
173 :    
174 :     // init macroblock array
175 :     for (i = 0; i < pEnc->mbParam.mb_width * pEnc->mbParam.mb_height; i++)
176 :     {
177 :     pEnc->pMBs[i].dquant = NO_CHANGE;
178 :     }
179 :    
180 :     pParam->handle = (void *)pEnc;
181 :    
182 :     if (pParam->bitrate)
183 :     {
184 :     RateControlInit(pParam->bitrate, pParam->rc_buffersize, pParam->fbase, pParam->width,
185 :     pParam->height, pParam->max_quantizer, pParam->min_quantizer);
186 :     }
187 :    
188 :     create_vlc_tables();
189 :    
190 :     return XVID_ERR_OK;
191 :     }
192 :    
193 :    
194 :     int encoder_destroy(Encoder * pEnc)
195 :     {
196 :     ENC_CHECK(pEnc);
197 :     ENC_CHECK(pEnc->sCurrent.y);
198 :     ENC_CHECK(pEnc->sReference.y);
199 :    
200 :     free(pEnc->pMBs);
201 :     image_destroy(&pEnc->sCurrent, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
202 :     image_destroy(&pEnc->sReference, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
203 :     image_destroy(&pEnc->vInterH, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
204 :     image_destroy(&pEnc->vInterV, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
205 :     image_destroy(&pEnc->vInterHV, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
206 :     free(pEnc);
207 :    
208 :     destroy_vlc_tables();
209 :    
210 :     return XVID_ERR_OK;
211 :     }
212 :    
213 :     int encoder_encode(Encoder * pEnc, XVID_ENC_FRAME * pFrame, XVID_ENC_STATS * pResult)
214 :     {
215 :     uint16_t x, y;
216 :     Bitstream bs;
217 :     uint32_t bits;
218 :     uint16_t quant_type = 0;
219 :     uint16_t quant_change = 0;
220 :    
221 :     IMAGE *pCurrent = &(pEnc->sCurrent);
222 :    
223 :     start_global_timer();
224 :    
225 :     ENC_CHECK(pEnc);
226 :     ENC_CHECK(pFrame);
227 :     ENC_CHECK(pFrame->bitstream);
228 :     ENC_CHECK(pFrame->image);
229 :    
230 :     pEnc->mbParam.global_flags = pFrame->general;
231 :     pEnc->mbParam.motion_flags = pFrame->motion;
232 :    
233 :     start_timer();
234 :     if (image_input(&pEnc->sCurrent, pEnc->mbParam.width, pEnc->mbParam.height, pEnc->mbParam.edged_width,
235 :     pFrame->image, pFrame->colorspace))
236 :     {
237 :     return XVID_ERR_FORMAT;
238 :     }
239 :     stop_conv_timer();
240 :    
241 :     BitstreamInit(&bs, pFrame->bitstream, 0);
242 :    
243 :     if (pFrame->quant == 0)
244 :     {
245 :     pEnc->mbParam.quant = RateControlGetQ(0);
246 :     }
247 :     else
248 :     {
249 :     pEnc->mbParam.quant = pFrame->quant;
250 :     }
251 :    
252 :     if ((pEnc->mbParam.global_flags & XVID_LUMIMASKING) > 0)
253 :     {
254 :     int * temp_dquants = (int *) malloc(pEnc->mbParam.mb_width * pEnc->mbParam.mb_height * sizeof(int));
255 :    
256 :     pEnc->mbParam.quant = adaptive_quantization(pEnc->sCurrent.y, pEnc->mbParam.width,
257 :     temp_dquants, pFrame->quant, pFrame->quant,
258 :     2*pFrame->quant, pEnc->mbParam.mb_width, pEnc->mbParam.mb_height);
259 :    
260 :     for (y = 0; y < pEnc->mbParam.mb_height; y++)
261 :     for (x = 0; x < pEnc->mbParam.mb_width; x++)
262 :     {
263 :     MACROBLOCK *pMB = &pEnc->pMBs[x + y * pEnc->mbParam.mb_width];
264 :     pMB->dquant = iDQtab[(temp_dquants[y * pEnc->mbParam.mb_width + x] + 2)];
265 :     }
266 :     free(temp_dquants);
267 :     }
268 :    
269 :     if(pEnc->mbParam.global_flags & XVID_H263QUANT)
270 :     quant_type = H263_QUANT;
271 :     else if(pEnc->mbParam.global_flags & XVID_MPEGQUANT)
272 :     quant_type = MPEG4_QUANT;
273 :    
274 :     if(pEnc->mbParam.quant_type != quant_type) {
275 :     pEnc->mbParam.quant_type = quant_type;
276 :     quant_change = 1;
277 :     }
278 :     else
279 :     quant_change = 0;
280 :    
281 :    
282 :     if (pFrame->intra < 0)
283 :     {
284 :     if ((pEnc->iFrameNum == 0) || ((pEnc->iMaxKeyInterval > 0)
285 :     && (pEnc->iFrameNum >= pEnc->iMaxKeyInterval)))
286 :    
287 :     pFrame->intra = FrameCodeI(pEnc, &bs, &bits);
288 :     else
289 :     pFrame->intra = FrameCodeP(pEnc, &bs, &bits, 0, quant_change);
290 :     }
291 :     else
292 :     {
293 :     if (pFrame->intra == 1)
294 :     pFrame->intra = FrameCodeI(pEnc, &bs, &bits);
295 :     else
296 :     pFrame->intra = FrameCodeP(pEnc, &bs, &bits, 1, quant_change);
297 :     }
298 :    
299 :     BitstreamPutBits(&bs, 0xFFFF, 16);
300 :     BitstreamPutBits(&bs, 0xFFFF, 16);
301 :     BitstreamPad(&bs);
302 :     pFrame->length = BitstreamLength(&bs);
303 :    
304 :     if (pResult)
305 :     {
306 :     pResult->quant = pEnc->mbParam.quant;
307 :     pResult->hlength = pFrame->length - (pEnc->sStat.iTextBits / 8);
308 :     pResult->kblks = pEnc->sStat.kblks;
309 :     pResult->mblks = pEnc->sStat.mblks;
310 :     pResult->ublks = pEnc->sStat.ublks;
311 :     }
312 :    
313 :     if (pEnc->bitrate)
314 :     {
315 :     RateControlUpdate(pEnc->mbParam.quant, pFrame->length, pFrame->intra);
316 :     }
317 :    
318 :     pEnc->iFrameNum++;
319 :     image_swap(&pEnc->sCurrent, &pEnc->sReference);
320 :    
321 :     stop_global_timer();
322 :     write_timer();
323 :    
324 :     return XVID_ERR_OK;
325 :     }
326 :    
327 :    
328 :     static __inline void CodeIntraMB(Encoder *pEnc, MACROBLOCK *pMB) {
329 :    
330 :     pMB->mode = MODE_INTRA;
331 :    
332 :     if ((pEnc->mbParam.global_flags & XVID_LUMIMASKING) > 0) {
333 :     if(pMB->dquant != NO_CHANGE)
334 :     {
335 :     pMB->mode = MODE_INTRA_Q;
336 :     pEnc->mbParam.quant += DQtab[pMB->dquant];
337 :    
338 :     if (pEnc->mbParam.quant > 31) pEnc->mbParam.quant = 31;
339 :     if (pEnc->mbParam.quant < 1) pEnc->mbParam.quant = 1;
340 :     }
341 :     }
342 :    
343 :     pMB->quant = pEnc->mbParam.quant;
344 :     }
345 :    
346 :    
347 :     static int FrameCodeI(Encoder * pEnc, Bitstream * bs, uint32_t *pBits)
348 :     {
349 :     int16_t dct_codes[6][64];
350 :     int16_t qcoeff[6][64];
351 :     uint16_t x, y;
352 :     IMAGE *pCurrent = &pEnc->sCurrent;
353 :    
354 :     pEnc->iFrameNum = 0;
355 :     pEnc->mbParam.rounding_type = 1;
356 :     pEnc->mbParam.coding_type = I_VOP;
357 :    
358 :     BitstreamWriteVolHeader(bs, pEnc->mbParam.width, pEnc->mbParam.height, pEnc->mbParam.quant_type);
359 :     BitstreamWriteVopHeader(bs, I_VOP, pEnc->mbParam.rounding_type,
360 :     pEnc->mbParam.quant,
361 :     pEnc->mbParam.fixed_code);
362 :    
363 :     *pBits = BitstreamPos(bs);
364 :    
365 :     pEnc->sStat.iTextBits = 0;
366 :     pEnc->sStat.kblks = pEnc->mbParam.mb_width * pEnc->mbParam.mb_height;
367 :     pEnc->sStat.mblks = pEnc->sStat.ublks = 0;
368 :    
369 :     for (y = 0; y < pEnc->mbParam.mb_height; y++)
370 :     for (x = 0; x < pEnc->mbParam.mb_width; x++)
371 :     {
372 :     MACROBLOCK *pMB = &pEnc->pMBs[x + y * pEnc->mbParam.mb_width];
373 :    
374 :     CodeIntraMB(pEnc, pMB);
375 :    
376 :     MBTransQuantIntra(&pEnc->mbParam, x, y, dct_codes, qcoeff, pCurrent);
377 :    
378 :     start_timer();
379 :     MBPrediction(&pEnc->mbParam, x, y, pEnc->mbParam.mb_width, qcoeff, pEnc->pMBs);
380 :     stop_prediction_timer();
381 :    
382 :     start_timer();
383 :     MBCoding(&pEnc->mbParam, pMB, qcoeff, bs, &pEnc->sStat);
384 :     stop_coding_timer();
385 :     }
386 :    
387 :     emms();
388 :    
389 :     *pBits = BitstreamPos(bs) - *pBits;
390 :     pEnc->sStat.fMvPrevSigma = -1;
391 :     pEnc->sStat.iMvSum = 0;
392 :     pEnc->sStat.iMvCount = 0;
393 :     pEnc->mbParam.fixed_code = 2;
394 :    
395 :     return 1; // intra
396 :     }
397 :    
398 :    
399 :     #define INTRA_THRESHOLD 0.5
400 :    
401 :     static int FrameCodeP(Encoder * pEnc, Bitstream * bs, uint32_t *pBits, bool force_inter, bool vol_header)
402 :     {
403 :     float fSigma;
404 :     int16_t dct_codes[6][64];
405 :     int16_t qcoeff[6][64];
406 :     int iLimit;
407 :     uint32_t x, y;
408 :     int iSearchRange;
409 :     bool bIntra;
410 :    
411 :     IMAGE *pCurrent = &pEnc->sCurrent;
412 :     IMAGE *pRef = &pEnc->sReference;
413 :    
414 :     image_setedges(pRef,pEnc->mbParam.edged_width, pEnc->mbParam.edged_height, pEnc->mbParam.width, pEnc->mbParam.height);
415 :    
416 :     pEnc->mbParam.rounding_type = 1 - pEnc->mbParam.rounding_type;
417 :    
418 :     if (!force_inter)
419 :     iLimit = (int)(pEnc->mbParam.mb_width * pEnc->mbParam.mb_height * INTRA_THRESHOLD);
420 :     else
421 :     iLimit = pEnc->mbParam.mb_width * pEnc->mbParam.mb_height + 1;
422 :    
423 :     if ((pEnc->mbParam.global_flags & XVID_HALFPEL) > 0) {
424 :     start_timer();
425 :     image_interpolate(pRef, &pEnc->vInterH, &pEnc->vInterV, &pEnc->vInterHV,
426 :     pEnc->mbParam.edged_width, pEnc->mbParam.edged_height,
427 :     pEnc->mbParam.rounding_type);
428 :     stop_inter_timer();
429 :     }
430 :    
431 :     start_timer();
432 :     bIntra = MotionEstimation(pEnc->pMBs, &pEnc->mbParam, &pEnc->sReference,
433 :     &pEnc->vInterH, &pEnc->vInterV,
434 :     &pEnc->vInterHV, &pEnc->sCurrent, iLimit);
435 :     stop_motion_timer();
436 :    
437 :     if (bIntra == 1)
438 :     return FrameCodeI(pEnc, bs, pBits);
439 :    
440 :     pEnc->mbParam.coding_type = P_VOP;
441 :    
442 :     if(vol_header)
443 :     BitstreamWriteVolHeader(bs, pEnc->mbParam.width, pEnc->mbParam.height, pEnc->mbParam.quant_type);
444 :    
445 :     BitstreamWriteVopHeader(bs, P_VOP, pEnc->mbParam.rounding_type,
446 :     pEnc->mbParam.quant,
447 :     pEnc->mbParam.fixed_code);
448 :    
449 :     *pBits = BitstreamPos(bs);
450 :    
451 :     pEnc->sStat.iTextBits = 0;
452 :     pEnc->sStat.iMvSum = 0;
453 :     pEnc->sStat.iMvCount = 0;
454 :     pEnc->sStat.kblks = pEnc->sStat.mblks = pEnc->sStat.ublks = 0;
455 :    
456 :     for(y = 0; y < pEnc->mbParam.mb_height; y++)
457 :     {
458 :     for(x = 0; x < pEnc->mbParam.mb_width; x++)
459 :     {
460 :     MACROBLOCK * pMB = &pEnc->pMBs[x + y * pEnc->mbParam.mb_width];
461 :    
462 :     bIntra = (pMB->mode == MODE_INTRA) || (pMB->mode == MODE_INTRA_Q);
463 :    
464 :     if (!bIntra)
465 :     {
466 :     start_timer();
467 :     MBMotionCompensation(pMB, x, y, &pEnc->sReference,
468 :     &pEnc->vInterH, &pEnc->vInterV,
469 :     &pEnc->vInterHV, &pEnc->sCurrent, dct_codes,
470 :     pEnc->mbParam.width,
471 :     pEnc->mbParam.height,
472 :     pEnc->mbParam.edged_width,
473 :     pEnc->mbParam.rounding_type);
474 :     stop_comp_timer();
475 :    
476 :     if ((pEnc->mbParam.global_flags & XVID_LUMIMASKING) > 0) {
477 :     if(pMB->dquant != NO_CHANGE) {
478 :     pMB->mode = MODE_INTER_Q;
479 :     pEnc->mbParam.quant += DQtab[pMB->dquant];
480 :     if (pEnc->mbParam.quant > 31) pEnc->mbParam.quant = 31;
481 :     else if(pEnc->mbParam.quant < 1) pEnc->mbParam.quant = 1;
482 :     }
483 :     }
484 :     pMB->quant = pEnc->mbParam.quant;
485 :    
486 :     pMB->cbp = MBTransQuantInter(&pEnc->mbParam, x, y, dct_codes, qcoeff, pCurrent);
487 :     }
488 :     else
489 :     {
490 :     CodeIntraMB(pEnc, pMB);
491 :     MBTransQuantIntra(&pEnc->mbParam, x, y, dct_codes, qcoeff, pCurrent);
492 :     }
493 :    
494 :     start_timer();
495 :     MBPrediction(&pEnc->mbParam, x, y, pEnc->mbParam.mb_width, qcoeff, pEnc->pMBs);
496 :     stop_prediction_timer();
497 :    
498 :     if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q)
499 :     {
500 :     pEnc->sStat.kblks++;
501 :     }
502 :     else if (pMB->cbp ||
503 :     pMB->mvs[0].x || pMB->mvs[0].y ||
504 :     pMB->mvs[1].x || pMB->mvs[1].y ||
505 :     pMB->mvs[2].x || pMB->mvs[2].y ||
506 :     pMB->mvs[3].x || pMB->mvs[3].y)
507 :     {
508 :     pEnc->sStat.mblks++;
509 :     }
510 :     else
511 :     {
512 :     pEnc->sStat.ublks++;
513 :     }
514 :    
515 :     start_timer();
516 :     MBCoding(&pEnc->mbParam, pMB, qcoeff, bs, &pEnc->sStat);
517 :     stop_coding_timer();
518 :     }
519 :     }
520 :    
521 :     emms();
522 :    
523 :     if (pEnc->sStat.iMvCount == 0)
524 :     pEnc->sStat.iMvCount = 1;
525 :    
526 :     fSigma = (float)sqrt((float) pEnc->sStat.iMvSum / pEnc->sStat.iMvCount);
527 :    
528 :     iSearchRange = 1 << (3 + pEnc->mbParam.fixed_code);
529 :    
530 :     if ((fSigma > iSearchRange / 3)
531 :     && (pEnc->mbParam.fixed_code <= 3)) // maximum search range 128
532 :     {
533 :     pEnc->mbParam.fixed_code++;
534 :     iSearchRange *= 2;
535 :     }
536 :     else if ((fSigma < iSearchRange / 6)
537 :     && (pEnc->sStat.fMvPrevSigma >= 0)
538 :     && (pEnc->sStat.fMvPrevSigma < iSearchRange / 6)
539 :     && (pEnc->mbParam.fixed_code >= 2)) // minimum search range 16
540 :     {
541 :     pEnc->mbParam.fixed_code--;
542 :     iSearchRange /= 2;
543 :     }
544 :    
545 :     pEnc->sStat.fMvPrevSigma = fSigma;
546 :    
547 :     *pBits = BitstreamPos(bs) - *pBits;
548 :    
549 :     return 0; // inter
550 :     }

No admin address has been configured
ViewVC Help
Powered by ViewVC 1.0.4