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