FFmpeg  4.2.2
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)
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 
537  frame->key_frame = 1;
538  bytestream2_skip(gb, 1);
539  if (avctx->bits_per_coded_sample == 16) {
540  uint16_t value = bytestream2_get_le16(gb);
541  int r, g, b;
542 
543  r = (value ) & 31;
544  g = (value >> 5) & 31;
545  b = (value >> 10) & 31;
546  clr = (r << 16) + (g << 8) + b;
547  } else {
548  clr = bytestream2_get_le24(gb);
549  }
550  for (y = 0; y < avctx->height; y++) {
551  dst[0] = clr;
552  av_memcpy_backptr((uint8_t*)(dst+1), 4, 4*avctx->width - 4);
553  dst += s->current_frame->linesize[0] / 4;
554  }
555  } else if (type == 0 || type == 1) {
556  frame->key_frame = 0;
557 
558  if (s->version == 1 || s->version == 2)
559  ret = decompress_p(avctx, (uint32_t *)s->current_frame->data[0],
560  s->current_frame->linesize[0] / 4,
561  (uint32_t *)s->last_frame->data[0],
562  s->last_frame->linesize[0] / 4);
563  else
564  ret = decompress_p3(avctx, (uint32_t *)s->current_frame->data[0],
565  s->current_frame->linesize[0] / 4,
566  (uint32_t *)s->last_frame->data[0],
567  s->last_frame->linesize[0] / 4);
568  if (ret == 1)
569  return avpkt->size;
570  } else {
571  return AVERROR_PATCHWELCOME;
572  }
573 
574  if (ret < 0)
575  return ret;
576 
577  if (bytestream2_get_bytes_left(gb) > 5)
578  return AVERROR_INVALIDDATA;
579 
580  if (avctx->bits_per_coded_sample != 16) {
581  ret = av_frame_ref(data, s->current_frame);
582  if (ret < 0)
583  return ret;
584  } else {
585  uint8_t *dst = frame->data[0];
586  int x, y;
587 
588  ret = av_frame_copy(frame, s->current_frame);
589  if (ret < 0)
590  return ret;
591 
592  // scale up each sample by 8
593  for (y = 0; y < avctx->height; y++) {
594  // If the image is sufficiently aligned, compute 8 samples at once
595  if (!(((uintptr_t)dst) & 7)) {
596  uint64_t *dst64 = (uint64_t *)dst;
597  int w = avctx->width>>1;
598  for (x = 0; x < w; x++) {
599  dst64[x] = (dst64[x] << 3) & 0xFCFCFCFCFCFCFCFCULL;
600  }
601  x *= 8;
602  } else
603  x = 0;
604  for (; x < avctx->width * 4; x++) {
605  dst[x] = dst[x] << 3;
606  }
607  dst += frame->linesize[0];
608  }
609  }
610 
612 
614 
615  frame->data[0] += frame->linesize[0] * (avctx->height - 1);
616  frame->linesize[0] *= -1;
617 
618  *got_frame = 1;
619 
620  return avpkt->size;
621 }
622 
624 {
625  SCPRContext *s = avctx->priv_data;
626 
627  switch (avctx->bits_per_coded_sample) {
628  case 16: avctx->pix_fmt = AV_PIX_FMT_RGB0; break;
629  case 24:
630  case 32: avctx->pix_fmt = AV_PIX_FMT_BGR0; break;
631  default:
632  av_log(avctx, AV_LOG_ERROR, "Unsupported bitdepth %i\n", avctx->bits_per_coded_sample);
633  return AVERROR_INVALIDDATA;
634  }
635 
636  s->get_freq = get_freq0;
637  s->decode = decode0;
638 
639  s->cxshift = avctx->bits_per_coded_sample == 16 ? 0 : 2;
640  s->cbits = avctx->bits_per_coded_sample == 16 ? 0x1F : 0xFF;
641  s->nbx = (avctx->width + 15) / 16;
642  s->nby = (avctx->height + 15) / 16;
643  s->nbcount = s->nbx * s->nby;
644  s->blocks = av_malloc_array(s->nbcount, sizeof(*s->blocks));
645  if (!s->blocks)
646  return AVERROR(ENOMEM);
647 
648  s->last_frame = av_frame_alloc();
650  if (!s->last_frame || !s->current_frame)
651  return AVERROR(ENOMEM);
652 
653  return 0;
654 }
655 
657 {
658  SCPRContext *s = avctx->priv_data;
659 
660  av_freep(&s->blocks);
663 
664  return 0;
665 }
666 
668  .name = "scpr",
669  .long_name = NULL_IF_CONFIG_SMALL("ScreenPressor"),
670  .type = AVMEDIA_TYPE_VIDEO,
671  .id = AV_CODEC_ID_SCPR,
672  .priv_data_size = sizeof(SCPRContext),
673  .init = decode_init,
674  .close = decode_close,
675  .decode = decode_frame,
676  .capabilities = AV_CODEC_CAP_DR1,
677  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
679 };
#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:623
#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
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:1478
const char * b
Definition: vf_curves.c:116
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1775
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
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:3481
int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame)
Identical in function to av_frame_make_writable(), except it uses ff_get_buffer() to allocate the buf...
Definition: decode.c:2011
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
static int decompress_p3(AVCodecContext *avctx, uint32_t *dst, int linesize, uint32_t *prev, int plinesize)
Definition: scpr3.c:1017
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 AVFrame * frame
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
const char data[16]
Definition: mxf.c:91
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:1477
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:2789
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:656
#define AVERROR(e)
Definition: error.h:43
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
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:3488
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
Definition: frame.c:792
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:1738
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
static void init_rangecoder(RangeCoder *rc, GetByteContext *gb)
Definition: scpr.c:38
#define s(width, name)
Definition: cbs_vp9.c:257
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
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:1565
#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:1964
uint32_t * blocks
Definition: scpr.h:63
double value
Definition: eval.c:98
cl_device_type type
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:667
#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
static double c[64]
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:1592
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:373
#define av_freep(p)
void INT64 INT64 count
Definition: avisynth_c.h:766
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
float min
This structure stores compressed data.
Definition: avcodec.h:1454
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:981
for(j=16;j >0;--j)
Predicted.
Definition: avutil.h:275