1 /*
2 * QPEG codec
3 * Copyright (c) 2004 Konstantin Shishkov
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 /**
23 * @file
24 * QPEG codec.
25 */
26
27 #include "avcodec.h"
28 #include "bytestream.h"
29 #include "codec_internal.h"
30 #include "decode.h"
31 #include "internal.h"
32
33 typedef struct QpegContext{
34 AVCodecContext *avctx;
35 AVFrame *ref;
36 uint32_t pal[256];
37 GetByteContext buffer;
38 } QpegContext;
39
qpeg_decode_intra(QpegContext * qctx,uint8_t * dst,int stride,int width,int height)40 static void qpeg_decode_intra(QpegContext *qctx, uint8_t *dst,
41 int stride, int width, int height)
42 {
43 int i;
44 int code;
45 int c0, c1;
46 int run, copy;
47 int filled = 0;
48 int rows_to_go;
49
50 rows_to_go = height;
51 height--;
52 dst = dst + height * stride;
53
54 while ((bytestream2_get_bytes_left(&qctx->buffer) > 0) && (rows_to_go > 0)) {
55 code = bytestream2_get_byte(&qctx->buffer);
56 run = copy = 0;
57 if(code == 0xFC) /* end-of-picture code */
58 break;
59 if(code >= 0xF8) { /* very long run */
60 c0 = bytestream2_get_byte(&qctx->buffer);
61 c1 = bytestream2_get_byte(&qctx->buffer);
62 run = ((code & 0x7) << 16) + (c0 << 8) + c1 + 2;
63 } else if (code >= 0xF0) { /* long run */
64 c0 = bytestream2_get_byte(&qctx->buffer);
65 run = ((code & 0xF) << 8) + c0 + 2;
66 } else if (code >= 0xE0) { /* short run */
67 run = (code & 0x1F) + 2;
68 } else if (code >= 0xC0) { /* very long copy */
69 c0 = bytestream2_get_byte(&qctx->buffer);
70 c1 = bytestream2_get_byte(&qctx->buffer);
71 copy = ((code & 0x3F) << 16) + (c0 << 8) + c1 + 1;
72 } else if (code >= 0x80) { /* long copy */
73 c0 = bytestream2_get_byte(&qctx->buffer);
74 copy = ((code & 0x7F) << 8) + c0 + 1;
75 } else { /* short copy */
76 copy = code + 1;
77 }
78
79 /* perform actual run or copy */
80 if(run) {
81 int p;
82
83 p = bytestream2_get_byte(&qctx->buffer);
84 for(i = 0; i < run; i++) {
85 int step = FFMIN(run - i, width - filled);
86 memset(dst+filled, p, step);
87 filled += step;
88 i += step - 1;
89 if (filled >= width) {
90 filled = 0;
91 dst -= stride;
92 rows_to_go--;
93 while (run - i > width && rows_to_go > 0) {
94 memset(dst, p, width);
95 dst -= stride;
96 rows_to_go--;
97 i += width;
98 }
99 if(rows_to_go <= 0)
100 break;
101 }
102 }
103 } else {
104 if (bytestream2_get_bytes_left(&qctx->buffer) < copy)
105 copy = bytestream2_get_bytes_left(&qctx->buffer);
106 while (copy > 0) {
107 int step = FFMIN(copy, width - filled);
108 bytestream2_get_bufferu(&qctx->buffer, dst + filled, step);
109 filled += step;
110 copy -= step;
111 if (filled >= width) {
112 filled = 0;
113 dst -= stride;
114 rows_to_go--;
115 if(rows_to_go <= 0)
116 break;
117 }
118 }
119 }
120 }
121 }
122
123 static const uint8_t qpeg_table_h[16] =
124 { 0x00, 0x20, 0x20, 0x20, 0x18, 0x10, 0x10, 0x20, 0x10, 0x08, 0x18, 0x08, 0x08, 0x18, 0x10, 0x04};
125 static const uint8_t qpeg_table_w[16] =
126 { 0x00, 0x20, 0x18, 0x08, 0x18, 0x10, 0x20, 0x10, 0x08, 0x10, 0x20, 0x20, 0x08, 0x10, 0x18, 0x04};
127
128 /* Decodes delta frames */
qpeg_decode_inter(QpegContext * qctx,uint8_t * dst,int stride,int width,int height,int delta,const uint8_t * ctable,uint8_t * refdata)129 static void av_noinline qpeg_decode_inter(QpegContext *qctx, uint8_t *dst,
130 int stride, int width, int height,
131 int delta, const uint8_t *ctable,
132 uint8_t *refdata)
133 {
134 int i, j;
135 int code;
136 int filled = 0;
137 int orig_height;
138
139 if (refdata) {
140 /* copy prev frame */
141 for (i = 0; i < height; i++)
142 memcpy(dst + (i * stride), refdata + (i * stride), width);
143 } else {
144 refdata = dst;
145 }
146
147 orig_height = height;
148 height--;
149 dst = dst + height * stride;
150
151 while ((bytestream2_get_bytes_left(&qctx->buffer) > 0) && (height >= 0)) {
152 code = bytestream2_get_byte(&qctx->buffer);
153
154 if(delta) {
155 /* motion compensation */
156 while(bytestream2_get_bytes_left(&qctx->buffer) > 0 && (code & 0xF0) == 0xF0) {
157 if(delta == 1) {
158 int me_idx;
159 int me_w, me_h, me_x, me_y;
160 uint8_t *me_plane;
161 int corr, val;
162
163 /* get block size by index */
164 me_idx = code & 0xF;
165 me_w = qpeg_table_w[me_idx];
166 me_h = qpeg_table_h[me_idx];
167
168 /* extract motion vector */
169 corr = bytestream2_get_byte(&qctx->buffer);
170
171 val = corr >> 4;
172 if(val > 7)
173 val -= 16;
174 me_x = val;
175
176 val = corr & 0xF;
177 if(val > 7)
178 val -= 16;
179 me_y = val;
180
181 /* check motion vector */
182 if ((me_x + filled < 0) || (me_x + me_w + filled > width) ||
183 (height - me_y - me_h < 0) || (height - me_y >= orig_height) ||
184 (filled + me_w > width) || (height - me_h < 0))
185 av_log(qctx->avctx, AV_LOG_ERROR, "Bogus motion vector (%i,%i), block size %ix%i at %i,%i\n",
186 me_x, me_y, me_w, me_h, filled, height);
187 else {
188 /* do motion compensation */
189 me_plane = refdata + (filled + me_x) + (height - me_y) * stride;
190 for(j = 0; j < me_h; j++) {
191 for(i = 0; i < me_w; i++)
192 dst[filled + i - (j * stride)] = me_plane[i - (j * stride)];
193 }
194 }
195 }
196 code = bytestream2_get_byte(&qctx->buffer);
197 }
198 }
199
200 if(code == 0xE0) /* end-of-picture code */
201 break;
202 if(code > 0xE0) { /* run code: 0xE1..0xFF */
203 int p;
204
205 code &= 0x1F;
206 p = bytestream2_get_byte(&qctx->buffer);
207 for(i = 0; i <= code; i++) {
208 dst[filled++] = p;
209 if(filled >= width) {
210 filled = 0;
211 dst -= stride;
212 height--;
213 if (height < 0)
214 break;
215 }
216 }
217 } else if(code >= 0xC0) { /* copy code: 0xC0..0xDF */
218 code &= 0x1F;
219
220 if(code + 1 > bytestream2_get_bytes_left(&qctx->buffer))
221 break;
222
223 for(i = 0; i <= code; i++) {
224 dst[filled++] = bytestream2_get_byte(&qctx->buffer);
225 if(filled >= width) {
226 filled = 0;
227 dst -= stride;
228 height--;
229 if (height < 0)
230 break;
231 }
232 }
233 } else if(code >= 0x80) { /* skip code: 0x80..0xBF */
234 int skip;
235
236 code &= 0x3F;
237 /* codes 0x80 and 0x81 are actually escape codes,
238 skip value minus constant is in the next byte */
239 if(!code)
240 skip = bytestream2_get_byte(&qctx->buffer) + 64;
241 else if(code == 1)
242 skip = bytestream2_get_byte(&qctx->buffer) + 320;
243 else
244 skip = code;
245 filled += skip;
246 while( filled >= width) {
247 filled -= width;
248 dst -= stride;
249 height--;
250 if(height < 0)
251 break;
252 }
253 } else {
254 /* zero code treated as one-pixel skip */
255 if(code) {
256 dst[filled++] = ctable[code & 0x7F];
257 }
258 else
259 filled++;
260 if(filled >= width) {
261 filled = 0;
262 dst -= stride;
263 height--;
264 }
265 }
266 }
267 }
268
decode_frame(AVCodecContext * avctx,AVFrame * p,int * got_frame,AVPacket * avpkt)269 static int decode_frame(AVCodecContext *avctx, AVFrame *p,
270 int *got_frame, AVPacket *avpkt)
271 {
272 uint8_t ctable[128];
273 QpegContext * const a = avctx->priv_data;
274 AVFrame * const ref = a->ref;
275 uint8_t* outdata;
276 int delta, intra, ret;
277
278 if (avpkt->size < 0x86) {
279 av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");
280 return AVERROR_INVALIDDATA;
281 }
282
283 bytestream2_init(&a->buffer, avpkt->data, avpkt->size);
284
285 if ((ret = ff_get_buffer(avctx, p, AV_GET_BUFFER_FLAG_REF)) < 0)
286 return ret;
287 outdata = p->data[0];
288 bytestream2_skip(&a->buffer, 4);
289 bytestream2_get_buffer(&a->buffer, ctable, 128);
290 bytestream2_skip(&a->buffer, 1);
291
292 delta = bytestream2_get_byte(&a->buffer);
293 intra = delta == 0x10;
294 if (intra) {
295 qpeg_decode_intra(a, outdata, p->linesize[0], avctx->width, avctx->height);
296 } else {
297 qpeg_decode_inter(a, outdata, p->linesize[0], avctx->width, avctx->height, delta, ctable, ref->data[0]);
298 }
299
300 /* make the palette available on the way out */
301 p->palette_has_changed = ff_copy_palette(a->pal, avpkt, avctx);
302 memcpy(p->data[1], a->pal, AVPALETTE_SIZE);
303
304 av_frame_unref(ref);
305 if ((ret = av_frame_ref(ref, p)) < 0)
306 return ret;
307
308 p->key_frame = intra;
309 p->pict_type = intra ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
310
311 *got_frame = 1;
312
313 return avpkt->size;
314 }
315
decode_flush(AVCodecContext * avctx)316 static void decode_flush(AVCodecContext *avctx){
317 QpegContext * const a = avctx->priv_data;
318 int i, pal_size;
319 const uint8_t *pal_src;
320
321 av_frame_unref(a->ref);
322
323 pal_size = FFMIN(1024U, avctx->extradata_size);
324 pal_src = avctx->extradata + avctx->extradata_size - pal_size;
325
326 for (i=0; i<pal_size/4; i++)
327 a->pal[i] = 0xFFU<<24 | AV_RL32(pal_src+4*i);
328 }
329
decode_end(AVCodecContext * avctx)330 static av_cold int decode_end(AVCodecContext *avctx)
331 {
332 QpegContext * const a = avctx->priv_data;
333
334 av_frame_free(&a->ref);
335
336 return 0;
337 }
338
decode_init(AVCodecContext * avctx)339 static av_cold int decode_init(AVCodecContext *avctx){
340 QpegContext * const a = avctx->priv_data;
341
342 a->avctx = avctx;
343 avctx->pix_fmt= AV_PIX_FMT_PAL8;
344
345 a->ref = av_frame_alloc();
346 if (!a->ref)
347 return AVERROR(ENOMEM);
348
349 decode_flush(avctx);
350
351 return 0;
352 }
353
354 const FFCodec ff_qpeg_decoder = {
355 .p.name = "qpeg",
356 .p.long_name = NULL_IF_CONFIG_SMALL("Q-team QPEG"),
357 .p.type = AVMEDIA_TYPE_VIDEO,
358 .p.id = AV_CODEC_ID_QPEG,
359 .priv_data_size = sizeof(QpegContext),
360 .init = decode_init,
361 .close = decode_end,
362 FF_CODEC_DECODE_CB(decode_frame),
363 .flush = decode_flush,
364 .p.capabilities = AV_CODEC_CAP_DR1,
365 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
366 FF_CODEC_CAP_INIT_CLEANUP,
367 };
368