frameworks/base/media/libstagefright/codecs/m4v_h263/dec/src/vlc_decode.cpp

   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@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@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@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