1 /*
2 * Microsoft Screen 4 (aka Microsoft Expression Encoder Screen) decoder
3 * Copyright (c) 2012 Konstantin Shishkov
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 * Microsoft Screen 4 (aka Microsoft Titanium Screen 2,
25 * aka Microsoft Expression Encoder Screen) decoder
26 */
27
28 #include "libavutil/thread.h"
29 #include "libavutil/imgutils.h"
30
31 #include "avcodec.h"
32 #include "bytestream.h"
33 #include "codec_internal.h"
34 #include "get_bits.h"
35 #include "internal.h"
36 #include "jpegtables.h"
37 #include "mss34dsp.h"
38 #include "unary.h"
39
40 #define HEADER_SIZE 8
41
42 enum FrameType {
43 INTRA_FRAME = 0,
44 INTER_FRAME,
45 SKIP_FRAME
46 };
47
48 enum BlockType {
49 SKIP_BLOCK = 0,
50 DCT_BLOCK,
51 IMAGE_BLOCK,
52 };
53
54 enum CachePos {
55 LEFT = 0,
56 TOP_LEFT,
57 TOP,
58 };
59
60 static const uint8_t mss4_dc_vlc_lens[2][16] = {
61 { 0, 1, 5, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0 },
62 { 0, 3, 1, 1, 1, 1, 1, 1, 1, 2, 0, 0, 0, 0, 0, 0 }
63 };
64
65 static const uint8_t vec_len_syms[2][4] = {
66 { 4, 2, 3, 1 },
67 { 4, 1, 2, 3 }
68 };
69
70 static const uint8_t mss4_vec_entry_vlc_lens[2][16] = {
71 { 0, 2, 2, 3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
72 { 0, 1, 5, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
73 };
74
75 static const uint8_t mss4_vec_entry_vlc_syms[2][9] = {
76 { 0, 7, 6, 5, 8, 4, 3, 1, 2 },
77 { 0, 2, 3, 4, 5, 6, 7, 1, 8 }
78 };
79
80 #define MAX_ENTRIES 162
81
82 typedef struct MSS4Context {
83 AVFrame *pic;
84
85 int block[64];
86 uint8_t imgbuf[3][16 * 16];
87
88 int quality;
89 uint16_t quant_mat[2][64];
90
91 int *prev_dc[3];
92 ptrdiff_t dc_stride[3];
93 int dc_cache[4][4];
94
95 int prev_vec[3][4];
96 } MSS4Context;
97
98 static VLC dc_vlc[2], ac_vlc[2];
99 static VLC vec_entry_vlc[2];
100
mss4_init_vlc(VLC * vlc,unsigned * offset,const uint8_t * lens,const uint8_t * syms)101 static av_cold void mss4_init_vlc(VLC *vlc, unsigned *offset,
102 const uint8_t *lens, const uint8_t *syms)
103 {
104 static VLCElem vlc_buf[2146];
105 uint8_t bits[MAX_ENTRIES];
106 int i, j;
107 int idx = 0;
108
109 for (i = 0; i < 16; i++) {
110 for (j = 0; j < lens[i]; j++) {
111 bits[idx] = i + 1;
112 idx++;
113 }
114 }
115
116 vlc->table = &vlc_buf[*offset];
117 vlc->table_allocated = FF_ARRAY_ELEMS(vlc_buf) - *offset;
118 ff_init_vlc_from_lengths(vlc, FFMIN(bits[idx - 1], 9), idx,
119 bits, 1, syms, 1, 1,
120 0, INIT_VLC_STATIC_OVERLONG, NULL);
121 *offset += vlc->table_size;
122 }
123
mss4_init_vlcs(void)124 static av_cold void mss4_init_vlcs(void)
125 {
126 for (unsigned i = 0, offset = 0; i < 2; i++) {
127 mss4_init_vlc(&dc_vlc[i], &offset, mss4_dc_vlc_lens[i], NULL);
128 mss4_init_vlc(&ac_vlc[i], &offset,
129 i ? ff_mjpeg_bits_ac_chrominance + 1
130 : ff_mjpeg_bits_ac_luminance + 1,
131 i ? ff_mjpeg_val_ac_chrominance
132 : ff_mjpeg_val_ac_luminance);
133 mss4_init_vlc(&vec_entry_vlc[i], &offset, mss4_vec_entry_vlc_lens[i],
134 mss4_vec_entry_vlc_syms[i]);
135 }
136 }
137
138 /* This function returns values in the range
139 * (-range + 1; -range/2] U [range/2; range - 1)
140 * i.e.
141 * nbits = 0 -> 0
142 * nbits = 1 -> -1, 1
143 * nbits = 2 -> -3, -2, 2, 3
144 */
get_coeff_bits(GetBitContext * gb,int nbits)145 static av_always_inline int get_coeff_bits(GetBitContext *gb, int nbits)
146 {
147 int val;
148
149 if (!nbits)
150 return 0;
151
152 val = get_bits(gb, nbits);
153 if (val < (1 << (nbits - 1)))
154 val -= (1 << nbits) - 1;
155
156 return val;
157 }
158
get_coeff(GetBitContext * gb,VLC * vlc)159 static inline int get_coeff(GetBitContext *gb, VLC *vlc)
160 {
161 int val = get_vlc2(gb, vlc->table, vlc->bits, 2);
162
163 return get_coeff_bits(gb, val);
164 }
165
mss4_decode_dct(GetBitContext * gb,VLC * dc_vlc,VLC * ac_vlc,int * block,int * dc_cache,int bx,int by,uint16_t * quant_mat)166 static int mss4_decode_dct(GetBitContext *gb, VLC *dc_vlc, VLC *ac_vlc,
167 int *block, int *dc_cache,
168 int bx, int by, uint16_t *quant_mat)
169 {
170 int skip, val, pos = 1, zz_pos, dc;
171
172 memset(block, 0, sizeof(*block) * 64);
173
174 dc = get_coeff(gb, dc_vlc);
175 // DC prediction is the same as in MSS3
176 if (by) {
177 if (bx) {
178 int l, tl, t;
179
180 l = dc_cache[LEFT];
181 tl = dc_cache[TOP_LEFT];
182 t = dc_cache[TOP];
183
184 if (FFABS(t - tl) <= FFABS(l - tl))
185 dc += l;
186 else
187 dc += t;
188 } else {
189 dc += dc_cache[TOP];
190 }
191 } else if (bx) {
192 dc += dc_cache[LEFT];
193 }
194 dc_cache[LEFT] = dc;
195 block[0] = dc * quant_mat[0];
196
197 while (pos < 64) {
198 val = get_vlc2(gb, ac_vlc->table, 9, 2);
199 if (!val)
200 return 0;
201 if (val == -1)
202 return -1;
203 if (val == 0xF0) {
204 pos += 16;
205 continue;
206 }
207 skip = val >> 4;
208 val = get_coeff_bits(gb, val & 0xF);
209 pos += skip;
210 if (pos >= 64)
211 return -1;
212
213 zz_pos = ff_zigzag_direct[pos];
214 block[zz_pos] = val * quant_mat[zz_pos];
215 pos++;
216 }
217
218 return pos == 64 ? 0 : -1;
219 }
220
mss4_decode_dct_block(MSS4Context * c,GetBitContext * gb,uint8_t * dst[3],int mb_x,int mb_y)221 static int mss4_decode_dct_block(MSS4Context *c, GetBitContext *gb,
222 uint8_t *dst[3], int mb_x, int mb_y)
223 {
224 int i, j, k, ret;
225 uint8_t *out = dst[0];
226
227 for (j = 0; j < 2; j++) {
228 for (i = 0; i < 2; i++) {
229 int xpos = mb_x * 2 + i;
230 c->dc_cache[j][TOP_LEFT] = c->dc_cache[j][TOP];
231 c->dc_cache[j][TOP] = c->prev_dc[0][mb_x * 2 + i];
232 ret = mss4_decode_dct(gb, &dc_vlc[0], &ac_vlc[0], c->block,
233 c->dc_cache[j],
234 xpos, mb_y * 2 + j, c->quant_mat[0]);
235 if (ret)
236 return ret;
237 c->prev_dc[0][mb_x * 2 + i] = c->dc_cache[j][LEFT];
238
239 ff_mss34_dct_put(out + xpos * 8, c->pic->linesize[0],
240 c->block);
241 }
242 out += 8 * c->pic->linesize[0];
243 }
244
245 for (i = 1; i < 3; i++) {
246 c->dc_cache[i + 1][TOP_LEFT] = c->dc_cache[i + 1][TOP];
247 c->dc_cache[i + 1][TOP] = c->prev_dc[i][mb_x];
248 ret = mss4_decode_dct(gb, &dc_vlc[1], &ac_vlc[1],
249 c->block, c->dc_cache[i + 1], mb_x, mb_y,
250 c->quant_mat[1]);
251 if (ret)
252 return ret;
253 c->prev_dc[i][mb_x] = c->dc_cache[i + 1][LEFT];
254
255 ff_mss34_dct_put(c->imgbuf[i], 8, c->block);
256 out = dst[i] + mb_x * 16;
257 // Since the DCT block is coded as YUV420 and the whole frame as YUV444,
258 // we need to scale chroma.
259 for (j = 0; j < 16; j++) {
260 for (k = 0; k < 8; k++)
261 AV_WN16A(out + k * 2, c->imgbuf[i][k + (j & ~1) * 4] * 0x101);
262 out += c->pic->linesize[i];
263 }
264 }
265
266 return 0;
267 }
268
read_vec_pos(GetBitContext * gb,int * vec_pos,int * sel_flag,int * sel_len,int * prev)269 static void read_vec_pos(GetBitContext *gb, int *vec_pos, int *sel_flag,
270 int *sel_len, int *prev)
271 {
272 int i, y_flag = 0;
273
274 for (i = 2; i >= 0; i--) {
275 if (!sel_flag[i]) {
276 vec_pos[i] = 0;
277 continue;
278 }
279 if ((!i && !y_flag) || get_bits1(gb)) {
280 if (sel_len[i] > 0) {
281 int pval = prev[i];
282 vec_pos[i] = get_bits(gb, sel_len[i]);
283 if (vec_pos[i] >= pval)
284 vec_pos[i]++;
285 } else {
286 vec_pos[i] = !prev[i];
287 }
288 y_flag = 1;
289 } else {
290 vec_pos[i] = prev[i];
291 }
292 }
293 }
294
get_value_cached(GetBitContext * gb,int vec_pos,uint8_t * vec,int vec_size,int component,int shift,int * prev)295 static int get_value_cached(GetBitContext *gb, int vec_pos, uint8_t *vec,
296 int vec_size, int component, int shift, int *prev)
297 {
298 if (vec_pos < vec_size)
299 return vec[vec_pos];
300 if (!get_bits1(gb))
301 return prev[component];
302 prev[component] = get_bits(gb, 8 - shift) << shift;
303 return prev[component];
304 }
305
306 #define MKVAL(vals) ((vals)[0] | ((vals)[1] << 3) | ((vals)[2] << 6))
307
308 /* Image mode - the hardest to comprehend MSS4 coding mode.
309 *
310 * In this mode all three 16x16 blocks are coded together with a method
311 * remotely similar to the methods employed in MSS1-MSS3.
312 * The idea is that every component has a vector of 1-4 most common symbols
313 * and an escape mode for reading new value from the bitstream. Decoding
314 * consists of retrieving pixel values from the vector or reading new ones
315 * from the bitstream; depending on flags read from the bitstream, these vector
316 * positions can be updated or reused from the state of the previous line
317 * or previous pixel.
318 */
mss4_decode_image_block(MSS4Context * ctx,GetBitContext * gb,uint8_t * picdst[3],int mb_x,int mb_y)319 static int mss4_decode_image_block(MSS4Context *ctx, GetBitContext *gb,
320 uint8_t *picdst[3], int mb_x, int mb_y)
321 {
322 uint8_t vec[3][4];
323 int vec_len[3];
324 int sel_len[3], sel_flag[3];
325 int i, j, k, mode, split;
326 int prev_vec1 = 0, prev_split = 0;
327 int vals[3] = { 0 };
328 int prev_pix[3] = { 0 };
329 int prev_mode[16] = { 0 };
330 uint8_t *dst[3];
331
332 const int val_shift = ctx->quality == 100 ? 0 : 2;
333
334 for (i = 0; i < 3; i++)
335 dst[i] = ctx->imgbuf[i];
336
337 for (i = 0; i < 3; i++) {
338 vec_len[i] = vec_len_syms[!!i][get_unary(gb, 0, 3)];
339 for (j = 0; j < vec_len[i]; j++) {
340 vec[i][j] = get_coeff(gb, &vec_entry_vlc[!!i]);
341 vec[i][j] += ctx->prev_vec[i][j];
342 ctx->prev_vec[i][j] = vec[i][j];
343 }
344 sel_flag[i] = vec_len[i] > 1;
345 sel_len[i] = vec_len[i] > 2 ? vec_len[i] - 2 : 0;
346 }
347
348 for (j = 0; j < 16; j++) {
349 if (get_bits1(gb)) {
350 split = 0;
351 if (get_bits1(gb)) {
352 prev_mode[0] = 0;
353 vals[0] = vals[1] = vals[2] = 0;
354 mode = 2;
355 } else {
356 mode = get_bits1(gb);
357 if (mode)
358 split = get_bits(gb, 4);
359 }
360 for (i = 0; i < 16; i++) {
361 if (mode <= 1) {
362 vals[0] = prev_mode[i] & 7;
363 vals[1] = (prev_mode[i] >> 3) & 7;
364 vals[2] = prev_mode[i] >> 6;
365 if (mode == 1 && i == split) {
366 read_vec_pos(gb, vals, sel_flag, sel_len, vals);
367 }
368 } else if (mode == 2) {
369 if (get_bits1(gb))
370 read_vec_pos(gb, vals, sel_flag, sel_len, vals);
371 }
372 for (k = 0; k < 3; k++)
373 *dst[k]++ = get_value_cached(gb, vals[k], vec[k],
374 vec_len[k], k,
375 val_shift, prev_pix);
376 prev_mode[i] = MKVAL(vals);
377 }
378 } else {
379 if (get_bits1(gb)) {
380 split = get_bits(gb, 4);
381 if (split >= prev_split)
382 split++;
383 prev_split = split;
384 } else {
385 split = prev_split;
386 }
387 if (split) {
388 vals[0] = prev_mode[0] & 7;
389 vals[1] = (prev_mode[0] >> 3) & 7;
390 vals[2] = prev_mode[0] >> 6;
391 for (i = 0; i < 3; i++) {
392 for (k = 0; k < split; k++) {
393 *dst[i]++ = get_value_cached(gb, vals[i], vec[i],
394 vec_len[i], i, val_shift,
395 prev_pix);
396 prev_mode[k] = MKVAL(vals);
397 }
398 }
399 }
400
401 if (split != 16) {
402 vals[0] = prev_vec1 & 7;
403 vals[1] = (prev_vec1 >> 3) & 7;
404 vals[2] = prev_vec1 >> 6;
405 if (get_bits1(gb)) {
406 read_vec_pos(gb, vals, sel_flag, sel_len, vals);
407 prev_vec1 = MKVAL(vals);
408 }
409 for (i = 0; i < 3; i++) {
410 for (k = 0; k < 16 - split; k++) {
411 *dst[i]++ = get_value_cached(gb, vals[i], vec[i],
412 vec_len[i], i, val_shift,
413 prev_pix);
414 prev_mode[split + k] = MKVAL(vals);
415 }
416 }
417 }
418 }
419 }
420
421 for (i = 0; i < 3; i++)
422 for (j = 0; j < 16; j++)
423 memcpy(picdst[i] + mb_x * 16 + j * ctx->pic->linesize[i],
424 ctx->imgbuf[i] + j * 16, 16);
425
426 return 0;
427 }
428
mss4_update_dc_cache(MSS4Context * c,int mb_x)429 static inline void mss4_update_dc_cache(MSS4Context *c, int mb_x)
430 {
431 int i;
432
433 c->dc_cache[0][TOP] = c->prev_dc[0][mb_x * 2 + 1];
434 c->dc_cache[0][LEFT] = 0;
435 c->dc_cache[1][TOP] = 0;
436 c->dc_cache[1][LEFT] = 0;
437
438 for (i = 0; i < 2; i++)
439 c->prev_dc[0][mb_x * 2 + i] = 0;
440
441 for (i = 1; i < 3; i++) {
442 c->dc_cache[i + 1][TOP] = c->prev_dc[i][mb_x];
443 c->dc_cache[i + 1][LEFT] = 0;
444 c->prev_dc[i][mb_x] = 0;
445 }
446 }
447
mss4_decode_frame(AVCodecContext * avctx,AVFrame * rframe,int * got_frame,AVPacket * avpkt)448 static int mss4_decode_frame(AVCodecContext *avctx, AVFrame *rframe,
449 int *got_frame, AVPacket *avpkt)
450 {
451 const uint8_t *buf = avpkt->data;
452 int buf_size = avpkt->size;
453 MSS4Context *c = avctx->priv_data;
454 GetBitContext gb;
455 GetByteContext bc;
456 uint8_t *dst[3];
457 int width, height, quality, frame_type;
458 int x, y, i, mb_width, mb_height, blk_type;
459 int ret;
460
461 if (buf_size < HEADER_SIZE) {
462 av_log(avctx, AV_LOG_ERROR,
463 "Frame should have at least %d bytes, got %d instead\n",
464 HEADER_SIZE, buf_size);
465 return AVERROR_INVALIDDATA;
466 }
467
468 bytestream2_init(&bc, buf, buf_size);
469 width = bytestream2_get_be16(&bc);
470 height = bytestream2_get_be16(&bc);
471 bytestream2_skip(&bc, 2);
472 quality = bytestream2_get_byte(&bc);
473 frame_type = bytestream2_get_byte(&bc);
474
475 if (width > avctx->width ||
476 height != avctx->height) {
477 av_log(avctx, AV_LOG_ERROR, "Invalid frame dimensions %dx%d\n",
478 width, height);
479 return AVERROR_INVALIDDATA;
480 }
481 if (av_image_check_size2(width, height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0)
482 return AVERROR_INVALIDDATA;
483
484 if (quality < 1 || quality > 100) {
485 av_log(avctx, AV_LOG_ERROR, "Invalid quality setting %d\n", quality);
486 return AVERROR_INVALIDDATA;
487 }
488 if ((frame_type & ~3) || frame_type == 3) {
489 av_log(avctx, AV_LOG_ERROR, "Invalid frame type %d\n", frame_type);
490 return AVERROR_INVALIDDATA;
491 }
492
493 if (frame_type != SKIP_FRAME && !bytestream2_get_bytes_left(&bc)) {
494 av_log(avctx, AV_LOG_ERROR,
495 "Empty frame found but it is not a skip frame.\n");
496 return AVERROR_INVALIDDATA;
497 }
498 mb_width = FFALIGN(width, 16) >> 4;
499 mb_height = FFALIGN(height, 16) >> 4;
500
501 if (frame_type != SKIP_FRAME && 8*buf_size < 8*HEADER_SIZE + mb_width*mb_height)
502 return AVERROR_INVALIDDATA;
503
504 if ((ret = ff_reget_buffer(avctx, c->pic, 0)) < 0)
505 return ret;
506 c->pic->key_frame = (frame_type == INTRA_FRAME);
507 c->pic->pict_type = (frame_type == INTRA_FRAME) ? AV_PICTURE_TYPE_I
508 : AV_PICTURE_TYPE_P;
509 if (frame_type == SKIP_FRAME) {
510 *got_frame = 1;
511 if ((ret = av_frame_ref(rframe, c->pic)) < 0)
512 return ret;
513
514 return buf_size;
515 }
516
517 if (c->quality != quality) {
518 c->quality = quality;
519 for (i = 0; i < 2; i++)
520 ff_mss34_gen_quant_mat(c->quant_mat[i], quality, !i);
521 }
522
523 if ((ret = init_get_bits8(&gb, buf + HEADER_SIZE, buf_size - HEADER_SIZE)) < 0)
524 return ret;
525 dst[0] = c->pic->data[0];
526 dst[1] = c->pic->data[1];
527 dst[2] = c->pic->data[2];
528
529 memset(c->prev_vec, 0, sizeof(c->prev_vec));
530 for (y = 0; y < mb_height; y++) {
531 memset(c->dc_cache, 0, sizeof(c->dc_cache));
532 for (x = 0; x < mb_width; x++) {
533 blk_type = decode012(&gb);
534 switch (blk_type) {
535 case DCT_BLOCK:
536 if (mss4_decode_dct_block(c, &gb, dst, x, y) < 0) {
537 av_log(avctx, AV_LOG_ERROR,
538 "Error decoding DCT block %d,%d\n",
539 x, y);
540 return AVERROR_INVALIDDATA;
541 }
542 break;
543 case IMAGE_BLOCK:
544 if (mss4_decode_image_block(c, &gb, dst, x, y) < 0) {
545 av_log(avctx, AV_LOG_ERROR,
546 "Error decoding VQ block %d,%d\n",
547 x, y);
548 return AVERROR_INVALIDDATA;
549 }
550 break;
551 case SKIP_BLOCK:
552 if (frame_type == INTRA_FRAME) {
553 av_log(avctx, AV_LOG_ERROR, "Skip block in intra frame\n");
554 return AVERROR_INVALIDDATA;
555 }
556 break;
557 }
558 if (blk_type != DCT_BLOCK)
559 mss4_update_dc_cache(c, x);
560 }
561 dst[0] += c->pic->linesize[0] * 16;
562 dst[1] += c->pic->linesize[1] * 16;
563 dst[2] += c->pic->linesize[2] * 16;
564 }
565
566 if ((ret = av_frame_ref(rframe, c->pic)) < 0)
567 return ret;
568
569 *got_frame = 1;
570
571 return buf_size;
572 }
573
mss4_decode_end(AVCodecContext * avctx)574 static av_cold int mss4_decode_end(AVCodecContext *avctx)
575 {
576 MSS4Context * const c = avctx->priv_data;
577 int i;
578
579 av_frame_free(&c->pic);
580 for (i = 0; i < 3; i++)
581 av_freep(&c->prev_dc[i]);
582
583 return 0;
584 }
585
mss4_decode_init(AVCodecContext * avctx)586 static av_cold int mss4_decode_init(AVCodecContext *avctx)
587 {
588 static AVOnce init_static_once = AV_ONCE_INIT;
589 MSS4Context * const c = avctx->priv_data;
590 int i;
591
592 for (i = 0; i < 3; i++) {
593 c->dc_stride[i] = FFALIGN(avctx->width, 16) >> (2 + !!i);
594 c->prev_dc[i] = av_malloc_array(c->dc_stride[i], sizeof(**c->prev_dc));
595 if (!c->prev_dc[i]) {
596 av_log(avctx, AV_LOG_ERROR, "Cannot allocate buffer\n");
597 return AVERROR(ENOMEM);
598 }
599 }
600
601 c->pic = av_frame_alloc();
602 if (!c->pic)
603 return AVERROR(ENOMEM);
604
605 avctx->pix_fmt = AV_PIX_FMT_YUV444P;
606
607 ff_thread_once(&init_static_once, mss4_init_vlcs);
608
609 return 0;
610 }
611
612 const FFCodec ff_mts2_decoder = {
613 .p.name = "mts2",
614 .p.long_name = NULL_IF_CONFIG_SMALL("MS Expression Encoder Screen"),
615 .p.type = AVMEDIA_TYPE_VIDEO,
616 .p.id = AV_CODEC_ID_MTS2,
617 .priv_data_size = sizeof(MSS4Context),
618 .init = mss4_decode_init,
619 .close = mss4_decode_end,
620 FF_CODEC_DECODE_CB(mss4_decode_frame),
621 .p.capabilities = AV_CODEC_CAP_DR1,
622 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_INIT_THREADSAFE,
623 };
624