[svn] / trunk / xvidcore / src / bitstream / mbcoding.c Repository:
ViewVC logotype

Diff of /trunk/xvidcore/src/bitstream/mbcoding.c

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

revision 248, Fri Jun 28 15:14:40 2002 UTC revision 655, Sun Nov 17 00:57:58 2002 UTC
# Line 1  Line 1 
1   /******************************************************************************  /*****************************************************************************
2    *                                                                            *   *
3    *  This file is part of XviD, a free MPEG-4 video encoder/decoder            *   *  XVID MPEG-4 VIDEO CODEC
4    *                                                                            *   *  - Macro Block coding functions -
5    *  XviD is an implementation of a part of one or more MPEG-4 Video tools     *   *
6    *  as specified in ISO/IEC 14496-2 standard.  Those intending to use this    *   *  Copyright(C) 2002 Michael Militzer <isibaar@xvid.org>
7    *  software module in hardware or software products are advised that its     *   *
8    *  use may infringe existing patents or copyrights, and any such use         *   *  This file is part of XviD, a free MPEG-4 video encoder/decoder
9    *  would be at such party's own risk.  The original developer of this        *   *
10    *  software module and his/her company, and subsequent editors and their     *   *  XviD is free software; you can redistribute it and/or modify it
11    *  companies, will have no liability for use of this software or             *   *  under the terms of the GNU General Public License as published by
12    *  modifications or derivatives thereof.                                     *   *  the Free Software Foundation; either version 2 of the License, or
13    *                                                                            *   *  (at your option) any later version.
14    *  XviD is free software; you can redistribute it and/or modify it           *   *
15    *  under the terms of the GNU General Public License as published by         *   *  This program is distributed in the hope that it will be useful,
16    *  the Free Software Foundation; either version 2 of the License, or         *   *  but WITHOUT ANY WARRANTY; without even the implied warranty of
17    *  (at your option) any later version.                                       *   *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18    *                                                                            *   *  GNU General Public License for more details.
19    *  XviD is distributed in the hope that it will be useful, but               *   *
20    *  WITHOUT ANY WARRANTY; without even the implied warranty of                *   *  You should have received a copy of the GNU General Public License
21    *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             *   *  along with this program; if not, write to the Free Software
22    *  GNU General Public License for more details.                              *   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
23    *                                                                            *   *
24    *  You should have received a copy of the GNU General Public License         *   *  Under section 8 of the GNU General Public License, the copyright
25    *  along with this program; if not, write to the Free Software               *   *  holders of XVID explicitly forbid distribution in the following
26    *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA  *   *  countries:
27    *                                                                            *   *
28    ******************************************************************************/   *    - Japan
29     *    - United States of America
30   /******************************************************************************   *
31    *                                                                            *   *  Linking XviD statically or dynamically with other modules is making a
32    *  mbcoding.c                                                                *   *  combined work based on XviD.  Thus, the terms and conditions of the
33    *                                                                            *   *  GNU General Public License cover the whole combination.
34    *  Copyright (C) 2002 - Michael Militzer <isibaar@xvid.org>                  *   *
35    *                                                                            *   *  As a special exception, the copyright holders of XviD give you
36    *  For more information visit the XviD homepage: http://www.xvid.org         *   *  permission to link XviD with independent modules that communicate with
37    *                                                                            *   *  XviD solely through the VFW1.1 and DShow interfaces, regardless of the
38    ******************************************************************************/   *  license terms of these independent modules, and to copy and distribute
39     *  the resulting combined work under terms of your choice, provided that
40   /******************************************************************************   *  every copy of the combined work is accompanied by a complete copy of
41    *                                                                                                                                                        *   *  the source code of XviD (the version of XviD used to produce the
42    *  Revision history:                                                         *   *  combined work), being distributed under the terms of the GNU General
43    *                                                                            *   *  Public License plus this exception.  An independent module is a module
44    *  28.06.2002 added check_resync_marker()                                    *   *  which is not derived from or based on XviD.
45    *  14.04.2002 bframe encoding                                                                                            *   *
46    *  08.03.2002 initial version; isibaar                                                           *   *  Note that people who make modified versions of XviD are not obligated
47    *                                                                                                                                                        *   *  to grant this special exception for their modified versions; it is
48    ******************************************************************************/   *  their choice whether to do so.  The GNU General Public License gives
49     *  permission to release a modified version without this exception; this
50     *  exception also makes it possible to release a modified version which
51     *  carries forward this exception.
52     *
53     * $Id: mbcoding.c,v 1.33 2002-11-17 00:57:57 edgomez Exp $
54     *
55     ****************************************************************************/
56    
57  #include <stdlib.h>  #include <stdlib.h>
58  #include "../portab.h"  #include "../portab.h"
# Line 61  Line 66 
66  #define ABS(X) (((X)>0)?(X):-(X))  #define ABS(X) (((X)>0)?(X):-(X))
67  #define CLIP(X,A) (X > A) ? (A) : (X)  #define CLIP(X,A) (X > A) ? (A) : (X)
68    
69    /*****************************************************************************
70     * Local data
71     ****************************************************************************/
72    
73    /* msvc sp5+pp gets confused if they globals are made static */
74  VLC intra_table[524032];  VLC intra_table[524032];
75  VLC inter_table[524032];  VLC inter_table[524032];
76    
77  VLC DCT3Dintra[4096];  static VLC DCT3Dintra[4096];
78  VLC DCT3Dinter[4096];  static VLC DCT3Dinter[4096];
79    
80    /*****************************************************************************
81     * Vector Length Coding Initialization
82     ****************************************************************************/
83    
84  void  void
85  init_vlc_tables(void)  init_vlc_tables(void)
# Line 73  Line 87 
87    
88          int32_t k, l, i, intra, last;          int32_t k, l, i, intra, last;
89          VLC *vlc[2];          VLC *vlc[2];
90          VLC **coeff_ptr;          VLC const **coeff_ptr;
91          VLC *vlc1, *vlc2;          VLC *vlc1, *vlc2;
92    
93          vlc1 = DCT3Dintra;          vlc1 = DCT3Dintra;
# Line 82  Line 96 
96          vlc[0] = intra_table;          vlc[0] = intra_table;
97          vlc[1] = inter_table;          vlc[1] = inter_table;
98    
99          // generate encoding vlc lookup tables          /*
100          // the lookup table idea is taken from the excellent fame project by Vivien Chapellier           * Generate encoding vlc lookup tables
101             * the lookup table idea is taken from the excellent fame project
102             * by Vivien Chapellier
103             */
104          for (i = 0; i < 4; i++) {          for (i = 0; i < 4; i++) {
105                  intra = i % 2;                  intra = i % 2;
106                  last = i / 2;                  last = i / 2;
# Line 91  Line 108 
108                  coeff_ptr = coeff_vlc[last + 2 * intra];                  coeff_ptr = coeff_vlc[last + 2 * intra];
109    
110                  for (k = -2047; k < 2048; k++) {        // level                  for (k = -2047; k < 2048; k++) {        // level
111                          int8_t *max_level_ptr = max_level[last + 2 * intra];                          int8_t const *max_level_ptr = max_level[last + 2 * intra];
112                          int8_t *max_run_ptr = max_run[last + 2 * intra];                          int8_t const *max_run_ptr = max_run[last + 2 * intra];
113    
114                          for (l = 0; l < 64; l++) {      // run                          for (l = 0; l < 64; l++) {      // run
115                                  int32_t level = k;                                  int32_t level = k;
# Line 185  Line 202 
202    
203  }  }
204    
205    /*****************************************************************************
206     * Local inlined functions for MB coding
207     ****************************************************************************/
208    
209  static __inline void  static __inline void
210  CodeVector(Bitstream * bs,  CodeVector(Bitstream * bs,
211                     int32_t value,                     int32_t value,
# Line 240  Line 261 
261    
262  }  }
263    
   
264  static __inline void  static __inline void
265  CodeCoeff(Bitstream * bs,  CodeCoeff(Bitstream * bs,
266                    const int16_t qcoeff[64],                    const int16_t qcoeff[64],
# Line 279  Line 299 
299    
300  }  }
301    
302    /*****************************************************************************
303     * Local functions
304     ****************************************************************************/
305    
306  static void  static void
307  CodeBlockIntra(const FRAMEINFO * frame,  CodeBlockIntra(const FRAMEINFO * frame,
# Line 370  Line 393 
393    
394          // interlacing          // interlacing
395          if (frame->global_flags & XVID_INTERLACING) {          if (frame->global_flags & XVID_INTERLACING) {
396                    if (pMB->cbp) {
397                  BitstreamPutBit(bs, pMB->field_dct);                  BitstreamPutBit(bs, pMB->field_dct);
398                  DEBUG1("codep: field_dct: ", pMB->field_dct);                          DPRINTF(DPRINTF_DEBUG, "codep: field_dct: %d", pMB->field_dct);
399                    }
400    
401                  // if inter block, write field ME flag                  // if inter block, write field ME flag
402                  if (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) {                  if (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) {
403                          BitstreamPutBit(bs, pMB->field_pred);                          BitstreamPutBit(bs, pMB->field_pred);
404                          DEBUG1("codep: field_pred: ", pMB->field_pred);                          DPRINTF(DPRINTF_DEBUG, "codep: field_pred: %d", pMB->field_pred);
405    
406                          // write field prediction references                          // write field prediction references
407                          if (pMB->field_pred) {                          if (pMB->field_pred) {
# Line 403  Line 428 
428    
429  }  }
430    
431    /*****************************************************************************
432     * Macro Block bitstream encoding functions
433     ****************************************************************************/
434    
435  void  void
436  MBCoding(const FRAMEINFO * frame,  MBCoding(const FRAMEINFO * frame,
# Line 412  Line 440 
440                   Statistics * pStat)                   Statistics * pStat)
441  {  {
442    
         int intra = (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q);  
   
443          if (frame->coding_type == P_VOP) {          if (frame->coding_type == P_VOP) {
                 if (pMB->cbp == 0 && pMB->mode == MODE_INTER && pMB->mvs[0].x == 0 &&  
                         pMB->mvs[0].y == 0) {  
                         BitstreamPutBit(bs, 1); // not_coded  
                         return;  
                 } else  
444                          BitstreamPutBit(bs, 0); // coded                          BitstreamPutBit(bs, 0); // coded
445          }          }
446    
447          if (intra)          if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q)
448                  CodeBlockIntra(frame, pMB, qcoeff, bs, pStat);                  CodeBlockIntra(frame, pMB, qcoeff, bs, pStat);
449          else          else
450                  CodeBlockInter(frame, pMB, qcoeff, bs, pStat);                  CodeBlockInter(frame, pMB, qcoeff, bs, pStat);
451    
452  }  }
453    
 /***************************************************************  
  * bframe encoding start  
  ***************************************************************/  
   
 /*  
         mbtype  
         0       1b              direct(h263)            mvdb  
         1       01b             interpolate mc+q        dbquant, mvdf, mvdb  
         2       001b    backward mc+q           dbquant, mvdb  
         3       0001b   forward mc+q            dbquant, mvdf  
 */  
454    
455  void  void
456  put_bvop_mbtype(Bitstream * bs,  MBSkip(Bitstream * bs)
                                 int value)  
457  {  {
458          switch (value) {          BitstreamPutBit(bs, 1); // not coded
         case 0:  
                 BitstreamPutBit(bs, 1);  
459                  return;                  return;
   
         case 1:  
                 BitstreamPutBit(bs, 0);  
                 BitstreamPutBit(bs, 1);  
                 return;  
   
         case 2:  
                 BitstreamPutBit(bs, 0);  
                 BitstreamPutBit(bs, 0);  
                 BitstreamPutBit(bs, 1);  
                 return;  
   
         case 3:  
                 BitstreamPutBit(bs, 0);  
                 BitstreamPutBit(bs, 0);  
                 BitstreamPutBit(bs, 0);  
                 BitstreamPutBit(bs, 1);  
                 return;  
   
         default:;                                       // invalid!  
   
460          }          }
461    
462  }  /*****************************************************************************
463     * decoding stuff starts here
464     ****************************************************************************/
465    
466  /*  /*
467          dbquant   * For IVOP addbits == 0
468          -2      10b   * For PVOP addbits == fcode - 1
469          0       0b   * For BVOP addbits == max(fcode,bcode) - 1
470          +2      11b   * returns true or false
471  */  */
472    
 void  
 put_bvop_dbquant(Bitstream * bs,  
                                  int value)  
 {  
         switch (value) {  
         case 0:  
                 BitstreamPutBit(bs, 0);  
                 return;  
   
         case -2:  
                 BitstreamPutBit(bs, 1);  
                 BitstreamPutBit(bs, 0);  
                 return;  
   
         case 2:  
                 BitstreamPutBit(bs, 1);  
                 BitstreamPutBit(bs, 1);  
                 return;  
   
         default:;                                       // invalid  
         }  
 }  
   
   
   
 void  
 MBCodingBVOP(const MACROBLOCK * mb,  
                          const int16_t qcoeff[6 * 64],  
                          const int32_t fcode,  
                          const int32_t bcode,  
                          Bitstream * bs,  
                          Statistics * pStat)  
 {  
         int i;  
   
 /*      ------------------------------------------------------------------  
                 when a block is skipped it is decoded DIRECT(0,)  
                 hence are interpolated from forward & backward frames  
         ------------------------------------------------------------------ */  
   
         if (mb->mode == 5) {  
                 BitstreamPutBit(bs, 1); // skipped  
                 return;  
         }  
   
         BitstreamPutBit(bs, 0);         // not skipped  
   
         if (mb->cbp == 0) {  
                 BitstreamPutBit(bs, 1); // cbp == 0  
         } else {  
                 BitstreamPutBit(bs, 0); // cbp == xxx  
         }  
   
         put_bvop_mbtype(bs, mb->mode);  
   
         if (mb->cbp) {  
                 BitstreamPutBits(bs, mb->cbp, 6);  
         }  
   
         if (mb->mode != MODE_DIRECT && mb->cbp != 0) {  
                 put_bvop_dbquant(bs, 0);        // todo: mb->dquant = 0  
         }  
   
         if (mb->mode == MODE_INTERPOLATE || mb->mode == MODE_FORWARD) {  
                 CodeVector(bs, mb->pmvs[0].x, fcode, pStat);  
                 CodeVector(bs, mb->pmvs[0].y, fcode, pStat);  
         }  
   
         if (mb->mode == MODE_INTERPOLATE || mb->mode == MODE_BACKWARD) {  
                 CodeVector(bs, mb->b_pmvs[0].x, bcode, pStat);  
                 CodeVector(bs, mb->b_pmvs[0].y, bcode, pStat);  
         }  
   
         if (mb->mode == MODE_DIRECT) {  
                 // TODO: direct  
         }  
   
         for (i = 0; i < 6; i++) {  
                 if (mb->cbp & (1 << (5 - i))) {  
                         CodeCoeff(bs, &qcoeff[i * 64], inter_table, scan_tables[0], 0);  
                 }  
         }  
 }  
   
   
   
 /***************************************************************  
  * decoding stuff starts here                                  *  
  ***************************************************************/  
   
   
 void  
 skip_stuffing(Bitstream *bs)  
 {  
         while (BitstreamShowBits(bs, 9) == 1)  
                 BitstreamSkip(bs, 9);  
 }  
   
   
   
 // for IVOP addbits == 0  
 // for PVOP addbits == fcode - 1  
 // for BVOP addbits == max(fcode,bcode) - 1  
 // returns true or false  
473  int  int
474  check_resync_marker(Bitstream * bs, int addbits)  check_resync_marker(Bitstream * bs, int addbits)
475  {  {
# Line 762  Line 646 
646    
647  }  }
648    
649    /*****************************************************************************
650     * Local inlined function to "decode" written vlc codes
651     ****************************************************************************/
652    
653    static __inline int
654    get_coeff(Bitstream * bs,
655                      int *run,
656                      int *last,
657                      int intra,
658                      int short_video_header)
659    {
660    
661            uint32_t mode;
662            const VLC *tab;
663            int32_t level;
664    
665            if (short_video_header)         // inter-VLCs will be used for both intra and inter blocks
666                    intra = 0;
667    
668            tab = &DCT3D[intra][BitstreamShowBits(bs, 12)];
669    
670            if (tab->code == -1)
671                    goto error;
672    
673            BitstreamSkip(bs, tab->len);
674    
675            if (tab->code != ESCAPE) {
676                    if (!intra) {
677                            *run = (tab->code >> 4) & 255;
678                            level = tab->code & 15;
679                            *last = (tab->code >> 12) & 1;
680                    } else {
681                            *run = (tab->code >> 8) & 255;
682                            level = tab->code & 255;
683                            *last = (tab->code >> 16) & 1;
684                    }
685                    return BitstreamGetBit(bs) ? -level : level;
686            }
687    
688            if (short_video_header) {
689                    // escape mode 4 - H.263 type, only used if short_video_header = 1
690                    *last = BitstreamGetBit(bs);
691                    *run = BitstreamGetBits(bs, 6);
692                    level = BitstreamGetBits(bs, 8);
693    
694                    if (level == 0 || level == 128)
695                            DPRINTF(DPRINTF_ERROR, "Illegal LEVEL for ESCAPE mode 4: %d", level);
696    
697                    return (level >= 128 ? -(256 - level) : level);
698            }
699    
700            mode = BitstreamShowBits(bs, 2);
701    
702            if (mode < 3) {
703                    BitstreamSkip(bs, (mode == 2) ? 2 : 1);
704    
705                    tab = &DCT3D[intra][BitstreamShowBits(bs, 12)];
706                    if (tab->code == -1)
707                            goto error;
708    
709                    BitstreamSkip(bs, tab->len);
710    
711                    if (!intra) {
712                            *run = (tab->code >> 4) & 255;
713                            level = tab->code & 15;
714                            *last = (tab->code >> 12) & 1;
715                    } else {
716                            *run = (tab->code >> 8) & 255;
717                            level = tab->code & 255;
718                            *last = (tab->code >> 16) & 1;
719                    }
720    
721                    if (mode < 2)                   // first escape mode, level is offset
722                            level += max_level[*last + (!intra << 1)][*run];        // need to add back the max level
723                    else if (mode == 2)             // second escape mode, run is offset
724                            *run += max_run[*last + (!intra << 1)][level] + 1;
725    
726                    return BitstreamGetBit(bs) ? -level : level;
727            }
728            // third escape mode - fixed length codes
729            BitstreamSkip(bs, 2);
730            *last = BitstreamGetBits(bs, 1);
731            *run = BitstreamGetBits(bs, 6);
732            BitstreamSkip(bs, 1);           // marker
733            level = BitstreamGetBits(bs, 12);
734            BitstreamSkip(bs, 1);           // marker
735    
736            return (level & 0x800) ? (level | (-1 ^ 0xfff)) : level;
737    
738      error:
739            *run = VLC_ERROR;
740            return 0;
741    
742    }
743    
744    /*****************************************************************************
745     * MB reading functions
746     ****************************************************************************/
747    
748  void  void
749  get_intra_block(Bitstream * bs,  get_intra_block(Bitstream * bs,
750                                  int16_t * block,                                  int16_t * block,
# Line 777  Line 760 
760          do {          do {
761                  level = get_coeff(bs, &run, &last, 1, 0);                  level = get_coeff(bs, &run, &last, 1, 0);
762                  if (run == -1) {                  if (run == -1) {
763                          DEBUG("fatal: invalid run");                          DPRINTF(DPRINTF_DEBUG, "fatal: invalid run");
764                          break;                          break;
765                  }                  }
766                  coeff += run;                  coeff += run;
767                  block[scan[coeff]] = level;                  block[scan[coeff]] = level;
768    
769                    DPRINTF(DPRINTF_COEFF,"block[%i] %i", scan[coeff], level);
770                    //DPRINTF(DPRINTF_COEFF,"block[%i] %i %08x", scan[coeff], level, BitstreamShowBits(bs, 32));
771    
772                  if (level < -127 || level > 127) {                  if (level < -127 || level > 127) {
773                          DEBUG1("warning: intra_overflow", level);                          DPRINTF(DPRINTF_DEBUG, "warning: intra_overflow: %d", level);
774                  }                  }
775                  coeff++;                  coeff++;
776          } while (!last);          } while (!last);
# Line 805  Line 792 
792          do {          do {
793                  level = get_coeff(bs, &run, &last, 0, 0);                  level = get_coeff(bs, &run, &last, 0, 0);
794                  if (run == -1) {                  if (run == -1) {
795                          DEBUG("fatal: invalid run");                          DPRINTF(DPRINTF_ERROR, "fatal: invalid run");
796                          break;                          break;
797                  }                  }
798                  p += run;                  p += run;
799    
800                  block[scan[p]] = level;                  block[scan[p]] = level;
801    
802                    DPRINTF(DPRINTF_COEFF,"block[%i] %i", scan[p], level);
803    
804                  if (level < -127 || level > 127) {                  if (level < -127 || level > 127) {
805                          DEBUG1("warning: inter_overflow", level);                          DPRINTF(DPRINTF_DEBUG, "warning: inter_overflow: %d", level);
806                  }                  }
807                  p++;                  p++;
808          } while (!last);          } while (!last);
Legend:
Removed from v.248  
changed lines
  Added in v.655
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4