1/* 2 * ScreenPressor version 3 decoder 3 * 4 * Copyright (c) 2017 Paul B Mahol 5 * 6 * This file is part of FFmpeg. 7 * 8 * FFmpeg is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU Lesser General Public 10 * License as published by the Free Software Foundation; either 11 * version 2.1 of the License, or (at your option) any later version. 12 * 13 * FFmpeg is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 * Lesser General Public License for more details. 17 * 18 * You should have received a copy of the GNU Lesser General Public 19 * License along with FFmpeg; if not, write to the Free Software 20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 21 */ 22 23#include <stdio.h> 24#include <stdlib.h> 25#include <string.h> 26 27#include "libavutil/qsort.h" 28 29#include "avcodec.h" 30#include "bytestream.h" 31#include "internal.h" 32#include "scpr.h" 33 34static void renew_table3(uint32_t nsym, uint32_t *cntsum, 35 uint16_t *freqs, uint16_t *freqs1, 36 uint16_t *cnts, uint8_t *dectab) 37{ 38 uint32_t a = 0, b = 4096 / nsym, c = b - (b >> 1); 39 40 *cntsum = c * nsym; 41 42 for (int d = 0; d < nsym; d++) { 43 freqs[d] = b; 44 freqs1[d] = a; 45 cnts[d] = c; 46 for (int q = a + 128 - 1 >> 7, f = (a + b - 1 >> 7) + 1; q < f; q++) 47 dectab[q] = d; 48 49 a += b; 50 } 51} 52 53static void reinit_tables3(SCPRContext * s) 54{ 55 for (int i = 0; i < 3; i++) { 56 for (int j = 0; j < 4096; j++) { 57 PixelModel3 *m = &s->pixel_model3[i][j]; 58 m->type = 0; 59 } 60 } 61 62 for (int i = 0; i < 6; i++) { 63 renew_table3(256, &s->run_model3[i].cntsum, 64 s->run_model3[i].freqs[0], s->run_model3[i].freqs[1], 65 s->run_model3[i].cnts, s->run_model3[i].dectab); 66 } 67 68 renew_table3(256, &s->range_model3.cntsum, 69 s->range_model3.freqs[0], s->range_model3.freqs[1], 70 s->range_model3.cnts, s->range_model3.dectab); 71 72 renew_table3(5, &s->fill_model3.cntsum, 73 s->fill_model3.freqs[0], s->fill_model3.freqs[1], 74 s->fill_model3.cnts, s->fill_model3.dectab); 75 76 renew_table3(256, &s->count_model3.cntsum, 77 s->count_model3.freqs[0], s->count_model3.freqs[1], 78 s->count_model3.cnts, s->count_model3.dectab); 79 80 for (int i = 0; i < 4; i++) { 81 renew_table3(16, &s->sxy_model3[i].cntsum, 82 s->sxy_model3[i].freqs[0], s->sxy_model3[i].freqs[1], 83 s->sxy_model3[i].cnts, s->sxy_model3[i].dectab); 84 } 85 86 for (int i = 0; i < 2; i++) { 87 renew_table3(512, &s->mv_model3[i].cntsum, 88 s->mv_model3[i].freqs[0], s->mv_model3[i].freqs[1], 89 s->mv_model3[i].cnts, s->mv_model3[i].dectab); 90 } 91 92 for (int i = 0; i < 6; i++) { 93 renew_table3(6, &s->op_model3[i].cntsum, 94 s->op_model3[i].freqs[0], s->op_model3[i].freqs[1], 95 s->op_model3[i].cnts, s->op_model3[i].dectab); 96 } 97} 98 99static int decode3(GetByteContext *gb, RangeCoder *rc, uint32_t a, uint32_t b) 100{ 101 uint32_t code = a * (rc->code >> 12) + (rc->code & 0xFFF) - b; 102 103 while (code < 0x800000 && bytestream2_get_bytes_left(gb) > 0) 104 code = bytestream2_get_byteu(gb) | (code << 8); 105 rc->code = code; 106 107 return 0; 108} 109 110static void rescale(PixelModel3 *m, int *totfr) 111{ 112 uint32_t a; 113 114 a = 256 - m->size; 115 for (int b = 0; b < m->size; b++) { 116 m->freqs[b] -= m->freqs[b] >> 1; 117 a += m->freqs[b]; 118 } 119 120 *totfr = a; 121} 122 123static int add_symbol(PixelModel3 *m, int index, uint32_t symbol, int *totfr, int max) 124{ 125 if (m->size == max) 126 return 0; 127 128 for (int c = m->size - 1; c >= index; c--) { 129 m->symbols[c + 1] = m->symbols[c]; 130 m->freqs[c + 1] = m->freqs[c]; 131 } 132 133 m->symbols[index] = symbol; 134 m->freqs[index] = 50; 135 m->size++; 136 137 if (m->maxpos >= index) 138 m->maxpos++; 139 140 *totfr += 50; 141 if (*totfr + 50 > 4096) 142 rescale(m, totfr); 143 144 return 1; 145} 146 147static int decode_adaptive45(PixelModel3 *m, int rccode, uint32_t *value, 148 uint16_t *a, uint16_t *b, uint32_t *c, int max) 149{ 150 uint32_t q, g, maxpos, d, e = *c, totfr = *c; 151 int ret; 152 153 for (d = 0; e <= 2048; d++) 154 e <<= 1; 155 maxpos = m->maxpos; 156 rccode >>= d; 157 *c = m->freqs[maxpos]; 158 m->freqs[maxpos] += 4096 - e >> d; 159 160 for (q = 0, g = 0, e = 0; q < m->size; q++) { 161 uint32_t f = m->symbols[q]; 162 uint32_t p = e + f - g; 163 uint32_t k = m->freqs[q]; 164 165 if (rccode < p) { 166 *value = rccode - e + g; 167 *b = rccode << d; 168 *a = 1 << d; 169 m->freqs[maxpos] = *c; 170 ret = add_symbol(m, q, *value, &totfr, max); 171 *c = totfr; 172 return ret; 173 } 174 175 if (p + k > rccode) { 176 *value = f; 177 e += *value - g; 178 *b = e << d; 179 *a = k << d; 180 m->freqs[maxpos] = *c; 181 m->freqs[q] += 50; 182 totfr += 50; 183 if ((q != maxpos) && (m->freqs[q] > m->freqs[maxpos])) 184 m->maxpos = q; 185 if (totfr + 50 > 4096) 186 rescale(m, &totfr); 187 *c = totfr; 188 return 1; 189 } 190 191 e += f - g + k; 192 g = f + 1; 193 } 194 195 m->freqs[maxpos] = *c; 196 *value = g + rccode - e; 197 *b = rccode << d; 198 *a = 1 << d; 199 ret = add_symbol(m, q, *value, &totfr, max); 200 *c = totfr; 201 return ret; 202} 203 204static int update_model6_to_7(PixelModel3 *m) 205{ 206 PixelModel3 n = {0}; 207 int c, d, e, f, k, p, length, i, j, index; 208 uint16_t *freqs, *freqs1, *cnts; 209 210 n.type = 7; 211 212 length = m->length; 213 freqs = n.freqs; 214 freqs1 = n.freqs1; 215 cnts = n.cnts; 216 n.cntsum = m->cnts[length]; 217 for (i = 0; i < length; i++) { 218 if (!m->cnts[i]) 219 continue; 220 index = m->symbols[i]; 221 freqs[index] = m->freqs[2 * i]; 222 freqs1[index] = m->freqs[2 * i + 1]; 223 cnts[index] = m->cnts[i]; 224 } 225 c = 1 << m->fshift; 226 d = c - (c >> 1); 227 for (j = 0, e = 0; j < 256; j++) { 228 f = freqs[j]; 229 if (!f) { 230 f = c; 231 freqs[j] = c; 232 freqs1[j] = e; 233 cnts[j] = d; 234 } 235 p = (e + 127) >> 7; 236 k = ((f + e - 1) >> 7) + 1; 237 if (k > FF_ARRAY_ELEMS(n.dectab)) 238 return AVERROR_INVALIDDATA; 239 for (i = 0; i < k - p; i++) 240 n.dectab[p + i] = j; 241 e += f; 242 } 243 244 memcpy(m, &n, sizeof(n)); 245 246 return 0; 247} 248 249static void calc_sum(PixelModel3 *m) 250{ 251 uint32_t a; 252 int len; 253 254 len = m->length; 255 a = 256 - m->size << (m->fshift > 0 ? m->fshift - 1 : 0); 256 for (int c = 0; c < len; c++) 257 a += m->cnts[c]; 258 m->cnts[len] = a; 259} 260 261static void rescale_dec(PixelModel3 *m) 262{ 263 uint16_t cnts[256] = {0}; 264 uint16_t freqs[512] = {0}; 265 int b, c, e, g; 266 uint32_t a; 267 268 for (a = 1 << (0 < m->fshift ? m->fshift - 1 : 0), b = 0; b < 256; b++) 269 cnts[b] = a; 270 271 for (a = 0, b = m->size; a < b; a++) 272 cnts[m->symbols[a]] = m->cnts[a]; 273 274 for (b = a = 0; b < 256; b++) { 275 freqs[2 * b] = cnts[b]; 276 freqs[2 * b + 1] = a; 277 a += cnts[b]; 278 } 279 280 if (m->fshift > 0) 281 m->fshift--; 282 283 a = 256 - m->size << (0 < m->fshift ? m->fshift - 1 : 0); 284 for (b = 0, c = m->size; b < c; b++) { 285 m->cnts[b] -= m->cnts[b] >> 1; 286 a = a + m->cnts[b]; 287 e = m->symbols[b]; 288 g = freqs[2 * e + 1]; 289 m->freqs[2 * b] = freqs[2 * e]; 290 m->freqs[2 * b + 1] = g; 291 } 292 m->cnts[m->length] = a; 293} 294 295static int update_model5_to_6(PixelModel3 *m, uint8_t value) 296{ 297 PixelModel3 n = {0}; 298 int c, d, e, f, g, k, q, p; 299 300 n.type = 6; 301 n.length = 32; 302 303 for (c = m->size, d = 256 - c, e = 0; e < c; e++) 304 d = d + m->freqs[e]; 305 306 for (e = 0; d <= 2048; e++) 307 d <<= 1; 308 309 for (q = d = 0, g = q = 0; g < c; g++) { 310 p = m->symbols[g]; 311 d = d + (p - q); 312 q = m->freqs[g]; 313 k = q << e; 314 n.freqs[2 * g] = k; 315 n.freqs[2 * g + 1] = d << e; 316 n.cnts[g] = k - (k >> 1); 317 n.symbols[g] = p; 318 d += q; 319 q = p + 1; 320 } 321 322 n.fshift = e; 323 e = 1 << n.fshift; 324 d = 0; 325 if (value > 0) { 326 d = -1; 327 for (p = f = g = 0; p < c; p++) { 328 k = n.symbols[p]; 329 if (k > d && k < value) { 330 d = k; 331 g = n.freqs[2 * p]; 332 f = n.freqs[2 * p + 1]; 333 } 334 } 335 d = 0 < g ? f + g + (value - d - 1 << n.fshift) : value << n.fshift; 336 } 337 n.freqs[2 * c] = e; 338 n.freqs[2 * c + 1] = d; 339 n.cnts[c] = e - (e >> 1); 340 n.symbols[c] = value; 341 n.size = c + 1; 342 e = 25 << n.fshift; 343 n.cnts[c] += e; 344 n.cnts[32] += e; 345 if (n.cnts[32] + e > 4096) 346 rescale_dec(&n); 347 348 calc_sum(&n); 349 for (c = 0, e = n.size - 1; c < e; c++) { 350 for (g = c + 1, f = n.size; g < f; g++) { 351 if (q = n.freqs[2 * g], k = n.freqs[2 * c], q > k) { 352 int l = n.freqs[2 * c + 1]; 353 int h = n.freqs[2 * g + 1]; 354 n.freqs[2 * c] = q; 355 n.freqs[2 * c + 1] = h; 356 n.freqs[2 * g] = k; 357 n.freqs[2 * g + 1] = l; 358 FFSWAP(uint16_t, n.cnts[c], n.cnts[g]); 359 FFSWAP(uint8_t, n.symbols[c], n.symbols[g]); 360 } 361 } 362 } 363 364 memcpy(m, &n, sizeof(n)); 365 366 return 0; 367} 368 369static void grow_dec(PixelModel3 *m) 370{ 371 int a; 372 373 a = 2 * m->length; 374 m->cnts[2 * m->length] = m->cnts[m->length]; 375 m->length = a; 376} 377 378static int add_dec(PixelModel3 *m, int sym, int f1, int f2) 379{ 380 int size; 381 382 if (m->size >= 40 || m->size >= m->length) 383 return -1; 384 385 size = m->size; 386 m->symbols[size] = sym; 387 m->freqs[2 * size] = f1; 388 m->freqs[2 * size + 1] = f2; 389 m->cnts[size] = f1 - (f1 >> 1); 390 m->size++; 391 392 return size; 393} 394 395static void incr_cntdec(PixelModel3 *m, int a) 396{ 397 int b, len, d, e, g; 398 399 b = 25 << m->fshift; 400 len = m->length; 401 m->cnts[a] += b; 402 m->cnts[len] += b; 403 if (a > 0 && m->cnts[a] > m->cnts[a - 1]) { 404 FFSWAP(uint16_t, m->cnts[a], m->cnts[a - 1]); 405 d = m->freqs[2 * a]; 406 e = m->freqs[2 * a + 1]; 407 g = m->freqs[2 * (a - 1) + 1]; 408 m->freqs[2 * a] = m->freqs[2 * (a - 1)]; 409 m->freqs[2 * a + 1] = g; 410 g = a - 1; 411 m->freqs[2 * g] = d; 412 m->freqs[2 * g + 1] = e; 413 FFSWAP(uint8_t, m->symbols[a], m->symbols[a - 1]); 414 } 415 416 if (m->cnts[len] + b > 4096) 417 rescale_dec(m); 418} 419 420static int decode_adaptive6(PixelModel3 *m, uint32_t code, uint32_t *value, 421 uint16_t *a, uint16_t *b) 422{ 423 int c, d, e, f, g, q; 424 425 for (c = 0, d = 0, e = 0, f = 0, g = 0, q = m->size; g < q; g++) { 426 uint32_t p = m->freqs[2 * g + 1]; 427 428 if (p <= code) { 429 uint32_t k = m->freqs[2 * g]; 430 431 if (p + k > code) { 432 *value = m->symbols[g]; 433 *a = k; 434 *b = p; 435 incr_cntdec(m, g); 436 return 1; 437 } 438 439 if (p >= d) { 440 c = k; 441 d = p; 442 e = m->symbols[g]; 443 } 444 } 445 } 446 447 g = 1 << m->fshift; 448 q = f = 0; 449 450 if (c > 0) { 451 f = code - (d + c) >> m->fshift; 452 q = f + e + 1; 453 f = d + c + (f << m->fshift); 454 } else { 455 q = code >> m->fshift; 456 f = q << m->fshift; 457 } 458 459 *a = g; 460 *b = f; 461 *value = q; 462 463 c = add_dec(m, q, g, f); 464 if (c < 0) { 465 if (m->length == 64) 466 return 0; 467 grow_dec(m); 468 c = add_dec(m, q, g, f); 469 } 470 471 incr_cntdec(m, c); 472 return 1; 473} 474 475static int cmpbytes(const void *p1, const void *p2) 476{ 477 int left = *(const uint8_t *)p1; 478 int right = *(const uint8_t *)p2; 479 return FFDIFFSIGN(left, right); 480} 481 482static int update_model1_to_2(PixelModel3 *m, uint32_t val) 483{ 484 PixelModel3 n = {0}; 485 int i, b; 486 487 n.type = 2; 488 n.size = m->size + 1; 489 b = m->size; 490 for (i = 0; i < b; i++) 491 n.symbols[i] = m->symbols[i]; 492 n.symbols[b] = val; 493 494 memcpy(m, &n, sizeof(n)); 495 496 return 0; 497} 498 499static int update_model1_to_4(PixelModel3 *m, uint32_t val) 500{ 501 PixelModel3 n = {0}; 502 int size, i; 503 504 size = m->size; 505 n.type = 4; 506 n.size = size; 507 for (i = 0; i < n.size; i++) { 508 n.symbols[i] = m->symbols[i]; 509 } 510 AV_QSORT(n.symbols, size, uint8_t, cmpbytes); 511 for (i = 0; i < n.size; i++) { 512 if (val == n.symbols[i]) { 513 n.freqs[i] = 100; 514 n.maxpos = i; 515 } else { 516 n.freqs[i] = 50; 517 } 518 } 519 520 memcpy(m, &n, sizeof(n)); 521 522 return 0; 523} 524 525static int update_model1_to_5(PixelModel3 *m, uint32_t val) 526{ 527 int i, size, freqs; 528 uint32_t a; 529 530 update_model1_to_4(m, val); 531 size = m->size; 532 a = 256 - size; 533 for (i = 0; i < size; i++, a += freqs) 534 freqs = m->freqs[i]; 535 m->type = 5; 536 m->cntsum = a; 537 538 return 0; 539} 540 541static int decode_static1(PixelModel3 *m, uint32_t val) 542{ 543 uint32_t size; 544 545 size = m->size; 546 for (int i = 0; i < size; i++) { 547 if (val == m->symbols[i]) { 548 if (size <= 4) 549 return update_model1_to_4(m, val); 550 else 551 return update_model1_to_5(m, val); 552 } 553 } 554 555 if (size >= 14) 556 return update_model1_to_2(m, val); 557 558 m->symbols[size] = val; 559 m->size++; 560 return 0; 561} 562 563static int update_model2_to_6(PixelModel3 *m, uint8_t value, int a4) 564{ 565 PixelModel3 n = {0}; 566 int c, d, e, f, g, q; 567 568 n.type = 6; 569 n.length = a4; 570 571 memset(n.symbols, 1u, a4); 572 573 c = m->size; 574 d = 256 - c + (64 * c + 64); 575 for (e = 0; d <= 2048; e++) { 576 d <<= 1; 577 } 578 579 g = q = 0; 580 AV_QSORT(m->symbols, c, uint8_t, cmpbytes); 581 for (f = d = 0; f < c; f++) { 582 int p = f; 583 int k = m->symbols[p]; 584 int l; 585 g = g + (k - q); 586 587 if (k == value) { 588 d = p; 589 q = 128; 590 } else { 591 q = 64; 592 } 593 l = q << e; 594 n.freqs[2 * p] = l; 595 n.freqs[2 * p + 1] = g << e; 596 n.symbols[p] = k; 597 n.cnts[p] = l - (l >> 1); 598 g += q; 599 q = k + 1; 600 } 601 n.size = c; 602 n.fshift = e; 603 calc_sum(&n); 604 605 if (d > 0) { 606 c = n.freqs[0]; 607 e = n.freqs[1]; 608 g = n.freqs[2 * d + 1]; 609 n.freqs[0] = n.freqs[2 * d]; 610 n.freqs[1] = g; 611 n.freqs[2 * d] = c; 612 n.freqs[2 * d + 1] = e; 613 FFSWAP(uint16_t, n.cnts[0], n.cnts[d]); 614 FFSWAP(uint8_t, n.symbols[0], n.symbols[d]); 615 } 616 617 memcpy(m, &n, sizeof(n)); 618 619 return 0; 620} 621 622static int update_model2_to_3(PixelModel3 *m, uint32_t val) 623{ 624 PixelModel3 n = {0}; 625 uint32_t size; 626 627 n.type = 3; 628 n.size = m->size + 1; 629 630 size = m->size; 631 for (int i = 0; i < size; i++) 632 n.symbols[i] = m->symbols[i]; 633 n.symbols[size] = val; 634 635 memcpy(m, &n, sizeof(n)); 636 637 return 0; 638} 639 640static int decode_static2(PixelModel3 *m, uint32_t val) 641{ 642 uint32_t size; 643 644 size = m->size; 645 for (int i = 0; i < size; i++) { 646 if (val == m->symbols[i]) { 647 int a; 648 649 if (m->size <= 32) 650 a = 32; 651 else 652 a = 64; 653 return update_model2_to_6(m, val, a); 654 } 655 } 656 657 if (size >= 64) 658 return update_model2_to_3(m, val); 659 660 m->symbols[size] = val; 661 m->size++; 662 663 return 0; 664} 665 666static int update_model3_to_7(PixelModel3 *m, uint8_t value) 667{ 668 PixelModel3 n = {0}; 669 int c, d, e, f, g, q; 670 671 n.type = 7; 672 673 for (c = 0; c < 256; c++) { 674 d = c; 675 n.freqs[d] = 1; 676 n.cnts[d] = 1; 677 } 678 679 for (c = m->size, d = (4096 - (256 - c)) / (c + 1) | 0, e = d - (d >> 1), g = 0; g < c;) { 680 q = g++; 681 q = m->symbols[q]; 682 n.freqs[q] = d; 683 n.cnts[q] = e; 684 } 685 n.freqs[value] += d; 686 n.cnts[value] += 16; 687 for (d = c = n.cntsum = 0; 256 > d; d++) { 688 e = d; 689 n.cntsum += n.cnts[e]; 690 n.freqs1[e] = c; 691 g = n.freqs[e]; 692 f = (c + g - 1 >> 7) + 1; 693 if (f > FF_ARRAY_ELEMS(n.dectab)) 694 return AVERROR_INVALIDDATA; 695 for (q = c + 128 - 1 >> 7; q < f; q++) { 696 n.dectab[q] = e; 697 } 698 c += g; 699 } 700 701 memcpy(m, &n, sizeof(n)); 702 703 return 0; 704} 705 706static int decode_static3(PixelModel3 *m, uint32_t val) 707{ 708 uint32_t size = m->size; 709 710 for (int i = 0; i < size; i++) { 711 if (val == m->symbols[i]) 712 return update_model3_to_7(m, val); 713 } 714 715 if (size >= 256) 716 return 0; 717 718 m->symbols[size] = val; 719 m->size++; 720 return 0; 721} 722 723static void sync_code3(GetByteContext *gb, RangeCoder *rc) 724{ 725 rc->code1++; 726 if (rc->code1 == 0x20000) { 727 rc->code = bytestream2_get_le32(gb); 728 rc->code1 = 0; 729 } 730} 731 732static int decode_value3(SCPRContext *s, uint32_t max, uint32_t *cntsum, 733 uint16_t *freqs1, uint16_t *freqs2, 734 uint16_t *cnts, uint8_t *dectable, 735 uint32_t *value) 736{ 737 GetByteContext *gb = &s->gb; 738 RangeCoder *rc = &s->rc; 739 uint32_t r, y, a, b, e, g, q; 740 741 r = dectable[(rc->code & 0xFFFu) >> 7]; 742 if (r < max) { 743 while (freqs2[r + 1] <= (rc->code & 0xFFF)) { 744 if (++r >= max) 745 break; 746 } 747 } 748 749 if (r > max) 750 return AVERROR_INVALIDDATA; 751 752 cnts[r] += 16; 753 a = freqs1[r]; 754 b = freqs2[r]; 755 *cntsum += 16; 756 if (*cntsum + 16 > 4096) { 757 *cntsum = 0; 758 for (int c = 0, i = 0; i < max + 1; i++) { 759 e = cnts[i]; 760 freqs2[i] = c; 761 freqs1[i] = e; 762 g = (c + 127) >> 7; 763 c += e; 764 q = ((c - 1) >> 7) + 1; 765 if (q > g) { 766 for (int j = 0; j < q - g; j++) 767 dectable[j + g] = i; 768 } 769 y = e - (e >> 1); 770 cnts[i] = y; 771 *cntsum += y; 772 } 773 } 774 775 decode3(gb, rc, a, b); 776 sync_code3(gb, rc); 777 778 *value = r; 779 780 return 0; 781} 782 783static void calc_sum5(PixelModel3 *m) 784{ 785 uint32_t a; 786 787 a = 256 - m->size; 788 for (int b = 0; b < m->size; b++) 789 a += m->freqs[b]; 790 m->cntsum = a; 791} 792 793static int update_model4_to_5(PixelModel3 *m, uint32_t value) 794{ 795 PixelModel3 n = {0}; 796 int c, e, g, totfr; 797 798 n.type = 5; 799 800 for (c = 0, e = 0; c < m->size && m->symbols[c] < value; c++) { 801 n.symbols[c] = m->symbols[c]; 802 e += n.freqs[c] = m->freqs[c]; 803 } 804 805 g = c; 806 n.symbols[g] = value; 807 e += n.freqs[g++] = 50; 808 for (; c < m->size; g++, c++) { 809 n.symbols[g] = m->symbols[c]; 810 e += n.freqs[g] = m->freqs[c]; 811 } 812 n.size = m->size + 1; 813 if (e > 4096) 814 rescale(&n, &totfr); 815 816 calc_sum5(&n); 817 818 memcpy(m, &n, sizeof(n)); 819 820 return 0; 821} 822 823static int decode_unit3(SCPRContext *s, PixelModel3 *m, uint32_t code, uint32_t *value) 824{ 825 GetByteContext *gb = &s->gb; 826 RangeCoder *rc = &s->rc; 827 uint16_t a = 0, b = 0; 828 uint32_t param; 829 int type; 830 int ret; 831 832 type = m->type; 833 switch (type) { 834 case 0: 835 *value = bytestream2_get_byte(&s->gb); 836 m->type = 1; 837 m->size = 1; 838 m->symbols[0] = *value; 839 sync_code3(gb, rc); 840 break; 841 case 1: 842 *value = bytestream2_get_byte(&s->gb); 843 decode_static1(m, *value); 844 sync_code3(gb, rc); 845 break; 846 case 2: 847 *value = bytestream2_get_byte(&s->gb); 848 decode_static2(m, *value); 849 sync_code3(gb, rc); 850 break; 851 case 3: 852 *value = bytestream2_get_byte(&s->gb); 853 ret = decode_static3(m, *value); 854 if (ret < 0) 855 return AVERROR_INVALIDDATA; 856 sync_code3(gb, rc); 857 break; 858 case 4: 859 param = m->freqs[0] + m->freqs[1] + m->freqs[2] + m->freqs[3] + 256 - m->size; 860 if (!decode_adaptive45(m, code, value, &a, &b, ¶m, 4)) 861 update_model4_to_5(m, *value); 862 decode3(gb, rc, a, b); 863 sync_code3(gb, rc); 864 break; 865 case 5: 866 if (!decode_adaptive45(m, code, value, &a, &b, &m->cntsum, 16)) 867 update_model5_to_6(m, *value); 868 decode3(gb, rc, a, b); 869 sync_code3(gb, rc); 870 break; 871 case 6: 872 if (!decode_adaptive6(m, code, value, &a, &b)) { 873 ret = update_model6_to_7(m); 874 if (ret < 0) 875 return AVERROR_INVALIDDATA; 876 } 877 decode3(gb, rc, a, b); 878 sync_code3(gb, rc); 879 break; 880 case 7: 881 return decode_value3(s, 255, &m->cntsum, 882 m->freqs, m->freqs1, 883 m->cnts, m->dectab, value); 884 } 885 886 if (*value > 255) 887 return AVERROR_INVALIDDATA; 888 889 return 0; 890} 891 892static int decode_units3(SCPRContext * s, uint32_t *red, 893 uint32_t *green, uint32_t *blue, 894 int *cx, int *cx1) 895{ 896 RangeCoder *rc = &s->rc; 897 int ret; 898 899 ret = decode_unit3(s, &s->pixel_model3[0][*cx + *cx1], rc->code & 0xFFF, red); 900 if (ret < 0) 901 return ret; 902 903 *cx1 = (*cx << 6) & 0xFC0; 904 *cx = *red >> 2; 905 906 ret = decode_unit3(s, &s->pixel_model3[1][*cx + *cx1], rc->code & 0xFFF, green); 907 if (ret < 0) 908 return ret; 909 910 *cx1 = (*cx << 6) & 0xFC0; 911 *cx = *green >> 2; 912 913 ret = decode_unit3(s, &s->pixel_model3[2][*cx + *cx1], rc->code & 0xFFF, blue); 914 if (ret < 0) 915 return ret; 916 917 *cx1 = (*cx << 6) & 0xFC0; 918 *cx = *blue >> 2; 919 920 return 0; 921} 922 923static void init_rangecoder3(RangeCoder *rc, GetByteContext *gb) 924{ 925 rc->code = bytestream2_get_le32(gb); 926 rc->code1 = 0; 927} 928 929static int decompress_i3(AVCodecContext *avctx, uint32_t *dst, int linesize) 930{ 931 SCPRContext *s = avctx->priv_data; 932 GetByteContext *gb = &s->gb; 933 RangeCoder *rc = &s->rc; 934 int cx = 0, cx1 = 0, k = 0; 935 int run, off, y = 0, x = 0, ret; 936 uint32_t backstep = linesize - avctx->width; 937 uint32_t clr = 0, lx, ly, ptype, r, g, b; 938 939 bytestream2_skip(gb, 1); 940 init_rangecoder3(rc, gb); 941 reinit_tables3(s); 942 943 while (k < avctx->width + 1) { 944 ret = decode_units3(s, &r, &g, &b, &cx, &cx1); 945 if (ret < 0) 946 return ret; 947 ret = decode_value3(s, 255, &s->run_model3[0].cntsum, 948 s->run_model3[0].freqs[0], 949 s->run_model3[0].freqs[1], 950 s->run_model3[0].cnts, 951 s->run_model3[0].dectab, &run); 952 if (ret < 0) 953 return ret; 954 if (run <= 0) 955 return AVERROR_INVALIDDATA; 956 957 clr = (b << 16) + (g << 8) + r; 958 k += run; 959 while (run-- > 0) { 960 if (y >= avctx->height) 961 return AVERROR_INVALIDDATA; 962 963 dst[y * linesize + x] = clr; 964 lx = x; 965 ly = y; 966 x++; 967 if (x >= avctx->width) { 968 x = 0; 969 y++; 970 } 971 } 972 } 973 off = -linesize - 1; 974 ptype = 0; 975 976 while (x < avctx->width && y < avctx->height) { 977 ret = decode_value3(s, 5, &s->op_model3[ptype].cntsum, 978 s->op_model3[ptype].freqs[0], 979 s->op_model3[ptype].freqs[1], 980 s->op_model3[ptype].cnts, 981 s->op_model3[ptype].dectab, &ptype); 982 if (ret < 0) 983 return ret; 984 if (ptype == 0) { 985 ret = decode_units3(s, &r, &g, &b, &cx, &cx1); 986 if (ret < 0) 987 return ret; 988 clr = (b << 16) + (g << 8) + r; 989 } 990 if (ptype > 5) 991 return AVERROR_INVALIDDATA; 992 ret = decode_value3(s, 255, &s->run_model3[ptype].cntsum, 993 s->run_model3[ptype].freqs[0], 994 s->run_model3[ptype].freqs[1], 995 s->run_model3[ptype].cnts, 996 s->run_model3[ptype].dectab, &run); 997 if (ret < 0) 998 return ret; 999 if (run <= 0) 1000 return AVERROR_INVALIDDATA; 1001 1002 ret = decode_run_i(avctx, ptype, run, &x, &y, clr, 1003 dst, linesize, &lx, &ly, 1004 backstep, off, &cx, &cx1); 1005 if (ret < 0) 1006 return ret; 1007 } 1008 1009 return 0; 1010} 1011 1012static int decompress_p3(AVCodecContext *avctx, 1013 uint32_t *dst, int linesize, 1014 uint32_t *prev, int plinesize) 1015{ 1016 SCPRContext *s = avctx->priv_data; 1017 GetByteContext *gb = &s->gb; 1018 int ret, temp, min, max, x, y, cx = 0, cx1 = 0; 1019 int backstep = linesize - avctx->width; 1020 int mvx = 0, mvy = 0; 1021 1022 if (bytestream2_get_byte(gb) == 0) 1023 return 1; 1024 init_rangecoder3(&s->rc, gb); 1025 1026 ret = decode_value3(s, 255, &s->range_model3.cntsum, 1027 s->range_model3.freqs[0], 1028 s->range_model3.freqs[1], 1029 s->range_model3.cnts, 1030 s->range_model3.dectab, &min); 1031 ret |= decode_value3(s, 255, &s->range_model3.cntsum, 1032 s->range_model3.freqs[0], 1033 s->range_model3.freqs[1], 1034 s->range_model3.cnts, 1035 s->range_model3.dectab, &temp); 1036 if (ret < 0) 1037 return ret; 1038 1039 min += temp << 8; 1040 ret |= decode_value3(s, 255, &s->range_model3.cntsum, 1041 s->range_model3.freqs[0], 1042 s->range_model3.freqs[1], 1043 s->range_model3.cnts, 1044 s->range_model3.dectab, &max); 1045 ret |= decode_value3(s, 255, &s->range_model3.cntsum, 1046 s->range_model3.freqs[0], 1047 s->range_model3.freqs[1], 1048 s->range_model3.cnts, 1049 s->range_model3.dectab, &temp); 1050 if (ret < 0) 1051 return ret; 1052 1053 max += temp << 8; 1054 if (min > max || min >= s->nbcount) 1055 return AVERROR_INVALIDDATA; 1056 1057 memset(s->blocks, 0, sizeof(*s->blocks) * s->nbcount); 1058 1059 while (min <= max) { 1060 int fill, count; 1061 1062 ret = decode_value3(s, 4, &s->fill_model3.cntsum, 1063 s->fill_model3.freqs[0], 1064 s->fill_model3.freqs[1], 1065 s->fill_model3.cnts, 1066 s->fill_model3.dectab, &fill); 1067 ret |= decode_value3(s, 255, &s->count_model3.cntsum, 1068 s->count_model3.freqs[0], 1069 s->count_model3.freqs[1], 1070 s->count_model3.cnts, 1071 s->count_model3.dectab, &count); 1072 if (ret < 0) 1073 return ret; 1074 if (count <= 0) 1075 return AVERROR_INVALIDDATA; 1076 1077 while (min < s->nbcount && count-- > 0) { 1078 s->blocks[min++] = fill; 1079 } 1080 } 1081 1082 ret = av_frame_copy(s->current_frame, s->last_frame); 1083 if (ret < 0) 1084 return ret; 1085 1086 for (y = 0; y < s->nby; y++) { 1087 for (x = 0; x < s->nbx; x++) { 1088 int sy1 = 0, sy2 = 16, sx1 = 0, sx2 = 16; 1089 1090 if (s->blocks[y * s->nbx + x] == 0) 1091 continue; 1092 1093 if (((s->blocks[y * s->nbx + x] + 1) & 1) > 0) { 1094 ret = decode_value3(s, 15, &s->sxy_model3[0].cntsum, 1095 s->sxy_model3[0].freqs[0], 1096 s->sxy_model3[0].freqs[1], 1097 s->sxy_model3[0].cnts, 1098 s->sxy_model3[0].dectab, &sx1); 1099 ret |= decode_value3(s, 15, &s->sxy_model3[1].cntsum, 1100 s->sxy_model3[1].freqs[0], 1101 s->sxy_model3[1].freqs[1], 1102 s->sxy_model3[1].cnts, 1103 s->sxy_model3[1].dectab, &sy1); 1104 ret |= decode_value3(s, 15, &s->sxy_model3[2].cntsum, 1105 s->sxy_model3[2].freqs[0], 1106 s->sxy_model3[2].freqs[1], 1107 s->sxy_model3[2].cnts, 1108 s->sxy_model3[2].dectab, &sx2); 1109 ret |= decode_value3(s, 15, &s->sxy_model3[3].cntsum, 1110 s->sxy_model3[3].freqs[0], 1111 s->sxy_model3[3].freqs[1], 1112 s->sxy_model3[3].cnts, 1113 s->sxy_model3[3].dectab, &sy2); 1114 if (ret < 0) 1115 return ret; 1116 1117 sx2++; 1118 sy2++; 1119 } 1120 if (((s->blocks[y * s->nbx + x] + 3) & 2) > 0) { 1121 int i, a, b, c, j, by = y * 16, bx = x * 16; 1122 uint32_t code; 1123 1124 a = s->rc.code & 0xFFF; 1125 c = 1; 1126 1127 if (a < 0x800) 1128 c = 0; 1129 b = 2048; 1130 if (!c) 1131 b = 0; 1132 1133 code = a + ((s->rc.code >> 1) & 0xFFFFF800) - b; 1134 while (code < 0x800000 && bytestream2_get_bytes_left(gb) > 0) 1135 code = bytestream2_get_byteu(gb) | (code << 8); 1136 s->rc.code = code; 1137 1138 sync_code3(gb, &s->rc); 1139 1140 if (!c) { 1141 ret = decode_value3(s, 511, &s->mv_model3[0].cntsum, 1142 s->mv_model3[0].freqs[0], 1143 s->mv_model3[0].freqs[1], 1144 s->mv_model3[0].cnts, 1145 s->mv_model3[0].dectab, &mvx); 1146 ret |= decode_value3(s, 511, &s->mv_model3[1].cntsum, 1147 s->mv_model3[1].freqs[0], 1148 s->mv_model3[1].freqs[1], 1149 s->mv_model3[1].cnts, 1150 s->mv_model3[1].dectab, &mvy); 1151 if (ret < 0) 1152 return ret; 1153 1154 mvx -= 256; 1155 mvy -= 256; 1156 } 1157 1158 if (by + mvy + sy1 < 0 || bx + mvx + sx1 < 0 || 1159 by + mvy + sy1 >= avctx->height || bx + mvx + sx1 >= avctx->width) 1160 return AVERROR_INVALIDDATA; 1161 1162 for (i = 0; i < sy2 - sy1 && (by + sy1 + i) < avctx->height && (by + mvy + sy1 + i) < avctx->height; i++) { 1163 for (j = 0; j < sx2 - sx1 && (bx + sx1 + j) < avctx->width && (bx + mvx + sx1 + j) < avctx->width; j++) { 1164 dst[(by + i + sy1) * linesize + bx + sx1 + j] = prev[(by + mvy + sy1 + i) * plinesize + bx + sx1 + mvx + j]; 1165 } 1166 } 1167 } else { 1168 int run, bx = x * 16 + sx1, by = y * 16 + sy1; 1169 uint32_t clr, ptype = 0, r, g, b; 1170 1171 if (bx >= avctx->width) 1172 return AVERROR_INVALIDDATA; 1173 1174 for (; by < y * 16 + sy2 && by < avctx->height;) { 1175 ret = decode_value3(s, 5, &s->op_model3[ptype].cntsum, 1176 s->op_model3[ptype].freqs[0], 1177 s->op_model3[ptype].freqs[1], 1178 s->op_model3[ptype].cnts, 1179 s->op_model3[ptype].dectab, &ptype); 1180 if (ret < 0) 1181 return ret; 1182 if (ptype == 0) { 1183 ret = decode_units3(s, &r, &g, &b, &cx, &cx1); 1184 if (ret < 0) 1185 return ret; 1186 1187 clr = (b << 16) + (g << 8) + r; 1188 } 1189 if (ptype > 5) 1190 return AVERROR_INVALIDDATA; 1191 ret = decode_value3(s, 255, &s->run_model3[ptype].cntsum, 1192 s->run_model3[ptype].freqs[0], 1193 s->run_model3[ptype].freqs[1], 1194 s->run_model3[ptype].cnts, 1195 s->run_model3[ptype].dectab, &run); 1196 if (ret < 0) 1197 return ret; 1198 if (run <= 0) 1199 return AVERROR_INVALIDDATA; 1200 1201 ret = decode_run_p(avctx, ptype, run, x, y, clr, 1202 dst, prev, linesize, plinesize, &bx, &by, 1203 backstep, sx1, sx2, &cx, &cx1); 1204 if (ret < 0) 1205 return ret; 1206 } 1207 } 1208 } 1209 } 1210 1211 return 0; 1212} 1213