avcodec: add ScreenPressor decoder
[ffmpeg.git] / libavcodec / scpr.c
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
31 #define TOP  0x01000000
32 #define BOT    0x010000
33
34 typedef struct RangeCoder {
35     unsigned   code;
36     unsigned   range;
37 } RangeCoder;
38
39 typedef struct PixelModel {
40     unsigned    freq[256];
41     unsigned    lookup[16];
42     unsigned    total_freq;
43 } PixelModel;
44
45 typedef struct SCPRContext {
46     AVFrame        *last_frame;
47     AVFrame        *current_frame;
48     GetByteContext  gb;
49     RangeCoder      rc;
50     PixelModel      pixel_model[3][4096];
51     unsigned        op_model[6][7];
52     unsigned        run_model[6][257];
53     unsigned        range_model[257];
54     unsigned        count_model[257];
55     unsigned        fill_model[6];
56     unsigned        sxy_model[4][17];
57     unsigned        mv_model[2][513];
58     unsigned        nbx, nby;
59     unsigned        nbcount;
60     unsigned       *blocks;
61     int             cxshift;
62 } SCPRContext;
63
64 static void init_rangecoder(RangeCoder *rc, GetByteContext *gb)
65 {
66     rc->range = 0xFFFFFFFFU;
67     rc->code  = bytestream2_get_be32(gb);
68 }
69
70 static void reinit_tables(SCPRContext *s)
71 {
72     int comp, i, j;
73
74     for (comp = 0; comp < 3; comp++) {
75         for (j = 0; j < 4096; j++) {
76             if (s->pixel_model[comp][j].total_freq != 256) {
77                 for (i = 0; i < 256; i++)
78                     s->pixel_model[comp][j].freq[i] = 1;
79                 for (i = 0; i < 16; i++)
80                     s->pixel_model[comp][j].lookup[i] = 16;
81                 s->pixel_model[comp][j].total_freq = 256;
82             }
83         }
84     }
85
86     for (j = 0; j < 6; j++) {
87         unsigned *p = s->run_model[j];
88         for (i = 0; i < 256; i++)
89             p[i] = 1;
90         p[256] = 256;
91     }
92
93     for (j = 0; j < 6; j++) {
94         unsigned *op = s->op_model[j];
95         for (i = 0; i < 6; i++)
96             op[i] = 1;
97         op[6] = 6;
98     }
99
100     for (i = 0; i < 256; i++) {
101         s->range_model[i] = 1;
102         s->count_model[i] = 1;
103     }
104     s->range_model[256] = 256;
105     s->count_model[256] = 256;
106
107     for (i = 0; i < 5; i++) {
108         s->fill_model[i] = 1;
109     }
110     s->fill_model[5] = 5;
111
112     for (j = 0; j < 4; j++) {
113         for (i = 0; i < 16; i++) {
114             s->sxy_model[j][i] = 1;
115         }
116         s->sxy_model[j][16] = 16;
117     }
118
119     for (i = 0; i < 512; i++) {
120         s->mv_model[0][i] = 1;
121         s->mv_model[1][i] = 1;
122     }
123     s->mv_model[0][512] = 512;
124     s->mv_model[1][512] = 512;
125 }
126
127 static void decode(GetByteContext *gb, RangeCoder *rc, unsigned cumFreq, unsigned freq, unsigned total_freq)
128 {
129     rc->code -= cumFreq * rc->range;
130     rc->range *= freq;
131
132     while (rc->range < TOP && bytestream2_get_bytes_left(gb) > 0) {
133         unsigned byte = bytestream2_get_byte(gb);
134         rc->code = (rc->code << 8) | byte;
135         rc->range <<= 8;
136     }
137 }
138
139 static int get_freq(RangeCoder *rc, unsigned total_freq, unsigned *freq)
140 {
141     if (total_freq == 0)
142         return AVERROR_INVALIDDATA;
143
144     rc->range = rc->range / total_freq;
145
146     if (rc->range == 0)
147         return AVERROR_INVALIDDATA;
148
149     *freq = rc->code / rc->range;
150
151     return 0;
152 }
153
154 static int decode_value(SCPRContext *s, unsigned *cnt, unsigned maxc, unsigned step, unsigned *rval)
155 {
156     GetByteContext *gb = &s->gb;
157     RangeCoder *rc = &s->rc;
158     unsigned totfr = cnt[maxc];
159     unsigned value;
160     unsigned c = 0, cumfr = 0, cnt_c = 0;
161     int i, ret;
162
163     if ((ret = get_freq(rc, totfr, &value)) < 0)
164         return ret;
165
166     while (c < maxc) {
167         cnt_c = cnt[c];
168         if (value >= cumfr + cnt_c)
169             cumfr += cnt_c;
170         else
171             break;
172         c++;
173     }
174     decode(gb, rc, cumfr, cnt_c, totfr);
175
176     cnt[c] = cnt_c + step;
177     totfr += step;
178     if (totfr > BOT) {
179         totfr = 0;
180         for (i = 0; i < maxc; i++) {
181             unsigned nc = (cnt[i] >> 1) + 1;
182             cnt[i] = nc;
183             totfr += nc;
184         }
185     }
186
187     cnt[maxc] = totfr;
188     *rval = c;
189
190     return 0;
191 }
192
193 static int decode_unit(SCPRContext *s, PixelModel *pixel, unsigned step, unsigned *rval)
194 {
195     GetByteContext *gb = &s->gb;
196     RangeCoder *rc = &s->rc;
197     unsigned totfr = pixel->total_freq;
198     unsigned value, x = 0, cumfr = 0, cnt_x = 0;
199     int i, j, ret, c, cnt_c;
200
201     if ((ret = get_freq(rc, totfr, &value)) < 0)
202         return ret;
203
204     while (x < 16) {
205         cnt_x = pixel->lookup[x];
206         if (value >= cumfr + cnt_x)
207             cumfr += cnt_x;
208         else
209             break;
210         x++;
211     }
212
213     c = x * 16;
214     cnt_c = 0;
215     while (c < 256) {
216         cnt_c = pixel->freq[c];
217         if (value >= cumfr + cnt_c)
218             cumfr += cnt_c;
219         else
220             break;
221         c++;
222     }
223     decode(gb, rc, cumfr, cnt_c, totfr);
224     pixel->freq[c] = cnt_c + step;
225     pixel->lookup[x] = cnt_x + step;
226     totfr += step;
227     if (totfr > BOT) {
228         totfr = 0;
229         for (i = 0; i < 256; i++) {
230             unsigned nc = (pixel->freq[i] >> 1) + 1;
231             pixel->freq[i] = nc;
232             totfr += nc;
233         }
234         for (i = 0; i < 16; i++) {
235             unsigned sum = 0;
236             unsigned i16_17 = i << 4;
237             for (j = 0; j < 16; j++)
238                 sum += pixel->freq[i16_17 + j];
239             pixel->lookup[i] = sum;
240         }
241     }
242     pixel->total_freq = totfr;
243
244     *rval = c;
245
246     return 0;
247 }
248
249 static int decompress_i(AVCodecContext *avctx, uint32_t *dst, int linesize)
250 {
251     SCPRContext *s = avctx->priv_data;
252     GetByteContext *gb = &s->gb;
253     int cx = 0, cx1 = 0, k = 0, clr = 0;
254     int run, r, g, b, off, y = 0, x = 0, ret;
255     const int cxshift = s->cxshift;
256     unsigned lx, ly, ptype;
257
258     reinit_tables(s);
259     bytestream2_skip(gb, 2);
260     init_rangecoder(&s->rc, gb);
261
262     while (k < avctx->width + 1) {
263         ret = decode_unit(s, &s->pixel_model[0][cx + cx1], 400, &r);
264         if (ret < 0)
265             return ret;
266
267         cx1 = (cx << 6) & 0xFC0;
268         cx = r >> cxshift;
269         ret = decode_unit(s, &s->pixel_model[1][cx + cx1], 400, &g);
270         if (ret < 0)
271             return ret;
272
273         cx1 = (cx << 6) & 0xFC0;
274         cx = g >> cxshift;
275         ret = decode_unit(s, &s->pixel_model[2][cx + cx1], 400, &b);
276         if (ret < 0)
277             return ret;
278
279         cx1 = (cx << 6) & 0xFC0;
280         cx = b >> cxshift;
281
282         ret = decode_value(s, s->run_model[0], 256, 400, &run);
283         if (ret < 0)
284             return ret;
285
286         clr = (b << 16) + (g << 8) + r;
287         k += run;
288         while (run-- > 0) {
289             dst[y * linesize + x] = clr;
290             lx = x;
291             ly = y;
292             x++;
293             if (x >= avctx->width) {
294                 x = 0;
295                 y++;
296             }
297         }
298     }
299     off = -linesize - 1;
300     ptype = 0;
301
302     while (x < avctx->width && y < avctx->height) {
303         ret = decode_value(s, s->op_model[ptype], 6, 1000, &ptype);
304         if (ret < 0)
305             return ret;
306         if (ptype == 0) {
307             ret = decode_unit(s, &s->pixel_model[0][cx + cx1], 400, &r);
308             if (ret < 0)
309                 return ret;
310
311             cx1 = (cx << 6) & 0xFC0;
312             cx = r >> cxshift;
313             ret = decode_unit(s, &s->pixel_model[1][cx + cx1], 400, &g);
314             if (ret < 0)
315                 return ret;
316
317             cx1 = (cx << 6) & 0xFC0;
318             cx = g >> cxshift;
319             ret = decode_unit(s, &s->pixel_model[2][cx + cx1], 400, &b);
320             if (ret < 0)
321                 return ret;
322
323             cx1 = (cx << 6) & 0xFC0;
324             cx = b >> cxshift;
325             clr = (b << 16) + (g << 8) + r;
326         }
327         if (ptype > 5)
328             return AVERROR_INVALIDDATA;
329         ret = decode_value(s, s->run_model[ptype], 256, 400, &run);
330         if (ret < 0)
331             return ret;
332
333         switch (ptype) {
334         case 0:
335             while (run-- > 0) {
336                 dst[y * linesize + x] = clr;
337                 lx = x;
338                 ly = y;
339                 x++;
340                 if (x >= avctx->width) {
341                     x = 0;
342                     y++;
343                 }
344             }
345             break;
346         case 1:
347             while (run-- > 0) {
348                 dst[y * linesize + x] = dst[ly * linesize + lx];
349                 lx = x;
350                 ly = y;
351                 x++;
352                 if (x >= avctx->width) {
353                     x = 0;
354                     y++;
355                 }
356             }
357             clr = dst[ly * linesize + lx];
358             break;
359         case 2:
360             while (run-- > 0) {
361                 clr = dst[y * linesize + x + off + 1];
362                 dst[y * linesize + x] = clr;
363                 lx = x;
364                 ly = y;
365                 x++;
366                 if (x >= avctx->width) {
367                     x = 0;
368                     y++;
369                 }
370             }
371             break;
372         case 4:
373             while (run-- > 0) {
374                 uint8_t *odst = (uint8_t *)dst;
375                 r = odst[(ly * linesize + lx) * 4] +
376                     odst[((y * linesize + x) + off) * 4 + 4] -
377                     odst[((y * linesize + x) + off) * 4];
378                 g = odst[(ly * linesize + lx) * 4 + 1] +
379                     odst[((y * linesize + x) + off) * 4 + 5] -
380                     odst[((y * linesize + x) + off) * 4 + 1];
381                 b = odst[(ly * linesize + lx) * 4 + 2] +
382                     odst[((y * linesize + x) + off) * 4 + 6] -
383                     odst[((y * linesize + x) + off) * 4 + 2];
384                 clr = ((b & 0xFF) << 16) + ((g & 0xFF) << 8) + (r & 0xFF);
385                 dst[y * linesize + x] = clr;
386                 lx = x;
387                 ly = y;
388                 x++;
389                 if (x >= avctx->width) {
390                     x = 0;
391                     y++;
392                 }
393             }
394             break;
395         case 5:
396             while (run-- > 0) {
397                 clr = dst[y * linesize + x + off];
398                 dst[y * linesize + x] = clr;
399                 lx = x;
400                 ly = y;
401                 x++;
402                 if (x >= avctx->width) {
403                     x = 0;
404                     y++;
405                 }
406             }
407             break;
408         }
409
410         if (avctx->bits_per_coded_sample == 16) {
411             cx1 = (clr & 0xFF00) >> 2;
412             cx = (clr & 0xFFFFFF) >> 16;
413         } else {
414             cx1 = (clr & 0xFC00) >> 4;
415             cx = (clr & 0xFFFFFF) >> 18;
416         }
417     }
418
419     return 0;
420 }
421
422 static int decompress_p(AVCodecContext *avctx,
423                         uint32_t *dst, int linesize,
424                         uint32_t *prev, int plinesize)
425 {
426     SCPRContext *s = avctx->priv_data;
427     GetByteContext *gb = &s->gb;
428     int ret, temp, min, max, x, y, cx = 0, cx1 = 0;
429     int backstep = linesize - avctx->width;
430     const int cxshift = s->cxshift;
431
432     if (bytestream2_get_byte(gb) == 0)
433         return 0;
434     bytestream2_skip(gb, 1);
435     init_rangecoder(&s->rc, gb);
436
437     ret  = decode_value(s, s->range_model, 256, 1, &min);
438     ret |= decode_value(s, s->range_model, 256, 1, &temp);
439     min += temp << 8;
440     ret |= decode_value(s, s->range_model, 256, 1, &max);
441     ret |= decode_value(s, s->range_model, 256, 1, &temp);
442     if (ret < 0)
443         return ret;
444
445     max += temp << 8;
446     memset(s->blocks, 0, sizeof(*s->blocks) * s->nbcount);
447
448     while (min <= max) {
449         int fill, count;
450
451         ret  = decode_value(s, s->fill_model,  5,   10, &fill);
452         ret |= decode_value(s, s->count_model, 256, 20, &count);
453         if (ret < 0)
454             return ret;
455
456         while (min < s->nbcount && count-- > 0) {
457             s->blocks[min++] = fill;
458         }
459     }
460
461     for (y = 0; y < s->nby; y++) {
462         for (x = 0; x < s->nbx; x++) {
463             int sy1 = 0, sy2 = 16, sx1 = 0, sx2 = 16;
464
465             if (s->blocks[y * s->nbx + x] == 0)
466                 continue;
467
468             if (((s->blocks[y * s->nbx + x] - 1) & 1) > 0) {
469                 ret  = decode_value(s, s->sxy_model[0], 16, 100, &sx1);
470                 ret |= decode_value(s, s->sxy_model[1], 16, 100, &sy1);
471                 ret |= decode_value(s, s->sxy_model[2], 16, 100, &sx2);
472                 ret |= decode_value(s, s->sxy_model[3], 16, 100, &sy2);
473                 if (ret < 0)
474                     return ret;
475
476                 sx2++;
477                 sy2++;
478             }
479             if (((s->blocks[y * s->nbx + x] - 1) & 2) > 0) {
480                 int i, j, by = y * 16, bx = x * 16;
481                 int mvx, mvy;
482
483                 ret  = decode_value(s, s->mv_model[0], 512, 100, &mvx);
484                 ret |= decode_value(s, s->mv_model[1], 512, 100, &mvy);
485                 if (ret < 0)
486                     return ret;
487
488                 mvx -= 256;
489                 mvy -= 256;
490
491                 if (by + mvy + sy1 < 0 || bx + mvx + sx1 < 0)
492                     return AVERROR_INVALIDDATA;
493
494                 for (i = 0; i < sy2 - sy1 && (by + sy1 + i) < avctx->height; i++) {
495                     for (j = 0; j < sx2 - sx1 && (bx + sx1 + j) < avctx->width; j++) {
496                         dst[(by + i + sy1) * linesize + bx + sx1 + j] = prev[(by + mvy + sy1 + i) * plinesize + bx + sx1 + mvx + j];
497                     }
498                 }
499             } else {
500                 int run, r, g, b, z, bx = x * 16 + sx1, by = y * 16 + sy1;
501                 unsigned clr, ptype = 0;
502
503                 for (; by < y * 16 + sy2 && by < avctx->height;) {
504                     ret = decode_value(s, s->op_model[ptype], 6, 1000, &ptype);
505                     if (ptype == 0) {
506                         ret = decode_unit(s, &s->pixel_model[0][cx + cx1], 400, &r);
507                         if (ret < 0)
508                             return ret;
509
510                         cx1 = (cx << 6) & 0xFC0;
511                         cx = r >> cxshift;
512                         ret = decode_unit(s, &s->pixel_model[1][cx + cx1], 400, &g);
513                         if (ret < 0)
514                             return ret;
515
516                         cx1 = (cx << 6) & 0xFC0;
517                         cx = g >> cxshift;
518                         ret = decode_unit(s, &s->pixel_model[2][cx + cx1], 400, &b);
519                         if (ret < 0)
520                             return ret;
521
522                         cx1 = (cx << 6) & 0xFC0;
523                         cx = b >> cxshift;
524                         clr = (b << 16) + (g << 8) + r;
525                     }
526                     if (ptype > 5)
527                         return AVERROR_INVALIDDATA;
528                     ret = decode_value(s, s->run_model[ptype], 256, 400, &run);
529                     if (ret < 0)
530                         return ret;
531
532                     switch (ptype) {
533                     case 0:
534                         while (run-- > 0) {
535                             if (by >= avctx->height)
536                                 return AVERROR_INVALIDDATA;
537
538                             dst[by * linesize + bx] = clr;
539                             bx++;
540                             if (bx >= x * 16 + sx2 || bx >= avctx->width) {
541                                 bx = x * 16 + sx1;
542                                 by++;
543                             }
544                         }
545                         break;
546                     case 1:
547                         while (run-- > 0) {
548                             if (bx == 0) {
549                                 if (by < 1)
550                                     return AVERROR_INVALIDDATA;
551                                 z = backstep;
552                             } else {
553                                 z = 0;
554                             }
555
556                             if (by >= avctx->height)
557                                 return AVERROR_INVALIDDATA;
558
559                             clr = dst[by * linesize + bx - 1 - z];
560                             dst[by * linesize + bx] = clr;
561                             bx++;
562                             if (bx >= x * 16 + sx2 || bx >= avctx->width) {
563                                 bx = x * 16 + sx1;
564                                 by++;
565                             }
566                         }
567                         break;
568                     case 2:
569                         while (run-- > 0) {
570                             if (by < 1 || by >= avctx->height)
571                                 return AVERROR_INVALIDDATA;
572
573                             clr = dst[(by - 1) * linesize + bx];
574                             dst[by * linesize + bx] = clr;
575                             bx++;
576                             if (bx >= x * 16 + sx2 || bx >= avctx->width) {
577                                 bx = x * 16 + sx1;
578                                 by++;
579                             }
580                         }
581                         break;
582                     case 3:
583                         while (run-- > 0) {
584                             if (by >= avctx->height)
585                                 return AVERROR_INVALIDDATA;
586
587                             clr = prev[by * linesize + bx];
588                             dst[by * linesize + bx] = clr;
589                             bx++;
590                             if (bx >= x * 16 + sx2 || bx >= avctx->width) {
591                                 bx = x * 16 + sx1;
592                                 by++;
593                             }
594                         }
595                         break;
596                     case 4:
597                         while (run-- > 0) {
598                             uint8_t *odst = (uint8_t *)dst;
599
600                             if (by < 1 || by >= avctx->height)
601                                 return AVERROR_INVALIDDATA;
602
603                             if (bx == 0) {
604                                 z = backstep;
605                             } else {
606                                 z = 0;
607                             }
608
609                             r = odst[((by - 1) * linesize + bx) * 4] +
610                                 odst[(by * linesize + bx - 1 - z) * 4] -
611                                 odst[((by - 1) * linesize + bx - 1 - z) * 4];
612                             g = odst[((by - 1) * linesize + bx) * 4 + 1] +
613                                 odst[(by * linesize + bx - 1 - z) * 4 + 1] -
614                                 odst[((by - 1) * linesize + bx - 1 - z) * 4 + 1];
615                             b = odst[((by - 1) * linesize + bx) * 4 + 2] +
616                                 odst[(by * linesize + bx - 1 - z) * 4 + 2] -
617                                 odst[((by - 1) * linesize + bx - 1 - z) * 4 + 2];
618                             clr = ((b & 0xFF) << 16) + ((g & 0xFF) << 8) + (r & 0xFF);
619                             dst[by * linesize + bx] = clr;
620                             bx++;
621                             if (bx >= x * 16 + sx2 || bx >= avctx->width) {
622                                 bx = x * 16 + sx1;
623                                 by++;
624                             }
625                         }
626                         break;
627                     case 5:
628                         while (run-- > 0) {
629                             if (by < 1 || by >= avctx->height)
630                                 return AVERROR_INVALIDDATA;
631
632                             if (bx == 0) {
633                                 z = backstep;
634                             } else {
635                                 z = 0;
636                             }
637
638                             clr = dst[(by - 1) * linesize + bx - 1 - z];
639                             dst[by * linesize + bx] = clr;
640                             bx++;
641                             if (bx >= x * 16 + sx2 || bx >= avctx->width) {
642                                 bx = x * 16 + sx1;
643                                 by++;
644                             }
645                         }
646                         break;
647                     }
648
649                     if (avctx->bits_per_coded_sample == 16) {
650                         cx1 = (clr & 0xFF00) >> 2;
651                         cx = (clr & 0xFFFFFF) >> 16;
652                     } else {
653                         cx1 = (clr & 0xFC00) >> 4;
654                         cx = (clr & 0xFFFFFF) >> 18;
655                     }
656                 }
657             }
658         }
659     }
660
661     return 0;
662 }
663
664 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
665                         AVPacket *avpkt)
666 {
667     SCPRContext *s = avctx->priv_data;
668     GetByteContext *gb = &s->gb;
669     AVFrame *frame = data;
670     int ret, type;
671
672     if (avctx->bits_per_coded_sample == 16) {
673         if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
674             return ret;
675     }
676
677     if ((ret = ff_reget_buffer(avctx, s->current_frame)) < 0)
678         return ret;
679
680     bytestream2_init(gb, avpkt->data, avpkt->size);
681
682     type = bytestream2_peek_byte(gb);
683
684     if (type == 18) {
685         frame->key_frame = 1;
686         ret = decompress_i(avctx, (uint32_t *)s->current_frame->data[0],
687                            s->current_frame->linesize[0] / 4);
688     } else if (type == 17) {
689         uint32_t clr, *dst = (uint32_t *)s->current_frame->data[0];
690         int x, y;
691
692         frame->key_frame = 1;
693         bytestream2_skip(gb, 1);
694         if (avctx->bits_per_coded_sample == 16) {
695             uint16_t value = bytestream2_get_le16(gb);
696             int r, g, b;
697
698             r = (value      ) & 31;
699             g = (value >>  5) & 31;
700             b = (value >> 10) & 31;
701             clr = (r << 16) + (g << 8) + b;
702         } else {
703             clr = bytestream2_get_le24(gb);
704         }
705         for (y = 0; y < avctx->height; y++) {
706             for (x = 0; x < avctx->width; x++) {
707                 dst[x] = clr;
708             }
709             dst += s->current_frame->linesize[0] / 4;
710         }
711     } else if (type == 0 || type == 1) {
712         frame->key_frame = 0;
713
714         ret = av_frame_copy(s->current_frame, s->last_frame);
715         if (ret < 0)
716             return ret;
717
718         ret = decompress_p(avctx, (uint32_t *)s->current_frame->data[0],
719                            s->current_frame->linesize[0] / 4,
720                            (uint32_t *)s->last_frame->data[0],
721                            s->last_frame->linesize[0] / 4);
722     } else {
723         return AVERROR_PATCHWELCOME;
724     }
725
726     if (ret < 0)
727         return ret;
728
729     if (avctx->bits_per_coded_sample != 16) {
730         ret = av_frame_ref(data, s->current_frame);
731         if (ret < 0)
732             return ret;
733     } else {
734         uint8_t *dst = frame->data[0];
735         int x, y;
736
737         ret = av_frame_copy(frame, s->current_frame);
738         if (ret < 0)
739             return ret;
740
741         for (y = 0; y < avctx->height; y++) {
742             for (x = 0; x < avctx->width * 4; x++) {
743                 dst[x] = dst[x] << 3;
744             }
745             dst += frame->linesize[0];
746         }
747     }
748
749     frame->pict_type = frame->key_frame ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
750
751     FFSWAP(AVFrame *, s->current_frame, s->last_frame);
752
753     frame->data[0]     += frame->linesize[0] * (avctx->height - 1);
754     frame->linesize[0] *= -1;
755
756     *got_frame = 1;
757
758     return avpkt->size;
759 }
760
761 static av_cold int decode_init(AVCodecContext *avctx)
762 {
763     SCPRContext *s = avctx->priv_data;
764
765     switch (avctx->bits_per_coded_sample) {
766     case 16: avctx->pix_fmt = AV_PIX_FMT_RGB0; break;
767     case 24:
768     case 32: avctx->pix_fmt = AV_PIX_FMT_BGR0; break;
769     default:
770         av_log(avctx, AV_LOG_ERROR, "Unsupported bitdepth %i\n", avctx->bits_per_coded_sample);
771         return AVERROR_INVALIDDATA;
772     }
773
774     s->cxshift = avctx->bits_per_coded_sample == 16 ? 0 : 2;
775     s->nbx = (avctx->width + 15) / 16;
776     s->nby = (avctx->height + 15) / 16;
777     s->nbcount = s->nbx * s->nby;
778     s->blocks = av_malloc_array(s->nbcount, sizeof(*s->blocks));
779     if (!s->blocks)
780         return AVERROR(ENOMEM);
781
782     s->last_frame = av_frame_alloc();
783     s->current_frame = av_frame_alloc();
784     if (!s->last_frame || !s->current_frame)
785         return AVERROR(ENOMEM);
786
787     return 0;
788 }
789
790 static av_cold int decode_close(AVCodecContext *avctx)
791 {
792     SCPRContext *s = avctx->priv_data;
793
794     av_freep(&s->blocks);
795     av_frame_free(&s->last_frame);
796     av_frame_free(&s->current_frame);
797
798     return 0;
799 }
800
801 AVCodec ff_scpr_decoder = {
802     .name             = "scpr",
803     .long_name        = NULL_IF_CONFIG_SMALL("ScreenPressor"),
804     .type             = AVMEDIA_TYPE_VIDEO,
805     .id               = AV_CODEC_ID_SCPR,
806     .priv_data_size   = sizeof(SCPRContext),
807     .init             = decode_init,
808     .close            = decode_close,
809     .decode           = decode_frame,
810     .capabilities     = AV_CODEC_CAP_DR1,
811     .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE |
812                         FF_CODEC_CAP_INIT_CLEANUP,
813 };