avcodec/qdrw: Fix the code which asks for version 1 samples
[ffmpeg.git] / libavcodec / qdrw.c
1 /*
2  * QuickDraw (qdrw) codec
3  * Copyright (c) 2004 Konstantin Shishkov
4  * Copyright (c) 2015 Vittorio Giovara
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 /**
24  * @file
25  * Apple QuickDraw codec.
26  * https://developer.apple.com/legacy/library/documentation/mac/QuickDraw/QuickDraw-461.html
27  */
28
29 #include "libavutil/common.h"
30 #include "libavutil/intreadwrite.h"
31 #include "avcodec.h"
32 #include "bytestream.h"
33 #include "internal.h"
34
35 enum QuickdrawOpcodes {
36     PACKBITSRECT = 0x0098,
37     PACKBITSRGN,
38     DIRECTBITSRECT,
39     DIRECTBITSRGN,
40
41     EOP = 0x00FF,
42 };
43
44 static int parse_palette(AVCodecContext *avctx, GetByteContext *gbc,
45                          uint32_t *pal, int colors)
46 {
47     int i;
48
49     for (i = 0; i <= colors; i++) {
50         uint8_t r, g, b;
51         unsigned int idx = bytestream2_get_be16(gbc); /* color index */
52         if (idx > 255) {
53             av_log(avctx, AV_LOG_WARNING,
54                    "Palette index out of range: %u\n", idx);
55             bytestream2_skip(gbc, 6);
56             continue;
57         }
58         r = bytestream2_get_byte(gbc);
59         bytestream2_skip(gbc, 1);
60         g = bytestream2_get_byte(gbc);
61         bytestream2_skip(gbc, 1);
62         b = bytestream2_get_byte(gbc);
63         bytestream2_skip(gbc, 1);
64         pal[idx] = (0xFFU << 24) | (r << 16) | (g << 8) | b;
65     }
66     return 0;
67 }
68
69 static int decode_rle(AVCodecContext *avctx, AVFrame *p, GetByteContext *gbc,
70                       int step)
71 {
72     int i, j;
73     int offset = avctx->width * step;
74     uint8_t *outdata = p->data[0];
75
76     for (i = 0; i < avctx->height; i++) {
77         int size, left, code, pix;
78         uint8_t *out = outdata;
79         int pos = 0;
80
81         /* size of packed line */
82         size = left = bytestream2_get_be16(gbc);
83         if (bytestream2_get_bytes_left(gbc) < size)
84             return AVERROR_INVALIDDATA;
85
86         /* decode line */
87         while (left > 0) {
88             code = bytestream2_get_byte(gbc);
89             if (code & 0x80 ) { /* run */
90                 pix = bytestream2_get_byte(gbc);
91                 for (j = 0; j < 257 - code; j++) {
92                     out[pos] = pix;
93                     pos += step;
94                     if (pos >= offset) {
95                         pos -= offset;
96                         pos++;
97                     }
98                 }
99                 left  -= 2;
100             } else { /* copy */
101                 for (j = 0; j < code + 1; j++) {
102                     out[pos] = bytestream2_get_byte(gbc);
103                     pos += step;
104                     if (pos >= offset) {
105                         pos -= offset;
106                         pos++;
107                     }
108                 }
109                 left  -= 2 + code;
110             }
111         }
112         outdata += p->linesize[0];
113     }
114     return 0;
115 }
116
117 static int check_header(const char *buf, int buf_size)
118 {
119     unsigned w, h, v0, v1;
120
121     if (buf_size < 40)
122         return 0;
123
124     w = AV_RB16(buf+6);
125     h = AV_RB16(buf+8);
126     v0 = AV_RB16(buf+10);
127     v1 = AV_RB16(buf+12);
128
129     if (!w || !h)
130         return 0;
131
132     if (v0 == 0x1101)
133         return 1;
134     if (v0 == 0x0011 && v1 == 0x02FF)
135         return 2;
136     return 0;
137 }
138
139
140 static int decode_frame(AVCodecContext *avctx,
141                         void *data, int *got_frame,
142                         AVPacket *avpkt)
143 {
144     AVFrame * const p      = data;
145     GetByteContext gbc;
146     int colors;
147     int w, h, ret;
148     int ver;
149
150     bytestream2_init(&gbc, avpkt->data, avpkt->size);
151     if (   bytestream2_get_bytes_left(&gbc) >= 552
152            && !check_header(gbc.buffer      , bytestream2_get_bytes_left(&gbc))
153            &&  check_header(gbc.buffer + 512, bytestream2_get_bytes_left(&gbc) - 512)
154        )
155         bytestream2_skip(&gbc, 512);
156
157     ver = check_header(gbc.buffer, bytestream2_get_bytes_left(&gbc));
158
159     /* smallest PICT header */
160     if (bytestream2_get_bytes_left(&gbc) < 40) {
161         av_log(avctx, AV_LOG_ERROR, "Frame is too small %d\n",
162                bytestream2_get_bytes_left(&gbc));
163         return AVERROR_INVALIDDATA;
164     }
165
166     bytestream2_skip(&gbc, 6);
167     h = bytestream2_get_be16(&gbc);
168     w = bytestream2_get_be16(&gbc);
169
170     ret = ff_set_dimensions(avctx, w, h);
171     if (ret < 0)
172         return ret;
173
174     /* version 1 is identified by 0x1101
175      * it uses byte-aligned opcodes rather than word-aligned */
176     if (ver == 1) {
177         avpriv_request_sample(avctx, "QuickDraw version 1");
178         return AVERROR_PATCHWELCOME;
179     } else if (ver != 2) {
180         avpriv_request_sample(avctx, "QuickDraw version unknown (%X)", bytestream2_get_be32(&gbc));
181         return AVERROR_PATCHWELCOME;
182     }
183
184     bytestream2_skip(&gbc, 4+26);
185
186     while (bytestream2_get_bytes_left(&gbc) >= 4) {
187         int bppcnt, bpp;
188         int rowbytes, pack_type;
189         int opcode = bytestream2_get_be16(&gbc);
190
191         switch(opcode) {
192         case PACKBITSRECT:
193         case PACKBITSRGN:
194             av_log(avctx, AV_LOG_DEBUG, "Parsing Packbit opcode\n");
195
196             bytestream2_skip(&gbc, 30);
197             bppcnt = bytestream2_get_be16(&gbc); /* cmpCount */
198             bpp    = bytestream2_get_be16(&gbc); /* cmpSize */
199
200             av_log(avctx, AV_LOG_DEBUG, "bppcount %d bpp %d\n", bppcnt, bpp);
201             if (bppcnt == 1 && bpp == 8) {
202                 avctx->pix_fmt = AV_PIX_FMT_PAL8;
203             } else {
204                 av_log(avctx, AV_LOG_ERROR,
205                        "Invalid pixel format (bppcnt %d bpp %d) in Packbit\n",
206                        bppcnt, bpp);
207                 return AVERROR_INVALIDDATA;
208             }
209
210             /* jump to palette */
211             bytestream2_skip(&gbc, 18);
212             colors = bytestream2_get_be16(&gbc);
213
214             if (colors < 0 || colors > 256) {
215                 av_log(avctx, AV_LOG_ERROR,
216                        "Error color count - %i(0x%X)\n", colors, colors);
217                 return AVERROR_INVALIDDATA;
218             }
219             if (bytestream2_get_bytes_left(&gbc) < (colors + 1) * 8) {
220                 av_log(avctx, AV_LOG_ERROR, "Palette is too small %d\n",
221                        bytestream2_get_bytes_left(&gbc));
222                 return AVERROR_INVALIDDATA;
223             }
224             if ((ret = ff_get_buffer(avctx, p, 0)) < 0)
225                 return ret;
226
227             parse_palette(avctx, &gbc, (uint32_t *)p->data[1], colors);
228             p->palette_has_changed = 1;
229
230             /* jump to image data */
231             bytestream2_skip(&gbc, 18);
232
233             if (opcode == PACKBITSRGN) {
234                 bytestream2_skip(&gbc, 2 + 8); /* size + rect */
235                 avpriv_report_missing_feature(avctx, "Packbit mask region");
236             }
237
238             ret = decode_rle(avctx, p, &gbc, bppcnt);
239             if (ret < 0)
240                 return ret;
241             *got_frame = 1;
242             break;
243         case DIRECTBITSRECT:
244         case DIRECTBITSRGN:
245             av_log(avctx, AV_LOG_DEBUG, "Parsing Directbit opcode\n");
246
247             bytestream2_skip(&gbc, 4);
248             rowbytes = bytestream2_get_be16(&gbc) & 0x3FFF;
249             if (rowbytes <= 250) {
250                 avpriv_report_missing_feature(avctx, "Short rowbytes");
251                 return AVERROR_PATCHWELCOME;
252             }
253
254             bytestream2_skip(&gbc, 10);
255             pack_type = bytestream2_get_be16(&gbc);
256
257             bytestream2_skip(&gbc, 16);
258             bppcnt = bytestream2_get_be16(&gbc); /* cmpCount */
259             bpp    = bytestream2_get_be16(&gbc); /* cmpSize */
260
261             av_log(avctx, AV_LOG_DEBUG, "bppcount %d bpp %d\n", bppcnt, bpp);
262             if (bppcnt == 3 && bpp == 8) {
263                 avctx->pix_fmt = AV_PIX_FMT_RGB24;
264             } else if (bppcnt == 4 && bpp == 8) {
265                 avctx->pix_fmt = AV_PIX_FMT_ARGB;
266             } else {
267                 av_log(avctx, AV_LOG_ERROR,
268                        "Invalid pixel format (bppcnt %d bpp %d) in Directbit\n",
269                        bppcnt, bpp);
270                 return AVERROR_INVALIDDATA;
271             }
272
273             /* set packing when default is selected */
274             if (pack_type == 0)
275                 pack_type = bppcnt;
276
277             if (pack_type != 3 && pack_type != 4) {
278                 avpriv_request_sample(avctx, "Pack type %d", pack_type);
279                 return AVERROR_PATCHWELCOME;
280             }
281             if ((ret = ff_get_buffer(avctx, p, 0)) < 0) {
282                 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
283                 return ret;
284             }
285
286             /* jump to data */
287             bytestream2_skip(&gbc, 30);
288
289             if (opcode == DIRECTBITSRGN) {
290                 bytestream2_skip(&gbc, 2 + 8); /* size + rect */
291                 avpriv_report_missing_feature(avctx, "DirectBit mask region");
292             }
293
294             ret = decode_rle(avctx, p, &gbc, bppcnt);
295             if (ret < 0)
296                 return ret;
297             *got_frame = 1;
298             break;
299         default:
300             av_log(avctx, AV_LOG_TRACE, "Unknown 0x%04X opcode\n", opcode);
301             break;
302         }
303         /* exit the loop when a known pixel block has been found */
304         if (*got_frame) {
305             int eop, trail;
306
307             /* re-align to a word */
308             bytestream2_skip(&gbc, bytestream2_get_bytes_left(&gbc) % 2);
309
310             eop = bytestream2_get_be16(&gbc);
311             trail = bytestream2_get_bytes_left(&gbc);
312             if (eop != EOP)
313                 av_log(avctx, AV_LOG_WARNING,
314                        "Missing end of picture opcode (found 0x%04X)\n", eop);
315             if (trail)
316                 av_log(avctx, AV_LOG_WARNING, "Got %d trailing bytes\n", trail);
317             break;
318         }
319     }
320
321     if (*got_frame) {
322         p->pict_type = AV_PICTURE_TYPE_I;
323         p->key_frame = 1;
324
325         return avpkt->size;
326     } else {
327         av_log(avctx, AV_LOG_ERROR, "Frame contained no usable data\n");
328
329         return AVERROR_INVALIDDATA;
330     }
331 }
332
333 AVCodec ff_qdraw_decoder = {
334     .name           = "qdraw",
335     .long_name      = NULL_IF_CONFIG_SMALL("Apple QuickDraw"),
336     .type           = AVMEDIA_TYPE_VIDEO,
337     .id             = AV_CODEC_ID_QDRAW,
338     .decode         = decode_frame,
339     .capabilities   = CODEC_CAP_DR1,
340 };