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)
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 
611  frame->pict_type = frame->key_frame ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
612 
613  FFSWAP(AVFrame *, s->current_frame, s->last_frame);
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();
649  s->current_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);
661  av_frame_free(&s->last_frame);
662  av_frame_free(&s->current_frame);
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 };
RangeCoder::range
uint32_t range
Definition: mss3.c:64
TOP
#define TOP
Definition: scpr.c:33
AVCodec
AVCodec.
Definition: avcodec.h:3481
FF_CODEC_CAP_INIT_THREADSAFE
#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
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
r
const char * r
Definition: vf_curves.c:114
AVERROR
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
FFSWAP
#define FFSWAP(type, a, b)
Definition: common.h:99
comp
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:83
GetByteContext
Definition: bytestream.h:33
decode_close
static av_cold int decode_close(AVCodecContext *avctx)
Definition: scpr.c:656
count
void INT64 INT64 count
Definition: avisynth_c.h:767
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
get_freq0
static int get_freq0(RangeCoder *rc, uint32_t total_freq, uint32_t *freq)
Definition: scpr.c:153
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
step
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
Definition: rate_distortion.txt:58
w
uint8_t w
Definition: llviddspenc.c:38
internal.h
AVPacket::data
uint8_t * data
Definition: avcodec.h:1477
b
#define b
Definition: input.c:41
data
const char data[16]
Definition: mxf.c:91
RangeCoder::code1
uint32_t code1
Definition: scpr.h:38
ff_reget_buffer
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:2012
max
#define max(a, b)
Definition: cuda_runtime.h:33
bytestream2_get_bytes_left
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:154
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:164
U
#define U(x)
Definition: vp56_arith.h:37
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
PixelModel
Definition: scpr.h:41
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:189
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
av_cold
#define av_cold
Definition: attributes.h:84
decompress_p
static int decompress_p(AVCodecContext *avctx, uint32_t *dst, int linesize, uint32_t *prev, int plinesize)
Definition: scpr.c:369
av_memcpy_backptr
void av_memcpy_backptr(uint8_t *dst, int back, int cnt)
Overlapping memcpy() implementation.
Definition: mem.c:426
width
#define width
s
#define s(width, name)
Definition: cbs_vp9.c:257
g
const char * g
Definition: vf_curves.c:115
op
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
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:80
BOT
#define BOT
Definition: scpr.c:34
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition: scpr.c:623
ff_scpr_decoder
AVCodec ff_scpr_decoder
Definition: scpr.c:667
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
run
uint8_t run
Definition: svq3.c:206
pixel
uint8_t pixel
Definition: tiny_ssim.c:42
scpr3.h
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
get_freq
static int get_freq(RangeCoder *rc, uint32_t total_freq, uint32_t *freq)
Definition: scpr.c:116
AV_PIX_FMT_BGR0
@ AV_PIX_FMT_BGR0
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
Definition: pixfmt.h:240
reinit_tables
static void reinit_tables(SCPRContext *s)
Definition: scpr.c:45
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
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
decode_frame
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: scpr.c:494
scpr3.c
decompress_i
static int decompress_i(AVCodecContext *avctx, uint32_t *dst, int linesize)
Definition: scpr.c:297
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1965
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:981
AV_CODEC_ID_SCPR
@ AV_CODEC_ID_SCPR
Definition: avcodec.h:440
AVPacket::size
int size
Definition: avcodec.h:1478
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:188
av_frame_ref
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
av_frame_copy
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
Definition: frame.c:792
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:222
decode_value
static int decode_value(SCPRContext *s, uint32_t *cnt, uint32_t maxc, uint32_t step, uint32_t *rval)
Definition: scpr.c:163
SCPRContext
Definition: scpr.h:47
height
#define height
AV_PIX_FMT_RGB0
@ AV_PIX_FMT_RGB0
packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined
Definition: pixfmt.h:238
decode_units
static int decode_units(SCPRContext *s, uint32_t *r, uint32_t *g, uint32_t *b, int *cx, int *cx1)
Definition: scpr.c:269
decompress_i3
static int decompress_i3(AVCodecContext *avctx, uint32_t *dst, int linesize)
Definition: scpr3.c:945
RangeCoder::code
uint32_t code
Definition: scpr.h:36
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:2789
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
FF_CODEC_CAP_INIT_CLEANUP
#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
decode_unit
static int decode_unit(SCPRContext *s, PixelModel *pixel, uint32_t step, uint32_t *rval)
Definition: scpr.c:207
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:32
decompress_p3
static int decompress_p3(AVCodecContext *avctx, uint32_t *dst, int linesize, uint32_t *prev, int plinesize)
Definition: scpr3.c:1028
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
uint8_t
uint8_t
Definition: audio_convert.c:194
AVCodec::name
const char * name
Name of the codec implementation.
Definition: avcodec.h:3488
AVCodecContext::height
int height
Definition: avcodec.h:1738
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1775
avcodec.h
ret
ret
Definition: filter_design.txt:187
frame
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
Definition: filter_design.txt:264
decode0
static int decode0(GetByteContext *gb, RangeCoder *rc, uint32_t cumFreq, uint32_t freq, uint32_t total_freq)
Definition: scpr.c:131
decode
static int decode(GetByteContext *gb, RangeCoder *rc, uint32_t cumFreq, uint32_t freq, uint32_t total_freq)
Definition: scpr.c:102
AVCodecContext
main external API structure.
Definition: avcodec.h:1565
scpr.h
temp
else temp
Definition: vf_mcdeint.c:256
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1454
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:1592
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:1738
bytestream.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
RangeCoder
Definition: mss3.c:61
init_rangecoder
static void init_rangecoder(RangeCoder *rc, GetByteContext *gb)
Definition: scpr.c:38
min
float min
Definition: vorbis_enc_data.h:456