1 |
|
|
/* |
2 |
|
|
* Copyright (C) 2005 Ole André Vadla Ravnås <oleavr@gmail.com> |
3 |
|
|
* Copyright (C) 2008 Ramiro Polla |
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 |
|
|
#include <stdlib.h> |
23 |
|
|
#include <string.h> |
24 |
|
|
#include <stdint.h> |
25 |
|
|
|
26 |
|
|
#include "libavutil/mem_internal.h" |
27 |
|
|
#include "libavutil/thread.h" |
28 |
|
|
|
29 |
|
|
#include "avcodec.h" |
30 |
|
|
#include "blockdsp.h" |
31 |
|
|
#include "internal.h" |
32 |
|
|
#include "get_bits.h" |
33 |
|
|
#include "bytestream.h" |
34 |
|
|
#include "bswapdsp.h" |
35 |
|
|
#include "hpeldsp.h" |
36 |
|
|
#include "idctdsp.h" |
37 |
|
|
#include "thread.h" |
38 |
|
|
|
39 |
|
|
#define MIMIC_HEADER_SIZE 20 |
40 |
|
|
#define MIMIC_VLC_BITS 11 |
41 |
|
|
|
42 |
|
|
typedef struct MimicContext { |
43 |
|
|
AVCodecContext *avctx; |
44 |
|
|
|
45 |
|
|
int num_vblocks[3]; |
46 |
|
|
int num_hblocks[3]; |
47 |
|
|
|
48 |
|
|
void *swap_buf; |
49 |
|
|
int swap_buf_size; |
50 |
|
|
|
51 |
|
|
int cur_index; |
52 |
|
|
int prev_index; |
53 |
|
|
|
54 |
|
|
ThreadFrame frames [16]; |
55 |
|
|
|
56 |
|
|
DECLARE_ALIGNED(32, int16_t, dct_block)[64]; |
57 |
|
|
|
58 |
|
|
GetBitContext gb; |
59 |
|
|
ScanTable scantable; |
60 |
|
|
BlockDSPContext bdsp; |
61 |
|
|
BswapDSPContext bbdsp; |
62 |
|
|
HpelDSPContext hdsp; |
63 |
|
|
IDCTDSPContext idsp; |
64 |
|
|
|
65 |
|
|
/* Kept in the context so multithreading can have a constant to read from */ |
66 |
|
|
int next_cur_index; |
67 |
|
|
int next_prev_index; |
68 |
|
|
} MimicContext; |
69 |
|
|
|
70 |
|
|
static VLC block_vlc; |
71 |
|
|
|
72 |
|
|
static const uint8_t huffsyms[] = { |
73 |
|
|
0x10, 0x20, 0x30, 0x00, 0x11, 0x40, 0x50, 0x12, 0x13, 0x21, 0x31, 0x60, |
74 |
|
|
0x14, 0x15, 0x16, 0x22, 0x41, 0x17, 0x18, 0x23, 0x24, 0x25, 0x32, 0x42, |
75 |
|
|
0x51, 0x61, 0x70, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x26, 0x27, |
76 |
|
|
0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x33, 0x34, 0x35, 0x36, 0x37, |
77 |
|
|
0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x43, 0x44, 0x45, 0x46, 0x47, |
78 |
|
|
0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x52, 0x53, 0x54, 0x55, 0x56, |
79 |
|
|
0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x62, 0x63, 0x64, 0x65, |
80 |
|
|
0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x71, 0x72, 0x73, |
81 |
|
|
0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, |
82 |
|
|
}; |
83 |
|
|
|
84 |
|
|
static const uint8_t huffbits[] = { |
85 |
|
|
2, 2, 3, 4, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, |
86 |
|
|
8, 8, 9, 9, 9, 9, 10, 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12, |
87 |
|
|
13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 17, 17, |
88 |
|
|
17, 17, 18, 18, 18, 18, 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, |
89 |
|
|
22, 22, 22, 22, 23, 23, 23, 23, 24, 24, 24, 24, 25, 25, 25, 25, 26, 26, |
90 |
|
|
26, 26, 27, 27, 27, 27, 28, 28, 28, 28, 29, 29, 29, 29, 30, 30, 30, |
91 |
|
|
}; |
92 |
|
|
|
93 |
|
|
static const uint8_t col_zag[64] = { |
94 |
|
|
0, 8, 1, 2, 9, 16, 24, 17, |
95 |
|
|
10, 3, 4, 11, 18, 25, 32, 40, |
96 |
|
|
33, 26, 19, 12, 5, 6, 13, 20, |
97 |
|
|
27, 34, 41, 48, 56, 49, 42, 35, |
98 |
|
|
28, 21, 14, 7, 15, 22, 29, 36, |
99 |
|
|
43, 50, 57, 58, 51, 44, 37, 30, |
100 |
|
|
23, 31, 38, 45, 52, 59, 39, 46, |
101 |
|
|
53, 60, 61, 54, 47, 55, 62, 63, |
102 |
|
|
}; |
103 |
|
|
|
104 |
|
2 |
static av_cold int mimic_decode_end(AVCodecContext *avctx) |
105 |
|
|
{ |
106 |
|
2 |
MimicContext *ctx = avctx->priv_data; |
107 |
|
|
int i; |
108 |
|
|
|
109 |
|
2 |
av_freep(&ctx->swap_buf); |
110 |
|
2 |
ctx->swap_buf_size = 0; |
111 |
|
|
|
112 |
✓✓ |
34 |
for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) { |
113 |
✓✗ |
32 |
if (ctx->frames[i].f) |
114 |
|
32 |
ff_thread_release_buffer(avctx, &ctx->frames[i]); |
115 |
|
32 |
av_frame_free(&ctx->frames[i].f); |
116 |
|
|
} |
117 |
|
|
|
118 |
|
2 |
return 0; |
119 |
|
|
} |
120 |
|
|
|
121 |
|
1 |
static av_cold void mimic_init_static(void) |
122 |
|
|
{ |
123 |
|
1 |
INIT_VLC_STATIC_FROM_LENGTHS(&block_vlc, MIMIC_VLC_BITS, FF_ARRAY_ELEMS(huffbits), |
124 |
|
|
huffbits, 1, huffsyms, 1, 1, 0, 0, 4368); |
125 |
|
1 |
} |
126 |
|
|
|
127 |
|
2 |
static av_cold int mimic_decode_init(AVCodecContext *avctx) |
128 |
|
|
{ |
129 |
|
|
static AVOnce init_static_once = AV_ONCE_INIT; |
130 |
|
2 |
MimicContext *ctx = avctx->priv_data; |
131 |
|
|
int i; |
132 |
|
|
|
133 |
|
2 |
ctx->prev_index = 0; |
134 |
|
2 |
ctx->cur_index = 15; |
135 |
|
|
|
136 |
|
2 |
ff_blockdsp_init(&ctx->bdsp, avctx); |
137 |
|
2 |
ff_bswapdsp_init(&ctx->bbdsp); |
138 |
|
2 |
ff_hpeldsp_init(&ctx->hdsp, avctx->flags); |
139 |
|
2 |
ff_idctdsp_init(&ctx->idsp, avctx); |
140 |
|
2 |
ff_init_scantable(ctx->idsp.idct_permutation, &ctx->scantable, col_zag); |
141 |
|
|
|
142 |
✓✓ |
34 |
for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) { |
143 |
|
32 |
ctx->frames[i].f = av_frame_alloc(); |
144 |
✗✓ |
32 |
if (!ctx->frames[i].f) |
145 |
|
|
return AVERROR(ENOMEM); |
146 |
|
|
} |
147 |
|
|
|
148 |
|
2 |
ff_thread_once(&init_static_once, mimic_init_static); |
149 |
|
|
|
150 |
|
2 |
return 0; |
151 |
|
|
} |
152 |
|
|
|
153 |
|
|
#if HAVE_THREADS |
154 |
|
|
static int mimic_decode_update_thread_context(AVCodecContext *avctx, const AVCodecContext *avctx_from) |
155 |
|
|
{ |
156 |
|
|
MimicContext *dst = avctx->priv_data, *src = avctx_from->priv_data; |
157 |
|
|
int i, ret; |
158 |
|
|
|
159 |
|
|
if (avctx == avctx_from) |
160 |
|
|
return 0; |
161 |
|
|
|
162 |
|
|
dst->cur_index = src->next_cur_index; |
163 |
|
|
dst->prev_index = src->next_prev_index; |
164 |
|
|
|
165 |
|
|
for (i = 0; i < FF_ARRAY_ELEMS(dst->frames); i++) { |
166 |
|
|
ff_thread_release_buffer(avctx, &dst->frames[i]); |
167 |
|
|
if (i != src->next_cur_index && src->frames[i].f->data[0]) { |
168 |
|
|
ret = ff_thread_ref_frame(&dst->frames[i], &src->frames[i]); |
169 |
|
|
if (ret < 0) |
170 |
|
|
return ret; |
171 |
|
|
} |
172 |
|
|
} |
173 |
|
|
|
174 |
|
|
return 0; |
175 |
|
|
} |
176 |
|
|
#endif |
177 |
|
|
|
178 |
|
|
static const int8_t vlcdec_lookup[9][64] = { |
179 |
|
|
{ 0, }, |
180 |
|
|
{ -1, 1, }, |
181 |
|
|
{ -3, 3, -2, 2, }, |
182 |
|
|
{ -7, 7, -6, 6, -5, 5, -4, 4, }, |
183 |
|
|
{ -15, 15, -14, 14, -13, 13, -12, 12, |
184 |
|
|
-11, 11, -10, 10, -9, 9, -8, 8, }, |
185 |
|
|
{ -31, 31, -30, 30, -29, 29, -28, 28, |
186 |
|
|
-27, 27, -26, 26, -25, 25, -24, 24, |
187 |
|
|
-23, 23, -22, 22, -21, 21, -20, 20, |
188 |
|
|
-19, 19, -18, 18, -17, 17, -16, 16, }, |
189 |
|
|
{ -63, 63, -62, 62, -61, 61, -60, 60, |
190 |
|
|
-59, 59, -58, 58, -57, 57, -56, 56, |
191 |
|
|
-55, 55, -54, 54, -53, 53, -52, 52, |
192 |
|
|
-51, 51, -50, 50, -49, 49, -48, 48, |
193 |
|
|
-47, 47, -46, 46, -45, 45, -44, 44, |
194 |
|
|
-43, 43, -42, 42, -41, 41, -40, 40, |
195 |
|
|
-39, 39, -38, 38, -37, 37, -36, 36, |
196 |
|
|
-35, 35, -34, 34, -33, 33, -32, 32, }, |
197 |
|
|
{ -127, 127, -126, 126, -125, 125, -124, 124, |
198 |
|
|
-123, 123, -122, 122, -121, 121, -120, 120, |
199 |
|
|
-119, 119, -118, 118, -117, 117, -116, 116, |
200 |
|
|
-115, 115, -114, 114, -113, 113, -112, 112, |
201 |
|
|
-111, 111, -110, 110, -109, 109, -108, 108, |
202 |
|
|
-107, 107, -106, 106, -105, 105, -104, 104, |
203 |
|
|
-103, 103, -102, 102, -101, 101, -100, 100, |
204 |
|
|
-99, 99, -98, 98, -97, 97, -96, 96, }, |
205 |
|
|
{ -95, 95, -94, 94, -93, 93, -92, 92, |
206 |
|
|
-91, 91, -90, 90, -89, 89, -88, 88, |
207 |
|
|
-87, 87, -86, 86, -85, 85, -84, 84, |
208 |
|
|
-83, 83, -82, 82, -81, 81, -80, 80, |
209 |
|
|
-79, 79, -78, 78, -77, 77, -76, 76, |
210 |
|
|
-75, 75, -74, 74, -73, 73, -72, 72, |
211 |
|
|
-71, 71, -70, 70, -69, 69, -68, 68, |
212 |
|
|
-67, 67, -66, 66, -65, 65, -64, 64, }, |
213 |
|
|
}; |
214 |
|
|
|
215 |
|
44548 |
static int vlc_decode_block(MimicContext *ctx, int num_coeffs, int qscale) |
216 |
|
|
{ |
217 |
|
44548 |
int16_t *block = ctx->dct_block; |
218 |
|
|
unsigned int pos; |
219 |
|
|
|
220 |
|
44548 |
ctx->bdsp.clear_block(block); |
221 |
|
|
|
222 |
|
44548 |
block[0] = get_bits(&ctx->gb, 8) << 3; |
223 |
|
|
|
224 |
✓✓ |
304893 |
for (pos = 1; pos < num_coeffs; pos++) { |
225 |
|
|
uint32_t vlc, num_bits; |
226 |
|
|
int value; |
227 |
|
|
int coeff; |
228 |
|
|
|
229 |
|
302169 |
vlc = get_vlc2(&ctx->gb, block_vlc.table, MIMIC_VLC_BITS, 3); |
230 |
✓✓ |
302169 |
if (!vlc) /* end-of-block code */ |
231 |
|
41824 |
return 0; |
232 |
✗✓ |
260345 |
if (vlc == -1) |
233 |
|
|
return AVERROR_INVALIDDATA; |
234 |
|
|
|
235 |
|
|
/* pos_add and num_bits are coded in the vlc code */ |
236 |
|
260345 |
pos += vlc & 15; // pos_add |
237 |
|
260345 |
num_bits = vlc >> 4; // num_bits |
238 |
|
|
|
239 |
✗✓ |
260345 |
if (pos >= 64) |
240 |
|
|
return AVERROR_INVALIDDATA; |
241 |
|
|
|
242 |
|
260345 |
value = get_bits(&ctx->gb, num_bits); |
243 |
|
|
|
244 |
|
|
/* FFmpeg's IDCT behaves somewhat different from the original code, so |
245 |
|
|
* a factor of 4 was added to the input */ |
246 |
|
|
|
247 |
|
260345 |
coeff = ((int8_t*)vlcdec_lookup[num_bits])[value]; |
248 |
✓✓ |
260345 |
if (pos < 3) |
249 |
|
50048 |
coeff *= 16; |
250 |
|
|
else /* TODO Use >> 10 instead of / 1001 */ |
251 |
|
210297 |
coeff = (coeff * qscale) / 1001; |
252 |
|
|
|
253 |
|
260345 |
block[ctx->scantable.permutated[pos]] = coeff; |
254 |
|
|
} |
255 |
|
|
|
256 |
|
2724 |
return 0; |
257 |
|
|
} |
258 |
|
|
|
259 |
|
77 |
static int decode(MimicContext *ctx, int quality, int num_coeffs, |
260 |
|
|
int is_iframe) |
261 |
|
|
{ |
262 |
|
77 |
int ret, y, x, plane, cur_row = 0; |
263 |
|
|
|
264 |
✓✓ |
308 |
for (plane = 0; plane < 3; plane++) { |
265 |
|
231 |
const int is_chroma = !!plane; |
266 |
✓✓ |
231 |
const int qscale = av_clip(10000 - quality, is_chroma ? 1000 : 2000, |
267 |
|
|
10000) << 2; |
268 |
|
231 |
const int stride = ctx->frames[ctx->cur_index ].f->linesize[plane]; |
269 |
|
231 |
const uint8_t *src = ctx->frames[ctx->prev_index].f->data[plane]; |
270 |
|
231 |
uint8_t *dst = ctx->frames[ctx->cur_index ].f->data[plane]; |
271 |
|
|
|
272 |
✓✓ |
4851 |
for (y = 0; y < ctx->num_vblocks[plane]; y++) { |
273 |
✓✓ |
143220 |
for (x = 0; x < ctx->num_hblocks[plane]; x++) { |
274 |
|
|
/* Check for a change condition in the current block. |
275 |
|
|
* - iframes always change. |
276 |
|
|
* - Luma plane changes on get_bits1 == 0 |
277 |
|
|
* - Chroma planes change on get_bits1 == 1 */ |
278 |
✓✓✓✓
|
138600 |
if (is_iframe || get_bits1(&ctx->gb) == is_chroma) { |
279 |
|
|
/* Luma planes may use a backreference from the 15 last |
280 |
|
|
* frames preceding the previous. (get_bits1 == 1) |
281 |
|
|
* Chroma planes don't use backreferences. */ |
282 |
✓✓✓✓
✓✓ |
50491 |
if (is_chroma || is_iframe || !get_bits1(&ctx->gb)) { |
283 |
✗✓ |
44548 |
if ((ret = vlc_decode_block(ctx, num_coeffs, |
284 |
|
|
qscale)) < 0) { |
285 |
|
|
av_log(ctx->avctx, AV_LOG_ERROR, "Error decoding " |
286 |
|
|
"block.\n"); |
287 |
|
|
return ret; |
288 |
|
|
} |
289 |
|
44548 |
ctx->idsp.idct_put(dst, stride, ctx->dct_block); |
290 |
|
|
} else { |
291 |
|
5943 |
unsigned int backref = get_bits(&ctx->gb, 4); |
292 |
|
5943 |
int index = (ctx->cur_index + backref) & 15; |
293 |
|
5943 |
uint8_t *p = ctx->frames[index].f->data[0]; |
294 |
|
|
|
295 |
✓✗✓✗
|
5943 |
if (index != ctx->cur_index && p) { |
296 |
|
5943 |
ff_thread_await_progress(&ctx->frames[index], |
297 |
|
|
cur_row, 0); |
298 |
|
5943 |
p += src - |
299 |
|
5943 |
ctx->frames[ctx->prev_index].f->data[plane]; |
300 |
|
5943 |
ctx->hdsp.put_pixels_tab[1][0](dst, p, stride, 8); |
301 |
|
|
} else { |
302 |
|
|
av_log(ctx->avctx, AV_LOG_ERROR, |
303 |
|
|
"No such backreference! Buggy sample.\n"); |
304 |
|
|
} |
305 |
|
|
} |
306 |
|
|
} else { |
307 |
|
88109 |
ff_thread_await_progress(&ctx->frames[ctx->prev_index], |
308 |
|
|
cur_row, 0); |
309 |
|
88109 |
ctx->hdsp.put_pixels_tab[1][0](dst, src, stride, 8); |
310 |
|
|
} |
311 |
|
138600 |
src += 8; |
312 |
|
138600 |
dst += 8; |
313 |
|
|
} |
314 |
|
4620 |
src += (stride - ctx->num_hblocks[plane]) << 3; |
315 |
|
4620 |
dst += (stride - ctx->num_hblocks[plane]) << 3; |
316 |
|
|
|
317 |
|
4620 |
ff_thread_report_progress(&ctx->frames[ctx->cur_index], |
318 |
|
|
cur_row++, 0); |
319 |
|
|
} |
320 |
|
|
} |
321 |
|
|
|
322 |
|
77 |
return 0; |
323 |
|
|
} |
324 |
|
|
|
325 |
|
|
/** |
326 |
|
|
* Flip the buffer upside-down and put it in the YVU order to revert the |
327 |
|
|
* way Mimic encodes frames. |
328 |
|
|
*/ |
329 |
|
77 |
static void flip_swap_frame(AVFrame *f) |
330 |
|
|
{ |
331 |
|
|
int i; |
332 |
|
77 |
uint8_t *data_1 = f->data[1]; |
333 |
|
77 |
f->data[0] = f->data[0] + ( f->height - 1) * f->linesize[0]; |
334 |
|
77 |
f->data[1] = f->data[2] + ((f->height >> 1) - 1) * f->linesize[2]; |
335 |
|
77 |
f->data[2] = data_1 + ((f->height >> 1) - 1) * f->linesize[1]; |
336 |
✓✓ |
308 |
for (i = 0; i < 3; i++) |
337 |
|
231 |
f->linesize[i] *= -1; |
338 |
|
77 |
} |
339 |
|
|
|
340 |
|
77 |
static int mimic_decode_frame(AVCodecContext *avctx, void *data, |
341 |
|
|
int *got_frame, AVPacket *avpkt) |
342 |
|
|
{ |
343 |
|
77 |
const uint8_t *buf = avpkt->data; |
344 |
|
77 |
int buf_size = avpkt->size; |
345 |
|
77 |
int swap_buf_size = buf_size - MIMIC_HEADER_SIZE; |
346 |
|
77 |
MimicContext *ctx = avctx->priv_data; |
347 |
|
|
GetByteContext gb; |
348 |
|
|
int is_pframe; |
349 |
|
|
int width, height; |
350 |
|
|
int quality, num_coeffs; |
351 |
|
|
int res; |
352 |
|
|
|
353 |
✗✓ |
77 |
if (buf_size <= MIMIC_HEADER_SIZE) { |
354 |
|
|
av_log(avctx, AV_LOG_ERROR, "insufficient data\n"); |
355 |
|
|
return AVERROR_INVALIDDATA; |
356 |
|
|
} |
357 |
|
|
|
358 |
|
77 |
bytestream2_init(&gb, buf, MIMIC_HEADER_SIZE); |
359 |
|
77 |
bytestream2_skip(&gb, 2); /* some constant (always 256) */ |
360 |
|
77 |
quality = bytestream2_get_le16u(&gb); |
361 |
|
77 |
width = bytestream2_get_le16u(&gb); |
362 |
|
77 |
height = bytestream2_get_le16u(&gb); |
363 |
|
77 |
bytestream2_skip(&gb, 4); /* some constant */ |
364 |
|
77 |
is_pframe = bytestream2_get_le32u(&gb); |
365 |
|
77 |
num_coeffs = bytestream2_get_byteu(&gb); |
366 |
|
77 |
bytestream2_skip(&gb, 3); /* some constant */ |
367 |
|
|
|
368 |
✓✓ |
77 |
if (!ctx->avctx) { |
369 |
|
|
int i; |
370 |
|
|
|
371 |
✗✓✗✗
✓✗ |
2 |
if (!(width == 160 && height == 120) && |
372 |
✗✓ |
2 |
!(width == 320 && height == 240)) { |
373 |
|
|
av_log(avctx, AV_LOG_ERROR, "invalid width/height!\n"); |
374 |
|
|
return AVERROR_INVALIDDATA; |
375 |
|
|
} |
376 |
|
|
|
377 |
|
2 |
res = ff_set_dimensions(avctx, width, height); |
378 |
✗✓ |
2 |
if (res < 0) |
379 |
|
|
return res; |
380 |
|
|
|
381 |
|
2 |
ctx->avctx = avctx; |
382 |
|
2 |
avctx->pix_fmt = AV_PIX_FMT_YUV420P; |
383 |
✓✓ |
8 |
for (i = 0; i < 3; i++) { |
384 |
✓✓ |
6 |
ctx->num_vblocks[i] = AV_CEIL_RSHIFT(height, 3 + !!i); |
385 |
✓✓ |
6 |
ctx->num_hblocks[i] = width >> (3 + !!i); |
386 |
|
|
} |
387 |
✓✗✗✓
|
75 |
} else if (width != ctx->avctx->width || height != ctx->avctx->height) { |
388 |
|
|
avpriv_request_sample(avctx, "Resolution changing"); |
389 |
|
|
return AVERROR_PATCHWELCOME; |
390 |
|
|
} |
391 |
|
|
|
392 |
✓✓✗✓
|
77 |
if (is_pframe && !ctx->frames[ctx->prev_index].f->data[0]) { |
393 |
|
|
av_log(avctx, AV_LOG_ERROR, "decoding must start with keyframe\n"); |
394 |
|
|
return AVERROR_INVALIDDATA; |
395 |
|
|
} |
396 |
|
|
|
397 |
|
77 |
ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]); |
398 |
✓✓ |
77 |
ctx->frames[ctx->cur_index].f->pict_type = is_pframe ? AV_PICTURE_TYPE_P : |
399 |
|
|
AV_PICTURE_TYPE_I; |
400 |
✗✓ |
77 |
if ((res = ff_thread_get_buffer(avctx, &ctx->frames[ctx->cur_index], |
401 |
|
|
AV_GET_BUFFER_FLAG_REF)) < 0) |
402 |
|
|
return res; |
403 |
|
|
|
404 |
|
77 |
ctx->next_prev_index = ctx->cur_index; |
405 |
|
77 |
ctx->next_cur_index = (ctx->cur_index - 1) & 15; |
406 |
|
|
|
407 |
|
77 |
ff_thread_finish_setup(avctx); |
408 |
|
|
|
409 |
|
77 |
av_fast_padded_malloc(&ctx->swap_buf, &ctx->swap_buf_size, swap_buf_size); |
410 |
✗✓ |
77 |
if (!ctx->swap_buf) |
411 |
|
|
return AVERROR(ENOMEM); |
412 |
|
|
|
413 |
|
77 |
ctx->bbdsp.bswap_buf(ctx->swap_buf, |
414 |
|
77 |
(const uint32_t *) (buf + MIMIC_HEADER_SIZE), |
415 |
|
|
swap_buf_size >> 2); |
416 |
|
77 |
init_get_bits(&ctx->gb, ctx->swap_buf, swap_buf_size << 3); |
417 |
|
|
|
418 |
|
77 |
res = decode(ctx, quality, num_coeffs, !is_pframe); |
419 |
|
77 |
ff_thread_report_progress(&ctx->frames[ctx->cur_index], INT_MAX, 0); |
420 |
✗✓ |
77 |
if (res < 0) { |
421 |
|
|
if (!(avctx->active_thread_type & FF_THREAD_FRAME)) |
422 |
|
|
ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]); |
423 |
|
|
return res; |
424 |
|
|
} |
425 |
|
|
|
426 |
✗✓ |
77 |
if ((res = av_frame_ref(data, ctx->frames[ctx->cur_index].f)) < 0) |
427 |
|
|
return res; |
428 |
|
77 |
*got_frame = 1; |
429 |
|
|
|
430 |
|
77 |
flip_swap_frame(data); |
431 |
|
|
|
432 |
|
77 |
ctx->prev_index = ctx->next_prev_index; |
433 |
|
77 |
ctx->cur_index = ctx->next_cur_index; |
434 |
|
|
|
435 |
|
77 |
return buf_size; |
436 |
|
|
} |
437 |
|
|
|
438 |
|
|
AVCodec ff_mimic_decoder = { |
439 |
|
|
.name = "mimic", |
440 |
|
|
.long_name = NULL_IF_CONFIG_SMALL("Mimic"), |
441 |
|
|
.type = AVMEDIA_TYPE_VIDEO, |
442 |
|
|
.id = AV_CODEC_ID_MIMIC, |
443 |
|
|
.priv_data_size = sizeof(MimicContext), |
444 |
|
|
.init = mimic_decode_init, |
445 |
|
|
.close = mimic_decode_end, |
446 |
|
|
.decode = mimic_decode_frame, |
447 |
|
|
.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS, |
448 |
|
|
.update_thread_context = ONLY_IF_THREADS_ENABLED(mimic_decode_update_thread_context), |
449 |
|
|
.caps_internal = FF_CODEC_CAP_ALLOCATE_PROGRESS | |
450 |
|
|
FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_INIT_THREADSAFE, |
451 |
|
|
}; |