FFmpeg  4.4.4
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  if (bx >= avctx->width)
463  return AVERROR_INVALIDDATA;
464 
465  for (; by < y * 16 + sy2 && by < avctx->height;) {
466  ret = decode_value(s, s->op_model[ptype], 6, 1000, &ptype);
467  if (ret < 0)
468  return ret;
469  if (ptype == 0) {
470  ret = decode_units(s, &r, &g, &b, &cx, &cx1);
471  if (ret < 0)
472  return ret;
473 
474  clr = (b << 16) + (g << 8) + r;
475  }
476  if (ptype > 5)
477  return AVERROR_INVALIDDATA;
478  ret = decode_value(s, s->run_model[ptype], 256, 400, &run);
479  if (ret < 0)
480  return ret;
481  if (run <= 0)
482  return AVERROR_INVALIDDATA;
483 
484  ret = decode_run_p(avctx, ptype, run, x, y, clr,
485  dst, prev, linesize, plinesize, &bx, &by,
486  backstep, sx1, sx2, &cx, &cx1);
487  if (ret < 0)
488  return ret;
489  }
490  }
491  }
492  }
493 
494  return 0;
495 }
496 
497 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
498  AVPacket *avpkt)
499 {
500  SCPRContext *s = avctx->priv_data;
501  GetByteContext *gb = &s->gb;
502  AVFrame *frame = data;
503  int ret, type;
504 
505  if (avctx->bits_per_coded_sample == 16) {
506  if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
507  return ret;
508  }
509 
510  if ((ret = ff_reget_buffer(avctx, s->current_frame, 0)) < 0)
511  return ret;
512 
513  bytestream2_init(gb, avpkt->data, avpkt->size);
514 
515  type = bytestream2_peek_byte(gb);
516 
517  if (type == 2) {
518  s->version = 1;
519  s->get_freq = get_freq0;
520  s->decode = decode0;
521  frame->key_frame = 1;
522  ret = decompress_i(avctx, (uint32_t *)s->current_frame->data[0],
523  s->current_frame->linesize[0] / 4);
524  } else if (type == 18) {
525  s->version = 2;
526  s->get_freq = get_freq;
527  s->decode = decode;
528  frame->key_frame = 1;
529  ret = decompress_i(avctx, (uint32_t *)s->current_frame->data[0],
530  s->current_frame->linesize[0] / 4);
531  } else if (type == 34) {
532  frame->key_frame = 1;
533  s->version = 3;
534  ret = decompress_i3(avctx, (uint32_t *)s->current_frame->data[0],
535  s->current_frame->linesize[0] / 4);
536  } else if (type == 17 || type == 33) {
537  uint32_t clr, *dst = (uint32_t *)s->current_frame->data[0];
538  int y;
539 
541  return AVERROR_INVALIDDATA;
542 
543  frame->key_frame = 1;
544  bytestream2_skip(gb, 1);
545  if (avctx->bits_per_coded_sample == 16) {
546  uint16_t value = bytestream2_get_le16(gb);
547  int r, g, b;
548 
549  r = (value ) & 31;
550  g = (value >> 5) & 31;
551  b = (value >> 10) & 31;
552  clr = (r << 16) + (g << 8) + b;
553  } else {
554  clr = bytestream2_get_le24(gb);
555  }
556  for (y = 0; y < avctx->height; y++) {
557  dst[0] = clr;
558  av_memcpy_backptr((uint8_t*)(dst+1), 4, 4*avctx->width - 4);
559  dst += s->current_frame->linesize[0] / 4;
560  }
561  } else if (type == 0 || type == 1) {
562  frame->key_frame = 0;
563 
564  if (s->version == 1 || s->version == 2)
565  ret = decompress_p(avctx, (uint32_t *)s->current_frame->data[0],
566  s->current_frame->linesize[0] / 4,
567  (uint32_t *)s->last_frame->data[0],
568  s->last_frame->linesize[0] / 4);
569  else
570  ret = decompress_p3(avctx, (uint32_t *)s->current_frame->data[0],
571  s->current_frame->linesize[0] / 4,
572  (uint32_t *)s->last_frame->data[0],
573  s->last_frame->linesize[0] / 4);
574  if (ret == 1)
575  return avpkt->size;
576  } else {
577  return AVERROR_PATCHWELCOME;
578  }
579 
580  if (ret < 0)
581  return ret;
582 
583  if (bytestream2_get_bytes_left(gb) > 5)
584  return AVERROR_INVALIDDATA;
585 
586  if (avctx->bits_per_coded_sample != 16) {
587  ret = av_frame_ref(data, s->current_frame);
588  if (ret < 0)
589  return ret;
590  } else {
591  uint8_t *dst = frame->data[0];
592  int x, y;
593 
594  ret = av_frame_copy(frame, s->current_frame);
595  if (ret < 0)
596  return ret;
597 
598  // scale up each sample by 8
599  for (y = 0; y < avctx->height; y++) {
600  // If the image is sufficiently aligned, compute 8 samples at once
601  if (!(((uintptr_t)dst) & 7)) {
602  uint64_t *dst64 = (uint64_t *)dst;
603  int w = avctx->width>>1;
604  for (x = 0; x < w; x++) {
605  dst64[x] = (dst64[x] << 3) & 0xFCFCFCFCFCFCFCFCULL;
606  }
607  x *= 8;
608  } else
609  x = 0;
610  for (; x < avctx->width * 4; x++) {
611  dst[x] = dst[x] << 3;
612  }
613  dst += frame->linesize[0];
614  }
615  }
616 
618 
619  FFSWAP(AVFrame *, s->current_frame, s->last_frame);
620 
621  frame->data[0] += frame->linesize[0] * (avctx->height - 1);
622  frame->linesize[0] *= -1;
623 
624  *got_frame = 1;
625 
626  return avpkt->size;
627 }
628 
630 {
631  SCPRContext *s = avctx->priv_data;
632 
633  switch (avctx->bits_per_coded_sample) {
634  case 16: avctx->pix_fmt = AV_PIX_FMT_RGB0; break;
635  case 24:
636  case 32: avctx->pix_fmt = AV_PIX_FMT_BGR0; break;
637  default:
638  av_log(avctx, AV_LOG_ERROR, "Unsupported bitdepth %i\n", avctx->bits_per_coded_sample);
639  return AVERROR_INVALIDDATA;
640  }
641 
642  s->get_freq = get_freq0;
643  s->decode = decode0;
644 
645  s->cxshift = avctx->bits_per_coded_sample == 16 ? 0 : 2;
646  s->cbits = avctx->bits_per_coded_sample == 16 ? 0x1F : 0xFF;
647  s->nbx = (avctx->width + 15) / 16;
648  s->nby = (avctx->height + 15) / 16;
649  s->nbcount = s->nbx * s->nby;
650  s->blocks = av_malloc_array(s->nbcount, sizeof(*s->blocks));
651  if (!s->blocks)
652  return AVERROR(ENOMEM);
653 
654  s->last_frame = av_frame_alloc();
655  s->current_frame = av_frame_alloc();
656  if (!s->last_frame || !s->current_frame)
657  return AVERROR(ENOMEM);
658 
659  return 0;
660 }
661 
663 {
664  SCPRContext *s = avctx->priv_data;
665 
666  av_freep(&s->blocks);
667  av_frame_free(&s->last_frame);
668  av_frame_free(&s->current_frame);
669 
670  return 0;
671 }
672 
674  .name = "scpr",
675  .long_name = NULL_IF_CONFIG_SMALL("ScreenPressor"),
676  .type = AVMEDIA_TYPE_VIDEO,
677  .id = AV_CODEC_ID_SCPR,
678  .priv_data_size = sizeof(SCPRContext),
679  .init = decode_init,
680  .close = decode_close,
681  .decode = decode_frame,
682  .capabilities = AV_CODEC_CAP_DR1,
683  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
685 };
#define av_cold
Definition: attributes.h:88
uint8_t
Libavcodec external API header.
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
#define s(width, name)
Definition: cbs_vp9.c:257
#define FFSWAP(type, a, b)
Definition: common.h:108
#define max(a, b)
Definition: cuda_runtime.h:33
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1900
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:2007
static AVFrame * frame
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:85
double value
Definition: eval.c:98
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
@ AV_CODEC_ID_SCPR
Definition: codec_id.h:276
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define AVERROR(e)
Definition: error.h:43
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
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
Definition: frame.c:799
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
void av_memcpy_backptr(uint8_t *dst, int back, int cnt)
Overlapping memcpy() implementation.
Definition: mem.c:428
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
for(j=16;j >0;--j)
cl_device_type type
int i
Definition: input.c:407
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:75
#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:41
#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:49
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
uint8_t w
Definition: llviddspenc.c:39
const char data[16]
Definition: mxf.c:142
@ AV_PIX_FMT_BGR0
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
Definition: pixfmt.h:240
@ AV_PIX_FMT_RGB0
packed RGB 8:8:8, 32bpp, RGBXRGBX... X=unused/undefined
Definition: pixfmt.h:238
static int decompress_p3(AVCodecContext *avctx, uint32_t *dst, int linesize, uint32_t *prev, int plinesize)
Definition: scpr3.c:1012
static int decompress_i3(AVCodecContext *avctx, uint32_t *dst, int linesize)
Definition: scpr3.c:929
static int decode_value(SCPRContext *s, uint32_t *cnt, uint32_t maxc, uint32_t step, uint32_t *rval)
Definition: scpr.c:163
static int decode_unit(SCPRContext *s, PixelModel *pixel, uint32_t step, uint32_t *rval)
Definition: scpr.c:207
static void init_rangecoder(RangeCoder *rc, GetByteContext *gb)
Definition: scpr.c:38
static void reinit_tables(SCPRContext *s)
Definition: scpr.c:45
static int decode0(GetByteContext *gb, RangeCoder *rc, uint32_t cumFreq, uint32_t freq, uint32_t total_freq)
Definition: scpr.c:131
static av_cold int decode_close(AVCodecContext *avctx)
Definition: scpr.c:662
static int get_freq(RangeCoder *rc, uint32_t total_freq, uint32_t *freq)
Definition: scpr.c:116
static av_cold int decode_init(AVCodecContext *avctx)
Definition: scpr.c:629
static int decompress_i(AVCodecContext *avctx, uint32_t *dst, int linesize)
Definition: scpr.c:297
#define BOT
Definition: scpr.c:34
static int decode(GetByteContext *gb, RangeCoder *rc, uint32_t cumFreq, uint32_t freq, uint32_t total_freq)
Definition: scpr.c:102
static int decompress_p(AVCodecContext *avctx, uint32_t *dst, int linesize, uint32_t *prev, int plinesize)
Definition: scpr.c:369
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: scpr.c:497
static int decode_units(SCPRContext *s, uint32_t *r, uint32_t *g, uint32_t *b, int *cx, int *cx1)
Definition: scpr.c:269
AVCodec ff_scpr_decoder
Definition: scpr.c:673
static int get_freq0(RangeCoder *rc, uint32_t total_freq, uint32_t *freq)
Definition: scpr.c:153
#define TOP
Definition: scpr.c:33
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_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
main external API structure.
Definition: avcodec.h:536
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:746
int width
picture width / height.
Definition: avcodec.h:709
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1740
void * priv_data
Definition: avcodec.h:563
AVCodec.
Definition: codec.h:197
const char * name
Name of the codec implementation.
Definition: codec.h:204
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:396
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:349
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:401
This structure stores compressed data.
Definition: packet.h:346
int size
Definition: packet.h:370
uint8_t * data
Definition: packet.h:369
uint32_t code
Definition: scpr.h:36
uint32_t range
Definition: mss3.c:64
uint32_t code1
Definition: scpr.h:38
uint8_t run
Definition: svq3.c:205
#define av_malloc_array(a, b)
#define av_freep(p)
#define av_log(a,...)
#define height
#define width
uint8_t pixel
Definition: tiny_ssim.c:42
const char * b
Definition: vf_curves.c:118
const char * g
Definition: vf_curves.c:117
const char * r
Definition: vf_curves.c:116
else temp
Definition: vf_mcdeint.c:259
if(ret< 0)
Definition: vf_mcdeint.c:282
float min
static double c[64]