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