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/ ====================================================================== */ 103PV_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********/ 132PV_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********/ 267PV_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********/ 319PV_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 353void 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 452PV_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 503int 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 536int 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 557int 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 590int 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********/ 628PV_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 839PV_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 1022PV_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=========================================================*/ 1201PV_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 1261PV_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 1316PV_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 1389PV_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 1471PV_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 1554PV_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