ffmpeg / libavcodec / fraps.c @ 67c1a59a
History | View | Annotate | Download (11.8 KB)
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 "avcodec.h" |
35 |
#include "get_bits.h" |
36 |
#include "huffman.h" |
37 |
#include "bytestream.h" |
38 |
#include "dsputil.h" |
39 |
|
40 |
#define FPS_TAG MKTAG('F', 'P', 'S', 'x') |
41 |
|
42 |
/**
|
43 |
* local variable storage
|
44 |
*/
|
45 |
typedef struct FrapsContext{ |
46 |
AVCodecContext *avctx; |
47 |
AVFrame frame; |
48 |
uint8_t *tmpbuf; |
49 |
int tmpbuf_size;
|
50 |
DSPContext dsp; |
51 |
} FrapsContext; |
52 |
|
53 |
|
54 |
/**
|
55 |
* initializes decoder
|
56 |
* @param avctx codec context
|
57 |
* @return 0 on success or negative if fails
|
58 |
*/
|
59 |
static av_cold int decode_init(AVCodecContext *avctx) |
60 |
{ |
61 |
FrapsContext * const s = avctx->priv_data;
|
62 |
|
63 |
avctx->coded_frame = (AVFrame*)&s->frame; |
64 |
avctx->pix_fmt= PIX_FMT_NONE; /* set in decode_frame */
|
65 |
|
66 |
s->avctx = avctx; |
67 |
s->tmpbuf = NULL;
|
68 |
|
69 |
dsputil_init(&s->dsp, avctx); |
70 |
|
71 |
return 0; |
72 |
} |
73 |
|
74 |
/**
|
75 |
* Comparator - our nodes should ascend by count
|
76 |
* but with preserved symbol order
|
77 |
*/
|
78 |
static int huff_cmp(const void *va, const void *vb){ |
79 |
const Node *a = va, *b = vb;
|
80 |
return (a->count - b->count)*256 + a->sym - b->sym; |
81 |
} |
82 |
|
83 |
/**
|
84 |
* decode Fraps v2 packed plane
|
85 |
*/
|
86 |
static int fraps2_decode_plane(FrapsContext *s, uint8_t *dst, int stride, int w, |
87 |
int h, const uint8_t *src, int size, int Uoff, |
88 |
const int step) |
89 |
{ |
90 |
int i, j;
|
91 |
GetBitContext gb; |
92 |
VLC vlc; |
93 |
Node nodes[512];
|
94 |
|
95 |
for(i = 0; i < 256; i++) |
96 |
nodes[i].count = bytestream_get_le32(&src); |
97 |
size -= 1024;
|
98 |
if (ff_huff_build_tree(s->avctx, &vlc, 256, nodes, huff_cmp, |
99 |
FF_HUFFMAN_FLAG_ZERO_COUNT) < 0)
|
100 |
return -1; |
101 |
/* we have built Huffman table and are ready to decode plane */
|
102 |
|
103 |
/* convert bits so they may be used by standard bitreader */
|
104 |
s->dsp.bswap_buf((uint32_t *)s->tmpbuf, (const uint32_t *)src, size >> 2); |
105 |
|
106 |
init_get_bits(&gb, s->tmpbuf, size * 8);
|
107 |
for(j = 0; j < h; j++){ |
108 |
for(i = 0; i < w*step; i += step){ |
109 |
dst[i] = get_vlc2(&gb, vlc.table, 9, 3); |
110 |
/* lines are stored as deltas between previous lines
|
111 |
* and we need to add 0x80 to the first lines of chroma planes
|
112 |
*/
|
113 |
if(j) dst[i] += dst[i - stride];
|
114 |
else if(Uoff) dst[i] += 0x80; |
115 |
} |
116 |
dst += stride; |
117 |
} |
118 |
free_vlc(&vlc); |
119 |
return 0; |
120 |
} |
121 |
|
122 |
static int decode_frame(AVCodecContext *avctx, |
123 |
void *data, int *data_size, |
124 |
AVPacket *avpkt) |
125 |
{ |
126 |
const uint8_t *buf = avpkt->data;
|
127 |
int buf_size = avpkt->size;
|
128 |
FrapsContext * const s = avctx->priv_data;
|
129 |
AVFrame *frame = data; |
130 |
AVFrame * const f = (AVFrame*)&s->frame;
|
131 |
uint32_t header; |
132 |
unsigned int version,header_size; |
133 |
unsigned int x, y; |
134 |
const uint32_t *buf32;
|
135 |
uint32_t *luma1,*luma2,*cb,*cr; |
136 |
uint32_t offs[4];
|
137 |
int i, j, is_chroma, planes;
|
138 |
|
139 |
|
140 |
header = AV_RL32(buf); |
141 |
version = header & 0xff;
|
142 |
header_size = (header & (1<<30))? 8 : 4; /* bit 30 means pad to 8 bytes */ |
143 |
|
144 |
if (version > 5) { |
145 |
av_log(avctx, AV_LOG_ERROR, |
146 |
"This file is encoded with Fraps version %d. " \
|
147 |
"This codec can only decode versions <= 5.\n", version);
|
148 |
return -1; |
149 |
} |
150 |
|
151 |
buf+=4;
|
152 |
if (header_size == 8) |
153 |
buf+=4;
|
154 |
|
155 |
switch(version) {
|
156 |
case 0: |
157 |
default:
|
158 |
/* Fraps v0 is a reordered YUV420 */
|
159 |
avctx->pix_fmt = PIX_FMT_YUVJ420P; |
160 |
|
161 |
if ( (buf_size != avctx->width*avctx->height*3/2+header_size) && |
162 |
(buf_size != header_size) ) { |
163 |
av_log(avctx, AV_LOG_ERROR, |
164 |
"Invalid frame length %d (should be %d)\n",
|
165 |
buf_size, avctx->width*avctx->height*3/2+header_size); |
166 |
return -1; |
167 |
} |
168 |
|
169 |
if (( (avctx->width % 8) != 0) || ( (avctx->height % 2) != 0 )) { |
170 |
av_log(avctx, AV_LOG_ERROR, "Invalid frame size %dx%d\n",
|
171 |
avctx->width, avctx->height); |
172 |
return -1; |
173 |
} |
174 |
|
175 |
f->reference = 1;
|
176 |
f->buffer_hints = FF_BUFFER_HINTS_VALID | |
177 |
FF_BUFFER_HINTS_PRESERVE | |
178 |
FF_BUFFER_HINTS_REUSABLE; |
179 |
if (avctx->reget_buffer(avctx, f)) {
|
180 |
av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
|
181 |
return -1; |
182 |
} |
183 |
/* bit 31 means same as previous pic */
|
184 |
f->pict_type = (header & (1U<<31))? FF_P_TYPE : FF_I_TYPE; |
185 |
f->key_frame = f->pict_type == FF_I_TYPE; |
186 |
|
187 |
if (f->pict_type == FF_I_TYPE) {
|
188 |
buf32=(const uint32_t*)buf;
|
189 |
for(y=0; y<avctx->height/2; y++){ |
190 |
luma1=(uint32_t*)&f->data[0][ y*2*f->linesize[0] ]; |
191 |
luma2=(uint32_t*)&f->data[0][ (y*2+1)*f->linesize[0] ]; |
192 |
cr=(uint32_t*)&f->data[1][ y*f->linesize[1] ]; |
193 |
cb=(uint32_t*)&f->data[2][ y*f->linesize[2] ]; |
194 |
for(x=0; x<avctx->width; x+=8){ |
195 |
*(luma1++) = *(buf32++); |
196 |
*(luma1++) = *(buf32++); |
197 |
*(luma2++) = *(buf32++); |
198 |
*(luma2++) = *(buf32++); |
199 |
*(cr++) = *(buf32++); |
200 |
*(cb++) = *(buf32++); |
201 |
} |
202 |
} |
203 |
} |
204 |
break;
|
205 |
|
206 |
case 1: |
207 |
/* Fraps v1 is an upside-down BGR24 */
|
208 |
avctx->pix_fmt = PIX_FMT_BGR24; |
209 |
|
210 |
if ( (buf_size != avctx->width*avctx->height*3+header_size) && |
211 |
(buf_size != header_size) ) { |
212 |
av_log(avctx, AV_LOG_ERROR, |
213 |
"Invalid frame length %d (should be %d)\n",
|
214 |
buf_size, avctx->width*avctx->height*3+header_size);
|
215 |
return -1; |
216 |
} |
217 |
|
218 |
f->reference = 1;
|
219 |
f->buffer_hints = FF_BUFFER_HINTS_VALID | |
220 |
FF_BUFFER_HINTS_PRESERVE | |
221 |
FF_BUFFER_HINTS_REUSABLE; |
222 |
if (avctx->reget_buffer(avctx, f)) {
|
223 |
av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
|
224 |
return -1; |
225 |
} |
226 |
/* bit 31 means same as previous pic */
|
227 |
f->pict_type = (header & (1U<<31))? FF_P_TYPE : FF_I_TYPE; |
228 |
f->key_frame = f->pict_type == FF_I_TYPE; |
229 |
|
230 |
if (f->pict_type == FF_I_TYPE) {
|
231 |
for(y=0; y<avctx->height; y++) |
232 |
memcpy(&f->data[0][ (avctx->height-y)*f->linesize[0] ], |
233 |
&buf[y*avctx->width*3],
|
234 |
3*avctx->width);
|
235 |
} |
236 |
break;
|
237 |
|
238 |
case 2: |
239 |
case 4: |
240 |
/**
|
241 |
* Fraps v2 is Huffman-coded YUV420 planes
|
242 |
* Fraps v4 is virtually the same
|
243 |
*/
|
244 |
avctx->pix_fmt = PIX_FMT_YUVJ420P; |
245 |
planes = 3;
|
246 |
f->reference = 1;
|
247 |
f->buffer_hints = FF_BUFFER_HINTS_VALID | |
248 |
FF_BUFFER_HINTS_PRESERVE | |
249 |
FF_BUFFER_HINTS_REUSABLE; |
250 |
if (avctx->reget_buffer(avctx, f)) {
|
251 |
av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
|
252 |
return -1; |
253 |
} |
254 |
/* skip frame */
|
255 |
if(buf_size == 8) { |
256 |
f->pict_type = FF_P_TYPE; |
257 |
f->key_frame = 0;
|
258 |
break;
|
259 |
} |
260 |
f->pict_type = FF_I_TYPE; |
261 |
f->key_frame = 1;
|
262 |
if ((AV_RL32(buf) != FPS_TAG)||(buf_size < (planes*1024 + 24))) { |
263 |
av_log(avctx, AV_LOG_ERROR, "Fraps: error in data stream\n");
|
264 |
return -1; |
265 |
} |
266 |
for(i = 0; i < planes; i++) { |
267 |
offs[i] = AV_RL32(buf + 4 + i * 4); |
268 |
if(offs[i] >= buf_size || (i && offs[i] <= offs[i - 1] + 1024)) { |
269 |
av_log(avctx, AV_LOG_ERROR, "Fraps: plane %i offset is out of bounds\n", i);
|
270 |
return -1; |
271 |
} |
272 |
} |
273 |
offs[planes] = buf_size; |
274 |
for(i = 0; i < planes; i++){ |
275 |
is_chroma = !!i; |
276 |
av_fast_malloc(&s->tmpbuf, &s->tmpbuf_size, offs[i + 1] - offs[i] - 1024 + FF_INPUT_BUFFER_PADDING_SIZE); |
277 |
if (!s->tmpbuf)
|
278 |
return AVERROR(ENOMEM);
|
279 |
if(fraps2_decode_plane(s, f->data[i], f->linesize[i], avctx->width >> is_chroma,
|
280 |
avctx->height >> is_chroma, buf + offs[i], offs[i + 1] - offs[i], is_chroma, 1) < 0) { |
281 |
av_log(avctx, AV_LOG_ERROR, "Error decoding plane %i\n", i);
|
282 |
return -1; |
283 |
} |
284 |
} |
285 |
break;
|
286 |
case 3: |
287 |
case 5: |
288 |
/* Virtually the same as version 4, but is for RGB24 */
|
289 |
avctx->pix_fmt = PIX_FMT_BGR24; |
290 |
planes = 3;
|
291 |
f->reference = 1;
|
292 |
f->buffer_hints = FF_BUFFER_HINTS_VALID | |
293 |
FF_BUFFER_HINTS_PRESERVE | |
294 |
FF_BUFFER_HINTS_REUSABLE; |
295 |
if (avctx->reget_buffer(avctx, f)) {
|
296 |
av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
|
297 |
return -1; |
298 |
} |
299 |
/* skip frame */
|
300 |
if(buf_size == 8) { |
301 |
f->pict_type = FF_P_TYPE; |
302 |
f->key_frame = 0;
|
303 |
break;
|
304 |
} |
305 |
f->pict_type = FF_I_TYPE; |
306 |
f->key_frame = 1;
|
307 |
if ((AV_RL32(buf) != FPS_TAG)||(buf_size < (planes*1024 + 24))) { |
308 |
av_log(avctx, AV_LOG_ERROR, "Fraps: error in data stream\n");
|
309 |
return -1; |
310 |
} |
311 |
for(i = 0; i < planes; i++) { |
312 |
offs[i] = AV_RL32(buf + 4 + i * 4); |
313 |
if(offs[i] >= buf_size || (i && offs[i] <= offs[i - 1] + 1024)) { |
314 |
av_log(avctx, AV_LOG_ERROR, "Fraps: plane %i offset is out of bounds\n", i);
|
315 |
return -1; |
316 |
} |
317 |
} |
318 |
offs[planes] = buf_size; |
319 |
for(i = 0; i < planes; i++){ |
320 |
av_fast_malloc(&s->tmpbuf, &s->tmpbuf_size, offs[i + 1] - offs[i] - 1024 + FF_INPUT_BUFFER_PADDING_SIZE); |
321 |
if (!s->tmpbuf)
|
322 |
return AVERROR(ENOMEM);
|
323 |
if(fraps2_decode_plane(s, f->data[0] + i + (f->linesize[0] * (avctx->height - 1)), -f->linesize[0], |
324 |
avctx->width, avctx->height, buf + offs[i], offs[i + 1] - offs[i], 0, 3) < 0) { |
325 |
av_log(avctx, AV_LOG_ERROR, "Error decoding plane %i\n", i);
|
326 |
return -1; |
327 |
} |
328 |
} |
329 |
// convert pseudo-YUV into real RGB
|
330 |
for(j = 0; j < avctx->height; j++){ |
331 |
for(i = 0; i < avctx->width; i++){ |
332 |
f->data[0][0 + i*3 + j*f->linesize[0]] += f->data[0][1 + i*3 + j*f->linesize[0]]; |
333 |
f->data[0][2 + i*3 + j*f->linesize[0]] += f->data[0][1 + i*3 + j*f->linesize[0]]; |
334 |
} |
335 |
} |
336 |
break;
|
337 |
} |
338 |
|
339 |
*frame = *f; |
340 |
*data_size = sizeof(AVFrame);
|
341 |
|
342 |
return buf_size;
|
343 |
} |
344 |
|
345 |
|
346 |
/**
|
347 |
* closes decoder
|
348 |
* @param avctx codec context
|
349 |
* @return 0 on success or negative if fails
|
350 |
*/
|
351 |
static av_cold int decode_end(AVCodecContext *avctx) |
352 |
{ |
353 |
FrapsContext *s = (FrapsContext*)avctx->priv_data; |
354 |
|
355 |
if (s->frame.data[0]) |
356 |
avctx->release_buffer(avctx, &s->frame); |
357 |
|
358 |
av_freep(&s->tmpbuf); |
359 |
return 0; |
360 |
} |
361 |
|
362 |
|
363 |
AVCodec ff_fraps_decoder = { |
364 |
"fraps",
|
365 |
AVMEDIA_TYPE_VIDEO, |
366 |
CODEC_ID_FRAPS, |
367 |
sizeof(FrapsContext),
|
368 |
decode_init, |
369 |
NULL,
|
370 |
decode_end, |
371 |
decode_frame, |
372 |
CODEC_CAP_DR1, |
373 |
.long_name = NULL_IF_CONFIG_SMALL("Fraps"),
|
374 |
}; |