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  PixelModel3 n = {0};
528  int i, size, freqs;
529  uint32_t a;
530 
531  size = m->size;
532  n.size = size;
533  for (i = 0; i < size; i++) {
534  n.symbols[i] = m->symbols[i];
535  }
536  AV_QSORT(n.symbols, size, uint8_t, cmpbytes);
537  size = n.size;
538  for (i = 0; i < size; i++) {
539  if (val == n.symbols[i]) {
540  n.freqs[i] = 100;
541  n.maxpos = i;
542  } else {
543  n.freqs[i] = 50;
544  }
545  }
546  a = 256 - size;
547  for (i = 0; i < size; i++, a += freqs)
548  freqs = n.freqs[i];
549  n.type = 5;
550  n.cntsum = a;
551 
552  memcpy(m, &n, sizeof(n));
553 
554  return 0;
555 }
556 
557 static int decode_static1(PixelModel3 *m, uint32_t val)
558 {
559  uint32_t size;
560 
561  size = m->size;
562  for (int i = 0; i < size; i++) {
563  if (val == m->symbols[i]) {
564  if (size <= 4)
565  return update_model1_to_4(m, val);
566  else
567  return update_model1_to_5(m, val);
568  }
569  }
570 
571  if (size >= 14)
572  return update_model1_to_2(m, val);
573 
574  m->symbols[size] = val;
575  m->size++;
576  return 0;
577 }
578 
580 {
581  PixelModel3 n = {0};
582  int c, d, e, f, g, q;
583 
584  n.type = 6;
585  n.length = a4;
586 
587  memset(n.symbols, 1u, a4);
588 
589  c = m->size;
590  d = 256 - c + (64 * c + 64);
591  for (e = 0; d <= 2048; e++) {
592  d <<= 1;
593  }
594 
595  g = q = 0;
596  AV_QSORT(m->symbols, c, uint8_t, cmpbytes);
597  for (f = d = 0; f < c; f++) {
598  int p = f;
599  int k = m->symbols[p];
600  int l;
601  g = g + (k - q);
602 
603  if (k == value) {
604  d = p;
605  q = 128;
606  } else {
607  q = 64;
608  }
609  l = q << e;
610  n.freqs[2 * p] = l;
611  n.freqs[2 * p + 1] = g << e;
612  n.symbols[p] = k;
613  n.cnts[p] = l - (l >> 1);
614  g += q;
615  q = k + 1;
616  }
617  n.size = c;
618  n.fshift = e;
619  calc_sum(&n);
620 
621  if (d > 0) {
622  c = n.freqs[0];
623  e = n.freqs[1];
624  g = n.freqs[2 * d + 1];
625  n.freqs[0] = n.freqs[2 * d];
626  n.freqs[1] = g;
627  n.freqs[2 * d] = c;
628  n.freqs[2 * d + 1] = e;
629  FFSWAP(uint16_t, n.cnts[0], n.cnts[d]);
630  FFSWAP(uint8_t, n.symbols[0], n.symbols[d]);
631  }
632 
633  memcpy(m, &n, sizeof(n));
634 
635  return 0;
636 }
637 
638 static int update_model2_to_3(PixelModel3 *m, uint32_t val)
639 {
640  PixelModel3 n = {0};
641  uint32_t size;
642 
643  n.type = 3;
644  n.size = m->size + 1;
645 
646  size = m->size;
647  for (int i = 0; i < size; i++)
648  n.symbols[i] = m->symbols[i];
649  n.symbols[size] = val;
650 
651  memcpy(m, &n, sizeof(n));
652 
653  return 0;
654 }
655 
656 static int decode_static2(PixelModel3 *m, uint32_t val)
657 {
658  uint32_t size;
659 
660  size = m->size;
661  for (int i = 0; i < size; i++) {
662  if (val == m->symbols[i]) {
663  int a;
664 
665  if (m->size <= 32)
666  a = 32;
667  else
668  a = 64;
669  return update_model2_to_6(m, val, a);
670  }
671  }
672 
673  if (size >= 64)
674  return update_model2_to_3(m, val);
675 
676  m->symbols[size] = val;
677  m->size++;
678 
679  return 0;
680 }
681 
683 {
684  PixelModel3 n = {0};
685  int c, d, e, f, g, q;
686 
687  n.type = 7;
688 
689  for (c = 0; c < 256; c++) {
690  d = c;
691  n.freqs[d] = 1;
692  n.cnts[d] = 1;
693  }
694 
695  for (c = m->size, d = (4096 - (256 - c)) / (c + 1) | 0, e = d - (d >> 1), g = 0; g < c;) {
696  q = g++;
697  q = m->symbols[q];
698  n.freqs[q] = d;
699  n.cnts[q] = e;
700  }
701  n.freqs[value] += d;
702  n.cnts[value] += 16;
703  for (d = c = n.cntsum = 0; 256 > d; d++) {
704  e = d;
705  n.cntsum += n.cnts[e];
706  n.freqs1[e] = c;
707  g = n.freqs[e];
708  f = (c + g - 1 >> 7) + 1;
709  if (f > FF_ARRAY_ELEMS(n.dectab))
710  return AVERROR_INVALIDDATA;
711  for (q = c + 128 - 1 >> 7; q < f; q++) {
712  n.dectab[q] = e;
713  }
714  c += g;
715  }
716 
717  memcpy(m, &n, sizeof(n));
718 
719  return 0;
720 }
721 
722 static int decode_static3(PixelModel3 *m, uint32_t val)
723 {
724  uint32_t size = m->size;
725 
726  for (int i = 0; i < size; i++) {
727  if (val == m->symbols[i])
728  return update_model3_to_7(m, val);
729  }
730 
731  if (size >= 256)
732  return 0;
733 
734  m->symbols[size] = val;
735  m->size++;
736  return 0;
737 }
738 
739 static void sync_code3(GetByteContext *gb, RangeCoder *rc)
740 {
741  rc->code1++;
742  if (rc->code1 == 0x20000) {
743  rc->code = bytestream2_get_le32(gb);
744  rc->code1 = 0;
745  }
746 }
747 
748 static int decode_value3(SCPRContext *s, uint32_t max, uint32_t *cntsum,
749  uint16_t *freqs1, uint16_t *freqs2,
750  uint16_t *cnts, uint8_t *dectable,
751  uint32_t *value)
752 {
753  GetByteContext *gb = &s->gb;
754  RangeCoder *rc = &s->rc;
755  uint32_t r, y, a, b, e, g, q;
756 
757  r = dectable[(rc->code & 0xFFFu) >> 7];
758  if (r < max) {
759  while (freqs2[r + 1] <= (rc->code & 0xFFF)) {
760  if (++r >= max)
761  break;
762  }
763  }
764 
765  if (r > max)
766  return AVERROR_INVALIDDATA;
767 
768  cnts[r] += 16;
769  a = freqs1[r];
770  b = freqs2[r];
771  *cntsum += 16;
772  if (*cntsum + 16 > 4096) {
773  *cntsum = 0;
774  for (int c = 0, i = 0; i < max + 1; i++) {
775  e = cnts[i];
776  freqs2[i] = c;
777  freqs1[i] = e;
778  g = (c + 127) >> 7;
779  c += e;
780  q = ((c - 1) >> 7) + 1;
781  if (q > g) {
782  for (int j = 0; j < q - g; j++)
783  dectable[j + g] = i;
784  }
785  y = e - (e >> 1);
786  cnts[i] = y;
787  *cntsum += y;
788  }
789  }
790 
791  decode3(gb, rc, a, b);
792  sync_code3(gb, rc);
793 
794  *value = r;
795 
796  return 0;
797 }
798 
799 static void calc_sum5(PixelModel3 *m)
800 {
801  uint32_t a;
802 
803  a = 256 - m->size;
804  for (int b = 0; b < m->size; b++)
805  a += m->freqs[b];
806  m->cntsum = a;
807 }
808 
809 static int update_model4_to_5(PixelModel3 *m, uint32_t value)
810 {
811  PixelModel3 n = {0};
812  int c, e, g, totfr;
813 
814  n.type = 5;
815 
816  for (c = 0, e = 0; c < m->size && m->symbols[c] < value; c++) {
817  n.symbols[c] = m->symbols[c];
818  e += n.freqs[c] = m->freqs[c];
819  }
820 
821  g = c;
822  n.symbols[g] = value;
823  e += n.freqs[g++] = 50;
824  for (; c < m->size; g++, c++) {
825  n.symbols[g] = m->symbols[c];
826  e += n.freqs[g] = m->freqs[c];
827  }
828  n.size = m->size + 1;
829  if (e > 4096)
830  rescale(&n, &totfr);
831 
832  calc_sum5(&n);
833 
834  memcpy(m, &n, sizeof(n));
835 
836  return 0;
837 }
838 
839 static int decode_unit3(SCPRContext *s, PixelModel3 *m, uint32_t code, uint32_t *value)
840 {
841  GetByteContext *gb = &s->gb;
842  RangeCoder *rc = &s->rc;
843  uint16_t a = 0, b = 0;
844  uint32_t param;
845  int type;
846  int ret;
847 
848  type = m->type;
849  switch (type) {
850  case 0:
851  *value = bytestream2_get_byte(&s->gb);
852  m->type = 1;
853  m->size = 1;
854  m->symbols[0] = *value;
855  sync_code3(gb, rc);
856  break;
857  case 1:
858  *value = bytestream2_get_byte(&s->gb);
859  decode_static1(m, *value);
860  sync_code3(gb, rc);
861  break;
862  case 2:
863  *value = bytestream2_get_byte(&s->gb);
864  decode_static2(m, *value);
865  sync_code3(gb, rc);
866  break;
867  case 3:
868  *value = bytestream2_get_byte(&s->gb);
869  ret = decode_static3(m, *value);
870  if (ret < 0)
871  return AVERROR_INVALIDDATA;
872  sync_code3(gb, rc);
873  break;
874  case 4:
875  param = m->freqs[0] + m->freqs[1] + m->freqs[2] + m->freqs[3] + 256 - m->size;
876  if (!decode_adaptive45(m, code, value, &a, &b, &param, 4))
877  update_model4_to_5(m, *value);
878  decode3(gb, rc, a, b);
879  sync_code3(gb, rc);
880  break;
881  case 5:
882  if (!decode_adaptive45(m, code, value, &a, &b, &m->cntsum, 16))
883  update_model5_to_6(m, *value);
884  decode3(gb, rc, a, b);
885  sync_code3(gb, rc);
886  break;
887  case 6:
888  if (!decode_adaptive6(m, code, value, &a, &b)) {
889  ret = update_model6_to_7(m);
890  if (ret < 0)
891  return AVERROR_INVALIDDATA;
892  }
893  decode3(gb, rc, a, b);
894  sync_code3(gb, rc);
895  break;
896  case 7:
897  return decode_value3(s, 255, &m->cntsum,
898  m->freqs, m->freqs1,
899  m->cnts, m->dectab, value);
900  }
901 
902  if (*value > 255)
903  return AVERROR_INVALIDDATA;
904 
905  return 0;
906 }
907 
908 static int decode_units3(SCPRContext * s, uint32_t *red,
909  uint32_t *green, uint32_t *blue,
910  int *cx, int *cx1)
911 {
912  RangeCoder *rc = &s->rc;
913  int ret;
914 
915  ret = decode_unit3(s, &s->pixel_model3[0][*cx + *cx1], rc->code & 0xFFF, red);
916  if (ret < 0)
917  return ret;
918 
919  *cx1 = (*cx << 6) & 0xFC0;
920  *cx = *red >> 2;
921 
922  ret = decode_unit3(s, &s->pixel_model3[1][*cx + *cx1], rc->code & 0xFFF, green);
923  if (ret < 0)
924  return ret;
925 
926  *cx1 = (*cx << 6) & 0xFC0;
927  *cx = *green >> 2;
928 
929  ret = decode_unit3(s, &s->pixel_model3[2][*cx + *cx1], rc->code & 0xFFF, blue);
930  if (ret < 0)
931  return ret;
932 
933  *cx1 = (*cx << 6) & 0xFC0;
934  *cx = *blue >> 2;
935 
936  return 0;
937 }
938 
940 {
941  rc->code = bytestream2_get_le32(gb);
942  rc->code1 = 0;
943 }
944 
945 static int decompress_i3(AVCodecContext *avctx, uint32_t *dst, int linesize)
946 {
947  SCPRContext *s = avctx->priv_data;
948  GetByteContext *gb = &s->gb;
949  RangeCoder *rc = &s->rc;
950  int cx = 0, cx1 = 0, k = 0;
951  int run, off, y = 0, x = 0, ret;
952  uint32_t backstep = linesize - avctx->width;
953  uint32_t clr = 0, lx, ly, ptype, r, g, b;
954 
955  bytestream2_skip(gb, 1);
956  init_rangecoder3(rc, gb);
957  reinit_tables3(s);
958 
959  while (k < avctx->width + 1) {
960  ret = decode_units3(s, &r, &g, &b, &cx, &cx1);
961  if (ret < 0)
962  return ret;
963  ret = decode_value3(s, 255, &s->run_model3[0].cntsum,
964  s->run_model3[0].freqs[0],
965  s->run_model3[0].freqs[1],
966  s->run_model3[0].cnts,
967  s->run_model3[0].dectab, &run);
968  if (ret < 0)
969  return ret;
970  if (run <= 0)
971  return AVERROR_INVALIDDATA;
972 
973  clr = (b << 16) + (g << 8) + r;
974  k += run;
975  while (run-- > 0) {
976  if (y >= avctx->height)
977  return AVERROR_INVALIDDATA;
978 
979  dst[y * linesize + x] = clr;
980  lx = x;
981  ly = y;
982  x++;
983  if (x >= avctx->width) {
984  x = 0;
985  y++;
986  }
987  }
988  }
989  off = -linesize - 1;
990  ptype = 0;
991 
992  while (x < avctx->width && y < avctx->height) {
993  ret = decode_value3(s, 5, &s->op_model3[ptype].cntsum,
994  s->op_model3[ptype].freqs[0],
995  s->op_model3[ptype].freqs[1],
996  s->op_model3[ptype].cnts,
997  s->op_model3[ptype].dectab, &ptype);
998  if (ret < 0)
999  return ret;
1000  if (ptype == 0) {
1001  ret = decode_units3(s, &r, &g, &b, &cx, &cx1);
1002  if (ret < 0)
1003  return ret;
1004  clr = (b << 16) + (g << 8) + r;
1005  }
1006  if (ptype > 5)
1007  return AVERROR_INVALIDDATA;
1008  ret = decode_value3(s, 255, &s->run_model3[ptype].cntsum,
1009  s->run_model3[ptype].freqs[0],
1010  s->run_model3[ptype].freqs[1],
1011  s->run_model3[ptype].cnts,
1012  s->run_model3[ptype].dectab, &run);
1013  if (ret < 0)
1014  return ret;
1015  if (run <= 0)
1016  return AVERROR_INVALIDDATA;
1017 
1018  ret = decode_run_i(avctx, ptype, run, &x, &y, clr,
1019  dst, linesize, &lx, &ly,
1020  backstep, off, &cx, &cx1);
1021  if (ret < 0)
1022  return ret;
1023  }
1024 
1025  return 0;
1026 }
1027 
1028 static int decompress_p3(AVCodecContext *avctx,
1029  uint32_t *dst, int linesize,
1030  uint32_t *prev, int plinesize)
1031 {
1032  SCPRContext *s = avctx->priv_data;
1033  GetByteContext *gb = &s->gb;
1034  int ret, temp, min, max, x, y, cx = 0, cx1 = 0;
1035  int backstep = linesize - avctx->width;
1036  int mvx = 0, mvy = 0;
1037 
1038  if (bytestream2_get_byte(gb) == 0)
1039  return 1;
1040  init_rangecoder3(&s->rc, gb);
1041 
1042  ret = decode_value3(s, 255, &s->range_model3.cntsum,
1043  s->range_model3.freqs[0],
1044  s->range_model3.freqs[1],
1045  s->range_model3.cnts,
1046  s->range_model3.dectab, &min);
1047  ret |= decode_value3(s, 255, &s->range_model3.cntsum,
1048  s->range_model3.freqs[0],
1049  s->range_model3.freqs[1],
1050  s->range_model3.cnts,
1051  s->range_model3.dectab, &temp);
1052  if (ret < 0)
1053  return ret;
1054 
1055  min += temp << 8;
1056  ret |= decode_value3(s, 255, &s->range_model3.cntsum,
1057  s->range_model3.freqs[0],
1058  s->range_model3.freqs[1],
1059  s->range_model3.cnts,
1060  s->range_model3.dectab, &max);
1061  ret |= decode_value3(s, 255, &s->range_model3.cntsum,
1062  s->range_model3.freqs[0],
1063  s->range_model3.freqs[1],
1064  s->range_model3.cnts,
1065  s->range_model3.dectab, &temp);
1066  if (ret < 0)
1067  return ret;
1068 
1069  max += temp << 8;
1070  if (min > max || min >= s->nbcount)
1071  return AVERROR_INVALIDDATA;
1072 
1073  memset(s->blocks, 0, sizeof(*s->blocks) * s->nbcount);
1074 
1075  while (min <= max) {
1076  int fill, count;
1077 
1078  ret = decode_value3(s, 4, &s->fill_model3.cntsum,
1079  s->fill_model3.freqs[0],
1080  s->fill_model3.freqs[1],
1081  s->fill_model3.cnts,
1082  s->fill_model3.dectab, &fill);
1083  ret |= decode_value3(s, 255, &s->count_model3.cntsum,
1084  s->count_model3.freqs[0],
1085  s->count_model3.freqs[1],
1086  s->count_model3.cnts,
1087  s->count_model3.dectab, &count);
1088  if (ret < 0)
1089  return ret;
1090  if (count <= 0)
1091  return AVERROR_INVALIDDATA;
1092 
1093  while (min < s->nbcount && count-- > 0) {
1094  s->blocks[min++] = fill;
1095  }
1096  }
1097 
1098  ret = av_frame_copy(s->current_frame, s->last_frame);
1099  if (ret < 0)
1100  return ret;
1101 
1102  for (y = 0; y < s->nby; y++) {
1103  for (x = 0; x < s->nbx; x++) {
1104  int sy1 = 0, sy2 = 16, sx1 = 0, sx2 = 16;
1105 
1106  if (s->blocks[y * s->nbx + x] == 0)
1107  continue;
1108 
1109  if (((s->blocks[y * s->nbx + x] + 1) & 1) > 0) {
1110  ret = decode_value3(s, 15, &s->sxy_model3[0].cntsum,
1111  s->sxy_model3[0].freqs[0],
1112  s->sxy_model3[0].freqs[1],
1113  s->sxy_model3[0].cnts,
1114  s->sxy_model3[0].dectab, &sx1);
1115  ret |= decode_value3(s, 15, &s->sxy_model3[1].cntsum,
1116  s->sxy_model3[1].freqs[0],
1117  s->sxy_model3[1].freqs[1],
1118  s->sxy_model3[1].cnts,
1119  s->sxy_model3[1].dectab, &sy1);
1120  ret |= decode_value3(s, 15, &s->sxy_model3[2].cntsum,
1121  s->sxy_model3[2].freqs[0],
1122  s->sxy_model3[2].freqs[1],
1123  s->sxy_model3[2].cnts,
1124  s->sxy_model3[2].dectab, &sx2);
1125  ret |= decode_value3(s, 15, &s->sxy_model3[3].cntsum,
1126  s->sxy_model3[3].freqs[0],
1127  s->sxy_model3[3].freqs[1],
1128  s->sxy_model3[3].cnts,
1129  s->sxy_model3[3].dectab, &sy2);
1130  if (ret < 0)
1131  return ret;
1132 
1133  sx2++;
1134  sy2++;
1135  }
1136  if (((s->blocks[y * s->nbx + x] + 3) & 2) > 0) {
1137  int i, a, b, c, j, by = y * 16, bx = x * 16;
1138  uint32_t code;
1139 
1140  a = s->rc.code & 0xFFF;
1141  c = 1;
1142 
1143  if (a < 0x800)
1144  c = 0;
1145  b = 2048;
1146  if (!c)
1147  b = 0;
1148 
1149  code = a + ((s->rc.code >> 1) & 0xFFFFF800) - b;
1150  while (code < 0x800000 && bytestream2_get_bytes_left(gb) > 0)
1151  code = bytestream2_get_byteu(gb) | (code << 8);
1152  s->rc.code = code;
1153 
1154  sync_code3(gb, &s->rc);
1155 
1156  if (!c) {
1157  ret = decode_value3(s, 511, &s->mv_model3[0].cntsum,
1158  s->mv_model3[0].freqs[0],
1159  s->mv_model3[0].freqs[1],
1160  s->mv_model3[0].cnts,
1161  s->mv_model3[0].dectab, &mvx);
1162  ret |= decode_value3(s, 511, &s->mv_model3[1].cntsum,
1163  s->mv_model3[1].freqs[0],
1164  s->mv_model3[1].freqs[1],
1165  s->mv_model3[1].cnts,
1166  s->mv_model3[1].dectab, &mvy);
1167  if (ret < 0)
1168  return ret;
1169 
1170  mvx -= 256;
1171  mvy -= 256;
1172  }
1173 
1174  if (by + mvy + sy1 < 0 || bx + mvx + sx1 < 0 ||
1175  by + mvy + sy1 >= avctx->height || bx + mvx + sx1 >= avctx->width)
1176  return AVERROR_INVALIDDATA;
1177 
1178  for (i = 0; i < sy2 - sy1 && (by + sy1 + i) < avctx->height && (by + mvy + sy1 + i) < avctx->height; i++) {
1179  for (j = 0; j < sx2 - sx1 && (bx + sx1 + j) < avctx->width && (bx + mvx + sx1 + j) < avctx->width; j++) {
1180  dst[(by + i + sy1) * linesize + bx + sx1 + j] = prev[(by + mvy + sy1 + i) * plinesize + bx + sx1 + mvx + j];
1181  }
1182  }
1183  } else {
1184  int run, bx = x * 16 + sx1, by = y * 16 + sy1;
1185  uint32_t clr, ptype = 0, r, g, b;
1186 
1187  for (; by < y * 16 + sy2 && by < avctx->height;) {
1188  ret = decode_value3(s, 5, &s->op_model3[ptype].cntsum,
1189  s->op_model3[ptype].freqs[0],
1190  s->op_model3[ptype].freqs[1],
1191  s->op_model3[ptype].cnts,
1192  s->op_model3[ptype].dectab, &ptype);
1193  if (ret < 0)
1194  return ret;
1195  if (ptype == 0) {
1196  ret = decode_units3(s, &r, &g, &b, &cx, &cx1);
1197  if (ret < 0)
1198  return ret;
1199 
1200  clr = (b << 16) + (g << 8) + r;
1201  }
1202  if (ptype > 5)
1203  return AVERROR_INVALIDDATA;
1204  ret = decode_value3(s, 255, &s->run_model3[ptype].cntsum,
1205  s->run_model3[ptype].freqs[0],
1206  s->run_model3[ptype].freqs[1],
1207  s->run_model3[ptype].cnts,
1208  s->run_model3[ptype].dectab, &run);
1209  if (ret < 0)
1210  return ret;
1211  if (run <= 0)
1212  return AVERROR_INVALIDDATA;
1213 
1214  ret = decode_run_p(avctx, ptype, run, x, y, clr,
1215  dst, prev, linesize, plinesize, &bx, &by,
1216  backstep, sx1, sx2, &cx, &cx1);
1217  if (ret < 0)
1218  return ret;
1219  }
1220  }
1221  }
1222  }
1223 
1224  return 0;
1225 }
static int update_model2_to_6(PixelModel3 *m, uint8_t value, int a4)
Definition: scpr3.c:579
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:115
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:839
uint8_t length
Definition: scpr3.h:35
uint16_t freqs[256]
Definition: scpr3.h:41
uint8_t dectab[32]
Definition: scpr3.h:65
uint8_t run
Definition: svq3.c:208
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:739
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:1028
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:262
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:154
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:164
uint16_t freqs[2][512]
Definition: scpr3.h:77
const char * r
Definition: vf_curves.c:114
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:799
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:800
static void grow_dec(PixelModel3 *m)
Definition: scpr3.c:369
#define FFDIFFSIGN(x, y)
Comparator.
Definition: common.h:92
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:699
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
#define FF_ARRAY_ELEMS(a)
uint32_t cntsum
Definition: scpr3.h:55
static int update_model4_to_5(PixelModel3 *m, uint32_t value)
Definition: scpr3.c:809
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:526
static void init_rangecoder3(RangeCoder *rc, GetByteContext *gb)
Definition: scpr3.c:939
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:638
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:553
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:656
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:945
static int update_model3_to_7(PixelModel3 *m, uint8_t value)
Definition: scpr3.c:682
#define FFSWAP(type, a, b)
Definition: common.h:99
static int decode_units3(SCPRContext *s, uint32_t *red, uint32_t *green, uint32_t *blue, int *cx, int *cx1)
Definition: scpr3.c:908
RunModel3 range_model3
Definition: scpr.h:69
float min
static int decode_static1(PixelModel3 *m, uint32_t val)
Definition: scpr3.c:557
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:722
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:406
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:748