blob: 1a5076717126f4dd6baa0275089f3f5bad7ec062
1 | /* |
2 | * FFV1 decoder |
3 | * |
4 | * Copyright (c) 2003-2013 Michael Niedermayer <michaelni@gmx.at> |
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 | * FF Video Codec 1 (a lossless codec) decoder |
26 | */ |
27 | |
28 | #include "libavutil/avassert.h" |
29 | #include "libavutil/crc.h" |
30 | #include "libavutil/opt.h" |
31 | #include "libavutil/imgutils.h" |
32 | #include "libavutil/pixdesc.h" |
33 | #include "libavutil/timer.h" |
34 | #include "avcodec.h" |
35 | #include "internal.h" |
36 | #include "get_bits.h" |
37 | #include "rangecoder.h" |
38 | #include "golomb.h" |
39 | #include "mathops.h" |
40 | #include "ffv1.h" |
41 | |
42 | static inline av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state, |
43 | int is_signed) |
44 | { |
45 | if (get_rac(c, state + 0)) |
46 | return 0; |
47 | else { |
48 | int i, e, a; |
49 | e = 0; |
50 | while (get_rac(c, state + 1 + FFMIN(e, 9))) { // 1..10 |
51 | e++; |
52 | if (e > 31) |
53 | return AVERROR_INVALIDDATA; |
54 | } |
55 | |
56 | a = 1; |
57 | for (i = e - 1; i >= 0; i--) |
58 | a += a + get_rac(c, state + 22 + FFMIN(i, 9)); // 22..31 |
59 | |
60 | e = -(is_signed && get_rac(c, state + 11 + FFMIN(e, 10))); // 11..21 |
61 | return (a ^ e) - e; |
62 | } |
63 | } |
64 | |
65 | static av_noinline int get_symbol(RangeCoder *c, uint8_t *state, int is_signed) |
66 | { |
67 | return get_symbol_inline(c, state, is_signed); |
68 | } |
69 | |
70 | static inline int get_vlc_symbol(GetBitContext *gb, VlcState *const state, |
71 | int bits) |
72 | { |
73 | int k, i, v, ret; |
74 | |
75 | i = state->count; |
76 | k = 0; |
77 | while (i < state->error_sum) { // FIXME: optimize |
78 | k++; |
79 | i += i; |
80 | } |
81 | |
82 | v = get_sr_golomb(gb, k, 12, bits); |
83 | ff_dlog(NULL, "v:%d bias:%d error:%d drift:%d count:%d k:%d", |
84 | v, state->bias, state->error_sum, state->drift, state->count, k); |
85 | |
86 | v ^= ((2 * state->drift + state->count) >> 31); |
87 | |
88 | ret = fold(v + state->bias, bits); |
89 | |
90 | update_vlc_state(state, v); |
91 | |
92 | return ret; |
93 | } |
94 | |
95 | #define TYPE int16_t |
96 | #define RENAME(name) name |
97 | #include "ffv1dec_template.c" |
98 | #undef TYPE |
99 | #undef RENAME |
100 | |
101 | #define TYPE int32_t |
102 | #define RENAME(name) name ## 32 |
103 | #include "ffv1dec_template.c" |
104 | |
105 | static void decode_plane(FFV1Context *s, uint8_t *src, |
106 | int w, int h, int stride, int plane_index, |
107 | int pixel_stride) |
108 | { |
109 | int x, y; |
110 | int16_t *sample[2]; |
111 | sample[0] = s->sample_buffer + 3; |
112 | sample[1] = s->sample_buffer + w + 6 + 3; |
113 | |
114 | s->run_index = 0; |
115 | |
116 | memset(s->sample_buffer, 0, 2 * (w + 6) * sizeof(*s->sample_buffer)); |
117 | |
118 | for (y = 0; y < h; y++) { |
119 | int16_t *temp = sample[0]; // FIXME: try a normal buffer |
120 | |
121 | sample[0] = sample[1]; |
122 | sample[1] = temp; |
123 | |
124 | sample[1][-1] = sample[0][0]; |
125 | sample[0][w] = sample[0][w - 1]; |
126 | |
127 | // { START_TIMER |
128 | if (s->avctx->bits_per_raw_sample <= 8) { |
129 | decode_line(s, w, sample, plane_index, 8); |
130 | for (x = 0; x < w; x++) |
131 | src[x*pixel_stride + stride * y] = sample[1][x]; |
132 | } else { |
133 | decode_line(s, w, sample, plane_index, s->avctx->bits_per_raw_sample); |
134 | if (s->packed_at_lsb) { |
135 | for (x = 0; x < w; x++) { |
136 | ((uint16_t*)(src + stride*y))[x*pixel_stride] = sample[1][x]; |
137 | } |
138 | } else { |
139 | for (x = 0; x < w; x++) { |
140 | ((uint16_t*)(src + stride*y))[x*pixel_stride] = sample[1][x] << (16 - s->avctx->bits_per_raw_sample) | ((uint16_t **)sample)[1][x] >> (2 * s->avctx->bits_per_raw_sample - 16); |
141 | } |
142 | } |
143 | } |
144 | // STOP_TIMER("decode-line") } |
145 | } |
146 | } |
147 | |
148 | static int decode_slice_header(FFV1Context *f, FFV1Context *fs) |
149 | { |
150 | RangeCoder *c = &fs->c; |
151 | uint8_t state[CONTEXT_SIZE]; |
152 | unsigned ps, i, context_count; |
153 | memset(state, 128, sizeof(state)); |
154 | |
155 | av_assert0(f->version > 2); |
156 | |
157 | fs->slice_x = get_symbol(c, state, 0) * f->width ; |
158 | fs->slice_y = get_symbol(c, state, 0) * f->height; |
159 | fs->slice_width = (get_symbol(c, state, 0) + 1) * f->width + fs->slice_x; |
160 | fs->slice_height = (get_symbol(c, state, 0) + 1) * f->height + fs->slice_y; |
161 | |
162 | fs->slice_x /= f->num_h_slices; |
163 | fs->slice_y /= f->num_v_slices; |
164 | fs->slice_width = fs->slice_width /f->num_h_slices - fs->slice_x; |
165 | fs->slice_height = fs->slice_height/f->num_v_slices - fs->slice_y; |
166 | if ((unsigned)fs->slice_width > f->width || (unsigned)fs->slice_height > f->height) |
167 | return -1; |
168 | if ( (unsigned)fs->slice_x + (uint64_t)fs->slice_width > f->width |
169 | || (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height) |
170 | return -1; |
171 | |
172 | for (i = 0; i < f->plane_count; i++) { |
173 | PlaneContext * const p = &fs->plane[i]; |
174 | int idx = get_symbol(c, state, 0); |
175 | if (idx >= (unsigned)f->quant_table_count) { |
176 | av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n"); |
177 | return -1; |
178 | } |
179 | p->quant_table_index = idx; |
180 | memcpy(p->quant_table, f->quant_tables[idx], sizeof(p->quant_table)); |
181 | context_count = f->context_count[idx]; |
182 | |
183 | if (p->context_count < context_count) { |
184 | av_freep(&p->state); |
185 | av_freep(&p->vlc_state); |
186 | } |
187 | p->context_count = context_count; |
188 | } |
189 | |
190 | ps = get_symbol(c, state, 0); |
191 | if (ps == 1) { |
192 | f->cur->interlaced_frame = 1; |
193 | f->cur->top_field_first = 1; |
194 | } else if (ps == 2) { |
195 | f->cur->interlaced_frame = 1; |
196 | f->cur->top_field_first = 0; |
197 | } else if (ps == 3) { |
198 | f->cur->interlaced_frame = 0; |
199 | } |
200 | f->cur->sample_aspect_ratio.num = get_symbol(c, state, 0); |
201 | f->cur->sample_aspect_ratio.den = get_symbol(c, state, 0); |
202 | |
203 | if (av_image_check_sar(f->width, f->height, |
204 | f->cur->sample_aspect_ratio) < 0) { |
205 | av_log(f->avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n", |
206 | f->cur->sample_aspect_ratio.num, |
207 | f->cur->sample_aspect_ratio.den); |
208 | f->cur->sample_aspect_ratio = (AVRational){ 0, 1 }; |
209 | } |
210 | |
211 | if (fs->version > 3) { |
212 | fs->slice_reset_contexts = get_rac(c, state); |
213 | fs->slice_coding_mode = get_symbol(c, state, 0); |
214 | if (fs->slice_coding_mode != 1) { |
215 | fs->slice_rct_by_coef = get_symbol(c, state, 0); |
216 | fs->slice_rct_ry_coef = get_symbol(c, state, 0); |
217 | if ((uint64_t)fs->slice_rct_by_coef + (uint64_t)fs->slice_rct_ry_coef > 4) { |
218 | av_log(f->avctx, AV_LOG_ERROR, "slice_rct_y_coef out of range\n"); |
219 | return AVERROR_INVALIDDATA; |
220 | } |
221 | } |
222 | } |
223 | |
224 | return 0; |
225 | } |
226 | |
227 | static int decode_slice(AVCodecContext *c, void *arg) |
228 | { |
229 | FFV1Context *fs = *(void **)arg; |
230 | FFV1Context *f = fs->avctx->priv_data; |
231 | int width, height, x, y, ret; |
232 | const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step; |
233 | AVFrame * const p = f->cur; |
234 | int i, si; |
235 | |
236 | for( si=0; fs != f->slice_context[si]; si ++) |
237 | ; |
238 | |
239 | if(f->fsrc && !p->key_frame) |
240 | ff_thread_await_progress(&f->last_picture, si, 0); |
241 | |
242 | if(f->fsrc && !p->key_frame) { |
243 | FFV1Context *fssrc = f->fsrc->slice_context[si]; |
244 | FFV1Context *fsdst = f->slice_context[si]; |
245 | av_assert1(fsdst->plane_count == fssrc->plane_count); |
246 | av_assert1(fsdst == fs); |
247 | |
248 | if (!p->key_frame) |
249 | fsdst->slice_damaged |= fssrc->slice_damaged; |
250 | |
251 | for (i = 0; i < f->plane_count; i++) { |
252 | PlaneContext *psrc = &fssrc->plane[i]; |
253 | PlaneContext *pdst = &fsdst->plane[i]; |
254 | |
255 | av_free(pdst->state); |
256 | av_free(pdst->vlc_state); |
257 | memcpy(pdst, psrc, sizeof(*pdst)); |
258 | pdst->state = NULL; |
259 | pdst->vlc_state = NULL; |
260 | |
261 | if (fssrc->ac) { |
262 | pdst->state = av_malloc_array(CONTEXT_SIZE, psrc->context_count); |
263 | memcpy(pdst->state, psrc->state, CONTEXT_SIZE * psrc->context_count); |
264 | } else { |
265 | pdst->vlc_state = av_malloc_array(sizeof(*pdst->vlc_state), psrc->context_count); |
266 | memcpy(pdst->vlc_state, psrc->vlc_state, sizeof(*pdst->vlc_state) * psrc->context_count); |
267 | } |
268 | } |
269 | } |
270 | |
271 | fs->slice_rct_by_coef = 1; |
272 | fs->slice_rct_ry_coef = 1; |
273 | |
274 | if (f->version > 2) { |
275 | if (ff_ffv1_init_slice_state(f, fs) < 0) |
276 | return AVERROR(ENOMEM); |
277 | if (decode_slice_header(f, fs) < 0) { |
278 | fs->slice_x = fs->slice_y = fs->slice_height = fs->slice_width = 0; |
279 | fs->slice_damaged = 1; |
280 | return AVERROR_INVALIDDATA; |
281 | } |
282 | } |
283 | if ((ret = ff_ffv1_init_slice_state(f, fs)) < 0) |
284 | return ret; |
285 | if (f->cur->key_frame || fs->slice_reset_contexts) |
286 | ff_ffv1_clear_slice_state(f, fs); |
287 | |
288 | width = fs->slice_width; |
289 | height = fs->slice_height; |
290 | x = fs->slice_x; |
291 | y = fs->slice_y; |
292 | |
293 | if (fs->ac == AC_GOLOMB_RICE) { |
294 | if (f->version == 3 && f->micro_version > 1 || f->version > 3) |
295 | get_rac(&fs->c, (uint8_t[]) { 129 }); |
296 | fs->ac_byte_count = f->version > 2 || (!x && !y) ? fs->c.bytestream - fs->c.bytestream_start - 1 : 0; |
297 | init_get_bits(&fs->gb, |
298 | fs->c.bytestream_start + fs->ac_byte_count, |
299 | (fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count) * 8); |
300 | } |
301 | |
302 | av_assert1(width && height); |
303 | if (f->colorspace == 0 && (f->chroma_planes || !fs->transparency)) { |
304 | const int chroma_width = AV_CEIL_RSHIFT(width, f->chroma_h_shift); |
305 | const int chroma_height = AV_CEIL_RSHIFT(height, f->chroma_v_shift); |
306 | const int cx = x >> f->chroma_h_shift; |
307 | const int cy = y >> f->chroma_v_shift; |
308 | decode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0, 1); |
309 | |
310 | if (f->chroma_planes) { |
311 | decode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1, 1); |
312 | decode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1, 1); |
313 | } |
314 | if (fs->transparency) |
315 | decode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], (f->version >= 4 && !f->chroma_planes) ? 1 : 2, 1); |
316 | } else if (f->colorspace == 0) { |
317 | decode_plane(fs, p->data[0] + ps*x + y*p->linesize[0] , width, height, p->linesize[0], 0, 2); |
318 | decode_plane(fs, p->data[0] + ps*x + y*p->linesize[0] + 1, width, height, p->linesize[0], 1, 2); |
319 | } else if (f->use32bit) { |
320 | uint8_t *planes[3] = { p->data[0] + ps * x + y * p->linesize[0], |
321 | p->data[1] + ps * x + y * p->linesize[1], |
322 | p->data[2] + ps * x + y * p->linesize[2] }; |
323 | decode_rgb_frame32(fs, planes, width, height, p->linesize); |
324 | } else { |
325 | uint8_t *planes[3] = { p->data[0] + ps * x + y * p->linesize[0], |
326 | p->data[1] + ps * x + y * p->linesize[1], |
327 | p->data[2] + ps * x + y * p->linesize[2] }; |
328 | decode_rgb_frame(fs, planes, width, height, p->linesize); |
329 | } |
330 | if (fs->ac != AC_GOLOMB_RICE && f->version > 2) { |
331 | int v; |
332 | get_rac(&fs->c, (uint8_t[]) { 129 }); |
333 | v = fs->c.bytestream_end - fs->c.bytestream - 2 - 5*f->ec; |
334 | if (v) { |
335 | av_log(f->avctx, AV_LOG_ERROR, "bytestream end mismatching by %d\n", v); |
336 | fs->slice_damaged = 1; |
337 | } |
338 | } |
339 | |
340 | emms_c(); |
341 | |
342 | ff_thread_report_progress(&f->picture, si, 0); |
343 | |
344 | return 0; |
345 | } |
346 | |
347 | static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale) |
348 | { |
349 | int v; |
350 | int i = 0; |
351 | uint8_t state[CONTEXT_SIZE]; |
352 | |
353 | memset(state, 128, sizeof(state)); |
354 | |
355 | for (v = 0; i < 128; v++) { |
356 | unsigned len = get_symbol(c, state, 0) + 1; |
357 | |
358 | if (len > 128 - i || !len) |
359 | return AVERROR_INVALIDDATA; |
360 | |
361 | while (len--) { |
362 | quant_table[i] = scale * v; |
363 | i++; |
364 | } |
365 | } |
366 | |
367 | for (i = 1; i < 128; i++) |
368 | quant_table[256 - i] = -quant_table[i]; |
369 | quant_table[128] = -quant_table[127]; |
370 | |
371 | return 2 * v - 1; |
372 | } |
373 | |
374 | static int read_quant_tables(RangeCoder *c, |
375 | int16_t quant_table[MAX_CONTEXT_INPUTS][256]) |
376 | { |
377 | int i; |
378 | int context_count = 1; |
379 | |
380 | for (i = 0; i < 5; i++) { |
381 | int ret = read_quant_table(c, quant_table[i], context_count); |
382 | if (ret < 0) |
383 | return ret; |
384 | context_count *= ret; |
385 | if (context_count > 32768U) { |
386 | return AVERROR_INVALIDDATA; |
387 | } |
388 | } |
389 | return (context_count + 1) / 2; |
390 | } |
391 | |
392 | static int read_extra_header(FFV1Context *f) |
393 | { |
394 | RangeCoder *const c = &f->c; |
395 | uint8_t state[CONTEXT_SIZE]; |
396 | int i, j, k, ret; |
397 | uint8_t state2[32][CONTEXT_SIZE]; |
398 | unsigned crc = 0; |
399 | |
400 | memset(state2, 128, sizeof(state2)); |
401 | memset(state, 128, sizeof(state)); |
402 | |
403 | ff_init_range_decoder(c, f->avctx->extradata, f->avctx->extradata_size); |
404 | ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8); |
405 | |
406 | f->version = get_symbol(c, state, 0); |
407 | if (f->version < 2) { |
408 | av_log(f->avctx, AV_LOG_ERROR, "Invalid version in global header\n"); |
409 | return AVERROR_INVALIDDATA; |
410 | } |
411 | if (f->version > 2) { |
412 | c->bytestream_end -= 4; |
413 | f->micro_version = get_symbol(c, state, 0); |
414 | if (f->micro_version < 0) |
415 | return AVERROR_INVALIDDATA; |
416 | } |
417 | f->ac = get_symbol(c, state, 0); |
418 | |
419 | if (f->ac == AC_RANGE_CUSTOM_TAB) { |
420 | for (i = 1; i < 256; i++) |
421 | f->state_transition[i] = get_symbol(c, state, 1) + c->one_state[i]; |
422 | } |
423 | |
424 | f->colorspace = get_symbol(c, state, 0); //YUV cs type |
425 | f->avctx->bits_per_raw_sample = get_symbol(c, state, 0); |
426 | f->chroma_planes = get_rac(c, state); |
427 | f->chroma_h_shift = get_symbol(c, state, 0); |
428 | f->chroma_v_shift = get_symbol(c, state, 0); |
429 | f->transparency = get_rac(c, state); |
430 | f->plane_count = 1 + (f->chroma_planes || f->version<4) + f->transparency; |
431 | f->num_h_slices = 1 + get_symbol(c, state, 0); |
432 | f->num_v_slices = 1 + get_symbol(c, state, 0); |
433 | |
434 | if (f->chroma_h_shift > 4U || f->chroma_v_shift > 4U) { |
435 | av_log(f->avctx, AV_LOG_ERROR, "chroma shift parameters %d %d are invalid\n", |
436 | f->chroma_h_shift, f->chroma_v_shift); |
437 | return AVERROR_INVALIDDATA; |
438 | } |
439 | |
440 | if (f->num_h_slices > (unsigned)f->width || !f->num_h_slices || |
441 | f->num_v_slices > (unsigned)f->height || !f->num_v_slices |
442 | ) { |
443 | av_log(f->avctx, AV_LOG_ERROR, "slice count invalid\n"); |
444 | return AVERROR_INVALIDDATA; |
445 | } |
446 | |
447 | f->quant_table_count = get_symbol(c, state, 0); |
448 | if (f->quant_table_count > (unsigned)MAX_QUANT_TABLES || !f->quant_table_count) { |
449 | av_log(f->avctx, AV_LOG_ERROR, "quant table count %d is invalid\n", f->quant_table_count); |
450 | f->quant_table_count = 0; |
451 | return AVERROR_INVALIDDATA; |
452 | } |
453 | |
454 | for (i = 0; i < f->quant_table_count; i++) { |
455 | f->context_count[i] = read_quant_tables(c, f->quant_tables[i]); |
456 | if (f->context_count[i] < 0) { |
457 | av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n"); |
458 | return AVERROR_INVALIDDATA; |
459 | } |
460 | } |
461 | if ((ret = ff_ffv1_allocate_initial_states(f)) < 0) |
462 | return ret; |
463 | |
464 | for (i = 0; i < f->quant_table_count; i++) |
465 | if (get_rac(c, state)) { |
466 | for (j = 0; j < f->context_count[i]; j++) |
467 | for (k = 0; k < CONTEXT_SIZE; k++) { |
468 | int pred = j ? f->initial_states[i][j - 1][k] : 128; |
469 | f->initial_states[i][j][k] = |
470 | (pred + get_symbol(c, state2[k], 1)) & 0xFF; |
471 | } |
472 | } |
473 | |
474 | if (f->version > 2) { |
475 | f->ec = get_symbol(c, state, 0); |
476 | if (f->micro_version > 2) |
477 | f->intra = get_symbol(c, state, 0); |
478 | } |
479 | |
480 | if (f->version > 2) { |
481 | unsigned v; |
482 | v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, |
483 | f->avctx->extradata, f->avctx->extradata_size); |
484 | if (v || f->avctx->extradata_size < 4) { |
485 | av_log(f->avctx, AV_LOG_ERROR, "CRC mismatch %X!\n", v); |
486 | return AVERROR_INVALIDDATA; |
487 | } |
488 | crc = AV_RB32(f->avctx->extradata + f->avctx->extradata_size - 4); |
489 | } |
490 | |
491 | if (f->avctx->debug & FF_DEBUG_PICT_INFO) |
492 | av_log(f->avctx, AV_LOG_DEBUG, |
493 | "global: ver:%d.%d, coder:%d, colorspace: %d bpr:%d chroma:%d(%d:%d), alpha:%d slices:%dx%d qtabs:%d ec:%d intra:%d CRC:0x%08X\n", |
494 | f->version, f->micro_version, |
495 | f->ac, |
496 | f->colorspace, |
497 | f->avctx->bits_per_raw_sample, |
498 | f->chroma_planes, f->chroma_h_shift, f->chroma_v_shift, |
499 | f->transparency, |
500 | f->num_h_slices, f->num_v_slices, |
501 | f->quant_table_count, |
502 | f->ec, |
503 | f->intra, |
504 | crc |
505 | ); |
506 | return 0; |
507 | } |
508 | |
509 | static int read_header(FFV1Context *f) |
510 | { |
511 | uint8_t state[CONTEXT_SIZE]; |
512 | int i, j, context_count = -1; //-1 to avoid warning |
513 | RangeCoder *const c = &f->slice_context[0]->c; |
514 | |
515 | memset(state, 128, sizeof(state)); |
516 | |
517 | if (f->version < 2) { |
518 | int chroma_planes, chroma_h_shift, chroma_v_shift, transparency, colorspace, bits_per_raw_sample; |
519 | unsigned v= get_symbol(c, state, 0); |
520 | if (v >= 2) { |
521 | av_log(f->avctx, AV_LOG_ERROR, "invalid version %d in ver01 header\n", v); |
522 | return AVERROR_INVALIDDATA; |
523 | } |
524 | f->version = v; |
525 | f->ac = get_symbol(c, state, 0); |
526 | |
527 | if (f->ac == AC_RANGE_CUSTOM_TAB) { |
528 | for (i = 1; i < 256; i++) |
529 | f->state_transition[i] = get_symbol(c, state, 1) + c->one_state[i]; |
530 | } |
531 | |
532 | colorspace = get_symbol(c, state, 0); //YUV cs type |
533 | bits_per_raw_sample = f->version > 0 ? get_symbol(c, state, 0) : f->avctx->bits_per_raw_sample; |
534 | chroma_planes = get_rac(c, state); |
535 | chroma_h_shift = get_symbol(c, state, 0); |
536 | chroma_v_shift = get_symbol(c, state, 0); |
537 | transparency = get_rac(c, state); |
538 | if (colorspace == 0 && f->avctx->skip_alpha) |
539 | transparency = 0; |
540 | |
541 | if (f->plane_count) { |
542 | if (colorspace != f->colorspace || |
543 | bits_per_raw_sample != f->avctx->bits_per_raw_sample || |
544 | chroma_planes != f->chroma_planes || |
545 | chroma_h_shift != f->chroma_h_shift || |
546 | chroma_v_shift != f->chroma_v_shift || |
547 | transparency != f->transparency) { |
548 | av_log(f->avctx, AV_LOG_ERROR, "Invalid change of global parameters\n"); |
549 | return AVERROR_INVALIDDATA; |
550 | } |
551 | } |
552 | |
553 | if (chroma_h_shift > 4U || chroma_v_shift > 4U) { |
554 | av_log(f->avctx, AV_LOG_ERROR, "chroma shift parameters %d %d are invalid\n", |
555 | chroma_h_shift, chroma_v_shift); |
556 | return AVERROR_INVALIDDATA; |
557 | } |
558 | |
559 | f->colorspace = colorspace; |
560 | f->avctx->bits_per_raw_sample = bits_per_raw_sample; |
561 | f->chroma_planes = chroma_planes; |
562 | f->chroma_h_shift = chroma_h_shift; |
563 | f->chroma_v_shift = chroma_v_shift; |
564 | f->transparency = transparency; |
565 | |
566 | f->plane_count = 2 + f->transparency; |
567 | } |
568 | |
569 | if (f->colorspace == 0) { |
570 | if (!f->transparency && !f->chroma_planes) { |
571 | if (f->avctx->bits_per_raw_sample <= 8) |
572 | f->avctx->pix_fmt = AV_PIX_FMT_GRAY8; |
573 | else if (f->avctx->bits_per_raw_sample == 10) { |
574 | f->packed_at_lsb = 1; |
575 | f->avctx->pix_fmt = AV_PIX_FMT_GRAY10; |
576 | } else if (f->avctx->bits_per_raw_sample == 12) { |
577 | f->packed_at_lsb = 1; |
578 | f->avctx->pix_fmt = AV_PIX_FMT_GRAY12; |
579 | } else if (f->avctx->bits_per_raw_sample == 16) { |
580 | f->packed_at_lsb = 1; |
581 | f->avctx->pix_fmt = AV_PIX_FMT_GRAY16; |
582 | } else if (f->avctx->bits_per_raw_sample < 16) { |
583 | f->avctx->pix_fmt = AV_PIX_FMT_GRAY16; |
584 | } else |
585 | return AVERROR(ENOSYS); |
586 | } else if (f->transparency && !f->chroma_planes) { |
587 | if (f->avctx->bits_per_raw_sample <= 8) |
588 | f->avctx->pix_fmt = AV_PIX_FMT_YA8; |
589 | else |
590 | return AVERROR(ENOSYS); |
591 | } else if (f->avctx->bits_per_raw_sample<=8 && !f->transparency) { |
592 | switch(16 * f->chroma_h_shift + f->chroma_v_shift) { |
593 | case 0x00: f->avctx->pix_fmt = AV_PIX_FMT_YUV444P; break; |
594 | case 0x01: f->avctx->pix_fmt = AV_PIX_FMT_YUV440P; break; |
595 | case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUV422P; break; |
596 | case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUV420P; break; |
597 | case 0x20: f->avctx->pix_fmt = AV_PIX_FMT_YUV411P; break; |
598 | case 0x22: f->avctx->pix_fmt = AV_PIX_FMT_YUV410P; break; |
599 | } |
600 | } else if (f->avctx->bits_per_raw_sample <= 8 && f->transparency) { |
601 | switch(16*f->chroma_h_shift + f->chroma_v_shift) { |
602 | case 0x00: f->avctx->pix_fmt = AV_PIX_FMT_YUVA444P; break; |
603 | case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUVA422P; break; |
604 | case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUVA420P; break; |
605 | } |
606 | } else if (f->avctx->bits_per_raw_sample == 9 && !f->transparency) { |
607 | f->packed_at_lsb = 1; |
608 | switch(16 * f->chroma_h_shift + f->chroma_v_shift) { |
609 | case 0x00: f->avctx->pix_fmt = AV_PIX_FMT_YUV444P9; break; |
610 | case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUV422P9; break; |
611 | case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUV420P9; break; |
612 | } |
613 | } else if (f->avctx->bits_per_raw_sample == 9 && f->transparency) { |
614 | f->packed_at_lsb = 1; |
615 | switch(16 * f->chroma_h_shift + f->chroma_v_shift) { |
616 | case 0x00: f->avctx->pix_fmt = AV_PIX_FMT_YUVA444P9; break; |
617 | case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUVA422P9; break; |
618 | case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUVA420P9; break; |
619 | } |
620 | } else if (f->avctx->bits_per_raw_sample == 10 && !f->transparency) { |
621 | f->packed_at_lsb = 1; |
622 | switch(16 * f->chroma_h_shift + f->chroma_v_shift) { |
623 | case 0x00: f->avctx->pix_fmt = AV_PIX_FMT_YUV444P10; break; |
624 | case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUV422P10; break; |
625 | case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUV420P10; break; |
626 | } |
627 | } else if (f->avctx->bits_per_raw_sample == 10 && f->transparency) { |
628 | f->packed_at_lsb = 1; |
629 | switch(16 * f->chroma_h_shift + f->chroma_v_shift) { |
630 | case 0x00: f->avctx->pix_fmt = AV_PIX_FMT_YUVA444P10; break; |
631 | case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUVA422P10; break; |
632 | case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUVA420P10; break; |
633 | } |
634 | } else if (f->avctx->bits_per_raw_sample == 12 && !f->transparency) { |
635 | f->packed_at_lsb = 1; |
636 | switch(16 * f->chroma_h_shift + f->chroma_v_shift) { |
637 | case 0x00: f->avctx->pix_fmt = AV_PIX_FMT_YUV444P12; break; |
638 | case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUV422P12; break; |
639 | case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUV420P12; break; |
640 | } |
641 | } else if (f->avctx->bits_per_raw_sample == 16 && !f->transparency){ |
642 | f->packed_at_lsb = 1; |
643 | switch(16 * f->chroma_h_shift + f->chroma_v_shift) { |
644 | case 0x00: f->avctx->pix_fmt = AV_PIX_FMT_YUV444P16; break; |
645 | case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUV422P16; break; |
646 | case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUV420P16; break; |
647 | } |
648 | } else if (f->avctx->bits_per_raw_sample == 16 && f->transparency){ |
649 | f->packed_at_lsb = 1; |
650 | switch(16 * f->chroma_h_shift + f->chroma_v_shift) { |
651 | case 0x00: f->avctx->pix_fmt = AV_PIX_FMT_YUVA444P16; break; |
652 | case 0x10: f->avctx->pix_fmt = AV_PIX_FMT_YUVA422P16; break; |
653 | case 0x11: f->avctx->pix_fmt = AV_PIX_FMT_YUVA420P16; break; |
654 | } |
655 | } |
656 | } else if (f->colorspace == 1) { |
657 | if (f->chroma_h_shift || f->chroma_v_shift) { |
658 | av_log(f->avctx, AV_LOG_ERROR, |
659 | "chroma subsampling not supported in this colorspace\n"); |
660 | return AVERROR(ENOSYS); |
661 | } |
662 | if ( f->avctx->bits_per_raw_sample <= 8 && !f->transparency) |
663 | f->avctx->pix_fmt = AV_PIX_FMT_0RGB32; |
664 | else if (f->avctx->bits_per_raw_sample <= 8 && f->transparency) |
665 | f->avctx->pix_fmt = AV_PIX_FMT_RGB32; |
666 | else if (f->avctx->bits_per_raw_sample == 9 && !f->transparency) |
667 | f->avctx->pix_fmt = AV_PIX_FMT_GBRP9; |
668 | else if (f->avctx->bits_per_raw_sample == 10 && !f->transparency) |
669 | f->avctx->pix_fmt = AV_PIX_FMT_GBRP10; |
670 | else if (f->avctx->bits_per_raw_sample == 12 && !f->transparency) |
671 | f->avctx->pix_fmt = AV_PIX_FMT_GBRP12; |
672 | else if (f->avctx->bits_per_raw_sample == 14 && !f->transparency) |
673 | f->avctx->pix_fmt = AV_PIX_FMT_GBRP14; |
674 | else if (f->avctx->bits_per_raw_sample == 16 && !f->transparency) { |
675 | f->avctx->pix_fmt = AV_PIX_FMT_GBRP16; |
676 | f->use32bit = 1; |
677 | } |
678 | } else { |
679 | av_log(f->avctx, AV_LOG_ERROR, "colorspace not supported\n"); |
680 | return AVERROR(ENOSYS); |
681 | } |
682 | if (f->avctx->pix_fmt == AV_PIX_FMT_NONE) { |
683 | av_log(f->avctx, AV_LOG_ERROR, "format not supported\n"); |
684 | return AVERROR(ENOSYS); |
685 | } |
686 | |
687 | ff_dlog(f->avctx, "%d %d %d\n", |
688 | f->chroma_h_shift, f->chroma_v_shift, f->avctx->pix_fmt); |
689 | if (f->version < 2) { |
690 | context_count = read_quant_tables(c, f->quant_table); |
691 | if (context_count < 0) { |
692 | av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n"); |
693 | return AVERROR_INVALIDDATA; |
694 | } |
695 | f->slice_count = f->max_slice_count; |
696 | } else if (f->version < 3) { |
697 | f->slice_count = get_symbol(c, state, 0); |
698 | } else { |
699 | const uint8_t *p = c->bytestream_end; |
700 | for (f->slice_count = 0; |
701 | f->slice_count < MAX_SLICES && 3 < p - c->bytestream_start; |
702 | f->slice_count++) { |
703 | int trailer = 3 + 5*!!f->ec; |
704 | int size = AV_RB24(p-trailer); |
705 | if (size + trailer > p - c->bytestream_start) |
706 | break; |
707 | p -= size + trailer; |
708 | } |
709 | } |
710 | if (f->slice_count > (unsigned)MAX_SLICES || f->slice_count <= 0 || f->slice_count > f->max_slice_count) { |
711 | av_log(f->avctx, AV_LOG_ERROR, "slice count %d is invalid (max=%d)\n", f->slice_count, f->max_slice_count); |
712 | return AVERROR_INVALIDDATA; |
713 | } |
714 | |
715 | for (j = 0; j < f->slice_count; j++) { |
716 | FFV1Context *fs = f->slice_context[j]; |
717 | fs->ac = f->ac; |
718 | fs->packed_at_lsb = f->packed_at_lsb; |
719 | |
720 | fs->slice_damaged = 0; |
721 | |
722 | if (f->version == 2) { |
723 | fs->slice_x = get_symbol(c, state, 0) * f->width ; |
724 | fs->slice_y = get_symbol(c, state, 0) * f->height; |
725 | fs->slice_width = (get_symbol(c, state, 0) + 1) * f->width + fs->slice_x; |
726 | fs->slice_height = (get_symbol(c, state, 0) + 1) * f->height + fs->slice_y; |
727 | |
728 | fs->slice_x /= f->num_h_slices; |
729 | fs->slice_y /= f->num_v_slices; |
730 | fs->slice_width = fs->slice_width / f->num_h_slices - fs->slice_x; |
731 | fs->slice_height = fs->slice_height / f->num_v_slices - fs->slice_y; |
732 | if ((unsigned)fs->slice_width > f->width || |
733 | (unsigned)fs->slice_height > f->height) |
734 | return AVERROR_INVALIDDATA; |
735 | if ( (unsigned)fs->slice_x + (uint64_t)fs->slice_width > f->width |
736 | || (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height) |
737 | return AVERROR_INVALIDDATA; |
738 | } |
739 | |
740 | for (i = 0; i < f->plane_count; i++) { |
741 | PlaneContext *const p = &fs->plane[i]; |
742 | |
743 | if (f->version == 2) { |
744 | int idx = get_symbol(c, state, 0); |
745 | if (idx > (unsigned)f->quant_table_count) { |
746 | av_log(f->avctx, AV_LOG_ERROR, |
747 | "quant_table_index out of range\n"); |
748 | return AVERROR_INVALIDDATA; |
749 | } |
750 | p->quant_table_index = idx; |
751 | memcpy(p->quant_table, f->quant_tables[idx], |
752 | sizeof(p->quant_table)); |
753 | context_count = f->context_count[idx]; |
754 | } else { |
755 | memcpy(p->quant_table, f->quant_table, sizeof(p->quant_table)); |
756 | } |
757 | |
758 | if (f->version <= 2) { |
759 | av_assert0(context_count >= 0); |
760 | if (p->context_count < context_count) { |
761 | av_freep(&p->state); |
762 | av_freep(&p->vlc_state); |
763 | } |
764 | p->context_count = context_count; |
765 | } |
766 | } |
767 | } |
768 | return 0; |
769 | } |
770 | |
771 | static av_cold int decode_init(AVCodecContext *avctx) |
772 | { |
773 | FFV1Context *f = avctx->priv_data; |
774 | int ret; |
775 | |
776 | if ((ret = ff_ffv1_common_init(avctx)) < 0) |
777 | return ret; |
778 | |
779 | if (avctx->extradata_size > 0 && (ret = read_extra_header(f)) < 0) |
780 | return ret; |
781 | |
782 | if ((ret = ff_ffv1_init_slice_contexts(f)) < 0) |
783 | return ret; |
784 | |
785 | avctx->internal->allocate_progress = 1; |
786 | |
787 | return 0; |
788 | } |
789 | |
790 | static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt) |
791 | { |
792 | uint8_t *buf = avpkt->data; |
793 | int buf_size = avpkt->size; |
794 | FFV1Context *f = avctx->priv_data; |
795 | RangeCoder *const c = &f->slice_context[0]->c; |
796 | int i, ret; |
797 | uint8_t keystate = 128; |
798 | uint8_t *buf_p; |
799 | AVFrame *p; |
800 | |
801 | if (f->last_picture.f) |
802 | ff_thread_release_buffer(avctx, &f->last_picture); |
803 | FFSWAP(ThreadFrame, f->picture, f->last_picture); |
804 | |
805 | f->cur = p = f->picture.f; |
806 | |
807 | if (f->version < 3 && avctx->field_order > AV_FIELD_PROGRESSIVE) { |
808 | /* we have interlaced material flagged in container */ |
809 | p->interlaced_frame = 1; |
810 | if (avctx->field_order == AV_FIELD_TT || avctx->field_order == AV_FIELD_TB) |
811 | p->top_field_first = 1; |
812 | } |
813 | |
814 | f->avctx = avctx; |
815 | ff_init_range_decoder(c, buf, buf_size); |
816 | ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8); |
817 | |
818 | p->pict_type = AV_PICTURE_TYPE_I; //FIXME I vs. P |
819 | if (get_rac(c, &keystate)) { |
820 | p->key_frame = 1; |
821 | f->key_frame_ok = 0; |
822 | if ((ret = read_header(f)) < 0) |
823 | return ret; |
824 | f->key_frame_ok = 1; |
825 | } else { |
826 | if (!f->key_frame_ok) { |
827 | av_log(avctx, AV_LOG_ERROR, |
828 | "Cannot decode non-keyframe without valid keyframe\n"); |
829 | return AVERROR_INVALIDDATA; |
830 | } |
831 | p->key_frame = 0; |
832 | } |
833 | |
834 | if ((ret = ff_thread_get_buffer(avctx, &f->picture, AV_GET_BUFFER_FLAG_REF)) < 0) |
835 | return ret; |
836 | |
837 | if (avctx->debug & FF_DEBUG_PICT_INFO) |
838 | av_log(avctx, AV_LOG_DEBUG, "ver:%d keyframe:%d coder:%d ec:%d slices:%d bps:%d\n", |
839 | f->version, p->key_frame, f->ac, f->ec, f->slice_count, f->avctx->bits_per_raw_sample); |
840 | |
841 | ff_thread_finish_setup(avctx); |
842 | |
843 | buf_p = buf + buf_size; |
844 | for (i = f->slice_count - 1; i >= 0; i--) { |
845 | FFV1Context *fs = f->slice_context[i]; |
846 | int trailer = 3 + 5*!!f->ec; |
847 | int v; |
848 | |
849 | if (i || f->version > 2) v = AV_RB24(buf_p-trailer) + trailer; |
850 | else v = buf_p - c->bytestream_start; |
851 | if (buf_p - c->bytestream_start < v) { |
852 | av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n"); |
853 | ff_thread_report_progress(&f->picture, INT_MAX, 0); |
854 | return AVERROR_INVALIDDATA; |
855 | } |
856 | buf_p -= v; |
857 | |
858 | if (f->ec) { |
859 | unsigned crc = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, v); |
860 | if (crc) { |
861 | int64_t ts = avpkt->pts != AV_NOPTS_VALUE ? avpkt->pts : avpkt->dts; |
862 | av_log(f->avctx, AV_LOG_ERROR, "CRC mismatch %X!", crc); |
863 | if (ts != AV_NOPTS_VALUE && avctx->pkt_timebase.num) { |
864 | av_log(f->avctx, AV_LOG_ERROR, "at %f seconds\n", ts*av_q2d(avctx->pkt_timebase)); |
865 | } else if (ts != AV_NOPTS_VALUE) { |
866 | av_log(f->avctx, AV_LOG_ERROR, "at %"PRId64"\n", ts); |
867 | } else { |
868 | av_log(f->avctx, AV_LOG_ERROR, "\n"); |
869 | } |
870 | fs->slice_damaged = 1; |
871 | } |
872 | if (avctx->debug & FF_DEBUG_PICT_INFO) { |
873 | av_log(avctx, AV_LOG_DEBUG, "slice %d, CRC: 0x%08"PRIX32"\n", i, AV_RB32(buf_p + v - 4)); |
874 | } |
875 | } |
876 | |
877 | if (i) { |
878 | ff_init_range_decoder(&fs->c, buf_p, v); |
879 | } else |
880 | fs->c.bytestream_end = buf_p + v; |
881 | |
882 | fs->avctx = avctx; |
883 | fs->cur = p; |
884 | } |
885 | |
886 | avctx->execute(avctx, |
887 | decode_slice, |
888 | &f->slice_context[0], |
889 | NULL, |
890 | f->slice_count, |
891 | sizeof(void*)); |
892 | |
893 | for (i = f->slice_count - 1; i >= 0; i--) { |
894 | FFV1Context *fs = f->slice_context[i]; |
895 | int j; |
896 | if (fs->slice_damaged && f->last_picture.f->data[0]) { |
897 | const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt); |
898 | const uint8_t *src[4]; |
899 | uint8_t *dst[4]; |
900 | ff_thread_await_progress(&f->last_picture, INT_MAX, 0); |
901 | for (j = 0; j < 4; j++) { |
902 | int pixshift = desc->comp[j].depth > 8; |
903 | int sh = (j == 1 || j == 2) ? f->chroma_h_shift : 0; |
904 | int sv = (j == 1 || j == 2) ? f->chroma_v_shift : 0; |
905 | dst[j] = p->data[j] + p->linesize[j] * |
906 | (fs->slice_y >> sv) + ((fs->slice_x >> sh) << pixshift); |
907 | src[j] = f->last_picture.f->data[j] + f->last_picture.f->linesize[j] * |
908 | (fs->slice_y >> sv) + ((fs->slice_x >> sh) << pixshift); |
909 | } |
910 | av_image_copy(dst, p->linesize, src, |
911 | f->last_picture.f->linesize, |
912 | avctx->pix_fmt, |
913 | fs->slice_width, |
914 | fs->slice_height); |
915 | } |
916 | } |
917 | ff_thread_report_progress(&f->picture, INT_MAX, 0); |
918 | |
919 | f->picture_number++; |
920 | |
921 | if (f->last_picture.f) |
922 | ff_thread_release_buffer(avctx, &f->last_picture); |
923 | f->cur = NULL; |
924 | if ((ret = av_frame_ref(data, f->picture.f)) < 0) |
925 | return ret; |
926 | |
927 | *got_frame = 1; |
928 | |
929 | return buf_size; |
930 | } |
931 | |
932 | #if HAVE_THREADS |
933 | static int init_thread_copy(AVCodecContext *avctx) |
934 | { |
935 | FFV1Context *f = avctx->priv_data; |
936 | int i, ret; |
937 | |
938 | f->picture.f = NULL; |
939 | f->last_picture.f = NULL; |
940 | f->sample_buffer = NULL; |
941 | f->max_slice_count = 0; |
942 | f->slice_count = 0; |
943 | |
944 | for (i = 0; i < f->quant_table_count; i++) { |
945 | av_assert0(f->version > 1); |
946 | f->initial_states[i] = av_memdup(f->initial_states[i], |
947 | f->context_count[i] * sizeof(*f->initial_states[i])); |
948 | } |
949 | |
950 | f->picture.f = av_frame_alloc(); |
951 | f->last_picture.f = av_frame_alloc(); |
952 | |
953 | if ((ret = ff_ffv1_init_slice_contexts(f)) < 0) |
954 | return ret; |
955 | |
956 | return 0; |
957 | } |
958 | #endif |
959 | |
960 | static void copy_fields(FFV1Context *fsdst, FFV1Context *fssrc, FFV1Context *fsrc) |
961 | { |
962 | fsdst->version = fsrc->version; |
963 | fsdst->micro_version = fsrc->micro_version; |
964 | fsdst->chroma_planes = fsrc->chroma_planes; |
965 | fsdst->chroma_h_shift = fsrc->chroma_h_shift; |
966 | fsdst->chroma_v_shift = fsrc->chroma_v_shift; |
967 | fsdst->transparency = fsrc->transparency; |
968 | fsdst->plane_count = fsrc->plane_count; |
969 | fsdst->ac = fsrc->ac; |
970 | fsdst->colorspace = fsrc->colorspace; |
971 | |
972 | fsdst->ec = fsrc->ec; |
973 | fsdst->intra = fsrc->intra; |
974 | fsdst->slice_damaged = fssrc->slice_damaged; |
975 | fsdst->key_frame_ok = fsrc->key_frame_ok; |
976 | |
977 | fsdst->bits_per_raw_sample = fsrc->bits_per_raw_sample; |
978 | fsdst->packed_at_lsb = fsrc->packed_at_lsb; |
979 | fsdst->slice_count = fsrc->slice_count; |
980 | if (fsrc->version<3){ |
981 | fsdst->slice_x = fssrc->slice_x; |
982 | fsdst->slice_y = fssrc->slice_y; |
983 | fsdst->slice_width = fssrc->slice_width; |
984 | fsdst->slice_height = fssrc->slice_height; |
985 | } |
986 | } |
987 | |
988 | #if HAVE_THREADS |
989 | static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src) |
990 | { |
991 | FFV1Context *fsrc = src->priv_data; |
992 | FFV1Context *fdst = dst->priv_data; |
993 | int i, ret; |
994 | |
995 | if (dst == src) |
996 | return 0; |
997 | |
998 | { |
999 | ThreadFrame picture = fdst->picture, last_picture = fdst->last_picture; |
1000 | uint8_t (*initial_states[MAX_QUANT_TABLES])[32]; |
1001 | struct FFV1Context *slice_context[MAX_SLICES]; |
1002 | memcpy(initial_states, fdst->initial_states, sizeof(fdst->initial_states)); |
1003 | memcpy(slice_context, fdst->slice_context , sizeof(fdst->slice_context)); |
1004 | |
1005 | memcpy(fdst, fsrc, sizeof(*fdst)); |
1006 | memcpy(fdst->initial_states, initial_states, sizeof(fdst->initial_states)); |
1007 | memcpy(fdst->slice_context, slice_context , sizeof(fdst->slice_context)); |
1008 | fdst->picture = picture; |
1009 | fdst->last_picture = last_picture; |
1010 | for (i = 0; i<fdst->num_h_slices * fdst->num_v_slices; i++) { |
1011 | FFV1Context *fssrc = fsrc->slice_context[i]; |
1012 | FFV1Context *fsdst = fdst->slice_context[i]; |
1013 | copy_fields(fsdst, fssrc, fsrc); |
1014 | } |
1015 | av_assert0(!fdst->plane[0].state); |
1016 | av_assert0(!fdst->sample_buffer); |
1017 | } |
1018 | |
1019 | av_assert1(fdst->max_slice_count == fsrc->max_slice_count); |
1020 | |
1021 | |
1022 | ff_thread_release_buffer(dst, &fdst->picture); |
1023 | if (fsrc->picture.f->data[0]) { |
1024 | if ((ret = ff_thread_ref_frame(&fdst->picture, &fsrc->picture)) < 0) |
1025 | return ret; |
1026 | } |
1027 | |
1028 | fdst->fsrc = fsrc; |
1029 | |
1030 | return 0; |
1031 | } |
1032 | #endif |
1033 | |
1034 | AVCodec ff_ffv1_decoder = { |
1035 | .name = "ffv1", |
1036 | .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"), |
1037 | .type = AVMEDIA_TYPE_VIDEO, |
1038 | .id = AV_CODEC_ID_FFV1, |
1039 | .priv_data_size = sizeof(FFV1Context), |
1040 | .init = decode_init, |
1041 | .close = ff_ffv1_close, |
1042 | .decode = decode_frame, |
1043 | .init_thread_copy = ONLY_IF_THREADS_ENABLED(init_thread_copy), |
1044 | .update_thread_context = ONLY_IF_THREADS_ENABLED(update_thread_context), |
1045 | .capabilities = AV_CODEC_CAP_DR1 /*| AV_CODEC_CAP_DRAW_HORIZ_BAND*/ | |
1046 | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_SLICE_THREADS, |
1047 | .caps_internal = FF_CODEC_CAP_INIT_CLEANUP |
1048 | }; |
1049 |