hevc: move restore_tqb where it should be.
[ffmpeg.git] / libavcodec / escape130.c
1 /*
2  * Escape 130 video decoder
3  * Copyright (C) 2008 Eli Friedman (eli.friedman <at> gmail.com)
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 #include "libavutil/attributes.h"
23 #include "libavutil/mem.h"
24 #include "avcodec.h"
25 #define BITSTREAM_READER_LE
26 #include "get_bits.h"
27 #include "internal.h"
28
29 typedef struct Escape130Context {
30     uint8_t *old_y_avg;
31
32     uint8_t *new_y, *old_y;
33     uint8_t *new_u, *old_u;
34     uint8_t *new_v, *old_v;
35
36     uint8_t *buf1, *buf2;
37     int     linesize[3];
38 } Escape130Context;
39
40 static const uint8_t offset_table[] = { 2, 4, 10, 20 };
41 static const int8_t sign_table[64][4] = {
42     {  0,  0,  0,  0 },
43     { -1,  1,  0,  0 },
44     {  1, -1,  0,  0 },
45     { -1,  0,  1,  0 },
46     { -1,  1,  1,  0 },
47     {  0, -1,  1,  0 },
48     {  1, -1,  1,  0 },
49     { -1, -1,  1,  0 },
50     {  1,  0, -1,  0 },
51     {  0,  1, -1,  0 },
52     {  1,  1, -1,  0 },
53     { -1,  1, -1,  0 },
54     {  1, -1, -1,  0 },
55     { -1,  0,  0,  1 },
56     { -1,  1,  0,  1 },
57     {  0, -1,  0,  1 },
58
59     {  0,  0,  0,  0 },
60     {  1, -1,  0,  1 },
61     { -1, -1,  0,  1 },
62     { -1,  0,  1,  1 },
63     { -1,  1,  1,  1 },
64     {  0, -1,  1,  1 },
65     {  1, -1,  1,  1 },
66     { -1, -1,  1,  1 },
67     {  0,  0, -1,  1 },
68     {  1,  0, -1,  1 },
69     { -1,  0, -1,  1 },
70     {  0,  1, -1,  1 },
71     {  1,  1, -1,  1 },
72     { -1,  1, -1,  1 },
73     {  0, -1, -1,  1 },
74     {  1, -1, -1,  1 },
75
76     {  0,  0,  0,  0 },
77     { -1, -1, -1,  1 },
78     {  1,  0,  0, -1 },
79     {  0,  1,  0, -1 },
80     {  1,  1,  0, -1 },
81     { -1,  1,  0, -1 },
82     {  1, -1,  0, -1 },
83     {  0,  0,  1, -1 },
84     {  1,  0,  1, -1 },
85     { -1,  0,  1, -1 },
86     {  0,  1,  1, -1 },
87     {  1,  1,  1, -1 },
88     { -1,  1,  1, -1 },
89     {  0, -1,  1, -1 },
90     {  1, -1,  1, -1 },
91     { -1, -1,  1, -1 },
92
93     {  0,  0,  0,  0 },
94     {  1,  0, -1, -1 },
95     {  0,  1, -1, -1 },
96     {  1,  1, -1, -1 },
97     { -1,  1, -1, -1 },
98     {  1, -1, -1, -1 }
99 };
100
101 static const int8_t luma_adjust[] = { -4, -3, -2, -1, 1, 2, 3, 4 };
102
103 static const int8_t chroma_adjust[2][8] = {
104     { 1, 1, 0, -1, -1, -1,  0,  1 },
105     { 0, 1, 1,  1,  0, -1, -1, -1 }
106 };
107
108 static const uint8_t chroma_vals[] = {
109      20,  28,  36,  44,  52,  60,  68,  76,
110      84,  92, 100, 106, 112, 116, 120, 124,
111     128, 132, 136, 140, 144, 150, 156, 164,
112     172, 180, 188, 196, 204, 212, 220, 228
113 };
114
115 static av_cold int escape130_decode_init(AVCodecContext *avctx)
116 {
117     Escape130Context *s = avctx->priv_data;
118     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
119
120     if ((avctx->width & 1) || (avctx->height & 1)) {
121         av_log(avctx, AV_LOG_ERROR,
122                "Dimensions should be a multiple of two.\n");
123         return AVERROR_INVALIDDATA;
124     }
125
126     s->old_y_avg = av_malloc(avctx->width * avctx->height / 4);
127     s->buf1      = av_malloc(avctx->width * avctx->height * 3 / 2);
128     s->buf2      = av_malloc(avctx->width * avctx->height * 3 / 2);
129     if (!s->old_y_avg || !s->buf1 || !s->buf2) {
130         av_freep(&s->old_y_avg);
131         av_freep(&s->buf1);
132         av_freep(&s->buf2);
133         av_log(avctx, AV_LOG_ERROR, "Could not allocate buffer.\n");
134         return AVERROR(ENOMEM);
135     }
136
137     s->linesize[0] = avctx->width;
138     s->linesize[1] =
139     s->linesize[2] = avctx->width / 2;
140
141     s->new_y = s->buf1;
142     s->new_u = s->new_y + avctx->width * avctx->height;
143     s->new_v = s->new_u + avctx->width * avctx->height / 4;
144     s->old_y = s->buf2;
145     s->old_u = s->old_y + avctx->width * avctx->height;
146     s->old_v = s->old_u + avctx->width * avctx->height / 4;
147     memset(s->old_y, 0,    avctx->width * avctx->height);
148     memset(s->old_u, 0x10, avctx->width * avctx->height / 4);
149     memset(s->old_v, 0x10, avctx->width * avctx->height / 4);
150
151     return 0;
152 }
153
154 static av_cold int escape130_decode_close(AVCodecContext *avctx)
155 {
156     Escape130Context *s = avctx->priv_data;
157
158     av_freep(&s->old_y_avg);
159     av_freep(&s->buf1);
160     av_freep(&s->buf2);
161
162     return 0;
163 }
164
165 static int decode_skip_count(GetBitContext* gb)
166 {
167     int value;
168
169     if (get_bits_left(gb) < 1+3)
170         return -1;
171
172     value = get_bits1(gb);
173     if (value)
174         return 0;
175
176     value = get_bits(gb, 3);
177     if (value)
178         return value;
179
180     value = get_bits(gb, 8);
181     if (value)
182         return value + 7;
183
184     value = get_bits(gb, 15);
185     if (value)
186         return value + 262;
187
188     return -1;
189 }
190
191 static int escape130_decode_frame(AVCodecContext *avctx, void *data,
192                                   int *got_frame, AVPacket *avpkt)
193 {
194     int buf_size        = avpkt->size;
195     Escape130Context *s = avctx->priv_data;
196     AVFrame *pic        = data;
197     GetBitContext gb;
198     int ret;
199
200     uint8_t *old_y, *old_cb, *old_cr,
201             *new_y, *new_cb, *new_cr;
202     uint8_t *dstY, *dstU, *dstV;
203     unsigned old_y_stride, old_cb_stride, old_cr_stride,
204              new_y_stride, new_cb_stride, new_cr_stride;
205     unsigned total_blocks = avctx->width * avctx->height / 4,
206              block_index, block_x = 0;
207     unsigned y[4] = { 0 }, cb = 0x10, cr = 0x10;
208     int skip = -1, y_avg = 0, i, j;
209     uint8_t *ya = s->old_y_avg;
210
211     // first 16 bytes are header; no useful information in here
212     if (buf_size <= 16) {
213         av_log(avctx, AV_LOG_ERROR, "Insufficient frame data\n");
214         return AVERROR_INVALIDDATA;
215     }
216
217     if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
218         return ret;
219
220     if ((ret = init_get_bits8(&gb, avpkt->data, avpkt->size)) < 0)
221         return ret;
222     skip_bits_long(&gb, 16 * 8);
223
224     new_y  = s->new_y;
225     new_cb = s->new_u;
226     new_cr = s->new_v;
227     new_y_stride  = s->linesize[0];
228     new_cb_stride = s->linesize[1];
229     new_cr_stride = s->linesize[2];
230     old_y  = s->old_y;
231     old_cb = s->old_u;
232     old_cr = s->old_v;
233     old_y_stride  = s->linesize[0];
234     old_cb_stride = s->linesize[1];
235     old_cr_stride = s->linesize[2];
236
237     for (block_index = 0; block_index < total_blocks; block_index++) {
238         // Note that this call will make us skip the rest of the blocks
239         // if the frame ends prematurely.
240         if (skip == -1)
241             skip = decode_skip_count(&gb);
242         if (skip == -1) {
243             av_log(avctx, AV_LOG_ERROR, "Error decoding skip value\n");
244             return AVERROR_INVALIDDATA;
245         }
246
247         if (skip) {
248             y[0] = old_y[0];
249             y[1] = old_y[1];
250             y[2] = old_y[old_y_stride];
251             y[3] = old_y[old_y_stride + 1];
252             y_avg = ya[0];
253             cb = old_cb[0];
254             cr = old_cr[0];
255         } else {
256             if (get_bits1(&gb)) {
257                 unsigned sign_selector       = get_bits(&gb, 6);
258                 unsigned difference_selector = get_bits(&gb, 2);
259                 y_avg = 2 * get_bits(&gb, 5);
260                 for (i = 0; i < 4; i++) {
261                     y[i] = av_clip(y_avg + offset_table[difference_selector] *
262                                    sign_table[sign_selector][i], 0, 63);
263                 }
264             } else if (get_bits1(&gb)) {
265                 if (get_bits1(&gb)) {
266                     y_avg = get_bits(&gb, 6);
267                 } else {
268                     unsigned adjust_index = get_bits(&gb, 3);
269                     y_avg = (y_avg + luma_adjust[adjust_index]) & 63;
270                 }
271                 for (i = 0; i < 4; i++)
272                     y[i] = y_avg;
273             }
274
275             if (get_bits1(&gb)) {
276                 if (get_bits1(&gb)) {
277                     cb = get_bits(&gb, 5);
278                     cr = get_bits(&gb, 5);
279                 } else {
280                     unsigned adjust_index = get_bits(&gb, 3);
281                     cb = (cb + chroma_adjust[0][adjust_index]) & 31;
282                     cr = (cr + chroma_adjust[1][adjust_index]) & 31;
283                 }
284             }
285         }
286         *ya++ = y_avg;
287
288         new_y[0]                = y[0];
289         new_y[1]                = y[1];
290         new_y[new_y_stride]     = y[2];
291         new_y[new_y_stride + 1] = y[3];
292         *new_cb = cb;
293         *new_cr = cr;
294
295         old_y += 2;
296         old_cb++;
297         old_cr++;
298         new_y += 2;
299         new_cb++;
300         new_cr++;
301         block_x++;
302         if (block_x * 2 == avctx->width) {
303             block_x = 0;
304             old_y  += old_y_stride * 2  - avctx->width;
305             old_cb += old_cb_stride     - avctx->width / 2;
306             old_cr += old_cr_stride     - avctx->width / 2;
307             new_y  += new_y_stride * 2  - avctx->width;
308             new_cb += new_cb_stride     - avctx->width / 2;
309             new_cr += new_cr_stride     - avctx->width / 2;
310         }
311
312         skip--;
313     }
314
315     new_y  = s->new_y;
316     new_cb = s->new_u;
317     new_cr = s->new_v;
318     dstY   = pic->data[0];
319     dstU   = pic->data[1];
320     dstV   = pic->data[2];
321     for (j = 0; j < avctx->height; j++) {
322         for (i = 0; i < avctx->width; i++)
323             dstY[i] = new_y[i] << 2;
324         dstY  += pic->linesize[0];
325         new_y += new_y_stride;
326     }
327     for (j = 0; j < avctx->height / 2; j++) {
328         for (i = 0; i < avctx->width / 2; i++) {
329             dstU[i] = chroma_vals[new_cb[i]];
330             dstV[i] = chroma_vals[new_cr[i]];
331         }
332         dstU   += pic->linesize[1];
333         dstV   += pic->linesize[2];
334         new_cb += new_cb_stride;
335         new_cr += new_cr_stride;
336     }
337
338     av_dlog(avctx, "Frame data: provided %d bytes, used %d bytes\n",
339             buf_size, get_bits_count(&gb) >> 3);
340
341     FFSWAP(uint8_t*, s->old_y, s->new_y);
342     FFSWAP(uint8_t*, s->old_u, s->new_u);
343     FFSWAP(uint8_t*, s->old_v, s->new_v);
344
345     *got_frame = 1;
346
347     return buf_size;
348 }
349
350 AVCodec ff_escape130_decoder = {
351     .name           = "escape130",
352     .long_name      = NULL_IF_CONFIG_SMALL("Escape 130"),
353     .type           = AVMEDIA_TYPE_VIDEO,
354     .id             = AV_CODEC_ID_ESCAPE130,
355     .priv_data_size = sizeof(Escape130Context),
356     .init           = escape130_decode_init,
357     .close          = escape130_decode_close,
358     .decode         = escape130_decode_frame,
359     .capabilities   = CODEC_CAP_DR1,
360 };