FFmpeg
scpr.c
Go to the documentation of this file.
1 /*
2  * ScreenPressor 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 "avcodec.h"
28 #include "bytestream.h"
29 #include "internal.h"
30 #include "scpr.h"
31 #include "scpr3.h"
32 
33 #define TOP 0x01000000
34 #define BOT 0x010000
35 
36 #include "scpr3.c"
37 
39 {
40  rc->code1 = 0;
41  rc->range = 0xFFFFFFFFU;
42  rc->code = bytestream2_get_be32(gb);
43 }
44 
46 {
47  int comp, i, j;
48 
49  for (comp = 0; comp < 3; comp++) {
50  for (j = 0; j < 4096; j++) {
51  if (s->pixel_model[comp][j].total_freq != 256) {
52  for (i = 0; i < 256; i++)
53  s->pixel_model[comp][j].freq[i] = 1;
54  for (i = 0; i < 16; i++)
55  s->pixel_model[comp][j].lookup[i] = 16;
56  s->pixel_model[comp][j].total_freq = 256;
57  }
58  }
59  }
60 
61  for (j = 0; j < 6; j++) {
62  uint32_t *p = s->run_model[j];
63  for (i = 0; i < 256; i++)
64  p[i] = 1;
65  p[256] = 256;
66  }
67 
68  for (j = 0; j < 6; j++) {
69  uint32_t *op = s->op_model[j];
70  for (i = 0; i < 6; i++)
71  op[i] = 1;
72  op[6] = 6;
73  }
74 
75  for (i = 0; i < 256; i++) {
76  s->range_model[i] = 1;
77  s->count_model[i] = 1;
78  }
79  s->range_model[256] = 256;
80  s->count_model[256] = 256;
81 
82  for (i = 0; i < 5; i++) {
83  s->fill_model[i] = 1;
84  }
85  s->fill_model[5] = 5;
86 
87  for (j = 0; j < 4; j++) {
88  for (i = 0; i < 16; i++) {
89  s->sxy_model[j][i] = 1;
90  }
91  s->sxy_model[j][16] = 16;
92  }
93 
94  for (i = 0; i < 512; i++) {
95  s->mv_model[0][i] = 1;
96  s->mv_model[1][i] = 1;
97  }
98  s->mv_model[0][512] = 512;
99  s->mv_model[1][512] = 512;
100 }
101 
102 static int decode(GetByteContext *gb, RangeCoder *rc, uint32_t cumFreq, uint32_t freq, uint32_t total_freq)
103 {
104  rc->code -= cumFreq * rc->range;
105  rc->range *= freq;
106 
107  while (rc->range < TOP && bytestream2_get_bytes_left(gb) > 0) {
108  uint32_t byte = bytestream2_get_byteu(gb);
109  rc->code = (rc->code << 8) | byte;
110  rc->range <<= 8;
111  }
112 
113  return 0;
114 }
115 
116 static int get_freq(RangeCoder *rc, uint32_t total_freq, uint32_t *freq)
117 {
118  if (total_freq == 0)
119  return AVERROR_INVALIDDATA;
120 
121  rc->range = rc->range / total_freq;
122 
123  if (rc->range == 0)
124  return AVERROR_INVALIDDATA;
125 
126  *freq = rc->code / rc->range;
127 
128  return 0;
129 }
130 
131 static int decode0(GetByteContext *gb, RangeCoder *rc, uint32_t cumFreq, uint32_t freq, uint32_t total_freq)
132 {
133  uint32_t t;
134 
135  if (total_freq == 0)
136  return AVERROR_INVALIDDATA;
137 
138  t = rc->range * (uint64_t)cumFreq / total_freq;
139 
140  rc->code1 += t + 1;
141  rc->range = rc->range * (uint64_t)(freq + cumFreq) / total_freq - (t + 1);
142 
143  while (rc->range < TOP && bytestream2_get_bytes_left(gb) > 0) {
144  uint32_t byte = bytestream2_get_byteu(gb);
145  rc->code = (rc->code << 8) | byte;
146  rc->code1 <<= 8;
147  rc->range <<= 8;
148  }
149 
150  return 0;
151 }
152 
153 static int get_freq0(RangeCoder *rc, uint32_t total_freq, uint32_t *freq)
154 {
155  if (rc->range == 0)
156  return AVERROR_INVALIDDATA;
157 
158  *freq = total_freq * (uint64_t)(rc->code - rc->code1) / rc->range;
159 
160  return 0;
161 }
162 
163 static int decode_value(SCPRContext *s, uint32_t *cnt, uint32_t maxc, uint32_t step, uint32_t *rval)
164 {
165  GetByteContext *gb = &s->gb;
166  RangeCoder *rc = &s->rc;
167  uint32_t totfr = cnt[maxc];
168  uint32_t value;
169  uint32_t c = 0, cumfr = 0, cnt_c = 0;
170  int i, ret;
171 
172  if ((ret = s->get_freq(rc, totfr, &value)) < 0)
173  return ret;
174 
175  while (c < maxc) {
176  cnt_c = cnt[c];
177  if (value >= cumfr + cnt_c)
178  cumfr += cnt_c;
179  else
180  break;
181  c++;
182  }
183 
184  if (c >= maxc)
185  return AVERROR_INVALIDDATA;
186 
187  if ((ret = s->decode(gb, rc, cumfr, cnt_c, totfr)) < 0)
188  return ret;
189 
190  cnt[c] = cnt_c + step;
191  totfr += step;
192  if (totfr > BOT) {
193  totfr = 0;
194  for (i = 0; i < maxc; i++) {
195  uint32_t nc = (cnt[i] >> 1) + 1;
196  cnt[i] = nc;
197  totfr += nc;
198  }
199  }
200 
201  cnt[maxc] = totfr;
202  *rval = c;
203 
204  return 0;
205 }
206 
207 static int decode_unit(SCPRContext *s, PixelModel *pixel, uint32_t step, uint32_t *rval)
208 {
209  GetByteContext *gb = &s->gb;
210  RangeCoder *rc = &s->rc;
211  uint32_t totfr = pixel->total_freq;
212  uint32_t value, x = 0, cumfr = 0, cnt_x = 0;
213  int i, j, ret, c, cnt_c;
214 
215  if ((ret = s->get_freq(rc, totfr, &value)) < 0)
216  return ret;
217 
218  while (x < 16) {
219  cnt_x = pixel->lookup[x];
220  if (value >= cumfr + cnt_x)
221  cumfr += cnt_x;
222  else
223  break;
224  x++;
225  }
226 
227  c = x * 16;
228  cnt_c = 0;
229  while (c < 256) {
230  cnt_c = pixel->freq[c];
231  if (value >= cumfr + cnt_c)
232  cumfr += cnt_c;
233  else
234  break;
235  c++;
236  }
237  if (x >= 16 || c >= 256) {
238  return AVERROR_INVALIDDATA;
239  }
240 
241  if ((ret = s->decode(gb, rc, cumfr, cnt_c, totfr)) < 0)
242  return ret;
243 
244  pixel->freq[c] = cnt_c + step;
245  pixel->lookup[x] = cnt_x + step;
246  totfr += step;
247  if (totfr > BOT) {
248  totfr = 0;
249  for (i = 0; i < 256; i++) {
250  uint32_t nc = (pixel->freq[i] >> 1) + 1;
251  pixel->freq[i] = nc;
252  totfr += nc;
253  }
254  for (i = 0; i < 16; i++) {
255  uint32_t sum = 0;
256  uint32_t i16_17 = i << 4;
257  for (j = 0; j < 16; j++)
258  sum += pixel->freq[i16_17 + j];
259  pixel->lookup[i] = sum;
260  }
261  }
262  pixel->total_freq = totfr;
263 
264  *rval = c & s->cbits;
265 
266  return 0;
267 }
268 
269 static int decode_units(SCPRContext *s, uint32_t *r, uint32_t *g, uint32_t *b,
270  int *cx, int *cx1)
271 {
272  const int cxshift = s->cxshift;
273  int ret;
274 
275  ret = decode_unit(s, &s->pixel_model[0][*cx + *cx1], 400, r);
276  if (ret < 0)
277  return ret;
278 
279  *cx1 = (*cx << 6) & 0xFC0;
280  *cx = *r >> cxshift;
281  ret = decode_unit(s, &s->pixel_model[1][*cx + *cx1], 400, g);
282  if (ret < 0)
283  return ret;
284 
285  *cx1 = (*cx << 6) & 0xFC0;
286  *cx = *g >> cxshift;
287  ret = decode_unit(s, &s->pixel_model[2][*cx + *cx1], 400, b);
288  if (ret < 0)
289  return ret;
290 
291  *cx1 = (*cx << 6) & 0xFC0;
292  *cx = *b >> cxshift;
293 
294  return 0;
295 }
296 
297 static int decompress_i(AVCodecContext *avctx, uint32_t *dst, int linesize)
298 {
299  SCPRContext *s = avctx->priv_data;
300  GetByteContext *gb = &s->gb;
301  int cx = 0, cx1 = 0, k = 0;
302  int run, off, y = 0, x = 0, ret;
303  uint32_t clr = 0, r, g, b, backstep = linesize - avctx->width;
304  uint32_t lx, ly, ptype;
305 
306  reinit_tables(s);
307  bytestream2_skip(gb, 2);
308  init_rangecoder(&s->rc, gb);
309 
310  while (k < avctx->width + 1) {
311  ret = decode_units(s, &r, &g, &b, &cx, &cx1);
312  if (ret < 0)
313  return ret;
314 
315  ret = decode_value(s, s->run_model[0], 256, 400, &run);
316  if (ret < 0)
317  return ret;
318  if (run <= 0)
319  return AVERROR_INVALIDDATA;
320 
321  clr = (b << 16) + (g << 8) + r;
322  k += run;
323  while (run-- > 0) {
324  if (y >= avctx->height)
325  return AVERROR_INVALIDDATA;
326 
327  dst[y * linesize + x] = clr;
328  lx = x;
329  ly = y;
330  x++;
331  if (x >= avctx->width) {
332  x = 0;
333  y++;
334  }
335  }
336  }
337  off = -linesize - 1;
338  ptype = 0;
339 
340  while (x < avctx->width && y < avctx->height) {
341  ret = decode_value(s, s->op_model[ptype], 6, 1000, &ptype);
342  if (ret < 0)
343  return ret;
344  if (ptype == 0) {
345  ret = decode_units(s, &r, &g, &b, &cx, &cx1);
346  if (ret < 0)
347  return ret;
348 
349  clr = (b << 16) + (g << 8) + r;
350  }
351  if (ptype > 5)
352  return AVERROR_INVALIDDATA;
353  ret = decode_value(s, s->run_model[ptype], 256, 400, &run);
354  if (ret < 0)
355  return ret;
356  if (run <= 0)
357  return AVERROR_INVALIDDATA;
358 
359  ret = decode_run_i(avctx, ptype, run, &x, &y, clr,
360  dst, linesize, &lx, &ly,
361  backstep, off, &cx, &cx1);
362  if (ret < 0)
363  return ret;
364  }
365 
366  return 0;
367 }
368 
369 static int decompress_p(AVCodecContext *avctx,
370  uint32_t *dst, int linesize,
371  uint32_t *prev, int plinesize)
372 {
373  SCPRContext *s = avctx->priv_data;
374  GetByteContext *gb = &s->gb;
375  int ret, temp = 0, min, max, x, y, cx = 0, cx1 = 0;
376  int backstep = linesize - avctx->width;
377 
378  if (bytestream2_get_byte(gb) == 0)
379  return 1;
380  bytestream2_skip(gb, 1);
381  init_rangecoder(&s->rc, gb);
382 
383  ret = decode_value(s, s->range_model, 256, 1, &min);
384  ret |= decode_value(s, s->range_model, 256, 1, &temp);
385  if (ret < 0)
386  return ret;
387 
388  min += temp << 8;
389  ret = decode_value(s, s->range_model, 256, 1, &max);
390  ret |= decode_value(s, s->range_model, 256, 1, &temp);
391  if (ret < 0)
392  return ret;
393 
394  max += temp << 8;
395  if (min > max || min >= s->nbcount)
396  return AVERROR_INVALIDDATA;
397 
398  memset(s->blocks, 0, sizeof(*s->blocks) * s->nbcount);
399 
400  while (min <= max) {
401  int fill, count;
402 
403  ret = decode_value(s, s->fill_model, 5, 10, &fill);
404  ret |= decode_value(s, s->count_model, 256, 20, &count);
405  if (ret < 0)
406  return ret;
407  if (count <= 0)
408  return AVERROR_INVALIDDATA;
409 
410  while (min < s->nbcount && count-- > 0) {
411  s->blocks[min++] = fill;
412  }
413  }
414 
415  ret = av_frame_copy(s->current_frame, s->last_frame);
416  if (ret < 0)
417  return ret;
418 
419  for (y = 0; y < s->nby; y++) {
420  for (x = 0; x < s->nbx; x++) {
421  int sy1 = 0, sy2 = 16, sx1 = 0, sx2 = 16;
422 
423  if (s->blocks[y * s->nbx + x] == 0)
424  continue;
425 
426  if (((s->blocks[y * s->nbx + x] - 1) & 1) > 0) {
427  ret = decode_value(s, s->sxy_model[0], 16, 100, &sx1);
428  ret |= decode_value(s, s->sxy_model[1], 16, 100, &sy1);
429  ret |= decode_value(s, s->sxy_model[2], 16, 100, &sx2);
430  ret |= decode_value(s, s->sxy_model[3], 16, 100, &sy2);
431  if (ret < 0)
432  return ret;
433 
434  sx2++;
435  sy2++;
436  }
437  if (((s->blocks[y * s->nbx + x] - 1) & 2) > 0) {
438  int i, j, by = y * 16, bx = x * 16;
439  int mvx, mvy;
440 
441  ret = decode_value(s, s->mv_model[0], 512, 100, &mvx);
442  ret |= decode_value(s, s->mv_model[1], 512, 100, &mvy);
443  if (ret < 0)
444  return ret;
445 
446  mvx -= 256;
447  mvy -= 256;
448 
449  if (by + mvy + sy1 < 0 || bx + mvx + sx1 < 0 ||
450  by + mvy + sy1 >= avctx->height || bx + mvx + sx1 >= avctx->width)
451  return AVERROR_INVALIDDATA;
452 
453  for (i = 0; i < sy2 - sy1 && (by + sy1 + i) < avctx->height && (by + mvy + sy1 + i) < avctx->height; i++) {
454  for (j = 0; j < sx2 - sx1 && (bx + sx1 + j) < avctx->width && (bx + mvx + sx1 + j) < avctx->width; j++) {
455  dst[(by + i + sy1) * linesize + bx + sx1 + j] = prev[(by + mvy + sy1 + i) * plinesize + bx + sx1 + mvx + j];
456  }
457  }
458  } else {
459  int run, bx = x * 16 + sx1, by = y * 16 + sy1;
460  uint32_t r, g, b, clr, ptype = 0;
461 
462  for (; by < y * 16 + sy2 && by < avctx->height;) {
463  ret = decode_value(s, s->op_model[ptype], 6, 1000, &ptype);
464  if (ret < 0)
465  return ret;
466  if (ptype == 0) {
467  ret = decode_units(s, &r, &g, &b, &cx, &cx1);
468  if (ret < 0)
469  return ret;
470 
471  clr = (b << 16) + (g << 8) + r;
472  }
473  if (ptype > 5)
474  return AVERROR_INVALIDDATA;
475  ret = decode_value(s, s->run_model[ptype], 256, 400, &run);
476  if (ret < 0)
477  return ret;
478  if (run <= 0)
479  return AVERROR_INVALIDDATA;
480 
481  ret = decode_run_p(avctx, ptype, run, x, y, clr,
482  dst, prev, linesize, plinesize, &bx, &by,
483  backstep, sx1, sx2, &cx, &cx1);
484  if (ret < 0)
485  return ret;
486  }
487  }
488  }
489  }
490 
491  return 0;
492 }
493 
494 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
495  AVPacket *avpkt)
496 {
497  SCPRContext *s = avctx->priv_data;
498  GetByteContext *gb = &s->gb;
499  AVFrame *frame = data;
500  int ret, type;
501 
502  if (avctx->bits_per_coded_sample == 16) {
503  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
504  return ret;
505  }
506 
507  if ((ret = ff_reget_buffer(avctx, s->current_frame, 0)) < 0)
508  return ret;
509 
510  bytestream2_init(gb, avpkt->data, avpkt->size);
511 
512  type = bytestream2_peek_byte(gb);
513 
514  if (type == 2) {
515  s->version = 1;
516  s->get_freq = get_freq0;
517  s->decode = decode0;
518  frame->key_frame = 1;
519  ret = decompress_i(avctx, (uint32_t *)s->current_frame->data[0],
520  s->current_frame->linesize[0] / 4);
521  } else if (type == 18) {
522  s->version = 2;
523  s->get_freq = get_freq;
524  s->decode = decode;
525  frame->key_frame = 1;
526  ret = decompress_i(avctx, (uint32_t *)s->current_frame->data[0],
527  s->current_frame->linesize[0] / 4);
528  } else if (type == 34) {
529  frame->key_frame = 1;
530  s->version = 3;
531  ret = decompress_i3(avctx, (uint32_t *)s->current_frame->data[0],
532  s->current_frame->linesize[0] / 4);
533  } else if (type == 17 || type == 33) {
534  uint32_t clr, *dst = (uint32_t *)s->current_frame->data[0];
535  int y;
536 
538  return AVERROR_INVALIDDATA;
539 
540  frame->key_frame = 1;
541  bytestream2_skip(gb, 1);
542  if (avctx->bits_per_coded_sample == 16) {
543  uint16_t value = bytestream2_get_le16(gb);
544  int r, g, b;
545 
546  r = (value ) & 31;
547  g = (value >> 5) & 31;
548  b = (value >> 10) & 31;
549  clr = (r << 16) + (g << 8) + b;
550  } else {
551  clr = bytestream2_get_le24(gb);
552  }
553  for (y = 0; y < avctx->height; y++) {
554  dst[0] = clr;
555  av_memcpy_backptr((uint8_t*)(dst+1), 4, 4*avctx->width - 4);
556  dst += s->current_frame->linesize[0] / 4;
557  }
558  } else if (type == 0 || type == 1) {
559  frame->key_frame = 0;
560 
561  if (s->version == 1 || s->version == 2)
562  ret = decompress_p(avctx, (uint32_t *)s->current_frame->data[0],
563  s->current_frame->linesize[0] / 4,
564  (uint32_t *)s->last_frame->data[0],
565  s->last_frame->linesize[0] / 4);
566  else
567  ret = decompress_p3(avctx, (uint32_t *)s->current_frame->data[0],
568  s->current_frame->linesize[0] / 4,
569  (uint32_t *)s->last_frame->data[0],
570  s->last_frame->linesize[0] / 4);
571  if (ret == 1)
572  return avpkt->size;
573  } else {
574  return AVERROR_PATCHWELCOME;
575  }
576 
577  if (ret < 0)
578  return ret;
579 
580  if (bytestream2_get_bytes_left(gb) > 5)
581  return AVERROR_INVALIDDATA;
582 
583  if (avctx->bits_per_coded_sample != 16) {
584  ret = av_frame_ref(data, s->current_frame);
585  if (ret < 0)
586  return ret;
587  } else {
588  uint8_t *dst = frame->data[0];
589  int x, y;
590 
591  ret = av_frame_copy(frame, s->current_frame);
592  if (ret < 0)
593  return ret;
594 
595  // scale up each sample by 8
596  for (y = 0; y < avctx->height; y++) {
597  // If the image is sufficiently aligned, compute 8 samples at once
598  if (!(((uintptr_t)dst) & 7)) {
599  uint64_t *dst64 = (uint64_t *)dst;
600  int w = avctx->width>>1;
601  for (x = 0; x < w; x++) {
602  dst64[x] = (dst64[x] << 3) & 0xFCFCFCFCFCFCFCFCULL;
603  }
604  x *= 8;
605  } else
606  x = 0;
607  for (; x < avctx->width * 4; x++) {
608  dst[x] = dst[x] << 3;
609  }
610  dst += frame->linesize[0];
611  }
612  }
613 
615 
617 
618  frame->data[0] += frame->linesize[0] * (avctx->height - 1);
619  frame->linesize[0] *= -1;
620 
621  *got_frame = 1;
622 
623  return avpkt->size;
624 }
625 
627 {
628  SCPRContext *s = avctx->priv_data;
629 
630  switch (avctx->bits_per_coded_sample) {
631  case 16: avctx->pix_fmt = AV_PIX_FMT_RGB0; break;
632  case 24:
633  case 32: avctx->pix_fmt = AV_PIX_FMT_BGR0; break;
634  default:
635  av_log(avctx, AV_LOG_ERROR, "Unsupported bitdepth %i\n", avctx->bits_per_coded_sample);
636  return AVERROR_INVALIDDATA;
637  }
638 
639  s->get_freq = get_freq0;
640  s->decode = decode0;
641 
642  s->cxshift = avctx->bits_per_coded_sample == 16 ? 0 : 2;
643  s->cbits = avctx->bits_per_coded_sample == 16 ? 0x1F : 0xFF;
644  s->nbx = (avctx->width + 15) / 16;
645  s->nby = (avctx->height + 15) / 16;
646  s->nbcount = s->nbx * s->nby;
647  s->blocks = av_malloc_array(s->nbcount, sizeof(*s->blocks));
648  if (!s->blocks)
649  return AVERROR(ENOMEM);
650 
651  s->last_frame = av_frame_alloc();
653  if (!s->last_frame || !s->current_frame)
654  return AVERROR(ENOMEM);
655 
656  return 0;
657 }
658 
660 {
661  SCPRContext *s = avctx->priv_data;
662 
663  av_freep(&s->blocks);
666 
667  return 0;
668 }
669 
671  .name = "scpr",
672  .long_name = NULL_IF_CONFIG_SMALL("ScreenPressor"),
673  .type = AVMEDIA_TYPE_VIDEO,
674  .id = AV_CODEC_ID_SCPR,
675  .priv_data_size = sizeof(SCPRContext),
676  .init = decode_init,
677  .close = decode_close,
678  .decode = decode_frame,
679  .capabilities = AV_CODEC_CAP_DR1,
680  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
682 };
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:48
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
static int decode_value(SCPRContext *s, uint32_t *cnt, uint32_t maxc, uint32_t step, uint32_t *rval)
Definition: scpr.c:163
AVFrame * last_frame
Definition: scpr.h:49
static av_cold int decode_init(AVCodecContext *avctx)
Definition: scpr.c:626
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
PixelModel pixel_model[3][4096]
Definition: scpr.h:53
else temp
Definition: vf_mcdeint.c:256
const char * g
Definition: vf_curves.c:115
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
static int decode_unit(SCPRContext *s, PixelModel *pixel, uint32_t step, uint32_t *rval)
Definition: scpr.c:207
static void reinit_tables(SCPRContext *s)
Definition: scpr.c:45
uint32_t code1
Definition: scpr.h:38
int size
Definition: avcodec.h:1481
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1778
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
GLint GLenum type
Definition: opengl_enc.c:104
int(* get_freq)(RangeCoder *rc, uint32_t total_freq, uint32_t *freq)
Definition: scpr.h:76
uint32_t range
Definition: mss3.c:64
uint8_t run
Definition: svq3.c:206
static int decompress_i(AVCodecContext *avctx, uint32_t *dst, int linesize)
Definition: scpr.c:297
static int decompress_p(AVCodecContext *avctx, uint32_t *dst, int linesize, uint32_t *prev, int plinesize)
Definition: scpr.c:369
AVCodec.
Definition: avcodec.h:3492
uint32_t fill_model[6]
Definition: scpr.h:58
int version
Definition: scpr.h:48
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:40
uint8_t
#define av_cold
Definition: attributes.h:82
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:189
packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined
Definition: pixfmt.h:238
static int decode_units(SCPRContext *s, uint32_t *r, uint32_t *g, uint32_t *b, int *cx, int *cx1)
Definition: scpr.c:269
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:1017
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:443
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
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: scpr.c:494
#define height
uint8_t * data
Definition: avcodec.h:1480
void av_memcpy_backptr(uint8_t *dst, int back, int cnt)
Overlapping memcpy() implementation.
Definition: mem.c:426
#define max(a, b)
Definition: cuda_runtime.h:33
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:2792
uint32_t nby
Definition: scpr.h:61
AVFrame * current_frame
Definition: scpr.h:50
uint32_t sxy_model[4][17]
Definition: scpr.h:59
#define av_log(a,...)
#define U(x)
Definition: vp56_arith.h:37
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
RangeCoder rc
Definition: scpr.h:52
static av_cold int decode_close(AVCodecContext *avctx)
Definition: scpr.c:659
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:164
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Identical in function to ff_get_buffer(), except it reuses the existing buffer if available...
Definition: decode.c:2015
const char * r
Definition: vf_curves.c:114
uint32_t op_model[6][7]
Definition: scpr.h:54
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:154
int cxshift
Definition: scpr.h:65
uint32_t freq[256]
Definition: scpr.h:42
const char * name
Name of the codec implementation.
Definition: avcodec.h:3499
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:792
#define b
Definition: input.c:41
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:378
uint32_t run_model[6][257]
Definition: scpr.h:55
#define width
uint32_t nbcount
Definition: scpr.h:62
int width
picture width / height.
Definition: avcodec.h:1741
uint8_t w
Definition: llviddspenc.c:38
uint32_t count_model[257]
Definition: scpr.h:57
static int decode(GetByteContext *gb, RangeCoder *rc, uint32_t cumFreq, uint32_t freq, uint32_t total_freq)
Definition: scpr.c:102
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
static void init_rangecoder(RangeCoder *rc, GetByteContext *gb)
Definition: scpr.c:38
#define s(width, name)
Definition: cbs_vp9.c:257
if(ret)
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:83
uint32_t mv_model[2][513]
Definition: scpr.h:60
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
Libavcodec external API header.
static int decode0(GetByteContext *gb, RangeCoder *rc, uint32_t cumFreq, uint32_t freq, uint32_t total_freq)
Definition: scpr.c:131
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_WB16 unsigned int_TMPL byte
Definition: bytestream.h:87
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
main external API structure.
Definition: avcodec.h:1568
#define BOT
Definition: scpr.c:34
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1968
uint32_t * blocks
Definition: scpr.h:63
uint32_t code
Definition: scpr.h:36
uint32_t lookup[16]
Definition: scpr.h:43
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
Definition: pixfmt.h:240
uint32_t range_model[257]
Definition: scpr.h:56
AVCodec ff_scpr_decoder
Definition: scpr.c:670
#define TOP
Definition: scpr.c:33
uint32_t nbx
Definition: scpr.h:61
uint8_t pixel
Definition: tiny_ssim.c:42
uint32_t cbits
Definition: scpr.h:64
uint32_t total_freq
Definition: scpr.h:44
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
static int get_freq(RangeCoder *rc, uint32_t total_freq, uint32_t *freq)
Definition: scpr.c:116
GetByteContext gb
Definition: scpr.h:51
static int op(uint8_t **dst, const uint8_t *dst_end, GetByteContext *gb, int pixel, int count, int *x, int width, int linesize)
Perform decode operation.
Definition: anm.c:78
common internal api header.
static int get_freq0(RangeCoder *rc, uint32_t total_freq, uint32_t *freq)
Definition: scpr.c:153
int(* decode)(GetByteContext *gb, RangeCoder *rc, uint32_t cumFreq, uint32_t freq, uint32_t total_freq)
Definition: scpr.h:77
void * priv_data
Definition: avcodec.h:1595
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:373
#define av_freep(p)
static int decompress_i3(AVCodecContext *avctx, uint32_t *dst, int linesize)
Definition: scpr3.c:934
#define av_malloc_array(a, b)
#define FFSWAP(type, a, b)
Definition: common.h:99
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
float min
This structure stores compressed data.
Definition: avcodec.h:1457
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:984
for(j=16;j >0;--j)
Predicted.
Definition: avutil.h:275
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step