avcodec: add Gremlin Digital Video decoder
[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 Bits32 {
42     uint32_t queue;
43     uint8_t  fill;
44 } Bits32;
45
46 #define PREAMBLE_SIZE 4096
47
48 static av_cold int gdv_decode_init(AVCodecContext *avctx)
49 {
50     GDVContext *gdv = avctx->priv_data;
51     int i, j, k;
52
53     avctx->pix_fmt  = AV_PIX_FMT_PAL8;
54     gdv->frame_size = avctx->width * avctx->height + PREAMBLE_SIZE;
55     gdv->frame = av_calloc(gdv->frame_size, 1);
56     if (!gdv->frame)
57         return AVERROR(ENOMEM);
58
59     for (i = 0; i < 2; i++) {
60         for (j = 0; j < 256; j++) {
61             for (k = 0; k < 8; k++) {
62                 gdv->frame[i * 2048 + j * 8 + k] = j;
63             }
64         }
65     }
66
67     return 0;
68 }
69
70 static void rescale(GDVContext *gdv, uint8_t *dst, int w, int h, int scale_v, int scale_h)
71 {
72     int i, j, y, x;
73
74     if ((gdv->scale_v == scale_v) && (gdv->scale_h == scale_h)) {
75         return;
76     }
77
78     if (gdv->scale_h && gdv->scale_v) {
79         for (j = 0; j < h; j++) {
80             int y = h - j - 1;
81             for (i = 0; i < w; i++) {
82                 int x = w - i - 1;
83                 dst[PREAMBLE_SIZE + x + y * w] = dst[PREAMBLE_SIZE + x/2 + (y/2) * (w/2)];
84             }
85         }
86     } else if (gdv->scale_h) {
87         for (j = 0; j < h; j++) {
88             int y = h - j - 1;
89             for (x = 0; x < w; x++) {
90                 dst[PREAMBLE_SIZE + x + y * w] = dst[PREAMBLE_SIZE + x + (y/2) * w];
91             }
92         }
93     } else if (gdv->scale_v) {
94         for (j = 0; j < h; j++) {
95             int y = h - j - 1;
96             for (i = 0; i < w; i++) {
97                 int x = w - i - 1;
98                 dst[PREAMBLE_SIZE + x + y * w] = dst[PREAMBLE_SIZE + x/2 + y * (w/2)];
99             }
100         }
101     }
102
103     if (scale_h && scale_v) {
104         for (y = 0; y < h/2; y++) {
105             for (x = 0; x < w/2; x++) {
106                 dst[PREAMBLE_SIZE + x + y * (w/2)] = dst[PREAMBLE_SIZE + x*2 + y*2 * w];
107             }
108         }
109     } else if (scale_h) {
110         for (y = 0; y < h/2; y++) {
111             for (x = 0; x < w; x++) {
112                 dst[PREAMBLE_SIZE + x + y * w] = dst[PREAMBLE_SIZE + x + y*2 * w];
113             }
114         }
115     } else if (scale_v) {
116         for (y = 0; y < h; y++) {
117             for (x = 0; x < w/2; x++) {
118                 dst[PREAMBLE_SIZE + x + y * w] = dst[PREAMBLE_SIZE + x*2 + y * w];
119             }
120         }
121     }
122
123     gdv->scale_v = scale_v;
124     gdv->scale_h = scale_h;
125 }
126
127 static void fill_bits32(Bits32 *bits, GetByteContext *gb)
128 {
129     bits->queue = bytestream2_get_le32(gb);
130     bits->fill  = 32;
131 }
132
133 static int read_bits32(Bits32 *bits, GetByteContext *gb, int nbits)
134 {
135     int res = bits->queue & ((1 << nbits) - 1);
136
137     bits->queue >>= nbits;
138     bits->fill   -= nbits;
139     if (bits->fill <= 16) {
140         bits->queue |= bytestream2_get_le16(gb) << bits->fill;
141         bits->fill  += 16;
142     }
143
144     return res;
145 }
146
147 static void lz_copy(PutByteContext *pb, GetByteContext *g2, int offset, unsigned len)
148 {
149     int i;
150
151     if (offset == -1) {
152         int c;
153
154         bytestream2_seek(g2, bytestream2_tell_p(pb) - 1, SEEK_SET);
155         c = bytestream2_get_byte(g2);
156         for (i = 0; i < len; i++) {
157             bytestream2_put_byte(pb, c);
158         }
159     } else if (offset < 0) {
160         int start = bytestream2_tell_p(pb) - (-offset);
161
162         bytestream2_seek(g2, start, SEEK_SET);
163         for (i = 0; i < len; i++) {
164             bytestream2_put_byte(pb, bytestream2_get_byte(g2));
165         }
166     } else {
167         int start = bytestream2_tell_p(pb) + offset;
168
169         bytestream2_seek(g2, start, SEEK_SET);
170         for (i = 0; i < len; i++) {
171             bytestream2_put_byte(pb, bytestream2_get_byte(g2));
172         }
173     }
174 }
175
176 static int decompress_68(AVCodecContext *avctx, unsigned skip, unsigned use8)
177 {
178     GDVContext *gdv = avctx->priv_data;
179     GetByteContext *gb = &gdv->gb;
180     GetByteContext *g2 = &gdv->g2;
181     PutByteContext *pb = &gdv->pb;
182     Bits32 bits;
183
184     bytestream2_init(g2, gdv->frame, gdv->frame_size);
185     bytestream2_skip_p(pb, skip + PREAMBLE_SIZE);
186     fill_bits32(&bits, gb);
187
188     while (bytestream2_get_bytes_left_p(pb) > 0 && bytestream2_get_bytes_left(gb) > 0) {
189         int tag = read_bits32(&bits, gb, 2);
190         if (tag == 0) {
191             int b = read_bits32(&bits, gb, 1);
192             if (b == 0) {
193                 bytestream2_put_byte(pb, bytestream2_get_byte(gb));
194             } else {
195                 int i, len = 2;
196                 int lbits = 0;
197                 while (1) {
198                     int val;
199
200                     lbits += 1;
201                     val = read_bits32(&bits, gb, lbits);
202                     len += val;
203                     if (val != ((1 << lbits) - 1)) {
204                         break;
205                     }
206                     assert(lbits < 16);
207                 }
208                 for (i = 0; i < len; i++) {
209                     bytestream2_put_byte(pb, bytestream2_get_byte(gb));
210                 }
211             }
212         } else if (tag == 1) {
213             int b = read_bits32(&bits, gb, 1);
214             int len;
215
216             if (b == 0) {
217                 len = (read_bits32(&bits, gb, 4)) + 2;
218             } else {
219                 int bb = bytestream2_get_byte(gb);
220                 if ((bb & 0x80) == 0) {
221                     len = bb + 18;
222                 } else {
223                     int top = (bb & 0x7F) << 8;
224                     len = top + bytestream2_get_byte(gb) + 146;
225                 }
226             }
227             bytestream2_skip_p(pb, len);
228         } else if (tag == 2) {
229             int i, subtag = read_bits32(&bits, gb, 2);
230
231             if (subtag != 3) {
232                 int top = (read_bits32(&bits, gb, 4)) << 8;
233                 int offs = top + bytestream2_get_byte(gb);
234                 if ((subtag != 0) || (offs <= 0xF80)) {
235                     int len = (subtag) + 3;
236                     lz_copy(pb, g2, (offs) - 4096, len);
237                 } else {
238                     if (offs == 0xFFF) {
239                         return 0;
240                     }
241
242                     int real_off = ((offs >> 4) & 0x7) + 1;
243                     int len = ((offs & 0xF) + 2) * 2;
244                     int c1 = gdv->frame[bytestream2_tell_p(pb) - real_off];
245                     int c2 = gdv->frame[bytestream2_tell_p(pb) - real_off + 1];
246                     for (i = 0; i < len/2; i++) {
247                         bytestream2_put_byte(pb, c1);
248                         bytestream2_put_byte(pb, c2);
249                     }
250                 }
251             } else {
252                 int b = bytestream2_get_byte(gb);
253                 int off = ((b & 0x7F)) + 1;
254                 int len = ((b & 0x80) == 0) ? 2 : 3;
255
256                 lz_copy(pb, g2, -off, len);
257             }
258         } else {
259             int len;
260             int off;
261             if (use8) {
262                 int b = bytestream2_get_byte(gb);
263                 if ((b & 0xC0) == 0xC0) {
264                     len = ((b & 0x3F)) + 8;
265                     int q = read_bits32(&bits, gb, 4);
266                     off = (q << 8) + (bytestream2_get_byte(gb)) + 1;
267                 } else {
268                     int ofs1;
269                     if ((b & 0x80) == 0) {
270                         len = ((b >> 4)) + 6;
271                         ofs1 = (b & 0xF);
272                     } else {
273                         len = ((b & 0x3F)) + 14;
274                         ofs1 = read_bits32(&bits, gb, 4);
275                     }
276                     off = (ofs1 << 8) + (bytestream2_get_byte(gb)) - 4096;
277                 }
278             } else {
279                 int b = bytestream2_get_byte(gb);
280
281                 if ((b >> 4) == 0xF) {
282                     len = bytestream2_get_byte(gb) + 21;
283                 } else {
284                     len = (b >> 4) + 6;
285                 }
286                 int ofs1 = (b & 0xF);
287                 off = (ofs1 << 8) + bytestream2_get_byte(gb) - 4096;
288             }
289             lz_copy(pb, g2, off, len);
290         }
291     }
292
293     return 0;
294 }
295
296 static int gdv_decode_frame(AVCodecContext *avctx, void *data,
297                             int *got_frame, AVPacket *avpkt)
298 {
299     GDVContext *gdv = avctx->priv_data;
300     GetByteContext *gb = &gdv->gb;
301     PutByteContext *pb = &gdv->pb;
302     AVFrame *frame = data;
303     int ret, i, pal_size;
304     const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, &pal_size);
305     int compression;
306     unsigned flags;
307     uint8_t *dst;
308
309     if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
310         return ret;
311     if (pal && pal_size == AVPALETTE_SIZE)
312         memcpy(gdv->pal, pal, AVPALETTE_SIZE);
313
314     bytestream2_init(gb, avpkt->data, avpkt->size);
315     bytestream2_init_writer(pb, gdv->frame, gdv->frame_size);
316
317     flags = bytestream2_get_le32(gb);
318     compression = flags & 0xF;
319
320     rescale(gdv, gdv->frame, avctx->width, avctx->height,
321             !!(flags & 0x10), !!(flags & 0x20));
322
323     switch (compression) {
324     case 1:
325         memset(gdv->frame + PREAMBLE_SIZE, 0, gdv->frame_size - PREAMBLE_SIZE);
326     case 0:
327         for (i = 0; i < 256; i++) {
328             unsigned r = bytestream2_get_byte(gb);
329             unsigned g = bytestream2_get_byte(gb);
330             unsigned b = bytestream2_get_byte(gb);
331             gdv->pal[i] = 0xFF << 24 | r << 18 | g << 10 | b << 2;
332         }
333         break;
334     case 3:
335         break;
336     case 6:
337         ret = decompress_68(avctx, flags >> 8, 0);
338         break;
339     case 8:
340         ret = decompress_68(avctx, flags >> 8, 1);
341         break;
342     default:
343         return AVERROR_INVALIDDATA;
344     }
345
346     memcpy(frame->data[1], gdv->pal, AVPALETTE_SIZE);
347     dst = frame->data[0];
348
349     if (!gdv->scale_v && !gdv->scale_h) {
350         int sidx = PREAMBLE_SIZE, didx = 0;
351         int y, x;
352
353         for (y = 0; y < avctx->height; y++) {
354             for (x = 0; x < avctx->width; x++) {
355                 dst[x+didx] = gdv->frame[x+sidx];
356             }
357             sidx += avctx->width;
358             didx += frame->linesize[0];
359         }
360     } else {
361         int sidx = PREAMBLE_SIZE, didx = 0;
362         int y, x;
363
364         for (y = 0; y < avctx->height; y++) {
365             if (!gdv->scale_v) {
366                 for (x = 0; x < avctx->width; x++) {
367                     dst[didx + x] = gdv->frame[sidx + x];
368                 }
369             } else {
370                 for (x = 0; x < avctx->width; x++) {
371                     dst[didx + x] = gdv->frame[sidx + x/2];
372                 }
373             }
374             if (!gdv->scale_h || ((y & 1) == 1)) {
375                 sidx += !gdv->scale_v ? avctx->width : avctx->width/2;
376             }
377             didx += frame->linesize[0];
378         }
379     }
380
381     *got_frame = 1;
382
383     return ret < 0 ? ret : avpkt->size;
384 }
385
386 static av_cold int gdv_decode_close(AVCodecContext *avctx)
387 {
388     GDVContext *gdv = avctx->priv_data;
389     av_freep(&gdv->frame);
390     return 0;
391 }
392
393 AVCodec ff_gdv_decoder = {
394     .name           = "gdv",
395     .long_name      = NULL_IF_CONFIG_SMALL("Gremlin Digital Video"),
396     .type           = AVMEDIA_TYPE_VIDEO,
397     .id             = AV_CODEC_ID_GDV,
398     .priv_data_size = sizeof(GDVContext),
399     .init           = gdv_decode_init,
400     .close          = gdv_decode_close,
401     .decode         = gdv_decode_frame,
402     .capabilities   = AV_CODEC_CAP_DR1,
403     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
404 };