avcodec/dca: avoid using bitstream reader in a non-standard way
[ffmpeg.git] / libavcodec / gdv.c
1 /*
2  * Gremlin Digital Video (GDV) decoder
3  * Copyright (c) 2017 Konstantin Shishkov
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 "libavutil/common.h"
24 #include "avcodec.h"
25 #include "bytestream.h"
26 #include "internal.h"
27
28 typedef struct GDVContext {
29     AVCodecContext *avctx;
30
31     GetByteContext gb;
32     GetByteContext g2;
33     PutByteContext pb;
34
35     uint32_t pal[256];
36     uint8_t *frame;
37     unsigned frame_size;
38     unsigned scale_h, scale_v;
39 } GDVContext;
40
41 typedef struct Bits8 {
42     uint8_t queue;
43     uint8_t fill;
44 } Bits8;
45
46 typedef struct Bits32 {
47     uint32_t queue;
48     uint8_t  fill;
49 } Bits32;
50
51 #define PREAMBLE_SIZE 4096
52
53 static av_cold int gdv_decode_init(AVCodecContext *avctx)
54 {
55     GDVContext *gdv = avctx->priv_data;
56     int i, j, k;
57
58     avctx->pix_fmt  = AV_PIX_FMT_PAL8;
59     gdv->frame_size = avctx->width * avctx->height + PREAMBLE_SIZE;
60     gdv->frame = av_calloc(gdv->frame_size, 1);
61     if (!gdv->frame)
62         return AVERROR(ENOMEM);
63
64     for (i = 0; i < 2; i++) {
65         for (j = 0; j < 256; j++) {
66             for (k = 0; k < 8; k++) {
67                 gdv->frame[i * 2048 + j * 8 + k] = j;
68             }
69         }
70     }
71
72     return 0;
73 }
74
75 static void rescale(GDVContext *gdv, uint8_t *dst, int w, int h, int scale_v, int scale_h)
76 {
77     int i, j, y, x;
78
79     if ((gdv->scale_v == scale_v) && (gdv->scale_h == scale_h)) {
80         return;
81     }
82
83     if (gdv->scale_h && gdv->scale_v) {
84         for (j = 0; j < h; j++) {
85             int y = h - j - 1;
86             for (i = 0; i < w; i++) {
87                 int x = w - i - 1;
88                 dst[PREAMBLE_SIZE + x + y * w] = dst[PREAMBLE_SIZE + x/2 + (y/2) * (w/2)];
89             }
90         }
91     } else if (gdv->scale_h) {
92         for (j = 0; j < h; j++) {
93             int y = h - j - 1;
94             for (x = 0; x < w; x++) {
95                 dst[PREAMBLE_SIZE + x + y * w] = dst[PREAMBLE_SIZE + x + (y/2) * w];
96             }
97         }
98     } else if (gdv->scale_v) {
99         for (j = 0; j < h; j++) {
100             int y = h - j - 1;
101             for (i = 0; i < w; i++) {
102                 int x = w - i - 1;
103                 dst[PREAMBLE_SIZE + x + y * w] = dst[PREAMBLE_SIZE + x/2 + y * (w/2)];
104             }
105         }
106     }
107
108     if (scale_h && scale_v) {
109         for (y = 0; y < h/2; y++) {
110             for (x = 0; x < w/2; x++) {
111                 dst[PREAMBLE_SIZE + x + y * (w/2)] = dst[PREAMBLE_SIZE + x*2 + y*2 * w];
112             }
113         }
114     } else if (scale_h) {
115         for (y = 0; y < h/2; y++) {
116             for (x = 0; x < w; x++) {
117                 dst[PREAMBLE_SIZE + x + y * w] = dst[PREAMBLE_SIZE + x + y*2 * w];
118             }
119         }
120     } else if (scale_v) {
121         for (y = 0; y < h; y++) {
122             for (x = 0; x < w/2; x++) {
123                 dst[PREAMBLE_SIZE + x + y * w] = dst[PREAMBLE_SIZE + x*2 + y * w];
124             }
125         }
126     }
127
128     gdv->scale_v = scale_v;
129     gdv->scale_h = scale_h;
130 }
131
132 static int read_bits2(Bits8 *bits, GetByteContext *gb)
133 {
134     int res;
135
136     if (bits->fill == 0) {
137         bits->queue |= bytestream2_get_byte(gb);
138         bits->fill   = 8;
139     }
140     res = bits->queue >> 6;
141     bits->queue <<= 2;
142     bits->fill   -= 2;
143
144     return res;
145 }
146
147 static void fill_bits32(Bits32 *bits, GetByteContext *gb)
148 {
149     bits->queue = bytestream2_get_le32(gb);
150     bits->fill  = 32;
151 }
152
153 static int read_bits32(Bits32 *bits, GetByteContext *gb, int nbits)
154 {
155     int res = bits->queue & ((1 << nbits) - 1);
156
157     bits->queue >>= nbits;
158     bits->fill   -= nbits;
159     if (bits->fill <= 16) {
160         bits->queue |= bytestream2_get_le16(gb) << bits->fill;
161         bits->fill  += 16;
162     }
163
164     return res;
165 }
166
167 static void lz_copy(PutByteContext *pb, GetByteContext *g2, int offset, unsigned len)
168 {
169     int i;
170
171     if (offset == -1) {
172         int c;
173
174         bytestream2_seek(g2, bytestream2_tell_p(pb) - 1, SEEK_SET);
175         c = bytestream2_get_byte(g2);
176         for (i = 0; i < len; i++) {
177             bytestream2_put_byte(pb, c);
178         }
179     } else if (offset < 0) {
180         int start = bytestream2_tell_p(pb) - (-offset);
181
182         bytestream2_seek(g2, start, SEEK_SET);
183         for (i = 0; i < len; i++) {
184             bytestream2_put_byte(pb, bytestream2_get_byte(g2));
185         }
186     } else {
187         int start = bytestream2_tell_p(pb) + offset;
188
189         bytestream2_seek(g2, start, SEEK_SET);
190         for (i = 0; i < len; i++) {
191             bytestream2_put_byte(pb, bytestream2_get_byte(g2));
192         }
193     }
194 }
195
196 static int decompress_2(AVCodecContext *avctx)
197 {
198     GDVContext *gdv = avctx->priv_data;
199     GetByteContext *gb = &gdv->gb;
200     GetByteContext *g2 = &gdv->g2;
201     PutByteContext *pb = &gdv->pb;
202     Bits8 bits = { 0 };
203     int c, i;
204
205     bytestream2_init(g2, gdv->frame, gdv->frame_size);
206     bytestream2_skip_p(pb, PREAMBLE_SIZE);
207
208     for (c = 0; c < 256; c++) {
209         for (i = 0; i < 16; i++) {
210             gdv->frame[c * 16 + i] = c;
211         }
212     }
213
214     while (bytestream2_get_bytes_left_p(pb) > 0 && bytestream2_get_bytes_left(gb) > 0) {
215         int tag = read_bits2(&bits, gb);
216         if (tag == 0) {
217             bytestream2_put_byte(pb, bytestream2_get_byte(gb));
218         } else if (tag == 1) {
219             int b = bytestream2_get_byte(gb);
220             int len = (b & 0xF) + 3;
221             int top = (b >> 4) & 0xF;
222             int off = (bytestream2_get_byte(gb) << 4) + top - 4096;
223             lz_copy(pb, g2, off, len);
224         } else if (tag == 2) {
225             int len = (bytestream2_get_byte(gb)) + 2;
226             bytestream2_skip_p(pb, len);
227         } else {
228             break;
229         }
230     }
231     return 0;
232 }
233
234 static int decompress_5(AVCodecContext *avctx, unsigned skip)
235 {
236     GDVContext *gdv = avctx->priv_data;
237     GetByteContext *gb = &gdv->gb;
238     GetByteContext *g2 = &gdv->g2;
239     PutByteContext *pb = &gdv->pb;
240     Bits8 bits = { 0 };
241
242     bytestream2_init(g2, gdv->frame, gdv->frame_size);
243     bytestream2_skip_p(pb, skip + PREAMBLE_SIZE);
244
245     while (bytestream2_get_bytes_left_p(pb) > 0 && bytestream2_get_bytes_left(gb) > 0) {
246         int tag = read_bits2(&bits, gb);
247         if (tag == 0) {
248             bytestream2_put_byte(pb, bytestream2_get_byte(gb));
249         } else if (tag == 1) {
250             int b = bytestream2_get_byte(gb);
251             int len = (b & 0xF) + 3;
252             int top = b >> 4;
253             int off = (bytestream2_get_byte(gb) << 4) + top - 4096;
254             lz_copy(pb, g2, off, len);
255         } else if (tag == 2) {
256             int len;
257             int b = bytestream2_get_byte(gb);
258             if (b == 0) {
259                 break;
260             }
261             if (b != 0xFF) {
262                 len = b;
263             } else {
264                 len = bytestream2_get_le16(gb);
265             }
266             bytestream2_skip_p(pb, len + 1);
267         } else {
268             int b = bytestream2_get_byte(gb);
269             int len = (b & 0x3) + 2;
270             int off = -(b >> 2) - 1;
271             lz_copy(pb, g2, off, len);
272         }
273     }
274     return 0;
275 }
276
277 static int decompress_68(AVCodecContext *avctx, unsigned skip, unsigned use8)
278 {
279     GDVContext *gdv = avctx->priv_data;
280     GetByteContext *gb = &gdv->gb;
281     GetByteContext *g2 = &gdv->g2;
282     PutByteContext *pb = &gdv->pb;
283     Bits32 bits;
284
285     bytestream2_init(g2, gdv->frame, gdv->frame_size);
286     bytestream2_skip_p(pb, skip + PREAMBLE_SIZE);
287     fill_bits32(&bits, gb);
288
289     while (bytestream2_get_bytes_left_p(pb) > 0 && bytestream2_get_bytes_left(gb) > 0) {
290         int tag = read_bits32(&bits, gb, 2);
291         if (tag == 0) {
292             int b = read_bits32(&bits, gb, 1);
293             if (b == 0) {
294                 bytestream2_put_byte(pb, bytestream2_get_byte(gb));
295             } else {
296                 int i, len = 2;
297                 int lbits = 0;
298                 while (1) {
299                     int val;
300
301                     lbits += 1;
302                     val = read_bits32(&bits, gb, lbits);
303                     len += val;
304                     if (val != ((1 << lbits) - 1)) {
305                         break;
306                     }
307                     assert(lbits < 16);
308                 }
309                 for (i = 0; i < len; i++) {
310                     bytestream2_put_byte(pb, bytestream2_get_byte(gb));
311                 }
312             }
313         } else if (tag == 1) {
314             int b = read_bits32(&bits, gb, 1);
315             int len;
316
317             if (b == 0) {
318                 len = (read_bits32(&bits, gb, 4)) + 2;
319             } else {
320                 int bb = bytestream2_get_byte(gb);
321                 if ((bb & 0x80) == 0) {
322                     len = bb + 18;
323                 } else {
324                     int top = (bb & 0x7F) << 8;
325                     len = top + bytestream2_get_byte(gb) + 146;
326                 }
327             }
328             bytestream2_skip_p(pb, len);
329         } else if (tag == 2) {
330             int i, subtag = read_bits32(&bits, gb, 2);
331
332             if (subtag != 3) {
333                 int top = (read_bits32(&bits, gb, 4)) << 8;
334                 int offs = top + bytestream2_get_byte(gb);
335                 if ((subtag != 0) || (offs <= 0xF80)) {
336                     int len = (subtag) + 3;
337                     lz_copy(pb, g2, (offs) - 4096, len);
338                 } else {
339                     int real_off, len, c1, c2;
340
341                     if (offs == 0xFFF) {
342                         return 0;
343                     }
344
345                     real_off = ((offs >> 4) & 0x7) + 1;
346                     len = ((offs & 0xF) + 2) * 2;
347                     c1 = gdv->frame[bytestream2_tell_p(pb) - real_off];
348                     c2 = gdv->frame[bytestream2_tell_p(pb) - real_off + 1];
349                     for (i = 0; i < len/2; i++) {
350                         bytestream2_put_byte(pb, c1);
351                         bytestream2_put_byte(pb, c2);
352                     }
353                 }
354             } else {
355                 int b = bytestream2_get_byte(gb);
356                 int off = ((b & 0x7F)) + 1;
357                 int len = ((b & 0x80) == 0) ? 2 : 3;
358
359                 lz_copy(pb, g2, -off, len);
360             }
361         } else {
362             int len;
363             int off;
364             if (use8) {
365                 int q, b = bytestream2_get_byte(gb);
366                 if ((b & 0xC0) == 0xC0) {
367                     len = ((b & 0x3F)) + 8;
368                     q = read_bits32(&bits, gb, 4);
369                     off = (q << 8) + (bytestream2_get_byte(gb)) + 1;
370                 } else {
371                     int ofs1;
372                     if ((b & 0x80) == 0) {
373                         len = ((b >> 4)) + 6;
374                         ofs1 = (b & 0xF);
375                     } else {
376                         len = ((b & 0x3F)) + 14;
377                         ofs1 = read_bits32(&bits, gb, 4);
378                     }
379                     off = (ofs1 << 8) + (bytestream2_get_byte(gb)) - 4096;
380                 }
381             } else {
382                 int ofs1, b = bytestream2_get_byte(gb);
383
384                 if ((b >> 4) == 0xF) {
385                     len = bytestream2_get_byte(gb) + 21;
386                 } else {
387                     len = (b >> 4) + 6;
388                 }
389                 ofs1 = (b & 0xF);
390                 off = (ofs1 << 8) + bytestream2_get_byte(gb) - 4096;
391             }
392             lz_copy(pb, g2, off, len);
393         }
394     }
395
396     return 0;
397 }
398
399 static int gdv_decode_frame(AVCodecContext *avctx, void *data,
400                             int *got_frame, AVPacket *avpkt)
401 {
402     GDVContext *gdv = avctx->priv_data;
403     GetByteContext *gb = &gdv->gb;
404     PutByteContext *pb = &gdv->pb;
405     AVFrame *frame = data;
406     int ret, i, pal_size;
407     const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, &pal_size);
408     int compression;
409     unsigned flags;
410     uint8_t *dst;
411
412     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
413         return ret;
414     if (pal && pal_size == AVPALETTE_SIZE)
415         memcpy(gdv->pal, pal, AVPALETTE_SIZE);
416
417     bytestream2_init(gb, avpkt->data, avpkt->size);
418     bytestream2_init_writer(pb, gdv->frame, gdv->frame_size);
419
420     flags = bytestream2_get_le32(gb);
421     compression = flags & 0xF;
422
423     rescale(gdv, gdv->frame, avctx->width, avctx->height,
424             !!(flags & 0x10), !!(flags & 0x20));
425
426     switch (compression) {
427     case 1:
428         memset(gdv->frame + PREAMBLE_SIZE, 0, gdv->frame_size - PREAMBLE_SIZE);
429     case 0:
430         for (i = 0; i < 256; i++) {
431             unsigned r = bytestream2_get_byte(gb);
432             unsigned g = bytestream2_get_byte(gb);
433             unsigned b = bytestream2_get_byte(gb);
434             gdv->pal[i] = 0xFFU << 24 | r << 18 | g << 10 | b << 2;
435         }
436         break;
437     case 2:
438         ret = decompress_2(avctx);
439         break;
440     case 3:
441         break;
442     case 5:
443         ret = decompress_5(avctx, flags >> 8);
444         break;
445     case 6:
446         ret = decompress_68(avctx, flags >> 8, 0);
447         break;
448     case 8:
449         ret = decompress_68(avctx, flags >> 8, 1);
450         break;
451     default:
452         return AVERROR_INVALIDDATA;
453     }
454
455     memcpy(frame->data[1], gdv->pal, AVPALETTE_SIZE);
456     dst = frame->data[0];
457
458     if (!gdv->scale_v && !gdv->scale_h) {
459         int sidx = PREAMBLE_SIZE, didx = 0;
460         int y, x;
461
462         for (y = 0; y < avctx->height; y++) {
463             for (x = 0; x < avctx->width; x++) {
464                 dst[x+didx] = gdv->frame[x+sidx];
465             }
466             sidx += avctx->width;
467             didx += frame->linesize[0];
468         }
469     } else {
470         int sidx = PREAMBLE_SIZE, didx = 0;
471         int y, x;
472
473         for (y = 0; y < avctx->height; y++) {
474             if (!gdv->scale_v) {
475                 for (x = 0; x < avctx->width; x++) {
476                     dst[didx + x] = gdv->frame[sidx + x];
477                 }
478             } else {
479                 for (x = 0; x < avctx->width; x++) {
480                     dst[didx + x] = gdv->frame[sidx + x/2];
481                 }
482             }
483             if (!gdv->scale_h || ((y & 1) == 1)) {
484                 sidx += !gdv->scale_v ? avctx->width : avctx->width/2;
485             }
486             didx += frame->linesize[0];
487         }
488     }
489
490     *got_frame = 1;
491
492     return ret < 0 ? ret : avpkt->size;
493 }
494
495 static av_cold int gdv_decode_close(AVCodecContext *avctx)
496 {
497     GDVContext *gdv = avctx->priv_data;
498     av_freep(&gdv->frame);
499     return 0;
500 }
501
502 AVCodec ff_gdv_decoder = {
503     .name           = "gdv",
504     .long_name      = NULL_IF_CONFIG_SMALL("Gremlin Digital Video"),
505     .type           = AVMEDIA_TYPE_VIDEO,
506     .id             = AV_CODEC_ID_GDV,
507     .priv_data_size = sizeof(GDVContext),
508     .init           = gdv_decode_init,
509     .close          = gdv_decode_close,
510     .decode         = gdv_decode_frame,
511     .capabilities   = AV_CODEC_CAP_DR1,
512     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
513 };