[svn] / branches / dev-api-4 / xvidcore / src / bitstream / mbcoding.c Repository:
ViewVC logotype

Diff of /branches/dev-api-4/xvidcore/src/bitstream/mbcoding.c

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

revision 451, Sun Sep 8 14:43:04 2002 UTC revision 655, Sun Nov 17 00:57:58 2002 UTC
# Line 1  Line 1 
1  /*****************************************************************************  /*****************************************************************************
2   *   *
3   *  XVID MPEG-4 VIDEO CODEC   *  XVID MPEG-4 VIDEO CODEC
4   *  - Vector Length Coding tables -   *  - Macro Block coding functions -
5   *   *
6   *  Copyright(C) 2002 Michael Militzer <isibaar@xvid.org>   *  Copyright(C) 2002 Michael Militzer <isibaar@xvid.org>
7   *   *
8     *  This file is part of XviD, a free MPEG-4 video encoder/decoder
9   *   *
10   *  This program is an implementation of a part of one or more MPEG-4   *  XviD is free software; you can redistribute it and/or modify it
11   *  Video tools as specified in ISO/IEC 14496-2 standard.  Those intending   *  under the terms of the GNU General Public License as published by
  *  to use this software module in hardware or software products are  
  *  advised that its use may infringe existing patents or copyrights, and  
  *  any such use would be at such party's own risk.  The original  
  *  developer of this software module and his/her company, and subsequent  
  *  editors and their companies, will have no liability for use of this  
  *  software or modifications or derivatives thereof.  
  *  
  *  This program is free software; you can redistribute it and/or modify  
  *  it under the terms of the GNU General Public License as published by  
12   *  the Free Software Foundation; either version 2 of the License, or   *  the Free Software Foundation; either version 2 of the License, or
13   *  (at your option) any later version.   *  (at your option) any later version.
14   *   *
# Line 29  Line 21 
21   *  along with this program; if not, write to the Free Software   *  along with this program; if not, write to the Free Software
22   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
23   *   *
24   * $Id: mbcoding.c,v 1.26 2002-09-08 14:43:04 edgomez Exp $   *  Under section 8 of the GNU General Public License, the copyright
25     *  holders of XVID explicitly forbid distribution in the following
26     *  countries:
27     *
28     *    - Japan
29     *    - United States of America
30     *
31     *  Linking XviD statically or dynamically with other modules is making a
32     *  combined work based on XviD.  Thus, the terms and conditions of the
33     *  GNU General Public License cover the whole combination.
34     *
35     *  As a special exception, the copyright holders of XviD give you
36     *  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     *  combined work), being distributed under the terms of the GNU General
43     *  Public License plus this exception.  An independent module is a module
44     *  which is not derived from or based on XviD.
45     *
46     *  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    
# Line 49  Line 70 
70   * Local data   * Local data
71   ****************************************************************************/   ****************************************************************************/
72    
73  static VLC intra_table[524032];  /* msvc sp5+pp gets confused if they globals are made static */
74  static VLC inter_table[524032];  VLC intra_table[524032];
75    VLC inter_table[524032];
76    
77  static VLC DCT3Dintra[4096];  static VLC DCT3Dintra[4096];
78  static VLC DCT3Dinter[4096];  static VLC DCT3Dinter[4096];
79    
80  /*****************************************************************************  /*****************************************************************************
81   * Functions   * Vector Length Coding Initialization
82   ****************************************************************************/   ****************************************************************************/
83    
84  void  void
# Line 65  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 86  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 180  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 235  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 274  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 367  Line 395 
395          if (frame->global_flags & XVID_INTERLACING) {          if (frame->global_flags & XVID_INTERLACING) {
396                  if (pMB->cbp) {                  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 400  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 428  Line 459 
459          return;          return;
460  }  }
461    
462    /*****************************************************************************
463  /***************************************************************   * decoding stuff starts here
464   * 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  
 */  
   
 void  
 put_bvop_mbtype(Bitstream * bs,  
                                 int value)  
 {  
         switch (value) {  
         case 0:  
                 BitstreamPutBit(bs, 1);  
                 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!  
   
         }  
   
 }  
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,0)  
                 hence is interpolated from forward & backward frames  
         ------------------------------------------------------------------ */  
   
         if (mb->mode == MODE_DIRECT_NONE_MV) {  
                 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) {  
                 CodeVector(bs, mb->deltamv.x, 1, pStat);                /* fcode is always 1 for delta vector */  
                 CodeVector(bs, mb->deltamv.y, 1, pStat);                /* prediction is always (0,0) */  
         }  
   
         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                                  *  
  ***************************************************************/  
   
   
 // 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 753  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 768  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;
# Line 778  Line 770 
770                  //DPRINTF(DPRINTF_COEFF,"block[%i] %i %08x", scan[coeff], level, BitstreamShowBits(bs, 32));                  //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 800  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;
# Line 808  Line 800 
800                  block[scan[p]] = level;                  block[scan[p]] = level;
801    
802                  DPRINTF(DPRINTF_COEFF,"block[%i] %i", scan[p], level);                  DPRINTF(DPRINTF_COEFF,"block[%i] %i", scan[p], level);
                 // DPRINTF(DPRINTF_COEFF,"block[%i] %i %08x", scan[p], level, BitstreamShowBits(bs, 32));  
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.451  
changed lines
  Added in v.655
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4