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* mbi = t->Index->MBIndex;
 268
 269         const UINT8* c = t->Count;
 270
 271         MotionVector_t last[2] = { { 0, 0 }, { 0, 0 } };
 272
 273         INT32 (*Decode)(MotionVector_t*, INT32);
 274
 275         INT32 x, s;
 276         FETCH_BITS_I(x, 1)
 277
 278         Decode = (x == 0) ? DecodeMV0 : DecodeMV1;
 279
 280         for (; m < end; m++, c += 4, mbi += 4) {
 281                 MotionVector_t* mv = t->MV + mbi[0];
 282
 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                         INT32 i;
 315                         for (i = 0; i < 4; i++) {
 316                                 MotionVector_t* v = t->MV + mbi[i];
 317
 318                                 if (c[i] != 0xff) {
 319                                         LOAD_BITS
 320                                         x = GET_BITS_I(16);
 321                                         s = Decode(v, x);
 322                                         RETIRE_BITS(s)
 323
 324                                         mv = v;
 325
 326                                 } else {
 327                                         v->X = 0;
 328                                         v->Y = 0;
 329                                 }
 330                         }
 331
 332                         last[1] = last[0];
 333                         last[0] = *mv;
 334                         break;
 335                 }
 336
 337                 default:
 338                         mv->X = 0;
 339                         mv->Y = 0;
 340                         break;
 341
 342                 } /* switch */
 343         }
 344
 345         FINALIZE_BITS
 346
 347         return TRUE;
 348 }
 349
 350 /* */
 351
 352 static BOOL FrameDecoder_DecodeBlocks(
 353         FrameDecoder_t*           t,
 354         BitReader_t*              d,
 355         const HuffmanDecoder_t*   h,
 356         DCTCoefficientsContext_t* ctx,
 357         INT32                     index)
 358 {
 359         INITIATE_BITS
 360
 361         INT32 count = ctx->BlocksCoded[index];
 362
 363         while (count > 0) {
 364                 INT32 i, run = 0, coeff = 0;
 365
 366                 if (ctx->EOB_Run == 0) {
 367                         INT32 token = -1;
 368                         INT32 bits  = 0;
 369                         INT32 rbits = 0;
 370
 371                         UINT32 code = 0;
 372
 373                         LOAD_BITS
 374
 375                         if (h->LookupBits > 0) {
 376                                 INT32 len;
 377
 378                                 code = GET_BITS(h->LookupBits);
 379                                 len  = h->LookupLength[code];
 380
 381                                 if (len > 0) {
 382                                         RETIRE_BITS(len)
 383                                         token = h->LookupToken[code];
 384
 385                                 } else {
 386                                         RETIRE_BITS(h->LookupBits)
 387                                         rbits = bits = h->LookupBits;
 388                                 }
 389                         }
 390
 391                         for (; token < 0 && bits < BITS_COUNT; bits++) {
 392                                 INT32 es = h->Count[bits], idx;
 393                                 if (es < 0) {
 394                                         break;
 395                                 }
 396
 397                                 idx = h->Index[bits];
 398                                 if (idx >= 0) {
 399                                         INT32 len = bits + 1 - rbits;
 400
 401                                         const UINT32* s = h->Code + idx;
 402                                         const UINT32* e = s + es;
 403
 404                                         LOAD_BITS
 405                                         code = (code << len) | GET_BITS(len);
 406                                         RETIRE_BITS(len)
 407
 408                                         rbits = bits + 1;
 409
 410                                         while (s < e) {
 411                                                 const UINT32* x = s + (e - s) / 2;
 412                                                 if (code == *x) {
 413                                                         token = h->Token[x - h->Code];
 414                                                         break;
 415                                                 }
 416
 417                                                 if (code < *x) {
 418                                                         e = x;
 419                                                 } else {
 420                                                         s = x + 1;
 421                                                 }
 422                                         }
 423                                 }
 424                         }
 425
 426                         if (token >= 0 && token < 7) {
 427                                 INT32 blen = EOB_BITS_LEN[token];
 428                                 ctx->EOB_Run = EOB_RUN_BASE[token];
 429                                 if (blen > 0) {
 430                                         INT32 x;
 431                                         FETCH_BITS(x, blen)
 432                                         ctx->EOB_Run += x;
 433                                 }
 434
 435                                 coeff = 0;
 436                                 run   = 0;
 437
 438                         } else if (token >= 7 && token < 32) {
 439                                 INT32 clen = COEFF_BITS_LEN[token - 7];
 440                                 INT32 rlen = RUN_BITS_LEN  [token - 7];
 441
 442                                 coeff = COEFF_BASE[token - 7];
 443                                 if (clen > 0) {
 444                                         INT32 sign;
 445                                         FETCH_BITS_I(sign, 1)
 446                                         sign = COEFF_SIGN[sign];
 447                                         if (clen > 1) {
 448                                                 INT32 x;
 449                                                 clen--;
 450                                                 FETCH_BITS(x, clen)
 451                                                 coeff = sign * (coeff + x);
 452                                         } else {
 453                                                 coeff *= sign;
 454                                         }
 455                                 }
 456
 457                                 run = RUN_BASE[token - 7];
 458                                 if (rlen > 0) {
 459                                         INT32 x;
 460                                         FETCH_BITS(x, rlen)
 461                                         run += x;
 462                                 }
 463
 464                         } else {
 465                                 return FALSE;
 466                         }
 467                 }
 468
 469                 if (ctx->EOB_Run == 0) {
 470                         *((ctx->Run  )++) = run;
 471                         *((ctx->Coeff)++) = coeff;
 472
 473                         if (index + run + 1 > 64) {
 474                                 return FALSE;
 475                         }
 476
 477                         for (i = index + 1; i < index + run + 1; i++) {
 478                                 ctx->BlocksCoded[i] -= 1;
 479                         }
 480
 481                         count -= 1;
 482
 483                 } else {
 484                         INT32 eob = ctx->EOB_Run;
 485
 486                         if (eob > count) {
 487                                 eob = count;
 488                         }
 489
 490                         *((ctx->Run  )++) = -1;
 491                         *((ctx->Coeff)++) = eob;
 492
 493                         for (i = index + 1; i < 64; i++) {
 494                                 ctx->BlocksCoded[i] -= eob;
 495                         }
 496
 497                         ctx->EOB_Run -= eob;
 498
 499                         count -= eob;
 500                 }
 501         }
 502
 503         FINALIZE_BITS
 504
 505         if (REST_BITS < 0) {
 506                 return FALSE;
 507         }
 508
 509         return TRUE;
 510 }
 511
 512 static BOOL FrameDecoder_DecodeDCTCoefficients(
 513         FrameDecoder_t* t,
 514         BitReader_t*    d)
 515 {
 516         INT32 i, j, k;
 517
 518         const HuffmanDecoder_t* huff[3];
 519
 520         INT32 index = 0;
 521
 522         INT32 hy, hc;
 523
 524         DCTCoefficientsContext_t ctx = { 0 };
 525
 526         INT32 Coded[3][64];
 527
 528         ctx.Run   = t->DCTRun;
 529         ctx.Coeff = t->DCTCoeff;
 530
 531         for (i = 0; i < 64; i++) {
 532                 Coded[0][i] = t->BlocksCoded[0];
 533                 Coded[1][i] = t->BlocksCoded[1];
 534                 Coded[2][i] = t->BlocksCoded[2];
 535         }
 536
 537         for (i = 0; i < 5; i++) {
 538                 if (i < 2) {
 539                         INITIATE_BITS
 540                         FETCH_BITS_I(hy, 4);
 541                         FETCH_BITS_I(hc, 4);
 542                         FINALIZE_BITS
 543                 }
 544
 545                 huff[0] = t->Setup->Huffman + i * 0x10 + hy;
 546                 huff[1] = t->Setup->Huffman + i * 0x10 + hc;
 547                 huff[2] = huff[1];
 548
 549                 for (j = 0; j < COEFFS[i]; j++, index++) {
 550                         for (k = 0; k < 3; k++) {
 551                                 t->BRun  [k][index] = ctx.Run;
 552                                 t->BCoeff[k][index] = ctx.Coeff;
 553
 554                                 ctx.BlocksCoded = Coded[k];
 555
 556                                 if (!FrameDecoder_DecodeBlocks(
 557                                         t,
 558                                         d,
 559                                         huff[k],
 560                                         &ctx,
 561                                         index)) {
 562                                         return FALSE;
 563                                 }
 564                         }
 565                 }
 566         }
 567
 568         return TRUE;
 569 }
 570
 571 /* */
 572
 573 static BOOL FrameDecoder_Decode(
 574         FrameDecoder_t* t,
 575         const VOID*     p,
 576         SIZE_T          size)
 577 {
 578         BitReader_t d;
 579
 580         QT_BitReader_Initialize(&d, p, size);
 581
 582         if (!FrameHeader_Decode(&(t->Header), &d)) {
 583                 return FALSE;
 584         }
 585
 586         /* */
 587
 588         if (t->Header.Type == 0) { /* Intra */
 589                 memset(t->Count, 0, sizeof(UINT8) * t->Index->Blocks);
 590
 591                 memset(t->BMode, 1, t->Index->Blocks);
 592
 593                 t->BlocksCoded[0] = t->Index->BC[0];
 594                 t->BlocksCoded[1] = t->Index->BC[1];
 595                 t->BlocksCoded[2] = t->Index->BC[2];
 596
 597         } else {
 598                 if (!FrameDecoder_DecodeCodedBlockFlag(t, &d)) {
 599                         return FALSE;
 600                 }
 601
 602                 if (!FrameDecoder_DecodeMacroBlockCodingModes(t, &d)) {
 603                         return FALSE;
 604                 }
 605
 606                 if (!FrameDecoder_DecodeMotionVectors(t, &d)) {
 607                         return FALSE;
 608                 }
 609         }
 610
 611         if (!FrameDecoder_DecodeDCTCoefficients(t, &d)) {
 612                 return FALSE;
 613         }
 614
 615         /* */
 616
 617         DecodeDCCoefficients(t);
 618
 619 #if 0
 620         {
 621                 INT32 i;
 622                 INT32 x, y;
 623
 624                 const INT16* dc = t->DC;
 625
 626                 for (i = 0; i < 3; i++) {
 627                         INT32 bx = t->Index->BX[i];
 628                         INT32 by = t->Index->BY[i];
 629
 630                         printf("DC: %d\n", i);
 631                         for (y = 0; y < by; y++) {
 632                                 for (x = 0; x < bx; x++, dc++) {
 633                                         if (x > 0) {
 634                                                 printf(" ");
 635                                         }
 636                                         printf("%d", *dc);
 637                                 }
 638                                 printf("\n");
 639                         }
 640                 }
 641         }
 642 #endif
 643
 644         /* */
 645
 646         UndoDCPrediction(t);
 647
 648         {
 649                 INT32 i;
 650                 INT32 x, y;
 651
 652                 const INT16* dc = t->DC;
 653
 654                 for (i = 0; i < 3; i++) {
 655                         INT32 bx = t->Index->BX[i];
 656                         INT32 by = t->Index->BY[i];
 657
 658                         printf("DC: %d\n", i);
 659                         for (y = 0; y < by; y++) {
 660                                 for (x = 0; x < bx; x++, dc++) {
 661                                         if (x > 0) {
 662                                                 printf(" ");
 663                                         }
 664                                         printf("%d", *dc);
 665                                 }
 666                                 printf("\n");
 667                         }
 668                 }
 669         }
 670
 671         /* */
 672
 673         return TRUE;
 674 }
 675
 676 /* */
 677
 678 #undef FrameHeader_Decode
 679
 680 #undef FrameDecoder_DecodeCodedBlockFlag
 681 #undef FrameDecoder_DecodeMacroBlockCodingModes
 682 #undef FrameDecoder_DecodeMotionVectors
 683
 684 #undef FrameDecoder_DecodeBlocks
 685 #undef FrameDecoder_DecodeDCTCoefficients
 686
 687 #undef FrameDecoder_Decode
 688
 689 /* */
 690