Home | History | Annotate | Download | only in src
      1 /* ------------------------------------------------------------------
      2  * Copyright (C) 1998-2009 PacketVideo
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
     13  * express or implied.
     14  * See the License for the specific language governing permissions
     15  * and limitations under the License.
     16  * -------------------------------------------------------------------
     17  */
     18 /*
     19 *     -------------------------------------------------------------------       *
     20 *                    MPEG-4 Simple Profile Video Decoder                        *
     21 *     -------------------------------------------------------------------       *
     22 *
     23 * This software module was originally developed by
     24 *
     25 *   Paulo Nunes (IST / ACTS-MoMuSyS)
     26 *   Robert Danielsen (Telenor / ACTS-MoMuSyS)
     27 *
     28 * in the course of development of the MPEG-4 Video (ISO/IEC 14496-2) standard.
     29 * This software module is an implementation of a part of one or more MPEG-4
     30 * Video (ISO/IEC 14496-2) tools as specified by the MPEG-4 Video (ISO/IEC
     31 * 14496-2) standard.
     32 *
     33 * ISO/IEC gives users of the MPEG-4 Video (ISO/IEC 14496-2) standard free
     34 * license to this software module or modifications thereof for use in hardware
     35 * or software products claiming conformance to the MPEG-4 Video (ISO/IEC
     36 * 14496-2) standard.
     37 *
     38 * Those intending to use this software module in hardware or software products
     39 * are advised that its use may infringe existing patents. The original
     40 * developer of this software module and his/her company, the subsequent
     41 * editors and their companies, and ISO/IEC have no liability for use of this
     42 * software module or modifications thereof in an implementation. Copyright is
     43 * not released for non MPEG-4 Video (ISO/IEC 14496-2) Standard conforming
     44 * products.
     45 *
     46 * ACTS-MoMuSys partners retain full right to use the code for his/her own
     47 * purpose, assign or donate the code to a third party and to inhibit third
     48 * parties from using the code for non MPEG-4 Video (ISO/IEC 14496-2) Standard
     49 * conforming products. This copyright notice must be included in all copies or
     50 * derivative works.
     51 *
     52 * Copyright (c) 1996
     53 *
     54 *****************************************************************************/
     55 
     56 /***********************************************************HeaderBegin*******
     57 *
     58 * File: vlc_dec.c
     59 *
     60 * Author:   Paulo Nunes (IST) - Paulo.Nunes (at) lx.it.pt
     61 * Created:  1-Mar-96
     62 *
     63 * Description: This file contains the VLC functions needed to decode a
     64 *       bitstream.
     65 *
     66 * Notes:
     67 *       The functions contained in this file were adapted from
     68 *       tmndecode
     69 *       Written by Karl Olav Lillevold <kol (at) nta.no>,
     70 *       1995 Telenor R&D.
     71 *       Donated to the Momusys-project as background code by
     72 *       Telenor.
     73 *
     74 *       based on mpeg2decode, (C) 1994, MPEG Software Simulation Group
     75 *       and mpeg2play, (C) 1994 Stefan Eckart
     76 *                   <stefan (at) lis.e-technik.tu-muenchen.de>
     77 *
     78 *
     79 * Modified: 9-May-96 Paulo Nunes: Reformatted. New headers.
     80 *              17-Jan-97 Jan De Lameillieure (HHI) : corrected in
     81 *              01.05.97 Luis Ducla-Soares: added RvlcDecTCOEF() to allow decoding
     82 *                                          of Reversible VLCs.
     83 *       09.03.98 Paulo Nunes: Cleaning.
     84 *
     85 ***********************************************************HeaderEnd*********/
     86 
     87 #include "mp4dec_lib.h"
     88 #include "vlc_dec_tab.h"
     89 #include "vlc_decode.h"
     90 #include "bitstream.h"
     91 #include "max_level.h"
     92 
     93 
     94 /* ====================================================================== /
     95     Function : DecodeUserData()
     96     Date     : 04/10/2000
     97     History  :
     98     Modified : 04/16/2001 : removed status checking of PV_BitstreamFlushBits
     99 
    100         This is simply a realization of the user_data() function
    101         in the ISO/IEC 14496-2 manual.
    102 / ====================================================================== */
    103 PV_STATUS DecodeUserData(BitstreamDecVideo *stream)
    104 {
    105     PV_STATUS status;
    106     uint32 code;
    107 
    108     BitstreamReadBits32HC(stream);
    109     BitstreamShowBits32(stream, 24, &code);
    110 
    111     while (code != 1)
    112     {
    113         /* Discard user data for now.   04/05/2000 */
    114         BitstreamReadBits16(stream, 8);
    115         BitstreamShowBits32(stream, 24, &code);
    116         status = BitstreamCheckEndBuffer(stream);
    117         if (status == PV_END_OF_VOP) return status;    /*  03/19/2002 */
    118     }
    119     return PV_SUCCESS;
    120 }
    121 
    122 
    123 
    124 /***********************************************************CommentBegin******
    125 *
    126 *       3/10/00  : initial modification to the
    127 *                new PV-Decoder Lib format.
    128 *       3/29/00  : added return code check to some functions and
    129 *                optimize the code.
    130 *
    131 ***********************************************************CommentEnd********/
    132 PV_STATUS PV_GetMBvectors(VideoDecData *video, uint mode)
    133 {
    134     PV_STATUS status;
    135     BitstreamDecVideo *stream = video->bitstream;
    136     int  f_code_f = video->currVop->fcodeForward;
    137     int  vlc_code_mag;
    138 
    139 
    140     MOT *mot_x = video->motX;
    141     MOT *mot_y = video->motY;
    142 
    143     int k, offset;
    144     int x_pos = video->mbnum_col;
    145     int y_pos = video->mbnum_row;
    146     int doubleWidth = video->nMBPerRow << 1;
    147     int pos = (x_pos + y_pos * doubleWidth) << 1;
    148     MOT mvx = 0, mvy = 0;
    149 
    150 
    151     if (f_code_f == 1)
    152     {
    153 #ifdef PV_ANNEX_IJKT_SUPPORT
    154         if (mode == MODE_INTER4V || mode == MODE_INTER4V_Q)
    155 #else
    156         if (mode == MODE_INTER4V)
    157 #endif
    158         {
    159             for (k = 0; k < 4; k++)
    160             {
    161                 offset = (k & 1) + (k >> 1) * doubleWidth;
    162                 mv_prediction(video, k, &mvx, &mvy);
    163                 /* decode component x */
    164                 status = PV_VlcDecMV(stream, &vlc_code_mag);
    165                 if (status != PV_SUCCESS)
    166                 {
    167                     return status;
    168                 }
    169 
    170                 mvx += (MOT)vlc_code_mag;
    171                 mvx = (MOT)(((mvx + 32) & 0x3F) - 32);
    172 
    173 
    174                 status = PV_VlcDecMV(stream, &vlc_code_mag);
    175                 if (status != PV_SUCCESS)
    176                 {
    177                     return status;
    178                 }
    179 
    180                 mvy += (MOT)vlc_code_mag;
    181                 mvy = (MOT)(((mvy + 32) & 0x3F) - 32);
    182 
    183                 mot_x[pos+offset] = (MOT) mvx;
    184                 mot_y[pos+offset] = (MOT) mvy;
    185             }
    186         }
    187         else
    188         {
    189             mv_prediction(video, 0, &mvx, &mvy);
    190             /* For PVOPs, field  appears only in MODE_INTER & MODE_INTER_Q */
    191             status = PV_VlcDecMV(stream, &vlc_code_mag);
    192             if (status != PV_SUCCESS)
    193             {
    194                 return status;
    195             }
    196 
    197             mvx += (MOT)vlc_code_mag;
    198             mvx = (MOT)(((mvx + 32) & 0x3F) - 32);
    199 
    200 
    201             status = PV_VlcDecMV(stream, &vlc_code_mag);
    202             if (status != PV_SUCCESS)
    203             {
    204                 return status;
    205             }
    206 
    207 
    208             mvy += (MOT)vlc_code_mag;
    209             mvy = (MOT)(((mvy + 32) & 0x3F) - 32);
    210 
    211 
    212             mot_x[pos] = mot_x[pos+1] = (MOT) mvx;
    213             mot_y[pos] = mot_y[pos+1] = (MOT) mvy;
    214             pos += doubleWidth;
    215             mot_x[pos] = mot_x[pos+1] = (MOT) mvx;
    216             mot_y[pos] = mot_y[pos+1] = (MOT) mvy;
    217         }
    218     }
    219     else
    220     {
    221 #ifdef PV_ANNEX_IJKT_SUPPORT
    222         if (mode == MODE_INTER4V || mode == MODE_INTER4V_Q)
    223 #else
    224         if (mode == MODE_INTER4V)
    225 #endif
    226         {
    227             for (k = 0; k < 4; k++)
    228             {
    229                 offset = (k & 1) + (k >> 1) * doubleWidth;
    230                 mv_prediction(video, k, &mvx, &mvy);
    231                 status = PV_DecodeMBVec(stream, &mvx, &mvy, f_code_f);
    232                 mot_x[pos+offset] = (MOT) mvx;
    233                 mot_y[pos+offset] = (MOT) mvy;
    234                 if (status != PV_SUCCESS)
    235                 {
    236                     return status;
    237                 }
    238             }
    239         }
    240         else
    241         {
    242             mv_prediction(video, 0, &mvx, &mvy);
    243             /* For PVOPs, field  appears only in MODE_INTER & MODE_INTER_Q */
    244             status = PV_DecodeMBVec(stream, &mvx, &mvy, f_code_f);
    245             mot_x[pos] = mot_x[pos+1] = (MOT) mvx;
    246             mot_y[pos] = mot_y[pos+1] = (MOT) mvy;
    247             pos += doubleWidth;
    248             mot_x[pos] = mot_x[pos+1] = (MOT) mvx;
    249             mot_y[pos] = mot_y[pos+1] = (MOT) mvy;
    250             if (status != PV_SUCCESS)
    251             {
    252                 return status;
    253             }
    254         }
    255     }
    256     return PV_SUCCESS;
    257 }
    258 
    259 
    260 /***********************************************************CommentBegin******
    261 *       3/10/00  : initial modification to the
    262 *                new PV-Decoder Lib format.
    263 *       3/29/00  : added return code check to some functions
    264 *       5/10/00  : check whether the decoded vector is legal.
    265 *       4/17/01  : use MOT type
    266 ***********************************************************CommentEnd********/
    267 PV_STATUS PV_DecodeMBVec(BitstreamDecVideo *stream, MOT *mv_x, MOT *mv_y, int f_code_f)
    268 {
    269     PV_STATUS status;
    270     int  vlc_code_magx, vlc_code_magy;
    271     int  residualx = 0, residualy = 0;
    272 
    273     /* decode component x */
    274     status = PV_VlcDecMV(stream, &vlc_code_magx);
    275     if (status != PV_SUCCESS)
    276     {
    277         return status;
    278     }
    279 
    280     if (vlc_code_magx)
    281     {
    282         residualx = (int) BitstreamReadBits16_INLINE(stream, (int)(f_code_f - 1));
    283     }
    284 
    285 
    286     /* decode component y */
    287     status = PV_VlcDecMV(stream, &vlc_code_magy);
    288     if (status != PV_SUCCESS)
    289     {
    290         return status;
    291     }
    292 
    293     if (vlc_code_magy)
    294     {
    295         residualy = (int) BitstreamReadBits16_INLINE(stream, (int)(f_code_f - 1));
    296     }
    297 
    298 
    299     if (PV_DeScaleMVD(f_code_f, residualx, vlc_code_magx, mv_x) != PV_SUCCESS)
    300     {
    301         return PV_FAIL;
    302     }
    303 
    304     if (PV_DeScaleMVD(f_code_f, residualy, vlc_code_magy, mv_y) != PV_SUCCESS)
    305     {
    306         return PV_FAIL;
    307     }
    308 
    309     return PV_SUCCESS;
    310 }
    311 
    312 
    313 /***********************************************************CommentBegin******
    314 *       3/31/2000 : initial modification to the new PV-Decoder Lib format.
    315 *       5/10/2000 : check to see if the decoded vector falls within
    316 *                           the legal fcode range.
    317 *
    318 ***********************************************************CommentEnd********/
    319 PV_STATUS PV_DeScaleMVD(
    320     int  f_code,       /* <-- MV range in 1/2 units: 1=32,2=64,...,7=2048     */
    321     int  residual,     /* <-- part of the MV Diff. FLC coded                  */
    322     int  vlc_code_mag, /* <-- part of the MV Diff. VLC coded                  */
    323     MOT  *vector       /* --> Obtained MV component in 1/2 units              */
    324 )
    325 {
    326     int   half_range = (1 << (f_code + 4));
    327     int   mask = (half_range << 1) - 1;
    328     int   diff_vector;
    329 
    330 
    331     if (vlc_code_mag == 0)
    332     {
    333         diff_vector = vlc_code_mag;
    334     }
    335     else
    336     {
    337         diff_vector = ((PV_ABS(vlc_code_mag) - 1) << (f_code - 1)) + residual + 1;
    338         if (vlc_code_mag < 0)
    339         {
    340             diff_vector = -diff_vector;
    341         }
    342     }
    343 
    344     *vector += (MOT)(diff_vector);
    345 
    346     *vector = (MOT)((*vector + half_range) & mask) - half_range;
    347 
    348     return PV_SUCCESS;
    349 }
    350 
    351 
    352 
    353 void mv_prediction(
    354     VideoDecData *video,
    355     int block,
    356     MOT *mvx,
    357     MOT *mvy
    358 )
    359 {
    360     /*----------------------------------------------------------------------------
    361     ; Define all local variables
    362     ----------------------------------------------------------------------------*/
    363     MOT *motxdata = video->motX;
    364     MOT *motydata = video->motY;
    365     int mbnum_col = video->mbnum_col;
    366     int mbnum_row = video->mbnum_row;
    367     uint8 *slice_nb = video->sliceNo;
    368     int nMBPerRow = video->nMBPerRow;
    369     int nMVPerRow = nMBPerRow << 1;
    370     int mbnum = video->mbnum;
    371     int p1x = 0, p2x = 0, p3x = 0;
    372     int p1y = 0, p2y = 0, p3y = 0;
    373     int rule1 = 0, rule2 = 0, rule3 = 0;
    374     int     indx;
    375 
    376     indx = ((mbnum_col << 1) + (block & 1)) + ((mbnum_row << 1)  + (block >> 1)) * nMVPerRow - 1; /* left block */
    377 
    378     if (block & 1)           /* block 1, 3 */
    379     {
    380         p1x = motxdata[indx];
    381         p1y = motydata[indx];
    382         rule1 = 1;
    383     }
    384     else                    /* block 0, 2 */
    385     {
    386         if (mbnum_col > 0 && slice_nb[mbnum] == slice_nb[mbnum-1])
    387         {
    388             p1x = motxdata[indx];
    389             p1y = motydata[indx];
    390             rule1 = 1;
    391         }
    392     }
    393 
    394     indx = indx + 1 - nMVPerRow; /* upper_block */
    395     if (block >> 1)
    396     {
    397         indx -= (block & 1);
    398         p2x = motxdata[indx];
    399         p2y = motydata[indx];
    400         p3x = motxdata[indx + 1];
    401         p3y = motydata[indx + 1];
    402         rule2 = rule3 = 1;
    403     }
    404     else
    405     {                           /* block 0,1 */
    406         if (mbnum_row)
    407         {
    408             if (slice_nb[mbnum] == slice_nb[mbnum-nMBPerRow])
    409             {
    410                 p2x = motxdata[indx];
    411                 p2y = motydata[indx];
    412                 rule2 = 1;
    413             }
    414             if (mbnum_col < nMBPerRow - 1 && slice_nb[mbnum] == slice_nb[mbnum-nMBPerRow+1])
    415             {
    416                 indx = indx + 2 - (block & 1);
    417                 p3x = motxdata[indx];
    418                 p3y = motydata[indx];
    419                 rule3 = 1;
    420             }
    421         }
    422     }
    423 
    424     if (rule1 + rule2 + rule3 > 1)
    425     {
    426         *mvx = (MOT)PV_MEDIAN(p1x, p2x, p3x);
    427         *mvy = (MOT)PV_MEDIAN(p1y, p2y, p3y);
    428     }
    429     else if (rule1 + rule2 + rule3 == 1)
    430     {
    431         /* two of three are zero */
    432         *mvx = (MOT)(p1x + p2x + p3x);
    433         *mvy = (MOT)(p1y + p2y + p3y);
    434     }
    435     else
    436     {
    437         /* all MBs are outside the VOP */
    438         *mvx = *mvy = 0;
    439     }
    440     /*----------------------------------------------------------------------------
    441     ; Return nothing or data or data pointer
    442     ----------------------------------------------------------------------------*/
    443     return;
    444 }
    445 
    446 /***********************************************************CommentBegin******
    447 *
    448 *       3/30/2000 : initial modification to the new PV-Decoder Lib format.
    449 *       4/16/2001 : removed checking of status for PV_BitstreamFlushBits
    450 ***********************************************************CommentEnd********/
    451 
    452 PV_STATUS PV_VlcDecMV(BitstreamDecVideo *stream, int *mv)
    453 {
    454     PV_STATUS status = PV_SUCCESS;
    455     uint code;
    456 
    457     BitstreamShow13Bits(stream, &code);
    458 
    459     if (code >> 12)
    460     {
    461         *mv = 0; /* Vector difference = 0 */
    462         PV_BitstreamFlushBits(stream, 1);
    463         return PV_SUCCESS;
    464     }
    465 
    466     if (code >= 512)
    467     {
    468         code = (code >> 8) - 2;
    469         PV_BitstreamFlushBits(stream, PV_TMNMVtab0[code].len + 1);
    470         *mv = PV_TMNMVtab0[code].val;
    471         return status;
    472     }
    473 
    474     if (code >= 128)
    475     {
    476         code = (code >> 2) - 32;
    477         PV_BitstreamFlushBits(stream, PV_TMNMVtab1[code].len + 1);
    478         *mv = PV_TMNMVtab1[code].val;
    479         return status;
    480     }
    481 
    482     if (code < 4)
    483     {
    484         *mv = -1;
    485         return PV_FAIL;
    486     }
    487 
    488     code -= 4;
    489 
    490     PV_BitstreamFlushBits(stream, PV_TMNMVtab2[code].len + 1);
    491 
    492     *mv = PV_TMNMVtab2[code].val;
    493     return status;
    494 }
    495 
    496 
    497 /***********************************************************CommentBegin******
    498 *       3/30/2000 : initial modification to the new PV-Decoder Lib
    499 *                           format and the change of error-handling method.
    500 *       4/16/01   : removed status checking of PV_BitstreamFlushBits
    501 ***********************************************************CommentEnd********/
    502 
    503 int PV_VlcDecMCBPC_com_intra(BitstreamDecVideo *stream)
    504 {
    505     uint code;
    506 
    507     BitstreamShowBits16(stream, 9, &code);
    508 
    509 
    510     if (code < 8)
    511     {
    512         return VLC_CODE_ERROR;
    513     }
    514 
    515     code >>= 3;
    516 
    517     if (code >= 32)
    518     {
    519         PV_BitstreamFlushBits(stream, 1);
    520         return 3;
    521     }
    522 
    523     PV_BitstreamFlushBits(stream, PV_MCBPCtabintra[code].len);
    524 
    525     return PV_MCBPCtabintra[code].val;
    526 }
    527 
    528 
    529 /***********************************************************CommentBegin******
    530 *
    531 *       3/30/2000 : initial modification to the new PV-Decoder Lib
    532 *                           format and the change of error-handling method.
    533 *       4/16/2001 : removed checking of return status of PV_BitstreamFlushBits
    534 ***********************************************************CommentEnd********/
    535 
    536 int PV_VlcDecMCBPC_com_inter(BitstreamDecVideo *stream)
    537 {
    538     uint code;
    539 
    540     BitstreamShowBits16(stream, 9, &code);
    541 
    542     if (code == 0)
    543     {
    544         return VLC_CODE_ERROR;
    545     }
    546     else if (code >= 256)
    547     {
    548         PV_BitstreamFlushBits(stream, 1);
    549         return 0;
    550     }
    551 
    552     PV_BitstreamFlushBits(stream, PV_MCBPCtab[code].len);
    553     return PV_MCBPCtab[code].val;
    554 }
    555 
    556 #ifdef PV_ANNEX_IJKT_SUPPORT
    557 int PV_VlcDecMCBPC_com_inter_H263(BitstreamDecVideo *stream)
    558 {
    559     uint code;
    560 
    561     BitstreamShow13Bits(stream, &code);
    562 
    563     if (code == 0)
    564     {
    565         return VLC_CODE_ERROR;
    566     }
    567     else if (code >= 4096)
    568     {
    569         PV_BitstreamFlushBits(stream, 1);
    570         return 0;
    571     }
    572     if (code >= 16)
    573     {
    574         PV_BitstreamFlushBits(stream, PV_MCBPCtab[code >> 4].len);
    575         return PV_MCBPCtab[code >> 4].val;
    576     }
    577     else
    578     {
    579         PV_BitstreamFlushBits(stream, PV_MCBPCtab1[code - 8].len);
    580         return PV_MCBPCtab1[code - 8].val;
    581     }
    582 }
    583 #endif
    584 /***********************************************************CommentBegin******
    585 *       3/30/2000 : initial modification to the new PV-Decoder Lib
    586 *                           format and the change of error-handling method.
    587 *       4/16/2001 : removed status checking for PV_BitstreamFlushBits
    588 ***********************************************************CommentEnd********/
    589 
    590 int PV_VlcDecCBPY(BitstreamDecVideo *stream, int intra)
    591 {
    592     int CBPY = 0;
    593     uint code;
    594 
    595     BitstreamShowBits16(stream, 6, &code);
    596 
    597 
    598     if (code < 2)
    599     {
    600         return -1;
    601     }
    602     else if (code >= 48)
    603     {
    604         PV_BitstreamFlushBits(stream, 2);
    605         CBPY = 15;
    606     }
    607     else
    608     {
    609         PV_BitstreamFlushBits(stream, PV_CBPYtab[code].len);
    610         CBPY = PV_CBPYtab[code].val;
    611     }
    612 
    613     if (intra == 0) CBPY = 15 - CBPY;
    614     CBPY = CBPY & 15;
    615     return CBPY;
    616 }
    617 
    618 
    619 /***********************************************************CommentBegin******
    620 *       3/31/2000 : initial modification to the new PV-Decoder Lib format.
    621 *
    622 *       8/23/2000 : optimize the function by removing unnecessary BitstreamShowBits()
    623 *                       function calls.
    624 *
    625 *       9/6/2000 : change the API to check for end-of-buffer for proper
    626 *                           termination of decoding process.
    627 ***********************************************************CommentEnd********/
    628 PV_STATUS PV_VlcDecIntraDCPredSize(BitstreamDecVideo *stream, int compnum, uint *DC_size)
    629 {
    630     PV_STATUS status = PV_FAIL;      /*  07/09/01 */
    631     uint  code;
    632 
    633     *DC_size = 0;
    634     if (compnum < 4)  /* luminance block */
    635     {
    636 
    637         BitstreamShowBits16(stream, 11, &code);
    638 
    639         if (code == 1)
    640         {
    641             *DC_size = 12;
    642             PV_BitstreamFlushBits(stream, 11);
    643             return PV_SUCCESS;
    644         }
    645         code >>= 1;
    646         if (code == 1)
    647         {
    648             *DC_size = 11;
    649             PV_BitstreamFlushBits(stream, 10);
    650             return PV_SUCCESS;
    651         }
    652         code >>= 1;
    653         if (code == 1)
    654         {
    655             *DC_size = 10;
    656             PV_BitstreamFlushBits(stream, 9);
    657             return PV_SUCCESS;
    658         }
    659 
    660         code >>= 1;
    661         if (code == 1)
    662         {
    663             *DC_size = 9;
    664             PV_BitstreamFlushBits(stream, 8);
    665             return PV_SUCCESS;
    666         }
    667 
    668         code >>= 1;
    669         if (code == 1)
    670         {
    671             *DC_size = 8;
    672             PV_BitstreamFlushBits(stream, 7);
    673             return PV_SUCCESS;
    674         }
    675 
    676         code >>= 1;
    677         if (code == 1)
    678         {
    679             *DC_size = 7;
    680             PV_BitstreamFlushBits(stream, 6);
    681             return PV_SUCCESS;
    682         }
    683 
    684         code >>= 1;
    685         if (code == 1)
    686         {
    687             *DC_size = 6;
    688             PV_BitstreamFlushBits(stream, 5);
    689             return PV_SUCCESS;
    690         }
    691 
    692         code >>= 1;
    693         if (code == 1)
    694         {
    695             *DC_size = 5;
    696             PV_BitstreamFlushBits(stream, 4);
    697             return PV_SUCCESS;
    698         }
    699 
    700         code >>= 1;
    701         if (code == 1)
    702         {
    703             *DC_size = 4;
    704             PV_BitstreamFlushBits(stream, 3);
    705             return PV_SUCCESS;
    706         }
    707         else if (code == 2)
    708         {
    709             *DC_size = 3;
    710             PV_BitstreamFlushBits(stream, 3);
    711             return PV_SUCCESS;
    712         }
    713         else if (code == 3)
    714         {
    715             *DC_size = 0;
    716             PV_BitstreamFlushBits(stream, 3);
    717             return PV_SUCCESS;
    718         }
    719 
    720         code >>= 1;
    721         if (code == 2)
    722         {
    723             *DC_size = 2;
    724             PV_BitstreamFlushBits(stream, 2);
    725             return PV_SUCCESS;
    726         }
    727         else if (code == 3)
    728         {
    729             *DC_size = 1;
    730             PV_BitstreamFlushBits(stream, 2);
    731             return PV_SUCCESS;
    732         }
    733     }
    734     else /* chrominance block */
    735     {
    736 
    737         BitstreamShow13Bits(stream, &code);
    738         code >>= 1;
    739         if (code == 1)
    740         {
    741             *DC_size = 12;
    742             PV_BitstreamFlushBits(stream, 12);
    743             return PV_SUCCESS;
    744         }
    745 
    746         code >>= 1;
    747         if (code == 1)
    748         {
    749             *DC_size = 11;
    750             PV_BitstreamFlushBits(stream, 11);
    751             return PV_SUCCESS;
    752         }
    753 
    754         code >>= 1;
    755         if (code == 1)
    756         {
    757             *DC_size = 10;
    758             PV_BitstreamFlushBits(stream, 10);
    759             return PV_SUCCESS;
    760         }
    761 
    762         code >>= 1;
    763         if (code == 1)
    764         {
    765             *DC_size = 9;
    766             PV_BitstreamFlushBits(stream, 9);
    767             return PV_SUCCESS;
    768         }
    769 
    770         code >>= 1;
    771         if (code == 1)
    772         {
    773             *DC_size = 8;
    774             PV_BitstreamFlushBits(stream, 8);
    775             return PV_SUCCESS;
    776         }
    777 
    778         code >>= 1;
    779         if (code == 1)
    780         {
    781             *DC_size = 7;
    782             PV_BitstreamFlushBits(stream, 7);
    783             return PV_SUCCESS;
    784         }
    785 
    786         code >>= 1;
    787         if (code == 1)
    788         {
    789             *DC_size = 6;
    790             PV_BitstreamFlushBits(stream, 6);
    791             return PV_SUCCESS;
    792         }
    793 
    794         code >>= 1;
    795         if (code == 1)
    796         {
    797             *DC_size = 5;
    798             PV_BitstreamFlushBits(stream, 5);
    799             return PV_SUCCESS;
    800         }
    801 
    802         code >>= 1;
    803         if (code == 1)
    804         {
    805             *DC_size = 4;
    806             PV_BitstreamFlushBits(stream, 4);
    807             return PV_SUCCESS;
    808         }
    809 
    810         code >>= 1;
    811         if (code == 1)
    812         {
    813             *DC_size = 3;
    814             PV_BitstreamFlushBits(stream, 3);
    815             return PV_SUCCESS;
    816         }
    817 
    818         code >>= 1;
    819         {
    820             *DC_size = (int)(3 - code);
    821             PV_BitstreamFlushBits(stream, 2);
    822             return PV_SUCCESS;
    823         }
    824     }
    825 
    826     return status;
    827 }
    828 
    829 /***********************************************************CommentBegin******
    830 *
    831 *
    832 *       3/30/2000 : initial modification to the new PV-Decoder Lib
    833 *                           format and the change of error-handling method.
    834 *
    835 ***********************************************************CommentEnd********/
    836 
    837 
    838 
    839 PV_STATUS VlcDecTCOEFIntra(BitstreamDecVideo *stream, Tcoef *pTcoef)
    840 {
    841     uint code;
    842     const VLCtab2 *tab;
    843 
    844     BitstreamShow13Bits(stream, &code);
    845 
    846     /* 10/17/2000, perform a little bit better on ARM by putting the whole function in VlcDecTCOEFFIntra */
    847     /*  if(GetTcoeffIntra(code,pTcoef,&tab,stream)!=PV_SUCCESS) return status;*/
    848     if (code >= 1024)
    849     {
    850         tab = &PV_DCT3Dtab3[(code >> 6) - 16];
    851     }
    852     else
    853     {
    854         if (code >= 256)
    855         {
    856             tab = &PV_DCT3Dtab4[(code >> 3) - 32];
    857         }
    858         else
    859         {
    860             if (code >= 16)
    861             {
    862                 tab = &PV_DCT3Dtab5[(code>>1) - 8];
    863             }
    864             else
    865             {
    866                 return PV_FAIL;
    867             }
    868         }
    869     }
    870 
    871     PV_BitstreamFlushBits(stream, tab->len + 1);
    872     pTcoef->sign = (code >> (12 - tab->len)) & 1;
    873     pTcoef->run = (uint) tab->run; //(tab->val >> 8) & 255;
    874     pTcoef->level = (int) tab->level; //tab->val & 255;
    875     pTcoef->last = (uint) tab->last; //(tab->val >> 16) & 1;
    876 
    877 
    878     /* the following is modified for 3-mode escape -- boon */
    879     if (tab->level != 0xFF)
    880     {
    881         return PV_SUCCESS;
    882     }
    883 
    884     //if (((tab->run<<8)|(tab->level)|(tab->last<<16)) == VLC_ESCAPE_CODE)
    885 
    886     if (!pTcoef->sign)
    887     {
    888         /* first escape mode. level is offset */
    889         BitstreamShow13Bits(stream, &code);
    890 
    891         /* 10/17/2000, perform a little bit better on ARM by putting the whole function in VlcDecTCOEFFIntra */
    892         /*          if(GetTcoeffIntra(code,pTcoef,&tab,stream)!=PV_SUCCESS) return status;*/
    893         if (code >= 1024)
    894         {
    895             tab = &PV_DCT3Dtab3[(code >> 6) - 16];
    896         }
    897         else
    898         {
    899             if (code >= 256)
    900             {
    901                 tab = &PV_DCT3Dtab4[(code >> 3) - 32];
    902             }
    903             else
    904             {
    905                 if (code >= 16)
    906                 {
    907                     tab = &PV_DCT3Dtab5[(code>>1) - 8];
    908                 }
    909                 else
    910                 {
    911                     return PV_FAIL;
    912                 }
    913             }
    914         }
    915 
    916         PV_BitstreamFlushBits(stream, tab->len + 1);
    917 
    918         /* sign bit */
    919         pTcoef->sign = (code >> (12 - tab->len)) & 1;
    920         pTcoef->run = (uint)tab->run; //(tab->val >> 8) & 255;
    921         pTcoef->level = (int)tab->level; //tab->val & 255;
    922         pTcoef->last = (uint)tab->last; //(tab->val >> 16) & 1;
    923 
    924 
    925         /* need to add back the max level */
    926         if ((pTcoef->last == 0 && pTcoef->run > 14) || (pTcoef->last == 1 && pTcoef->run > 20))
    927         {
    928             return PV_FAIL;
    929         }
    930         pTcoef->level = pTcoef->level + intra_max_level[pTcoef->last][pTcoef->run];
    931 
    932 
    933     }
    934     else
    935     {
    936         uint run_offset;
    937         run_offset = BitstreamRead1Bits_INLINE(stream);
    938 
    939         if (!run_offset)
    940         {
    941             /* second escape mode. run is offset */
    942             BitstreamShow13Bits(stream, &code);
    943 
    944             /* 10/17/2000, perform a little bit better on ARM by putting the whole function in VlcDecTCOEFFIntra */
    945             /*              if(GetTcoeffIntra(code,pTcoef,&tab,stream)!=PV_SUCCESS) return status;*/
    946             if (code >= 1024)
    947             {
    948                 tab = &PV_DCT3Dtab3[(code >> 6) - 16];
    949             }
    950             else
    951             {
    952                 if (code >= 256)
    953                 {
    954                     tab = &PV_DCT3Dtab4[(code >> 3) - 32];
    955                 }
    956                 else
    957                 {
    958                     if (code >= 16)
    959                     {
    960                         tab = &PV_DCT3Dtab5[(code>>1) - 8];
    961                     }
    962                     else
    963                     {
    964                         return PV_FAIL;
    965                     }
    966                 }
    967             }
    968 
    969             PV_BitstreamFlushBits(stream, tab->len + 1);
    970             /* sign bit */
    971             pTcoef->sign = (code >> (12 - tab->len)) & 1;
    972             pTcoef->run = (uint)tab->run; //(tab->val >> 8) & 255;
    973             pTcoef->level = (int)tab->level; //tab->val & 255;
    974             pTcoef->last = (uint)tab->last; //(tab->val >> 16) & 1;
    975 
    976 
    977 
    978             /* need to add back the max run */
    979             if (pTcoef->last)
    980             {
    981                 if (pTcoef->level > 8)
    982                 {
    983                     return PV_FAIL;
    984                 }
    985                 pTcoef->run = pTcoef->run + intra_max_run1[pTcoef->level] + 1;
    986             }
    987             else
    988             {
    989                 if (pTcoef->level > 27)
    990                 {
    991                     return PV_FAIL;
    992                 }
    993                 pTcoef->run = pTcoef->run + intra_max_run0[pTcoef->level] + 1;
    994             }
    995 
    996 
    997         }
    998         else
    999         {
   1000 
   1001             code = BitstreamReadBits16_INLINE(stream, 8);
   1002             pTcoef->last = code >> 7;
   1003             pTcoef->run = (code >> 1) & 0x3F;
   1004             pTcoef->level = (int)(BitstreamReadBits16_INLINE(stream, 13) >> 1);
   1005 
   1006             if (pTcoef->level >= 2048)
   1007             {
   1008                 pTcoef->sign = 1;
   1009                 pTcoef->level = 4096 - pTcoef->level;
   1010             }
   1011             else
   1012             {
   1013                 pTcoef->sign = 0;
   1014             }
   1015         } /* flc */
   1016     }
   1017 
   1018     return PV_SUCCESS;
   1019 
   1020 } /* VlcDecTCOEFIntra */
   1021 
   1022 PV_STATUS VlcDecTCOEFInter(BitstreamDecVideo *stream, Tcoef *pTcoef)
   1023 {
   1024     uint code;
   1025     const VLCtab2 *tab;
   1026 
   1027     BitstreamShow13Bits(stream, &code);
   1028 
   1029     /* 10/17/2000, perform a little bit better on ARM by putting the whole function in VlcDecTCOEFFInter */
   1030     /*  if(GetTcoeffInter(code,pTcoef,&tab,stream)!=PV_SUCCESS) return status;*/
   1031     if (code >= 1024)
   1032     {
   1033         tab = &PV_DCT3Dtab0[(code >> 6) - 16];
   1034     }
   1035     else
   1036     {
   1037         if (code >= 256)
   1038         {
   1039             tab = &PV_DCT3Dtab1[(code >> 3) - 32];
   1040         }
   1041         else
   1042         {
   1043             if (code >= 16)
   1044             {
   1045                 tab = &PV_DCT3Dtab2[(code>>1) - 8];
   1046             }
   1047             else
   1048             {
   1049                 return PV_FAIL;
   1050             }
   1051         }
   1052     }
   1053     PV_BitstreamFlushBits(stream, tab->len + 1);
   1054     pTcoef->sign = (code >> (12 - tab->len)) & 1;
   1055     pTcoef->run = (uint)tab->run;     //(tab->val >> 4) & 255;
   1056     pTcoef->level = (int)tab->level; //tab->val & 15;
   1057     pTcoef->last = (uint)tab->last;   //(tab->val >> 12) & 1;
   1058 
   1059     /* the following is modified for 3-mode escape -- boon */
   1060     if (tab->run != 0xBF)
   1061     {
   1062         return PV_SUCCESS;
   1063     }
   1064     //if (((tab->run<<4)|(tab->level)|(tab->last<<12)) == VLC_ESCAPE_CODE)
   1065 
   1066 
   1067     if (!pTcoef->sign)
   1068     {
   1069         /* first escape mode. level is offset */
   1070         BitstreamShow13Bits(stream, &code);
   1071 
   1072         /* 10/17/2000, perform a little bit better on ARM by putting the whole function in VlcDecTCOEFFInter */
   1073         /*          if(GetTcoeffInter(code,pTcoef,&tab,stream)!=PV_SUCCESS) return status;*/
   1074         if (code >= 1024)
   1075         {
   1076             tab = &PV_DCT3Dtab0[(code >> 6) - 16];
   1077         }
   1078         else
   1079         {
   1080             if (code >= 256)
   1081             {
   1082                 tab = &PV_DCT3Dtab1[(code >> 3) - 32];
   1083             }
   1084             else
   1085             {
   1086                 if (code >= 16)
   1087                 {
   1088                     tab = &PV_DCT3Dtab2[(code>>1) - 8];
   1089                 }
   1090                 else
   1091                 {
   1092                     return PV_FAIL;
   1093                 }
   1094             }
   1095         }
   1096         PV_BitstreamFlushBits(stream, tab->len + 1);
   1097         pTcoef->sign = (code >> (12 - tab->len)) & 1;
   1098         pTcoef->run = (uint)tab->run;     //(tab->val >> 4) & 255;
   1099         pTcoef->level = (int)tab->level; //tab->val & 15;
   1100         pTcoef->last = (uint)tab->last;   //(tab->val >> 12) & 1;
   1101 
   1102         /* need to add back the max level */
   1103         if ((pTcoef->last == 0 && pTcoef->run > 26) || (pTcoef->last == 1 && pTcoef->run > 40))
   1104         {
   1105             return PV_FAIL;
   1106         }
   1107         pTcoef->level = pTcoef->level + inter_max_level[pTcoef->last][pTcoef->run];
   1108     }
   1109     else
   1110     {
   1111         uint run_offset;
   1112         run_offset = BitstreamRead1Bits_INLINE(stream);
   1113 
   1114         if (!run_offset)
   1115         {
   1116             /* second escape mode. run is offset */
   1117             BitstreamShow13Bits(stream, &code);
   1118 
   1119             /* 10/17/2000, perform a little bit better on ARM by putting the whole function in VlcDecTCOEFFInter */
   1120             /*if(GetTcoeffInter(code,pTcoef,&tab,stream)!=PV_SUCCESS) return status;*/
   1121             if (code >= 1024)
   1122             {
   1123                 tab = &PV_DCT3Dtab0[(code >> 6) - 16];
   1124             }
   1125             else
   1126             {
   1127                 if (code >= 256)
   1128                 {
   1129                     tab = &PV_DCT3Dtab1[(code >> 3) - 32];
   1130                 }
   1131                 else
   1132                 {
   1133                     if (code >= 16)
   1134                     {
   1135                         tab = &PV_DCT3Dtab2[(code>>1) - 8];
   1136                     }
   1137                     else
   1138                     {
   1139                         return PV_FAIL;
   1140                     }
   1141                 }
   1142             }
   1143             PV_BitstreamFlushBits(stream, tab->len + 1);
   1144             pTcoef->sign = (code >> (12 - tab->len)) & 1;
   1145             pTcoef->run = (uint)tab->run;     //(tab->val >> 4) & 255;
   1146             pTcoef->level = (int)tab->level; //tab->val & 15;
   1147             pTcoef->last = (uint)tab->last;   //(tab->val >> 12) & 1;
   1148 
   1149             /* need to add back the max run */
   1150             if (pTcoef->last)
   1151             {
   1152                 if (pTcoef->level > 3)
   1153                 {
   1154                     return PV_FAIL;
   1155                 }
   1156                 pTcoef->run = pTcoef->run + inter_max_run1[pTcoef->level] + 1;
   1157             }
   1158             else
   1159             {
   1160                 if (pTcoef->level > 12)
   1161                 {
   1162                     return PV_FAIL;
   1163                 }
   1164                 pTcoef->run = pTcoef->run + inter_max_run0[pTcoef->level] + 1;
   1165             }
   1166         }
   1167         else
   1168         {
   1169 
   1170             code = BitstreamReadBits16_INLINE(stream, 8);
   1171             pTcoef->last = code >> 7;
   1172             pTcoef->run = (code >> 1) & 0x3F;
   1173             pTcoef->level = (int)(BitstreamReadBits16_INLINE(stream, 13) >> 1);
   1174 
   1175 
   1176 
   1177             if (pTcoef->level >= 2048)
   1178             {
   1179                 pTcoef->sign = 1;
   1180                 pTcoef->level = 4096 - pTcoef->level;
   1181             }
   1182             else
   1183             {
   1184                 pTcoef->sign = 0;
   1185             }
   1186         } /* flc */
   1187     }
   1188 
   1189     return PV_SUCCESS;
   1190 
   1191 } /* VlcDecTCOEFInter */
   1192 
   1193 /*=======================================================
   1194     Function:   VlcDecTCOEFShortHeader()
   1195     Date    :   04/27/99
   1196     Purpose :   New function used in decoding of video planes
   1197                 with short header
   1198     Modified:   05/23/2000
   1199                 for new decoder structure.
   1200 =========================================================*/
   1201 PV_STATUS VlcDecTCOEFShortHeader(BitstreamDecVideo *stream, Tcoef *pTcoef/*, int intra*/)
   1202 {
   1203     uint code;
   1204     const VLCtab2 *tab;
   1205 
   1206     BitstreamShow13Bits(stream, &code);
   1207 
   1208     /*intra = 0;*/
   1209 
   1210     if (code >= 1024) tab = &PV_DCT3Dtab0[(code >> 6) - 16];
   1211     else
   1212     {
   1213         if (code >= 256) tab = &PV_DCT3Dtab1[(code >> 3) - 32];
   1214         else
   1215         {
   1216             if (code >= 16) tab = &PV_DCT3Dtab2[(code>>1) - 8];
   1217             else return PV_FAIL;
   1218         }
   1219     }
   1220 
   1221     PV_BitstreamFlushBits(stream, tab->len + 1);
   1222     pTcoef->sign = (code >> (12 - tab->len)) & 1;
   1223     pTcoef->run = (uint)tab->run;//(tab->val >> 4) & 255;
   1224     pTcoef->level = (int)tab->level;//tab->val & 15;
   1225     pTcoef->last = (uint)tab->last;//(tab->val >> 12) & 1;
   1226 
   1227     /* the following is modified for 3-mode escape -- boon */
   1228     if (((tab->run << 4) | (tab->level) | (tab->last << 12)) != VLC_ESCAPE_CODE)    /* ESCAPE */
   1229     {
   1230         return PV_SUCCESS;
   1231     }
   1232 
   1233 
   1234     /* escape mode 4 - H.263 type */
   1235     pTcoef->last = pTcoef->sign; /* Last */
   1236     pTcoef->run = BitstreamReadBits16_INLINE(stream, 6); /* Run */
   1237     pTcoef->level = (int) BitstreamReadBits16_INLINE(stream, 8); /* Level */
   1238 
   1239     if (pTcoef->level == 0 || pTcoef->level == 128)
   1240     {
   1241         return PV_FAIL;
   1242     }
   1243 
   1244     if (pTcoef->level > 128)
   1245     {
   1246         pTcoef->sign = 1;
   1247         pTcoef->level = 256 - pTcoef->level;
   1248     }
   1249     else
   1250     {
   1251         pTcoef->sign = 0;
   1252     }
   1253 
   1254 
   1255 
   1256     return PV_SUCCESS;
   1257 
   1258 }   /* VlcDecTCOEFShortHeader */
   1259 
   1260 #ifdef PV_ANNEX_IJKT_SUPPORT
   1261 PV_STATUS VlcDecTCOEFShortHeader_AnnexI(BitstreamDecVideo *stream, Tcoef *pTcoef/*, int intra*/)
   1262 {
   1263     uint code;
   1264     const VLCtab2 *tab;
   1265 
   1266     BitstreamShow13Bits(stream, &code);
   1267 
   1268     /*intra = 0;*/
   1269 
   1270     if (code >= 1024) tab = &PV_DCT3Dtab6[(code >> 6) - 16];
   1271     else
   1272     {
   1273         if (code >= 256) tab = &PV_DCT3Dtab7[(code >> 3) - 32];
   1274         else
   1275         {
   1276             if (code >= 16) tab = &PV_DCT3Dtab8[(code>>1) - 8];
   1277             else return PV_FAIL;
   1278         }
   1279     }
   1280 
   1281     PV_BitstreamFlushBits(stream, tab->len + 1);
   1282     pTcoef->sign = (code >> (12 - tab->len)) & 1;
   1283     pTcoef->run = (uint)tab->run;//(tab->val >> 4) & 255;
   1284     pTcoef->level = (int)tab->level;//tab->val & 15;
   1285     pTcoef->last = (uint)tab->last;//(tab->val >> 12) & 1;
   1286 
   1287     /* the following is modified for 3-mode escape -- boon */
   1288     if (((tab->run << 6) | (tab->level) | (tab->last << 12)) != VLC_ESCAPE_CODE)    /* ESCAPE */
   1289     {
   1290         return PV_SUCCESS;
   1291     }
   1292     /* escape mode 4 - H.263 type */
   1293     pTcoef->last = pTcoef->sign; /* Last */
   1294     pTcoef->run = BitstreamReadBits16(stream, 6); /* Run */
   1295     pTcoef->level = (int) BitstreamReadBits16(stream, 8); /* Level */
   1296 
   1297     if (pTcoef->level == 0 || pTcoef->level == 128)
   1298     {
   1299         return PV_FAIL;
   1300     }
   1301 
   1302 
   1303     if (pTcoef->level > 128)
   1304     {
   1305         pTcoef->sign = 1;
   1306         pTcoef->level = 256 - pTcoef->level;
   1307     }
   1308     else pTcoef->sign = 0;
   1309 
   1310 
   1311 
   1312     return PV_SUCCESS;
   1313 
   1314 }   /* VlcDecTCOEFShortHeader_AnnexI */
   1315 
   1316 PV_STATUS VlcDecTCOEFShortHeader_AnnexT(BitstreamDecVideo *stream, Tcoef *pTcoef/*, int intra*/)
   1317 {
   1318     uint code;
   1319     const VLCtab2 *tab;
   1320 
   1321     BitstreamShow13Bits(stream, &code);
   1322 
   1323     /*intra = 0;*/
   1324 
   1325     if (code >= 1024) tab = &PV_DCT3Dtab0[(code >> 6) - 16];
   1326     else
   1327     {
   1328         if (code >= 256) tab = &PV_DCT3Dtab1[(code >> 3) - 32];
   1329         else
   1330         {
   1331             if (code >= 16) tab = &PV_DCT3Dtab2[(code>>1) - 8];
   1332             else return PV_FAIL;
   1333         }
   1334     }
   1335 
   1336     PV_BitstreamFlushBits(stream, tab->len + 1);
   1337     pTcoef->sign = (code >> (12 - tab->len)) & 1;
   1338     pTcoef->run = (uint)tab->run;//(tab->val >> 4) & 255;
   1339     pTcoef->level = (int)tab->level;//tab->val & 15;
   1340     pTcoef->last = (uint)tab->last;//(tab->val >> 12) & 1;
   1341 
   1342     /* the following is modified for 3-mode escape --  */
   1343     if (((tab->run << 4) | (tab->level) | (tab->last << 12)) != VLC_ESCAPE_CODE)    /* ESCAPE */
   1344     {
   1345         return PV_SUCCESS;
   1346     }
   1347     /* escape mode 4 - H.263 type */
   1348     pTcoef->last = pTcoef->sign; /* Last */
   1349     pTcoef->run = BitstreamReadBits16(stream, 6); /* Run */
   1350     pTcoef->level = (int) BitstreamReadBits16(stream, 8); /* Level */
   1351 
   1352     if (pTcoef->level == 0)
   1353     {
   1354         return PV_FAIL;
   1355     }
   1356 
   1357     if (pTcoef->level >= 128)
   1358     {
   1359         pTcoef->sign = 1;
   1360         pTcoef->level = 256 - pTcoef->level;
   1361     }
   1362     else
   1363     {
   1364         pTcoef->sign = 0;
   1365     }
   1366 
   1367     if (pTcoef->level == 128)
   1368     {
   1369         code = BitstreamReadBits16(stream, 11);        /* ANNEX_T */
   1370 
   1371         code = (code >> 6 & 0x1F) | (code << 5 & 0x7ff);
   1372         if (code > 1024)
   1373         {
   1374             pTcoef->sign = 1;
   1375             pTcoef->level = (2048 - code);
   1376         }
   1377         else
   1378         {
   1379             pTcoef->sign = 0;
   1380             pTcoef->level = code;
   1381         }
   1382     }
   1383 
   1384     return PV_SUCCESS;
   1385 
   1386 }   /* VlcDecTCOEFShortHeader */
   1387 
   1388 
   1389 PV_STATUS VlcDecTCOEFShortHeader_AnnexIT(BitstreamDecVideo *stream, Tcoef *pTcoef/*, int intra*/)
   1390 {
   1391     uint code;
   1392     const VLCtab2 *tab;
   1393 
   1394     BitstreamShow13Bits(stream, &code);
   1395 
   1396     /*intra = 0;*/
   1397 
   1398     if (code >= 1024) tab = &PV_DCT3Dtab6[(code >> 6) - 16];
   1399     else
   1400     {
   1401         if (code >= 256) tab = &PV_DCT3Dtab7[(code >> 3) - 32];
   1402         else
   1403         {
   1404             if (code >= 16) tab = &PV_DCT3Dtab8[(code>>1) - 8];
   1405             else return PV_FAIL;
   1406         }
   1407     }
   1408 
   1409     PV_BitstreamFlushBits(stream, tab->len + 1);
   1410     pTcoef->sign = (code >> (12 - tab->len)) & 1;
   1411     pTcoef->run = (uint)tab->run;//(tab->val >> 4) & 255;
   1412     pTcoef->level = (int)tab->level;//tab->val & 15;
   1413     pTcoef->last = (uint)tab->last;//(tab->val >> 12) & 1;
   1414 
   1415     /* the following is modified for 3-mode escape --  */
   1416     if (((tab->run << 6) | (tab->level) | (tab->last << 12)) != VLC_ESCAPE_CODE)    /* ESCAPE */
   1417     {
   1418         return PV_SUCCESS;
   1419     }
   1420     /* escape mode 4 - H.263 type */
   1421     pTcoef->last = pTcoef->sign; /* Last */
   1422     pTcoef->run = BitstreamReadBits16(stream, 6); /* Run */
   1423     pTcoef->level = (int) BitstreamReadBits16(stream, 8); /* Level */
   1424 
   1425     if (pTcoef->level == 0)
   1426     {
   1427         return PV_FAIL;
   1428     }
   1429 
   1430     if (pTcoef->level >= 128)
   1431     {
   1432         pTcoef->sign = 1;
   1433         pTcoef->level = 256 - pTcoef->level;
   1434     }
   1435     else
   1436     {
   1437         pTcoef->sign = 0;
   1438     }
   1439 
   1440     if (pTcoef->level == 128)
   1441     {
   1442         code = BitstreamReadBits16(stream, 11);        /* ANNEX_T */
   1443 
   1444         code = (code >> 6 & 0x1F) | (code << 5 & 0x7ff);
   1445         if (code > 1024)
   1446         {
   1447             pTcoef->sign = 1;
   1448             pTcoef->level = (2048 - code);
   1449         }
   1450         else
   1451         {
   1452             pTcoef->sign = 0;
   1453             pTcoef->level = code;
   1454         }
   1455     }
   1456 
   1457 
   1458     return PV_SUCCESS;
   1459 
   1460 }   /* VlcDecTCOEFShortHeader_AnnexI */
   1461 #endif
   1462 /***********************************************************CommentBegin******
   1463 *       3/30/2000 : initial modification to the new PV-Decoder Lib
   1464 *                           format and the change of error-handling method.
   1465 *                           The coefficient is now returned thru a pre-
   1466 *                           initialized parameters for speedup.
   1467 *
   1468 ***********************************************************CommentEnd********/
   1469 
   1470 
   1471 PV_STATUS RvlcDecTCOEFInter(BitstreamDecVideo *stream, Tcoef *pTcoef)
   1472 {
   1473     uint code, mask;
   1474     const VLCtab2 *tab2;
   1475     int count, len, num[2] = {0, 0} /*  01/30/01 */;
   1476 
   1477     mask = 0x4000;      /* mask  100000000000000   */
   1478     BitstreamShow15Bits(stream, &code);   /*  03/07/01 */
   1479 
   1480     len = 1;
   1481 
   1482     //  09/20/99 Escape mode
   1483     /// Bitstream Exchange
   1484     if (code < 2048)
   1485     {
   1486         PV_BitstreamFlushBits(stream, 5);
   1487         pTcoef->last = BitstreamRead1Bits_INLINE(stream);
   1488         pTcoef->run = BitstreamReadBits16_INLINE(stream, 6);
   1489         //  09/20/99 New marker bit
   1490         PV_BitstreamFlushBits(stream, 1);
   1491         //  09/20/99 The length for LEVEL used to be 7 in the old version
   1492         pTcoef->level = (int)(BitstreamReadBits16_INLINE(stream, 12) >> 1);
   1493         //  09/20/99 Another new marker bit
   1494 //      PV_BitstreamFlushBitsCheck(stream, 1);
   1495         pTcoef->sign = BitstreamReadBits16_INLINE(stream, 5) & 0x1;  /* fix   3/13/01  */
   1496         return PV_SUCCESS;
   1497     }
   1498 
   1499     if (code & mask)
   1500     {
   1501         count = 1;
   1502         while (mask && count > 0)       /* fix  3/28/01  */
   1503         {
   1504             mask = mask >> 1;
   1505             if (code & mask)
   1506                 count--;
   1507             else
   1508                 num[0]++; /* number of zeros in the middle */
   1509             len++;
   1510         }
   1511     }
   1512     else
   1513     {
   1514         count = 2;
   1515         while (mask && count > 0)           /* fix  3/28/01  */
   1516         {
   1517             mask = mask >> 1;
   1518             if (!(code & mask))
   1519                 count--;
   1520             else
   1521                 num[count-1]++; /* number of ones in the middle */
   1522             len++;
   1523         }
   1524     }
   1525 
   1526     code = code & 0x7fff;
   1527     code = code >> (15 - (len + 1));
   1528 
   1529     /*  1/30/01, add fast decoding algorithm here */
   1530     /* code is in two forms : 0xxxx0xxx00 or 0xxx0xxx01
   1531                          num[1] and num[0] x
   1532                         or  : 1xxxxx10 or 1xxxxx11
   1533                                 num[0]  x      */
   1534 
   1535     /* len+1 is the length of the above */
   1536 
   1537     if (num[1] > 10 || num[0] > 11) /* invalid RVLC code */
   1538         return PV_FAIL;
   1539 
   1540     if (code&(1 << len))
   1541         tab2 = RvlcDCTtabInter + 146 + (num[0] << 1) + (code & 1);
   1542     else
   1543         tab2 = RvlcDCTtabInter + ptrRvlcTab[num[1]] + (num[0] << 1) + (code & 1);
   1544 
   1545     PV_BitstreamFlushBits(stream, (int) tab2->len);
   1546     pTcoef->run = (uint)tab2->run;//(tab->val >> 8) & 255;
   1547     pTcoef->level = (int)tab2->level;//tab->val & 255;
   1548     pTcoef->last = (uint)tab2->last;//(tab->val >> 16) & 1;
   1549 
   1550     pTcoef->sign = BitstreamRead1Bits_INLINE(stream);
   1551     return PV_SUCCESS;
   1552 }               /* RvlcDecTCOEFInter */
   1553 
   1554 PV_STATUS RvlcDecTCOEFIntra(BitstreamDecVideo *stream, Tcoef *pTcoef)
   1555 {
   1556     uint code, mask;
   1557     const VLCtab2 *tab2;
   1558     int count, len, num[2] = {0, 0} /*  01/30/01 */;
   1559 
   1560     mask = 0x4000;      /* mask  100000000000000   */
   1561     BitstreamShow15Bits(stream, &code);
   1562 
   1563     len = 1;
   1564 
   1565     //  09/20/99 Escape mode
   1566     /// Bitstream Exchange
   1567     if (code < 2048)
   1568     {
   1569         PV_BitstreamFlushBits(stream, 5);
   1570         pTcoef->last = BitstreamRead1Bits_INLINE(stream);
   1571         pTcoef->run = BitstreamReadBits16_INLINE(stream, 6);
   1572         //  09/20/99 New marker bit
   1573         PV_BitstreamFlushBits(stream, 1);
   1574         //  09/20/99 The length for LEVEL used to be 7 in the old version
   1575         pTcoef->level = (int)(BitstreamReadBits16_INLINE(stream, 12) >> 1);
   1576         //  09/20/99 Another new marker bit
   1577 //      PV_BitstreamFlushBitsCheck(stream, 1);
   1578         pTcoef->sign = BitstreamReadBits16_INLINE(stream, 5) & 0x1; /* fix   03/13/01 */
   1579         return PV_SUCCESS;
   1580     }
   1581 
   1582     if (code & mask)
   1583     {
   1584         count = 1;
   1585         while (mask && count > 0)                          /* fix  03/28/01 */
   1586         {
   1587             mask = mask >> 1;
   1588             if (code & mask)
   1589                 count--;
   1590             else
   1591                 num[0]++; /* number of zeros in the middle */
   1592             len++;
   1593         }
   1594     }
   1595     else
   1596     {
   1597         count = 2;
   1598         while (mask && count > 0)              /* fix  03/28/01 */
   1599         {
   1600             mask = mask >> 1;
   1601             if (!(code & mask))
   1602                 count--;
   1603             else
   1604                 num[count-1]++; /* number of ones in the middle */
   1605             len++;
   1606         }
   1607     }
   1608 
   1609     code = code & 0x7fff;
   1610     code = code >> (15 - (len + 1));
   1611 
   1612     /*  1/30/01, add fast decoding algorithm here */
   1613     /* code is in two forms : 0xxxx0xxx00 or 0xxx0xxx01
   1614                          num[1] and num[0] x
   1615                         or  : 1xxxxx10 or 1xxxxx11
   1616                                 num[0]  x      */
   1617 
   1618     /* len+1 is the length of the above */
   1619 
   1620     if (num[1] > 10 || num[0] > 11) /* invalid RVLC code */
   1621         return PV_FAIL;
   1622 
   1623     if (code & (1 << len))
   1624         tab2 = RvlcDCTtabIntra + 146 + (num[0] << 1) + (code & 1);
   1625     else
   1626         tab2 = RvlcDCTtabIntra + ptrRvlcTab[num[1]] + (num[0] << 1) + (code & 1);
   1627 
   1628     PV_BitstreamFlushBits(stream, (int) tab2->len);
   1629     pTcoef->run = (uint)tab2->run;//(tab->val >> 8) & 255;
   1630     pTcoef->level = (int)tab2->level;//tab->val & 255;
   1631     pTcoef->last = (uint)tab2->last;//(tab->val >> 16) & 1;
   1632 
   1633     pTcoef->sign = BitstreamRead1Bits_INLINE(stream);
   1634     return PV_SUCCESS;
   1635 }               /* RvlcDecTCOEFIntra */
   1636 
   1637