| GCC Code Coverage Report | |||||||||||||||||||||
|
|||||||||||||||||||||
| Line | Branch | Exec | Source |
1 |
/* |
||
2 |
* Copyright (c) 2010-2011 Maxim Poliakovski |
||
3 |
* Copyright (c) 2010-2011 Elvis Presley |
||
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 |
* Known FOURCCs: 'apch' (HQ), 'apcn' (SD), 'apcs' (LT), 'acpo' (Proxy), 'ap4h' (4444) |
||
25 |
*/ |
||
26 |
|||
27 |
//#define DEBUG |
||
28 |
|||
29 |
#define LONG_BITSTREAM_READER |
||
30 |
|||
31 |
#include "libavutil/internal.h" |
||
32 |
#include "avcodec.h" |
||
33 |
#include "get_bits.h" |
||
34 |
#include "idctdsp.h" |
||
35 |
#include "internal.h" |
||
36 |
#include "profiles.h" |
||
37 |
#include "simple_idct.h" |
||
38 |
#include "proresdec.h" |
||
39 |
#include "proresdata.h" |
||
40 |
#include "thread.h" |
||
41 |
|||
42 |
2210 |
static void permute(uint8_t *dst, const uint8_t *src, const uint8_t permutation[64]) |
|
43 |
{ |
||
44 |
int i; |
||
45 |
✓✓ | 143650 |
for (i = 0; i < 64; i++) |
46 |
141440 |
dst[i] = permutation[src[i]]; |
|
47 |
2210 |
} |
|
48 |
|||
49 |
#define ALPHA_SHIFT_16_TO_10(alpha_val) (alpha_val >> 6) |
||
50 |
#define ALPHA_SHIFT_8_TO_10(alpha_val) ((alpha_val << 2) | (alpha_val >> 6)) |
||
51 |
#define ALPHA_SHIFT_16_TO_12(alpha_val) (alpha_val >> 4) |
||
52 |
#define ALPHA_SHIFT_8_TO_12(alpha_val) ((alpha_val << 4) | (alpha_val >> 4)) |
||
53 |
|||
54 |
5100 |
static void inline unpack_alpha(GetBitContext *gb, uint16_t *dst, int num_coeffs, |
|
55 |
const int num_bits, const int decode_precision) { |
||
56 |
5100 |
const int mask = (1 << num_bits) - 1; |
|
57 |
int i, idx, val, alpha_val; |
||
58 |
|||
59 |
5100 |
idx = 0; |
|
60 |
5100 |
alpha_val = mask; |
|
61 |
do { |
||
62 |
do { |
||
63 |
✓✓ | 58400 |
if (get_bits1(gb)) { |
64 |
43404 |
val = get_bits(gb, num_bits); |
|
65 |
} else { |
||
66 |
int sign; |
||
67 |
✓✗ | 14996 |
val = get_bits(gb, num_bits == 16 ? 7 : 4); |
68 |
14996 |
sign = val & 1; |
|
69 |
14996 |
val = (val + 2) >> 1; |
|
70 |
✗✓ | 14996 |
if (sign) |
71 |
val = -val; |
||
72 |
} |
||
73 |
58400 |
alpha_val = (alpha_val + val) & mask; |
|
74 |
✓✗ | 58400 |
if (num_bits == 16) { |
75 |
✗✓ | 58400 |
if (decode_precision == 10) { |
76 |
dst[idx++] = ALPHA_SHIFT_16_TO_10(alpha_val); |
||
77 |
} else { /* 12b */ |
||
78 |
58400 |
dst[idx++] = ALPHA_SHIFT_16_TO_12(alpha_val); |
|
79 |
} |
||
80 |
} else { |
||
81 |
if (decode_precision == 10) { |
||
82 |
dst[idx++] = ALPHA_SHIFT_8_TO_10(alpha_val); |
||
83 |
} else { /* 12b */ |
||
84 |
dst[idx++] = ALPHA_SHIFT_8_TO_12(alpha_val); |
||
85 |
} |
||
86 |
} |
||
87 |
✓✓ | 58400 |
if (idx >= num_coeffs) |
88 |
36 |
break; |
|
89 |
✓✓✓✓ |
58364 |
} while (get_bits_left(gb)>0 && get_bits1(gb)); |
90 |
37552 |
val = get_bits(gb, 4); |
|
91 |
✓✓ | 37552 |
if (!val) |
92 |
35779 |
val = get_bits(gb, 11); |
|
93 |
✓✓ | 37552 |
if (idx + val > num_coeffs) |
94 |
140 |
val = num_coeffs - idx; |
|
95 |
✓✗ | 37552 |
if (num_bits == 16) { |
96 |
✓✓ | 10423952 |
for (i = 0; i < val; i++) { |
97 |
✗✓ | 10386400 |
if (decode_precision == 10) { |
98 |
dst[idx++] = ALPHA_SHIFT_16_TO_10(alpha_val); |
||
99 |
} else { /* 12b */ |
||
100 |
10386400 |
dst[idx++] = ALPHA_SHIFT_16_TO_12(alpha_val); |
|
101 |
} |
||
102 |
} |
||
103 |
} else { |
||
104 |
for (i = 0; i < val; i++) { |
||
105 |
if (decode_precision == 10) { |
||
106 |
dst[idx++] = ALPHA_SHIFT_8_TO_10(alpha_val); |
||
107 |
} else { /* 12b */ |
||
108 |
dst[idx++] = ALPHA_SHIFT_8_TO_12(alpha_val); |
||
109 |
} |
||
110 |
} |
||
111 |
} |
||
112 |
✓✓ | 37552 |
} while (idx < num_coeffs); |
113 |
5100 |
} |
|
114 |
|||
115 |
static void unpack_alpha_10(GetBitContext *gb, uint16_t *dst, int num_coeffs, |
||
116 |
const int num_bits) |
||
117 |
{ |
||
118 |
if (num_bits == 16) { |
||
119 |
unpack_alpha(gb, dst, num_coeffs, 16, 10); |
||
120 |
} else { /* 8 bits alpha */ |
||
121 |
unpack_alpha(gb, dst, num_coeffs, 8, 10); |
||
122 |
} |
||
123 |
} |
||
124 |
|||
125 |
5100 |
static void unpack_alpha_12(GetBitContext *gb, uint16_t *dst, int num_coeffs, |
|
126 |
const int num_bits) |
||
127 |
{ |
||
128 |
✓✗ | 5100 |
if (num_bits == 16) { |
129 |
5100 |
unpack_alpha(gb, dst, num_coeffs, 16, 12); |
|
130 |
} else { /* 8 bits alpha */ |
||
131 |
unpack_alpha(gb, dst, num_coeffs, 8, 12); |
||
132 |
} |
||
133 |
5100 |
} |
|
134 |
|||
135 |
59 |
static av_cold int decode_init(AVCodecContext *avctx) |
|
136 |
{ |
||
137 |
59 |
int ret = 0; |
|
138 |
59 |
ProresContext *ctx = avctx->priv_data; |
|
139 |
uint8_t idct_permutation[64]; |
||
140 |
|||
141 |
59 |
avctx->bits_per_raw_sample = 10; |
|
142 |
|||
143 |
✓✓✓✓ ✓✗✗ |
59 |
switch (avctx->codec_tag) { |
144 |
3 |
case MKTAG('a','p','c','o'): |
|
145 |
3 |
avctx->profile = FF_PROFILE_PRORES_PROXY; |
|
146 |
3 |
break; |
|
147 |
2 |
case MKTAG('a','p','c','s'): |
|
148 |
2 |
avctx->profile = FF_PROFILE_PRORES_LT; |
|
149 |
2 |
break; |
|
150 |
20 |
case MKTAG('a','p','c','n'): |
|
151 |
20 |
avctx->profile = FF_PROFILE_PRORES_STANDARD; |
|
152 |
20 |
break; |
|
153 |
10 |
case MKTAG('a','p','c','h'): |
|
154 |
10 |
avctx->profile = FF_PROFILE_PRORES_HQ; |
|
155 |
10 |
break; |
|
156 |
24 |
case MKTAG('a','p','4','h'): |
|
157 |
24 |
avctx->profile = FF_PROFILE_PRORES_4444; |
|
158 |
24 |
avctx->bits_per_raw_sample = 12; |
|
159 |
24 |
break; |
|
160 |
case MKTAG('a','p','4','x'): |
||
161 |
avctx->profile = FF_PROFILE_PRORES_XQ; |
||
162 |
avctx->bits_per_raw_sample = 12; |
||
163 |
break; |
||
164 |
default: |
||
165 |
avctx->profile = FF_PROFILE_UNKNOWN; |
||
166 |
av_log(avctx, AV_LOG_WARNING, "Unknown prores profile %d\n", avctx->codec_tag); |
||
167 |
} |
||
168 |
|||
169 |
✓✓ | 59 |
if (avctx->bits_per_raw_sample == 10) { |
170 |
35 |
av_log(avctx, AV_LOG_DEBUG, "Auto bitdepth precision. Use 10b decoding based on codec tag.\n"); |
|
171 |
} else { /* 12b */ |
||
172 |
24 |
av_log(avctx, AV_LOG_DEBUG, "Auto bitdepth precision. Use 12b decoding based on codec tag.\n"); |
|
173 |
} |
||
174 |
|||
175 |
59 |
ff_blockdsp_init(&ctx->bdsp, avctx); |
|
176 |
59 |
ret = ff_proresdsp_init(&ctx->prodsp, avctx); |
|
177 |
✗✓ | 59 |
if (ret < 0) { |
178 |
av_log(avctx, AV_LOG_ERROR, "Fail to init proresdsp for bits per raw sample %d\n", avctx->bits_per_raw_sample); |
||
179 |
return ret; |
||
180 |
} |
||
181 |
|||
182 |
59 |
ff_init_scantable_permutation(idct_permutation, |
|
183 |
59 |
ctx->prodsp.idct_permutation_type); |
|
184 |
|||
185 |
59 |
permute(ctx->progressive_scan, ff_prores_progressive_scan, idct_permutation); |
|
186 |
59 |
permute(ctx->interlaced_scan, ff_prores_interlaced_scan, idct_permutation); |
|
187 |
|||
188 |
✓✓ | 59 |
if (avctx->bits_per_raw_sample == 10){ |
189 |
35 |
ctx->unpack_alpha = unpack_alpha_10; |
|
190 |
✓✗ | 24 |
} else if (avctx->bits_per_raw_sample == 12){ |
191 |
24 |
ctx->unpack_alpha = unpack_alpha_12; |
|
192 |
} else { |
||
193 |
av_log(avctx, AV_LOG_ERROR, "Fail to set unpack_alpha for bits per raw sample %d\n", avctx->bits_per_raw_sample); |
||
194 |
return AVERROR_BUG; |
||
195 |
} |
||
196 |
59 |
return ret; |
|
197 |
} |
||
198 |
|||
199 |
1046 |
static int decode_frame_header(ProresContext *ctx, const uint8_t *buf, |
|
200 |
const int data_size, AVCodecContext *avctx) |
||
201 |
{ |
||
202 |
int hdr_size, width, height, flags; |
||
203 |
int version; |
||
204 |
const uint8_t *ptr; |
||
205 |
|||
206 |
1046 |
hdr_size = AV_RB16(buf); |
|
207 |
ff_dlog(avctx, "header size %d\n", hdr_size); |
||
208 |
✗✓ | 1046 |
if (hdr_size > data_size) { |
209 |
av_log(avctx, AV_LOG_ERROR, "error, wrong header size\n"); |
||
210 |
return AVERROR_INVALIDDATA; |
||
211 |
} |
||
212 |
|||
213 |
1046 |
version = AV_RB16(buf + 2); |
|
214 |
ff_dlog(avctx, "%.4s version %d\n", buf+4, version); |
||
215 |
✗✓ | 1046 |
if (version > 1) { |
216 |
av_log(avctx, AV_LOG_ERROR, "unsupported version: %d\n", version); |
||
217 |
return AVERROR_PATCHWELCOME; |
||
218 |
} |
||
219 |
|||
220 |
1046 |
width = AV_RB16(buf + 8); |
|
221 |
1046 |
height = AV_RB16(buf + 10); |
|
222 |
|||
223 |
✓✗✗✓ |
1046 |
if (width != avctx->width || height != avctx->height) { |
224 |
int ret; |
||
225 |
|||
226 |
av_log(avctx, AV_LOG_WARNING, "picture resolution change: %dx%d -> %dx%d\n", |
||
227 |
avctx->width, avctx->height, width, height); |
||
228 |
if ((ret = ff_set_dimensions(avctx, width, height)) < 0) |
||
229 |
return ret; |
||
230 |
} |
||
231 |
|||
232 |
1046 |
ctx->frame_type = (buf[12] >> 2) & 3; |
|
233 |
1046 |
ctx->alpha_info = buf[17] & 0xf; |
|
234 |
|||
235 |
✗✓ | 1046 |
if (ctx->alpha_info > 2) { |
236 |
av_log(avctx, AV_LOG_ERROR, "Invalid alpha mode %d\n", ctx->alpha_info); |
||
237 |
return AVERROR_INVALIDDATA; |
||
238 |
} |
||
239 |
✓✓ | 1046 |
if (avctx->skip_alpha) ctx->alpha_info = 0; |
240 |
|||
241 |
ff_dlog(avctx, "frame type %d\n", ctx->frame_type); |
||
242 |
|||
243 |
✓✓ | 1046 |
if (ctx->frame_type == 0) { |
244 |
619 |
ctx->scan = ctx->progressive_scan; // permuted |
|
245 |
} else { |
||
246 |
427 |
ctx->scan = ctx->interlaced_scan; // permuted |
|
247 |
427 |
ctx->frame->interlaced_frame = 1; |
|
248 |
427 |
ctx->frame->top_field_first = ctx->frame_type == 1; |
|
249 |
} |
||
250 |
|||
251 |
✓✓ | 1046 |
if (ctx->alpha_info) { |
252 |
✗✓ | 5 |
if (avctx->bits_per_raw_sample == 10) { |
253 |
avctx->pix_fmt = (buf[12] & 0xC0) == 0xC0 ? AV_PIX_FMT_YUVA444P10 : AV_PIX_FMT_YUVA422P10; |
||
254 |
} else { /* 12b */ |
||
255 |
✓✗ | 5 |
avctx->pix_fmt = (buf[12] & 0xC0) == 0xC0 ? AV_PIX_FMT_YUVA444P12 : AV_PIX_FMT_YUVA422P12; |
256 |
} |
||
257 |
} else { |
||
258 |
✓✓ | 1041 |
if (avctx->bits_per_raw_sample == 10) { |
259 |
✗✓ | 628 |
avctx->pix_fmt = (buf[12] & 0xC0) == 0xC0 ? AV_PIX_FMT_YUV444P10 : AV_PIX_FMT_YUV422P10; |
260 |
} else { /* 12b */ |
||
261 |
✓✗ | 413 |
avctx->pix_fmt = (buf[12] & 0xC0) == 0xC0 ? AV_PIX_FMT_YUV444P12 : AV_PIX_FMT_YUV422P12; |
262 |
} |
||
263 |
} |
||
264 |
|||
265 |
1046 |
avctx->color_primaries = buf[14]; |
|
266 |
1046 |
avctx->color_trc = buf[15]; |
|
267 |
1046 |
avctx->colorspace = buf[16]; |
|
268 |
1046 |
avctx->color_range = AVCOL_RANGE_MPEG; |
|
269 |
|||
270 |
1046 |
ptr = buf + 20; |
|
271 |
1046 |
flags = buf[19]; |
|
272 |
ff_dlog(avctx, "flags %x\n", flags); |
||
273 |
|||
274 |
✓✗ | 1046 |
if (flags & 2) { |
275 |
✗✓ | 1046 |
if(buf + data_size - ptr < 64) { |
276 |
av_log(avctx, AV_LOG_ERROR, "Header truncated\n"); |
||
277 |
return AVERROR_INVALIDDATA; |
||
278 |
} |
||
279 |
1046 |
permute(ctx->qmat_luma, ctx->prodsp.idct_permutation, ptr); |
|
280 |
1046 |
ptr += 64; |
|
281 |
} else { |
||
282 |
memset(ctx->qmat_luma, 4, 64); |
||
283 |
} |
||
284 |
|||
285 |
✓✗ | 1046 |
if (flags & 1) { |
286 |
✗✓ | 1046 |
if(buf + data_size - ptr < 64) { |
287 |
av_log(avctx, AV_LOG_ERROR, "Header truncated\n"); |
||
288 |
return AVERROR_INVALIDDATA; |
||
289 |
} |
||
290 |
1046 |
permute(ctx->qmat_chroma, ctx->prodsp.idct_permutation, ptr); |
|
291 |
} else { |
||
292 |
memset(ctx->qmat_chroma, 4, 64); |
||
293 |
} |
||
294 |
|||
295 |
1046 |
return hdr_size; |
|
296 |
} |
||
297 |
|||
298 |
1473 |
static int decode_picture_header(AVCodecContext *avctx, const uint8_t *buf, const int buf_size) |
|
299 |
{ |
||
300 |
1473 |
ProresContext *ctx = avctx->priv_data; |
|
301 |
int i, hdr_size, slice_count; |
||
302 |
unsigned pic_data_size; |
||
303 |
int log2_slice_mb_width, log2_slice_mb_height; |
||
304 |
int slice_mb_count, mb_x, mb_y; |
||
305 |
const uint8_t *data_ptr, *index_ptr; |
||
306 |
|||
307 |
1473 |
hdr_size = buf[0] >> 3; |
|
308 |
✓✗✗✓ |
1473 |
if (hdr_size < 8 || hdr_size > buf_size) { |
309 |
av_log(avctx, AV_LOG_ERROR, "error, wrong picture header size\n"); |
||
310 |
return AVERROR_INVALIDDATA; |
||
311 |
} |
||
312 |
|||
313 |
1473 |
pic_data_size = AV_RB32(buf + 1); |
|
314 |
✗✓ | 1473 |
if (pic_data_size > buf_size) { |
315 |
av_log(avctx, AV_LOG_ERROR, "error, wrong picture data size\n"); |
||
316 |
return AVERROR_INVALIDDATA; |
||
317 |
} |
||
318 |
|||
319 |
1473 |
log2_slice_mb_width = buf[7] >> 4; |
|
320 |
1473 |
log2_slice_mb_height = buf[7] & 0xF; |
|
321 |
✓✗✗✓ |
1473 |
if (log2_slice_mb_width > 3 || log2_slice_mb_height) { |
322 |
av_log(avctx, AV_LOG_ERROR, "unsupported slice resolution: %dx%d\n", |
||
323 |
1 << log2_slice_mb_width, 1 << log2_slice_mb_height); |
||
324 |
return AVERROR_INVALIDDATA; |
||
325 |
} |
||
326 |
|||
327 |
1473 |
ctx->mb_width = (avctx->width + 15) >> 4; |
|
328 |
✓✓ | 1473 |
if (ctx->frame_type) |
329 |
854 |
ctx->mb_height = (avctx->height + 31) >> 5; |
|
330 |
else |
||
331 |
619 |
ctx->mb_height = (avctx->height + 15) >> 4; |
|
332 |
|||
333 |
// QT ignores the written value |
||
334 |
// slice_count = AV_RB16(buf + 5); |
||
335 |
1473 |
slice_count = ctx->mb_height * ((ctx->mb_width >> log2_slice_mb_width) + |
|
336 |
1473 |
av_popcount(ctx->mb_width & (1 << log2_slice_mb_width) - 1)); |
|
337 |
|||
338 |
✓✓✗✓ |
1473 |
if (ctx->slice_count != slice_count || !ctx->slices) { |
339 |
59 |
av_freep(&ctx->slices); |
|
340 |
59 |
ctx->slice_count = 0; |
|
341 |
59 |
ctx->slices = av_mallocz_array(slice_count, sizeof(*ctx->slices)); |
|
342 |
✗✓ | 59 |
if (!ctx->slices) |
343 |
return AVERROR(ENOMEM); |
||
344 |
59 |
ctx->slice_count = slice_count; |
|
345 |
} |
||
346 |
|||
347 |
✗✓ | 1473 |
if (!slice_count) |
348 |
return AVERROR(EINVAL); |
||
349 |
|||
350 |
✗✓ | 1473 |
if (hdr_size + slice_count*2 > buf_size) { |
351 |
av_log(avctx, AV_LOG_ERROR, "error, wrong slice count\n"); |
||
352 |
return AVERROR_INVALIDDATA; |
||
353 |
} |
||
354 |
|||
355 |
// parse slice information |
||
356 |
1473 |
index_ptr = buf + hdr_size; |
|
357 |
1473 |
data_ptr = index_ptr + slice_count*2; |
|
358 |
|||
359 |
1473 |
slice_mb_count = 1 << log2_slice_mb_width; |
|
360 |
1473 |
mb_x = 0; |
|
361 |
1473 |
mb_y = 0; |
|
362 |
|||
363 |
✓✓ | 82503 |
for (i = 0; i < slice_count; i++) { |
364 |
81030 |
SliceContext *slice = &ctx->slices[i]; |
|
365 |
|||
366 |
81030 |
slice->data = data_ptr; |
|
367 |
81030 |
data_ptr += AV_RB16(index_ptr + i*2); |
|
368 |
|||
369 |
✓✓ | 111495 |
while (ctx->mb_width - mb_x < slice_mb_count) |
370 |
30465 |
slice_mb_count >>= 1; |
|
371 |
|||
372 |
81030 |
slice->mb_x = mb_x; |
|
373 |
81030 |
slice->mb_y = mb_y; |
|
374 |
81030 |
slice->mb_count = slice_mb_count; |
|
375 |
81030 |
slice->data_size = data_ptr - slice->data; |
|
376 |
|||
377 |
✗✓ | 81030 |
if (slice->data_size < 6) { |
378 |
av_log(avctx, AV_LOG_ERROR, "error, wrong slice data size\n"); |
||
379 |
return AVERROR_INVALIDDATA; |
||
380 |
} |
||
381 |
|||
382 |
81030 |
mb_x += slice_mb_count; |
|
383 |
✓✓ | 81030 |
if (mb_x == ctx->mb_width) { |
384 |
16309 |
slice_mb_count = 1 << log2_slice_mb_width; |
|
385 |
16309 |
mb_x = 0; |
|
386 |
16309 |
mb_y++; |
|
387 |
} |
||
388 |
✗✓ | 81030 |
if (data_ptr > buf + buf_size) { |
389 |
av_log(avctx, AV_LOG_ERROR, "error, slice out of bounds\n"); |
||
390 |
return AVERROR_INVALIDDATA; |
||
391 |
} |
||
392 |
} |
||
393 |
|||
394 |
✓✗✗✓ |
1473 |
if (mb_x || mb_y != ctx->mb_height) { |
395 |
av_log(avctx, AV_LOG_ERROR, "error wrong mb count y %d h %d\n", |
||
396 |
mb_y, ctx->mb_height); |
||
397 |
return AVERROR_INVALIDDATA; |
||
398 |
} |
||
399 |
|||
400 |
1473 |
return pic_data_size; |
|
401 |
} |
||
402 |
|||
403 |
#define DECODE_CODEWORD(val, codebook, SKIP) \ |
||
404 |
do { \ |
||
405 |
unsigned int rice_order, exp_order, switch_bits; \ |
||
406 |
unsigned int q, buf, bits; \ |
||
407 |
\ |
||
408 |
UPDATE_CACHE(re, gb); \ |
||
409 |
buf = GET_CACHE(re, gb); \ |
||
410 |
\ |
||
411 |
/* number of bits to switch between rice and exp golomb */ \ |
||
412 |
switch_bits = codebook & 3; \ |
||
413 |
rice_order = codebook >> 5; \ |
||
414 |
exp_order = (codebook >> 2) & 7; \ |
||
415 |
\ |
||
416 |
q = 31 - av_log2(buf); \ |
||
417 |
\ |
||
418 |
if (q > switch_bits) { /* exp golomb */ \ |
||
419 |
bits = exp_order - switch_bits + (q<<1); \ |
||
420 |
if (bits > FFMIN(MIN_CACHE_BITS, 31)) \ |
||
421 |
return AVERROR_INVALIDDATA; \ |
||
422 |
val = SHOW_UBITS(re, gb, bits) - (1 << exp_order) + \ |
||
423 |
((switch_bits + 1) << rice_order); \ |
||
424 |
SKIP(re, gb, bits); \ |
||
425 |
} else if (rice_order) { \ |
||
426 |
SKIP_BITS(re, gb, q+1); \ |
||
427 |
val = (q << rice_order) + SHOW_UBITS(re, gb, rice_order); \ |
||
428 |
SKIP(re, gb, rice_order); \ |
||
429 |
} else { \ |
||
430 |
val = q; \ |
||
431 |
SKIP(re, gb, q+1); \ |
||
432 |
} \ |
||
433 |
} while (0) |
||
434 |
|||
435 |
#define TOSIGNED(x) (((x) >> 1) ^ (-((x) & 1))) |
||
436 |
|||
437 |
#define FIRST_DC_CB 0xB8 |
||
438 |
|||
439 |
static const uint8_t dc_codebook[7] = { 0x04, 0x28, 0x28, 0x4D, 0x4D, 0x70, 0x70}; |
||
440 |
|||
441 |
241578 |
static av_always_inline int decode_dc_coeffs(GetBitContext *gb, int16_t *out, |
|
442 |
int blocks_per_slice) |
||
443 |
{ |
||
444 |
int16_t prev_dc; |
||
445 |
int code, i, sign; |
||
446 |
|||
447 |
241578 |
OPEN_READER(re, gb); |
|
448 |
|||
449 |
✓✓✗✓ ✓✗ |
241578 |
DECODE_CODEWORD(code, FIRST_DC_CB, LAST_SKIP_BITS); |
450 |
241578 |
prev_dc = TOSIGNED(code); |
|
451 |
241578 |
out[0] = prev_dc; |
|
452 |
|||
453 |
241578 |
out += 64; // dc coeff for the next block |
|
454 |
|||
455 |
241578 |
code = 5; |
|
456 |
241578 |
sign = 0; |
|
457 |
✓✓ | 4780596 |
for (i = 1; i < blocks_per_slice; i++, out += 64) { |
458 |
✓✓✗✓ ✓✓ |
4539018 |
DECODE_CODEWORD(code, dc_codebook[FFMIN(code, 6U)], LAST_SKIP_BITS); |
459 |
✓✓ | 4539018 |
if(code) sign ^= -(code & 1); |
460 |
1671537 |
else sign = 0; |
|
461 |
4539018 |
prev_dc += (((code + 1) >> 1) ^ sign) - sign; |
|
462 |
4539018 |
out[0] = prev_dc; |
|
463 |
} |
||
464 |
241578 |
CLOSE_READER(re, gb); |
|
465 |
241578 |
return 0; |
|
466 |
} |
||
467 |
|||
468 |
// adaptive codebook switching lut according to previous run/level values |
||
469 |
static const uint8_t run_to_cb[16] = { 0x06, 0x06, 0x05, 0x05, 0x04, 0x29, 0x29, 0x29, 0x29, 0x28, 0x28, 0x28, 0x28, 0x28, 0x28, 0x4C }; |
||
470 |
static const uint8_t lev_to_cb[10] = { 0x04, 0x0A, 0x05, 0x06, 0x04, 0x28, 0x28, 0x28, 0x28, 0x4C }; |
||
471 |
|||
472 |
241578 |
static av_always_inline int decode_ac_coeffs(AVCodecContext *avctx, GetBitContext *gb, |
|
473 |
int16_t *out, int blocks_per_slice) |
||
474 |
{ |
||
475 |
241578 |
ProresContext *ctx = avctx->priv_data; |
|
476 |
int block_mask, sign; |
||
477 |
unsigned pos, run, level; |
||
478 |
int max_coeffs, i, bits_left; |
||
479 |
241578 |
int log2_block_count = av_log2(blocks_per_slice); |
|
480 |
|||
481 |
241578 |
OPEN_READER(re, gb); |
|
482 |
241578 |
UPDATE_CACHE(re, gb); \ |
|
483 |
241578 |
run = 4; |
|
484 |
241578 |
level = 2; |
|
485 |
|||
486 |
241578 |
max_coeffs = 64 << log2_block_count; |
|
487 |
241578 |
block_mask = blocks_per_slice - 1; |
|
488 |
|||
489 |
241578 |
for (pos = block_mask;;) { |
|
490 |
84310010 |
bits_left = gb->size_in_bits - re_index; |
|
491 |
✓✓✓✓ ✓✓ |
84310010 |
if (!bits_left || (bits_left < 32 && !SHOW_UBITS(re, gb, bits_left))) |
492 |
break; |
||
493 |
|||
494 |
✓✓✗✓ ✓✓ |
84068432 |
DECODE_CODEWORD(run, run_to_cb[FFMIN(run, 15)], LAST_SKIP_BITS); |
495 |
84068432 |
pos += run + 1; |
|
496 |
✗✓ | 84068432 |
if (pos >= max_coeffs) { |
497 |
av_log(avctx, AV_LOG_ERROR, "ac tex damaged %d, %d\n", pos, max_coeffs); |
||
498 |
return AVERROR_INVALIDDATA; |
||
499 |
} |
||
500 |
|||
501 |
✓✓✗✓ ✓✓ |
84068432 |
DECODE_CODEWORD(level, lev_to_cb[FFMIN(level, 9)], SKIP_BITS); |
502 |
84068432 |
level += 1; |
|
503 |
|||
504 |
84068432 |
i = pos >> log2_block_count; |
|
505 |
|||
506 |
84068432 |
sign = SHOW_SBITS(re, gb, 1); |
|
507 |
84068432 |
SKIP_BITS(re, gb, 1); |
|
508 |
84068432 |
out[((pos & block_mask) << 6) + ctx->scan[i]] = ((level ^ sign) - sign); |
|
509 |
} |
||
510 |
|||
511 |
241578 |
CLOSE_READER(re, gb); |
|
512 |
241578 |
return 0; |
|
513 |
} |
||
514 |
|||
515 |
81030 |
static int decode_slice_luma(AVCodecContext *avctx, SliceContext *slice, |
|
516 |
uint16_t *dst, int dst_stride, |
||
517 |
const uint8_t *buf, unsigned buf_size, |
||
518 |
const int16_t *qmat) |
||
519 |
{ |
||
520 |
81030 |
ProresContext *ctx = avctx->priv_data; |
|
521 |
81030 |
LOCAL_ALIGNED_32(int16_t, blocks, [8*4*64]); |
|
522 |
int16_t *block; |
||
523 |
GetBitContext gb; |
||
524 |
81030 |
int i, blocks_per_slice = slice->mb_count<<2; |
|
525 |
int ret; |
||
526 |
|||
527 |
✓✓ | 2073354 |
for (i = 0; i < blocks_per_slice; i++) |
528 |
1992324 |
ctx->bdsp.clear_block(blocks+(i<<6)); |
|
529 |
|||
530 |
81030 |
init_get_bits(&gb, buf, buf_size << 3); |
|
531 |
|||
532 |
✗✓ | 81030 |
if ((ret = decode_dc_coeffs(&gb, blocks, blocks_per_slice)) < 0) |
533 |
return ret; |
||
534 |
✗✓ | 81030 |
if ((ret = decode_ac_coeffs(avctx, &gb, blocks, blocks_per_slice)) < 0) |
535 |
return ret; |
||
536 |
|||
537 |
81030 |
block = blocks; |
|
538 |
✓✓ | 579111 |
for (i = 0; i < slice->mb_count; i++) { |
539 |
498081 |
ctx->prodsp.idct_put(dst, dst_stride, block+(0<<6), qmat); |
|
540 |
498081 |
ctx->prodsp.idct_put(dst +8, dst_stride, block+(1<<6), qmat); |
|
541 |
498081 |
ctx->prodsp.idct_put(dst+4*dst_stride , dst_stride, block+(2<<6), qmat); |
|
542 |
498081 |
ctx->prodsp.idct_put(dst+4*dst_stride+8, dst_stride, block+(3<<6), qmat); |
|
543 |
498081 |
block += 4*64; |
|
544 |
498081 |
dst += 16; |
|
545 |
} |
||
546 |
81030 |
return 0; |
|
547 |
} |
||
548 |
|||
549 |
160548 |
static int decode_slice_chroma(AVCodecContext *avctx, SliceContext *slice, |
|
550 |
uint16_t *dst, int dst_stride, |
||
551 |
const uint8_t *buf, unsigned buf_size, |
||
552 |
const int16_t *qmat, int log2_blocks_per_mb) |
||
553 |
{ |
||
554 |
160548 |
ProresContext *ctx = avctx->priv_data; |
|
555 |
160548 |
LOCAL_ALIGNED_32(int16_t, blocks, [8*4*64]); |
|
556 |
int16_t *block; |
||
557 |
GetBitContext gb; |
||
558 |
160548 |
int i, j, blocks_per_slice = slice->mb_count << log2_blocks_per_mb; |
|
559 |
int ret; |
||
560 |
|||
561 |
✓✓ | 2948820 |
for (i = 0; i < blocks_per_slice; i++) |
562 |
2788272 |
ctx->bdsp.clear_block(blocks+(i<<6)); |
|
563 |
|||
564 |
160548 |
init_get_bits(&gb, buf, buf_size << 3); |
|
565 |
|||
566 |
✗✓ | 160548 |
if ((ret = decode_dc_coeffs(&gb, blocks, blocks_per_slice)) < 0) |
567 |
return ret; |
||
568 |
✗✓ | 160548 |
if ((ret = decode_ac_coeffs(avctx, &gb, blocks, blocks_per_slice)) < 0) |
569 |
return ret; |
||
570 |
|||
571 |
160548 |
block = blocks; |
|
572 |
✓✓ | 1146990 |
for (i = 0; i < slice->mb_count; i++) { |
573 |
✓✓ | 2380578 |
for (j = 0; j < log2_blocks_per_mb; j++) { |
574 |
1394136 |
ctx->prodsp.idct_put(dst, dst_stride, block+(0<<6), qmat); |
|
575 |
1394136 |
ctx->prodsp.idct_put(dst+4*dst_stride, dst_stride, block+(1<<6), qmat); |
|
576 |
1394136 |
block += 2*64; |
|
577 |
1394136 |
dst += 8; |
|
578 |
} |
||
579 |
} |
||
580 |
160548 |
return 0; |
|
581 |
} |
||
582 |
|||
583 |
/** |
||
584 |
* Decode alpha slice plane. |
||
585 |
*/ |
||
586 |
5100 |
static void decode_slice_alpha(ProresContext *ctx, |
|
587 |
uint16_t *dst, int dst_stride, |
||
588 |
const uint8_t *buf, int buf_size, |
||
589 |
int blocks_per_slice) |
||
590 |
{ |
||
591 |
GetBitContext gb; |
||
592 |
int i; |
||
593 |
5100 |
LOCAL_ALIGNED_32(int16_t, blocks, [8*4*64]); |
|
594 |
int16_t *block; |
||
595 |
|||
596 |
✓✓ | 168300 |
for (i = 0; i < blocks_per_slice<<2; i++) |
597 |
163200 |
ctx->bdsp.clear_block(blocks+(i<<6)); |
|
598 |
|||
599 |
5100 |
init_get_bits(&gb, buf, buf_size << 3); |
|
600 |
|||
601 |
✓✗ | 5100 |
if (ctx->alpha_info == 2) { |
602 |
5100 |
ctx->unpack_alpha(&gb, blocks, blocks_per_slice * 4 * 64, 16); |
|
603 |
} else { |
||
604 |
ctx->unpack_alpha(&gb, blocks, blocks_per_slice * 4 * 64, 8); |
||
605 |
} |
||
606 |
|||
607 |
5100 |
block = blocks; |
|
608 |
|||
609 |
✓✓ | 86700 |
for (i = 0; i < 16; i++) { |
610 |
81600 |
memcpy(dst, block, 16 * blocks_per_slice * sizeof(*dst)); |
|
611 |
81600 |
dst += dst_stride >> 1; |
|
612 |
81600 |
block += 16 * blocks_per_slice; |
|
613 |
} |
||
614 |
5100 |
} |
|
615 |
|||
616 |
81030 |
static int decode_slice_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr) |
|
617 |
{ |
||
618 |
81030 |
ProresContext *ctx = avctx->priv_data; |
|
619 |
81030 |
SliceContext *slice = &ctx->slices[jobnr]; |
|
620 |
81030 |
const uint8_t *buf = slice->data; |
|
621 |
81030 |
AVFrame *pic = ctx->frame; |
|
622 |
int i, hdr_size, qscale, log2_chroma_blocks_per_mb; |
||
623 |
int luma_stride, chroma_stride; |
||
624 |
int y_data_size, u_data_size, v_data_size, a_data_size; |
||
625 |
uint8_t *dest_y, *dest_u, *dest_v, *dest_a; |
||
626 |
81030 |
LOCAL_ALIGNED_16(int16_t, qmat_luma_scaled, [64]); |
|
627 |
81030 |
LOCAL_ALIGNED_16(int16_t, qmat_chroma_scaled,[64]); |
|
628 |
int mb_x_shift; |
||
629 |
int ret; |
||
630 |
uint16_t val_no_chroma; |
||
631 |
|||
632 |
81030 |
slice->ret = -1; |
|
633 |
//av_log(avctx, AV_LOG_INFO, "slice %d mb width %d mb x %d y %d\n", |
||
634 |
// jobnr, slice->mb_count, slice->mb_x, slice->mb_y); |
||
635 |
|||
636 |
// slice header |
||
637 |
81030 |
hdr_size = buf[0] >> 3; |
|
638 |
81030 |
qscale = av_clip(buf[1], 1, 224); |
|
639 |
✗✓ | 81030 |
qscale = qscale > 128 ? qscale - 96 << 2: qscale; |
640 |
81030 |
y_data_size = AV_RB16(buf + 2); |
|
641 |
81030 |
u_data_size = AV_RB16(buf + 4); |
|
642 |
81030 |
v_data_size = slice->data_size - y_data_size - u_data_size - hdr_size; |
|
643 |
✓✓ | 81030 |
if (hdr_size > 7) v_data_size = AV_RB16(buf + 6); |
644 |
81030 |
a_data_size = slice->data_size - y_data_size - u_data_size - |
|
645 |
81030 |
v_data_size - hdr_size; |
|
646 |
|||
647 |
✓✗✓✗ ✓✗ |
81030 |
if (y_data_size < 0 || u_data_size < 0 || v_data_size < 0 |
648 |
✗✓ | 81030 |
|| hdr_size+y_data_size+u_data_size+v_data_size > slice->data_size){ |
649 |
av_log(avctx, AV_LOG_ERROR, "invalid plane data size\n"); |
||
650 |
return AVERROR_INVALIDDATA; |
||
651 |
} |
||
652 |
|||
653 |
81030 |
buf += hdr_size; |
|
654 |
|||
655 |
✓✓ | 5266950 |
for (i = 0; i < 64; i++) { |
656 |
5185920 |
qmat_luma_scaled [i] = ctx->qmat_luma [i] * qscale; |
|
657 |
5185920 |
qmat_chroma_scaled[i] = ctx->qmat_chroma[i] * qscale; |
|
658 |
} |
||
659 |
|||
660 |
✓✓ | 81030 |
if (ctx->frame_type == 0) { |
661 |
38802 |
luma_stride = pic->linesize[0]; |
|
662 |
38802 |
chroma_stride = pic->linesize[1]; |
|
663 |
} else { |
||
664 |
42228 |
luma_stride = pic->linesize[0] << 1; |
|
665 |
42228 |
chroma_stride = pic->linesize[1] << 1; |
|
666 |
} |
||
667 |
|||
668 |
✓✗✓✗ |
81030 |
if (avctx->pix_fmt == AV_PIX_FMT_YUV444P10 || avctx->pix_fmt == AV_PIX_FMT_YUVA444P10 || |
669 |
✓✓✓✓ |
81030 |
avctx->pix_fmt == AV_PIX_FMT_YUV444P12 || avctx->pix_fmt == AV_PIX_FMT_YUVA444P12) { |
670 |
32946 |
mb_x_shift = 5; |
|
671 |
32946 |
log2_chroma_blocks_per_mb = 2; |
|
672 |
} else { |
||
673 |
48084 |
mb_x_shift = 4; |
|
674 |
48084 |
log2_chroma_blocks_per_mb = 1; |
|
675 |
} |
||
676 |
|||
677 |
81030 |
dest_y = pic->data[0] + (slice->mb_y << 4) * luma_stride + (slice->mb_x << 5); |
|
678 |
81030 |
dest_u = pic->data[1] + (slice->mb_y << 4) * chroma_stride + (slice->mb_x << mb_x_shift); |
|
679 |
81030 |
dest_v = pic->data[2] + (slice->mb_y << 4) * chroma_stride + (slice->mb_x << mb_x_shift); |
|
680 |
81030 |
dest_a = pic->data[3] + (slice->mb_y << 4) * luma_stride + (slice->mb_x << 5); |
|
681 |
|||
682 |
✓✓✓✓ |
81030 |
if (ctx->frame_type && ctx->first_field ^ ctx->frame->top_field_first) { |
683 |
21114 |
dest_y += pic->linesize[0]; |
|
684 |
21114 |
dest_u += pic->linesize[1]; |
|
685 |
21114 |
dest_v += pic->linesize[2]; |
|
686 |
21114 |
dest_a += pic->linesize[3]; |
|
687 |
} |
||
688 |
|||
689 |
81030 |
ret = decode_slice_luma(avctx, slice, (uint16_t*)dest_y, luma_stride, |
|
690 |
buf, y_data_size, qmat_luma_scaled); |
||
691 |
✗✓ | 81030 |
if (ret < 0) |
692 |
return ret; |
||
693 |
|||
694 |
✓✗✓✓ |
81030 |
if (!(avctx->flags & AV_CODEC_FLAG_GRAY) && (u_data_size + v_data_size) > 0) { |
695 |
80274 |
ret = decode_slice_chroma(avctx, slice, (uint16_t*)dest_u, chroma_stride, |
|
696 |
buf + y_data_size, u_data_size, |
||
697 |
qmat_chroma_scaled, log2_chroma_blocks_per_mb); |
||
698 |
✗✓ | 80274 |
if (ret < 0) |
699 |
return ret; |
||
700 |
|||
701 |
80274 |
ret = decode_slice_chroma(avctx, slice, (uint16_t*)dest_v, chroma_stride, |
|
702 |
80274 |
buf + y_data_size + u_data_size, v_data_size, |
|
703 |
qmat_chroma_scaled, log2_chroma_blocks_per_mb); |
||
704 |
✗✓ | 80274 |
if (ret < 0) |
705 |
return ret; |
||
706 |
} |
||
707 |
else { |
||
708 |
756 |
size_t mb_max_x = slice->mb_count << (mb_x_shift - 1); |
|
709 |
size_t i, j; |
||
710 |
✓✗ | 756 |
if (avctx->bits_per_raw_sample == 10) { |
711 |
756 |
val_no_chroma = 511; |
|
712 |
} else { /* 12b */ |
||
713 |
val_no_chroma = 511 * 4; |
||
714 |
} |
||
715 |
✓✓ | 12852 |
for (i = 0; i < 16; ++i) |
716 |
✓✓ | 634176 |
for (j = 0; j < mb_max_x; ++j) { |
717 |
622080 |
*(uint16_t*)(dest_u + (i * chroma_stride) + (j << 1)) = val_no_chroma; |
|
718 |
622080 |
*(uint16_t*)(dest_v + (i * chroma_stride) + (j << 1)) = val_no_chroma; |
|
719 |
} |
||
720 |
} |
||
721 |
|||
722 |
/* decode alpha plane if available */ |
||
723 |
✓✓✓✗ ✓✗ |
81030 |
if (ctx->alpha_info && pic->data[3] && a_data_size) |
724 |
5100 |
decode_slice_alpha(ctx, (uint16_t*)dest_a, luma_stride, |
|
725 |
5100 |
buf + y_data_size + u_data_size + v_data_size, |
|
726 |
5100 |
a_data_size, slice->mb_count); |
|
727 |
|||
728 |
81030 |
slice->ret = 0; |
|
729 |
81030 |
return 0; |
|
730 |
} |
||
731 |
|||
732 |
1473 |
static int decode_picture(AVCodecContext *avctx) |
|
733 |
{ |
||
734 |
1473 |
ProresContext *ctx = avctx->priv_data; |
|
735 |
int i; |
||
736 |
1473 |
int error = 0; |
|
737 |
|||
738 |
1473 |
avctx->execute2(avctx, decode_slice_thread, NULL, NULL, ctx->slice_count); |
|
739 |
|||
740 |
✓✓ | 82503 |
for (i = 0; i < ctx->slice_count; i++) |
741 |
81030 |
error += ctx->slices[i].ret < 0; |
|
742 |
|||
743 |
✗✓ | 1473 |
if (error) |
744 |
ctx->frame->decode_error_flags = FF_DECODE_ERROR_INVALID_BITSTREAM; |
||
745 |
✓✗ | 1473 |
if (error < ctx->slice_count) |
746 |
1473 |
return 0; |
|
747 |
|||
748 |
return ctx->slices[0].ret; |
||
749 |
} |
||
750 |
|||
751 |
1046 |
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, |
|
752 |
AVPacket *avpkt) |
||
753 |
{ |
||
754 |
1046 |
ProresContext *ctx = avctx->priv_data; |
|
755 |
1046 |
ThreadFrame tframe = { .f = data }; |
|
756 |
1046 |
AVFrame *frame = data; |
|
757 |
1046 |
const uint8_t *buf = avpkt->data; |
|
758 |
1046 |
int buf_size = avpkt->size; |
|
759 |
int frame_hdr_size, pic_size, ret; |
||
760 |
|||
761 |
✓✗✗✓ |
1046 |
if (buf_size < 28 || AV_RL32(buf + 4) != AV_RL32("icpf")) { |
762 |
av_log(avctx, AV_LOG_ERROR, "invalid frame header\n"); |
||
763 |
return AVERROR_INVALIDDATA; |
||
764 |
} |
||
765 |
|||
766 |
1046 |
ctx->frame = frame; |
|
767 |
1046 |
ctx->frame->pict_type = AV_PICTURE_TYPE_I; |
|
768 |
1046 |
ctx->frame->key_frame = 1; |
|
769 |
1046 |
ctx->first_field = 1; |
|
770 |
|||
771 |
1046 |
buf += 8; |
|
772 |
1046 |
buf_size -= 8; |
|
773 |
|||
774 |
1046 |
frame_hdr_size = decode_frame_header(ctx, buf, buf_size, avctx); |
|
775 |
✗✓ | 1046 |
if (frame_hdr_size < 0) |
776 |
return frame_hdr_size; |
||
777 |
|||
778 |
1046 |
buf += frame_hdr_size; |
|
779 |
1046 |
buf_size -= frame_hdr_size; |
|
780 |
|||
781 |
1473 |
decode_picture: |
|
782 |
1473 |
pic_size = decode_picture_header(avctx, buf, buf_size); |
|
783 |
✗✓ | 1473 |
if (pic_size < 0) { |
784 |
av_log(avctx, AV_LOG_ERROR, "error decoding picture header\n"); |
||
785 |
return pic_size; |
||
786 |
} |
||
787 |
|||
788 |
✓✓ | 1473 |
if (ctx->first_field) |
789 |
✗✓ | 1046 |
if ((ret = ff_thread_get_buffer(avctx, &tframe, 0)) < 0) |
790 |
return ret; |
||
791 |
|||
792 |
✗✓ | 1473 |
if ((ret = decode_picture(avctx)) < 0) { |
793 |
av_log(avctx, AV_LOG_ERROR, "error decoding picture\n"); |
||
794 |
return ret; |
||
795 |
} |
||
796 |
|||
797 |
1473 |
buf += pic_size; |
|
798 |
1473 |
buf_size -= pic_size; |
|
799 |
|||
800 |
✓✓✓✓ ✓✓ |
1473 |
if (ctx->frame_type && buf_size > 0 && ctx->first_field) { |
801 |
427 |
ctx->first_field = 0; |
|
802 |
427 |
goto decode_picture; |
|
803 |
} |
||
804 |
|||
805 |
1046 |
*got_frame = 1; |
|
806 |
|||
807 |
1046 |
return avpkt->size; |
|
808 |
} |
||
809 |
|||
810 |
#if HAVE_THREADS |
||
811 |
static int decode_init_thread_copy(AVCodecContext *avctx) |
||
812 |
{ |
||
813 |
ProresContext *ctx = avctx->priv_data; |
||
814 |
|||
815 |
ctx->slices = NULL; |
||
816 |
|||
817 |
return 0; |
||
818 |
} |
||
819 |
#endif |
||
820 |
|||
821 |
59 |
static av_cold int decode_close(AVCodecContext *avctx) |
|
822 |
{ |
||
823 |
59 |
ProresContext *ctx = avctx->priv_data; |
|
824 |
|||
825 |
59 |
av_freep(&ctx->slices); |
|
826 |
|||
827 |
59 |
return 0; |
|
828 |
} |
||
829 |
|||
830 |
AVCodec ff_prores_decoder = { |
||
831 |
.name = "prores", |
||
832 |
.long_name = NULL_IF_CONFIG_SMALL("ProRes (iCodec Pro)"), |
||
833 |
.type = AVMEDIA_TYPE_VIDEO, |
||
834 |
.id = AV_CODEC_ID_PRORES, |
||
835 |
.priv_data_size = sizeof(ProresContext), |
||
836 |
.init = decode_init, |
||
837 |
.init_thread_copy = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy), |
||
838 |
.close = decode_close, |
||
839 |
.decode = decode_frame, |
||
840 |
.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS, |
||
841 |
.profiles = NULL_IF_CONFIG_SMALL(ff_prores_profiles), |
||
842 |
}; |
| Generated by: GCOVR (Version 4.1) |