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

Diff of /xvidcore/src/encoder.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.28, Thu Apr 25 19:27:49 2002 UTC revision 1.33, Fri May 3 08:32:49 2002 UTC
# Line 1  Line 1 
1  // 14.04.2002   added FrameCodeB()  /**************************************************************************
2     *
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     ***************************************************************************/
30    
31    /****************************************************************************
32     *
33     *  History
34     *
35     *  14.04.2002 added FrameCodeB()
36     *
37     *  $Id$
38     *
39     ***************************************************************************/
40    
41  #include <stdlib.h>  #include <stdlib.h>
42  #include <stdio.h>  #include <stdio.h>
# Line 9  Line 47 
47  #include "global.h"  #include "global.h"
48  #include "utils/timer.h"  #include "utils/timer.h"
49  #include "image/image.h"  #include "image/image.h"
50    #include "motion/motion.h"
51  #include "bitstream/cbp.h"  #include "bitstream/cbp.h"
52  #include "utils/mbfunctions.h"  #include "utils/mbfunctions.h"
53  #include "bitstream/bitstream.h"  #include "bitstream/bitstream.h"
# Line 26  Line 65 
65    
66  static int FrameCodeI(Encoder * pEnc, Bitstream * bs, uint32_t *pBits);  static int FrameCodeI(Encoder * pEnc, Bitstream * bs, uint32_t *pBits);
67  static int FrameCodeP(Encoder * pEnc, Bitstream * bs, uint32_t *pBits, bool force_inter, bool vol_header);  static int FrameCodeP(Encoder * pEnc, Bitstream * bs, uint32_t *pBits, bool force_inter, bool vol_header);
68    static void FrameCodeB(Encoder * pEnc, FRAMEINFO * frame, Bitstream * bs, uint32_t *pBits);
69    
70  static int DQtab[4] =  static int DQtab[4] =
71  {  {
# Line 125  Line 165 
165          pEnc->mbParam.edged_width = 16 * pEnc->mbParam.mb_width + 2 * EDGE_SIZE;          pEnc->mbParam.edged_width = 16 * pEnc->mbParam.mb_width + 2 * EDGE_SIZE;
166          pEnc->mbParam.edged_height = 16 * pEnc->mbParam.mb_height + 2 * EDGE_SIZE;          pEnc->mbParam.edged_height = 16 * pEnc->mbParam.mb_height + 2 * EDGE_SIZE;
167    
168            pEnc->mbParam.fbase = pParam->fbase;
169            pEnc->mbParam.fincr = pParam->fincr;
170    
171          pEnc->sStat.fMvPrevSigma = -1;          pEnc->sStat.fMvPrevSigma = -1;
172    
173          /* Fill rate control parameters */          /* Fill rate control parameters */
# Line 151  Line 194 
194          pEnc->current->mbs = NULL;          pEnc->current->mbs = NULL;
195          pEnc->reference->mbs = NULL;          pEnc->reference->mbs = NULL;
196    
 #ifdef _DEBUG  
 #ifdef WIN32  
 OutputDebugString("malloc mbs");  
 #endif  
 #endif  
   
197          if ((pEnc->current->mbs = xvid_malloc(sizeof(MACROBLOCK) * pEnc->mbParam.mb_width * pEnc->mbParam.mb_height, CACHE_LINE)) == NULL ||          if ((pEnc->current->mbs = xvid_malloc(sizeof(MACROBLOCK) * pEnc->mbParam.mb_width * pEnc->mbParam.mb_height, CACHE_LINE)) == NULL ||
198                  (pEnc->reference->mbs = xvid_malloc(sizeof(MACROBLOCK) * pEnc->mbParam.mb_width * pEnc->mbParam.mb_height, CACHE_LINE)) == NULL)                  (pEnc->reference->mbs = xvid_malloc(sizeof(MACROBLOCK) * pEnc->mbParam.mb_width * pEnc->mbParam.mb_height, CACHE_LINE)) == NULL)
199          {          {
# Line 171  Line 208 
208  #ifdef _DEBUG  #ifdef _DEBUG
209          image_null(&pEnc->sOriginal);          image_null(&pEnc->sOriginal);
210  #endif  #endif
211    #ifdef BFRAMES
212            image_null(&pEnc->f_refh);
213            image_null(&pEnc->f_refv);
214            image_null(&pEnc->f_refhv);
215    #endif
216          image_null(&pEnc->current->image);          image_null(&pEnc->current->image);
217          image_null(&pEnc->reference->image);          image_null(&pEnc->reference->image);
218          image_null(&pEnc->vInterH);          image_null(&pEnc->vInterH);
# Line 179  Line 221 
221          image_null(&pEnc->vInterHV);          image_null(&pEnc->vInterHV);
222          image_null(&pEnc->vInterHVf);          image_null(&pEnc->vInterHVf);
223    
 #ifdef _DEBUG  
 #ifdef WIN32  
 OutputDebugString("malloc images");  
 #endif  
 #endif  
224          if (          if (
225  #ifdef _DEBUG  #ifdef _DEBUG
226                  image_create(&pEnc->sOriginal, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0 ||                  image_create(&pEnc->sOriginal, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0 ||
227  #endif  #endif
228    #ifdef BFRAMES
229                    image_create(&pEnc->f_refh, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0 ||
230                    image_create(&pEnc->f_refv, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0 ||
231                    image_create(&pEnc->f_refhv, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0 ||
232    #endif
233                  image_create(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0 ||                  image_create(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0 ||
234                  image_create(&pEnc->reference->image, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0 ||                  image_create(&pEnc->reference->image, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0 ||
235                  image_create(&pEnc->vInterH, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0 ||                  image_create(&pEnc->vInterH, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0 ||
# Line 199  Line 241 
241  #ifdef _DEBUG  #ifdef _DEBUG
242                  image_destroy(&pEnc->sOriginal, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);                  image_destroy(&pEnc->sOriginal, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
243  #endif  #endif
244    #ifdef BFRAMES
245                    image_destroy(&pEnc->f_refh, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
246                    image_destroy(&pEnc->f_refv, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
247                    image_destroy(&pEnc->f_refhv, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
248    #endif
249                  image_destroy(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);                  image_destroy(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
250                  image_destroy(&pEnc->reference->image, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);                  image_destroy(&pEnc->reference->image, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
251                  image_destroy(&pEnc->vInterH, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);                  image_destroy(&pEnc->vInterH, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
# Line 213  Line 260 
260                  return XVID_ERR_MEMORY;                  return XVID_ERR_MEMORY;
261          }          }
262    
263    // ==============================================================================
264    #ifdef BFRAMES
265    
266            // TODO: handle malloc() == NULL
267            pEnc->max_bframes = pParam->max_bframes;
268            pEnc->bquant_ratio = pParam->bquant_ratio;
269            if (pEnc->max_bframes > 0)
270            {
271                    int n;
272    
273                    pEnc->bframes = malloc(pEnc->max_bframes * sizeof(FRAMEINFO *));
274    
275                    for (n = 0; n < pEnc->max_bframes; n++)
276                    {
277                            pEnc->bframes[n] = malloc(sizeof(FRAMEINFO));
278                            pEnc->bframes[n]->mbs = malloc(sizeof(MACROBLOCK) * pEnc->mbParam.mb_width * pEnc->mbParam.mb_height);
279    
280                            if (image_create(&pEnc->bframes[n]->image, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0)
281                            {
282                                    return XVID_ERR_MEMORY;
283                            }
284                    }
285            }
286            pEnc->bframenum_head = 0;
287            pEnc->bframenum_tail = 0;
288            pEnc->flush_bframes = 0;
289    
290            pEnc->mbParam.m_seconds = 0;
291            pEnc->mbParam.m_ticks = 0;
292    #endif
293    
294    
295    // ==============================================================================
296    
297    
298          pParam->handle = (void *)pEnc;          pParam->handle = (void *)pEnc;
299    
300          if (pParam->rc_bitrate)          if (pParam->rc_bitrate)
# Line 232  Line 314 
314  {  {
315          ENC_CHECK(pEnc);          ENC_CHECK(pEnc);
316    
317    // =================================================================
318    #ifdef BFRAMES
319            if (pEnc->max_bframes > 0)
320            {
321                    int n;
322                    for (n = 0; n < pEnc->max_bframes; n++)
323                    {
324                            image_destroy(&pEnc->bframes[n]->image, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
325                            free(pEnc->bframes[n]->mbs);
326                            free(pEnc->bframes[n]);
327                    }
328                    free(pEnc->bframes);
329            }
330    #endif BFRAMES
331    //====================================================================
332    
333          image_destroy(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);          image_destroy(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
334          image_destroy(&pEnc->reference->image, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);          image_destroy(&pEnc->reference->image, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
335          image_destroy(&pEnc->vInterH, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);          image_destroy(&pEnc->vInterH, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
# Line 239  Line 337 
337          image_destroy(&pEnc->vInterVf, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);          image_destroy(&pEnc->vInterVf, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
338          image_destroy(&pEnc->vInterHV, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);          image_destroy(&pEnc->vInterHV, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
339          image_destroy(&pEnc->vInterHVf, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);          image_destroy(&pEnc->vInterHVf, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
340    #ifdef BFRAMES
341            image_destroy(&pEnc->f_refh, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
342            image_destroy(&pEnc->f_refv, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
343            image_destroy(&pEnc->f_refhv, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
344    #endif
345  #ifdef _DEBUG  #ifdef _DEBUG
346                  image_destroy(&pEnc->sOriginal, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);                  image_destroy(&pEnc->sOriginal, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
347  #endif  #endif
# Line 252  Line 355 
355          return XVID_ERR_OK;          return XVID_ERR_OK;
356  }  }
357    
358    
359    
360    // ==================================================================
361    #ifdef BFRAMES
362    int encoder_encode(Encoder * pEnc, XVID_ENC_FRAME * pFrame, XVID_ENC_STATS * pResult)
363    {
364            uint16_t x, y;
365            Bitstream bs;
366            uint32_t bits;
367    
368            ENC_CHECK(pEnc);
369            ENC_CHECK(pFrame);
370    
371            start_global_timer();
372    
373            BitstreamInit(&bs, pFrame->bitstream, 0);
374    
375    // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
376    // bframe "flush" code
377    // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
378    
379            if ((pFrame->image == NULL || pEnc->flush_bframes) &&
380                    pEnc->bframenum_head < pEnc->bframenum_tail)
381            {
382    
383                    if (pEnc->flush_bframes == 0)
384                    {
385                            // we have reached end of stream without getting a future reference
386                            // .. so encode last final frame a pframe
387                            dprintf("--- PFRAME (final frame correction) --- ");
388                            pEnc->bframenum_tail--;
389                            SWAP(pEnc->current, pEnc->reference);
390    
391                            SWAP(pEnc->current, pEnc->bframes[pEnc->bframenum_tail]);
392    
393                            FrameCodeP(pEnc, &bs, &bits, 1, 0);
394    
395                            BitstreamPad(&bs);
396                            pFrame->length = BitstreamLength(&bs);
397                            pFrame->input_consumed = 0;
398                            pFrame->intra = 0;
399                            return XVID_ERR_OK;
400                    }
401    
402                    dprintf("--- BFRAME (flush) --- ");
403                    FrameCodeB(pEnc,
404                            pEnc->bframes[pEnc->bframenum_head],
405                             &bs, &bits);
406                    pEnc->bframenum_head++;
407    
408    
409                    BitstreamPad(&bs);
410                    pFrame->length = BitstreamLength(&bs);
411                    pFrame->input_consumed = 0;
412                    pFrame->intra = 0;
413                    return XVID_ERR_OK;
414            }
415    
416            if (pFrame->image == NULL)
417            {
418                    pFrame->length = 0;
419                    pFrame->input_consumed = 1;
420                    pFrame->intra = 0;
421                    return XVID_ERR_OK;
422            }
423    
424            if (pEnc->bframenum_head > 0)
425            {
426                    pEnc->bframenum_head = pEnc->bframenum_tail = 0;
427            }
428    
429            pEnc->flush_bframes = 0;
430    
431    // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
432    
433            SWAP(pEnc->current, pEnc->reference);
434    
435            pEnc->current->quant = (pFrame->quant == 0) ? RateControlGetQ(0) : pFrame->quant;
436    
437            if(pEnc->current->quant < 1)
438                    pEnc->current->quant = 1;
439    
440            if(pEnc->current->quant > 31)
441                    pEnc->current->quant = 31;
442    
443            pEnc->current->global_flags = pFrame->general;
444            pEnc->current->motion_flags = pFrame->motion;
445            pEnc->current->seconds = pEnc->mbParam.m_seconds;
446            pEnc->current->ticks = pEnc->mbParam.m_ticks;
447            //@@@ TODO: dyanmic fcode (in both directions)
448            pEnc->current->fcode = pEnc->mbParam.m_fcode;
449            pEnc->current->bcode = pEnc->mbParam.m_fcode;
450    
451            start_timer();
452            if (image_input(&pEnc->current->image, pEnc->mbParam.width, pEnc->mbParam.height, pEnc->mbParam.edged_width,
453                            pFrame->image, pFrame->colorspace))
454            {
455                    return XVID_ERR_FORMAT;
456            }
457            stop_conv_timer();
458    
459    #ifdef _DEBUG
460            image_copy(&pEnc->sOriginal, &pEnc->sCurrent, pEnc->mbParam.edged_width, pEnc->mbParam.height);
461    #endif
462    
463    
464    // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
465    // lumi masking
466    // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
467    
468            if ((pEnc->current->global_flags & XVID_LUMIMASKING))
469            {
470                    int * temp_dquants = (int *) xvid_malloc(pEnc->mbParam.mb_width * pEnc->mbParam.mb_height * sizeof(int), CACHE_LINE);
471    
472                    pEnc->current->quant = adaptive_quantization(pEnc->current->image.y,
473                                                                pEnc->mbParam.edged_width,  // stride
474                                                                temp_dquants,
475                                                                pEnc->current->quant,
476                                                                pEnc->current->quant,       // min_quant
477                                                                2*pEnc->current->quant,     // max_quant
478                                                                pEnc->mbParam.mb_width,
479                                                                pEnc->mbParam.mb_height);
480    
481                    for (y = 0; y < pEnc->mbParam.mb_height; y++)
482                            for (x = 0; x < pEnc->mbParam.mb_width; x++)
483                            {
484                                    MACROBLOCK *pMB = &pEnc->current->mbs[x + y * pEnc->mbParam.mb_width];
485                                    pMB->dquant = iDQtab[(temp_dquants[y * pEnc->mbParam.mb_width + x] + 2)];
486                            }
487                    xvid_free(temp_dquants);
488            }
489    
490    
491    // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
492    // ivop/pvop/bvop selection
493    // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
494    
495            if (pEnc->iFrameNum == 0 ||
496                    pFrame->intra == 1 ||
497                    (pFrame->intra < 0 && (pEnc->iMaxKeyInterval > 0 && pEnc->iFrameNum >= pEnc->iMaxKeyInterval)) ||
498                    image_mad(&pEnc->reference->image, &pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.width, pEnc->mbParam.height) > 30)
499            {
500                    dprintf("--- IFRAME ---");
501    
502                    FrameCodeI(pEnc, &bs, &bits);
503    
504                    pFrame->intra = 1;
505                    pEnc->flush_bframes = 1;
506    
507                    /* note: sequences like "IIBB" decode fine with msfdam but,
508                       go screwy with divx5.00 */
509            }
510            else if (pEnc->bframenum_tail >= pEnc->max_bframes)
511            {
512                    dprintf("--- PFRAME ---");
513    
514                    FrameCodeP(pEnc, &bs, &bits, 1, 0);
515                    pFrame->intra = 0;
516                    pEnc->flush_bframes = 1;
517            }
518            else
519            {
520                    dprintf("--- BFRAME (store) ---  head=%i tail=%i", pEnc->bframenum_head, pEnc->bframenum_tail);
521    
522                    if (pFrame->bquant < 1)
523                    {
524                            pEnc->current->quant = ((pEnc->reference->quant + pEnc->current->quant) * pEnc->bquant_ratio) / 200;
525                    }
526                    else
527                    {
528                            pEnc->current->quant = pFrame->bquant;
529                    }
530    
531                    // store frame into bframe buffer & swap ref back to current
532                    SWAP(pEnc->current, pEnc->bframes[pEnc->bframenum_tail]);
533                    SWAP(pEnc->current, pEnc->reference);
534    
535                    pEnc->bframenum_tail++;
536    
537                    pFrame->intra = 0;
538                    pFrame->length = 0;
539                    pFrame->input_consumed = 1;
540    
541                    pEnc->mbParam.m_ticks += pEnc->mbParam.fincr;
542                    if (pEnc->mbParam.m_ticks > pEnc->mbParam.fbase)
543                    {
544                            pEnc->mbParam.m_seconds++;
545                            pEnc->mbParam.m_ticks = 0;
546                    }
547                    return XVID_ERR_OK;
548            }
549    
550            BitstreamPad(&bs);
551            pFrame->length = BitstreamLength(&bs);
552    
553            if (pResult)
554            {
555                    pResult->quant = pEnc->current->quant;
556                    pResult->hlength = pFrame->length - (pEnc->sStat.iTextBits / 8);
557                    pResult->kblks = pEnc->sStat.kblks;
558                    pResult->mblks = pEnc->sStat.mblks;
559                    pResult->ublks = pEnc->sStat.ublks;
560            }
561    
562    #ifdef _DEBUG
563            psnr = image_psnr(&pEnc->sOriginal, &pEnc->current->image, pEnc->mbParam.edged_width,
564                                    pEnc->mbParam.width, pEnc->mbParam.height);
565    
566            sprintf(temp, "PSNR: %f\n", psnr);
567            DEBUG(temp);
568    #endif
569    
570            if (pFrame->quant == 0)
571            {
572                    RateControlUpdate(pEnc->current->quant, pFrame->length, pFrame->intra);
573            }
574    
575            pEnc->iFrameNum++;
576            pEnc->mbParam.m_ticks += pEnc->mbParam.fincr;
577            if (pEnc->mbParam.m_ticks > pEnc->mbParam.fbase)
578            {
579                    pEnc->mbParam.m_seconds++;
580                    pEnc->mbParam.m_ticks = 0;
581            }
582            pFrame->input_consumed = 1;
583    
584            stop_global_timer();
585            write_timer();
586    
587            return XVID_ERR_OK;
588    }
589    // ==================================================================
590    #else
591  int encoder_encode(Encoder * pEnc, XVID_ENC_FRAME * pFrame, XVID_ENC_STATS * pResult)  int encoder_encode(Encoder * pEnc, XVID_ENC_FRAME * pFrame, XVID_ENC_STATS * pResult)
592  {  {
593          uint16_t x, y;          uint16_t x, y;
# Line 285  Line 621 
621          stop_conv_timer();          stop_conv_timer();
622    
623  #ifdef _DEBUG  #ifdef _DEBUG
624          image_copy(&pEnc->sOriginal, &pEnc->sCurrent, pEnc->mbParam.edged_width, pEnc->mbParam.height);          image_copy(&pEnc->sOriginal, &pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height);
625  #endif  #endif
626    
627          EMMS();          EMMS();
# Line 405  Line 741 
741    
742          return XVID_ERR_OK;          return XVID_ERR_OK;
743  }  }
744    #endif
745    
746    
747  static __inline void CodeIntraMB(Encoder *pEnc, MACROBLOCK *pMB) {  static __inline void CodeIntraMB(Encoder *pEnc, MACROBLOCK *pMB) {
# Line 472  Line 809 
809                          MVBLOCKHINT * bhint = &hint->mvhint.block[x + y * pEnc->mbParam.mb_width];                          MVBLOCKHINT * bhint = &hint->mvhint.block[x + y * pEnc->mbParam.mb_width];
810                          VECTOR pred[4];                          VECTOR pred[4];
811                          VECTOR tmp;                          VECTOR tmp;
812                          int dummy[4];                          int32_t dummy[4];
813                          int vec;                          int vec;
814    
815                          pMB->mode = (hint->rawhints) ? bhint->mode : BitstreamGetBits(&bs, MODEBITS);                          pMB->mode = (hint->rawhints) ? bhint->mode : BitstreamGetBits(&bs, MODEBITS);
# Line 716  Line 1053 
1053          int iLimit;          int iLimit;
1054          uint32_t x, y;          uint32_t x, y;
1055          int iSearchRange;          int iSearchRange;
1056          bool bIntra;          int bIntra;
1057    
1058          IMAGE *pCurrent = &pEnc->current->image;          /* IMAGE *pCurrent = &pEnc->current->image; */
1059          IMAGE *pRef = &pEnc->reference->image;          IMAGE *pRef = &pEnc->reference->image;
1060    
1061          start_timer();          start_timer();
# Line 893  Line 1230 
1230  }  }
1231    
1232    
1233    #ifdef BFRAMES
 /*  
1234  static void FrameCodeB(Encoder * pEnc, FRAMEINFO * frame, Bitstream * bs, uint32_t *pBits)  static void FrameCodeB(Encoder * pEnc, FRAMEINFO * frame, Bitstream * bs, uint32_t *pBits)
1235  {  {
1236      int16_t dct_codes[6][64];      int16_t dct_codes[6*64];
1237      int16_t qcoeff[6][64];      int16_t qcoeff[6*64];
1238      uint32_t x, y;      uint32_t x, y;
1239          VECTOR forward;          VECTOR forward;
1240          VECTOR backward;          VECTOR backward;
# Line 907  Line 1243 
1243          IMAGE *b_ref = &pEnc->current->image;          IMAGE *b_ref = &pEnc->current->image;
1244    
1245          // forward          // forward
1246          image_setedges(f_ref, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height, pEnc->mbParam.width, pEnc->mbParam.height);          image_setedges(f_ref, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height, pEnc->mbParam.width, pEnc->mbParam.height, frame->global_flags & XVID_INTERLACING);
1247          start_timer();          start_timer();
1248          image_interpolate(f_ref, &pEnc->f_refh, &pEnc->f_refv, &pEnc->f_refhv,          image_interpolate(f_ref, &pEnc->f_refh, &pEnc->f_refv, &pEnc->f_refhv,
1249                  pEnc->mbParam.edged_width, pEnc->mbParam.edged_height, 0);                  pEnc->mbParam.edged_width, pEnc->mbParam.edged_height, 0);
1250          stop_inter_timer();          stop_inter_timer();
1251    
1252          // backward          // backward
1253          image_setedges(b_ref, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height, pEnc->mbParam.width, pEnc->mbParam.height);          image_setedges(b_ref, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height, pEnc->mbParam.width, pEnc->mbParam.height, frame->global_flags & XVID_INTERLACING);
1254      start_timer();      start_timer();
1255          image_interpolate(b_ref, &pEnc->vInterH, &pEnc->vInterV, &pEnc->vInterHV,          image_interpolate(b_ref, &pEnc->vInterH, &pEnc->vInterV, &pEnc->vInterHV,
1256                  pEnc->mbParam.edged_width, pEnc->mbParam.edged_height, 0);                  pEnc->mbParam.edged_width, pEnc->mbParam.edged_height, 0);
# Line 925  Line 1261 
1261                  pEnc->reference->mbs, f_ref, &pEnc->f_refh, &pEnc->f_refv, &pEnc->f_refhv,                  pEnc->reference->mbs, f_ref, &pEnc->f_refh, &pEnc->f_refv, &pEnc->f_refhv,
1262                  pEnc->current->mbs, b_ref, &pEnc->vInterH, &pEnc->vInterV, &pEnc->vInterHV);                  pEnc->current->mbs, b_ref, &pEnc->vInterH, &pEnc->vInterV, &pEnc->vInterHV);
1263    
1264    
1265          stop_motion_timer();          stop_motion_timer();
1266    
1267          if (test_quant_type(&pEnc->mbParam, pEnc->current))          /*if (test_quant_type(&pEnc->mbParam, pEnc->current))
1268          {          {
1269                  BitstreamWriteVolHeader(bs, pEnc->mbParam.width, pEnc->mbParam.height, pEnc->mbParam.quant_type);                  BitstreamWriteVolHeader(bs, pEnc->mbParam.width, pEnc->mbParam.height, pEnc->mbParam.quant_type);
1270          }          }*/
1271    
1272      frame->coding_type = B_VOP;      frame->coding_type = B_VOP;
1273      BitstreamWriteVopHeader(bs, B_VOP, frame->tick, 0,      BitstreamWriteVopHeader(bs, &pEnc->mbParam, frame);
                         frame->quant, frame->fcode, frame->bcode);  
1274    
1275      *pBits = BitstreamPos(bs);      *pBits = BitstreamPos(bs);
1276    
# Line 973  Line 1309 
1309                                          dct_codes);                                          dct_codes);
1310    
1311                          mb->quant = frame->quant;                          mb->quant = frame->quant;
1312                          mb->cbp = MBTransQuantInter(&pEnc->mbParam, frame, x, y, dct_codes, qcoeff);                          mb->cbp = MBTransQuantInter(&pEnc->mbParam, frame, mb, x, y, dct_codes, qcoeff);
1313                          //mb->cbp = MBTransQuantBVOP(&pEnc->mbParam, x, y, dct_codes, qcoeff, &frame->image, frame->quant);                          //mb->cbp = MBTransQuantBVOP(&pEnc->mbParam, x, y, dct_codes, qcoeff, &frame->image, frame->quant);
1314    
1315    
# Line 1004  Line 1340 
1340  //                      printf("[%i %i] M=%i CBP=%i MVX=%i MVY=%i %i,%i  %i,%i\n", x, y, pMB->mode, pMB->cbp, pMB->mvs[0].x, bmb->pmvs[0].x, bmb->pmvs[0].y, forward.x, forward.y);  //                      printf("[%i %i] M=%i CBP=%i MVX=%i MVY=%i %i,%i  %i,%i\n", x, y, pMB->mode, pMB->cbp, pMB->mvs[0].x, bmb->pmvs[0].x, bmb->pmvs[0].y, forward.x, forward.y);
1341    
1342                          start_timer();                          start_timer();
1343                          MBCodingBVOP(frame, mb, qcoeff, bs, &pEnc->sStat);                          MBCodingBVOP(mb, qcoeff, frame->fcode, frame->bcode, bs, &pEnc->sStat);
1344                          stop_coding_timer();                          stop_coding_timer();
1345                  }                  }
1346          }          }
# Line 1014  Line 1350 
1350          // TODO: dynamic fcode/bcode ???          // TODO: dynamic fcode/bcode ???
1351    
1352          *pBits = BitstreamPos(bs) - *pBits;          *pBits = BitstreamPos(bs) - *pBits;
   
1353  }  }
1354    #endif
 */  

Legend:
Removed from v.1.28  
changed lines
  Added in v.1.33

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