avcodec/scpr: remove 4 dead store
[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             clr = (b << 16) + (g << 8) + r;
325         }
326         if (ptype > 5)
327             return AVERROR_INVALIDDATA;
328         ret = decode_value(s, s->run_model[ptype], 256, 400, &run);
329         if (ret < 0)
330             return ret;
331
332         switch (ptype) {
333         case 0:
334             while (run-- > 0) {
335                 if (y >= avctx->height)
336                     return AVERROR_INVALIDDATA;
337
338                 dst[y * linesize + x] = clr;
339                 lx = x;
340                 ly = y;
341                 x++;
342                 if (x >= avctx->width) {
343                     x = 0;
344                     y++;
345                 }
346             }
347             break;
348         case 1:
349             while (run-- > 0) {
350                 if (y >= avctx->height)
351                     return AVERROR_INVALIDDATA;
352
353                 dst[y * linesize + x] = dst[ly * linesize + lx];
354                 lx = x;
355                 ly = y;
356                 x++;
357                 if (x >= avctx->width) {
358                     x = 0;
359                     y++;
360                 }
361             }
362             clr = dst[ly * linesize + lx];
363             break;
364         case 2:
365             while (run-- > 0) {
366                 if (y < 1 || y >= avctx->height)
367                     return AVERROR_INVALIDDATA;
368
369                 clr = dst[y * linesize + x + off + 1];
370                 dst[y * linesize + x] = clr;
371                 lx = x;
372                 ly = y;
373                 x++;
374                 if (x >= avctx->width) {
375                     x = 0;
376                     y++;
377                 }
378             }
379             break;
380         case 4:
381             while (run-- > 0) {
382                 uint8_t *odst = (uint8_t *)dst;
383
384                 if (y < 1 || y >= avctx->height)
385                     return AVERROR_INVALIDDATA;
386
387                 r = odst[(ly * linesize + lx) * 4] +
388                     odst[((y * linesize + x) + off) * 4 + 4] -
389                     odst[((y * linesize + x) + off) * 4];
390                 g = odst[(ly * linesize + lx) * 4 + 1] +
391                     odst[((y * linesize + x) + off) * 4 + 5] -
392                     odst[((y * linesize + x) + off) * 4 + 1];
393                 b = odst[(ly * linesize + lx) * 4 + 2] +
394                     odst[((y * linesize + x) + off) * 4 + 6] -
395                     odst[((y * linesize + x) + off) * 4 + 2];
396                 clr = ((b & 0xFF) << 16) + ((g & 0xFF) << 8) + (r & 0xFF);
397                 dst[y * linesize + x] = clr;
398                 lx = x;
399                 ly = y;
400                 x++;
401                 if (x >= avctx->width) {
402                     x = 0;
403                     y++;
404                 }
405             }
406             break;
407         case 5:
408             while (run-- > 0) {
409                 if (y < 1 || y >= avctx->height)
410                     return AVERROR_INVALIDDATA;
411
412                 clr = dst[y * linesize + x + off];
413                 dst[y * linesize + x] = clr;
414                 lx = x;
415                 ly = y;
416                 x++;
417                 if (x >= avctx->width) {
418                     x = 0;
419                     y++;
420                 }
421             }
422             break;
423         }
424
425         if (avctx->bits_per_coded_sample == 16) {
426             cx1 = (clr & 0x3F00) >> 2;
427             cx = (clr & 0xFFFFFF) >> 16;
428         } else {
429             cx1 = (clr & 0xFC00) >> 4;
430             cx = (clr & 0xFFFFFF) >> 18;
431         }
432     }
433
434     return 0;
435 }
436
437 static int decompress_p(AVCodecContext *avctx,
438                         uint32_t *dst, int linesize,
439                         uint32_t *prev, int plinesize)
440 {
441     SCPRContext *s = avctx->priv_data;
442     GetByteContext *gb = &s->gb;
443     int ret, temp, min, max, x, y, cx = 0, cx1 = 0;
444     int backstep = linesize - avctx->width;
445     const int cxshift = s->cxshift;
446
447     if (bytestream2_get_byte(gb) == 0)
448         return 0;
449     bytestream2_skip(gb, 1);
450     init_rangecoder(&s->rc, gb);
451
452     ret  = decode_value(s, s->range_model, 256, 1, &min);
453     ret |= decode_value(s, s->range_model, 256, 1, &temp);
454     min += temp << 8;
455     ret |= decode_value(s, s->range_model, 256, 1, &max);
456     ret |= decode_value(s, s->range_model, 256, 1, &temp);
457     if (ret < 0)
458         return ret;
459
460     max += temp << 8;
461     memset(s->blocks, 0, sizeof(*s->blocks) * s->nbcount);
462
463     while (min <= max) {
464         int fill, count;
465
466         ret  = decode_value(s, s->fill_model,  5,   10, &fill);
467         ret |= decode_value(s, s->count_model, 256, 20, &count);
468         if (ret < 0)
469             return ret;
470
471         while (min < s->nbcount && count-- > 0) {
472             s->blocks[min++] = fill;
473         }
474     }
475
476     for (y = 0; y < s->nby; y++) {
477         for (x = 0; x < s->nbx; x++) {
478             int sy1 = 0, sy2 = 16, sx1 = 0, sx2 = 16;
479
480             if (s->blocks[y * s->nbx + x] == 0)
481                 continue;
482
483             if (((s->blocks[y * s->nbx + x] - 1) & 1) > 0) {
484                 ret  = decode_value(s, s->sxy_model[0], 16, 100, &sx1);
485                 ret |= decode_value(s, s->sxy_model[1], 16, 100, &sy1);
486                 ret |= decode_value(s, s->sxy_model[2], 16, 100, &sx2);
487                 ret |= decode_value(s, s->sxy_model[3], 16, 100, &sy2);
488                 if (ret < 0)
489                     return ret;
490
491                 sx2++;
492                 sy2++;
493             }
494             if (((s->blocks[y * s->nbx + x] - 1) & 2) > 0) {
495                 int i, j, by = y * 16, bx = x * 16;
496                 int mvx, mvy;
497
498                 ret  = decode_value(s, s->mv_model[0], 512, 100, &mvx);
499                 ret |= decode_value(s, s->mv_model[1], 512, 100, &mvy);
500                 if (ret < 0)
501                     return ret;
502
503                 mvx -= 256;
504                 mvy -= 256;
505
506                 if (by + mvy + sy1 < 0 || bx + mvx + sx1 < 0 ||
507                     by + mvy + sy1 >= avctx->height || bx + mvx + sx1 >= avctx->width)
508                     return AVERROR_INVALIDDATA;
509
510                 for (i = 0; i < sy2 - sy1 && (by + sy1 + i) < avctx->height && (by + mvy + sy1 + i) < avctx->height; i++) {
511                     for (j = 0; j < sx2 - sx1 && (bx + sx1 + j) < avctx->width && (bx + mvx + sx1 + j) < avctx->width; j++) {
512                         dst[(by + i + sy1) * linesize + bx + sx1 + j] = prev[(by + mvy + sy1 + i) * plinesize + bx + sx1 + mvx + j];
513                     }
514                 }
515             } else {
516                 int run, r, g, b, z, bx = x * 16 + sx1, by = y * 16 + sy1;
517                 unsigned clr, ptype = 0;
518
519                 for (; by < y * 16 + sy2 && by < avctx->height;) {
520                     ret = decode_value(s, s->op_model[ptype], 6, 1000, &ptype);
521                     if (ptype == 0) {
522                         ret = decode_unit(s, &s->pixel_model[0][cx + cx1], 400, &r);
523                         if (ret < 0)
524                             return ret;
525
526                         cx1 = (cx << 6) & 0xFC0;
527                         cx = r >> cxshift;
528                         ret = decode_unit(s, &s->pixel_model[1][cx + cx1], 400, &g);
529                         if (ret < 0)
530                             return ret;
531
532                         cx1 = (cx << 6) & 0xFC0;
533                         cx = g >> cxshift;
534                         ret = decode_unit(s, &s->pixel_model[2][cx + cx1], 400, &b);
535                         if (ret < 0)
536                             return ret;
537
538                         clr = (b << 16) + (g << 8) + r;
539                     }
540                     if (ptype > 5)
541                         return AVERROR_INVALIDDATA;
542                     ret = decode_value(s, s->run_model[ptype], 256, 400, &run);
543                     if (ret < 0)
544                         return ret;
545
546                     switch (ptype) {
547                     case 0:
548                         while (run-- > 0) {
549                             if (by >= avctx->height)
550                                 return AVERROR_INVALIDDATA;
551
552                             dst[by * linesize + bx] = clr;
553                             bx++;
554                             if (bx >= x * 16 + sx2 || bx >= avctx->width) {
555                                 bx = x * 16 + sx1;
556                                 by++;
557                             }
558                         }
559                         break;
560                     case 1:
561                         while (run-- > 0) {
562                             if (bx == 0) {
563                                 if (by < 1)
564                                     return AVERROR_INVALIDDATA;
565                                 z = backstep;
566                             } else {
567                                 z = 0;
568                             }
569
570                             if (by >= avctx->height)
571                                 return AVERROR_INVALIDDATA;
572
573                             clr = dst[by * linesize + bx - 1 - z];
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 2:
583                         while (run-- > 0) {
584                             if (by < 1 || by >= avctx->height)
585                                 return AVERROR_INVALIDDATA;
586
587                             clr = dst[(by - 1) * 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 3:
597                         while (run-- > 0) {
598                             if (by >= avctx->height)
599                                 return AVERROR_INVALIDDATA;
600
601                             clr = prev[by * linesize + bx];
602                             dst[by * linesize + bx] = clr;
603                             bx++;
604                             if (bx >= x * 16 + sx2 || bx >= avctx->width) {
605                                 bx = x * 16 + sx1;
606                                 by++;
607                             }
608                         }
609                         break;
610                     case 4:
611                         while (run-- > 0) {
612                             uint8_t *odst = (uint8_t *)dst;
613
614                             if (by < 1 || by >= avctx->height)
615                                 return AVERROR_INVALIDDATA;
616
617                             if (bx == 0) {
618                                 z = backstep;
619                             } else {
620                                 z = 0;
621                             }
622
623                             r = odst[((by - 1) * linesize + bx) * 4] +
624                                 odst[(by * linesize + bx - 1 - z) * 4] -
625                                 odst[((by - 1) * linesize + bx - 1 - z) * 4];
626                             g = odst[((by - 1) * linesize + bx) * 4 + 1] +
627                                 odst[(by * linesize + bx - 1 - z) * 4 + 1] -
628                                 odst[((by - 1) * linesize + bx - 1 - z) * 4 + 1];
629                             b = odst[((by - 1) * linesize + bx) * 4 + 2] +
630                                 odst[(by * linesize + bx - 1 - z) * 4 + 2] -
631                                 odst[((by - 1) * linesize + bx - 1 - z) * 4 + 2];
632                             clr = ((b & 0xFF) << 16) + ((g & 0xFF) << 8) + (r & 0xFF);
633                             dst[by * linesize + bx] = clr;
634                             bx++;
635                             if (bx >= x * 16 + sx2 || bx >= avctx->width) {
636                                 bx = x * 16 + sx1;
637                                 by++;
638                             }
639                         }
640                         break;
641                     case 5:
642                         while (run-- > 0) {
643                             if (by < 1 || by >= avctx->height)
644                                 return AVERROR_INVALIDDATA;
645
646                             if (bx == 0) {
647                                 z = backstep;
648                             } else {
649                                 z = 0;
650                             }
651
652                             clr = dst[(by - 1) * linesize + bx - 1 - z];
653                             dst[by * linesize + bx] = clr;
654                             bx++;
655                             if (bx >= x * 16 + sx2 || bx >= avctx->width) {
656                                 bx = x * 16 + sx1;
657                                 by++;
658                             }
659                         }
660                         break;
661                     }
662
663                     if (avctx->bits_per_coded_sample == 16) {
664                         cx1 = (clr & 0x3F00) >> 2;
665                         cx = (clr & 0xFFFFFF) >> 16;
666                     } else {
667                         cx1 = (clr & 0xFC00) >> 4;
668                         cx = (clr & 0xFFFFFF) >> 18;
669                     }
670                 }
671             }
672         }
673     }
674
675     return 0;
676 }
677
678 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
679                         AVPacket *avpkt)
680 {
681     SCPRContext *s = avctx->priv_data;
682     GetByteContext *gb = &s->gb;
683     AVFrame *frame = data;
684     int ret, type;
685
686     if (avctx->bits_per_coded_sample == 16) {
687         if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
688             return ret;
689     }
690
691     if ((ret = ff_reget_buffer(avctx, s->current_frame)) < 0)
692         return ret;
693
694     bytestream2_init(gb, avpkt->data, avpkt->size);
695
696     type = bytestream2_peek_byte(gb);
697
698     if (type == 18) {
699         frame->key_frame = 1;
700         ret = decompress_i(avctx, (uint32_t *)s->current_frame->data[0],
701                            s->current_frame->linesize[0] / 4);
702     } else if (type == 17) {
703         uint32_t clr, *dst = (uint32_t *)s->current_frame->data[0];
704         int x, y;
705
706         frame->key_frame = 1;
707         bytestream2_skip(gb, 1);
708         if (avctx->bits_per_coded_sample == 16) {
709             uint16_t value = bytestream2_get_le16(gb);
710             int r, g, b;
711
712             r = (value      ) & 31;
713             g = (value >>  5) & 31;
714             b = (value >> 10) & 31;
715             clr = (r << 16) + (g << 8) + b;
716         } else {
717             clr = bytestream2_get_le24(gb);
718         }
719         for (y = 0; y < avctx->height; y++) {
720             for (x = 0; x < avctx->width; x++) {
721                 dst[x] = clr;
722             }
723             dst += s->current_frame->linesize[0] / 4;
724         }
725     } else if (type == 0 || type == 1) {
726         frame->key_frame = 0;
727
728         ret = av_frame_copy(s->current_frame, s->last_frame);
729         if (ret < 0)
730             return ret;
731
732         ret = decompress_p(avctx, (uint32_t *)s->current_frame->data[0],
733                            s->current_frame->linesize[0] / 4,
734                            (uint32_t *)s->last_frame->data[0],
735                            s->last_frame->linesize[0] / 4);
736     } else {
737         return AVERROR_PATCHWELCOME;
738     }
739
740     if (ret < 0)
741         return ret;
742
743     if (avctx->bits_per_coded_sample != 16) {
744         ret = av_frame_ref(data, s->current_frame);
745         if (ret < 0)
746             return ret;
747     } else {
748         uint8_t *dst = frame->data[0];
749         int x, y;
750
751         ret = av_frame_copy(frame, s->current_frame);
752         if (ret < 0)
753             return ret;
754
755         for (y = 0; y < avctx->height; y++) {
756             for (x = 0; x < avctx->width * 4; x++) {
757                 dst[x] = dst[x] << 3;
758             }
759             dst += frame->linesize[0];
760         }
761     }
762
763     frame->pict_type = frame->key_frame ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
764
765     FFSWAP(AVFrame *, s->current_frame, s->last_frame);
766
767     frame->data[0]     += frame->linesize[0] * (avctx->height - 1);
768     frame->linesize[0] *= -1;
769
770     *got_frame = 1;
771
772     return avpkt->size;
773 }
774
775 static av_cold int decode_init(AVCodecContext *avctx)
776 {
777     SCPRContext *s = avctx->priv_data;
778
779     switch (avctx->bits_per_coded_sample) {
780     case 16: avctx->pix_fmt = AV_PIX_FMT_RGB0; break;
781     case 24:
782     case 32: avctx->pix_fmt = AV_PIX_FMT_BGR0; break;
783     default:
784         av_log(avctx, AV_LOG_ERROR, "Unsupported bitdepth %i\n", avctx->bits_per_coded_sample);
785         return AVERROR_INVALIDDATA;
786     }
787
788     s->cxshift = avctx->bits_per_coded_sample == 16 ? 0 : 2;
789     s->cbits = avctx->bits_per_coded_sample == 16 ? 0x1F : 0xFF;
790     s->nbx = (avctx->width + 15) / 16;
791     s->nby = (avctx->height + 15) / 16;
792     s->nbcount = s->nbx * s->nby;
793     s->blocks = av_malloc_array(s->nbcount, sizeof(*s->blocks));
794     if (!s->blocks)
795         return AVERROR(ENOMEM);
796
797     s->last_frame = av_frame_alloc();
798     s->current_frame = av_frame_alloc();
799     if (!s->last_frame || !s->current_frame)
800         return AVERROR(ENOMEM);
801
802     return 0;
803 }
804
805 static av_cold int decode_close(AVCodecContext *avctx)
806 {
807     SCPRContext *s = avctx->priv_data;
808
809     av_freep(&s->blocks);
810     av_frame_free(&s->last_frame);
811     av_frame_free(&s->current_frame);
812
813     return 0;
814 }
815
816 AVCodec ff_scpr_decoder = {
817     .name             = "scpr",
818     .long_name        = NULL_IF_CONFIG_SMALL("ScreenPressor"),
819     .type             = AVMEDIA_TYPE_VIDEO,
820     .id               = AV_CODEC_ID_SCPR,
821     .priv_data_size   = sizeof(SCPRContext),
822     .init             = decode_init,
823     .close            = decode_close,
824     .decode           = decode_frame,
825     .capabilities     = AV_CODEC_CAP_DR1,
826     .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE |
827                         FF_CODEC_CAP_INIT_CLEANUP,
828 };