Lib/QTheoraEx/FrameDecoder_Impl.h

   1 /* FrameDecoder_Impl.h */
   2 /* 2009/06/29          */
   3
   4 /* */
   5
   6 static BOOL FrameHeader_Decode(
   7         FrameHeader_t* t,
   8         BitReader_t*   d)
   9 {
  10         INITIATE_BITS
  11
  12         INT32 n = 0;
  13         INT32 x;
  14
  15         FETCH_BITS_I(x, 1)
  16         if (x != 0) {
  17                 return FALSE;
  18         }
  19
  20         FETCH_BITS_I(t->Type, 1)
  21
  22         FETCH_BITS_I(t->QIS[n], 6) n++;
  23
  24         FETCH_BITS_I(x, 1)
  25         if (x != 0) {
  26                 FETCH_BITS_I(t->QIS[n], 6) n++;
  27
  28                 FETCH_BITS_I(x, 1)
  29                 if (x != 0) {
  30                         FETCH_BITS_I(t->QIS[n], 6) n++;
  31                 }
  32         }
  33
  34         t->NQIS = n;
  35
  36         if (t->Type == 0) { /* INTRA */
  37                 FETCH_BITS_I(x, 3)
  38                 if (x != 0) {
  39                         return FALSE;
  40                 }
  41         }
  42
  43         FINALIZE_BITS
  44
  45         return TRUE;
  46 }
  47
  48 /* */
  49
  50 static BOOL FrameDecoder_DecodeCodedBlockFlag(
  51         FrameDecoder_t* t,
  52         BitReader_t*    d)
  53 {
  54         INITIATE_BITS
  55
  56         INT8* p;
  57         INT32 x, i, j;
  58
  59         RunLength_t r;
  60
  61         INT32 full = 0;
  62         INT32 part = 0;
  63
  64         for (i = 0; i < 3; i++) {
  65                 t->BlocksCoded[i] = 0;
  66         }
  67
  68         memset(t->Count, 0, sizeof(UINT8) * t->Index->Blocks);
  69
  70         /* PARTIAL or FULL */
  71
  72         FETCH_BITS_I(x, 1)
  73         RunLength_Start(&r, x);
  74
  75         p = t->SBCoded;
  76         for (i = 0; i < 3; i++) {
  77                 INT8* e = p + t->Index->SC[i];
  78                 for (; p < e; p++) {
  79                         RL_LONG_DECODE
  80
  81                         *p = r.Bit;
  82                         if (r.Bit == 0) {
  83                                 full++;
  84                         } else {
  85                                 part++;
  86                         }
  87                 }
  88         }
  89
  90         if (r.Run > 0) {
  91                 return FALSE;
  92         }
  93
  94         /* FULL */
  95
  96         if (full > 0) {
  97                 UINT8* count = t->Count;
  98
  99                 FETCH_BITS_I(x, 1)
 100                 RunLength_Start(&r, x);
 101
 102                 p = t->SBCoded;
 103                 for (i = 0; i < 3; i++) {
 104                         const UINT8* c = t->Index->BCount[i];
 105
 106                         INT8* e = p + t->Index->SC[i];
 107                         for (; p < e; p++, c++) {
 108                                 if (*p == 0) {
 109                                         RL_LONG_DECODE
 110
 111                                         if (r.Bit != 0) {
 112                                                 *p = -1;
 113
 114                                                 t->BlocksCoded[i] += *c;
 115
 116                                         } else {
 117                                                 for (j = 0; j < *c; j++) {
 118                                                         count[j] = 0xff;
 119                                                 }
 120                                         }
 121                                 }
 122
 123                                 count += *c;
 124                         }
 125                 }
 126
 127                 if (r.Run > 0) {
 128                         return FALSE;
 129                 }
 130         }
 131
 132         /* PARTIAL */
 133
 134         if (part > 0) {
 135                 UINT8* count = t->Count;
 136
 137                 FETCH_BITS_I(x, 1)
 138                 RunLength_Start(&r, x);
 139
 140                 p = t->SBCoded;
 141                 for (i = 0; i < 3; i++) {
 142                         const UINT8* c = t->Index->BCount[i];
 143
 144                         INT8* e = p + t->Index->SC[i];
 145                         for (; p < e; p++, c++) {
 146                                 if (*p == 1) {
 147                                         for (j = 0; j < *c; j++) {
 148                                                 RL_SHORT_DECODE
 149
 150                                                 if (r.Bit != 0) {
 151                                                         t->BlocksCoded[i] += 1;
 152
 153                                                 } else {
 154                                                         count[j] = 0xff;
 155                                                 }
 156                                         }
 157                                 }
 158
 159                                 count += *c;
 160                         }
 161                 }
 162
 163                 if (r.Run > 0) {
 164                         return FALSE;
 165                 }
 166         }
 167
 168         FINALIZE_BITS
 169
 170         return TRUE;
 171 }
 172
 173 /* */
 174
 175 static BOOL FrameDecoder_DecodeMacroBlockCodingModes(
 176         FrameDecoder_t* t,
 177         BitReader_t*    d)
 178 {
 179         INITIATE_BITS
 180
 181         INT32 scheme;
 182         UINT8 mode[8];
 183
 184         UINT8* m   = t->MBMode;
 185         UINT8* end = m + t->Index->MC;
 186
 187         const UINT16* mbi = t->Index->MBIndex;
 188         const UINT16* cbi = t->Index->CBIndex;
 189
 190         UINT8* m0 = t->BMode;
 191         UINT8* m1 = m0 + t->Index->BC[0];
 192         UINT8* m2 = m1 + t->Index->BC[1];
 193
 194         const UINT8* c = t->Count;
 195
 196         FETCH_BITS_I(scheme, 3)
 197         memcpy(mode, M_MODE[scheme], 8);
 198
 199         if (scheme == 0) {
 200                 INT32 i;
 201                 for (i = 0; i < 8; i++) {
 202                         INT32 x;
 203                         FETCH_BITS_I(x, 3)
 204                         mode[x] = i;
 205                 }
 206         }
 207
 208         if (scheme != 7) {
 209                 for (; m < end; m++, c += 4, mbi += 4, cbi++) {
 210                         UINT8 mm = 0;
 211
 212                         if (c[0] != 0xff || c[1] != 0xff || c[2] != 0xff || c[3] != 0xff) {
 213                                 INT32 code;
 214                                 LOAD_BITS
 215                                 code = H_MODE[GET_BITS_I(7)];
 216                                 RETIRE_BITS(code & 0xf);
 217                                 mm = mode[code >> 4];
 218                         }
 219
 220                         *m = mm;
 221
 222                         m0[mbi[0]] = mm;
 223                         m0[mbi[1]] = mm;
 224                         m0[mbi[2]] = mm;
 225                         m0[mbi[3]] = mm;
 226                         m1[cbi[0]] = mm;
 227                         m2[cbi[0]] = mm;
 228                 }
 229
 230         } else {
 231                 for (; m < end; m++, c += 4, mbi += 4, cbi++) {
 232                         UINT8 mm = 0;
 233
 234                         if (c[0] != 0xff || c[1] != 0xff || c[2] != 0xff || c[3] != 0xff) {
 235                                 INT32 x;
 236                                 FETCH_BITS_I(x, 3)
 237                                 mm = mode[x];
 238                         }
 239
 240                         *m = mm;
 241
 242                         m0[mbi[0]] = mm;
 243                         m0[mbi[1]] = mm;
 244                         m0[mbi[2]] = mm;
 245                         m0[mbi[3]] = mm;
 246                         m1[cbi[0]] = mm;
 247                         m2[cbi[0]] = mm;
 248                 }
 249         }
 250
 251         FINALIZE_BITS
 252
 253         return TRUE;
 254 }
 255
 256 /* */
 257
 258 static BOOL FrameDecoder_DecodeMotionVectors(
 259         FrameDecoder_t* t,
 260         BitReader_t*    d)
 261 {
 262         INITIATE_BITS
 263
 264         const UINT8* m   = t->MBMode;
 265         const UINT8* end = m + t->Index->MC;
 266
 267         const UINT16* cbi = t->Index->CBIndex;
 268
 269         const UINT8* c = t->Count;
 270
 271         MotionVector_t* mv = t->MV;
 272
 273         MotionVector_t last[2] = { { 0, 0 }, { 0, 0 } };
 274
 275         INT32 (*Decode)(MotionVector_t*, INT32);
 276
 277         INT32 x, s;
 278         FETCH_BITS_I(x, 1)
 279
 280         Decode = (x == 0) ? DecodeMV0 : DecodeMV1;
 281
 282         for (; m < end; m++, c += 4, mv += 4, cbi++) {
 283                 switch (*m) {
 284                 case 2: /* INTER_MV */
 285                         LOAD_BITS
 286                         x = GET_BITS_I(16);
 287                         s = Decode(mv, x);
 288                         RETIRE_BITS(s)
 289
 290                         last[1] = last[0];
 291                         last[0] = *mv;
 292                         break;
 293
 294                 case 3: /* INTER_MV_LAST */
 295                         *mv = last[0];
 296                         break;
 297
 298                 case 4: /* INTER_MV_LAST2 */
 299                         *mv = last[1];
 300
 301                         last[1] = last[0];
 302                         last[0] = *mv;
 303                         break;
 304
 305                 case 6: /* INTER_GOLDEN_MV */
 306                         LOAD_BITS
 307                         x = GET_BITS_I(16);
 308                         s = Decode(mv, x);
 309                         RETIRE_BITS(s)
 310                         break;
 311
 312                 case 7: /* INTER_MV_FOUR */
 313                 {
 314                         MotionVector_t* mv0 = mv;
 315
 316                         MotionVector_t* v = mv;
 317
 318                         INT32 cmx = 0;
 319                         INT32 cmy = 0;
 320
 321                         INT32 i;
 322                         for (i = 0; i < 4; i++) {
 323                                 if (c[i] != 0xff) {
 324                                         LOAD_BITS
 325                                         x = GET_BITS_I(16);
 326                                         s = Decode(v, x);
 327                                         RETIRE_BITS(s)
 328
 329                                         cmx += v->X;
 330                                         cmy += v->Y;
 331
 332                                         mv0 = v++;
 333                                 }
 334                         }
 335
 336                         for (; v < mv + 4; v++) {
 337                                 v->X = 0;
 338                                 v->Y = 0;
 339                         }
 340
 341                         t->MVC[*cbi].X = (cmx + CMV[cmx < 0]) >> 2;
 342                         t->MVC[*cbi].Y = (cmy + CMV[cmy < 0]) >> 2;
 343
 344                         last[1] = last[0];
 345                         last[0] = *mv0;
 346                         break;
 347                 }
 348
 349                 default:
 350                         mv->X = 0;
 351                         mv->Y = 0;
 352                         break;
 353
 354                 } /* switch */
 355
 356                 if (*m != 7) { /* INTER_MV_FOUR */
 357                         t->MVC[*cbi] = *mv;
 358                 }
 359         }
 360
 361         FINALIZE_BITS
 362
 363         return TRUE;
 364 }
 365
 366 /* */
 367
 368 static BOOL FrameDecoder_DecodeBlocks(
 369         FrameDecoder_t*           t,
 370         BitReader_t*              d,
 371         const HuffmanDecoder_t*   h,
 372         DCTCoefficientsContext_t* ctx,
 373         INT32                     index)
 374 {
 375         INITIATE_BITS
 376
 377         INT32 count = ctx->BlocksCoded[index];
 378
 379         while (count > 0) {
 380                 INT32 i, run = 0, coeff = 0;
 381
 382                 if (ctx->EOB_Run == 0) {
 383                         INT32 token = -1;
 384                         INT32 bits  = 0;
 385                         INT32 rbits = 0;
 386
 387                         UINT32 code = 0;
 388
 389                         LOAD_BITS
 390
 391                         if (h->LookupBits > 0) {
 392                                 INT32 len;
 393
 394                                 code = GET_BITS(h->LookupBits);
 395                                 len  = h->LookupLength[code];
 396
 397                                 if (len > 0) {
 398                                         RETIRE_BITS(len)
 399                                         token = h->LookupToken[code];
 400
 401                                 } else {
 402                                         RETIRE_BITS(h->LookupBits)
 403                                         rbits = bits = h->LookupBits;
 404                                 }
 405                         }
 406
 407                         for (; token < 0 && bits < BITS_COUNT; bits++) {
 408                                 INT32 es = h->Count[bits], idx;
 409                                 if (es < 0) {
 410                                         break;
 411                                 }
 412
 413                                 idx = h->Index[bits];
 414                                 if (idx >= 0) {
 415                                         INT32 len = bits + 1 - rbits;
 416
 417                                         const UINT32* s = h->Code + idx;
 418                                         const UINT32* e = s + es;
 419
 420                                         LOAD_BITS
 421                                         code = (code << len) | GET_BITS(len);
 422                                         RETIRE_BITS(len)
 423
 424                                         rbits = bits + 1;
 425
 426                                         while (s < e) {
 427                                                 const UINT32* x = s + (e - s) / 2;
 428                                                 if (code == *x) {
 429                                                         token = h->Token[x - h->Code];
 430                                                         break;
 431                                                 }
 432
 433                                                 if (code < *x) {
 434                                                         e = x;
 435                                                 } else {
 436                                                         s = x + 1;
 437                                                 }
 438                                         }
 439                                 }
 440                         }
 441
 442                         if (token >= 0 && token < 7) {
 443                                 INT32 blen = EOB_BITS_LEN[token];
 444                                 ctx->EOB_Run = EOB_RUN_BASE[token];
 445                                 if (blen > 0) {
 446                                         INT32 x;
 447                                         FETCH_BITS(x, blen)
 448                                         ctx->EOB_Run += x;
 449                                 }
 450
 451                                 coeff = 0;
 452                                 run   = 0;
 453
 454                         } else if (token >= 7 && token < 32) {
 455                                 INT32 clen = COEFF_BITS_LEN[token - 7];
 456                                 INT32 rlen = RUN_BITS_LEN  [token - 7];
 457
 458                                 coeff = COEFF_BASE[token - 7];
 459                                 if (clen > 0) {
 460                                         INT32 sign;
 461                                         FETCH_BITS_I(sign, 1)
 462                                         sign = COEFF_SIGN[sign];
 463                                         if (clen > 1) {
 464                                                 INT32 x;
 465                                                 clen--;
 466                                                 FETCH_BITS(x, clen)
 467                                                 coeff = sign * (coeff + x);
 468                                         } else {
 469                                                 coeff *= sign;
 470                                         }
 471                                 }
 472
 473                                 run = RUN_BASE[token - 7];
 474                                 if (rlen > 0) {
 475                                         INT32 x;
 476                                         FETCH_BITS(x, rlen)
 477                                         run += x;
 478                                 }
 479
 480                         } else {
 481                                 return FALSE;
 482                         }
 483                 }
 484
 485                 if (ctx->EOB_Run == 0) {
 486                         *((ctx->Run  )++) = run;
 487                         *((ctx->Coeff)++) = coeff;
 488
 489                         if (index + run + 1 > 64) {
 490                                 return FALSE;
 491                         }
 492
 493                         for (i = index + 1; i < index + run + 1; i++) {
 494                                 ctx->BlocksCoded[i] -= 1;
 495                         }
 496
 497                         count -= 1;
 498
 499                 } else {
 500                         INT32 eob = ctx->EOB_Run;
 501
 502                         if (eob > count) {
 503                                 eob = count;
 504                         }
 505
 506                         *((ctx->Run  )++) = -1;
 507                         *((ctx->Coeff)++) = eob;
 508
 509                         for (i = index + 1; i < 64; i++) {
 510                                 ctx->BlocksCoded[i] -= eob;
 511                         }
 512
 513                         ctx->EOB_Run -= eob;
 514
 515                         count -= eob;
 516                 }
 517         }
 518
 519         FINALIZE_BITS
 520
 521         if (REST_BITS < 0) {
 522                 return FALSE;
 523         }
 524
 525         return TRUE;
 526 }
 527
 528 static BOOL FrameDecoder_DecodeDCTCoefficients(
 529         FrameDecoder_t* t,
 530         BitReader_t*    d)
 531 {
 532         INT32 i, j, k;
 533
 534         const HuffmanDecoder_t* huff[3];
 535
 536         INT32 index = 0;
 537
 538         INT32 hy, hc;
 539
 540         DCTCoefficientsContext_t ctx = { 0 };
 541
 542         INT32 Coded[3][64];
 543
 544         ctx.Run   = t->DCTRun;
 545         ctx.Coeff = t->DCTCoeff;
 546
 547         for (i = 0; i < 64; i++) {
 548                 Coded[0][i] = t->BlocksCoded[0];
 549                 Coded[1][i] = t->BlocksCoded[1];
 550                 Coded[2][i] = t->BlocksCoded[2];
 551         }
 552
 553         for (i = 0; i < 5; i++) {
 554                 if (i < 2) {
 555                         INITIATE_BITS
 556                         FETCH_BITS_I(hy, 4);
 557                         FETCH_BITS_I(hc, 4);
 558                         FINALIZE_BITS
 559                 }
 560
 561                 huff[0] = t->Setup->Huffman + i * 0x10 + hy;
 562                 huff[1] = t->Setup->Huffman + i * 0x10 + hc;
 563                 huff[2] = huff[1];
 564
 565                 for (j = 0; j < COEFFS[i]; j++, index++) {
 566                         for (k = 0; k < 3; k++) {
 567                                 t->BRun  [k][index] = ctx.Run;
 568                                 t->BCoeff[k][index] = ctx.Coeff;
 569
 570                                 ctx.BlocksCoded = Coded[k];
 571
 572                                 if (!FrameDecoder_DecodeBlocks(
 573                                         t,
 574                                         d,
 575                                         huff[k],
 576                                         &ctx,
 577                                         index)) {
 578                                         return FALSE;
 579                                 }
 580                         }
 581                 }
 582         }
 583
 584         return TRUE;
 585 }
 586
 587 /* */
 588
 589 static BOOL FrameDecoder_Decode(
 590         FrameDecoder_t* t,
 591         const VOID*     p,
 592         SIZE_T          size)
 593 {
 594         BitReader_t d;
 595
 596         QT_BitReader_Initialize(&d, p, size);
 597
 598         if (!FrameHeader_Decode(&(t->Header), &d)) {
 599                 return FALSE;
 600         }
 601
 602         if (t->QIndex != t->Header.QIS[0]) {
 603                 t->QIndex  = t->Header.QIS[0];
 604                 Dequantize_MakeMatrix(
 605                         &(t->Dequantize),
 606                         &(t->Setup->Dequantize),
 607                         t->QIndex);
 608
 609                 Filter_Setup(
 610                         &(t->Filter),
 611                         &(t->Setup->Filter),
 612                         t->QIndex);
 613         }
 614
 615         /* */
 616
 617         if (t->Header.Type == 0) { /* Intra */
 618                 t->Frame[0] = t->Plane + 0; /* G */
 619                 t->Frame[1] = t->Plane + 0; /* C */
 620                 t->Frame[2] = t->Plane + 3; /* R */
 621
 622                 memset(t->Count, 0, sizeof(UINT8) * t->Index->Blocks);
 623
 624                 memset(t->MBMode, 1, sizeof(UINT8) * t->Index->MC);
 625                 memset(t->BMode,  1, sizeof(UINT8) * t->Index->Blocks);
 626
 627                 t->BlocksCoded[0] = t->Index->BC[0];
 628                 t->BlocksCoded[1] = t->Index->BC[1];
 629                 t->BlocksCoded[2] = t->Index->BC[2];
 630
 631         } else {
 632                 if (t->Frame[1] == t->Plane + 0) {
 633                         t->Frame[1] = t->Plane + 3;
 634                         t->Frame[2] = t->Plane + 0;
 635                 } else if (t->Frame[1] == t->Plane + 3) {
 636                         t->Frame[1] = t->Plane + 6;
 637                         t->Frame[2] = t->Plane + 3;
 638                 } else if (t->Frame[1] == t->Plane + 6) {
 639                         t->Frame[1] = t->Plane + 3;
 640                         t->Frame[2] = t->Plane + 6;
 641                 }
 642
 643                 if (!FrameDecoder_DecodeCodedBlockFlag(t, &d)) {
 644                         return FALSE;
 645                 }
 646
 647                 if (!FrameDecoder_DecodeMacroBlockCodingModes(t, &d)) {
 648                         return FALSE;
 649                 }
 650
 651                 if (!FrameDecoder_DecodeMotionVectors(t, &d)) {
 652                         return FALSE;
 653                 }
 654         }
 655
 656         if (!FrameDecoder_DecodeDCTCoefficients(t, &d)) {
 657                 return FALSE;
 658         }
 659
 660         /* */
 661
 662         DecodeDCCoefficients(t);
 663
 664 #if 0
 665         {
 666                 INT32 i;
 667                 INT32 x, y;
 668
 669                 const INT16* dc = t->DC;
 670
 671                 for (i = 0; i < 3; i++) {
 672                         INT32 bx = t->Index->BX[i];
 673                         INT32 by = t->Index->BY[i];
 674
 675                         printf("DC: %d\n", i);
 676                         for (y = 0; y < by; y++) {
 677                                 for (x = 0; x < bx; x++, dc++) {
 678                                         if (x > 0) {
 679                                                 printf(" ");
 680                                         }
 681                                         printf("%d", *dc);
 682                                 }
 683                                 printf("\n");
 684                         }
 685                 }
 686         }
 687 #endif
 688
 689         /* */
 690
 691         UndoDCPrediction(t);
 692
 693 #if 0
 694         {
 695                 INT32 i;
 696                 INT32 x, y;
 697
 698                 const INT16* dc = t->DC;
 699
 700                 for (i = 0; i < 3; i++) {
 701                         INT32 bx = t->Index->BX[i];
 702                         INT32 by = t->Index->BY[i];
 703
 704                         printf("DC: %d\n", i);
 705                         for (y = 0; y < by; y++) {
 706                                 for (x = 0; x < bx; x++, dc++) {
 707                                         if (x > 0) {
 708                                                 printf(" ");
 709                                         }
 710                                         printf("%d", *dc);
 711                                 }
 712                                 printf("\n");
 713                         }
 714                 }
 715         }
 716 #endif
 717
 718         /* */
 719
 720         QT_ReconstructFrame(t);
 721
 722         /* */
 723
 724         return TRUE;
 725 }
 726
 727 /* */
 728
 729 #undef FrameHeader_Decode
 730
 731 #undef FrameDecoder_DecodeCodedBlockFlag
 732 #undef FrameDecoder_DecodeMacroBlockCodingModes
 733 #undef FrameDecoder_DecodeMotionVectors
 734
 735 #undef FrameDecoder_DecodeBlocks
 736 #undef FrameDecoder_DecodeDCTCoefficients
 737
 738 #undef FrameDecoder_Decode
 739
 740 /* */
 741