FFmpeg
scpr3.c
Go to the documentation of this file.
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 
34 static 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 
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 
69  s->range_model3.freqs[0], s->range_model3.freqs[1],
71 
73  s->fill_model3.freqs[0], s->fill_model3.freqs[1],
75 
77  s->count_model3.freqs[0], s->count_model3.freqs[1],
79 
80  for (int i = 0; i < 4; i++) {
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++) {
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 
99 static 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 
110 static 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 
123 static 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 
147 static 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 
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 
249 static 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 
261 static 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 
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 
369 static 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 
378 static 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 
395 static 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 
420 static 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 
475 static 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 
482 static 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 
499 static 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 
525 static 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 
541 static 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 
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 
622 static 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 
640 static 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 
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 
706 static 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 
723 static 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 
732 static 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 
783 static 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 
793 static 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 
823 static 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, &param, 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 
892 static 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 
924 {
925  rc->code = bytestream2_get_le32(gb);
926  rc->code1 = 0;
927 }
928 
929 static 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 
1012 static 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  for (; by < y * 16 + sy2 && by < avctx->height;) {
1172  ret = decode_value3(s, 5, &s->op_model3[ptype].cntsum,
1173  s->op_model3[ptype].freqs[0],
1174  s->op_model3[ptype].freqs[1],
1175  s->op_model3[ptype].cnts,
1176  s->op_model3[ptype].dectab, &ptype);
1177  if (ret < 0)
1178  return ret;
1179  if (ptype == 0) {
1180  ret = decode_units3(s, &r, &g, &b, &cx, &cx1);
1181  if (ret < 0)
1182  return ret;
1183 
1184  clr = (b << 16) + (g << 8) + r;
1185  }
1186  if (ptype > 5)
1187  return AVERROR_INVALIDDATA;
1188  ret = decode_value3(s, 255, &s->run_model3[ptype].cntsum,
1189  s->run_model3[ptype].freqs[0],
1190  s->run_model3[ptype].freqs[1],
1191  s->run_model3[ptype].cnts,
1192  s->run_model3[ptype].dectab, &run);
1193  if (ret < 0)
1194  return ret;
1195  if (run <= 0)
1196  return AVERROR_INVALIDDATA;
1197 
1198  ret = decode_run_p(avctx, ptype, run, x, y, clr,
1199  dst, prev, linesize, plinesize, &bx, &by,
1200  backstep, sx1, sx2, &cx, &cx1);
1201  if (ret < 0)
1202  return ret;
1203  }
1204  }
1205  }
1206  }
1207 
1208  return 0;
1209 }
static int update_model2_to_6(PixelModel3 *m, uint8_t value, int a4)
Definition: scpr3.c:563
static int decode_run_i(AVCodecContext *avctx, uint32_t ptype, int run, int *px, int *py, uint32_t clr, uint32_t *dst, int linesize, uint32_t *plx, uint32_t *ply, uint32_t backstep, int off, int *cx, int *cx1)
Definition: scpr.h:80
AVFrame * last_frame
Definition: scpr.h:49
static int add_symbol(PixelModel3 *m, int index, uint32_t symbol, int *totfr, int max)
Definition: scpr3.c:123
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
SxyModel3 sxy_model3[4]
Definition: scpr.h:72
static void reinit_tables3(SCPRContext *s)
Definition: scpr3.c:53
PixelModel3 pixel_model3[3][4096]
Definition: scpr.h:67
else temp
Definition: vf_mcdeint.c:256
const char * g
Definition: vf_curves.c:117
uint8_t fshift
Definition: scpr3.h:37
uint32_t cntsum
Definition: scpr3.h:48
uint32_t code1
Definition: scpr.h:38
uint8_t dectab[32]
Definition: scpr3.h:72
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
uint8_t dectab[32]
Definition: scpr3.h:58
GLint GLenum type
Definition: opengl_enc.c:104
static int decode_unit3(SCPRContext *s, PixelModel3 *m, uint32_t code, uint32_t *value)
Definition: scpr3.c:823
uint8_t length
Definition: scpr3.h:35
uint16_t freqs[256]
Definition: scpr3.h:41
#define FF_ARRAY_ELEMS(a)
uint8_t dectab[32]
Definition: scpr3.h:65
uint8_t run
Definition: svq3.c:205
uint8_t dectab[32]
Definition: scpr3.h:79
uint32_t cntsum
Definition: scpr3.h:39
static void sync_code3(GetByteContext *gb, RangeCoder *rc)
Definition: scpr3.c:723
uint8_t maxpos
Definition: scpr3.h:36
uint8_t
uint8_t symbols[256]
Definition: scpr3.h:40
#define f(width, name)
Definition: cbs_vp9.c:255
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
static int decompress_p3(AVCodecContext *avctx, uint32_t *dst, int linesize, uint32_t *prev, int plinesize)
Definition: scpr3.c:1012
static int update_model1_to_2(PixelModel3 *m, uint32_t val)
Definition: scpr3.c:482
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:264
static int decode_run_p(AVCodecContext *avctx, uint32_t ptype, int run, int x, int y, uint32_t clr, uint32_t *dst, uint32_t *prev, int linesize, int plinesize, uint32_t *bx, uint32_t *by, uint32_t backstep, int sx1, int sx2, int *cx, int *cx1)
Definition: scpr.h:222
#define height
#define max(a, b)
Definition: cuda_runtime.h:33
ptrdiff_t size
Definition: opengl_enc.c:100
uint32_t nby
Definition: scpr.h:61
AVFrame * current_frame
Definition: scpr.h:50
uint16_t cnts[256]
Definition: scpr3.h:64
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
uint16_t cnts[5]
Definition: scpr3.h:50
static int decode_adaptive45(PixelModel3 *m, int rccode, uint32_t *value, uint16_t *a, uint16_t *b, uint32_t *c, int max)
Definition: scpr3.c:147
RangeCoder rc
Definition: scpr.h:52
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
uint16_t freqs[2][512]
Definition: scpr3.h:77
const char * r
Definition: vf_curves.c:116
static int decode3(GetByteContext *gb, RangeCoder *rc, uint32_t a, uint32_t b)
Definition: scpr3.c:99
uint16_t cnts[16]
Definition: scpr3.h:71
static void calc_sum5(PixelModel3 *m)
Definition: scpr3.c:783
GLsizei GLsizei * length
Definition: opengl_enc.c:114
GLsizei count
Definition: opengl_enc.c:108
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
Definition: frame.c:799
static void grow_dec(PixelModel3 *m)
Definition: scpr3.c:369
#define FFDIFFSIGN(x, y)
Comparator.
Definition: common.h:101
uint16_t cnts[256]
Definition: scpr3.h:43
#define b
Definition: input.c:41
#define width
uint32_t nbcount
Definition: scpr.h:62
int width
picture width / height.
Definition: avcodec.h:704
FillModel3 fill_model3
Definition: scpr.h:71
static int update_model1_to_5(PixelModel3 *m, uint32_t val)
Definition: scpr3.c:525
#define s(width, name)
Definition: cbs_vp9.c:257
uint16_t freqs[2][16]
Definition: scpr3.h:70
uint16_t cnts[512]
Definition: scpr3.h:78
static void rescale(PixelModel3 *m, int *totfr)
Definition: scpr3.c:110
uint8_t type
Definition: scpr3.h:34
MVModel3 mv_model3[2]
Definition: scpr.h:73
uint32_t cntsum
Definition: scpr3.h:76
uint32_t cntsum
Definition: scpr3.h:55
static int update_model4_to_5(PixelModel3 *m, uint32_t value)
Definition: scpr3.c:793
static int update_model5_to_6(PixelModel3 *m, uint8_t value)
Definition: scpr3.c:295
uint16_t freqs[2][256]
Definition: scpr3.h:63
static int add_dec(PixelModel3 *m, int sym, int f1, int f2)
Definition: scpr3.c:378
uint16_t size
Definition: scpr3.h:38
Libavcodec external API header.
main external API structure.
Definition: avcodec.h:531
static void init_rangecoder3(RangeCoder *rc, GetByteContext *gb)
Definition: scpr3.c:923
uint32_t cntsum
Definition: scpr3.h:62
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2]...the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so...,+,-,+,-,+,+,-,+,-,+,...hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32-hcoeff[1]-hcoeff[2]-...a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2}an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||.........intra?||||:Block01:yes no||||:Block02:.................||||:Block03::y DC::ref index:||||:Block04::cb DC::motion x:||||.........:cr DC::motion y:||||.................|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------------------------------|||Y subbands||Cb subbands||Cr subbands||||------||------||------|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||------||------||------||||------||------||------|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||------||------||------||||------||------||------|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||------||------||------||||------||------||------|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------------------------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction------------|\Dequantization-------------------\||Reference frames|\IDWT|--------------|Motion\|||Frame 0||Frame 1||Compensation.OBMC v-------|--------------|--------------.\------> Frame n output Frame Frame<----------------------------------/|...|-------------------Range Coder:============Binary Range Coder:-------------------The implemented range coder is an adapted version based upon"Range encoding: an algorithm for removing redundancy from a digitised message."by G.N.N.Martin.The symbols encoded by the Snow range coder are bits(0|1).The associated probabilities are not fix but change depending on the symbol mix seen so far.bit seen|new state---------+-----------------------------------------------0|256-state_transition_table[256-old_state];1|state_transition_table[old_state];state_transition_table={0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:-------------------------FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1.the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:206
static void incr_cntdec(PixelModel3 *m, int a)
Definition: scpr3.c:395
uint32_t * blocks
Definition: scpr.h:63
int index
Definition: gxfenc.c:89
uint32_t code
Definition: scpr.h:36
uint16_t freqs1[256]
Definition: scpr3.h:42
static void renew_table3(uint32_t nsym, uint32_t *cntsum, uint16_t *freqs, uint16_t *freqs1, uint16_t *cnts, uint8_t *dectab)
Definition: scpr3.c:34
uint32_t nbx
Definition: scpr.h:61
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
static void rescale_dec(PixelModel3 *m)
Definition: scpr3.c:261
GetByteContext gb
Definition: scpr.h:51
static int decode_adaptive6(PixelModel3 *m, uint32_t code, uint32_t *value, uint16_t *a, uint16_t *b)
Definition: scpr3.c:420
common internal api header.
static int update_model2_to_3(PixelModel3 *m, uint32_t val)
Definition: scpr3.c:622
static void calc_sum(PixelModel3 *m)
Definition: scpr3.c:249
uint8_t dectab[32]
Definition: scpr3.h:51
uint16_t cnts[6]
Definition: scpr3.h:57
#define a4
Definition: regdef.h:50
void * priv_data
Definition: avcodec.h:558
uint16_t freqs[2][5]
Definition: scpr3.h:49
uint8_t dectab[32]
Definition: scpr3.h:44
OpModel3 op_model3[6]
Definition: scpr.h:74
int len
uint32_t cntsum
Definition: scpr3.h:69
uint16_t freqs[2][6]
Definition: scpr3.h:56
RunModel3 run_model3[6]
Definition: scpr.h:68
static int decode_static2(PixelModel3 *m, uint32_t val)
Definition: scpr3.c:640
static int update_model6_to_7(PixelModel3 *m)
Definition: scpr3.c:204
static int decompress_i3(AVCodecContext *avctx, uint32_t *dst, int linesize)
Definition: scpr3.c:929
static int update_model3_to_7(PixelModel3 *m, uint8_t value)
Definition: scpr3.c:666
#define FFSWAP(type, a, b)
Definition: common.h:108
static int decode_units3(SCPRContext *s, uint32_t *red, uint32_t *green, uint32_t *blue, int *cx, int *cx1)
Definition: scpr3.c:892
RunModel3 range_model3
Definition: scpr.h:69
float min
static int decode_static1(PixelModel3 *m, uint32_t val)
Definition: scpr3.c:541
static int cmpbytes(const void *p1, const void *p2)
Definition: scpr3.c:475
static double val(void *priv, double ch)
Definition: aeval.c:76
static int update_model1_to_4(PixelModel3 *m, uint32_t val)
Definition: scpr3.c:499
static int decode_static3(PixelModel3 *m, uint32_t val)
Definition: scpr3.c:706
RunModel3 count_model3
Definition: scpr.h:70
#define AV_QSORT(p, num, type, cmp)
Quicksort This sort is fast, and fully inplace but not stable and it is possible to construct input t...
Definition: qsort.h:33
int i
Definition: input.c:407
static int decode_value3(SCPRContext *s, uint32_t max, uint32_t *cntsum, uint16_t *freqs1, uint16_t *freqs2, uint16_t *cnts, uint8_t *dectable, uint32_t *value)
Definition: scpr3.c:732