1 |
|
|
/* |
2 |
|
|
* Fraps FPS1 decoder |
3 |
|
|
* Copyright (c) 2005 Roine Gustafsson |
4 |
|
|
* Copyright (c) 2006 Konstantin Shishkov |
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 |
|
|
* Lossless Fraps 'FPS1' decoder |
26 |
|
|
* @author Roine Gustafsson (roine at users sf net) |
27 |
|
|
* @author Konstantin Shishkov |
28 |
|
|
* |
29 |
|
|
* Codec algorithm for version 0 is taken from Transcode <www.transcoding.org> |
30 |
|
|
* |
31 |
|
|
* Version 2 files support by Konstantin Shishkov |
32 |
|
|
*/ |
33 |
|
|
|
34 |
|
|
#include "config.h" |
35 |
|
|
|
36 |
|
|
#define CACHED_BITSTREAM_READER HAVE_FAST_64BIT |
37 |
|
|
#define UNCHECKED_BITSTREAM_READER 1 |
38 |
|
|
#include "avcodec.h" |
39 |
|
|
#include "get_bits.h" |
40 |
|
|
#include "huffman.h" |
41 |
|
|
#include "bytestream.h" |
42 |
|
|
#include "bswapdsp.h" |
43 |
|
|
#include "internal.h" |
44 |
|
|
#include "thread.h" |
45 |
|
|
|
46 |
|
|
#define FPS_TAG MKTAG('F', 'P', 'S', 'x') |
47 |
|
|
#define VLC_BITS 11 |
48 |
|
|
|
49 |
|
|
/** |
50 |
|
|
* local variable storage |
51 |
|
|
*/ |
52 |
|
|
typedef struct FrapsContext { |
53 |
|
|
AVCodecContext *avctx; |
54 |
|
|
BswapDSPContext bdsp; |
55 |
|
|
uint8_t *tmpbuf; |
56 |
|
|
int tmpbuf_size; |
57 |
|
|
} FrapsContext; |
58 |
|
|
|
59 |
|
|
|
60 |
|
|
/** |
61 |
|
|
* initializes decoder |
62 |
|
|
* @param avctx codec context |
63 |
|
|
* @return 0 on success or negative if fails |
64 |
|
|
*/ |
65 |
|
14 |
static av_cold int decode_init(AVCodecContext *avctx) |
66 |
|
|
{ |
67 |
|
14 |
FrapsContext * const s = avctx->priv_data; |
68 |
|
|
|
69 |
|
14 |
s->avctx = avctx; |
70 |
|
14 |
s->tmpbuf = NULL; |
71 |
|
|
|
72 |
|
14 |
ff_bswapdsp_init(&s->bdsp); |
73 |
|
|
|
74 |
|
14 |
return 0; |
75 |
|
|
} |
76 |
|
|
|
77 |
|
|
/** |
78 |
|
|
* Comparator - our nodes should ascend by count |
79 |
|
|
* but with preserved symbol order |
80 |
|
|
*/ |
81 |
|
924225 |
static int huff_cmp(const void *va, const void *vb) |
82 |
|
|
{ |
83 |
|
924225 |
const Node *a = va, *b = vb; |
84 |
|
924225 |
return (a->count - b->count)*256 + a->sym - b->sym; |
85 |
|
|
} |
86 |
|
|
|
87 |
|
|
/** |
88 |
|
|
* decode Fraps v2 packed plane |
89 |
|
|
*/ |
90 |
|
417 |
static int fraps2_decode_plane(FrapsContext *s, uint8_t *dst, int stride, int w, |
91 |
|
|
int h, const uint8_t *src, int size, int Uoff, |
92 |
|
|
const int step) |
93 |
|
|
{ |
94 |
|
|
int i, j, ret; |
95 |
|
|
GetBitContext gb; |
96 |
|
|
VLC vlc; |
97 |
|
|
Node nodes[512]; |
98 |
|
|
|
99 |
✓✓ |
107169 |
for (i = 0; i < 256; i++) |
100 |
|
106752 |
nodes[i].count = bytestream_get_le32(&src); |
101 |
|
417 |
size -= 1024; |
102 |
✗✓ |
417 |
if ((ret = ff_huff_build_tree(s->avctx, &vlc, 256, VLC_BITS, |
103 |
|
|
nodes, huff_cmp, |
104 |
|
|
FF_HUFFMAN_FLAG_ZERO_COUNT)) < 0) |
105 |
|
|
return ret; |
106 |
|
|
/* we have built Huffman table and are ready to decode plane */ |
107 |
|
|
|
108 |
|
|
/* convert bits so they may be used by standard bitreader */ |
109 |
|
417 |
s->bdsp.bswap_buf((uint32_t *) s->tmpbuf, |
110 |
|
|
(const uint32_t *) src, size >> 2); |
111 |
|
|
|
112 |
✗✓ |
417 |
if ((ret = init_get_bits8(&gb, s->tmpbuf, size)) < 0) |
113 |
|
|
return ret; |
114 |
|
|
|
115 |
✓✓ |
82607 |
for (j = 0; j < h; j++) { |
116 |
✓✓ |
29602124 |
for (i = 0; i < w*step; i += step) { |
117 |
|
29519934 |
dst[i] = get_vlc2(&gb, vlc.table, VLC_BITS, 3); |
118 |
|
|
/* lines are stored as deltas between previous lines |
119 |
|
|
* and we need to add 0x80 to the first lines of chroma planes |
120 |
|
|
*/ |
121 |
✓✓ |
29519934 |
if (j) |
122 |
|
29387582 |
dst[i] += dst[i - stride]; |
123 |
✓✓ |
132352 |
else if (Uoff) |
124 |
|
8192 |
dst[i] += 0x80; |
125 |
✓✓ |
29519934 |
if (get_bits_left(&gb) < 0) { |
126 |
|
2 |
ff_free_vlc(&vlc); |
127 |
|
2 |
return AVERROR_INVALIDDATA; |
128 |
|
|
} |
129 |
|
|
} |
130 |
|
82190 |
dst += stride; |
131 |
|
|
} |
132 |
|
415 |
ff_free_vlc(&vlc); |
133 |
|
415 |
return 0; |
134 |
|
|
} |
135 |
|
|
|
136 |
|
176 |
static int decode_frame(AVCodecContext *avctx, |
137 |
|
|
void *data, int *got_frame, |
138 |
|
|
AVPacket *avpkt) |
139 |
|
|
{ |
140 |
|
176 |
FrapsContext * const s = avctx->priv_data; |
141 |
|
176 |
const uint8_t *buf = avpkt->data; |
142 |
|
176 |
int buf_size = avpkt->size; |
143 |
|
176 |
ThreadFrame frame = { .f = data }; |
144 |
|
176 |
AVFrame * const f = data; |
145 |
|
|
uint32_t header; |
146 |
|
|
unsigned int version,header_size; |
147 |
|
|
unsigned int x, y; |
148 |
|
|
const uint32_t *buf32; |
149 |
|
|
uint32_t *luma1,*luma2,*cb,*cr; |
150 |
|
|
uint32_t offs[4]; |
151 |
|
|
int i, j, ret, is_chroma; |
152 |
|
176 |
const int planes = 3; |
153 |
|
|
int is_pal; |
154 |
|
|
uint8_t *out; |
155 |
|
|
|
156 |
✗✓ |
176 |
if (buf_size < 4) { |
157 |
|
|
av_log(avctx, AV_LOG_ERROR, "Packet is too short\n"); |
158 |
|
|
return AVERROR_INVALIDDATA; |
159 |
|
|
} |
160 |
|
|
|
161 |
|
176 |
header = AV_RL32(buf); |
162 |
|
176 |
version = header & 0xff; |
163 |
✗✓✗✗
|
176 |
is_pal = buf[1] == 2 && version == 1; |
164 |
✓✗ |
176 |
header_size = (header & (1<<30))? 8 : 4; /* bit 30 means pad to 8 bytes */ |
165 |
|
|
|
166 |
✗✓ |
176 |
if (version > 5) { |
167 |
|
|
avpriv_report_missing_feature(avctx, "Fraps version %u", version); |
168 |
|
|
return AVERROR_PATCHWELCOME; |
169 |
|
|
} |
170 |
|
|
|
171 |
|
176 |
buf += header_size; |
172 |
|
|
|
173 |
✗✓ |
176 |
if (is_pal) { |
174 |
|
|
unsigned needed_size = avctx->width * avctx->height + 1024; |
175 |
|
|
needed_size += header_size; |
176 |
|
|
if (buf_size != needed_size) { |
177 |
|
|
av_log(avctx, AV_LOG_ERROR, |
178 |
|
|
"Invalid frame length %d (should be %d)\n", |
179 |
|
|
buf_size, needed_size); |
180 |
|
|
return AVERROR_INVALIDDATA; |
181 |
|
|
} |
182 |
✓✓ |
176 |
} else if (version < 2) { |
183 |
|
24 |
unsigned needed_size = avctx->width * avctx->height * 3; |
184 |
✓✓ |
24 |
if (version == 0) needed_size /= 2; |
185 |
|
24 |
needed_size += header_size; |
186 |
|
|
/* bit 31 means same as previous pic */ |
187 |
✗✓ |
24 |
if (header & (1U<<31)) { |
188 |
|
|
*got_frame = 0; |
189 |
|
|
return buf_size; |
190 |
|
|
} |
191 |
✓✓ |
24 |
if (buf_size != needed_size) { |
192 |
|
1 |
av_log(avctx, AV_LOG_ERROR, |
193 |
|
|
"Invalid frame length %d (should be %d)\n", |
194 |
|
|
buf_size, needed_size); |
195 |
|
1 |
return AVERROR_INVALIDDATA; |
196 |
|
|
} |
197 |
|
|
} else { |
198 |
|
|
/* skip frame */ |
199 |
✓✓ |
152 |
if (buf_size == 8) { |
200 |
|
10 |
*got_frame = 0; |
201 |
|
10 |
return buf_size; |
202 |
|
|
} |
203 |
✓✗✗✓
|
142 |
if (AV_RL32(buf) != FPS_TAG || buf_size < planes*1024 + 24) { |
204 |
|
|
av_log(avctx, AV_LOG_ERROR, "error in data stream\n"); |
205 |
|
|
return AVERROR_INVALIDDATA; |
206 |
|
|
} |
207 |
✓✓ |
563 |
for (i = 0; i < planes; i++) { |
208 |
|
424 |
offs[i] = AV_RL32(buf + 4 + i * 4); |
209 |
✓✓✓✓ ✗✓ |
424 |
if (offs[i] >= buf_size - header_size || (i && offs[i] <= offs[i - 1] + 1024)) { |
210 |
|
3 |
av_log(avctx, AV_LOG_ERROR, "plane %i offset is out of bounds\n", i); |
211 |
|
3 |
return AVERROR_INVALIDDATA; |
212 |
|
|
} |
213 |
|
|
} |
214 |
|
139 |
offs[planes] = buf_size - header_size; |
215 |
✓✓ |
556 |
for (i = 0; i < planes; i++) { |
216 |
|
417 |
av_fast_padded_malloc(&s->tmpbuf, &s->tmpbuf_size, offs[i + 1] - offs[i] - 1024); |
217 |
✗✓ |
417 |
if (!s->tmpbuf) |
218 |
|
|
return AVERROR(ENOMEM); |
219 |
|
|
} |
220 |
|
|
} |
221 |
|
|
|
222 |
|
162 |
f->pict_type = AV_PICTURE_TYPE_I; |
223 |
|
162 |
f->key_frame = 1; |
224 |
|
|
|
225 |
✓✓✗✓
|
162 |
avctx->pix_fmt = version & 1 ? is_pal ? AV_PIX_FMT_PAL8 : AV_PIX_FMT_BGR24 : AV_PIX_FMT_YUVJ420P; |
226 |
|
324 |
avctx->color_range = version & 1 ? AVCOL_RANGE_UNSPECIFIED |
227 |
✓✓ |
162 |
: AVCOL_RANGE_JPEG; |
228 |
✓✓ |
162 |
avctx->colorspace = version & 1 ? AVCOL_SPC_UNSPECIFIED : AVCOL_SPC_BT709; |
229 |
|
|
|
230 |
✗✓ |
162 |
if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0) |
231 |
|
|
return ret; |
232 |
|
|
|
233 |
✓✓✓✓
|
162 |
switch (version) { |
234 |
|
21 |
case 0: |
235 |
|
|
default: |
236 |
|
|
/* Fraps v0 is a reordered YUV420 */ |
237 |
✓✗✗✓
|
21 |
if (((avctx->width % 8) != 0) || ((avctx->height % 2) != 0)) { |
238 |
|
|
av_log(avctx, AV_LOG_ERROR, "Invalid frame size %dx%d\n", |
239 |
|
|
avctx->width, avctx->height); |
240 |
|
|
return AVERROR_INVALIDDATA; |
241 |
|
|
} |
242 |
|
|
|
243 |
|
21 |
buf32 = (const uint32_t*)buf; |
244 |
✓✓ |
2289 |
for (y = 0; y < avctx->height / 2; y++) { |
245 |
|
2268 |
luma1 = (uint32_t*)&f->data[0][ y * 2 * f->linesize[0] ]; |
246 |
|
2268 |
luma2 = (uint32_t*)&f->data[0][ (y * 2 + 1) * f->linesize[0] ]; |
247 |
|
2268 |
cr = (uint32_t*)&f->data[1][ y * f->linesize[1] ]; |
248 |
|
2268 |
cb = (uint32_t*)&f->data[2][ y * f->linesize[2] ]; |
249 |
✓✓ |
90720 |
for (x = 0; x < avctx->width; x += 8) { |
250 |
|
88452 |
*luma1++ = *buf32++; |
251 |
|
88452 |
*luma1++ = *buf32++; |
252 |
|
88452 |
*luma2++ = *buf32++; |
253 |
|
88452 |
*luma2++ = *buf32++; |
254 |
|
88452 |
*cr++ = *buf32++; |
255 |
|
88452 |
*cb++ = *buf32++; |
256 |
|
|
} |
257 |
|
|
} |
258 |
|
21 |
break; |
259 |
|
|
|
260 |
|
2 |
case 1: |
261 |
✗✓ |
2 |
if (is_pal) { |
262 |
|
|
uint32_t *pal = (uint32_t *)f->data[1]; |
263 |
|
|
|
264 |
|
|
for (y = 0; y < 256; y++) { |
265 |
|
|
pal[y] = AV_RL32(buf) | 0xFF000000; |
266 |
|
|
buf += 4; |
267 |
|
|
} |
268 |
|
|
|
269 |
|
|
for (y = 0; y <avctx->height; y++) |
270 |
|
|
memcpy(&f->data[0][y * f->linesize[0]], |
271 |
|
|
&buf[y * avctx->width], |
272 |
|
|
avctx->width); |
273 |
|
|
} else { |
274 |
|
|
/* Fraps v1 is an upside-down BGR24 */ |
275 |
✓✓ |
482 |
for (y = 0; y<avctx->height; y++) |
276 |
|
480 |
memcpy(&f->data[0][(avctx->height - y - 1) * f->linesize[0]], |
277 |
|
480 |
&buf[y * avctx->width * 3], |
278 |
|
480 |
3 * avctx->width); |
279 |
|
|
} |
280 |
|
2 |
break; |
281 |
|
|
|
282 |
|
11 |
case 2: |
283 |
|
|
case 4: |
284 |
|
|
/** |
285 |
|
|
* Fraps v2 is Huffman-coded YUV420 planes |
286 |
|
|
* Fraps v4 is virtually the same |
287 |
|
|
*/ |
288 |
✓✓ |
44 |
for (i = 0; i < planes; i++) { |
289 |
|
33 |
is_chroma = !!i; |
290 |
✗✓ |
33 |
if ((ret = fraps2_decode_plane(s, f->data[i], f->linesize[i], |
291 |
|
33 |
avctx->width >> is_chroma, |
292 |
|
33 |
avctx->height >> is_chroma, |
293 |
|
33 |
buf + offs[i], offs[i + 1] - offs[i], |
294 |
|
|
is_chroma, 1)) < 0) { |
295 |
|
|
av_log(avctx, AV_LOG_ERROR, "Error decoding plane %i\n", i); |
296 |
|
|
return ret; |
297 |
|
|
} |
298 |
|
|
} |
299 |
|
11 |
break; |
300 |
|
128 |
case 3: |
301 |
|
|
case 5: |
302 |
|
|
/* Virtually the same as version 4, but is for RGB24 */ |
303 |
✓✓ |
510 |
for (i = 0; i < planes; i++) { |
304 |
✓✓ |
384 |
if ((ret = fraps2_decode_plane(s, f->data[0] + i + (f->linesize[0] * (avctx->height - 1)), |
305 |
|
384 |
-f->linesize[0], avctx->width, avctx->height, |
306 |
|
384 |
buf + offs[i], offs[i + 1] - offs[i], 0, 3)) < 0) { |
307 |
|
2 |
av_log(avctx, AV_LOG_ERROR, "Error decoding plane %i\n", i); |
308 |
|
2 |
return ret; |
309 |
|
|
} |
310 |
|
|
} |
311 |
|
126 |
out = f->data[0]; |
312 |
|
|
// convert pseudo-YUV into real RGB |
313 |
✓✓ |
23022 |
for (j = 0; j < avctx->height; j++) { |
314 |
|
22896 |
uint8_t *line_end = out + 3*avctx->width; |
315 |
✓✓ |
7305072 |
while (out < line_end) { |
316 |
|
7282176 |
out[0] += out[1]; |
317 |
|
7282176 |
out[2] += out[1]; |
318 |
|
7282176 |
out += 3; |
319 |
|
|
} |
320 |
|
22896 |
out += f->linesize[0] - 3*avctx->width; |
321 |
|
|
} |
322 |
|
126 |
break; |
323 |
|
|
} |
324 |
|
|
|
325 |
|
160 |
*got_frame = 1; |
326 |
|
|
|
327 |
|
160 |
return buf_size; |
328 |
|
|
} |
329 |
|
|
|
330 |
|
|
|
331 |
|
|
/** |
332 |
|
|
* closes decoder |
333 |
|
|
* @param avctx codec context |
334 |
|
|
* @return 0 on success or negative if fails |
335 |
|
|
*/ |
336 |
|
14 |
static av_cold int decode_end(AVCodecContext *avctx) |
337 |
|
|
{ |
338 |
|
14 |
FrapsContext *s = (FrapsContext*)avctx->priv_data; |
339 |
|
|
|
340 |
|
14 |
av_freep(&s->tmpbuf); |
341 |
|
14 |
return 0; |
342 |
|
|
} |
343 |
|
|
|
344 |
|
|
|
345 |
|
|
AVCodec ff_fraps_decoder = { |
346 |
|
|
.name = "fraps", |
347 |
|
|
.long_name = NULL_IF_CONFIG_SMALL("Fraps"), |
348 |
|
|
.type = AVMEDIA_TYPE_VIDEO, |
349 |
|
|
.id = AV_CODEC_ID_FRAPS, |
350 |
|
|
.priv_data_size = sizeof(FrapsContext), |
351 |
|
|
.init = decode_init, |
352 |
|
|
.close = decode_end, |
353 |
|
|
.decode = decode_frame, |
354 |
|
|
.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS, |
355 |
|
|
.caps_internal = FF_CODEC_CAP_INIT_THREADSAFE, |
356 |
|
|
}; |