[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.27, Thu Apr 25 06:55:00 2002 UTC revision 1.36, Thu May 9 00:15:50 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     *  08.05.2002 fix some problem in DEBUG mode;
36     *             MinChen <chenm001@163.com>
37     *  14.04.2002 added FrameCodeB()
38     *
39     *  $Id$
40     *
41     ***************************************************************************/
42    
43  #include <stdlib.h>  #include <stdlib.h>
44  #include <stdio.h>  #include <stdio.h>
# Line 9  Line 49 
49  #include "global.h"  #include "global.h"
50  #include "utils/timer.h"  #include "utils/timer.h"
51  #include "image/image.h"  #include "image/image.h"
52    #include "motion/motion.h"
53  #include "bitstream/cbp.h"  #include "bitstream/cbp.h"
54  #include "utils/mbfunctions.h"  #include "utils/mbfunctions.h"
55  #include "bitstream/bitstream.h"  #include "bitstream/bitstream.h"
# Line 26  Line 67 
67    
68  static int FrameCodeI(Encoder * pEnc, Bitstream * bs, uint32_t *pBits);  static int FrameCodeI(Encoder * pEnc, Bitstream * bs, uint32_t *pBits);
69  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);
70    static void FrameCodeB(Encoder * pEnc, FRAMEINFO * frame, Bitstream * bs, uint32_t *pBits);
71    
72  static int DQtab[4] =  static int DQtab[4] =
73  {  {
# Line 125  Line 167 
167          pEnc->mbParam.edged_width = 16 * pEnc->mbParam.mb_width + 2 * EDGE_SIZE;          pEnc->mbParam.edged_width = 16 * pEnc->mbParam.mb_width + 2 * EDGE_SIZE;
168          pEnc->mbParam.edged_height = 16 * pEnc->mbParam.mb_height + 2 * EDGE_SIZE;          pEnc->mbParam.edged_height = 16 * pEnc->mbParam.mb_height + 2 * EDGE_SIZE;
169    
170            pEnc->mbParam.fbase = pParam->fbase;
171            pEnc->mbParam.fincr = pParam->fincr;
172    
173          pEnc->sStat.fMvPrevSigma = -1;          pEnc->sStat.fMvPrevSigma = -1;
174    
175          /* Fill rate control parameters */          /* Fill rate control parameters */
# Line 151  Line 196 
196          pEnc->current->mbs = NULL;          pEnc->current->mbs = NULL;
197          pEnc->reference->mbs = NULL;          pEnc->reference->mbs = NULL;
198    
 OutputDebugString("malloc mbs");  
199          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 ||
200                  (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)
201          {          {
# Line 166  Line 210 
210  #ifdef _DEBUG  #ifdef _DEBUG
211          image_null(&pEnc->sOriginal);          image_null(&pEnc->sOriginal);
212  #endif  #endif
213    #ifdef BFRAMES
214            image_null(&pEnc->f_refh);
215            image_null(&pEnc->f_refv);
216            image_null(&pEnc->f_refhv);
217    #endif
218          image_null(&pEnc->current->image);          image_null(&pEnc->current->image);
219          image_null(&pEnc->reference->image);          image_null(&pEnc->reference->image);
220          image_null(&pEnc->vInterH);          image_null(&pEnc->vInterH);
# Line 174  Line 223 
223          image_null(&pEnc->vInterHV);          image_null(&pEnc->vInterHV);
224          image_null(&pEnc->vInterHVf);          image_null(&pEnc->vInterHVf);
225    
   
 OutputDebugString("malloc images");  
226          if (          if (
227  #ifdef _DEBUG  #ifdef _DEBUG
228                  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 ||
229  #endif  #endif
230    #ifdef BFRAMES
231                    image_create(&pEnc->f_refh, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0 ||
232                    image_create(&pEnc->f_refv, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0 ||
233                    image_create(&pEnc->f_refhv, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0 ||
234    #endif
235                  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 ||
236                  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 ||
237                  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 191  Line 243 
243  #ifdef _DEBUG  #ifdef _DEBUG
244                  image_destroy(&pEnc->sOriginal, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);                  image_destroy(&pEnc->sOriginal, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
245  #endif  #endif
246    #ifdef BFRAMES
247                    image_destroy(&pEnc->f_refh, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
248                    image_destroy(&pEnc->f_refv, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
249                    image_destroy(&pEnc->f_refhv, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
250    #endif
251                  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);
252                  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);
253                  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 205  Line 262 
262                  return XVID_ERR_MEMORY;                  return XVID_ERR_MEMORY;
263          }          }
264    
265    // ==============================================================================
266    #ifdef BFRAMES
267    
268            // TODO: handle malloc() == NULL
269            pEnc->mbParam.max_bframes = pParam->max_bframes;
270            pEnc->bquant_ratio = pParam->bquant_ratio;
271            if (pEnc->mbParam.max_bframes > 0)
272            {
273                    int n;
274    
275                    pEnc->bframes = malloc(pEnc->mbParam.max_bframes * sizeof(FRAMEINFO *));
276    
277                    for (n = 0; n < pEnc->mbParam.max_bframes; n++)
278                    {
279                            pEnc->bframes[n] = malloc(sizeof(FRAMEINFO));
280                            pEnc->bframes[n]->mbs = malloc(sizeof(MACROBLOCK) * pEnc->mbParam.mb_width * pEnc->mbParam.mb_height);
281    
282                            if (image_create(&pEnc->bframes[n]->image, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0)
283                            {
284                                    return XVID_ERR_MEMORY;
285                            }
286                    }
287            }
288            pEnc->bframenum_head = 0;
289            pEnc->bframenum_tail = 0;
290            pEnc->flush_bframes = 0;
291    
292            pEnc->mbParam.m_seconds = 0;
293            pEnc->mbParam.m_ticks = 0;
294    #endif
295    
296    
297    // ==============================================================================
298    
299    
300          pParam->handle = (void *)pEnc;          pParam->handle = (void *)pEnc;
301    
302          if (pParam->rc_bitrate)          if (pParam->rc_bitrate)
# Line 224  Line 316 
316  {  {
317          ENC_CHECK(pEnc);          ENC_CHECK(pEnc);
318    
319    // =================================================================
320    #ifdef BFRAMES
321            if (pEnc->mbParam.max_bframes > 0)
322            {
323                    int n;
324                    for (n = 0; n < pEnc->mbParam.max_bframes; n++)
325                    {
326                            image_destroy(&pEnc->bframes[n]->image, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
327                            free(pEnc->bframes[n]->mbs);
328                            free(pEnc->bframes[n]);
329                    }
330                    free(pEnc->bframes);
331            }
332    #endif
333    //====================================================================
334    
335          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);
336          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);
337          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 231  Line 339 
339          image_destroy(&pEnc->vInterVf, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);          image_destroy(&pEnc->vInterVf, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
340          image_destroy(&pEnc->vInterHV, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);          image_destroy(&pEnc->vInterHV, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
341          image_destroy(&pEnc->vInterHVf, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);          image_destroy(&pEnc->vInterHVf, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
342    #ifdef BFRAMES
343            image_destroy(&pEnc->f_refh, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
344            image_destroy(&pEnc->f_refv, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
345            image_destroy(&pEnc->f_refhv, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
346    #endif
347  #ifdef _DEBUG  #ifdef _DEBUG
348                  image_destroy(&pEnc->sOriginal, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);                  image_destroy(&pEnc->sOriginal, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
349  #endif  #endif
# Line 244  Line 357 
357          return XVID_ERR_OK;          return XVID_ERR_OK;
358  }  }
359    
360    
361    
362    // ==================================================================
363    #ifdef BFRAMES
364    int encoder_encode(Encoder * pEnc, XVID_ENC_FRAME * pFrame, XVID_ENC_STATS * pResult)
365    {
366            uint16_t x, y;
367            Bitstream bs;
368            uint32_t bits;
369    
370    #ifdef _DEBUG
371            float psnr;
372            char temp[128];
373    #endif
374    
375            ENC_CHECK(pEnc);
376            ENC_CHECK(pFrame);
377    
378            start_global_timer();
379    
380            BitstreamInit(&bs, pFrame->bitstream, 0);
381    
382    // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
383    // bframe "flush" code
384    // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
385    
386            if ((pFrame->image == NULL || pEnc->flush_bframes) &&
387                    pEnc->bframenum_head < pEnc->bframenum_tail)
388            {
389    
390                    if (pEnc->flush_bframes == 0)
391                    {
392                            // we have reached end of stream without getting a future reference
393                            // .. so encode last final frame a pframe
394                            dprintf("--- PFRAME (final frame correction) --- ");
395                            pEnc->bframenum_tail--;
396                            SWAP(pEnc->current, pEnc->reference);
397    
398                            SWAP(pEnc->current, pEnc->bframes[pEnc->bframenum_tail]);
399    
400                            FrameCodeP(pEnc, &bs, &bits, 1, 0);
401    
402                            BitstreamPad(&bs);
403                            pFrame->length = BitstreamLength(&bs);
404                            pFrame->input_consumed = 0;
405                            pFrame->intra = 0;
406                            return XVID_ERR_OK;
407                    }
408    
409                    dprintf("--- BFRAME (flush) --- ");
410                    FrameCodeB(pEnc,
411                            pEnc->bframes[pEnc->bframenum_head],
412                             &bs, &bits);
413                    pEnc->bframenum_head++;
414    
415    
416                    BitstreamPad(&bs);
417                    pFrame->length = BitstreamLength(&bs);
418                    pFrame->input_consumed = 0;
419                    pFrame->intra = 0;
420                    return XVID_ERR_OK;
421            }
422    
423            if (pFrame->image == NULL)
424            {
425                    pFrame->length = 0;
426                    pFrame->input_consumed = 1;
427                    pFrame->intra = 0;
428                    return XVID_ERR_OK;
429            }
430    
431            if (pEnc->bframenum_head > 0)
432            {
433                    pEnc->bframenum_head = pEnc->bframenum_tail = 0;
434            }
435    
436            pEnc->flush_bframes = 0;
437    
438    // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
439    
440            SWAP(pEnc->current, pEnc->reference);
441    
442            pEnc->current->quant = (pFrame->quant == 0) ? RateControlGetQ(0) : pFrame->quant;
443    
444            if(pEnc->current->quant < 1)
445                    pEnc->current->quant = 1;
446    
447            if(pEnc->current->quant > 31)
448                    pEnc->current->quant = 31;
449    
450            pEnc->current->global_flags = pFrame->general;
451            pEnc->current->motion_flags = pFrame->motion;
452            pEnc->current->seconds = pEnc->mbParam.m_seconds;
453            pEnc->current->ticks = pEnc->mbParam.m_ticks;
454            //@@@ TODO: dyanmic fcode (in both directions)
455            pEnc->current->fcode = pEnc->mbParam.m_fcode;
456            pEnc->current->bcode = pEnc->mbParam.m_fcode;
457    
458            start_timer();
459            if (image_input(&pEnc->current->image, pEnc->mbParam.width, pEnc->mbParam.height, pEnc->mbParam.edged_width,
460                            pFrame->image, pFrame->colorspace))
461            {
462                    return XVID_ERR_FORMAT;
463            }
464            stop_conv_timer();
465    
466    #ifdef _DEBUG
467            image_copy(&pEnc->sOriginal, &pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height);
468    #endif
469    
470    
471    // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
472    // lumi masking
473    // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
474    
475            if ((pEnc->current->global_flags & XVID_LUMIMASKING))
476            {
477                    int * temp_dquants = (int *) xvid_malloc(pEnc->mbParam.mb_width * pEnc->mbParam.mb_height * sizeof(int), CACHE_LINE);
478    
479                    pEnc->current->quant = adaptive_quantization(pEnc->current->image.y,
480                                                                pEnc->mbParam.edged_width,  // stride
481                                                                temp_dquants,
482                                                                pEnc->current->quant,
483                                                                pEnc->current->quant,       // min_quant
484                                                                2*pEnc->current->quant,     // max_quant
485                                                                pEnc->mbParam.mb_width,
486                                                                pEnc->mbParam.mb_height);
487    
488                    for (y = 0; y < pEnc->mbParam.mb_height; y++)
489                            for (x = 0; x < pEnc->mbParam.mb_width; x++)
490                            {
491                                    MACROBLOCK *pMB = &pEnc->current->mbs[x + y * pEnc->mbParam.mb_width];
492                                    pMB->dquant = iDQtab[(temp_dquants[y * pEnc->mbParam.mb_width + x] + 2)];
493                            }
494                    xvid_free(temp_dquants);
495            }
496    
497    
498    // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
499    // ivop/pvop/bvop selection
500    // %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
501    
502            if (pEnc->iFrameNum == 0 ||
503                    pFrame->intra == 1 ||
504                    (pFrame->intra < 0 && (pEnc->iMaxKeyInterval > 0 && pEnc->iFrameNum >= pEnc->iMaxKeyInterval)) ||
505                    image_mad(&pEnc->reference->image, &pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.width, pEnc->mbParam.height) > 30)
506            {
507                    dprintf("--- IFRAME ---");
508    
509                    FrameCodeI(pEnc, &bs, &bits);
510    
511                    pFrame->intra = 1;
512                    pEnc->flush_bframes = 1;
513    
514                    /* note: sequences like "IIBB" decode fine with msfdam but,
515                       go screwy with divx5.00 */
516            }
517            else if (pEnc->bframenum_tail >= pEnc->mbParam.max_bframes)
518            {
519                    dprintf("--- PFRAME ---");
520    
521                    FrameCodeP(pEnc, &bs, &bits, 1, 0);
522                    pFrame->intra = 0;
523                    pEnc->flush_bframes = 1;
524            }
525            else
526            {
527                    dprintf("--- BFRAME (store) ---  head=%i tail=%i", pEnc->bframenum_head, pEnc->bframenum_tail);
528    
529                    if (pFrame->bquant < 1)
530                    {
531                            pEnc->current->quant = ((pEnc->reference->quant + pEnc->current->quant) * pEnc->bquant_ratio) / 200;
532                    }
533                    else
534                    {
535                            pEnc->current->quant = pFrame->bquant;
536                    }
537    
538                    // store frame into bframe buffer & swap ref back to current
539                    SWAP(pEnc->current, pEnc->bframes[pEnc->bframenum_tail]);
540                    SWAP(pEnc->current, pEnc->reference);
541    
542                    pEnc->bframenum_tail++;
543    
544                    pFrame->intra = 0;
545                    pFrame->length = 0;
546                    pFrame->input_consumed = 1;
547    
548                    pEnc->mbParam.m_ticks += pEnc->mbParam.fincr;
549                    if (pEnc->mbParam.m_ticks > pEnc->mbParam.fbase)
550                    {
551                            pEnc->mbParam.m_seconds++;
552                            pEnc->mbParam.m_ticks = 0;
553                    }
554                    return XVID_ERR_OK;
555            }
556    
557            BitstreamPad(&bs);
558            pFrame->length = BitstreamLength(&bs);
559    
560            if (pResult)
561            {
562                    pResult->quant = pEnc->current->quant;
563                    pResult->hlength = pFrame->length - (pEnc->sStat.iTextBits / 8);
564                    pResult->kblks = pEnc->sStat.kblks;
565                    pResult->mblks = pEnc->sStat.mblks;
566                    pResult->ublks = pEnc->sStat.ublks;
567            }
568    
569    #ifdef _DEBUG
570            psnr = image_psnr(&pEnc->sOriginal, &pEnc->current->image, pEnc->mbParam.edged_width,
571                                    pEnc->mbParam.width, pEnc->mbParam.height);
572    
573            sprintf(temp, "PSNR: %f\n", psnr);
574            DEBUG(temp);
575    #endif
576    
577            if (pFrame->quant == 0)
578            {
579                    RateControlUpdate(pEnc->current->quant, pFrame->length, pFrame->intra);
580            }
581    
582            pEnc->iFrameNum++;
583            pEnc->mbParam.m_ticks += pEnc->mbParam.fincr;
584            if (pEnc->mbParam.m_ticks > pEnc->mbParam.fbase)
585            {
586                    pEnc->mbParam.m_seconds++;
587                    pEnc->mbParam.m_ticks = 0;
588            }
589            pFrame->input_consumed = 1;
590    
591            stop_global_timer();
592            write_timer();
593    
594            return XVID_ERR_OK;
595    }
596    // ==================================================================
597    #else
598  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)
599  {  {
600          uint16_t x, y;          uint16_t x, y;
# Line 277  Line 628 
628          stop_conv_timer();          stop_conv_timer();
629    
630  #ifdef _DEBUG  #ifdef _DEBUG
631          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);
632  #endif  #endif
633    
634          EMMS();          EMMS();
# Line 397  Line 748 
748    
749          return XVID_ERR_OK;          return XVID_ERR_OK;
750  }  }
751    #endif
752    
753    
754  static __inline void CodeIntraMB(Encoder *pEnc, MACROBLOCK *pMB) {  static __inline void CodeIntraMB(Encoder *pEnc, MACROBLOCK *pMB) {
# Line 464  Line 816 
816                          MVBLOCKHINT * bhint = &hint->mvhint.block[x + y * pEnc->mbParam.mb_width];                          MVBLOCKHINT * bhint = &hint->mvhint.block[x + y * pEnc->mbParam.mb_width];
817                          VECTOR pred[4];                          VECTOR pred[4];
818                          VECTOR tmp;                          VECTOR tmp;
819                          int dummy[4];                          int32_t dummy[4];
820                          int vec;                          int vec;
821    
822                          pMB->mode = (hint->rawhints) ? bhint->mode : BitstreamGetBits(&bs, MODEBITS);                          pMB->mode = (hint->rawhints) ? bhint->mode : BitstreamGetBits(&bs, MODEBITS);
# Line 708  Line 1060 
1060          int iLimit;          int iLimit;
1061          uint32_t x, y;          uint32_t x, y;
1062          int iSearchRange;          int iSearchRange;
1063          bool bIntra;          int bIntra;
1064    
1065          IMAGE *pCurrent = &pEnc->current->image;          /* IMAGE *pCurrent = &pEnc->current->image; */
1066          IMAGE *pRef = &pEnc->reference->image;          IMAGE *pRef = &pEnc->reference->image;
1067    
1068          start_timer();          start_timer();
# Line 885  Line 1237 
1237  }  }
1238    
1239    
1240    #ifdef BFRAMES
 /*  
1241  static void FrameCodeB(Encoder * pEnc, FRAMEINFO * frame, Bitstream * bs, uint32_t *pBits)  static void FrameCodeB(Encoder * pEnc, FRAMEINFO * frame, Bitstream * bs, uint32_t *pBits)
1242  {  {
1243      int16_t dct_codes[6][64];      int16_t dct_codes[6*64];
1244      int16_t qcoeff[6][64];      int16_t qcoeff[6*64];
1245      uint32_t x, y;      uint32_t x, y;
1246          VECTOR forward;          VECTOR forward;
1247          VECTOR backward;          VECTOR backward;
# Line 899  Line 1250 
1250          IMAGE *b_ref = &pEnc->current->image;          IMAGE *b_ref = &pEnc->current->image;
1251    
1252          // forward          // forward
1253          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);
1254          start_timer();          start_timer();
1255          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,
1256                  pEnc->mbParam.edged_width, pEnc->mbParam.edged_height, 0);                  pEnc->mbParam.edged_width, pEnc->mbParam.edged_height, 0);
1257          stop_inter_timer();          stop_inter_timer();
1258    
1259          // backward          // backward
1260          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);
1261      start_timer();      start_timer();
1262          image_interpolate(b_ref, &pEnc->vInterH, &pEnc->vInterV, &pEnc->vInterHV,          image_interpolate(b_ref, &pEnc->vInterH, &pEnc->vInterV, &pEnc->vInterHV,
1263                  pEnc->mbParam.edged_width, pEnc->mbParam.edged_height, 0);                  pEnc->mbParam.edged_width, pEnc->mbParam.edged_height, 0);
# Line 917  Line 1268 
1268                  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,
1269                  pEnc->current->mbs, b_ref, &pEnc->vInterH, &pEnc->vInterV, &pEnc->vInterHV);                  pEnc->current->mbs, b_ref, &pEnc->vInterH, &pEnc->vInterV, &pEnc->vInterHV);
1270    
1271    
1272          stop_motion_timer();          stop_motion_timer();
1273    
1274          if (test_quant_type(&pEnc->mbParam, pEnc->current))          /*if (test_quant_type(&pEnc->mbParam, pEnc->current))
1275          {          {
1276                  BitstreamWriteVolHeader(bs, pEnc->mbParam.width, pEnc->mbParam.height, pEnc->mbParam.quant_type);                  BitstreamWriteVolHeader(bs, pEnc->mbParam.width, pEnc->mbParam.height, pEnc->mbParam.quant_type);
1277          }          }*/
1278    
1279      frame->coding_type = B_VOP;      frame->coding_type = B_VOP;
1280      BitstreamWriteVopHeader(bs, B_VOP, frame->tick, 0,      BitstreamWriteVopHeader(bs, &pEnc->mbParam, frame);
                         frame->quant, frame->fcode, frame->bcode);  
1281    
1282      *pBits = BitstreamPos(bs);      *pBits = BitstreamPos(bs);
1283    
# Line 965  Line 1316 
1316                                          dct_codes);                                          dct_codes);
1317    
1318                          mb->quant = frame->quant;                          mb->quant = frame->quant;
1319                          mb->cbp = MBTransQuantInter(&pEnc->mbParam, frame, x, y, dct_codes, qcoeff);                          mb->cbp = MBTransQuantInter(&pEnc->mbParam, frame, mb, x, y, dct_codes, qcoeff);
1320                          //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);
1321    
1322    
# Line 996  Line 1347 
1347  //                      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);
1348    
1349                          start_timer();                          start_timer();
1350                          MBCodingBVOP(frame, mb, qcoeff, bs, &pEnc->sStat);                          MBCodingBVOP(mb, qcoeff, frame->fcode, frame->bcode, bs, &pEnc->sStat);
1351                          stop_coding_timer();                          stop_coding_timer();
1352                  }                  }
1353          }          }
# Line 1006  Line 1357 
1357          // TODO: dynamic fcode/bcode ???          // TODO: dynamic fcode/bcode ???
1358    
1359          *pBits = BitstreamPos(bs) - *pBits;          *pBits = BitstreamPos(bs) - *pBits;
   
1360  }  }
   
 */  
1361    #endif

Legend:
Removed from v.1.27  
changed lines
  Added in v.1.36

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