Directory: | ../../../ffmpeg/ |
---|---|
File: | src/libavcodec/rpza.c |
Date: | 2022-07-06 18:02:43 |
Exec | Total | Coverage | |
---|---|---|---|
Lines: | 93 | 121 | 76.9% |
Branches: | 39 | 68 | 57.4% |
Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * Quicktime Video (RPZA) Video Decoder | ||
3 | * Copyright (C) 2003 The FFmpeg project | ||
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 | * QT RPZA Video Decoder by Roberto Togni | ||
25 | * For more information about the RPZA format, visit: | ||
26 | * http://www.pcisys.net/~melanson/codecs/ | ||
27 | * | ||
28 | * The RPZA decoder outputs RGB555 colorspace data. | ||
29 | * | ||
30 | * Note that this decoder reads big endian RGB555 pixel values from the | ||
31 | * bytestream, arranges them in the host's endian order, and outputs | ||
32 | * them to the final rendered map in the same host endian order. This is | ||
33 | * intended behavior as the libavcodec documentation states that RGB555 | ||
34 | * pixels shall be stored in native CPU endianness. | ||
35 | */ | ||
36 | |||
37 | #include <stdint.h> | ||
38 | #include <stdio.h> | ||
39 | #include <stdlib.h> | ||
40 | #include <string.h> | ||
41 | |||
42 | #include "libavutil/internal.h" | ||
43 | #include "avcodec.h" | ||
44 | #include "bytestream.h" | ||
45 | #include "codec_internal.h" | ||
46 | #include "internal.h" | ||
47 | |||
48 | typedef struct RpzaContext { | ||
49 | |||
50 | AVCodecContext *avctx; | ||
51 | AVFrame *frame; | ||
52 | |||
53 | GetByteContext gb; | ||
54 | } RpzaContext; | ||
55 | |||
56 | #define CHECK_BLOCK() \ | ||
57 | if (total_blocks < 1) { \ | ||
58 | av_log(s->avctx, AV_LOG_ERROR, \ | ||
59 | "Block counter just went negative (this should not happen)\n"); \ | ||
60 | return AVERROR_INVALIDDATA; \ | ||
61 | } \ | ||
62 | |||
63 | #define ADVANCE_BLOCK() \ | ||
64 | { \ | ||
65 | pixel_ptr += 4; \ | ||
66 | if (pixel_ptr >= width) \ | ||
67 | { \ | ||
68 | pixel_ptr = 0; \ | ||
69 | row_ptr += stride * 4; \ | ||
70 | } \ | ||
71 | total_blocks--; \ | ||
72 | } | ||
73 | |||
74 | 31 | static int rpza_decode_stream(RpzaContext *s) | |
75 | { | ||
76 | 31 | int width = s->avctx->width; | |
77 | int stride, row_inc, ret; | ||
78 | int chunk_size; | ||
79 | 31 | uint16_t colorA = 0, colorB; | |
80 | uint16_t color4[4]; | ||
81 | uint16_t ta, tb; | ||
82 | uint16_t *pixels; | ||
83 | |||
84 | 31 | int row_ptr = 0; | |
85 | 31 | int pixel_ptr = 0; | |
86 | int block_ptr; | ||
87 | int pixel_x, pixel_y; | ||
88 | int total_blocks; | ||
89 | |||
90 | /* First byte is always 0xe1. Warn if it's different */ | ||
91 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 31 times.
|
31 | if (bytestream2_peek_byte(&s->gb) != 0xe1) |
92 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "First chunk byte is 0x%02x instead of 0xe1\n", | |
93 | bytestream2_peek_byte(&s->gb)); | ||
94 | |||
95 | /* Get chunk size, ignoring first byte */ | ||
96 | 31 | chunk_size = bytestream2_get_be32(&s->gb) & 0x00FFFFFF; | |
97 | |||
98 | /* If length mismatch use size from MOV file and try to decode anyway */ | ||
99 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 31 times.
|
31 | if (chunk_size != bytestream2_get_bytes_left(&s->gb) + 4) |
100 | ✗ | av_log(s->avctx, AV_LOG_WARNING, | |
101 | "MOV chunk size %d != encoded chunk size %d\n", | ||
102 | chunk_size, | ||
103 | ✗ | bytestream2_get_bytes_left(&s->gb) + 4 | |
104 | ); | ||
105 | |||
106 | /* Number of 4x4 blocks in frame. */ | ||
107 | 31 | total_blocks = ((s->avctx->width + 3) / 4) * ((s->avctx->height + 3) / 4); | |
108 | |||
109 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 31 times.
|
31 | if (total_blocks / 32 > bytestream2_get_bytes_left(&s->gb)) |
110 | ✗ | return AVERROR_INVALIDDATA; | |
111 | |||
112 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 31 times.
|
31 | if ((ret = ff_reget_buffer(s->avctx, s->frame, 0)) < 0) |
113 | ✗ | return ret; | |
114 | 31 | pixels = (uint16_t *)s->frame->data[0]; | |
115 | 31 | stride = s->frame->linesize[0] / 2; | |
116 | 31 | row_inc = stride - 4; | |
117 | |||
118 | /* Process chunk data */ | ||
119 |
2/2✓ Branch 1 taken 60173 times.
✓ Branch 2 taken 31 times.
|
60204 | while (bytestream2_get_bytes_left(&s->gb)) { |
120 | 60173 | uint8_t opcode = bytestream2_get_byte(&s->gb); /* Get opcode */ | |
121 | |||
122 | 60173 | int n_blocks = (opcode & 0x1f) + 1; /* Extract block counter from opcode */ | |
123 | |||
124 | /* If opcode MSbit is 0, we need more data to decide what to do */ | ||
125 |
2/2✓ Branch 0 taken 48161 times.
✓ Branch 1 taken 12012 times.
|
60173 | if ((opcode & 0x80) == 0) { |
126 | 48161 | colorA = (opcode << 8) | bytestream2_get_byte(&s->gb); | |
127 | 48161 | opcode = 0; | |
128 |
1/2✓ Branch 1 taken 48161 times.
✗ Branch 2 not taken.
|
48161 | if ((bytestream2_peek_byte(&s->gb) & 0x80) != 0) { |
129 | /* Must behave as opcode 110xxxxx, using colorA computed | ||
130 | * above. Use fake opcode 0x20 to enter switch block at | ||
131 | * the right place */ | ||
132 | 48161 | opcode = 0x20; | |
133 | 48161 | n_blocks = 1; | |
134 | } | ||
135 | } | ||
136 | |||
137 | 60173 | n_blocks = FFMIN(n_blocks, total_blocks); | |
138 | |||
139 |
3/6✓ Branch 0 taken 10393 times.
✓ Branch 1 taken 1619 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 48161 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
60173 | switch (opcode & 0xe0) { |
140 | |||
141 | /* Skip blocks */ | ||
142 | 10393 | case 0x80: | |
143 |
2/2✓ Branch 0 taken 98305 times.
✓ Branch 1 taken 10393 times.
|
108698 | while (n_blocks--) { |
144 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 98305 times.
|
98305 | CHECK_BLOCK(); |
145 |
2/2✓ Branch 0 taken 1632 times.
✓ Branch 1 taken 96673 times.
|
98305 | ADVANCE_BLOCK(); |
146 | } | ||
147 | 10393 | break; | |
148 | |||
149 | /* Fill blocks with one color */ | ||
150 | 1619 | case 0xa0: | |
151 | 1619 | colorA = bytestream2_get_be16(&s->gb); | |
152 |
2/2✓ Branch 0 taken 2334 times.
✓ Branch 1 taken 1619 times.
|
3953 | while (n_blocks--) { |
153 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2334 times.
|
2334 | CHECK_BLOCK(); |
154 | 2334 | block_ptr = row_ptr + pixel_ptr; | |
155 |
2/2✓ Branch 0 taken 9336 times.
✓ Branch 1 taken 2334 times.
|
11670 | for (pixel_y = 0; pixel_y < 4; pixel_y++) { |
156 |
2/2✓ Branch 0 taken 37344 times.
✓ Branch 1 taken 9336 times.
|
46680 | for (pixel_x = 0; pixel_x < 4; pixel_x++){ |
157 | 37344 | pixels[block_ptr] = colorA; | |
158 | 37344 | block_ptr++; | |
159 | } | ||
160 | 9336 | block_ptr += row_inc; | |
161 | } | ||
162 |
2/2✓ Branch 0 taken 85 times.
✓ Branch 1 taken 2249 times.
|
2334 | ADVANCE_BLOCK(); |
163 | } | ||
164 | 1619 | break; | |
165 | |||
166 | /* Fill blocks with 4 colors */ | ||
167 | ✗ | case 0xc0: | |
168 | ✗ | colorA = bytestream2_get_be16(&s->gb); | |
169 | 48161 | case 0x20: | |
170 | 48161 | colorB = bytestream2_get_be16(&s->gb); | |
171 | |||
172 | /* sort out the colors */ | ||
173 | 48161 | color4[0] = colorB; | |
174 | 48161 | color4[1] = 0; | |
175 | 48161 | color4[2] = 0; | |
176 | 48161 | color4[3] = colorA; | |
177 | |||
178 | /* red components */ | ||
179 | 48161 | ta = (colorA >> 10) & 0x1F; | |
180 | 48161 | tb = (colorB >> 10) & 0x1F; | |
181 | 48161 | color4[1] |= ((11 * ta + 21 * tb) >> 5) << 10; | |
182 | 48161 | color4[2] |= ((21 * ta + 11 * tb) >> 5) << 10; | |
183 | |||
184 | /* green components */ | ||
185 | 48161 | ta = (colorA >> 5) & 0x1F; | |
186 | 48161 | tb = (colorB >> 5) & 0x1F; | |
187 | 48161 | color4[1] |= ((11 * ta + 21 * tb) >> 5) << 5; | |
188 | 48161 | color4[2] |= ((21 * ta + 11 * tb) >> 5) << 5; | |
189 | |||
190 | /* blue components */ | ||
191 | 48161 | ta = colorA & 0x1F; | |
192 | 48161 | tb = colorB & 0x1F; | |
193 | 48161 | color4[1] |= ((11 * ta + 21 * tb) >> 5); | |
194 | 48161 | color4[2] |= ((21 * ta + 11 * tb) >> 5); | |
195 | |||
196 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 48161 times.
|
48161 | if (bytestream2_get_bytes_left(&s->gb) < n_blocks * 4) |
197 | ✗ | return AVERROR_INVALIDDATA; | |
198 |
2/2✓ Branch 0 taken 48161 times.
✓ Branch 1 taken 48161 times.
|
96322 | while (n_blocks--) { |
199 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 48161 times.
|
48161 | CHECK_BLOCK(); |
200 | 48161 | block_ptr = row_ptr + pixel_ptr; | |
201 |
2/2✓ Branch 0 taken 192644 times.
✓ Branch 1 taken 48161 times.
|
240805 | for (pixel_y = 0; pixel_y < 4; pixel_y++) { |
202 | 192644 | uint8_t index = bytestream2_get_byteu(&s->gb); | |
203 |
2/2✓ Branch 0 taken 770576 times.
✓ Branch 1 taken 192644 times.
|
963220 | for (pixel_x = 0; pixel_x < 4; pixel_x++){ |
204 | 770576 | uint8_t idx = (index >> (2 * (3 - pixel_x))) & 0x03; | |
205 | 770576 | pixels[block_ptr] = color4[idx]; | |
206 | 770576 | block_ptr++; | |
207 | } | ||
208 | 192644 | block_ptr += row_inc; | |
209 | } | ||
210 |
2/2✓ Branch 0 taken 143 times.
✓ Branch 1 taken 48018 times.
|
48161 | ADVANCE_BLOCK(); |
211 | } | ||
212 | 48161 | break; | |
213 | |||
214 | /* Fill block with 16 colors */ | ||
215 | ✗ | case 0x00: | |
216 | ✗ | if (bytestream2_get_bytes_left(&s->gb) < 30) | |
217 | ✗ | return AVERROR_INVALIDDATA; | |
218 | ✗ | CHECK_BLOCK(); | |
219 | ✗ | block_ptr = row_ptr + pixel_ptr; | |
220 | ✗ | for (pixel_y = 0; pixel_y < 4; pixel_y++) { | |
221 | ✗ | for (pixel_x = 0; pixel_x < 4; pixel_x++){ | |
222 | /* We already have color of upper left pixel */ | ||
223 | ✗ | if ((pixel_y != 0) || (pixel_x != 0)) | |
224 | ✗ | colorA = bytestream2_get_be16u(&s->gb); | |
225 | ✗ | pixels[block_ptr] = colorA; | |
226 | ✗ | block_ptr++; | |
227 | } | ||
228 | ✗ | block_ptr += row_inc; | |
229 | } | ||
230 | ✗ | ADVANCE_BLOCK(); | |
231 | ✗ | break; | |
232 | |||
233 | /* Unknown opcode */ | ||
234 | ✗ | default: | |
235 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "Unknown opcode %d in rpza chunk." | |
236 | " Skip remaining %d bytes of chunk data.\n", opcode, | ||
237 | bytestream2_get_bytes_left(&s->gb)); | ||
238 | ✗ | return AVERROR_INVALIDDATA; | |
239 | } /* Opcode switch */ | ||
240 | } | ||
241 | |||
242 | 31 | return 0; | |
243 | } | ||
244 | |||
245 | 2 | static av_cold int rpza_decode_init(AVCodecContext *avctx) | |
246 | { | ||
247 | 2 | RpzaContext *s = avctx->priv_data; | |
248 | |||
249 | 2 | s->avctx = avctx; | |
250 | 2 | avctx->pix_fmt = AV_PIX_FMT_RGB555; | |
251 | |||
252 | 2 | s->frame = av_frame_alloc(); | |
253 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (!s->frame) |
254 | ✗ | return AVERROR(ENOMEM); | |
255 | |||
256 | 2 | return 0; | |
257 | } | ||
258 | |||
259 | 31 | static int rpza_decode_frame(AVCodecContext *avctx, AVFrame *rframe, | |
260 | int *got_frame, AVPacket *avpkt) | ||
261 | { | ||
262 | 31 | RpzaContext *s = avctx->priv_data; | |
263 | int ret; | ||
264 | |||
265 | 31 | bytestream2_init(&s->gb, avpkt->data, avpkt->size); | |
266 | |||
267 | 31 | ret = rpza_decode_stream(s); | |
268 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 31 times.
|
31 | if (ret < 0) |
269 | ✗ | return ret; | |
270 | |||
271 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 31 times.
|
31 | if ((ret = av_frame_ref(rframe, s->frame)) < 0) |
272 | ✗ | return ret; | |
273 | |||
274 | 31 | *got_frame = 1; | |
275 | |||
276 | /* always report that the buffer was completely consumed */ | ||
277 | 31 | return avpkt->size; | |
278 | } | ||
279 | |||
280 | 2 | static av_cold int rpza_decode_end(AVCodecContext *avctx) | |
281 | { | ||
282 | 2 | RpzaContext *s = avctx->priv_data; | |
283 | |||
284 | 2 | av_frame_free(&s->frame); | |
285 | |||
286 | 2 | return 0; | |
287 | } | ||
288 | |||
289 | const FFCodec ff_rpza_decoder = { | ||
290 | .p.name = "rpza", | ||
291 | .p.long_name = NULL_IF_CONFIG_SMALL("QuickTime video (RPZA)"), | ||
292 | .p.type = AVMEDIA_TYPE_VIDEO, | ||
293 | .p.id = AV_CODEC_ID_RPZA, | ||
294 | .priv_data_size = sizeof(RpzaContext), | ||
295 | .init = rpza_decode_init, | ||
296 | .close = rpza_decode_end, | ||
297 | FF_CODEC_DECODE_CB(rpza_decode_frame), | ||
298 | .p.capabilities = AV_CODEC_CAP_DR1, | ||
299 | .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE, | ||
300 | }; | ||
301 |