[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.65, Sun Jul 28 13:06:45 2002 UTC revision 1.85, Sat Oct 19 11:41:11 2002 UTC
# Line 3  Line 3 
3   *  XVID MPEG-4 VIDEO CODEC   *  XVID MPEG-4 VIDEO CODEC
4   *  -  Encoder main module  -   *  -  Encoder main module  -
5   *   *
6     *  Copyright(C) 2002 Michael Militzer <isibaar@xvid.org>
7     *
8   *  This program is an implementation of a part of one or more MPEG-4   *  This program is an implementation of a part of one or more MPEG-4
9   *  Video tools as specified in ISO/IEC 14496-2 standard.  Those intending   *  Video tools as specified in ISO/IEC 14496-2 standard.  Those intending
10   *  to use this software module in hardware or software products are   *  to use this software module in hardware or software products are
# Line 26  Line 28 
28   *  along with this program; if not, write to the Free Software   *  along with this program; if not, write to the Free Software
29   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
30   *   *
  ****************************************************************************/  
   
 /*****************************************************************************  
  *  
  *  History  
  *  
  *  10.07.2002  added BFRAMES_DEC_DEBUG support  
  *              MinChen <chenm001@163.com>  
  *  20.06.2002 bframe patch  
  *  08.05.2002 fix some problem in DEBUG mode;  
  *             MinChen <chenm001@163.com>  
  *  14.04.2002 added FrameCodeB()  
  *  
31   *  $Id$   *  $Id$
32   *   *
33   ****************************************************************************/   ****************************************************************************/
34    
   
35  #include <stdlib.h>  #include <stdlib.h>
36  #include <stdio.h>  #include <stdio.h>
37  #include <math.h>  #include <math.h>
# Line 54  Line 42 
42  #include "global.h"  #include "global.h"
43  #include "utils/timer.h"  #include "utils/timer.h"
44  #include "image/image.h"  #include "image/image.h"
 #ifdef BFRAMES  
 #include "image/font.h"  
 #include "motion/sad.h"  
 #endif  
45  #include "motion/motion.h"  #include "motion/motion.h"
46  #include "bitstream/cbp.h"  #include "bitstream/cbp.h"
47  #include "utils/mbfunctions.h"  #include "utils/mbfunctions.h"
# Line 94  Line 78 
78                                            bool force_inter,                                            bool force_inter,
79                                            bool vol_header);                                            bool vol_header);
80    
 #ifdef BFRAMES  
 static void FrameCodeB(Encoder * pEnc,  
                                            FRAMEINFO * frame,  
                                            Bitstream * bs,  
                                            uint32_t * pBits);  
 #endif  
   
81  /*****************************************************************************  /*****************************************************************************
82   * Local data   * Local data
83   ****************************************************************************/   ****************************************************************************/
# Line 125  Line 102 
102   * Encoder creation   * Encoder creation
103   *   *
104   * This function creates an Encoder instance, it allocates all necessary   * This function creates an Encoder instance, it allocates all necessary
105   * image buffers (reference, current and bframes) and initialize the internal   * image buffers (reference, current) and initialize the internal xvid
106   * xvid encoder paremeters according to the XVID_ENC_PARAM input parameter.   * encoder paremeters according to the XVID_ENC_PARAM input parameter.
107   *   *
108   * The code seems to be very long but is very basic, mainly memory allocation   * The code seems to be very long but is very basic, mainly memory allocation
109   * and cleaning code.   * and cleaning code.
# Line 264  Line 241 
241          pEnc->current->mbs =          pEnc->current->mbs =
242                  xvid_malloc(sizeof(MACROBLOCK) * pEnc->mbParam.mb_width *                  xvid_malloc(sizeof(MACROBLOCK) * pEnc->mbParam.mb_width *
243                                          pEnc->mbParam.mb_height, CACHE_LINE);                                          pEnc->mbParam.mb_height, CACHE_LINE);
244          pEnc->reference->mbs =          pEnc->reference->mbs =
245                  xvid_malloc(sizeof(MACROBLOCK) * pEnc->mbParam.mb_width *                  xvid_malloc(sizeof(MACROBLOCK) * pEnc->mbParam.mb_width *
246                                          pEnc->mbParam.mb_height, CACHE_LINE);                                          pEnc->mbParam.mb_height, CACHE_LINE);
   
         if (pEnc->current->mbs == NULL || pEnc->reference->mbs == NULL)  
                 goto xvid_err_memory2;  
   
         /* try to allocate image memory */  
   
 #ifdef _DEBUG_PSNR  
         image_null(&pEnc->sOriginal);  
 #endif  
 #ifdef BFRAMES  
         image_null(&pEnc->f_refh);  
         image_null(&pEnc->f_refv);  
         image_null(&pEnc->f_refhv);  
 #endif  
         image_null(&pEnc->current->image);  
         image_null(&pEnc->reference->image);  
         image_null(&pEnc->vInterH);  
         image_null(&pEnc->vInterV);  
         image_null(&pEnc->vInterVf);  
         image_null(&pEnc->vInterHV);  
         image_null(&pEnc->vInterHVf);  
   
 #ifdef _DEBUG_PSNR  
         if (image_create  
                 (&pEnc->sOriginal, pEnc->mbParam.edged_width,  
                  pEnc->mbParam.edged_height) < 0)  
                 goto xvid_err_memory3;  
 #endif  
 #ifdef BFRAMES  
         if (image_create  
                 (&pEnc->f_refh, pEnc->mbParam.edged_width,  
                  pEnc->mbParam.edged_height) < 0)  
                 goto xvid_err_memory3;  
         if (image_create  
                 (&pEnc->f_refv, pEnc->mbParam.edged_width,  
                  pEnc->mbParam.edged_height) < 0)  
                 goto xvid_err_memory3;  
         if (image_create  
                 (&pEnc->f_refhv, pEnc->mbParam.edged_width,  
                  pEnc->mbParam.edged_height) < 0)  
                 goto xvid_err_memory3;  
 #endif  
         if (image_create  
                 (&pEnc->current->image, pEnc->mbParam.edged_width,  
                  pEnc->mbParam.edged_height) < 0)  
                 goto xvid_err_memory3;  
         if (image_create  
                 (&pEnc->reference->image, pEnc->mbParam.edged_width,  
                  pEnc->mbParam.edged_height) < 0)  
                 goto xvid_err_memory3;  
         if (image_create  
                 (&pEnc->vInterH, pEnc->mbParam.edged_width,  
                  pEnc->mbParam.edged_height) < 0)  
                 goto xvid_err_memory3;  
         if (image_create  
                 (&pEnc->vInterV, pEnc->mbParam.edged_width,  
                  pEnc->mbParam.edged_height) < 0)  
                 goto xvid_err_memory3;  
         if (image_create  
                 (&pEnc->vInterVf, pEnc->mbParam.edged_width,  
                  pEnc->mbParam.edged_height) < 0)  
                 goto xvid_err_memory3;  
         if (image_create  
                 (&pEnc->vInterHV, pEnc->mbParam.edged_width,  
                  pEnc->mbParam.edged_height) < 0)  
                 goto xvid_err_memory3;  
         if (image_create  
                 (&pEnc->vInterHVf, pEnc->mbParam.edged_width,  
                  pEnc->mbParam.edged_height) < 0)  
                 goto xvid_err_memory3;  
   
   
   
         /* B Frames specific init */  
 #ifdef BFRAMES  
   
         pEnc->global = pParam->global;  
         pEnc->mbParam.max_bframes = pParam->max_bframes;  
         pEnc->bquant_ratio = pParam->bquant_ratio;  
         pEnc->frame_drop_ratio = pParam->frame_drop_ratio;  
         pEnc->bframes = NULL;  
   
         if (pEnc->mbParam.max_bframes > 0) {  
                 int n;  
   
                 pEnc->bframes =  
                         xvid_malloc(pEnc->mbParam.max_bframes * sizeof(FRAMEINFO *),  
                                                 CACHE_LINE);  
   
                 if (pEnc->bframes == NULL)  
                         goto xvid_err_memory3;  
   
                 for (n = 0; n < pEnc->mbParam.max_bframes; n++)  
                         pEnc->bframes[n] = NULL;  
   
   
                 for (n = 0; n < pEnc->mbParam.max_bframes; n++) {  
                         pEnc->bframes[n] = xvid_malloc(sizeof(FRAMEINFO), CACHE_LINE);  
   
                         if (pEnc->bframes[n] == NULL)  
                                 goto xvid_err_memory4;  
   
                         pEnc->bframes[n]->mbs =  
                                 xvid_malloc(sizeof(MACROBLOCK) * pEnc->mbParam.mb_width *  
                                                         pEnc->mbParam.mb_height, CACHE_LINE);  
   
                         if (pEnc->bframes[n]->mbs == NULL)  
                                 goto xvid_err_memory4;  
   
                         image_null(&pEnc->bframes[n]->image);  
   
                         if (image_create  
                                 (&pEnc->bframes[n]->image, pEnc->mbParam.edged_width,  
                                  pEnc->mbParam.edged_height) < 0)  
                                 goto xvid_err_memory4;  
   
                 }  
         }  
   
         pEnc->bframenum_head = 0;  
         pEnc->bframenum_tail = 0;  
         pEnc->flush_bframes = 0;  
         pEnc->bframenum_dx50bvop = -1;  
   
         pEnc->queue = NULL;  
   
   
         if (pEnc->mbParam.max_bframes > 0) {  
                 int n;  
   
                 pEnc->queue =  
                         xvid_malloc(pEnc->mbParam.max_bframes * sizeof(IMAGE),  
                                                 CACHE_LINE);  
   
                 if (pEnc->queue == NULL)  
                         goto xvid_err_memory4;  
   
                 for (n = 0; n < pEnc->mbParam.max_bframes; n++)  
                         image_null(&pEnc->queue[n]);  
   
                 for (n = 0; n < pEnc->mbParam.max_bframes; n++) {  
                         if (image_create  
                                 (&pEnc->queue[n], pEnc->mbParam.edged_width,  
                                  pEnc->mbParam.edged_height) < 0)  
                                 goto xvid_err_memory5;  
   
                 }  
         }  
   
         pEnc->queue_head = 0;  
         pEnc->queue_tail = 0;  
         pEnc->queue_size = 0;  
   
   
         pEnc->mbParam.m_seconds = 0;  
         pEnc->mbParam.m_ticks = 0;  
         pEnc->m_framenum = 0;  
         pEnc->last_pframe = 1;  
 #endif  
   
         pParam->handle = (void *) pEnc;  
   
         if (pParam->rc_bitrate) {  
                 RateControlInit(&pEnc->rate_control, pParam->rc_bitrate,  
                                                 pParam->rc_reaction_delay_factor,  
                                                 pParam->rc_averaging_period, pParam->rc_buffer,  
                                                 pParam->fbase * 1000 / pParam->fincr,  
                                                 pParam->max_quantizer, pParam->min_quantizer);  
         }  
   
         init_timer();  
   
         return XVID_ERR_OK;  
   
         /*  
          * We handle all XVID_ERR_MEMORY here, this makes the code lighter  
          */  
 #ifdef BFRAMES  
   xvid_err_memory5:  
   
   
         if (pEnc->mbParam.max_bframes > 0) {  
   
                 for (i = 0; i < pEnc->mbParam.max_bframes; i++) {  
                         image_destroy(&pEnc->queue[i], pEnc->mbParam.edged_width,  
                                                   pEnc->mbParam.edged_height);  
                 }  
                 xvid_free(pEnc->queue);  
         }  
   
   xvid_err_memory4:  
   
         if (pEnc->mbParam.max_bframes > 0) {  
   
                 for (i = 0; i < pEnc->mbParam.max_bframes; i++) {  
   
                         if (pEnc->bframes[i] == NULL)  
                                 continue;  
   
                         image_destroy(&pEnc->bframes[i]->image, pEnc->mbParam.edged_width,  
                                                   pEnc->mbParam.edged_height);  
   
                         xvid_free(pEnc->bframes[i]->mbs);  
   
                         xvid_free(pEnc->bframes[i]);  
   
                 }  
   
                 xvid_free(pEnc->bframes);  
         }  
   
 #endif  
   
   xvid_err_memory3:  
 #ifdef _DEBUG_PSNR  
         image_destroy(&pEnc->sOriginal, pEnc->mbParam.edged_width,  
                                   pEnc->mbParam.edged_height);  
 #endif  
   
 #ifdef BFRAMES  
         image_destroy(&pEnc->f_refh, pEnc->mbParam.edged_width,  
                                   pEnc->mbParam.edged_height);  
         image_destroy(&pEnc->f_refv, pEnc->mbParam.edged_width,  
                                   pEnc->mbParam.edged_height);  
         image_destroy(&pEnc->f_refhv, pEnc->mbParam.edged_width,  
                                   pEnc->mbParam.edged_height);  
 #endif  
   
         image_destroy(&pEnc->current->image, pEnc->mbParam.edged_width,  
                                   pEnc->mbParam.edged_height);  
         image_destroy(&pEnc->reference->image, pEnc->mbParam.edged_width,  
                                   pEnc->mbParam.edged_height);  
         image_destroy(&pEnc->vInterH, pEnc->mbParam.edged_width,  
                                   pEnc->mbParam.edged_height);  
         image_destroy(&pEnc->vInterV, pEnc->mbParam.edged_width,  
                                   pEnc->mbParam.edged_height);  
         image_destroy(&pEnc->vInterVf, pEnc->mbParam.edged_width,  
                                   pEnc->mbParam.edged_height);  
         image_destroy(&pEnc->vInterHV, pEnc->mbParam.edged_width,  
                                   pEnc->mbParam.edged_height);  
         image_destroy(&pEnc->vInterHVf, pEnc->mbParam.edged_width,  
                                   pEnc->mbParam.edged_height);  
   
   xvid_err_memory2:  
         xvid_free(pEnc->current->mbs);  
         xvid_free(pEnc->reference->mbs);  
   
   xvid_err_memory1:  
         xvid_free(pEnc->current);  
         xvid_free(pEnc->reference);  
         xvid_free(pEnc);  
   
         pParam->handle = NULL;  
   
         return XVID_ERR_MEMORY;  
 }  
   
 /*****************************************************************************  
  * Encoder destruction  
  *  
  * This function destroy the entire encoder structure created by a previous  
  * successful encoder_create call.  
  *  
  * Returned values (for now only one returned value) :  
  *    - XVID_ERR_OK     - no errors  
  *  
  ****************************************************************************/  
   
 int  
 encoder_destroy(Encoder * pEnc)  
 {  
 #ifdef BFRAMES  
         int i;  
 #endif  
   
         ENC_CHECK(pEnc);  
   
         /* B Frames specific */  
 #ifdef BFRAMES  
         if (pEnc->mbParam.max_bframes > 0) {  
   
                 for (i = 0; i < pEnc->mbParam.max_bframes; i++) {  
   
                         image_destroy(&pEnc->queue[i], pEnc->mbParam.edged_width,  
                                           pEnc->mbParam.edged_height);  
                 }  
                 xvid_free(pEnc->queue);  
         }  
   
   
         if (pEnc->mbParam.max_bframes > 0) {  
   
                 for (i = 0; i < pEnc->mbParam.max_bframes; i++) {  
   
                         if (pEnc->bframes[i] == NULL)  
                                 continue;  
   
                         image_destroy(&pEnc->bframes[i]->image, pEnc->mbParam.edged_width,  
                                           pEnc->mbParam.edged_height);  
   
                         xvid_free(pEnc->bframes[i]->mbs);  
   
                         xvid_free(pEnc->bframes[i]);  
                 }  
   
                 xvid_free(pEnc->bframes);  
   
         }  
 #endif  
   
         /* All images, reference, current etc ... */  
   
         image_destroy(&pEnc->current->image, pEnc->mbParam.edged_width,  
                                   pEnc->mbParam.edged_height);  
         image_destroy(&pEnc->reference->image, pEnc->mbParam.edged_width,  
                                   pEnc->mbParam.edged_height);  
         image_destroy(&pEnc->vInterH, pEnc->mbParam.edged_width,  
                                   pEnc->mbParam.edged_height);  
         image_destroy(&pEnc->vInterV, pEnc->mbParam.edged_width,  
                                   pEnc->mbParam.edged_height);  
         image_destroy(&pEnc->vInterVf, pEnc->mbParam.edged_width,  
                                   pEnc->mbParam.edged_height);  
         image_destroy(&pEnc->vInterHV, pEnc->mbParam.edged_width,  
                                   pEnc->mbParam.edged_height);  
         image_destroy(&pEnc->vInterHVf, pEnc->mbParam.edged_width,  
                                   pEnc->mbParam.edged_height);  
 #ifdef BFRAMES  
         image_destroy(&pEnc->f_refh, pEnc->mbParam.edged_width,  
                                   pEnc->mbParam.edged_height);  
         image_destroy(&pEnc->f_refv, pEnc->mbParam.edged_width,  
                                   pEnc->mbParam.edged_height);  
         image_destroy(&pEnc->f_refhv, pEnc->mbParam.edged_width,  
                                   pEnc->mbParam.edged_height);  
 #endif  
 #ifdef _DEBUG_PSNR  
         image_destroy(&pEnc->sOriginal, pEnc->mbParam.edged_width,  
                                   pEnc->mbParam.edged_height);  
 #endif  
   
         /* Encoder structure */  
   
         xvid_free(pEnc->current->mbs);  
         xvid_free(pEnc->current);  
   
         xvid_free(pEnc->reference->mbs);  
         xvid_free(pEnc->reference);  
   
         xvid_free(pEnc);  
   
         return XVID_ERR_OK;  
 }  
   
   
 #ifdef BFRAMES  
 void inc_frame_num(Encoder * pEnc)  
 {  
         pEnc->iFrameNum++;  
         pEnc->mbParam.m_ticks += pEnc->mbParam.fincr;  
   
         pEnc->mbParam.m_seconds = pEnc->mbParam.m_ticks / pEnc->mbParam.fbase;  
         pEnc->mbParam.m_ticks = pEnc->mbParam.m_ticks % pEnc->mbParam.fbase;  
 }  
 #endif  
   
   
 #ifdef BFRAMES  
 void queue_image(Encoder * pEnc, XVID_ENC_FRAME * pFrame)  
 {  
         if (pEnc->queue_size >= pEnc->mbParam.max_bframes)  
         {  
                 DPRINTF(DPRINTF_DEBUG,"FATAL: QUEUE FULL");  
                 return;  
         }  
   
         DPRINTF(DPRINTF_DEBUG,"*** QUEUE bf: head=%i tail=%i   queue: head=%i tail=%i size=%i",  
                                 pEnc->bframenum_head, pEnc->bframenum_tail,  
                                 pEnc->queue_head, pEnc->queue_tail, pEnc->queue_size);  
   
   
         start_timer();  
         if (image_input  
                 (&pEnc->queue[pEnc->queue_tail], pEnc->mbParam.width, pEnc->mbParam.height,  
                  pEnc->mbParam.edged_width, pFrame->image, pFrame->colorspace))  
                 return;  
         stop_conv_timer();  
   
         pEnc->queue_size++;  
         pEnc->queue_tail =  (pEnc->queue_tail + 1) % pEnc->mbParam.max_bframes;  
 }  
 #endif  
   
   
 #ifdef BFRAMES  
 /*****************************************************************************  
  * IPB frame encoder entry point  
  *  
  * Returned values :  
  *    - XVID_ERR_OK     - no errors  
  *    - XVID_ERR_FORMAT - the image subsystem reported the image had a wrong  
  *                        format  
  ****************************************************************************/  
   
 int  
 encoder_encode_bframes(Encoder * pEnc,  
                            XVID_ENC_FRAME * pFrame,  
                            XVID_ENC_STATS * pResult)  
 {  
         uint16_t x, y;  
         Bitstream bs;  
         uint32_t bits;  
   
         int input_valid = 1;  
   
 #ifdef _DEBUG_PSNR  
         float psnr;  
         char temp[128];  
 #endif  
   
         ENC_CHECK(pEnc);  
         ENC_CHECK(pFrame);  
         ENC_CHECK(pFrame->image);  
   
         start_global_timer();  
   
         BitstreamInit(&bs, pFrame->bitstream, 0);  
   
 ipvop_loop:  
   
         /*  
          * bframe "flush" code  
          */  
   
         if ((pFrame->image == NULL || pEnc->flush_bframes)  
                 && (pEnc->bframenum_head < pEnc->bframenum_tail)) {  
   
                 if (pEnc->flush_bframes == 0) {  
                         /*  
                          * we have reached the end of stream without getting  
                          * a future reference frame... so encode last final  
                          * frame as a pframe  
                          */  
   
                         DPRINTF(DPRINTF_DEBUG,"*** BFRAME (final frame) bf: head=%i tail=%i   queue: head=%i tail=%i size=%i",  
                                 pEnc->bframenum_head, pEnc->bframenum_tail,  
                                 pEnc->queue_head, pEnc->queue_tail, pEnc->queue_size);  
   
                         pEnc->bframenum_tail--;  
                         SWAP(pEnc->current, pEnc->reference);  
   
                         SWAP(pEnc->current, pEnc->bframes[pEnc->bframenum_tail]);  
   
                         FrameCodeP(pEnc, &bs, &bits, 1, 0);  
   
                         BitstreamPad(&bs);  
                         pFrame->length = BitstreamLength(&bs);  
                         pFrame->intra = 0;  
   
                         return XVID_ERR_OK;  
                 }  
   
   
                 DPRINTF(DPRINTF_DEBUG,"*** BFRAME (flush) bf: head=%i tail=%i   queue: head=%i tail=%i size=%i",  
                                 pEnc->bframenum_head, pEnc->bframenum_tail,  
                                 pEnc->queue_head, pEnc->queue_tail, pEnc->queue_size);  
   
                 FrameCodeB(pEnc, pEnc->bframes[pEnc->bframenum_head], &bs, &bits);  
                 pEnc->bframenum_head++;  
   
                 BitstreamPad(&bs);  
                 pFrame->length = BitstreamLength(&bs);  
                 pFrame->intra = 0;  
   
                 if (input_valid)  
                         queue_image(pEnc, pFrame);  
   
                 return XVID_ERR_OK;  
         }  
   
         if (pEnc->bframenum_head > 0) {  
                 pEnc->bframenum_head = pEnc->bframenum_tail = 0;  
   
                 if ((pEnc->global & XVID_GLOBAL_PACKED)) {  
   
                         DPRINTF(DPRINTF_DEBUG,"*** EMPTY bf: head=%i tail=%i   queue: head=%i tail=%i size=%i",  
                                 pEnc->bframenum_head, pEnc->bframenum_tail,  
                                 pEnc->queue_head, pEnc->queue_tail, pEnc->queue_size);  
   
                         BitstreamWriteVopHeader(&bs, &pEnc->mbParam, pEnc->current, 0);  
                         BitstreamPad(&bs);  
                         BitstreamPutBits(&bs, 0x7f, 8);  
   
                         pFrame->length = BitstreamLength(&bs);  
                         pFrame->intra = 0;  
   
                         if (input_valid)  
                                 queue_image(pEnc, pFrame);  
   
                         return XVID_ERR_OK;  
                 }  
         }  
   
   
 bvop_loop:  
   
         if (pEnc->bframenum_dx50bvop != -1)  
         {  
   
                 SWAP(pEnc->current, pEnc->reference);  
                 SWAP(pEnc->current, pEnc->bframes[pEnc->bframenum_dx50bvop]);  
   
                 if ((pEnc->global & XVID_GLOBAL_DEBUG)) {  
                         image_printf(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height, 5, 100, "DX50 IVOP");  
                 }  
   
                 if (input_valid)  
                 {  
                         queue_image(pEnc, pFrame);  
                         input_valid = 0;  
                 }  
   
         } else if (input_valid) {  
   
                 SWAP(pEnc->current, pEnc->reference);  
   
                 start_timer();  
                 if (image_input  
                         (&pEnc->current->image, pEnc->mbParam.width, pEnc->mbParam.height,  
                         pEnc->mbParam.edged_width, pFrame->image, pFrame->colorspace))  
                         return XVID_ERR_FORMAT;  
                 stop_conv_timer();  
   
                 // queue input frame, and dequue next image  
                 if (pEnc->queue_size > 0)  
                 {  
                         image_swap(&pEnc->current->image, &pEnc->queue[pEnc->queue_tail]);  
                         if (pEnc->queue_head != pEnc->queue_tail)  
                         {  
                                 image_swap(&pEnc->current->image, &pEnc->queue[pEnc->queue_head]);  
                         }  
                         pEnc->queue_head =  (pEnc->queue_head + 1) % pEnc->mbParam.max_bframes;  
                         pEnc->queue_tail =  (pEnc->queue_tail + 1) % pEnc->mbParam.max_bframes;  
                 }  
   
         } else if (pEnc->queue_size > 0) {  
   
                 SWAP(pEnc->current, pEnc->reference);  
   
                 image_swap(&pEnc->current->image, &pEnc->queue[pEnc->queue_head]);  
                 pEnc->queue_head =  (pEnc->queue_head + 1) % pEnc->mbParam.max_bframes;  
                 pEnc->queue_size--;  
   
         } else if (BitstreamPos(&bs) == 0) {  
   
                 DPRINTF(DPRINTF_DEBUG,"*** SKIP bf: head=%i tail=%i   queue: head=%i tail=%i size=%i",  
                                 pEnc->bframenum_head, pEnc->bframenum_tail,  
                                 pEnc->queue_head, pEnc->queue_tail, pEnc->queue_size);  
   
                 pFrame->intra = 0;  
   
                 BitstreamPutBits(&bs, 0x7f, 8);  
                 BitstreamPad(&bs);  
                 pFrame->length = BitstreamLength(&bs);  
   
                 return XVID_ERR_OK;  
   
         } else {  
   
                 pFrame->length = BitstreamLength(&bs);  
                 return XVID_ERR_OK;  
         }  
   
         pEnc->flush_bframes = 0;  
   
         /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  
          * Well there was a separation here so i put it in ANSI C  
          * comment style :-)  
          * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */  
   
         emms();  
   
         // only inc frame num, adapt quant, etc. if we havent seen it before  
         if (pEnc->bframenum_dx50bvop < 0 )  
         {  
                 if (pFrame->quant == 0)  
                         pEnc->current->quant = RateControlGetQ(&pEnc->rate_control, 0);  
                 else  
                         pEnc->current->quant = pFrame->quant;  
   
 /*              if (pEnc->current->quant < 1)  
                         pEnc->current->quant = 1;  
   
                 if (pEnc->current->quant > 31)  
                         pEnc->current->quant = 31;  
 */  
                 pEnc->current->global_flags = pFrame->general;  
                 pEnc->current->motion_flags = pFrame->motion;  
   
                 /* ToDo : dynamic fcode (in both directions) */  
                 pEnc->current->fcode = pEnc->mbParam.m_fcode;  
                 pEnc->current->bcode = pEnc->mbParam.m_fcode;  
   
                 pEnc->current->seconds = pEnc->mbParam.m_seconds;  
                 pEnc->current->ticks = pEnc->mbParam.m_ticks;  
   
                 inc_frame_num(pEnc);  
   
 #ifdef _DEBUG_PSNR  
                 image_copy(&pEnc->sOriginal, &pEnc->current->image,  
                            pEnc->mbParam.edged_width, pEnc->mbParam.height);  
 #endif  
   
                 emms();  
   
                 if ((pEnc->global & XVID_GLOBAL_DEBUG)) {  
                         image_printf(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height, 5, 5,  
                                 "%i  if:%i  st:%i:%i", pEnc->m_framenum++, pEnc->iFrameNum, pEnc->current->seconds, pEnc->current->ticks);  
                 }  
   
         /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  
          * Luminance masking  
          * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */  
   
                 if ((pEnc->current->global_flags & XVID_LUMIMASKING)) {  
                         int *temp_dquants =  
                                 (int *) xvid_malloc(pEnc->mbParam.mb_width *  
                                                                 pEnc->mbParam.mb_height * sizeof(int),  
                                                                 CACHE_LINE);  
   
                         pEnc->current->quant =  
                                 adaptive_quantization(pEnc->current->image.y,  
                                                                   pEnc->mbParam.edged_width, temp_dquants,  
                                                                   pEnc->current->quant, pEnc->current->quant,  
                                                                   2 * pEnc->current->quant,  
                                                                   pEnc->mbParam.mb_width,  
                                                                   pEnc->mbParam.mb_height);  
   
                         for (y = 0; y < pEnc->mbParam.mb_height; y++) {  
   
 #define OFFSET(x,y) ((x) + (y)*pEnc->mbParam.mb_width)  
   
                                 for (x = 0; x < pEnc->mbParam.mb_width; x++) {  
                                         MACROBLOCK *pMB = &pEnc->current->mbs[OFFSET(x, y)];  
   
                                         pMB->dquant = iDQtab[temp_dquants[OFFSET(x, y)] + 2];  
                                 }  
   
 #undef OFFSET  
                         }  
   
                         xvid_free(temp_dquants);  
                 }  
   
         }  
   
         /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%  
          * ivop/pvop/bvop selection  
          * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */  
   
   
         if (pEnc->iFrameNum == 0 || pFrame->intra == 1 || pEnc->bframenum_dx50bvop >= 0 ||  
                 (pFrame->intra < 0 && pEnc->iMaxKeyInterval > 0 &&  
                  pEnc->iFrameNum >= pEnc->iMaxKeyInterval)  
                 || image_mad(&pEnc->reference->image, &pEnc->current->image,  
                                          pEnc->mbParam.edged_width, pEnc->mbParam.width,  
                                          pEnc->mbParam.height) > 30) {  
                 /*  
                  * This will be coded as an Intra Frame  
                  */  
   
                 DPRINTF(DPRINTF_DEBUG,"*** IFRAME bf: head=%i tail=%i   queue: head=%i tail=%i size=%i",  
                                 pEnc->bframenum_head, pEnc->bframenum_tail,  
                                 pEnc->queue_head, pEnc->queue_tail, pEnc->queue_size);  
   
                 if ((pEnc->global & XVID_GLOBAL_DEBUG)) {  
                         image_printf(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height, 5, 200, "IVOP");  
                 }  
   
                 // when we reach an iframe in DX50BVOP mode, encode the last bframe as a pframe  
   
                 if ((pEnc->global & XVID_GLOBAL_DX50BVOP) && pEnc->bframenum_tail > 0) {  
   
                         pEnc->bframenum_tail--;  
                         pEnc->bframenum_dx50bvop = pEnc->bframenum_tail;  
   
                         SWAP(pEnc->current, pEnc->bframes[pEnc->bframenum_dx50bvop]);  
                         if ((pEnc->global & XVID_GLOBAL_DEBUG)) {  
                                 image_printf(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height, 5, 100, "DX50 BVOP->PVOP");  
                         }  
                         FrameCodeP(pEnc, &bs, &bits, 1, 0);  
   
                         pFrame->intra = 0;  
   
                 } else {  
   
                         FrameCodeI(pEnc, &bs, &bits);  
                         pFrame->intra = 1;  
   
                         pEnc->bframenum_dx50bvop = -1;  
                 }  
   
                 pEnc->flush_bframes = 1;  
   
                 if ((pEnc->global & XVID_GLOBAL_PACKED) && pEnc->bframenum_tail > 0) {  
                         BitstreamPad(&bs);  
                         input_valid = 0;  
                         goto ipvop_loop;  
                 }  
   
                 /*  
                  * NB : sequences like "IIBB" decode fine with msfdam but,  
                  *      go screwy with divx 5.00  
                  */  
         } else if (pEnc->bframenum_tail >= pEnc->mbParam.max_bframes) {  
                 /*  
                  * This will be coded as a Predicted Frame  
                  */  
   
                 DPRINTF(DPRINTF_DEBUG,"*** PFRAME bf: head=%i tail=%i   queue: head=%i tail=%i size=%i",  
                                 pEnc->bframenum_head, pEnc->bframenum_tail,  
                                 pEnc->queue_head, pEnc->queue_tail, pEnc->queue_size);  
247    
248                  if ((pEnc->global & XVID_GLOBAL_DEBUG)) {          if (pEnc->current->mbs == NULL || pEnc->reference->mbs == NULL)
249                          image_printf(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height, 5, 200, "PVOP");                  goto xvid_err_memory2;
                 }  
250    
251                  FrameCodeP(pEnc, &bs, &bits, 1, 0);          /* try to allocate image memory */
                 pFrame->intra = 0;  
                 pEnc->flush_bframes = 1;  
252    
253                  if ((pEnc->global & XVID_GLOBAL_PACKED)) {  #ifdef _DEBUG_PSNR
254                          BitstreamPad(&bs);          image_null(&pEnc->sOriginal);
255                          input_valid = 0;  #endif
256                          goto ipvop_loop;          image_null(&pEnc->current->image);
257                  }          image_null(&pEnc->reference->image);
258            image_null(&pEnc->vInterH);
259            image_null(&pEnc->vInterV);
260            image_null(&pEnc->vInterHV);
261    
262          } else {  #ifdef _DEBUG_PSNR
263                  /*          if (image_create
264                   * This will be coded as a Bidirectional Frame                  (&pEnc->sOriginal, pEnc->mbParam.edged_width,
265                   */                   pEnc->mbParam.edged_height) < 0)
266                    goto xvid_err_memory3;
267    #endif
268            if (image_create
269                    (&pEnc->current->image, pEnc->mbParam.edged_width,
270                     pEnc->mbParam.edged_height) < 0)
271                    goto xvid_err_memory3;
272            if (image_create
273                    (&pEnc->reference->image, pEnc->mbParam.edged_width,
274                     pEnc->mbParam.edged_height) < 0)
275                    goto xvid_err_memory3;
276            if (image_create
277                    (&pEnc->vInterH, pEnc->mbParam.edged_width,
278                     pEnc->mbParam.edged_height) < 0)
279                    goto xvid_err_memory3;
280            if (image_create
281                    (&pEnc->vInterV, pEnc->mbParam.edged_width,
282                     pEnc->mbParam.edged_height) < 0)
283                    goto xvid_err_memory3;
284            if (image_create
285                    (&pEnc->vInterHV, pEnc->mbParam.edged_width,
286                     pEnc->mbParam.edged_height) < 0)
287                    goto xvid_err_memory3;
288    
289                  if ((pEnc->global & XVID_GLOBAL_DEBUG)) {          pParam->handle = (void *) pEnc;
                         image_printf(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height, 5, 200, "BVOP");  
                 }  
290    
291                  if (pFrame->bquant < 1) {          if (pParam->rc_bitrate) {
292                          pEnc->current->quant =                  RateControlInit(&pEnc->rate_control, pParam->rc_bitrate,
293                                  ((pEnc->reference->quant +                                                  pParam->rc_reaction_delay_factor,
294                                    pEnc->current->quant) * pEnc->bquant_ratio) / 200;                                                  pParam->rc_averaging_period, pParam->rc_buffer,
295                  } else {                                                  pParam->fbase * 1000 / pParam->fincr,
296                          pEnc->current->quant = pFrame->bquant;                                                  pParam->max_quantizer, pParam->min_quantizer);
297                  }                  }
                 if (pEnc->current->quant < 1)  
                         pEnc->current->quant = 1;  
298    
299                  if (pEnc->current->quant > 31)          init_timer();
                         pEnc->current->quant = 31;  
300    
301            return XVID_ERR_OK;
302    
303                          DPRINTF(DPRINTF_DEBUG,"*** BFRAME (store) bf: head=%i tail=%i   queue: head=%i tail=%i size=%i  quant=%i\n",          /*
304                                  pEnc->bframenum_head, pEnc->bframenum_tail,           * We handle all XVID_ERR_MEMORY here, this makes the code lighter
305                                  pEnc->queue_head, pEnc->queue_tail, pEnc->queue_size,pEnc->current->quant);           */
306    
307      xvid_err_memory3:
308    #ifdef _DEBUG_PSNR
309            image_destroy(&pEnc->sOriginal, pEnc->mbParam.edged_width,
310                                      pEnc->mbParam.edged_height);
311    #endif
312    
313            image_destroy(&pEnc->current->image, pEnc->mbParam.edged_width,
314                                      pEnc->mbParam.edged_height);
315            image_destroy(&pEnc->reference->image, pEnc->mbParam.edged_width,
316                                      pEnc->mbParam.edged_height);
317            image_destroy(&pEnc->vInterH, pEnc->mbParam.edged_width,
318                                      pEnc->mbParam.edged_height);
319            image_destroy(&pEnc->vInterV, pEnc->mbParam.edged_width,
320                                      pEnc->mbParam.edged_height);
321            image_destroy(&pEnc->vInterHV, pEnc->mbParam.edged_width,
322                                      pEnc->mbParam.edged_height);
323    
324                  /* store frame into bframe buffer & swap ref back to current */    xvid_err_memory2:
325                  SWAP(pEnc->current, pEnc->bframes[pEnc->bframenum_tail]);          xvid_free(pEnc->current->mbs);
326                  SWAP(pEnc->current, pEnc->reference);          xvid_free(pEnc->reference->mbs);
327    
328                  pEnc->bframenum_tail++;    xvid_err_memory1:
329            xvid_free(pEnc->current);
330            xvid_free(pEnc->reference);
331            xvid_free(pEnc);
332    
333                  pFrame->intra = 0;          pParam->handle = NULL;
                 pFrame->length = 0;  
334    
335                  input_valid = 0;          return XVID_ERR_MEMORY;
                 goto bvop_loop;  
336          }          }
337    
338          BitstreamPad(&bs);  /*****************************************************************************
339          pFrame->length = BitstreamLength(&bs);   * Encoder destruction
340     *
341     * This function destroy the entire encoder structure created by a previous
342     * successful encoder_create call.
343     *
344     * Returned values (for now only one returned value) :
345     *    - XVID_ERR_OK     - no errors
346     *
347     ****************************************************************************/
348    
349          if (pResult) {  int
350                  pResult->quant = pEnc->current->quant;  encoder_destroy(Encoder * pEnc)
351                  pResult->hlength = pFrame->length - (pEnc->sStat.iTextBits / 8);  {
                 pResult->kblks = pEnc->sStat.kblks;  
                 pResult->mblks = pEnc->sStat.mblks;  
                 pResult->ublks = pEnc->sStat.ublks;  
         }  
352    
353          emms();          ENC_CHECK(pEnc);
354    
355  #ifdef _DEBUG_PSNR          /* All images, reference, current etc ... */
356          psnr =          image_destroy(&pEnc->current->image, pEnc->mbParam.edged_width,
357                  image_psnr(&pEnc->sOriginal, &pEnc->current->image,                                    pEnc->mbParam.edged_height);
358                                     pEnc->mbParam.edged_width, pEnc->mbParam.width,          image_destroy(&pEnc->reference->image, pEnc->mbParam.edged_width,
359                                     pEnc->mbParam.height);                                    pEnc->mbParam.edged_height);
360            image_destroy(&pEnc->vInterH, pEnc->mbParam.edged_width,
361                                      pEnc->mbParam.edged_height);
362            image_destroy(&pEnc->vInterV, pEnc->mbParam.edged_width,
363                                      pEnc->mbParam.edged_height);
364            image_destroy(&pEnc->vInterHV, pEnc->mbParam.edged_width,
365                                      pEnc->mbParam.edged_height);
366    
367          snprintf(temp, 127, "PSNR: %f\n", psnr);  #ifdef _DEBUG_PSNR
368          DEBUG(temp);          image_destroy(&pEnc->sOriginal, pEnc->mbParam.edged_width,
369                                      pEnc->mbParam.edged_height);
370  #endif  #endif
371    
372          if (pFrame->quant == 0) {          /* Encoder structure */
373                  RateControlUpdate(&pEnc->rate_control, pEnc->current->quant,          xvid_free(pEnc->current->mbs);
374                                                    pFrame->length, pFrame->intra);          xvid_free(pEnc->current);
         }  
375    
376            xvid_free(pEnc->reference->mbs);
377            xvid_free(pEnc->reference);
378    
379          stop_global_timer();          xvid_free(pEnc);
         write_timer();  
380    
381          return XVID_ERR_OK;          return XVID_ERR_OK;
382  }  }
383    
 #endif  
   
384    
385    void inc_frame_num(Encoder * pEnc)
386    {
387            pEnc->mbParam.m_ticks += pEnc->mbParam.fincr;
388            pEnc->mbParam.m_seconds = pEnc->mbParam.m_ticks / pEnc->mbParam.fbase;
389            pEnc->mbParam.m_ticks = pEnc->mbParam.m_ticks % pEnc->mbParam.fbase;
390    }
391    
392  /*****************************************************************************  /*****************************************************************************
393   * "original" IP frame encoder entry point   * "original" IP frame encoder entry point
# Line 1118  Line 424 
424    
425          pEnc->current->global_flags = pFrame->general;          pEnc->current->global_flags = pFrame->general;
426          pEnc->current->motion_flags = pFrame->motion;          pEnc->current->motion_flags = pFrame->motion;
 #ifdef BFRAMES  
427          pEnc->current->seconds = pEnc->mbParam.m_seconds;          pEnc->current->seconds = pEnc->mbParam.m_seconds;
428          pEnc->current->ticks = pEnc->mbParam.m_ticks;          pEnc->current->ticks = pEnc->mbParam.m_ticks;
 #endif  
429          pEnc->mbParam.hint = &pFrame->hint;          pEnc->mbParam.hint = &pFrame->hint;
430    
431          start_timer();          start_timer();
# Line 1238  Line 542 
542          emms();          emms();
543    
544          if (pFrame->quant == 0) {          if (pFrame->quant == 0) {
545                  RateControlUpdate(&pEnc->rate_control, pEnc->current->quant,                  RateControlUpdate(&pEnc->rate_control, (int16_t)pEnc->current->quant,
546                                                    pFrame->length, pFrame->intra);                                                    pFrame->length, pFrame->intra);
547          }          }
548  #ifdef _DEBUG_PSNR  #ifdef _DEBUG_PSNR
# Line 1251  Line 555 
555          DEBUG(temp);          DEBUG(temp);
556  #endif  #endif
557    
 #ifdef BFRAMES  
558          inc_frame_num(pEnc);          inc_frame_num(pEnc);
 #else  
559          pEnc->iFrameNum++;          pEnc->iFrameNum++;
 #endif  
   
560    
561          stop_global_timer();          stop_global_timer();
562          write_timer();          write_timer();
# Line 1507  Line 807 
807          pEnc->current->coding_type = I_VOP;          pEnc->current->coding_type = I_VOP;
808    
809          BitstreamWriteVolHeader(bs, &pEnc->mbParam, pEnc->current);          BitstreamWriteVolHeader(bs, &pEnc->mbParam, pEnc->current);
810  #ifdef BFRAMES  
 #define DIVX501B481P "DivX501b481p"  
         if ((pEnc->global & XVID_GLOBAL_PACKED)) {  
                 BitstreamWriteUserData(bs, DIVX501B481P, strlen(DIVX501B481P));  
         }  
 #endif  
811          BitstreamWriteVopHeader(bs, &pEnc->mbParam, pEnc->current, 1);          BitstreamWriteVopHeader(bs, &pEnc->mbParam, pEnc->current, 1);
812    
813          *pBits = BitstreamPos(bs);          *pBits = BitstreamPos(bs);
# Line 1536  Line 831 
831                          stop_prediction_timer();                          stop_prediction_timer();
832    
833                          start_timer();                          start_timer();
834                            if (pEnc->current->global_flags & XVID_GREYSCALE)
835                            {       pMB->cbp &= 0x3C;               /* keep only bits 5-2 */
836                                    qcoeff[4*64+0]=0;               /* zero, because for INTRA MBs DC value is saved */
837                                    qcoeff[5*64+0]=0;
838                            }
839                          MBCoding(pEnc->current, pMB, qcoeff, bs, &pEnc->sStat);                          MBCoding(pEnc->current, pMB, qcoeff, bs, &pEnc->sStat);
840                          stop_coding_timer();                          stop_coding_timer();
841                  }                  }
# Line 1557  Line 857 
857    
858    
859  #define INTRA_THRESHOLD 0.5  #define INTRA_THRESHOLD 0.5
 #define BFRAME_SKIP_THRESHHOLD 16  
860    
861  static int  static int
862  FrameCodeP(Encoder * pEnc,  FrameCodeP(Encoder * pEnc,
# Line 1572  Line 871 
871          DECLARE_ALIGNED_MATRIX(qcoeff, 6, 64, int16_t, CACHE_LINE);          DECLARE_ALIGNED_MATRIX(qcoeff, 6, 64, int16_t, CACHE_LINE);
872    
873          int iLimit;          int iLimit;
874          int k;          unsigned int x, y;
         int x, y;  
875          int iSearchRange;          int iSearchRange;
876          int bIntra;          int bIntra;
877    
# Line 1582  Line 880 
880    
881          start_timer();          start_timer();
882          image_setedges(pRef, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height,          image_setedges(pRef, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height,
883                                     pEnc->mbParam.width, pEnc->mbParam.height,                                     pEnc->mbParam.width, pEnc->mbParam.height);
                                    pEnc->current->global_flags & XVID_INTERLACING);  
884          stop_edges_timer();          stop_edges_timer();
885    
886          pEnc->mbParam.m_rounding_type = 1 - pEnc->mbParam.m_rounding_type;          pEnc->mbParam.m_rounding_type = 1 - pEnc->mbParam.m_rounding_type;
# Line 1684  Line 981 
981                                  CodeIntraMB(pEnc, pMB);                                  CodeIntraMB(pEnc, pMB);
982                                  MBTransQuantIntra(&pEnc->mbParam, pEnc->current, pMB, x, y,                                  MBTransQuantIntra(&pEnc->mbParam, pEnc->current, pMB, x, y,
983                                                                    dct_codes, qcoeff);                                                                    dct_codes, qcoeff);
                         }  
984    
985                          start_timer();                          start_timer();
986                          MBPrediction(pEnc->current, x, y, pEnc->mbParam.mb_width, qcoeff);                          MBPrediction(pEnc->current, x, y, pEnc->mbParam.mb_width, qcoeff);
987                          stop_prediction_timer();                          stop_prediction_timer();
988                            }
989    
990                          if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q) {                          if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q) {
991                                  pEnc->sStat.kblks++;                                  pEnc->sStat.kblks++;
# Line 1707  Line 1004 
1004                          if (pMB->cbp == 0 && pMB->mode == MODE_INTER && pMB->mvs[0].x == 0 &&                          if (pMB->cbp == 0 && pMB->mode == MODE_INTER && pMB->mvs[0].x == 0 &&
1005                                  pMB->mvs[0].y == 0) {                                  pMB->mvs[0].y == 0) {
1006    
1007  /* This is a candidate for SKIPping, but check intermediate B-frames first */                                          MBSkip(bs);     /* without B-frames, no precautions are needed */
   
 #ifdef BFRAMES  
                                 int iSAD=BFRAME_SKIP_THRESHHOLD;  
                                 int bSkip=1;  
1008    
                                 for (k=pEnc->bframenum_head; k< pEnc->bframenum_tail; k++)  
                                 {  
                                         iSAD = sad16(pEnc->reference->image.y + 16*y*pEnc->mbParam.edged_width + 16*x,  
                                                                 pEnc->bframes[k]->image.y + 16*y*pEnc->mbParam.edged_width + 16*x,  
                                                                 pEnc->mbParam.edged_width,BFRAME_SKIP_THRESHHOLD);  
                                         if (iSAD >= BFRAME_SKIP_THRESHHOLD)  
                                         {       bSkip = 0;  
                                                 break;  
1009                                          }                                          }
1010                            else {
1011                                    if (pEnc->current->global_flags & XVID_GREYSCALE) {
1012                                            pMB->cbp &= 0x3C;               /* keep only bits 5-2 */
1013                                            qcoeff[4*64+0]=0;               /* zero, because DC for INTRA MBs DC value is saved */
1014                                            qcoeff[5*64+0]=0;
1015                                  }                                  }
                                 if (!bSkip)  
                                 {  
                                         MBCoding(pEnc->current, pMB, qcoeff, bs, &pEnc->sStat);  
                                         pMB->cbp = 0x80;                /* trick! so cbp!=0, but still nothing is written to bs */  
                                 }  
                                 else  
                                         MBSkip(bs);  
   
   
 #else  
                                         MBSkip(bs);     /* without B-frames, no precautions are needed */  
   
 #endif  
   
                         } else {  
1016                                  MBCoding(pEnc->current, pMB, qcoeff, bs, &pEnc->sStat);                                  MBCoding(pEnc->current, pMB, qcoeff, bs, &pEnc->sStat);
1017                          }                          }
1018    
# Line 1774  Line 1049 
1049    
1050          pEnc->sStat.fMvPrevSigma = fSigma;          pEnc->sStat.fMvPrevSigma = fSigma;
1051    
 #ifdef BFRAMES  
         /* frame drop code */  
         // DPRINTF(DPRINTF_DEBUG, "kmu %i %i %i", pEnc->sStat.kblks, pEnc->sStat.mblks, pEnc->sStat.ublks);  
         if (pEnc->sStat.kblks + pEnc->sStat.mblks <=  
                 (pEnc->frame_drop_ratio * pEnc->mbParam.mb_width * pEnc->mbParam.mb_height) / 100)  
         {  
                 pEnc->sStat.kblks = pEnc->sStat.mblks = 0;  
                 pEnc->sStat.ublks = pEnc->mbParam.mb_width * pEnc->mbParam.mb_height;  
   
                 BitstreamReset(bs);  
                 BitstreamWriteVopHeader(bs, &pEnc->mbParam, pEnc->current, 0);  
   
                 // copy reference frame details into the current frame  
                 pEnc->current->quant = pEnc->reference->quant;  
                 pEnc->current->motion_flags = pEnc->reference->motion_flags;  
                 pEnc->current->rounding_type = pEnc->reference->rounding_type;  
                 pEnc->current->fcode = pEnc->reference->fcode;  
                 pEnc->current->bcode = pEnc->reference->bcode;  
                 image_copy(&pEnc->current->image, &pEnc->reference->image, pEnc->mbParam.edged_width, pEnc->mbParam.height);  
                 memcpy(pEnc->current->mbs, pEnc->reference->mbs, sizeof(MACROBLOCK) * pEnc->mbParam.mb_width * pEnc->mbParam.mb_height);  
   
         }  
 #endif  
   
1052          *pBits = BitstreamPos(bs) - *pBits;          *pBits = BitstreamPos(bs) - *pBits;
1053    
 #ifdef BFRAMES  
         pEnc->time_pp = ((int32_t)pEnc->mbParam.fbase - (int32_t)pEnc->last_pframe + (int32_t)pEnc->mbParam.m_ticks) % (int32_t)pEnc->mbParam.fbase;  
         pEnc->last_pframe = pEnc->mbParam.m_ticks;  
 #endif  
   
1054          return 0;                                       // inter          return 0;                                       // inter
 }  
   
   
 #ifdef BFRAMES  
 static void  
 FrameCodeB(Encoder * pEnc,  
                    FRAMEINFO * frame,  
                    Bitstream * bs,  
                    uint32_t * pBits)  
 {  
         int16_t dct_codes[6 * 64];  
         int16_t qcoeff[6 * 64];  
         uint32_t x, y;  
         VECTOR forward;  
         VECTOR backward;  
   
         IMAGE *f_ref = &pEnc->reference->image;  
         IMAGE *b_ref = &pEnc->current->image;  
   
 #ifdef BFRAMES_DEC_DEBUG  
         FILE *fp;  
         static char first=0;  
 #define BFRAME_DEBUG    if (!first && fp){ \  
                 fprintf(fp,"Y=%3d   X=%3d   MB=%2d   CBP=%02X\n",y,x,mb->mode,mb->cbp); \  
         }  
   
         if (!first){  
                 fp=fopen("C:\\XVIDDBGE.TXT","w");  
         }  
 #endif  
   
         // forward  
         image_setedges(f_ref, pEnc->mbParam.edged_width,  
                                    pEnc->mbParam.edged_height, pEnc->mbParam.width,  
                                    pEnc->mbParam.height,  
                                    frame->global_flags & XVID_INTERLACING);  
         start_timer();  
         image_interpolate(f_ref, &pEnc->f_refh, &pEnc->f_refv, &pEnc->f_refhv,  
                                           pEnc->mbParam.edged_width, pEnc->mbParam.edged_height,  
                                           0);  
         stop_inter_timer();  
   
         // backward  
         image_setedges(b_ref, pEnc->mbParam.edged_width,  
                                    pEnc->mbParam.edged_height, pEnc->mbParam.width,  
                                    pEnc->mbParam.height,  
                                    frame->global_flags & XVID_INTERLACING);  
         start_timer();  
         image_interpolate(b_ref, &pEnc->vInterH, &pEnc->vInterV, &pEnc->vInterHV,  
                                           pEnc->mbParam.edged_width, pEnc->mbParam.edged_height,  
                                           0);  
         stop_inter_timer();  
   
         start_timer();  
         MotionEstimationBVOP(&pEnc->mbParam, frame,  
           ((int32_t)pEnc->mbParam.fbase + (int32_t)pEnc->mbParam.m_ticks + 1 - (int32_t)pEnc->last_pframe) % pEnc->mbParam.fbase,  
                                                 pEnc->time_pp,  
                                                 pEnc->reference->mbs, f_ref,  
                                                  &pEnc->f_refh, &pEnc->f_refv, &pEnc->f_refhv,  
                                                  pEnc->current->mbs, b_ref, &pEnc->vInterH,  
                                                  &pEnc->vInterV, &pEnc->vInterHV);  
   
   
         stop_motion_timer();  
   
         /*if (test_quant_type(&pEnc->mbParam, pEnc->current))  
            {  
            BitstreamWriteVolHeader(bs, pEnc->mbParam.width, pEnc->mbParam.height, pEnc->mbParam.quant_type);  
            } */  
   
         frame->coding_type = B_VOP;  
         BitstreamWriteVopHeader(bs, &pEnc->mbParam, frame, 1);  
   
         *pBits = BitstreamPos(bs);  
   
         pEnc->sStat.iTextBits = 0;  
         pEnc->sStat.iMvSum = 0;  
         pEnc->sStat.iMvCount = 0;  
         pEnc->sStat.kblks = pEnc->sStat.mblks = pEnc->sStat.ublks = 0;  
   
   
         for (y = 0; y < pEnc->mbParam.mb_height; y++) {  
                 // reset prediction  
   
                 forward.x = 0;  
                 forward.y = 0;  
                 backward.x = 0;  
                 backward.y = 0;  
   
                 for (x = 0; x < pEnc->mbParam.mb_width; x++) {  
                         MACROBLOCK *f_mb =  
                                 &pEnc->reference->mbs[x + y * pEnc->mbParam.mb_width];  
                         MACROBLOCK *b_mb =  
                                 &pEnc->current->mbs[x + y * pEnc->mbParam.mb_width];  
                         MACROBLOCK *mb = &frame->mbs[x + y * pEnc->mbParam.mb_width];  
   
                         // decoder ignores mb when refence block is INTER(0,0), CBP=0  
                         if (mb->mode == MODE_NOT_CODED) {  
                                 mb->mvs[0].x = 0;  
                                 mb->mvs[0].y = 0;  
   
                                 mb->cbp = 0;  
 #ifdef BFRAMES_DEC_DEBUG  
         BFRAME_DEBUG  
 #endif  
                                 continue;  
                         }  
   
                         MBMotionCompensationBVOP(&pEnc->mbParam, mb, x, y, &frame->image,  
                                                                          f_ref, &pEnc->f_refh, &pEnc->f_refv,  
                                                                          &pEnc->f_refhv, b_ref, &pEnc->vInterH,  
                                                                          &pEnc->vInterV, &pEnc->vInterHV,  
                                                                          dct_codes);  
   
                         mb->quant = frame->quant;  
                         mb->cbp =  
                                 MBTransQuantInter(&pEnc->mbParam, frame, mb, x, y, dct_codes,  
                                                                   qcoeff);  
                         //mb->cbp = MBTransQuantBVOP(&pEnc->mbParam, x, y, dct_codes, qcoeff, &frame->image, frame->quant);  
   
                         if ( (mb->mode == MODE_DIRECT) && (mb->cbp == 0)  
                                 && (mb->deltamv.x == 0) && (mb->deltamv.y == 0) ) {  
                                 mb->mode = MODE_DIRECT_NONE_MV; // skipped  
                         }  
   
 /* update predictors for forward and backward vectors */  
                         if (mb->mode == MODE_INTERPOLATE || mb->mode == MODE_FORWARD) {  
                                 mb->pmvs[0].x = mb->mvs[0].x - forward.x;  
                                 mb->pmvs[0].y = mb->mvs[0].y - forward.y;  
                                 forward.x = mb->mvs[0].x;  
                                 forward.y = mb->mvs[0].y;  
                         }  
   
                         if (mb->mode == MODE_INTERPOLATE || mb->mode == MODE_BACKWARD) {  
                                 mb->b_pmvs[0].x = mb->b_mvs[0].x - backward.x;  
                                 mb->b_pmvs[0].y = mb->b_mvs[0].y - backward.y;  
                                 backward.x = mb->b_mvs[0].x;  
                                 backward.y = mb->b_mvs[0].y;  
                         }  
   
 //                      DPRINTF("%05i : [%i %i] M=%i CBP=%i MVS=%i,%i forward=%i,%i", pEnc->m_framenum, x, y, mb->mode, mb->cbp, mb->mvs[0].x, mb->mvs[0].y, forward.x, forward.y);  
   
 #ifdef BFRAMES_DEC_DEBUG  
         BFRAME_DEBUG  
 #endif  
                         start_timer();  
                         MBCodingBVOP(mb, qcoeff, frame->fcode, frame->bcode, bs,  
                                                  &pEnc->sStat);  
                         stop_coding_timer();  
                 }  
         }  
   
         emms();  
   
         // TODO: dynamic fcode/bcode ???  
   
         *pBits = BitstreamPos(bs) - *pBits;  
   
 #ifdef BFRAMES_DEC_DEBUG  
         if (!first){  
                 first=1;  
                 if (fp)  
                         fclose(fp);  
         }  
 #endif  
 }  
 #endif  
1055    
   
 /*      in case internal output is needed somewhere... */  
 /*      {  
         FILE *filehandle;  
         filehandle=fopen("last-b.pgm","wb");  
         if (filehandle)  
         {  
                 fprintf(filehandle,"P5\n\n");           //  
                 fprintf(filehandle,"%d %d 255\n",pEnc->mbParam.edged_width,pEnc->mbParam.edged_height);  
                 fwrite(frame->image.y,pEnc->mbParam.edged_width,pEnc->mbParam.edged_height,filehandle);  
                 fclose(filehandle);  
1056                  }                  }
         }  
 */  

Legend:
Removed from v.1.65  
changed lines
  Added in v.1.85

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