[svn] / branches / dev-api-3 / xvidcore / src / encoder.c Repository:
ViewVC logotype

Annotation of /branches/dev-api-3/xvidcore/src/encoder.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 572 - (view) (download)

1 : edgomez 194 /*****************************************************************************
2 : edgomez 145 *
3 :     * XVID MPEG-4 VIDEO CODEC
4 :     * - Encoder main module -
5 :     *
6 :     * This program is an implementation of a part of one or more MPEG-4
7 :     * Video tools as specified in ISO/IEC 14496-2 standard. Those intending
8 :     * to use this software module in hardware or software products are
9 :     * advised that its use may infringe existing patents or copyrights, and
10 :     * any such use would be at such party's own risk. The original
11 :     * developer of this software module and his/her company, and subsequent
12 :     * editors and their companies, will have no liability for use of this
13 :     * software or modifications or derivatives thereof.
14 :     *
15 :     * This program is free software; you can redistribute it and/or modify
16 :     * it under the terms of the GNU General Public License as published by
17 :     * the Free Software Foundation; either version 2 of the License, or
18 :     * (at your option) any later version.
19 :     *
20 :     * This program is distributed in the hope that it will be useful,
21 :     * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 :     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 :     * GNU General Public License for more details.
24 :     *
25 :     * You should have received a copy of the GNU General Public License
26 :     * along with this program; if not, write to the Free Software
27 :     * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 :     *
29 : edgomez 194 ****************************************************************************/
30 : suxen_drol 118
31 : edgomez 194 /*****************************************************************************
32 : edgomez 145 *
33 :     * History
34 :     *
35 : chenm001 290 * 10.07.2002 added BFRAMES_DEC_DEBUG support
36 :     * MinChen <chenm001@163.com>
37 :     * 20.06.2002 bframe patch
38 : chenm001 168 * 08.05.2002 fix some problem in DEBUG mode;
39 :     * MinChen <chenm001@163.com>
40 : edgomez 145 * 14.04.2002 added FrameCodeB()
41 :     *
42 : chl 572 * $Id: encoder.c,v 1.76.2.7 2002-09-30 09:19:26 chl Exp $
43 : edgomez 145 *
44 : edgomez 194 ****************************************************************************/
45 : edgomez 145
46 : chl 340
47 : Isibaar 3 #include <stdlib.h>
48 :     #include <stdio.h>
49 :     #include <math.h>
50 : edgomez 198 #include <string.h>
51 : Isibaar 3
52 :     #include "encoder.h"
53 :     #include "prediction/mbprediction.h"
54 :     #include "global.h"
55 :     #include "utils/timer.h"
56 :     #include "image/image.h"
57 : suxen_drol 238 #ifdef BFRAMES
58 :     #include "image/font.h"
59 : chl 347 #include "motion/sad.h"
60 : suxen_drol 238 #endif
61 : suxen_drol 152 #include "motion/motion.h"
62 : Isibaar 3 #include "bitstream/cbp.h"
63 :     #include "utils/mbfunctions.h"
64 :     #include "bitstream/bitstream.h"
65 :     #include "bitstream/mbcoding.h"
66 :     #include "utils/ratecontrol.h"
67 :     #include "utils/emms.h"
68 :     #include "bitstream/mbcoding.h"
69 :     #include "quant/adapt_quant.h"
70 : Isibaar 4 #include "quant/quant_matrix.h"
71 : Isibaar 41 #include "utils/mem_align.h"
72 : Isibaar 3
73 : edgomez 194 /*****************************************************************************
74 :     * Local macros
75 :     ****************************************************************************/
76 :    
77 : Isibaar 3 #define ENC_CHECK(X) if(!(X)) return XVID_ERR_FORMAT
78 : suxen_drol 136 #define SWAP(A,B) { void * tmp = A; A = B; B = tmp; }
79 : Isibaar 3
80 : edgomez 194 /*****************************************************************************
81 :     * Local function prototypes
82 :     ****************************************************************************/
83 :    
84 : edgomez 192 static int FrameCodeI(Encoder * pEnc,
85 : edgomez 195 Bitstream * bs,
86 :     uint32_t * pBits);
87 : Isibaar 3
88 : edgomez 192 static int FrameCodeP(Encoder * pEnc,
89 : edgomez 195 Bitstream * bs,
90 :     uint32_t * pBits,
91 :     bool force_inter,
92 :     bool vol_header);
93 : Isibaar 3
94 : edgomez 192 static void FrameCodeB(Encoder * pEnc,
95 : edgomez 195 FRAMEINFO * frame,
96 :     Bitstream * bs,
97 :     uint32_t * pBits);
98 : edgomez 192
99 : edgomez 194 /*****************************************************************************
100 :     * Local data
101 :     ****************************************************************************/
102 :    
103 : edgomez 195 static int DQtab[4] = {
104 : Isibaar 3 -1, -2, 1, 2
105 :     };
106 :    
107 : edgomez 195 static int iDQtab[5] = {
108 : Isibaar 3 1, 0, NO_CHANGE, 2, 3
109 :     };
110 :    
111 :    
112 : edgomez 195 static void __inline
113 :     image_null(IMAGE * image)
114 : suxen_drol 136 {
115 :     image->y = image->u = image->v = NULL;
116 :     }
117 :    
118 :    
119 : edgomez 194 /*****************************************************************************
120 :     * Encoder creation
121 :     *
122 :     * This function creates an Encoder instance, it allocates all necessary
123 :     * image buffers (reference, current and bframes) and initialize the internal
124 :     * xvid encoder paremeters according to the XVID_ENC_PARAM input parameter.
125 :     *
126 :     * The code seems to be very long but is very basic, mainly memory allocation
127 :     * and cleaning code.
128 :     *
129 :     * Returned values :
130 :     * - XVID_ERR_OK - no errors
131 :     * - XVID_ERR_MEMORY - the libc could not allocate memory, the function
132 :     * cleans the structure before exiting.
133 :     * pParam->handle is also set to NULL.
134 :     *
135 :     ****************************************************************************/
136 :    
137 :     int
138 :     encoder_create(XVID_ENC_PARAM * pParam)
139 : Isibaar 3 {
140 : edgomez 13 Encoder *pEnc;
141 : suxen_drol 229 int i;
142 : Isibaar 3
143 : edgomez 13 pParam->handle = NULL;
144 : Isibaar 3
145 : edgomez 13 ENC_CHECK(pParam);
146 : Isibaar 3
147 : edgomez 13 ENC_CHECK(pParam->width > 0 && pParam->width <= 1920);
148 :     ENC_CHECK(pParam->height > 0 && pParam->height <= 1280);
149 :     ENC_CHECK(!(pParam->width % 2));
150 :     ENC_CHECK(!(pParam->height % 2));
151 : Isibaar 3
152 : edgomez 192 /* Fps */
153 :    
154 : edgomez 195 if (pParam->fincr <= 0 || pParam->fbase <= 0) {
155 : Isibaar 3 pParam->fincr = 1;
156 :     pParam->fbase = 25;
157 :     }
158 :    
159 : edgomez 192 /*
160 :     * Simplify the "fincr/fbase" fraction
161 :     * (neccessary, since windows supplies us with huge numbers)
162 :     */
163 : Isibaar 3
164 :     i = pParam->fincr;
165 : edgomez 195 while (i > 1) {
166 :     if (pParam->fincr % i == 0 && pParam->fbase % i == 0) {
167 : Isibaar 3 pParam->fincr /= i;
168 :     pParam->fbase /= i;
169 :     i = pParam->fincr;
170 :     continue;
171 :     }
172 :     i--;
173 :     }
174 :    
175 : edgomez 195 if (pParam->fbase > 65535) {
176 :     float div = (float) pParam->fbase / 65535;
177 :    
178 :     pParam->fbase = (int) (pParam->fbase / div);
179 :     pParam->fincr = (int) (pParam->fincr / div);
180 : Isibaar 3 }
181 :    
182 : edgomez 192 /* Bitrate allocator defaults */
183 :    
184 : h 121 if (pParam->rc_bitrate <= 0)
185 :     pParam->rc_bitrate = 900000;
186 : Isibaar 3
187 : h 121 if (pParam->rc_reaction_delay_factor <= 0)
188 :     pParam->rc_reaction_delay_factor = 16;
189 : Isibaar 3
190 : h 121 if (pParam->rc_averaging_period <= 0)
191 :     pParam->rc_averaging_period = 100;
192 :    
193 :     if (pParam->rc_buffer <= 0)
194 :     pParam->rc_buffer = 100;
195 :    
196 : edgomez 192 /* Max and min quantizers */
197 :    
198 : edgomez 13 if ((pParam->min_quantizer <= 0) || (pParam->min_quantizer > 31))
199 : Isibaar 3 pParam->min_quantizer = 1;
200 :    
201 : edgomez 13 if ((pParam->max_quantizer <= 0) || (pParam->max_quantizer > 31))
202 : Isibaar 3 pParam->max_quantizer = 31;
203 :    
204 : edgomez 13 if (pParam->max_quantizer < pParam->min_quantizer)
205 : Isibaar 3 pParam->max_quantizer = pParam->min_quantizer;
206 :    
207 : edgomez 195 /* 1 keyframe each 10 seconds */
208 : edgomez 192
209 : edgomez 325 if (pParam->max_key_interval <= 0)
210 : edgomez 192 pParam->max_key_interval = 10 * pParam->fincr / pParam->fbase;
211 :    
212 :     pEnc = (Encoder *) xvid_malloc(sizeof(Encoder), CACHE_LINE);
213 :     if (pEnc == NULL)
214 : Isibaar 3 return XVID_ERR_MEMORY;
215 :    
216 : edgomez 198 /* Zero the Encoder Structure */
217 :    
218 :     memset(pEnc, 0, sizeof(Encoder));
219 :    
220 : Isibaar 3 /* Fill members of Encoder structure */
221 :    
222 : edgomez 13 pEnc->mbParam.width = pParam->width;
223 :     pEnc->mbParam.height = pParam->height;
224 : Isibaar 3
225 :     pEnc->mbParam.mb_width = (pEnc->mbParam.width + 15) / 16;
226 :     pEnc->mbParam.mb_height = (pEnc->mbParam.height + 15) / 16;
227 :    
228 : edgomez 195 pEnc->mbParam.edged_width = 16 * pEnc->mbParam.mb_width + 2 * EDGE_SIZE;
229 :     pEnc->mbParam.edged_height = 16 * pEnc->mbParam.mb_height + 2 * EDGE_SIZE;
230 : Isibaar 3
231 : suxen_drol 152 pEnc->mbParam.fbase = pParam->fbase;
232 :     pEnc->mbParam.fincr = pParam->fincr;
233 :    
234 : Isibaar 208 pEnc->mbParam.m_quant_type = H263_QUANT;
235 :    
236 : edgomez 13 pEnc->sStat.fMvPrevSigma = -1;
237 : Isibaar 3
238 :     /* Fill rate control parameters */
239 :    
240 : h 121 pEnc->bitrate = pParam->rc_bitrate;
241 : Isibaar 3
242 : edgomez 13 pEnc->iFrameNum = 0;
243 :     pEnc->iMaxKeyInterval = pParam->max_key_interval;
244 : Isibaar 3
245 : suxen_drol 136 /* try to allocate frame memory */
246 : Isibaar 3
247 : edgomez 192 pEnc->current = xvid_malloc(sizeof(FRAMEINFO), CACHE_LINE);
248 :     pEnc->reference = xvid_malloc(sizeof(FRAMEINFO), CACHE_LINE);
249 : Isibaar 3
250 : edgomez 195 if (pEnc->current == NULL || pEnc->reference == NULL)
251 : edgomez 192 goto xvid_err_memory1;
252 :    
253 : suxen_drol 136 /* try to allocate mb memory */
254 : Isibaar 3
255 : edgomez 195 pEnc->current->mbs =
256 :     xvid_malloc(sizeof(MACROBLOCK) * pEnc->mbParam.mb_width *
257 :     pEnc->mbParam.mb_height, CACHE_LINE);
258 :     pEnc->reference->mbs =
259 :     xvid_malloc(sizeof(MACROBLOCK) * pEnc->mbParam.mb_width *
260 :     pEnc->mbParam.mb_height, CACHE_LINE);
261 : suxen_drol 136
262 : edgomez 192 if (pEnc->current->mbs == NULL || pEnc->reference->mbs == NULL)
263 :     goto xvid_err_memory2;
264 : suxen_drol 136
265 :     /* try to allocate image memory */
266 :    
267 : suxen_drol 229 #ifdef _DEBUG_PSNR
268 : suxen_drol 136 image_null(&pEnc->sOriginal);
269 :     #endif
270 : chl 530
271 : suxen_drol 152 image_null(&pEnc->f_refh);
272 :     image_null(&pEnc->f_refv);
273 :     image_null(&pEnc->f_refhv);
274 : chl 530
275 : suxen_drol 136 image_null(&pEnc->current->image);
276 :     image_null(&pEnc->reference->image);
277 :     image_null(&pEnc->vInterH);
278 :     image_null(&pEnc->vInterV);
279 :     image_null(&pEnc->vInterVf);
280 :     image_null(&pEnc->vInterHV);
281 :     image_null(&pEnc->vInterHVf);
282 : edgomez 192
283 : suxen_drol 229 #ifdef _DEBUG_PSNR
284 : edgomez 195 if (image_create
285 :     (&pEnc->sOriginal, pEnc->mbParam.edged_width,
286 :     pEnc->mbParam.edged_height) < 0)
287 : edgomez 192 goto xvid_err_memory3;
288 : suxen_drol 136 #endif
289 : chl 530
290 : edgomez 195 if (image_create
291 :     (&pEnc->f_refh, pEnc->mbParam.edged_width,
292 :     pEnc->mbParam.edged_height) < 0)
293 : edgomez 192 goto xvid_err_memory3;
294 : edgomez 195 if (image_create
295 :     (&pEnc->f_refv, pEnc->mbParam.edged_width,
296 :     pEnc->mbParam.edged_height) < 0)
297 : edgomez 192 goto xvid_err_memory3;
298 : edgomez 195 if (image_create
299 :     (&pEnc->f_refhv, pEnc->mbParam.edged_width,
300 :     pEnc->mbParam.edged_height) < 0)
301 : edgomez 192 goto xvid_err_memory3;
302 : chl 530
303 : edgomez 195 if (image_create
304 :     (&pEnc->current->image, pEnc->mbParam.edged_width,
305 :     pEnc->mbParam.edged_height) < 0)
306 : edgomez 192 goto xvid_err_memory3;
307 : edgomez 195 if (image_create
308 :     (&pEnc->reference->image, pEnc->mbParam.edged_width,
309 :     pEnc->mbParam.edged_height) < 0)
310 : edgomez 192 goto xvid_err_memory3;
311 : edgomez 195 if (image_create
312 :     (&pEnc->vInterH, pEnc->mbParam.edged_width,
313 :     pEnc->mbParam.edged_height) < 0)
314 : edgomez 192 goto xvid_err_memory3;
315 : edgomez 195 if (image_create
316 :     (&pEnc->vInterV, pEnc->mbParam.edged_width,
317 :     pEnc->mbParam.edged_height) < 0)
318 : edgomez 192 goto xvid_err_memory3;
319 : edgomez 195 if (image_create
320 :     (&pEnc->vInterVf, pEnc->mbParam.edged_width,
321 :     pEnc->mbParam.edged_height) < 0)
322 : edgomez 192 goto xvid_err_memory3;
323 : edgomez 195 if (image_create
324 :     (&pEnc->vInterHV, pEnc->mbParam.edged_width,
325 :     pEnc->mbParam.edged_height) < 0)
326 : edgomez 192 goto xvid_err_memory3;
327 : edgomez 195 if (image_create
328 :     (&pEnc->vInterHVf, pEnc->mbParam.edged_width,
329 :     pEnc->mbParam.edged_height) < 0)
330 : edgomez 192 goto xvid_err_memory3;
331 : suxen_drol 136
332 : Isibaar 3
333 : edgomez 192
334 :     /* B Frames specific init */
335 : edgomez 195
336 : suxen_drol 234 pEnc->global = pParam->global;
337 : suxen_drol 164 pEnc->mbParam.max_bframes = pParam->max_bframes;
338 : suxen_drol 152 pEnc->bquant_ratio = pParam->bquant_ratio;
339 : suxen_drol 324 pEnc->frame_drop_ratio = pParam->frame_drop_ratio;
340 : edgomez 192 pEnc->bframes = NULL;
341 :    
342 : edgomez 195 if (pEnc->mbParam.max_bframes > 0) {
343 : suxen_drol 152 int n;
344 :    
345 : edgomez 195 pEnc->bframes =
346 :     xvid_malloc(pEnc->mbParam.max_bframes * sizeof(FRAMEINFO *),
347 :     CACHE_LINE);
348 : suxen_drol 152
349 : edgomez 192 if (pEnc->bframes == NULL)
350 :     goto xvid_err_memory3;
351 :    
352 : edgomez 195 for (n = 0; n < pEnc->mbParam.max_bframes; n++)
353 : edgomez 192 pEnc->bframes[n] = NULL;
354 :    
355 : suxen_drol 152
356 : edgomez 195 for (n = 0; n < pEnc->mbParam.max_bframes; n++) {
357 :     pEnc->bframes[n] = xvid_malloc(sizeof(FRAMEINFO), CACHE_LINE);
358 :    
359 : edgomez 192 if (pEnc->bframes[n] == NULL)
360 :     goto xvid_err_memory4;
361 :    
362 : edgomez 195 pEnc->bframes[n]->mbs =
363 :     xvid_malloc(sizeof(MACROBLOCK) * pEnc->mbParam.mb_width *
364 :     pEnc->mbParam.mb_height, CACHE_LINE);
365 : edgomez 192
366 :     if (pEnc->bframes[n]->mbs == NULL)
367 :     goto xvid_err_memory4;
368 :    
369 :     image_null(&pEnc->bframes[n]->image);
370 :    
371 : edgomez 195 if (image_create
372 :     (&pEnc->bframes[n]->image, pEnc->mbParam.edged_width,
373 :     pEnc->mbParam.edged_height) < 0)
374 : edgomez 192 goto xvid_err_memory4;
375 :    
376 : suxen_drol 152 }
377 :     }
378 : edgomez 192
379 : suxen_drol 152 pEnc->bframenum_head = 0;
380 :     pEnc->bframenum_tail = 0;
381 :     pEnc->flush_bframes = 0;
382 : suxen_drol 238 pEnc->bframenum_dx50bvop = -1;
383 : suxen_drol 152
384 : suxen_drol 229 pEnc->queue = NULL;
385 :    
386 :    
387 :     if (pEnc->mbParam.max_bframes > 0) {
388 :     int n;
389 :    
390 :     pEnc->queue =
391 :     xvid_malloc(pEnc->mbParam.max_bframes * sizeof(IMAGE),
392 :     CACHE_LINE);
393 :    
394 :     if (pEnc->queue == NULL)
395 :     goto xvid_err_memory4;
396 :    
397 :     for (n = 0; n < pEnc->mbParam.max_bframes; n++)
398 :     image_null(&pEnc->queue[n]);
399 :    
400 :     for (n = 0; n < pEnc->mbParam.max_bframes; n++) {
401 :     if (image_create
402 :     (&pEnc->queue[n], pEnc->mbParam.edged_width,
403 :     pEnc->mbParam.edged_height) < 0)
404 :     goto xvid_err_memory5;
405 :    
406 :     }
407 :     }
408 :    
409 :     pEnc->queue_head = 0;
410 :     pEnc->queue_tail = 0;
411 :     pEnc->queue_size = 0;
412 :    
413 : chl 557 pEnc->mbParam.m_stamp = 0;
414 : chl 572
415 : suxen_drol 234 pEnc->m_framenum = 0;
416 : chl 572 pEnc->current->stamp = 0;
417 :     pEnc->reference->stamp = 0;
418 : suxen_drol 152
419 : edgomez 195 pParam->handle = (void *) pEnc;
420 : Isibaar 3
421 : edgomez 195 if (pParam->rc_bitrate) {
422 :     RateControlInit(&pEnc->rate_control, pParam->rc_bitrate,
423 :     pParam->rc_reaction_delay_factor,
424 :     pParam->rc_averaging_period, pParam->rc_buffer,
425 :     pParam->fbase * 1000 / pParam->fincr,
426 :     pParam->max_quantizer, pParam->min_quantizer);
427 : Isibaar 3 }
428 :    
429 : Isibaar 36 init_timer();
430 : Isibaar 3
431 :     return XVID_ERR_OK;
432 : edgomez 192
433 :     /*
434 :     * We handle all XVID_ERR_MEMORY here, this makes the code lighter
435 :     */
436 : chl 530
437 : suxen_drol 229 xvid_err_memory5:
438 :    
439 :    
440 :     if (pEnc->mbParam.max_bframes > 0) {
441 :    
442 :     for (i = 0; i < pEnc->mbParam.max_bframes; i++) {
443 :     image_destroy(&pEnc->queue[i], pEnc->mbParam.edged_width,
444 :     pEnc->mbParam.edged_height);
445 :     }
446 :     xvid_free(pEnc->queue);
447 :     }
448 :    
449 : edgomez 195 xvid_err_memory4:
450 : edgomez 192
451 : suxen_drol 229 if (pEnc->mbParam.max_bframes > 0) {
452 : edgomez 192
453 : suxen_drol 229 for (i = 0; i < pEnc->mbParam.max_bframes; i++) {
454 : edgomez 192
455 : suxen_drol 229 if (pEnc->bframes[i] == NULL)
456 :     continue;
457 : edgomez 192
458 : suxen_drol 229 image_destroy(&pEnc->bframes[i]->image, pEnc->mbParam.edged_width,
459 :     pEnc->mbParam.edged_height);
460 :    
461 :     xvid_free(pEnc->bframes[i]->mbs);
462 :    
463 :     xvid_free(pEnc->bframes[i]);
464 : edgomez 192
465 : suxen_drol 229 }
466 :    
467 :     xvid_free(pEnc->bframes);
468 : edgomez 192 }
469 :    
470 : edgomez 195 xvid_err_memory3:
471 : suxen_drol 229 #ifdef _DEBUG_PSNR
472 : edgomez 195 image_destroy(&pEnc->sOriginal, pEnc->mbParam.edged_width,
473 :     pEnc->mbParam.edged_height);
474 : edgomez 192 #endif
475 :    
476 : edgomez 195 image_destroy(&pEnc->f_refh, pEnc->mbParam.edged_width,
477 :     pEnc->mbParam.edged_height);
478 :     image_destroy(&pEnc->f_refv, pEnc->mbParam.edged_width,
479 :     pEnc->mbParam.edged_height);
480 :     image_destroy(&pEnc->f_refhv, pEnc->mbParam.edged_width,
481 :     pEnc->mbParam.edged_height);
482 : edgomez 192
483 : edgomez 195 image_destroy(&pEnc->current->image, pEnc->mbParam.edged_width,
484 :     pEnc->mbParam.edged_height);
485 :     image_destroy(&pEnc->reference->image, pEnc->mbParam.edged_width,
486 :     pEnc->mbParam.edged_height);
487 :     image_destroy(&pEnc->vInterH, pEnc->mbParam.edged_width,
488 :     pEnc->mbParam.edged_height);
489 :     image_destroy(&pEnc->vInterV, pEnc->mbParam.edged_width,
490 :     pEnc->mbParam.edged_height);
491 :     image_destroy(&pEnc->vInterVf, pEnc->mbParam.edged_width,
492 :     pEnc->mbParam.edged_height);
493 :     image_destroy(&pEnc->vInterHV, pEnc->mbParam.edged_width,
494 :     pEnc->mbParam.edged_height);
495 :     image_destroy(&pEnc->vInterHVf, pEnc->mbParam.edged_width,
496 :     pEnc->mbParam.edged_height);
497 : edgomez 192
498 : edgomez 195 xvid_err_memory2:
499 : edgomez 192 xvid_free(pEnc->current->mbs);
500 :     xvid_free(pEnc->reference->mbs);
501 :    
502 : edgomez 195 xvid_err_memory1:
503 : edgomez 192 xvid_free(pEnc->current);
504 :     xvid_free(pEnc->reference);
505 :     xvid_free(pEnc);
506 :    
507 : edgomez 194 pParam->handle = NULL;
508 :    
509 : edgomez 192 return XVID_ERR_MEMORY;
510 : Isibaar 3 }
511 :    
512 : edgomez 194 /*****************************************************************************
513 :     * Encoder destruction
514 :     *
515 :     * This function destroy the entire encoder structure created by a previous
516 :     * successful encoder_create call.
517 :     *
518 :     * Returned values (for now only one returned value) :
519 :     * - XVID_ERR_OK - no errors
520 :     *
521 :     ****************************************************************************/
522 :    
523 :     int
524 :     encoder_destroy(Encoder * pEnc)
525 : Isibaar 3 {
526 : suxen_drol 229 int i;
527 :    
528 : edgomez 13 ENC_CHECK(pEnc);
529 : Isibaar 3
530 : edgomez 192 /* B Frames specific */
531 : suxen_drol 229 if (pEnc->mbParam.max_bframes > 0) {
532 : edgomez 192
533 : suxen_drol 229 for (i = 0; i < pEnc->mbParam.max_bframes; i++) {
534 :    
535 :     image_destroy(&pEnc->queue[i], pEnc->mbParam.edged_width,
536 :     pEnc->mbParam.edged_height);
537 :     }
538 :     xvid_free(pEnc->queue);
539 :     }
540 : edgomez 192
541 :    
542 : suxen_drol 229 if (pEnc->mbParam.max_bframes > 0) {
543 :    
544 :     for (i = 0; i < pEnc->mbParam.max_bframes; i++) {
545 :    
546 :     if (pEnc->bframes[i] == NULL)
547 :     continue;
548 :    
549 :     image_destroy(&pEnc->bframes[i]->image, pEnc->mbParam.edged_width,
550 : edgomez 195 pEnc->mbParam.edged_height);
551 : edgomez 192
552 : suxen_drol 229 xvid_free(pEnc->bframes[i]->mbs);
553 : edgomez 192
554 : suxen_drol 229 xvid_free(pEnc->bframes[i]);
555 :     }
556 : edgomez 192
557 : suxen_drol 229 xvid_free(pEnc->bframes);
558 :    
559 : suxen_drol 152 }
560 :    
561 : edgomez 192 /* All images, reference, current etc ... */
562 :    
563 : edgomez 195 image_destroy(&pEnc->current->image, pEnc->mbParam.edged_width,
564 :     pEnc->mbParam.edged_height);
565 :     image_destroy(&pEnc->reference->image, pEnc->mbParam.edged_width,
566 :     pEnc->mbParam.edged_height);
567 :     image_destroy(&pEnc->vInterH, pEnc->mbParam.edged_width,
568 :     pEnc->mbParam.edged_height);
569 :     image_destroy(&pEnc->vInterV, pEnc->mbParam.edged_width,
570 :     pEnc->mbParam.edged_height);
571 :     image_destroy(&pEnc->vInterVf, pEnc->mbParam.edged_width,
572 :     pEnc->mbParam.edged_height);
573 :     image_destroy(&pEnc->vInterHV, pEnc->mbParam.edged_width,
574 :     pEnc->mbParam.edged_height);
575 :     image_destroy(&pEnc->vInterHVf, pEnc->mbParam.edged_width,
576 :     pEnc->mbParam.edged_height);
577 : chl 530
578 : edgomez 195 image_destroy(&pEnc->f_refh, pEnc->mbParam.edged_width,
579 :     pEnc->mbParam.edged_height);
580 :     image_destroy(&pEnc->f_refv, pEnc->mbParam.edged_width,
581 :     pEnc->mbParam.edged_height);
582 :     image_destroy(&pEnc->f_refhv, pEnc->mbParam.edged_width,
583 :     pEnc->mbParam.edged_height);
584 : chl 530
585 : suxen_drol 229 #ifdef _DEBUG_PSNR
586 : edgomez 195 image_destroy(&pEnc->sOriginal, pEnc->mbParam.edged_width,
587 :     pEnc->mbParam.edged_height);
588 : Isibaar 113 #endif
589 : edgomez 192
590 :     /* Encoder structure */
591 : edgomez 195
592 : suxen_drol 136 xvid_free(pEnc->current->mbs);
593 :     xvid_free(pEnc->current);
594 :    
595 :     xvid_free(pEnc->reference->mbs);
596 :     xvid_free(pEnc->reference);
597 :    
598 : Isibaar 41 xvid_free(pEnc);
599 : edgomez 192
600 : edgomez 13 return XVID_ERR_OK;
601 : Isibaar 3 }
602 :    
603 : suxen_drol 229
604 : chl 530 static __inline void inc_frame_num(Encoder * pEnc)
605 : suxen_drol 229 {
606 : chl 569 pEnc->current->stamp = pEnc->mbParam.m_stamp; // first frame is zero
607 : chl 557 pEnc->mbParam.m_stamp += pEnc->mbParam.fincr;
608 : chl 387 }
609 : suxen_drol 229
610 : chl 387
611 : chl 530 static __inline void
612 :     queue_image(Encoder * pEnc, XVID_ENC_FRAME * pFrame)
613 : suxen_drol 229 {
614 :     if (pEnc->queue_size >= pEnc->mbParam.max_bframes)
615 :     {
616 : suxen_drol 252 DPRINTF(DPRINTF_DEBUG,"FATAL: QUEUE FULL");
617 : suxen_drol 229 return;
618 :     }
619 :    
620 : suxen_drol 252 DPRINTF(DPRINTF_DEBUG,"*** QUEUE bf: head=%i tail=%i queue: head=%i tail=%i size=%i",
621 : suxen_drol 229 pEnc->bframenum_head, pEnc->bframenum_tail,
622 :     pEnc->queue_head, pEnc->queue_tail, pEnc->queue_size);
623 :    
624 :    
625 :     start_timer();
626 :     if (image_input
627 :     (&pEnc->queue[pEnc->queue_tail], pEnc->mbParam.width, pEnc->mbParam.height,
628 :     pEnc->mbParam.edged_width, pFrame->image, pFrame->colorspace))
629 :     return;
630 :     stop_conv_timer();
631 :    
632 :     pEnc->queue_size++;
633 :     pEnc->queue_tail = (pEnc->queue_tail + 1) % pEnc->mbParam.max_bframes;
634 :     }
635 :    
636 : chl 557 static __inline void
637 :     set_timecodes(FRAMEINFO* pCur,FRAMEINFO *pRef, int32_t time_base)
638 :     {
639 : suxen_drol 229
640 : chl 557 pCur->ticks = (int32_t)pCur->stamp % time_base;
641 :     pCur->seconds = ((int32_t)pCur->stamp / time_base) - ((int32_t)pRef->stamp / time_base) ;
642 :    
643 : chl 569 //HEAVY DEBUG OUTPUT remove when timecodes prove to be stable
644 : chl 530
645 : chl 570 /* fprintf(stderr,"WriteVop: %d - %d \n",
646 : chl 557 ((int32_t)pCur->stamp / time_base), ((int32_t)pRef->stamp / time_base));
647 :     fprintf(stderr,"set_timecodes: VOP %1d stamp=%lld ref_stamp=%lld base=%d\n",
648 :     pCur->coding_type, pCur->stamp, pRef->stamp, time_base);
649 :     fprintf(stderr,"set_timecodes: VOP %1d seconds=%d ticks=%d (ref-sec=%d ref-tick=%d)\n",
650 :     pCur->coding_type, pCur->seconds, pCur->ticks, pRef->seconds, pRef->ticks);
651 :    
652 : chl 570 */
653 : chl 557 }
654 :    
655 :    
656 :    
657 :    
658 :    
659 : edgomez 194 /*****************************************************************************
660 : suxen_drol 229 * IPB frame encoder entry point
661 : edgomez 194 *
662 :     * Returned values :
663 :     * - XVID_ERR_OK - no errors
664 :     * - XVID_ERR_FORMAT - the image subsystem reported the image had a wrong
665 :     * format
666 :     ****************************************************************************/
667 : suxen_drol 152
668 : edgomez 194 int
669 : suxen_drol 229 encoder_encode_bframes(Encoder * pEnc,
670 : edgomez 195 XVID_ENC_FRAME * pFrame,
671 :     XVID_ENC_STATS * pResult)
672 : Isibaar 3 {
673 : edgomez 13 uint16_t x, y;
674 :     Bitstream bs;
675 : h 545 uint32_t bits, mode;
676 : suxen_drol 152
677 : suxen_drol 229 int input_valid = 1;
678 :    
679 :     #ifdef _DEBUG_PSNR
680 : chenm001 168 float psnr;
681 :     char temp[128];
682 :     #endif
683 :    
684 : suxen_drol 152 ENC_CHECK(pEnc);
685 :     ENC_CHECK(pFrame);
686 : suxen_drol 229 ENC_CHECK(pFrame->image);
687 : suxen_drol 152
688 :     start_global_timer();
689 : edgomez 195
690 : suxen_drol 152 BitstreamInit(&bs, pFrame->bitstream, 0);
691 :    
692 : suxen_drol 229 ipvop_loop:
693 :    
694 : edgomez 194 /*
695 :     * bframe "flush" code
696 :     */
697 : suxen_drol 152
698 : edgomez 195 if ((pFrame->image == NULL || pEnc->flush_bframes)
699 :     && (pEnc->bframenum_head < pEnc->bframenum_tail)) {
700 :    
701 :     if (pEnc->flush_bframes == 0) {
702 : edgomez 194 /*
703 :     * we have reached the end of stream without getting
704 :     * a future reference frame... so encode last final
705 :     * frame as a pframe
706 :     */
707 :    
708 : suxen_drol 252 DPRINTF(DPRINTF_DEBUG,"*** BFRAME (final frame) bf: head=%i tail=%i queue: head=%i tail=%i size=%i",
709 : suxen_drol 229 pEnc->bframenum_head, pEnc->bframenum_tail,
710 :     pEnc->queue_head, pEnc->queue_tail, pEnc->queue_size);
711 :    
712 : suxen_drol 152 pEnc->bframenum_tail--;
713 :     SWAP(pEnc->current, pEnc->reference);
714 :    
715 : edgomez 195 SWAP(pEnc->current, pEnc->bframes[pEnc->bframenum_tail]);
716 : suxen_drol 152
717 :     FrameCodeP(pEnc, &bs, &bits, 1, 0);
718 :    
719 :     BitstreamPad(&bs);
720 :     pFrame->length = BitstreamLength(&bs);
721 :     pFrame->intra = 0;
722 : edgomez 194
723 : suxen_drol 152 return XVID_ERR_OK;
724 :     }
725 :    
726 : suxen_drol 229
727 : suxen_drol 252 DPRINTF(DPRINTF_DEBUG,"*** BFRAME (flush) bf: head=%i tail=%i queue: head=%i tail=%i size=%i",
728 : suxen_drol 229 pEnc->bframenum_head, pEnc->bframenum_tail,
729 :     pEnc->queue_head, pEnc->queue_tail, pEnc->queue_size);
730 :    
731 : edgomez 195 FrameCodeB(pEnc, pEnc->bframes[pEnc->bframenum_head], &bs, &bits);
732 : suxen_drol 152 pEnc->bframenum_head++;
733 :    
734 :     BitstreamPad(&bs);
735 :     pFrame->length = BitstreamLength(&bs);
736 :     pFrame->intra = 0;
737 : edgomez 194
738 : suxen_drol 229 if (input_valid)
739 :     queue_image(pEnc, pFrame);
740 :    
741 : suxen_drol 152 return XVID_ERR_OK;
742 :     }
743 :    
744 : suxen_drol 229 if (pEnc->bframenum_head > 0) {
745 :     pEnc->bframenum_head = pEnc->bframenum_tail = 0;
746 :    
747 : suxen_drol 234 if ((pEnc->global & XVID_GLOBAL_PACKED)) {
748 : suxen_drol 229
749 : suxen_drol 252 DPRINTF(DPRINTF_DEBUG,"*** EMPTY bf: head=%i tail=%i queue: head=%i tail=%i size=%i",
750 : suxen_drol 229 pEnc->bframenum_head, pEnc->bframenum_tail,
751 :     pEnc->queue_head, pEnc->queue_tail, pEnc->queue_size);
752 :    
753 : chl 557 set_timecodes(pEnc->current,pEnc->reference,pEnc->mbParam.fbase);
754 : suxen_drol 229 BitstreamWriteVopHeader(&bs, &pEnc->mbParam, pEnc->current, 0);
755 :     BitstreamPad(&bs);
756 :     BitstreamPutBits(&bs, 0x7f, 8);
757 :    
758 :     pFrame->length = BitstreamLength(&bs);
759 :     pFrame->intra = 0;
760 :    
761 :     if (input_valid)
762 :     queue_image(pEnc, pFrame);
763 :    
764 :     return XVID_ERR_OK;
765 :     }
766 :     }
767 :    
768 :    
769 :     bvop_loop:
770 :    
771 : suxen_drol 238 if (pEnc->bframenum_dx50bvop != -1)
772 :     {
773 : suxen_drol 229
774 :     SWAP(pEnc->current, pEnc->reference);
775 : suxen_drol 238 SWAP(pEnc->current, pEnc->bframes[pEnc->bframenum_dx50bvop]);
776 : suxen_drol 229
777 : suxen_drol 238 if ((pEnc->global & XVID_GLOBAL_DEBUG)) {
778 :     image_printf(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height, 5, 100, "DX50 IVOP");
779 :     }
780 :    
781 :     if (input_valid)
782 :     {
783 :     queue_image(pEnc, pFrame);
784 :     input_valid = 0;
785 :     }
786 :    
787 :     } else if (input_valid) {
788 :    
789 :     SWAP(pEnc->current, pEnc->reference);
790 :    
791 : suxen_drol 229 start_timer();
792 :     if (image_input
793 :     (&pEnc->current->image, pEnc->mbParam.width, pEnc->mbParam.height,
794 :     pEnc->mbParam.edged_width, pFrame->image, pFrame->colorspace))
795 :     return XVID_ERR_FORMAT;
796 :     stop_conv_timer();
797 :    
798 :     // queue input frame, and dequue next image
799 :     if (pEnc->queue_size > 0)
800 :     {
801 :     image_swap(&pEnc->current->image, &pEnc->queue[pEnc->queue_tail]);
802 :     if (pEnc->queue_head != pEnc->queue_tail)
803 :     {
804 :     image_swap(&pEnc->current->image, &pEnc->queue[pEnc->queue_head]);
805 :     }
806 :     pEnc->queue_head = (pEnc->queue_head + 1) % pEnc->mbParam.max_bframes;
807 :     pEnc->queue_tail = (pEnc->queue_tail + 1) % pEnc->mbParam.max_bframes;
808 :     }
809 :    
810 :     } else if (pEnc->queue_size > 0) {
811 :    
812 :     SWAP(pEnc->current, pEnc->reference);
813 :    
814 :     image_swap(&pEnc->current->image, &pEnc->queue[pEnc->queue_head]);
815 :     pEnc->queue_head = (pEnc->queue_head + 1) % pEnc->mbParam.max_bframes;
816 :     pEnc->queue_size--;
817 :    
818 :     } else if (BitstreamPos(&bs) == 0) {
819 :    
820 : suxen_drol 252 DPRINTF(DPRINTF_DEBUG,"*** SKIP bf: head=%i tail=%i queue: head=%i tail=%i size=%i",
821 : suxen_drol 229 pEnc->bframenum_head, pEnc->bframenum_tail,
822 :     pEnc->queue_head, pEnc->queue_tail, pEnc->queue_size);
823 :    
824 : suxen_drol 152 pFrame->intra = 0;
825 : edgomez 194
826 : chl 557 set_timecodes(pEnc->current,pEnc->reference,pEnc->mbParam.fbase);
827 : Isibaar 360 BitstreamWriteVopHeader(&bs, &pEnc->mbParam, pEnc->current, 0); // write N_VOP
828 : suxen_drol 229 BitstreamPad(&bs);
829 :     pFrame->length = BitstreamLength(&bs);
830 :    
831 : suxen_drol 152 return XVID_ERR_OK;
832 :    
833 : suxen_drol 229 } else {
834 :    
835 :     pFrame->length = BitstreamLength(&bs);
836 :     return XVID_ERR_OK;
837 : suxen_drol 152 }
838 :    
839 :     pEnc->flush_bframes = 0;
840 :    
841 : edgomez 198 emms();
842 : edgomez 194
843 : suxen_drol 238 // only inc frame num, adapt quant, etc. if we havent seen it before
844 :     if (pEnc->bframenum_dx50bvop < 0 )
845 :     {
846 :     if (pFrame->quant == 0)
847 :     pEnc->current->quant = RateControlGetQ(&pEnc->rate_control, 0);
848 :     else
849 :     pEnc->current->quant = pFrame->quant;
850 : edgomez 194
851 : chl 326 /* if (pEnc->current->quant < 1)
852 : suxen_drol 238 pEnc->current->quant = 1;
853 : edgomez 195
854 : suxen_drol 238 if (pEnc->current->quant > 31)
855 :     pEnc->current->quant = 31;
856 : chl 326 */
857 : suxen_drol 238 pEnc->current->global_flags = pFrame->general;
858 :     pEnc->current->motion_flags = pFrame->motion;
859 : suxen_drol 152
860 : suxen_drol 238 /* ToDo : dynamic fcode (in both directions) */
861 :     pEnc->current->fcode = pEnc->mbParam.m_fcode;
862 :     pEnc->current->bcode = pEnc->mbParam.m_fcode;
863 : suxen_drol 152
864 : suxen_drol 238 inc_frame_num(pEnc);
865 :    
866 : suxen_drol 229 #ifdef _DEBUG_PSNR
867 : suxen_drol 238 image_copy(&pEnc->sOriginal, &pEnc->current->image,
868 : edgomez 195 pEnc->mbParam.edged_width, pEnc->mbParam.height);
869 : suxen_drol 152 #endif
870 :    
871 : suxen_drol 238 emms();
872 : suxen_drol 152
873 : suxen_drol 238 if ((pEnc->global & XVID_GLOBAL_DEBUG)) {
874 :     image_printf(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height, 5, 5,
875 :     "%i if:%i st:%i:%i", pEnc->m_framenum++, pEnc->iFrameNum, pEnc->current->seconds, pEnc->current->ticks);
876 :     }
877 : suxen_drol 234
878 : edgomez 194 /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
879 :     * Luminance masking
880 :     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */
881 : suxen_drol 152
882 : suxen_drol 238 if ((pEnc->current->global_flags & XVID_LUMIMASKING)) {
883 :     int *temp_dquants =
884 :     (int *) xvid_malloc(pEnc->mbParam.mb_width *
885 : edgomez 195 pEnc->mbParam.mb_height * sizeof(int),
886 :     CACHE_LINE);
887 :    
888 : suxen_drol 238 pEnc->current->quant =
889 :     adaptive_quantization(pEnc->current->image.y,
890 : edgomez 195 pEnc->mbParam.edged_width, temp_dquants,
891 :     pEnc->current->quant, pEnc->current->quant,
892 :     2 * pEnc->current->quant,
893 :     pEnc->mbParam.mb_width,
894 :     pEnc->mbParam.mb_height);
895 : edgomez 194
896 : suxen_drol 238 for (y = 0; y < pEnc->mbParam.mb_height; y++) {
897 : edgomez 194
898 : edgomez 195 #define OFFSET(x,y) ((x) + (y)*pEnc->mbParam.mb_width)
899 :    
900 : suxen_drol 238 for (x = 0; x < pEnc->mbParam.mb_width; x++) {
901 :     MACROBLOCK *pMB = &pEnc->current->mbs[OFFSET(x, y)];
902 : edgomez 195
903 : suxen_drol 238 pMB->dquant = iDQtab[temp_dquants[OFFSET(x, y)] + 2];
904 :     }
905 : edgomez 194
906 : edgomez 195 #undef OFFSET
907 : suxen_drol 238 }
908 : edgomez 194
909 : suxen_drol 238 xvid_free(temp_dquants);
910 : edgomez 194 }
911 :    
912 : suxen_drol 152 }
913 :    
914 : edgomez 194 /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
915 :     * ivop/pvop/bvop selection
916 :     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */
917 : suxen_drol 152
918 :    
919 : suxen_drol 240 if (pEnc->iFrameNum == 0 || pFrame->intra == 1 || pEnc->bframenum_dx50bvop >= 0 ||
920 : edgomez 195 (pFrame->intra < 0 && pEnc->iMaxKeyInterval > 0 &&
921 :     pEnc->iFrameNum >= pEnc->iMaxKeyInterval)
922 : h 545 || /*image_mad(&pEnc->reference->image, &pEnc->current->image,
923 : edgomez 195 pEnc->mbParam.edged_width, pEnc->mbParam.width,
924 : h 545 pEnc->mbParam.height) > 30) {*/
925 :     2 == (mode = MEanalysis(&pEnc->reference->image, &pEnc->current->image,
926 :     &pEnc->mbParam, pEnc->current->mbs, pEnc->current->fcode))) {
927 :    
928 : edgomez 194 /*
929 :     * This will be coded as an Intra Frame
930 :     */
931 : suxen_drol 152
932 : suxen_drol 252 DPRINTF(DPRINTF_DEBUG,"*** IFRAME bf: head=%i tail=%i queue: head=%i tail=%i size=%i",
933 : suxen_drol 229 pEnc->bframenum_head, pEnc->bframenum_tail,
934 :     pEnc->queue_head, pEnc->queue_tail, pEnc->queue_size);
935 : suxen_drol 234
936 :     if ((pEnc->global & XVID_GLOBAL_DEBUG)) {
937 :     image_printf(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height, 5, 200, "IVOP");
938 :     }
939 : edgomez 194
940 : suxen_drol 238 // when we reach an iframe in DX50BVOP mode, encode the last bframe as a pframe
941 : suxen_drol 152
942 : suxen_drol 238 if ((pEnc->global & XVID_GLOBAL_DX50BVOP) && pEnc->bframenum_tail > 0) {
943 :    
944 :     pEnc->bframenum_tail--;
945 :     pEnc->bframenum_dx50bvop = pEnc->bframenum_tail;
946 :    
947 :     SWAP(pEnc->current, pEnc->bframes[pEnc->bframenum_dx50bvop]);
948 :     if ((pEnc->global & XVID_GLOBAL_DEBUG)) {
949 :     image_printf(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height, 5, 100, "DX50 BVOP->PVOP");
950 :     }
951 :     FrameCodeP(pEnc, &bs, &bits, 1, 0);
952 :    
953 :     pFrame->intra = 0;
954 :    
955 :     } else {
956 : suxen_drol 240
957 : suxen_drol 238 FrameCodeI(pEnc, &bs, &bits);
958 :     pFrame->intra = 1;
959 : suxen_drol 240
960 :     pEnc->bframenum_dx50bvop = -1;
961 : suxen_drol 238 }
962 :    
963 : suxen_drol 152 pEnc->flush_bframes = 1;
964 :    
965 : suxen_drol 240 if ((pEnc->global & XVID_GLOBAL_PACKED) && pEnc->bframenum_tail > 0) {
966 : suxen_drol 229 BitstreamPad(&bs);
967 :     input_valid = 0;
968 :     goto ipvop_loop;
969 :     }
970 :    
971 : edgomez 194 /*
972 :     * NB : sequences like "IIBB" decode fine with msfdam but,
973 :     * go screwy with divx 5.00
974 :     */
975 : h 545 } else if (pEnc->bframenum_tail >= pEnc->mbParam.max_bframes || mode != 0) {
976 : edgomez 194 /*
977 :     * This will be coded as a Predicted Frame
978 :     */
979 : suxen_drol 152
980 : suxen_drol 252 DPRINTF(DPRINTF_DEBUG,"*** PFRAME bf: head=%i tail=%i queue: head=%i tail=%i size=%i",
981 : suxen_drol 229 pEnc->bframenum_head, pEnc->bframenum_tail,
982 :     pEnc->queue_head, pEnc->queue_tail, pEnc->queue_size);
983 : suxen_drol 234
984 :     if ((pEnc->global & XVID_GLOBAL_DEBUG)) {
985 :     image_printf(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height, 5, 200, "PVOP");
986 :     }
987 : edgomez 194
988 : suxen_drol 152 FrameCodeP(pEnc, &bs, &bits, 1, 0);
989 :     pFrame->intra = 0;
990 :     pEnc->flush_bframes = 1;
991 : suxen_drol 229
992 : suxen_drol 234 if ((pEnc->global & XVID_GLOBAL_PACKED)) {
993 : suxen_drol 229 BitstreamPad(&bs);
994 :     input_valid = 0;
995 :     goto ipvop_loop;
996 :     }
997 :    
998 : edgomez 195 } else {
999 : edgomez 194 /*
1000 :     * This will be coded as a Bidirectional Frame
1001 :     */
1002 : suxen_drol 152
1003 : suxen_drol 234 if ((pEnc->global & XVID_GLOBAL_DEBUG)) {
1004 :     image_printf(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height, 5, 200, "BVOP");
1005 :     }
1006 :    
1007 : edgomez 195 if (pFrame->bquant < 1) {
1008 : edgomez 194 pEnc->current->quant =
1009 : edgomez 195 ((pEnc->reference->quant +
1010 :     pEnc->current->quant) * pEnc->bquant_ratio) / 200;
1011 :     } else {
1012 : suxen_drol 152 pEnc->current->quant = pFrame->bquant;
1013 :     }
1014 : chl 327 if (pEnc->current->quant < 1)
1015 : chl 326 pEnc->current->quant = 1;
1016 : edgomez 195
1017 : chl 326 if (pEnc->current->quant > 31)
1018 :     pEnc->current->quant = 31;
1019 :    
1020 : chl 327
1021 : chl 326 DPRINTF(DPRINTF_DEBUG,"*** BFRAME (store) bf: head=%i tail=%i queue: head=%i tail=%i size=%i quant=%i\n",
1022 :     pEnc->bframenum_head, pEnc->bframenum_tail,
1023 :     pEnc->queue_head, pEnc->queue_tail, pEnc->queue_size,pEnc->current->quant);
1024 :    
1025 :    
1026 :    
1027 : edgomez 194 /* store frame into bframe buffer & swap ref back to current */
1028 : suxen_drol 152 SWAP(pEnc->current, pEnc->bframes[pEnc->bframenum_tail]);
1029 :     SWAP(pEnc->current, pEnc->reference);
1030 :    
1031 :     pEnc->bframenum_tail++;
1032 :    
1033 :     pFrame->intra = 0;
1034 :     pFrame->length = 0;
1035 :    
1036 : suxen_drol 229 input_valid = 0;
1037 :     goto bvop_loop;
1038 : suxen_drol 152 }
1039 :    
1040 : Isibaar 358 pEnc->iFrameNum++;
1041 :    
1042 : suxen_drol 152 BitstreamPad(&bs);
1043 :     pFrame->length = BitstreamLength(&bs);
1044 :    
1045 : edgomez 195 if (pResult) {
1046 : suxen_drol 152 pResult->quant = pEnc->current->quant;
1047 : edgomez 195 pResult->hlength = pFrame->length - (pEnc->sStat.iTextBits / 8);
1048 : suxen_drol 152 pResult->kblks = pEnc->sStat.kblks;
1049 :     pResult->mblks = pEnc->sStat.mblks;
1050 :     pResult->ublks = pEnc->sStat.ublks;
1051 :     }
1052 :    
1053 : edgomez 198 emms();
1054 : edgomez 194
1055 : suxen_drol 229 #ifdef _DEBUG_PSNR
1056 : edgomez 195 psnr =
1057 :     image_psnr(&pEnc->sOriginal, &pEnc->current->image,
1058 :     pEnc->mbParam.edged_width, pEnc->mbParam.width,
1059 :     pEnc->mbParam.height);
1060 : suxen_drol 152
1061 : edgomez 194 snprintf(temp, 127, "PSNR: %f\n", psnr);
1062 : suxen_drol 152 DEBUG(temp);
1063 :     #endif
1064 :    
1065 : edgomez 195 if (pFrame->quant == 0) {
1066 :     RateControlUpdate(&pEnc->rate_control, pEnc->current->quant,
1067 :     pFrame->length, pFrame->intra);
1068 : suxen_drol 152 }
1069 :    
1070 :     stop_global_timer();
1071 :     write_timer();
1072 :    
1073 :     return XVID_ERR_OK;
1074 :     }
1075 : suxen_drol 229
1076 :    
1077 :    
1078 : edgomez 194 /*****************************************************************************
1079 : suxen_drol 229 * "original" IP frame encoder entry point
1080 :     *
1081 :     * Returned values :
1082 :     * - XVID_ERR_OK - no errors
1083 :     * - XVID_ERR_FORMAT - the image subsystem reported the image had a wrong
1084 :     * format
1085 : edgomez 194 ****************************************************************************/
1086 : suxen_drol 229
1087 : edgomez 194 int
1088 :     encoder_encode(Encoder * pEnc,
1089 : edgomez 195 XVID_ENC_FRAME * pFrame,
1090 :     XVID_ENC_STATS * pResult)
1091 : suxen_drol 152 {
1092 :     uint16_t x, y;
1093 :     Bitstream bs;
1094 :     uint32_t bits;
1095 : Isibaar 4 uint16_t write_vol_header = 0;
1096 : edgomez 195
1097 : suxen_drol 229 #ifdef _DEBUG_PSNR
1098 : Isibaar 113 float psnr;
1099 : edgomez 194 uint8_t temp[128];
1100 : Isibaar 113 #endif
1101 : Isibaar 3
1102 :     start_global_timer();
1103 :    
1104 : edgomez 13 ENC_CHECK(pEnc);
1105 :     ENC_CHECK(pFrame);
1106 :     ENC_CHECK(pFrame->bitstream);
1107 :     ENC_CHECK(pFrame->image);
1108 : Isibaar 3
1109 : suxen_drol 136 SWAP(pEnc->current, pEnc->reference);
1110 :    
1111 :     pEnc->current->global_flags = pFrame->general;
1112 :     pEnc->current->motion_flags = pFrame->motion;
1113 : h 101 pEnc->mbParam.hint = &pFrame->hint;
1114 : Isibaar 3
1115 : h 543 /* disable alternate scan flag if interlacing is not enabled */
1116 :     if ((pEnc->current->global_flags & XVID_ALTERNATESCAN) &&
1117 :     !(pEnc->current->global_flags & XVID_INTERLACING))
1118 :     {
1119 :     pEnc->current->global_flags -= XVID_ALTERNATESCAN;
1120 :     }
1121 :    
1122 : Isibaar 3 start_timer();
1123 : edgomez 195 if (image_input
1124 :     (&pEnc->current->image, pEnc->mbParam.width, pEnc->mbParam.height,
1125 :     pEnc->mbParam.edged_width, pFrame->image, pFrame->colorspace) < 0)
1126 : Isibaar 3 return XVID_ERR_FORMAT;
1127 :     stop_conv_timer();
1128 :    
1129 : suxen_drol 229 #ifdef _DEBUG_PSNR
1130 : edgomez 195 image_copy(&pEnc->sOriginal, &pEnc->current->image,
1131 :     pEnc->mbParam.edged_width, pEnc->mbParam.height);
1132 : Isibaar 113 #endif
1133 :    
1134 : edgomez 198 emms();
1135 : suxen_drol 136
1136 : edgomez 13 BitstreamInit(&bs, pFrame->bitstream, 0);
1137 : Isibaar 3
1138 : edgomez 195 if (pFrame->quant == 0) {
1139 :     pEnc->current->quant = RateControlGetQ(&pEnc->rate_control, 0);
1140 :     } else {
1141 : suxen_drol 136 pEnc->current->quant = pFrame->quant;
1142 : Isibaar 3 }
1143 :    
1144 : edgomez 195 if ((pEnc->current->global_flags & XVID_LUMIMASKING)) {
1145 :     int *temp_dquants =
1146 :     (int *) xvid_malloc(pEnc->mbParam.mb_width *
1147 :     pEnc->mbParam.mb_height * sizeof(int),
1148 :     CACHE_LINE);
1149 :    
1150 : edgomez 194 pEnc->current->quant =
1151 :     adaptive_quantization(pEnc->current->image.y,
1152 : edgomez 195 pEnc->mbParam.edged_width, temp_dquants,
1153 :     pEnc->current->quant, pEnc->current->quant,
1154 :     2 * pEnc->current->quant,
1155 :     pEnc->mbParam.mb_width,
1156 :     pEnc->mbParam.mb_height);
1157 : edgomez 194
1158 : edgomez 195 for (y = 0; y < pEnc->mbParam.mb_height; y++) {
1159 : edgomez 194
1160 : edgomez 195 #define OFFSET(x,y) ((x) + (y)*pEnc->mbParam.mb_width)
1161 : edgomez 194
1162 : edgomez 195 for (x = 0; x < pEnc->mbParam.mb_width; x++) {
1163 : edgomez 194
1164 : edgomez 195
1165 :     MACROBLOCK *pMB = &pEnc->current->mbs[OFFSET(x, y)];
1166 :    
1167 :     pMB->dquant = iDQtab[temp_dquants[OFFSET(x, y)] + 2];
1168 : Isibaar 3 }
1169 : edgomez 194
1170 : edgomez 195 #undef OFFSET
1171 : edgomez 194 }
1172 :    
1173 : Isibaar 41 xvid_free(temp_dquants);
1174 : Isibaar 3 }
1175 :    
1176 : edgomez 195 if (pEnc->current->global_flags & XVID_H263QUANT) {
1177 :     if (pEnc->mbParam.m_quant_type != H263_QUANT)
1178 : Isibaar 20 write_vol_header = 1;
1179 : suxen_drol 136 pEnc->mbParam.m_quant_type = H263_QUANT;
1180 : edgomez 195 } else if (pEnc->current->global_flags & XVID_MPEGQUANT) {
1181 : edgomez 194 int matrix1_changed, matrix2_changed;
1182 : Isibaar 3
1183 : edgomez 194 matrix1_changed = matrix2_changed = 0;
1184 : edgomez 78
1185 : edgomez 195 if (pEnc->mbParam.m_quant_type != MPEG4_QUANT)
1186 : Isibaar 20 write_vol_header = 1;
1187 : edgomez 195
1188 : suxen_drol 136 pEnc->mbParam.m_quant_type = MPEG4_QUANT;
1189 : edgomez 195
1190 : suxen_drol 136 if ((pEnc->current->global_flags & XVID_CUSTOM_QMATRIX) > 0) {
1191 : edgomez 195 if (pFrame->quant_intra_matrix != NULL)
1192 :     matrix1_changed = set_intra_matrix(pFrame->quant_intra_matrix);
1193 :     if (pFrame->quant_inter_matrix != NULL)
1194 :     matrix2_changed = set_inter_matrix(pFrame->quant_inter_matrix);
1195 :     } else {
1196 : edgomez 194 matrix1_changed = set_intra_matrix(get_default_intra_matrix());
1197 :     matrix2_changed = set_inter_matrix(get_default_inter_matrix());
1198 : Isibaar 20 }
1199 : edgomez 195 if (write_vol_header == 0)
1200 : edgomez 194 write_vol_header = matrix1_changed | matrix2_changed;
1201 : Isibaar 4 }
1202 : Isibaar 3
1203 : edgomez 195 if (pFrame->intra < 0) {
1204 :     if ((pEnc->iFrameNum == 0)
1205 :     || ((pEnc->iMaxKeyInterval > 0)
1206 :     && (pEnc->iFrameNum >= pEnc->iMaxKeyInterval))) {
1207 :     pFrame->intra = FrameCodeI(pEnc, &bs, &bits);
1208 :     } else {
1209 :     pFrame->intra = FrameCodeP(pEnc, &bs, &bits, 0, write_vol_header);
1210 : edgomez 194 }
1211 : edgomez 195 } else {
1212 :     if (pFrame->intra == 1) {
1213 :     pFrame->intra = FrameCodeI(pEnc, &bs, &bits);
1214 :     } else {
1215 :     pFrame->intra = FrameCodeP(pEnc, &bs, &bits, 1, write_vol_header);
1216 : edgomez 194 }
1217 :    
1218 : edgomez 13 }
1219 : Isibaar 3
1220 :     BitstreamPutBits(&bs, 0xFFFF, 16);
1221 : edgomez 13 BitstreamPutBits(&bs, 0xFFFF, 16);
1222 :     BitstreamPad(&bs);
1223 :     pFrame->length = BitstreamLength(&bs);
1224 : h 29
1225 : edgomez 195 if (pResult) {
1226 : suxen_drol 136 pResult->quant = pEnc->current->quant;
1227 : Isibaar 3 pResult->hlength = pFrame->length - (pEnc->sStat.iTextBits / 8);
1228 :     pResult->kblks = pEnc->sStat.kblks;
1229 :     pResult->mblks = pEnc->sStat.mblks;
1230 :     pResult->ublks = pEnc->sStat.ublks;
1231 : edgomez 13 }
1232 : edgomez 195
1233 : edgomez 198 emms();
1234 : Isibaar 41
1235 : edgomez 195 if (pFrame->quant == 0) {
1236 :     RateControlUpdate(&pEnc->rate_control, pEnc->current->quant,
1237 :     pFrame->length, pFrame->intra);
1238 : Isibaar 3 }
1239 : suxen_drol 229 #ifdef _DEBUG_PSNR
1240 : edgomez 195 psnr =
1241 :     image_psnr(&pEnc->sOriginal, &pEnc->current->image,
1242 :     pEnc->mbParam.edged_width, pEnc->mbParam.width,
1243 :     pEnc->mbParam.height);
1244 : Isibaar 113
1245 : edgomez 194 snprintf(temp, 127, "PSNR: %f\n", psnr);
1246 : Isibaar 113 DEBUG(temp);
1247 :     #endif
1248 :    
1249 : suxen_drol 229 inc_frame_num(pEnc);
1250 : Isibaar 3 pEnc->iFrameNum++;
1251 : edgomez 195
1252 : Isibaar 3 stop_global_timer();
1253 :     write_timer();
1254 :    
1255 :     return XVID_ERR_OK;
1256 :     }
1257 :    
1258 :    
1259 : edgomez 195 static __inline void
1260 :     CodeIntraMB(Encoder * pEnc,
1261 :     MACROBLOCK * pMB)
1262 :     {
1263 : Isibaar 3
1264 :     pMB->mode = MODE_INTRA;
1265 :    
1266 : suxen_drol 136 /* zero mv statistics */
1267 :     pMB->mvs[0].x = pMB->mvs[1].x = pMB->mvs[2].x = pMB->mvs[3].x = 0;
1268 :     pMB->mvs[0].y = pMB->mvs[1].y = pMB->mvs[2].y = pMB->mvs[3].y = 0;
1269 :     pMB->sad8[0] = pMB->sad8[1] = pMB->sad8[2] = pMB->sad8[3] = 0;
1270 :     pMB->sad16 = 0;
1271 :    
1272 :     if ((pEnc->current->global_flags & XVID_LUMIMASKING)) {
1273 : edgomez 195 if (pMB->dquant != NO_CHANGE) {
1274 : Isibaar 3 pMB->mode = MODE_INTRA_Q;
1275 : suxen_drol 136 pEnc->current->quant += DQtab[pMB->dquant];
1276 : edgomez 195
1277 :     if (pEnc->current->quant > 31)
1278 :     pEnc->current->quant = 31;
1279 :     if (pEnc->current->quant < 1)
1280 :     pEnc->current->quant = 1;
1281 : Isibaar 3 }
1282 :     }
1283 :    
1284 : suxen_drol 136 pMB->quant = pEnc->current->quant;
1285 : Isibaar 3 }
1286 :    
1287 :    
1288 : h 101 #define FCODEBITS 3
1289 :     #define MODEBITS 5
1290 :    
1291 : edgomez 195 void
1292 :     HintedMESet(Encoder * pEnc,
1293 :     int *intra)
1294 : h 101 {
1295 : edgomez 195 HINTINFO *hint;
1296 : h 101 Bitstream bs;
1297 :     int length, high;
1298 :     uint32_t x, y;
1299 :    
1300 :     hint = pEnc->mbParam.hint;
1301 :    
1302 : edgomez 195 if (hint->rawhints) {
1303 : h 101 *intra = hint->mvhint.intra;
1304 : edgomez 195 } else {
1305 : h 101 BitstreamInit(&bs, hint->hintstream, hint->hintlength);
1306 :     *intra = BitstreamGetBit(&bs);
1307 :     }
1308 :    
1309 : edgomez 195 if (*intra) {
1310 : h 101 return;
1311 :     }
1312 :    
1313 : edgomez 195 pEnc->current->fcode =
1314 :     (hint->rawhints) ? hint->mvhint.fcode : BitstreamGetBits(&bs,
1315 :     FCODEBITS);
1316 : h 101
1317 : edgomez 195 length = pEnc->current->fcode + 5;
1318 :     high = 1 << (length - 1);
1319 : h 101
1320 : edgomez 195 for (y = 0; y < pEnc->mbParam.mb_height; ++y) {
1321 :     for (x = 0; x < pEnc->mbParam.mb_width; ++x) {
1322 :     MACROBLOCK *pMB =
1323 :     &pEnc->current->mbs[x + y * pEnc->mbParam.mb_width];
1324 :     MVBLOCKHINT *bhint =
1325 :     &hint->mvhint.block[x + y * pEnc->mbParam.mb_width];
1326 : chl 284 VECTOR pred;
1327 : h 101 VECTOR tmp;
1328 :     int vec;
1329 :    
1330 : edgomez 195 pMB->mode =
1331 :     (hint->rawhints) ? bhint->mode : BitstreamGetBits(&bs,
1332 :     MODEBITS);
1333 : h 101
1334 : h 128 pMB->mode = (pMB->mode == MODE_INTER_Q) ? MODE_INTER : pMB->mode;
1335 :     pMB->mode = (pMB->mode == MODE_INTRA_Q) ? MODE_INTRA : pMB->mode;
1336 :    
1337 : edgomez 195 if (pMB->mode == MODE_INTER) {
1338 :     tmp.x =
1339 :     (hint->rawhints) ? bhint->mvs[0].x : BitstreamGetBits(&bs,
1340 :     length);
1341 :     tmp.y =
1342 :     (hint->rawhints) ? bhint->mvs[0].y : BitstreamGetBits(&bs,
1343 :     length);
1344 :     tmp.x -= (tmp.x >= high) ? high * 2 : 0;
1345 :     tmp.y -= (tmp.y >= high) ? high * 2 : 0;
1346 : h 101
1347 : chl 284 pred = get_pmv2(pEnc->current->mbs,pEnc->mbParam.mb_width,0,x,y,0);
1348 : h 101
1349 : edgomez 195 for (vec = 0; vec < 4; ++vec) {
1350 :     pMB->mvs[vec].x = tmp.x;
1351 :     pMB->mvs[vec].y = tmp.y;
1352 : chl 284 pMB->pmvs[vec].x = pMB->mvs[0].x - pred.x;
1353 :     pMB->pmvs[vec].y = pMB->mvs[0].y - pred.y;
1354 : h 101 }
1355 : edgomez 195 } else if (pMB->mode == MODE_INTER4V) {
1356 :     for (vec = 0; vec < 4; ++vec) {
1357 :     tmp.x =
1358 :     (hint->rawhints) ? bhint->mvs[vec].
1359 :     x : BitstreamGetBits(&bs, length);
1360 :     tmp.y =
1361 :     (hint->rawhints) ? bhint->mvs[vec].
1362 :     y : BitstreamGetBits(&bs, length);
1363 :     tmp.x -= (tmp.x >= high) ? high * 2 : 0;
1364 :     tmp.y -= (tmp.y >= high) ? high * 2 : 0;
1365 : h 101
1366 : chl 284 pred = get_pmv2(pEnc->current->mbs,pEnc->mbParam.mb_width,0,x,y,vec);
1367 : h 101
1368 : edgomez 195 pMB->mvs[vec].x = tmp.x;
1369 :     pMB->mvs[vec].y = tmp.y;
1370 : chl 284 pMB->pmvs[vec].x = pMB->mvs[vec].x - pred.x;
1371 :     pMB->pmvs[vec].y = pMB->mvs[vec].y - pred.y;
1372 : h 101 }
1373 : edgomez 195 } else // intra / stuffing / not_coded
1374 : h 101 {
1375 : edgomez 195 for (vec = 0; vec < 4; ++vec) {
1376 :     pMB->mvs[vec].x = pMB->mvs[vec].y = 0;
1377 : h 101 }
1378 :     }
1379 : h 128
1380 : suxen_drol 136 if (pMB->mode == MODE_INTER4V &&
1381 : edgomez 195 (pEnc->current->global_flags & XVID_LUMIMASKING)
1382 :     && pMB->dquant != NO_CHANGE) {
1383 : h 128 pMB->mode = MODE_INTRA;
1384 :    
1385 : edgomez 195 for (vec = 0; vec < 4; ++vec) {
1386 : h 128 pMB->mvs[vec].x = pMB->mvs[vec].y = 0;
1387 :     }
1388 :     }
1389 : h 101 }
1390 :     }
1391 :     }
1392 :    
1393 :    
1394 : edgomez 195 void
1395 :     HintedMEGet(Encoder * pEnc,
1396 :     int intra)
1397 : h 101 {
1398 : edgomez 195 HINTINFO *hint;
1399 : h 101 Bitstream bs;
1400 :     uint32_t x, y;
1401 :     int length, high;
1402 :    
1403 :     hint = pEnc->mbParam.hint;
1404 :    
1405 : edgomez 195 if (hint->rawhints) {
1406 : h 101 hint->mvhint.intra = intra;
1407 : edgomez 195 } else {
1408 : h 101 BitstreamInit(&bs, hint->hintstream, 0);
1409 :     BitstreamPutBit(&bs, intra);
1410 :     }
1411 :    
1412 : edgomez 195 if (intra) {
1413 :     if (!hint->rawhints) {
1414 : h 101 BitstreamPad(&bs);
1415 :     hint->hintlength = BitstreamLength(&bs);
1416 :     }
1417 :     return;
1418 :     }
1419 :    
1420 : edgomez 195 length = pEnc->current->fcode + 5;
1421 :     high = 1 << (length - 1);
1422 : h 101
1423 : edgomez 195 if (hint->rawhints) {
1424 : suxen_drol 136 hint->mvhint.fcode = pEnc->current->fcode;
1425 : edgomez 195 } else {
1426 : suxen_drol 136 BitstreamPutBits(&bs, pEnc->current->fcode, FCODEBITS);
1427 : h 101 }
1428 :    
1429 : edgomez 195 for (y = 0; y < pEnc->mbParam.mb_height; ++y) {
1430 :     for (x = 0; x < pEnc->mbParam.mb_width; ++x) {
1431 :     MACROBLOCK *pMB =
1432 :     &pEnc->current->mbs[x + y * pEnc->mbParam.mb_width];
1433 :     MVBLOCKHINT *bhint =
1434 :     &hint->mvhint.block[x + y * pEnc->mbParam.mb_width];
1435 : h 101 VECTOR tmp;
1436 :    
1437 : edgomez 195 if (hint->rawhints) {
1438 : h 101 bhint->mode = pMB->mode;
1439 : edgomez 195 } else {
1440 : h 101 BitstreamPutBits(&bs, pMB->mode, MODEBITS);
1441 :     }
1442 :    
1443 : edgomez 195 if (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) {
1444 :     tmp.x = pMB->mvs[0].x;
1445 :     tmp.y = pMB->mvs[0].y;
1446 :     tmp.x += (tmp.x < 0) ? high * 2 : 0;
1447 :     tmp.y += (tmp.y < 0) ? high * 2 : 0;
1448 : h 101
1449 : edgomez 195 if (hint->rawhints) {
1450 : h 101 bhint->mvs[0].x = tmp.x;
1451 :     bhint->mvs[0].y = tmp.y;
1452 : edgomez 195 } else {
1453 : h 101 BitstreamPutBits(&bs, tmp.x, length);
1454 :     BitstreamPutBits(&bs, tmp.y, length);
1455 :     }
1456 : edgomez 195 } else if (pMB->mode == MODE_INTER4V) {
1457 : h 101 int vec;
1458 :    
1459 : edgomez 195 for (vec = 0; vec < 4; ++vec) {
1460 :     tmp.x = pMB->mvs[vec].x;
1461 :     tmp.y = pMB->mvs[vec].y;
1462 :     tmp.x += (tmp.x < 0) ? high * 2 : 0;
1463 :     tmp.y += (tmp.y < 0) ? high * 2 : 0;
1464 : h 101
1465 : edgomez 195 if (hint->rawhints) {
1466 : h 101 bhint->mvs[vec].x = tmp.x;
1467 :     bhint->mvs[vec].y = tmp.y;
1468 : edgomez 195 } else {
1469 : h 101 BitstreamPutBits(&bs, tmp.x, length);
1470 :     BitstreamPutBits(&bs, tmp.y, length);
1471 :     }
1472 :     }
1473 :     }
1474 :     }
1475 :     }
1476 :    
1477 : edgomez 195 if (!hint->rawhints) {
1478 : h 101 BitstreamPad(&bs);
1479 :     hint->hintlength = BitstreamLength(&bs);
1480 :     }
1481 :     }
1482 :    
1483 :    
1484 : edgomez 195 static int
1485 :     FrameCodeI(Encoder * pEnc,
1486 :     Bitstream * bs,
1487 :     uint32_t * pBits)
1488 : h 104 {
1489 :    
1490 :     DECLARE_ALIGNED_MATRIX(dct_codes, 6, 64, int16_t, CACHE_LINE);
1491 : edgomez 195 DECLARE_ALIGNED_MATRIX(qcoeff, 6, 64, int16_t, CACHE_LINE);
1492 : h 104
1493 :     uint16_t x, y;
1494 :    
1495 :     pEnc->iFrameNum = 0;
1496 : suxen_drol 136 pEnc->mbParam.m_rounding_type = 1;
1497 :     pEnc->current->rounding_type = pEnc->mbParam.m_rounding_type;
1498 :     pEnc->current->coding_type = I_VOP;
1499 : h 104
1500 : suxen_drol 136 BitstreamWriteVolHeader(bs, &pEnc->mbParam, pEnc->current);
1501 : chl 530
1502 : suxen_drol 229 #define DIVX501B481P "DivX501b481p"
1503 : suxen_drol 234 if ((pEnc->global & XVID_GLOBAL_PACKED)) {
1504 : suxen_drol 229 BitstreamWriteUserData(bs, DIVX501B481P, strlen(DIVX501B481P));
1505 :     }
1506 : chl 557
1507 :     set_timecodes(pEnc->current,pEnc->reference,pEnc->mbParam.fbase);
1508 : suxen_drol 229 BitstreamWriteVopHeader(bs, &pEnc->mbParam, pEnc->current, 1);
1509 : h 104
1510 :     *pBits = BitstreamPos(bs);
1511 :    
1512 :     pEnc->sStat.iTextBits = 0;
1513 :     pEnc->sStat.kblks = pEnc->mbParam.mb_width * pEnc->mbParam.mb_height;
1514 :     pEnc->sStat.mblks = pEnc->sStat.ublks = 0;
1515 :    
1516 :     for (y = 0; y < pEnc->mbParam.mb_height; y++)
1517 : edgomez 195 for (x = 0; x < pEnc->mbParam.mb_width; x++) {
1518 :     MACROBLOCK *pMB =
1519 :     &pEnc->current->mbs[x + y * pEnc->mbParam.mb_width];
1520 : h 104
1521 :     CodeIntraMB(pEnc, pMB);
1522 :    
1523 : edgomez 195 MBTransQuantIntra(&pEnc->mbParam, pEnc->current, pMB, x, y,
1524 :     dct_codes, qcoeff);
1525 : h 104
1526 :     start_timer();
1527 : suxen_drol 136 MBPrediction(pEnc->current, x, y, pEnc->mbParam.mb_width, qcoeff);
1528 : h 104 stop_prediction_timer();
1529 :    
1530 :     start_timer();
1531 : chl 353 if (pEnc->current->global_flags & XVID_GREYSCALE)
1532 :     { pMB->cbp &= 0x3C; /* keep only bits 5-2 */
1533 :     qcoeff[4*64+0]=0; /* zero, because for INTRA MBs DC value is saved */
1534 :     qcoeff[5*64+0]=0;
1535 :     }
1536 : suxen_drol 136 MBCoding(pEnc->current, pMB, qcoeff, bs, &pEnc->sStat);
1537 : h 104 stop_coding_timer();
1538 :     }
1539 :    
1540 :     emms();
1541 :    
1542 :     *pBits = BitstreamPos(bs) - *pBits;
1543 :     pEnc->sStat.fMvPrevSigma = -1;
1544 :     pEnc->sStat.iMvSum = 0;
1545 :     pEnc->sStat.iMvCount = 0;
1546 : suxen_drol 136 pEnc->mbParam.m_fcode = 2;
1547 : h 104
1548 : edgomez 195 if (pEnc->current->global_flags & XVID_HINTEDME_GET) {
1549 : h 104 HintedMEGet(pEnc, 1);
1550 :     }
1551 :    
1552 : edgomez 195 return 1; // intra
1553 : h 104 }
1554 :    
1555 :    
1556 : Isibaar 3 #define INTRA_THRESHOLD 0.5
1557 : chl 530 #define BFRAME_SKIP_THRESHHOLD 30
1558 : Isibaar 3
1559 : edgomez 195 static int
1560 :     FrameCodeP(Encoder * pEnc,
1561 :     Bitstream * bs,
1562 :     uint32_t * pBits,
1563 :     bool force_inter,
1564 :     bool vol_header)
1565 : Isibaar 3 {
1566 : edgomez 13 float fSigma;
1567 : Isibaar 42
1568 : edgomez 78 DECLARE_ALIGNED_MATRIX(dct_codes, 6, 64, int16_t, CACHE_LINE);
1569 : edgomez 195 DECLARE_ALIGNED_MATRIX(qcoeff, 6, 64, int16_t, CACHE_LINE);
1570 : edgomez 78
1571 : Isibaar 3 int iLimit;
1572 : chl 354 int x, y, k;
1573 : edgomez 13 int iSearchRange;
1574 : edgomez 145 int bIntra;
1575 : suxen_drol 240
1576 : edgomez 145 /* IMAGE *pCurrent = &pEnc->current->image; */
1577 : suxen_drol 136 IMAGE *pRef = &pEnc->reference->image;
1578 : Isibaar 3
1579 : h 69 start_timer();
1580 : edgomez 195 image_setedges(pRef, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height,
1581 : h 543 pEnc->mbParam.width, pEnc->mbParam.height);
1582 : h 69 stop_edges_timer();
1583 : Isibaar 3
1584 : suxen_drol 136 pEnc->mbParam.m_rounding_type = 1 - pEnc->mbParam.m_rounding_type;
1585 :     pEnc->current->rounding_type = pEnc->mbParam.m_rounding_type;
1586 :     pEnc->current->fcode = pEnc->mbParam.m_fcode;
1587 : Isibaar 3
1588 :     if (!force_inter)
1589 : edgomez 195 iLimit =
1590 :     (int) (pEnc->mbParam.mb_width * pEnc->mbParam.mb_height *
1591 :     INTRA_THRESHOLD);
1592 : edgomez 13 else
1593 : Isibaar 3 iLimit = pEnc->mbParam.mb_width * pEnc->mbParam.mb_height + 1;
1594 :    
1595 : suxen_drol 136 if ((pEnc->current->global_flags & XVID_HALFPEL)) {
1596 : Isibaar 3 start_timer();
1597 : edgomez 195 image_interpolate(pRef, &pEnc->vInterH, &pEnc->vInterV,
1598 :     &pEnc->vInterHV, pEnc->mbParam.edged_width,
1599 :     pEnc->mbParam.edged_height,
1600 :     pEnc->current->rounding_type);
1601 : Isibaar 3 stop_inter_timer();
1602 :     }
1603 :    
1604 :     start_timer();
1605 : edgomez 195 if (pEnc->current->global_flags & XVID_HINTEDME_SET) {
1606 : h 101 HintedMESet(pEnc, &bIntra);
1607 : chl 530 if (bIntra == 0) MotionEstimationHinted(&pEnc->mbParam, pEnc->current, pEnc->reference,
1608 :     &pEnc->vInterH, &pEnc->vInterV, &pEnc->vInterHV);
1609 :    
1610 : edgomez 195 } else {
1611 : chl 259
1612 : chl 530 bIntra =
1613 :     MotionEstimation(&pEnc->mbParam, pEnc->current, pEnc->reference,
1614 : suxen_drol 295 &pEnc->vInterH, &pEnc->vInterV, &pEnc->vInterHV,
1615 :     iLimit);
1616 :    
1617 : h 101 }
1618 : Isibaar 3 stop_motion_timer();
1619 :    
1620 : chl 530 if (bIntra == 1) return FrameCodeI(pEnc, bs, pBits);
1621 : Isibaar 3
1622 : suxen_drol 136 pEnc->current->coding_type = P_VOP;
1623 : Isibaar 3
1624 : edgomez 195 if (vol_header)
1625 : suxen_drol 136 BitstreamWriteVolHeader(bs, &pEnc->mbParam, pEnc->current);
1626 : chl 557
1627 : Isibaar 3
1628 : chl 557 set_timecodes(pEnc->current,pEnc->reference,pEnc->mbParam.fbase);
1629 : suxen_drol 229 BitstreamWriteVopHeader(bs, &pEnc->mbParam, pEnc->current, 1);
1630 : Isibaar 3
1631 : edgomez 13 *pBits = BitstreamPos(bs);
1632 : Isibaar 3
1633 : chl 530 pEnc->sStat.iTextBits = pEnc->sStat.iMvSum = pEnc->sStat.iMvCount =
1634 :     pEnc->sStat.kblks = pEnc->sStat.mblks = pEnc->sStat.ublks = 0;
1635 : Isibaar 3
1636 : edgomez 195 for (y = 0; y < pEnc->mbParam.mb_height; y++) {
1637 :     for (x = 0; x < pEnc->mbParam.mb_width; x++) {
1638 :     MACROBLOCK *pMB =
1639 :     &pEnc->current->mbs[x + y * pEnc->mbParam.mb_width];
1640 : Isibaar 3
1641 : edgomez 13 bIntra = (pMB->mode == MODE_INTRA) || (pMB->mode == MODE_INTRA_Q);
1642 : Isibaar 3
1643 : edgomez 195 if (!bIntra) {
1644 : Isibaar 3 start_timer();
1645 : edgomez 195 MBMotionCompensation(pMB, x, y, &pEnc->reference->image,
1646 :     &pEnc->vInterH, &pEnc->vInterV,
1647 :     &pEnc->vInterHV, &pEnc->current->image,
1648 :     dct_codes, pEnc->mbParam.width,
1649 :     pEnc->mbParam.height,
1650 :     pEnc->mbParam.edged_width,
1651 :     pEnc->current->rounding_type);
1652 : Isibaar 3 stop_comp_timer();
1653 :    
1654 : suxen_drol 136 if ((pEnc->current->global_flags & XVID_LUMIMASKING)) {
1655 : edgomez 195 if (pMB->dquant != NO_CHANGE) {
1656 : Isibaar 3 pMB->mode = MODE_INTER_Q;
1657 : suxen_drol 136 pEnc->current->quant += DQtab[pMB->dquant];
1658 : edgomez 195 if (pEnc->current->quant > 31)
1659 :     pEnc->current->quant = 31;
1660 :     else if (pEnc->current->quant < 1)
1661 :     pEnc->current->quant = 1;
1662 : Isibaar 3 }
1663 :     }
1664 : suxen_drol 136 pMB->quant = pEnc->current->quant;
1665 : Isibaar 3
1666 : h 69 pMB->field_pred = 0;
1667 :    
1668 : chl 530 if (pMB->mode != MODE_NOT_CODED)
1669 :     pMB->cbp =
1670 :     MBTransQuantInter(&pEnc->mbParam, pEnc->current, pMB, x, y,
1671 :     dct_codes, qcoeff);
1672 : edgomez 195 } else {
1673 : Isibaar 3 CodeIntraMB(pEnc, pMB);
1674 : edgomez 195 MBTransQuantIntra(&pEnc->mbParam, pEnc->current, pMB, x, y,
1675 :     dct_codes, qcoeff);
1676 : Isibaar 3 }
1677 :    
1678 : edgomez 13 start_timer();
1679 : edgomez 195 MBPrediction(pEnc->current, x, y, pEnc->mbParam.mb_width, qcoeff);
1680 : Isibaar 3 stop_prediction_timer();
1681 :    
1682 : edgomez 195 if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q) {
1683 : Isibaar 3 pEnc->sStat.kblks++;
1684 : edgomez 195 } else if (pMB->cbp || pMB->mvs[0].x || pMB->mvs[0].y ||
1685 :     pMB->mvs[1].x || pMB->mvs[1].y || pMB->mvs[2].x ||
1686 :     pMB->mvs[2].y || pMB->mvs[3].x || pMB->mvs[3].y) {
1687 : Isibaar 3 pEnc->sStat.mblks++;
1688 : chl 340 } else {
1689 : Isibaar 3 pEnc->sStat.ublks++;
1690 : chl 340 }
1691 : Isibaar 3
1692 :     start_timer();
1693 : chl 347
1694 :     /* Finished processing the MB, now check if to CODE or SKIP */
1695 :    
1696 : chl 530 if ((pMB->mode == MODE_NOT_CODED) ||
1697 :     (pMB->cbp == 0 && pMB->mode == MODE_INTER && pMB->mvs[0].x == 0 &&
1698 :     pMB->mvs[0].y == 0 && pMB->dquant == NO_CHANGE)) {
1699 : chl 347
1700 :     /* This is a candidate for SKIPping, but check intermediate B-frames first */
1701 :    
1702 : chl 530 int bSkip = 1;
1703 :     pMB->mode = MODE_NOT_CODED;
1704 : chl 347
1705 :     for (k=pEnc->bframenum_head; k< pEnc->bframenum_tail; k++)
1706 :     {
1707 : chl 530 int iSAD;
1708 : chl 347 iSAD = sad16(pEnc->reference->image.y + 16*y*pEnc->mbParam.edged_width + 16*x,
1709 :     pEnc->bframes[k]->image.y + 16*y*pEnc->mbParam.edged_width + 16*x,
1710 :     pEnc->mbParam.edged_width,BFRAME_SKIP_THRESHHOLD);
1711 : chl 530 if (iSAD >= BFRAME_SKIP_THRESHHOLD * pMB->quant)
1712 : chl 347 { bSkip = 0;
1713 :     break;
1714 :     }
1715 :     }
1716 :     if (!bSkip)
1717 :     {
1718 : chl 530 VECTOR predMV;
1719 :     predMV = get_pmv2(pEnc->current->mbs, pEnc->mbParam.mb_width, 0, x, y, 0);
1720 :     pMB->pmvs[0].x = -predMV.x; pMB->pmvs[0].y = -predMV.y;
1721 :     pMB->mode = MODE_INTER;
1722 :     pMB->cbp = 0;
1723 : chl 347 MBCoding(pEnc->current, pMB, qcoeff, bs, &pEnc->sStat);
1724 :     }
1725 : chl 530 else MBSkip(bs);
1726 :    
1727 : chl 347 } else {
1728 : chl 353 if (pEnc->current->global_flags & XVID_GREYSCALE)
1729 :     { pMB->cbp &= 0x3C; /* keep only bits 5-2 */
1730 :     qcoeff[4*64+0]=0; /* zero, because DC for INTRA MBs DC value is saved */
1731 :     qcoeff[5*64+0]=0;
1732 :     }
1733 : chl 347 MBCoding(pEnc->current, pMB, qcoeff, bs, &pEnc->sStat);
1734 :     }
1735 :    
1736 : Isibaar 3 stop_coding_timer();
1737 :     }
1738 :     }
1739 :    
1740 :     emms();
1741 :    
1742 : edgomez 195 if (pEnc->current->global_flags & XVID_HINTEDME_GET) {
1743 : h 101 HintedMEGet(pEnc, 0);
1744 :     }
1745 :    
1746 : Isibaar 3 if (pEnc->sStat.iMvCount == 0)
1747 :     pEnc->sStat.iMvCount = 1;
1748 :    
1749 : edgomez 195 fSigma = (float) sqrt((float) pEnc->sStat.iMvSum / pEnc->sStat.iMvCount);
1750 : Isibaar 3
1751 : suxen_drol 136 iSearchRange = 1 << (3 + pEnc->mbParam.m_fcode);
1752 : Isibaar 3
1753 : edgomez 195 if ((fSigma > iSearchRange / 3)
1754 :     && (pEnc->mbParam.m_fcode <= 3)) // maximum search range 128
1755 : edgomez 13 {
1756 : suxen_drol 136 pEnc->mbParam.m_fcode++;
1757 : Isibaar 3 iSearchRange *= 2;
1758 : edgomez 195 } else if ((fSigma < iSearchRange / 6)
1759 :     && (pEnc->sStat.fMvPrevSigma >= 0)
1760 :     && (pEnc->sStat.fMvPrevSigma < iSearchRange / 6)
1761 :     && (pEnc->mbParam.m_fcode >= 2)) // minimum search range 16
1762 : edgomez 13 {
1763 : suxen_drol 136 pEnc->mbParam.m_fcode--;
1764 : Isibaar 3 iSearchRange /= 2;
1765 : edgomez 13 }
1766 : Isibaar 3
1767 : edgomez 13 pEnc->sStat.fMvPrevSigma = fSigma;
1768 : edgomez 195
1769 : chl 557 #ifdef FRAMEDROP
1770 : suxen_drol 324 /* frame drop code */
1771 :     // DPRINTF(DPRINTF_DEBUG, "kmu %i %i %i", pEnc->sStat.kblks, pEnc->sStat.mblks, pEnc->sStat.ublks);
1772 : chl 350 if (pEnc->sStat.kblks + pEnc->sStat.mblks <
1773 : suxen_drol 324 (pEnc->frame_drop_ratio * pEnc->mbParam.mb_width * pEnc->mbParam.mb_height) / 100)
1774 :     {
1775 :     pEnc->sStat.kblks = pEnc->sStat.mblks = 0;
1776 :     pEnc->sStat.ublks = pEnc->mbParam.mb_width * pEnc->mbParam.mb_height;
1777 :    
1778 :     BitstreamReset(bs);
1779 : chl 557
1780 :     set_timecodes(pEnc->current,pEnc->reference,pEnc->mbParam.fbase);
1781 : suxen_drol 324 BitstreamWriteVopHeader(bs, &pEnc->mbParam, pEnc->current, 0);
1782 :    
1783 :     // copy reference frame details into the current frame
1784 :     pEnc->current->quant = pEnc->reference->quant;
1785 :     pEnc->current->motion_flags = pEnc->reference->motion_flags;
1786 :     pEnc->current->rounding_type = pEnc->reference->rounding_type;
1787 :     pEnc->current->fcode = pEnc->reference->fcode;
1788 :     pEnc->current->bcode = pEnc->reference->bcode;
1789 :     image_copy(&pEnc->current->image, &pEnc->reference->image, pEnc->mbParam.edged_width, pEnc->mbParam.height);
1790 :     memcpy(pEnc->current->mbs, pEnc->reference->mbs, sizeof(MACROBLOCK) * pEnc->mbParam.mb_width * pEnc->mbParam.mb_height);
1791 :    
1792 :     }
1793 :     #endif
1794 :    
1795 : Isibaar 3 *pBits = BitstreamPos(bs) - *pBits;
1796 :    
1797 : edgomez 195 return 0; // inter
1798 : Isibaar 3 }
1799 : suxen_drol 118
1800 :    
1801 : chl 530 static __inline void
1802 : edgomez 195 FrameCodeB(Encoder * pEnc,
1803 :     FRAMEINFO * frame,
1804 :     Bitstream * bs,
1805 :     uint32_t * pBits)
1806 : suxen_drol 118 {
1807 : edgomez 195 int16_t dct_codes[6 * 64];
1808 :     int16_t qcoeff[6 * 64];
1809 :     uint32_t x, y;
1810 : suxen_drol 118
1811 : edgomez 195 IMAGE *f_ref = &pEnc->reference->image;
1812 : suxen_drol 118 IMAGE *b_ref = &pEnc->current->image;
1813 :    
1814 : chenm001 290 #ifdef BFRAMES_DEC_DEBUG
1815 :     FILE *fp;
1816 :     static char first=0;
1817 :     #define BFRAME_DEBUG if (!first && fp){ \
1818 :     fprintf(fp,"Y=%3d X=%3d MB=%2d CBP=%02X\n",y,x,mb->mode,mb->cbp); \
1819 :     }
1820 :    
1821 :     if (!first){
1822 :     fp=fopen("C:\\XVIDDBGE.TXT","w");
1823 :     }
1824 :     #endif
1825 :    
1826 : suxen_drol 152 // forward
1827 : edgomez 195 image_setedges(f_ref, pEnc->mbParam.edged_width,
1828 :     pEnc->mbParam.edged_height, pEnc->mbParam.width,
1829 : h 543 pEnc->mbParam.height);
1830 : suxen_drol 118 start_timer();
1831 :     image_interpolate(f_ref, &pEnc->f_refh, &pEnc->f_refv, &pEnc->f_refhv,
1832 : edgomez 195 pEnc->mbParam.edged_width, pEnc->mbParam.edged_height,
1833 :     0);
1834 : suxen_drol 118 stop_inter_timer();
1835 :    
1836 : suxen_drol 152 // backward
1837 : edgomez 195 image_setedges(b_ref, pEnc->mbParam.edged_width,
1838 :     pEnc->mbParam.edged_height, pEnc->mbParam.width,
1839 : h 543 pEnc->mbParam.height);
1840 : edgomez 195 start_timer();
1841 : suxen_drol 118 image_interpolate(b_ref, &pEnc->vInterH, &pEnc->vInterV, &pEnc->vInterHV,
1842 : edgomez 195 pEnc->mbParam.edged_width, pEnc->mbParam.edged_height,
1843 :     0);
1844 : suxen_drol 118 stop_inter_timer();
1845 :    
1846 :     start_timer();
1847 : chl 557
1848 : chl 317 MotionEstimationBVOP(&pEnc->mbParam, frame,
1849 : chl 569 ((int32_t)(pEnc->current->stamp - frame->stamp)), // time_bp
1850 : chl 557 ((int32_t)(pEnc->current->stamp - pEnc->reference->stamp)), // time_pp
1851 :     pEnc->reference->mbs, f_ref,
1852 : edgomez 195 &pEnc->f_refh, &pEnc->f_refv, &pEnc->f_refhv,
1853 :     pEnc->current->mbs, b_ref, &pEnc->vInterH,
1854 :     &pEnc->vInterV, &pEnc->vInterHV);
1855 : suxen_drol 118
1856 : edgomez 195
1857 : suxen_drol 118 stop_motion_timer();
1858 : edgomez 195
1859 : suxen_drol 152 /*if (test_quant_type(&pEnc->mbParam, pEnc->current))
1860 : edgomez 195 {
1861 :     BitstreamWriteVolHeader(bs, pEnc->mbParam.width, pEnc->mbParam.height, pEnc->mbParam.quant_type);
1862 :     } */
1863 : suxen_drol 118
1864 : edgomez 195 frame->coding_type = B_VOP;
1865 : chl 557
1866 :     set_timecodes(frame, pEnc->reference,pEnc->mbParam.fbase);
1867 : suxen_drol 229 BitstreamWriteVopHeader(bs, &pEnc->mbParam, frame, 1);
1868 : suxen_drol 118
1869 : edgomez 195 *pBits = BitstreamPos(bs);
1870 : suxen_drol 118
1871 : edgomez 195 pEnc->sStat.iTextBits = 0;
1872 :     pEnc->sStat.iMvSum = 0;
1873 :     pEnc->sStat.iMvCount = 0;
1874 : suxen_drol 118 pEnc->sStat.kblks = pEnc->sStat.mblks = pEnc->sStat.ublks = 0;
1875 :    
1876 :    
1877 : edgomez 195 for (y = 0; y < pEnc->mbParam.mb_height; y++) {
1878 :     for (x = 0; x < pEnc->mbParam.mb_width; x++) {
1879 : chl 530 MACROBLOCK * const mb = &frame->mbs[x + y * pEnc->mbParam.mb_width];
1880 : h 543 int direction = pEnc->global & XVID_ALTERNATESCAN ? 2 : 0;
1881 : suxen_drol 118
1882 :     // decoder ignores mb when refence block is INTER(0,0), CBP=0
1883 : edgomez 195 if (mb->mode == MODE_NOT_CODED) {
1884 : chl 530 //mb->mvs[0].x = mb->mvs[0].y = mb->cbp = 0;
1885 : suxen_drol 118 continue;
1886 :     }
1887 :    
1888 : chl 530 if (mb->mode != MODE_DIRECT_NONE_MV) {
1889 :     MBMotionCompensationBVOP(&pEnc->mbParam, mb, x, y, &frame->image,
1890 : edgomez 195 f_ref, &pEnc->f_refh, &pEnc->f_refv,
1891 :     &pEnc->f_refhv, b_ref, &pEnc->vInterH,
1892 :     &pEnc->vInterV, &pEnc->vInterHV,
1893 :     dct_codes);
1894 :    
1895 : chl 530 if (mb->mode == MODE_DIRECT_NO4V) mb->mode = MODE_DIRECT;
1896 :     mb->quant = frame->quant;
1897 :    
1898 :     mb->cbp =
1899 :     MBTransQuantInterBVOP(&pEnc->mbParam, frame, mb, dct_codes, qcoeff);
1900 : suxen_drol 118
1901 : chl 530 if ( (mb->mode == MODE_DIRECT) && (mb->cbp == 0)
1902 :     && (mb->pmvs[3].x == 0) && (mb->pmvs[3].y == 0) ) {
1903 :     mb->mode = MODE_DIRECT_NONE_MV; // skipped
1904 :     }
1905 : suxen_drol 118 }
1906 :    
1907 : chenm001 290 #ifdef BFRAMES_DEC_DEBUG
1908 :     BFRAME_DEBUG
1909 :     #endif
1910 : edgomez 195 start_timer();
1911 :     MBCodingBVOP(mb, qcoeff, frame->fcode, frame->bcode, bs,
1912 : h 543 &pEnc->sStat, direction);
1913 : suxen_drol 118 stop_coding_timer();
1914 :     }
1915 :     }
1916 :    
1917 :     emms();
1918 :    
1919 :     // TODO: dynamic fcode/bcode ???
1920 :    
1921 :     *pBits = BitstreamPos(bs) - *pBits;
1922 : chenm001 290
1923 :     #ifdef BFRAMES_DEC_DEBUG
1924 :     if (!first){
1925 :     first=1;
1926 :     if (fp)
1927 :     fclose(fp);
1928 :     }
1929 :     #endif
1930 : suxen_drol 118 }
1931 : chl 340
1932 :    
1933 :     /* in case internal output is needed somewhere... */
1934 :     /* {
1935 :     FILE *filehandle;
1936 :     filehandle=fopen("last-b.pgm","wb");
1937 :     if (filehandle)
1938 :     {
1939 :     fprintf(filehandle,"P5\n\n"); //
1940 :     fprintf(filehandle,"%d %d 255\n",pEnc->mbParam.edged_width,pEnc->mbParam.edged_height);
1941 :     fwrite(frame->image.y,pEnc->mbParam.edged_width,pEnc->mbParam.edged_height,filehandle);
1942 :     fclose(filehandle);
1943 :     }
1944 :     }
1945 :     */

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