1 /*
2 * Copyright (c) 2003 The FFmpeg Project
3 *
4 * This file is part of FFmpeg.
5 *
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 /*
22 * How to use this decoder:
23 * SVQ3 data is transported within Apple Quicktime files. Quicktime files
24 * have stsd atoms to describe media trak properties. A stsd atom for a
25 * video trak contains 1 or more ImageDescription atoms. These atoms begin
26 * with the 4-byte length of the atom followed by the codec fourcc. Some
27 * decoders need information in this atom to operate correctly. Such
28 * is the case with SVQ3. In order to get the best use out of this decoder,
29 * the calling app must make the SVQ3 ImageDescription atom available
30 * via the AVCodecContext's extradata[_size] field:
31 *
32 * AVCodecContext.extradata = pointer to ImageDescription, first characters
33 * are expected to be 'S', 'V', 'Q', and '3', NOT the 4-byte atom length
34 * AVCodecContext.extradata_size = size of ImageDescription atom memory
35 * buffer (which will be the same as the ImageDescription atom size field
36 * from the QT file, minus 4 bytes since the length is missing)
37 *
38 * You will know you have these parameters passed correctly when the decoder
39 * correctly decodes this file:
40 * http://samples.mplayerhq.hu/V-codecs/SVQ3/Vertical400kbit.sorenson3.mov
41 */
42
43 #include <inttypes.h>
44
45 #include "libavutil/attributes.h"
46 #include "libavutil/crc.h"
47 #include "libavutil/mem_internal.h"
48
49 #include "codec_internal.h"
50 #include "internal.h"
51 #include "avcodec.h"
52 #include "mpegutils.h"
53 #include "h264data.h"
54 #include "h264dsp.h"
55 #include "h264pred.h"
56 #include "h264_parse.h"
57 #include "golomb.h"
58 #include "hpeldsp.h"
59 #include "mathops.h"
60 #include "rectangle.h"
61 #include "tpeldsp.h"
62 #include "videodsp.h"
63
64 #if CONFIG_ZLIB
65 #include <zlib.h>
66 #endif
67
68 #include "svq1.h"
69
70 /**
71 * @file
72 * svq3 decoder.
73 */
74
75 typedef struct SVQ3Frame {
76 AVFrame *f;
77
78 int16_t (*motion_val_buf[2])[2];
79 int16_t (*motion_val[2])[2];
80
81 uint32_t *mb_type_buf, *mb_type;
82 } SVQ3Frame;
83
84 typedef struct SVQ3Context {
85 AVCodecContext *avctx;
86
87 H264DSPContext h264dsp;
88 H264PredContext hpc;
89 HpelDSPContext hdsp;
90 TpelDSPContext tdsp;
91 VideoDSPContext vdsp;
92
93 SVQ3Frame *cur_pic;
94 SVQ3Frame *next_pic;
95 SVQ3Frame *last_pic;
96 GetBitContext gb;
97 GetBitContext gb_slice;
98 uint8_t *slice_buf;
99 unsigned slice_buf_size;
100 int halfpel_flag;
101 int thirdpel_flag;
102 int has_watermark;
103 uint32_t watermark_key;
104 int adaptive_quant;
105 int h_edge_pos;
106 int v_edge_pos;
107 int last_frame_output;
108 int slice_num;
109 int qscale;
110 int cbp;
111 int frame_num;
112 int frame_num_offset;
113 int prev_frame_num_offset;
114 int prev_frame_num;
115
116 enum AVPictureType pict_type;
117 enum AVPictureType slice_type;
118 int low_delay;
119
120 int mb_x, mb_y;
121 int mb_xy;
122 int mb_width, mb_height;
123 int mb_stride, mb_num;
124 int b_stride;
125
126 uint32_t *mb2br_xy;
127
128 int chroma_pred_mode;
129 int intra16x16_pred_mode;
130
131 int8_t intra4x4_pred_mode_cache[5 * 8];
132 int8_t (*intra4x4_pred_mode);
133
134 unsigned int top_samples_available;
135 unsigned int left_samples_available;
136
137 uint8_t *edge_emu_buffer;
138
139 DECLARE_ALIGNED(16, int16_t, mv_cache)[2][5 * 8][2];
140 DECLARE_ALIGNED(8, int8_t, ref_cache)[2][5 * 8];
141 DECLARE_ALIGNED(16, int16_t, mb)[16 * 48 * 2];
142 DECLARE_ALIGNED(16, int16_t, mb_luma_dc)[3][16 * 2];
143 DECLARE_ALIGNED(8, uint8_t, non_zero_count_cache)[15 * 8];
144 uint32_t dequant4_coeff[QP_MAX_NUM + 1][16];
145 int block_offset[2 * (16 * 3)];
146 SVQ3Frame frames[3];
147 } SVQ3Context;
148
149 #define FULLPEL_MODE 1
150 #define HALFPEL_MODE 2
151 #define THIRDPEL_MODE 3
152 #define PREDICT_MODE 4
153
154 /* dual scan (from some older H.264 draft)
155 * o-->o-->o o
156 * | /|
157 * o o o / o
158 * | / | |/ |
159 * o o o o
160 * /
161 * o-->o-->o-->o
162 */
163 static const uint8_t svq3_scan[16] = {
164 0 + 0 * 4, 1 + 0 * 4, 2 + 0 * 4, 2 + 1 * 4,
165 2 + 2 * 4, 3 + 0 * 4, 3 + 1 * 4, 3 + 2 * 4,
166 0 + 1 * 4, 0 + 2 * 4, 1 + 1 * 4, 1 + 2 * 4,
167 0 + 3 * 4, 1 + 3 * 4, 2 + 3 * 4, 3 + 3 * 4,
168 };
169
170 static const uint8_t luma_dc_zigzag_scan[16] = {
171 0 * 16 + 0 * 64, 1 * 16 + 0 * 64, 2 * 16 + 0 * 64, 0 * 16 + 2 * 64,
172 3 * 16 + 0 * 64, 0 * 16 + 1 * 64, 1 * 16 + 1 * 64, 2 * 16 + 1 * 64,
173 1 * 16 + 2 * 64, 2 * 16 + 2 * 64, 3 * 16 + 2 * 64, 0 * 16 + 3 * 64,
174 3 * 16 + 1 * 64, 1 * 16 + 3 * 64, 2 * 16 + 3 * 64, 3 * 16 + 3 * 64,
175 };
176
177 static const uint8_t svq3_pred_0[25][2] = {
178 { 0, 0 },
179 { 1, 0 }, { 0, 1 },
180 { 0, 2 }, { 1, 1 }, { 2, 0 },
181 { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
182 { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
183 { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
184 { 2, 4 }, { 3, 3 }, { 4, 2 },
185 { 4, 3 }, { 3, 4 },
186 { 4, 4 }
187 };
188
189 static const int8_t svq3_pred_1[6][6][5] = {
190 { { 2, -1, -1, -1, -1 }, { 2, 1, -1, -1, -1 }, { 1, 2, -1, -1, -1 },
191 { 2, 1, -1, -1, -1 }, { 1, 2, -1, -1, -1 }, { 1, 2, -1, -1, -1 } },
192 { { 0, 2, -1, -1, -1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
193 { 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
194 { { 2, 0, -1, -1, -1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
195 { 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
196 { { 2, 0, -1, -1, -1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
197 { 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
198 { { 0, 2, -1, -1, -1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
199 { 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
200 { { 0, 2, -1, -1, -1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
201 { 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
202 };
203
204 static const struct {
205 uint8_t run;
206 uint8_t level;
207 } svq3_dct_tables[2][16] = {
208 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
209 { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
210 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
211 { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
212 };
213
214 static const uint32_t svq3_dequant_coeff[32] = {
215 3881, 4351, 4890, 5481, 6154, 6914, 7761, 8718,
216 9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
217 24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
218 61694, 68745, 77615, 89113, 100253, 109366, 126635, 141533
219 };
220
svq3_luma_dc_dequant_idct_c(int16_t * output,int16_t * input,int qp)221 static void svq3_luma_dc_dequant_idct_c(int16_t *output, int16_t *input, int qp)
222 {
223 const unsigned qmul = svq3_dequant_coeff[qp];
224 #define stride 16
225 int i;
226 int temp[16];
227 static const uint8_t x_offset[4] = { 0, 1 * stride, 4 * stride, 5 * stride };
228
229 for (i = 0; i < 4; i++) {
230 const int z0 = 13 * (input[4 * i + 0] + input[4 * i + 2]);
231 const int z1 = 13 * (input[4 * i + 0] - input[4 * i + 2]);
232 const int z2 = 7 * input[4 * i + 1] - 17 * input[4 * i + 3];
233 const int z3 = 17 * input[4 * i + 1] + 7 * input[4 * i + 3];
234
235 temp[4 * i + 0] = z0 + z3;
236 temp[4 * i + 1] = z1 + z2;
237 temp[4 * i + 2] = z1 - z2;
238 temp[4 * i + 3] = z0 - z3;
239 }
240
241 for (i = 0; i < 4; i++) {
242 const int offset = x_offset[i];
243 const int z0 = 13 * (temp[4 * 0 + i] + temp[4 * 2 + i]);
244 const int z1 = 13 * (temp[4 * 0 + i] - temp[4 * 2 + i]);
245 const int z2 = 7 * temp[4 * 1 + i] - 17 * temp[4 * 3 + i];
246 const int z3 = 17 * temp[4 * 1 + i] + 7 * temp[4 * 3 + i];
247
248 output[stride * 0 + offset] = (int)((z0 + z3) * qmul + 0x80000) >> 20;
249 output[stride * 2 + offset] = (int)((z1 + z2) * qmul + 0x80000) >> 20;
250 output[stride * 8 + offset] = (int)((z1 - z2) * qmul + 0x80000) >> 20;
251 output[stride * 10 + offset] = (int)((z0 - z3) * qmul + 0x80000) >> 20;
252 }
253 }
254 #undef stride
255
svq3_add_idct_c(uint8_t * dst,int16_t * block,int stride,int qp,int dc)256 static void svq3_add_idct_c(uint8_t *dst, int16_t *block,
257 int stride, int qp, int dc)
258 {
259 const int qmul = svq3_dequant_coeff[qp];
260 int i;
261
262 if (dc) {
263 dc = 13 * 13 * (dc == 1 ? 1538U* block[0]
264 : qmul * (block[0] >> 3) / 2);
265 block[0] = 0;
266 }
267
268 for (i = 0; i < 4; i++) {
269 const int z0 = 13 * (block[0 + 4 * i] + block[2 + 4 * i]);
270 const int z1 = 13 * (block[0 + 4 * i] - block[2 + 4 * i]);
271 const int z2 = 7 * block[1 + 4 * i] - 17 * block[3 + 4 * i];
272 const int z3 = 17 * block[1 + 4 * i] + 7 * block[3 + 4 * i];
273
274 block[0 + 4 * i] = z0 + z3;
275 block[1 + 4 * i] = z1 + z2;
276 block[2 + 4 * i] = z1 - z2;
277 block[3 + 4 * i] = z0 - z3;
278 }
279
280 for (i = 0; i < 4; i++) {
281 const unsigned z0 = 13 * (block[i + 4 * 0] + block[i + 4 * 2]);
282 const unsigned z1 = 13 * (block[i + 4 * 0] - block[i + 4 * 2]);
283 const unsigned z2 = 7 * block[i + 4 * 1] - 17 * block[i + 4 * 3];
284 const unsigned z3 = 17 * block[i + 4 * 1] + 7 * block[i + 4 * 3];
285 const int rr = (dc + 0x80000u);
286
287 dst[i + stride * 0] = av_clip_uint8(dst[i + stride * 0] + ((int)((z0 + z3) * qmul + rr) >> 20));
288 dst[i + stride * 1] = av_clip_uint8(dst[i + stride * 1] + ((int)((z1 + z2) * qmul + rr) >> 20));
289 dst[i + stride * 2] = av_clip_uint8(dst[i + stride * 2] + ((int)((z1 - z2) * qmul + rr) >> 20));
290 dst[i + stride * 3] = av_clip_uint8(dst[i + stride * 3] + ((int)((z0 - z3) * qmul + rr) >> 20));
291 }
292
293 memset(block, 0, 16 * sizeof(int16_t));
294 }
295
svq3_decode_block(GetBitContext * gb,int16_t * block,int index,const int type)296 static inline int svq3_decode_block(GetBitContext *gb, int16_t *block,
297 int index, const int type)
298 {
299 static const uint8_t *const scan_patterns[4] = {
300 luma_dc_zigzag_scan, ff_zigzag_scan, svq3_scan, ff_h264_chroma_dc_scan
301 };
302
303 int run, level, sign, limit;
304 unsigned vlc;
305 const int intra = 3 * type >> 2;
306 const uint8_t *const scan = scan_patterns[type];
307
308 for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
309 for (; (vlc = get_interleaved_ue_golomb(gb)) != 0; index++) {
310 if ((int32_t)vlc < 0)
311 return -1;
312
313 sign = (vlc & 1) ? 0 : -1;
314 vlc = vlc + 1 >> 1;
315
316 if (type == 3) {
317 if (vlc < 3) {
318 run = 0;
319 level = vlc;
320 } else if (vlc < 4) {
321 run = 1;
322 level = 1;
323 } else {
324 run = vlc & 0x3;
325 level = (vlc + 9 >> 2) - run;
326 }
327 } else {
328 if (vlc < 16U) {
329 run = svq3_dct_tables[intra][vlc].run;
330 level = svq3_dct_tables[intra][vlc].level;
331 } else if (intra) {
332 run = vlc & 0x7;
333 level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
334 } else {
335 run = vlc & 0xF;
336 level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
337 }
338 }
339
340
341 if ((index += run) >= limit)
342 return -1;
343
344 block[scan[index]] = (level ^ sign) - sign;
345 }
346
347 if (type != 2) {
348 break;
349 }
350 }
351
352 return 0;
353 }
354
355 static av_always_inline int
svq3_fetch_diagonal_mv(const SVQ3Context * s,const int16_t ** C,int i,int list,int part_width)356 svq3_fetch_diagonal_mv(const SVQ3Context *s, const int16_t **C,
357 int i, int list, int part_width)
358 {
359 const int topright_ref = s->ref_cache[list][i - 8 + part_width];
360
361 if (topright_ref != PART_NOT_AVAILABLE) {
362 *C = s->mv_cache[list][i - 8 + part_width];
363 return topright_ref;
364 } else {
365 *C = s->mv_cache[list][i - 8 - 1];
366 return s->ref_cache[list][i - 8 - 1];
367 }
368 }
369
370 /**
371 * Get the predicted MV.
372 * @param n the block index
373 * @param part_width the width of the partition (4, 8,16) -> (1, 2, 4)
374 * @param mx the x component of the predicted motion vector
375 * @param my the y component of the predicted motion vector
376 */
svq3_pred_motion(const SVQ3Context * s,int n,int part_width,int list,int ref,int * const mx,int * const my)377 static av_always_inline void svq3_pred_motion(const SVQ3Context *s, int n,
378 int part_width, int list,
379 int ref, int *const mx, int *const my)
380 {
381 const int index8 = scan8[n];
382 const int top_ref = s->ref_cache[list][index8 - 8];
383 const int left_ref = s->ref_cache[list][index8 - 1];
384 const int16_t *const A = s->mv_cache[list][index8 - 1];
385 const int16_t *const B = s->mv_cache[list][index8 - 8];
386 const int16_t *C;
387 int diagonal_ref, match_count;
388
389 /* mv_cache
390 * B . . A T T T T
391 * U . . L . . , .
392 * U . . L . . . .
393 * U . . L . . , .
394 * . . . L . . . .
395 */
396
397 diagonal_ref = svq3_fetch_diagonal_mv(s, &C, index8, list, part_width);
398 match_count = (diagonal_ref == ref) + (top_ref == ref) + (left_ref == ref);
399 if (match_count > 1) { //most common
400 *mx = mid_pred(A[0], B[0], C[0]);
401 *my = mid_pred(A[1], B[1], C[1]);
402 } else if (match_count == 1) {
403 if (left_ref == ref) {
404 *mx = A[0];
405 *my = A[1];
406 } else if (top_ref == ref) {
407 *mx = B[0];
408 *my = B[1];
409 } else {
410 *mx = C[0];
411 *my = C[1];
412 }
413 } else {
414 if (top_ref == PART_NOT_AVAILABLE &&
415 diagonal_ref == PART_NOT_AVAILABLE &&
416 left_ref != PART_NOT_AVAILABLE) {
417 *mx = A[0];
418 *my = A[1];
419 } else {
420 *mx = mid_pred(A[0], B[0], C[0]);
421 *my = mid_pred(A[1], B[1], C[1]);
422 }
423 }
424 }
425
svq3_mc_dir_part(SVQ3Context * s,int x,int y,int width,int height,int mx,int my,int dxy,int thirdpel,int dir,int avg)426 static inline void svq3_mc_dir_part(SVQ3Context *s,
427 int x, int y, int width, int height,
428 int mx, int my, int dxy,
429 int thirdpel, int dir, int avg)
430 {
431 const SVQ3Frame *pic = (dir == 0) ? s->last_pic : s->next_pic;
432 uint8_t *src, *dest;
433 int i, emu = 0;
434 int blocksize = 2 - (width >> 3); // 16->0, 8->1, 4->2
435 int linesize = s->cur_pic->f->linesize[0];
436 int uvlinesize = s->cur_pic->f->linesize[1];
437
438 mx += x;
439 my += y;
440
441 if (mx < 0 || mx >= s->h_edge_pos - width - 1 ||
442 my < 0 || my >= s->v_edge_pos - height - 1) {
443 emu = 1;
444 mx = av_clip(mx, -16, s->h_edge_pos - width + 15);
445 my = av_clip(my, -16, s->v_edge_pos - height + 15);
446 }
447
448 /* form component predictions */
449 dest = s->cur_pic->f->data[0] + x + y * linesize;
450 src = pic->f->data[0] + mx + my * linesize;
451
452 if (emu) {
453 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src,
454 linesize, linesize,
455 width + 1, height + 1,
456 mx, my, s->h_edge_pos, s->v_edge_pos);
457 src = s->edge_emu_buffer;
458 }
459 if (thirdpel)
460 (avg ? s->tdsp.avg_tpel_pixels_tab
461 : s->tdsp.put_tpel_pixels_tab)[dxy](dest, src, linesize,
462 width, height);
463 else
464 (avg ? s->hdsp.avg_pixels_tab
465 : s->hdsp.put_pixels_tab)[blocksize][dxy](dest, src, linesize,
466 height);
467
468 if (!(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
469 mx = mx + (mx < (int) x) >> 1;
470 my = my + (my < (int) y) >> 1;
471 width = width >> 1;
472 height = height >> 1;
473 blocksize++;
474
475 for (i = 1; i < 3; i++) {
476 dest = s->cur_pic->f->data[i] + (x >> 1) + (y >> 1) * uvlinesize;
477 src = pic->f->data[i] + mx + my * uvlinesize;
478
479 if (emu) {
480 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src,
481 uvlinesize, uvlinesize,
482 width + 1, height + 1,
483 mx, my, (s->h_edge_pos >> 1),
484 s->v_edge_pos >> 1);
485 src = s->edge_emu_buffer;
486 }
487 if (thirdpel)
488 (avg ? s->tdsp.avg_tpel_pixels_tab
489 : s->tdsp.put_tpel_pixels_tab)[dxy](dest, src,
490 uvlinesize,
491 width, height);
492 else
493 (avg ? s->hdsp.avg_pixels_tab
494 : s->hdsp.put_pixels_tab)[blocksize][dxy](dest, src,
495 uvlinesize,
496 height);
497 }
498 }
499 }
500
svq3_mc_dir(SVQ3Context * s,int size,int mode,int dir,int avg)501 static inline int svq3_mc_dir(SVQ3Context *s, int size, int mode,
502 int dir, int avg)
503 {
504 int i, j, k, mx, my, dx, dy, x, y;
505 const int part_width = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
506 const int part_height = 16 >> ((unsigned)(size + 1) / 3);
507 const int extra_width = (mode == PREDICT_MODE) ? -16 * 6 : 0;
508 const int h_edge_pos = 6 * (s->h_edge_pos - part_width) - extra_width;
509 const int v_edge_pos = 6 * (s->v_edge_pos - part_height) - extra_width;
510
511 for (i = 0; i < 16; i += part_height)
512 for (j = 0; j < 16; j += part_width) {
513 const int b_xy = (4 * s->mb_x + (j >> 2)) +
514 (4 * s->mb_y + (i >> 2)) * s->b_stride;
515 int dxy;
516 x = 16 * s->mb_x + j;
517 y = 16 * s->mb_y + i;
518 k = (j >> 2 & 1) + (i >> 1 & 2) +
519 (j >> 1 & 4) + (i & 8);
520
521 if (mode != PREDICT_MODE) {
522 svq3_pred_motion(s, k, part_width >> 2, dir, 1, &mx, &my);
523 } else {
524 mx = s->next_pic->motion_val[0][b_xy][0] * 2;
525 my = s->next_pic->motion_val[0][b_xy][1] * 2;
526
527 if (dir == 0) {
528 mx = mx * s->frame_num_offset /
529 s->prev_frame_num_offset + 1 >> 1;
530 my = my * s->frame_num_offset /
531 s->prev_frame_num_offset + 1 >> 1;
532 } else {
533 mx = mx * (s->frame_num_offset - s->prev_frame_num_offset) /
534 s->prev_frame_num_offset + 1 >> 1;
535 my = my * (s->frame_num_offset - s->prev_frame_num_offset) /
536 s->prev_frame_num_offset + 1 >> 1;
537 }
538 }
539
540 /* clip motion vector prediction to frame border */
541 mx = av_clip(mx, extra_width - 6 * x, h_edge_pos - 6 * x);
542 my = av_clip(my, extra_width - 6 * y, v_edge_pos - 6 * y);
543
544 /* get (optional) motion vector differential */
545 if (mode == PREDICT_MODE) {
546 dx = dy = 0;
547 } else {
548 dy = get_interleaved_se_golomb(&s->gb_slice);
549 dx = get_interleaved_se_golomb(&s->gb_slice);
550
551 if (dx != (int16_t)dx || dy != (int16_t)dy) {
552 av_log(s->avctx, AV_LOG_ERROR, "invalid MV vlc\n");
553 return -1;
554 }
555 }
556
557 /* compute motion vector */
558 if (mode == THIRDPEL_MODE) {
559 int fx, fy;
560 mx = (mx + 1 >> 1) + dx;
561 my = (my + 1 >> 1) + dy;
562 fx = (unsigned)(mx + 0x30000) / 3 - 0x10000;
563 fy = (unsigned)(my + 0x30000) / 3 - 0x10000;
564 dxy = (mx - 3 * fx) + 4 * (my - 3 * fy);
565
566 svq3_mc_dir_part(s, x, y, part_width, part_height,
567 fx, fy, dxy, 1, dir, avg);
568 mx += mx;
569 my += my;
570 } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
571 mx = (unsigned)(mx + 1 + 0x30000) / 3 + dx - 0x10000;
572 my = (unsigned)(my + 1 + 0x30000) / 3 + dy - 0x10000;
573 dxy = (mx & 1) + 2 * (my & 1);
574
575 svq3_mc_dir_part(s, x, y, part_width, part_height,
576 mx >> 1, my >> 1, dxy, 0, dir, avg);
577 mx *= 3;
578 my *= 3;
579 } else {
580 mx = (unsigned)(mx + 3 + 0x60000) / 6 + dx - 0x10000;
581 my = (unsigned)(my + 3 + 0x60000) / 6 + dy - 0x10000;
582
583 svq3_mc_dir_part(s, x, y, part_width, part_height,
584 mx, my, 0, 0, dir, avg);
585 mx *= 6;
586 my *= 6;
587 }
588
589 /* update mv_cache */
590 if (mode != PREDICT_MODE) {
591 int32_t mv = pack16to32(mx, my);
592
593 if (part_height == 8 && i < 8) {
594 AV_WN32A(s->mv_cache[dir][scan8[k] + 1 * 8], mv);
595
596 if (part_width == 8 && j < 8)
597 AV_WN32A(s->mv_cache[dir][scan8[k] + 1 + 1 * 8], mv);
598 }
599 if (part_width == 8 && j < 8)
600 AV_WN32A(s->mv_cache[dir][scan8[k] + 1], mv);
601 if (part_width == 4 || part_height == 4)
602 AV_WN32A(s->mv_cache[dir][scan8[k]], mv);
603 }
604
605 /* write back motion vectors */
606 fill_rectangle(s->cur_pic->motion_val[dir][b_xy],
607 part_width >> 2, part_height >> 2, s->b_stride,
608 pack16to32(mx, my), 4);
609 }
610
611 return 0;
612 }
613
hl_decode_mb_idct_luma(SVQ3Context * s,int mb_type,const int * block_offset,int linesize,uint8_t * dest_y)614 static av_always_inline void hl_decode_mb_idct_luma(SVQ3Context *s,
615 int mb_type, const int *block_offset,
616 int linesize, uint8_t *dest_y)
617 {
618 int i;
619 if (!IS_INTRA4x4(mb_type)) {
620 for (i = 0; i < 16; i++)
621 if (s->non_zero_count_cache[scan8[i]] || s->mb[i * 16]) {
622 uint8_t *const ptr = dest_y + block_offset[i];
623 svq3_add_idct_c(ptr, s->mb + i * 16, linesize,
624 s->qscale, IS_INTRA(mb_type) ? 1 : 0);
625 }
626 }
627 }
628
hl_decode_mb_predict_luma(SVQ3Context * s,int mb_type,const int * block_offset,int linesize,uint8_t * dest_y)629 static av_always_inline void hl_decode_mb_predict_luma(SVQ3Context *s,
630 int mb_type,
631 const int *block_offset,
632 int linesize,
633 uint8_t *dest_y)
634 {
635 int i;
636 int qscale = s->qscale;
637
638 if (IS_INTRA4x4(mb_type)) {
639 for (i = 0; i < 16; i++) {
640 uint8_t *const ptr = dest_y + block_offset[i];
641 const int dir = s->intra4x4_pred_mode_cache[scan8[i]];
642
643 uint8_t *topright;
644 int nnz;
645 if (dir == DIAG_DOWN_LEFT_PRED || dir == VERT_LEFT_PRED) {
646 av_assert2(s->mb_y || linesize <= block_offset[i]);
647 topright = ptr + 4 - linesize;
648 } else
649 topright = NULL;
650
651 s->hpc.pred4x4[dir](ptr, topright, linesize);
652 nnz = s->non_zero_count_cache[scan8[i]];
653 if (nnz) {
654 svq3_add_idct_c(ptr, s->mb + i * 16, linesize, qscale, 0);
655 }
656 }
657 } else {
658 s->hpc.pred16x16[s->intra16x16_pred_mode](dest_y, linesize);
659 svq3_luma_dc_dequant_idct_c(s->mb, s->mb_luma_dc[0], qscale);
660 }
661 }
662
hl_decode_mb(SVQ3Context * s)663 static void hl_decode_mb(SVQ3Context *s)
664 {
665 const int mb_x = s->mb_x;
666 const int mb_y = s->mb_y;
667 const int mb_xy = s->mb_xy;
668 const int mb_type = s->cur_pic->mb_type[mb_xy];
669 uint8_t *dest_y, *dest_cb, *dest_cr;
670 int linesize, uvlinesize;
671 int i, j;
672 const int *block_offset = &s->block_offset[0];
673 const int block_h = 16 >> 1;
674
675 linesize = s->cur_pic->f->linesize[0];
676 uvlinesize = s->cur_pic->f->linesize[1];
677
678 dest_y = s->cur_pic->f->data[0] + (mb_x + mb_y * linesize) * 16;
679 dest_cb = s->cur_pic->f->data[1] + mb_x * 8 + mb_y * uvlinesize * block_h;
680 dest_cr = s->cur_pic->f->data[2] + mb_x * 8 + mb_y * uvlinesize * block_h;
681
682 s->vdsp.prefetch(dest_y + (s->mb_x & 3) * 4 * linesize + 64, linesize, 4);
683 s->vdsp.prefetch(dest_cb + (s->mb_x & 7) * uvlinesize + 64, dest_cr - dest_cb, 2);
684
685 if (IS_INTRA(mb_type)) {
686 s->hpc.pred8x8[s->chroma_pred_mode](dest_cb, uvlinesize);
687 s->hpc.pred8x8[s->chroma_pred_mode](dest_cr, uvlinesize);
688
689 hl_decode_mb_predict_luma(s, mb_type, block_offset, linesize, dest_y);
690 }
691
692 hl_decode_mb_idct_luma(s, mb_type, block_offset, linesize, dest_y);
693
694 if (s->cbp & 0x30) {
695 uint8_t *dest[2] = { dest_cb, dest_cr };
696 s->h264dsp.h264_chroma_dc_dequant_idct(s->mb + 16 * 16 * 1,
697 s->dequant4_coeff[4][0]);
698 s->h264dsp.h264_chroma_dc_dequant_idct(s->mb + 16 * 16 * 2,
699 s->dequant4_coeff[4][0]);
700 for (j = 1; j < 3; j++) {
701 for (i = j * 16; i < j * 16 + 4; i++)
702 if (s->non_zero_count_cache[scan8[i]] || s->mb[i * 16]) {
703 uint8_t *const ptr = dest[j - 1] + block_offset[i];
704 svq3_add_idct_c(ptr, s->mb + i * 16,
705 uvlinesize, ff_h264_chroma_qp[0][s->qscale + 12] - 12, 2);
706 }
707 }
708 }
709 }
710
svq3_decode_mb(SVQ3Context * s,unsigned int mb_type)711 static int svq3_decode_mb(SVQ3Context *s, unsigned int mb_type)
712 {
713 int i, j, k, m, dir, mode;
714 int cbp = 0;
715 uint32_t vlc;
716 int8_t *top, *left;
717 const int mb_xy = s->mb_xy;
718 const int b_xy = 4 * s->mb_x + 4 * s->mb_y * s->b_stride;
719
720 s->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
721 s->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
722
723 if (mb_type == 0) { /* SKIP */
724 if (s->pict_type == AV_PICTURE_TYPE_P ||
725 s->next_pic->mb_type[mb_xy] == -1) {
726 svq3_mc_dir_part(s, 16 * s->mb_x, 16 * s->mb_y, 16, 16,
727 0, 0, 0, 0, 0, 0);
728
729 if (s->pict_type == AV_PICTURE_TYPE_B)
730 svq3_mc_dir_part(s, 16 * s->mb_x, 16 * s->mb_y, 16, 16,
731 0, 0, 0, 0, 1, 1);
732
733 mb_type = MB_TYPE_SKIP;
734 } else {
735 mb_type = FFMIN(s->next_pic->mb_type[mb_xy], 6);
736 if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 0, 0) < 0)
737 return -1;
738 if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 1, 1) < 0)
739 return -1;
740
741 mb_type = MB_TYPE_16x16;
742 }
743 } else if (mb_type < 8) { /* INTER */
744 if (s->thirdpel_flag && s->halfpel_flag == !get_bits1(&s->gb_slice))
745 mode = THIRDPEL_MODE;
746 else if (s->halfpel_flag &&
747 s->thirdpel_flag == !get_bits1(&s->gb_slice))
748 mode = HALFPEL_MODE;
749 else
750 mode = FULLPEL_MODE;
751
752 /* fill caches */
753 /* note ref_cache should contain here:
754 * ????????
755 * ???11111
756 * N??11111
757 * N??11111
758 * N??11111
759 */
760
761 for (m = 0; m < 2; m++) {
762 if (s->mb_x > 0 && s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - 1] + 6] != -1) {
763 for (i = 0; i < 4; i++)
764 AV_COPY32(s->mv_cache[m][scan8[0] - 1 + i * 8],
765 s->cur_pic->motion_val[m][b_xy - 1 + i * s->b_stride]);
766 } else {
767 for (i = 0; i < 4; i++)
768 AV_ZERO32(s->mv_cache[m][scan8[0] - 1 + i * 8]);
769 }
770 if (s->mb_y > 0) {
771 memcpy(s->mv_cache[m][scan8[0] - 1 * 8],
772 s->cur_pic->motion_val[m][b_xy - s->b_stride],
773 4 * 2 * sizeof(int16_t));
774 memset(&s->ref_cache[m][scan8[0] - 1 * 8],
775 (s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1, 4);
776
777 if (s->mb_x < s->mb_width - 1) {
778 AV_COPY32(s->mv_cache[m][scan8[0] + 4 - 1 * 8],
779 s->cur_pic->motion_val[m][b_xy - s->b_stride + 4]);
780 s->ref_cache[m][scan8[0] + 4 - 1 * 8] =
781 (s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride + 1] + 6] == -1 ||
782 s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1;
783 } else
784 s->ref_cache[m][scan8[0] + 4 - 1 * 8] = PART_NOT_AVAILABLE;
785 if (s->mb_x > 0) {
786 AV_COPY32(s->mv_cache[m][scan8[0] - 1 - 1 * 8],
787 s->cur_pic->motion_val[m][b_xy - s->b_stride - 1]);
788 s->ref_cache[m][scan8[0] - 1 - 1 * 8] =
789 (s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride - 1] + 3] == -1) ? PART_NOT_AVAILABLE : 1;
790 } else
791 s->ref_cache[m][scan8[0] - 1 - 1 * 8] = PART_NOT_AVAILABLE;
792 } else
793 memset(&s->ref_cache[m][scan8[0] - 1 * 8 - 1],
794 PART_NOT_AVAILABLE, 8);
795
796 if (s->pict_type != AV_PICTURE_TYPE_B)
797 break;
798 }
799
800 /* decode motion vector(s) and form prediction(s) */
801 if (s->pict_type == AV_PICTURE_TYPE_P) {
802 if (svq3_mc_dir(s, mb_type - 1, mode, 0, 0) < 0)
803 return -1;
804 } else { /* AV_PICTURE_TYPE_B */
805 if (mb_type != 2) {
806 if (svq3_mc_dir(s, 0, mode, 0, 0) < 0)
807 return -1;
808 } else {
809 for (i = 0; i < 4; i++)
810 memset(s->cur_pic->motion_val[0][b_xy + i * s->b_stride],
811 0, 4 * 2 * sizeof(int16_t));
812 }
813 if (mb_type != 1) {
814 if (svq3_mc_dir(s, 0, mode, 1, mb_type == 3) < 0)
815 return -1;
816 } else {
817 for (i = 0; i < 4; i++)
818 memset(s->cur_pic->motion_val[1][b_xy + i * s->b_stride],
819 0, 4 * 2 * sizeof(int16_t));
820 }
821 }
822
823 mb_type = MB_TYPE_16x16;
824 } else if (mb_type == 8 || mb_type == 33) { /* INTRA4x4 */
825 int8_t *i4x4 = s->intra4x4_pred_mode + s->mb2br_xy[s->mb_xy];
826 int8_t *i4x4_cache = s->intra4x4_pred_mode_cache;
827
828 memset(s->intra4x4_pred_mode_cache, -1, 8 * 5 * sizeof(int8_t));
829
830 if (mb_type == 8) {
831 if (s->mb_x > 0) {
832 for (i = 0; i < 4; i++)
833 s->intra4x4_pred_mode_cache[scan8[0] - 1 + i * 8] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - 1] + 6 - i];
834 if (s->intra4x4_pred_mode_cache[scan8[0] - 1] == -1)
835 s->left_samples_available = 0x5F5F;
836 }
837 if (s->mb_y > 0) {
838 s->intra4x4_pred_mode_cache[4 + 8 * 0] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride] + 0];
839 s->intra4x4_pred_mode_cache[5 + 8 * 0] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride] + 1];
840 s->intra4x4_pred_mode_cache[6 + 8 * 0] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride] + 2];
841 s->intra4x4_pred_mode_cache[7 + 8 * 0] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride] + 3];
842
843 if (s->intra4x4_pred_mode_cache[4 + 8 * 0] == -1)
844 s->top_samples_available = 0x33FF;
845 }
846
847 /* decode prediction codes for luma blocks */
848 for (i = 0; i < 16; i += 2) {
849 vlc = get_interleaved_ue_golomb(&s->gb_slice);
850
851 if (vlc >= 25U) {
852 av_log(s->avctx, AV_LOG_ERROR,
853 "luma prediction:%"PRIu32"\n", vlc);
854 return -1;
855 }
856
857 left = &s->intra4x4_pred_mode_cache[scan8[i] - 1];
858 top = &s->intra4x4_pred_mode_cache[scan8[i] - 8];
859
860 left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
861 left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
862
863 if (left[1] == -1 || left[2] == -1) {
864 av_log(s->avctx, AV_LOG_ERROR, "weird prediction\n");
865 return -1;
866 }
867 }
868 } else { /* mb_type == 33, DC_128_PRED block type */
869 for (i = 0; i < 4; i++)
870 memset(&s->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_PRED, 4);
871 }
872
873 AV_COPY32(i4x4, i4x4_cache + 4 + 8 * 4);
874 i4x4[4] = i4x4_cache[7 + 8 * 3];
875 i4x4[5] = i4x4_cache[7 + 8 * 2];
876 i4x4[6] = i4x4_cache[7 + 8 * 1];
877
878 if (mb_type == 8) {
879 ff_h264_check_intra4x4_pred_mode(s->intra4x4_pred_mode_cache,
880 s->avctx, s->top_samples_available,
881 s->left_samples_available);
882
883 s->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
884 s->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
885 } else {
886 for (i = 0; i < 4; i++)
887 memset(&s->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_128_PRED, 4);
888
889 s->top_samples_available = 0x33FF;
890 s->left_samples_available = 0x5F5F;
891 }
892
893 mb_type = MB_TYPE_INTRA4x4;
894 } else { /* INTRA16x16 */
895 dir = ff_h264_i_mb_type_info[mb_type - 8].pred_mode;
896 dir = (dir >> 1) ^ 3 * (dir & 1) ^ 1;
897
898 if ((s->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(s->avctx, s->top_samples_available,
899 s->left_samples_available, dir, 0)) < 0) {
900 av_log(s->avctx, AV_LOG_ERROR, "ff_h264_check_intra_pred_mode < 0\n");
901 return s->intra16x16_pred_mode;
902 }
903
904 cbp = ff_h264_i_mb_type_info[mb_type - 8].cbp;
905 mb_type = MB_TYPE_INTRA16x16;
906 }
907
908 if (!IS_INTER(mb_type) && s->pict_type != AV_PICTURE_TYPE_I) {
909 for (i = 0; i < 4; i++)
910 memset(s->cur_pic->motion_val[0][b_xy + i * s->b_stride],
911 0, 4 * 2 * sizeof(int16_t));
912 if (s->pict_type == AV_PICTURE_TYPE_B) {
913 for (i = 0; i < 4; i++)
914 memset(s->cur_pic->motion_val[1][b_xy + i * s->b_stride],
915 0, 4 * 2 * sizeof(int16_t));
916 }
917 }
918 if (!IS_INTRA4x4(mb_type)) {
919 memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy], DC_PRED, 8);
920 }
921 if (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B) {
922 memset(s->non_zero_count_cache + 8, 0, 14 * 8 * sizeof(uint8_t));
923 }
924
925 if (!IS_INTRA16x16(mb_type) &&
926 (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B)) {
927 if ((vlc = get_interleaved_ue_golomb(&s->gb_slice)) >= 48U){
928 av_log(s->avctx, AV_LOG_ERROR, "cbp_vlc=%"PRIu32"\n", vlc);
929 return -1;
930 }
931
932 cbp = IS_INTRA(mb_type) ? ff_h264_golomb_to_intra4x4_cbp[vlc]
933 : ff_h264_golomb_to_inter_cbp[vlc];
934 }
935 if (IS_INTRA16x16(mb_type) ||
936 (s->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
937 s->qscale += get_interleaved_se_golomb(&s->gb_slice);
938
939 if (s->qscale > 31u) {
940 av_log(s->avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
941 return -1;
942 }
943 }
944 if (IS_INTRA16x16(mb_type)) {
945 AV_ZERO128(s->mb_luma_dc[0] + 0);
946 AV_ZERO128(s->mb_luma_dc[0] + 8);
947 if (svq3_decode_block(&s->gb_slice, s->mb_luma_dc[0], 0, 1)) {
948 av_log(s->avctx, AV_LOG_ERROR,
949 "error while decoding intra luma dc\n");
950 return -1;
951 }
952 }
953
954 if (cbp) {
955 const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
956 const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
957
958 for (i = 0; i < 4; i++)
959 if ((cbp & (1 << i))) {
960 for (j = 0; j < 4; j++) {
961 k = index ? (1 * (j & 1) + 2 * (i & 1) +
962 2 * (j & 2) + 4 * (i & 2))
963 : (4 * i + j);
964 s->non_zero_count_cache[scan8[k]] = 1;
965
966 if (svq3_decode_block(&s->gb_slice, &s->mb[16 * k], index, type)) {
967 av_log(s->avctx, AV_LOG_ERROR,
968 "error while decoding block\n");
969 return -1;
970 }
971 }
972 }
973
974 if ((cbp & 0x30)) {
975 for (i = 1; i < 3; ++i)
976 if (svq3_decode_block(&s->gb_slice, &s->mb[16 * 16 * i], 0, 3)) {
977 av_log(s->avctx, AV_LOG_ERROR,
978 "error while decoding chroma dc block\n");
979 return -1;
980 }
981
982 if ((cbp & 0x20)) {
983 for (i = 1; i < 3; i++) {
984 for (j = 0; j < 4; j++) {
985 k = 16 * i + j;
986 s->non_zero_count_cache[scan8[k]] = 1;
987
988 if (svq3_decode_block(&s->gb_slice, &s->mb[16 * k], 1, 1)) {
989 av_log(s->avctx, AV_LOG_ERROR,
990 "error while decoding chroma ac block\n");
991 return -1;
992 }
993 }
994 }
995 }
996 }
997 }
998
999 s->cbp = cbp;
1000 s->cur_pic->mb_type[mb_xy] = mb_type;
1001
1002 if (IS_INTRA(mb_type))
1003 s->chroma_pred_mode = ff_h264_check_intra_pred_mode(s->avctx, s->top_samples_available,
1004 s->left_samples_available, DC_PRED8x8, 1);
1005
1006 return 0;
1007 }
1008
svq3_decode_slice_header(AVCodecContext * avctx)1009 static int svq3_decode_slice_header(AVCodecContext *avctx)
1010 {
1011 SVQ3Context *s = avctx->priv_data;
1012 const int mb_xy = s->mb_xy;
1013 int i, header;
1014 unsigned slice_id;
1015
1016 header = get_bits(&s->gb, 8);
1017
1018 if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
1019 /* TODO: what? */
1020 av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
1021 return -1;
1022 } else {
1023 int slice_bits, slice_bytes, slice_length;
1024 int length = header >> 5 & 3;
1025
1026 slice_length = show_bits(&s->gb, 8 * length);
1027 slice_bits = slice_length * 8;
1028 slice_bytes = slice_length + length - 1;
1029
1030 skip_bits(&s->gb, 8);
1031
1032 av_fast_padded_malloc(&s->slice_buf, &s->slice_buf_size, slice_bytes);
1033 if (!s->slice_buf)
1034 return AVERROR(ENOMEM);
1035
1036 if (slice_bytes * 8LL > get_bits_left(&s->gb)) {
1037 av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
1038 return AVERROR_INVALIDDATA;
1039 }
1040 memcpy(s->slice_buf, s->gb.buffer + s->gb.index / 8, slice_bytes);
1041
1042 if (s->watermark_key) {
1043 uint32_t header = AV_RL32(&s->slice_buf[1]);
1044 AV_WL32(&s->slice_buf[1], header ^ s->watermark_key);
1045 }
1046 init_get_bits(&s->gb_slice, s->slice_buf, slice_bits);
1047
1048 if (length > 0) {
1049 memmove(s->slice_buf, &s->slice_buf[slice_length], length - 1);
1050 }
1051 skip_bits_long(&s->gb, slice_bytes * 8);
1052 }
1053
1054 if ((slice_id = get_interleaved_ue_golomb(&s->gb_slice)) >= 3) {
1055 av_log(s->avctx, AV_LOG_ERROR, "illegal slice type %u \n", slice_id);
1056 return -1;
1057 }
1058
1059 s->slice_type = ff_h264_golomb_to_pict_type[slice_id];
1060
1061 if ((header & 0x9F) == 2) {
1062 i = (s->mb_num < 64) ? 6 : (1 + av_log2(s->mb_num - 1));
1063 get_bits(&s->gb_slice, i);
1064 } else if (get_bits1(&s->gb_slice)) {
1065 avpriv_report_missing_feature(s->avctx, "Media key encryption");
1066 return AVERROR_PATCHWELCOME;
1067 }
1068
1069 s->slice_num = get_bits(&s->gb_slice, 8);
1070 s->qscale = get_bits(&s->gb_slice, 5);
1071 s->adaptive_quant = get_bits1(&s->gb_slice);
1072
1073 /* unknown fields */
1074 skip_bits1(&s->gb_slice);
1075
1076 if (s->has_watermark)
1077 skip_bits1(&s->gb_slice);
1078
1079 skip_bits1(&s->gb_slice);
1080 skip_bits(&s->gb_slice, 2);
1081
1082 if (skip_1stop_8data_bits(&s->gb_slice) < 0)
1083 return AVERROR_INVALIDDATA;
1084
1085 /* reset intra predictors and invalidate motion vector references */
1086 if (s->mb_x > 0) {
1087 memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy - 1] + 3,
1088 -1, 4 * sizeof(int8_t));
1089 memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy - s->mb_x],
1090 -1, 8 * sizeof(int8_t) * s->mb_x);
1091 }
1092 if (s->mb_y > 0) {
1093 memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy - s->mb_stride],
1094 -1, 8 * sizeof(int8_t) * (s->mb_width - s->mb_x));
1095
1096 if (s->mb_x > 0)
1097 s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride - 1] + 3] = -1;
1098 }
1099
1100 return 0;
1101 }
1102
init_dequant4_coeff_table(SVQ3Context * s)1103 static void init_dequant4_coeff_table(SVQ3Context *s)
1104 {
1105 int q, x;
1106 const int max_qp = 51;
1107
1108 for (q = 0; q < max_qp + 1; q++) {
1109 int shift = ff_h264_quant_div6[q] + 2;
1110 int idx = ff_h264_quant_rem6[q];
1111 for (x = 0; x < 16; x++)
1112 s->dequant4_coeff[q][(x >> 2) | ((x << 2) & 0xF)] =
1113 ((uint32_t)ff_h264_dequant4_coeff_init[idx][(x & 1) + ((x >> 2) & 1)] * 16) << shift;
1114 }
1115 }
1116
svq3_decode_init(AVCodecContext * avctx)1117 static av_cold int svq3_decode_init(AVCodecContext *avctx)
1118 {
1119 SVQ3Context *s = avctx->priv_data;
1120 int m, x, y;
1121 unsigned char *extradata;
1122 unsigned char *extradata_end;
1123 unsigned int size;
1124 int marker_found = 0;
1125 int ret;
1126
1127 s->cur_pic = &s->frames[0];
1128 s->last_pic = &s->frames[1];
1129 s->next_pic = &s->frames[2];
1130
1131 s->cur_pic->f = av_frame_alloc();
1132 s->last_pic->f = av_frame_alloc();
1133 s->next_pic->f = av_frame_alloc();
1134 if (!s->cur_pic->f || !s->last_pic->f || !s->next_pic->f)
1135 return AVERROR(ENOMEM);
1136
1137 ff_h264dsp_init(&s->h264dsp, 8, 1);
1138 ff_h264_pred_init(&s->hpc, AV_CODEC_ID_SVQ3, 8, 1);
1139 ff_videodsp_init(&s->vdsp, 8);
1140
1141
1142 avctx->bits_per_raw_sample = 8;
1143
1144 ff_hpeldsp_init(&s->hdsp, avctx->flags);
1145 ff_tpeldsp_init(&s->tdsp);
1146
1147 avctx->pix_fmt = AV_PIX_FMT_YUVJ420P;
1148 avctx->color_range = AVCOL_RANGE_JPEG;
1149
1150 s->avctx = avctx;
1151 s->halfpel_flag = 1;
1152 s->thirdpel_flag = 1;
1153 s->has_watermark = 0;
1154
1155 /* prowl for the "SEQH" marker in the extradata */
1156 extradata = (unsigned char *)avctx->extradata;
1157 extradata_end = avctx->extradata + avctx->extradata_size;
1158 if (extradata) {
1159 for (m = 0; m + 8 < avctx->extradata_size; m++) {
1160 if (!memcmp(extradata, "SEQH", 4)) {
1161 marker_found = 1;
1162 break;
1163 }
1164 extradata++;
1165 }
1166 }
1167
1168 /* if a match was found, parse the extra data */
1169 if (marker_found) {
1170 GetBitContext gb;
1171 int frame_size_code;
1172 int unk0, unk1, unk2, unk3, unk4;
1173 int w,h;
1174
1175 size = AV_RB32(&extradata[4]);
1176 if (size > extradata_end - extradata - 8)
1177 return AVERROR_INVALIDDATA;
1178 init_get_bits(&gb, extradata + 8, size * 8);
1179
1180 /* 'frame size code' and optional 'width, height' */
1181 frame_size_code = get_bits(&gb, 3);
1182 switch (frame_size_code) {
1183 case 0:
1184 w = 160;
1185 h = 120;
1186 break;
1187 case 1:
1188 w = 128;
1189 h = 96;
1190 break;
1191 case 2:
1192 w = 176;
1193 h = 144;
1194 break;
1195 case 3:
1196 w = 352;
1197 h = 288;
1198 break;
1199 case 4:
1200 w = 704;
1201 h = 576;
1202 break;
1203 case 5:
1204 w = 240;
1205 h = 180;
1206 break;
1207 case 6:
1208 w = 320;
1209 h = 240;
1210 break;
1211 case 7:
1212 w = get_bits(&gb, 12);
1213 h = get_bits(&gb, 12);
1214 break;
1215 }
1216 ret = ff_set_dimensions(avctx, w, h);
1217 if (ret < 0)
1218 return ret;
1219
1220 s->halfpel_flag = get_bits1(&gb);
1221 s->thirdpel_flag = get_bits1(&gb);
1222
1223 /* unknown fields */
1224 unk0 = get_bits1(&gb);
1225 unk1 = get_bits1(&gb);
1226 unk2 = get_bits1(&gb);
1227 unk3 = get_bits1(&gb);
1228
1229 s->low_delay = get_bits1(&gb);
1230
1231 /* unknown field */
1232 unk4 = get_bits1(&gb);
1233
1234 av_log(avctx, AV_LOG_DEBUG, "Unknown fields %d %d %d %d %d\n",
1235 unk0, unk1, unk2, unk3, unk4);
1236
1237 if (skip_1stop_8data_bits(&gb) < 0)
1238 return AVERROR_INVALIDDATA;
1239
1240 s->has_watermark = get_bits1(&gb);
1241 avctx->has_b_frames = !s->low_delay;
1242 if (s->has_watermark) {
1243 #if CONFIG_ZLIB
1244 unsigned watermark_width = get_interleaved_ue_golomb(&gb);
1245 unsigned watermark_height = get_interleaved_ue_golomb(&gb);
1246 int u1 = get_interleaved_ue_golomb(&gb);
1247 int u2 = get_bits(&gb, 8);
1248 int u3 = get_bits(&gb, 2);
1249 int u4 = get_interleaved_ue_golomb(&gb);
1250 unsigned long buf_len = watermark_width *
1251 watermark_height * 4;
1252 int offset = get_bits_count(&gb) + 7 >> 3;
1253 uint8_t *buf;
1254
1255 if (watermark_height <= 0 ||
1256 (uint64_t)watermark_width * 4 > UINT_MAX / watermark_height)
1257 return AVERROR_INVALIDDATA;
1258
1259 buf = av_malloc(buf_len);
1260 if (!buf)
1261 return AVERROR(ENOMEM);
1262
1263 av_log(avctx, AV_LOG_DEBUG, "watermark size: %ux%u\n",
1264 watermark_width, watermark_height);
1265 av_log(avctx, AV_LOG_DEBUG,
1266 "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n",
1267 u1, u2, u3, u4, offset);
1268 if (uncompress(buf, &buf_len, extradata + 8 + offset,
1269 size - offset) != Z_OK) {
1270 av_log(avctx, AV_LOG_ERROR,
1271 "could not uncompress watermark logo\n");
1272 av_free(buf);
1273 return -1;
1274 }
1275 s->watermark_key = av_bswap16(av_crc(av_crc_get_table(AV_CRC_16_CCITT), 0, buf, buf_len));
1276
1277 s->watermark_key = s->watermark_key << 16 | s->watermark_key;
1278 av_log(avctx, AV_LOG_DEBUG,
1279 "watermark key %#"PRIx32"\n", s->watermark_key);
1280 av_free(buf);
1281 #else
1282 av_log(avctx, AV_LOG_ERROR,
1283 "this svq3 file contains watermark which need zlib support compiled in\n");
1284 return AVERROR(ENOSYS);
1285 #endif
1286 }
1287 }
1288
1289 s->mb_width = (avctx->width + 15) / 16;
1290 s->mb_height = (avctx->height + 15) / 16;
1291 s->mb_stride = s->mb_width + 1;
1292 s->mb_num = s->mb_width * s->mb_height;
1293 s->b_stride = 4 * s->mb_width;
1294 s->h_edge_pos = s->mb_width * 16;
1295 s->v_edge_pos = s->mb_height * 16;
1296
1297 s->intra4x4_pred_mode = av_mallocz(s->mb_stride * 2 * 8);
1298 if (!s->intra4x4_pred_mode)
1299 return AVERROR(ENOMEM);
1300
1301 s->mb2br_xy = av_mallocz(s->mb_stride * (s->mb_height + 1) *
1302 sizeof(*s->mb2br_xy));
1303 if (!s->mb2br_xy)
1304 return AVERROR(ENOMEM);
1305
1306 for (y = 0; y < s->mb_height; y++)
1307 for (x = 0; x < s->mb_width; x++) {
1308 const int mb_xy = x + y * s->mb_stride;
1309
1310 s->mb2br_xy[mb_xy] = 8 * (mb_xy % (2 * s->mb_stride));
1311 }
1312
1313 init_dequant4_coeff_table(s);
1314
1315 return 0;
1316 }
1317
free_picture(SVQ3Frame * pic)1318 static void free_picture(SVQ3Frame *pic)
1319 {
1320 int i;
1321 for (i = 0; i < 2; i++) {
1322 av_freep(&pic->motion_val_buf[i]);
1323 }
1324 av_freep(&pic->mb_type_buf);
1325
1326 av_frame_unref(pic->f);
1327 }
1328
get_buffer(AVCodecContext * avctx,SVQ3Frame * pic)1329 static int get_buffer(AVCodecContext *avctx, SVQ3Frame *pic)
1330 {
1331 SVQ3Context *s = avctx->priv_data;
1332 const int big_mb_num = s->mb_stride * (s->mb_height + 1) + 1;
1333 const int b4_stride = s->mb_width * 4 + 1;
1334 const int b4_array_size = b4_stride * s->mb_height * 4;
1335 int ret;
1336
1337 if (!pic->motion_val_buf[0]) {
1338 int i;
1339
1340 pic->mb_type_buf = av_calloc(big_mb_num + s->mb_stride, sizeof(uint32_t));
1341 if (!pic->mb_type_buf)
1342 return AVERROR(ENOMEM);
1343 pic->mb_type = pic->mb_type_buf + 2 * s->mb_stride + 1;
1344
1345 for (i = 0; i < 2; i++) {
1346 pic->motion_val_buf[i] = av_calloc(b4_array_size + 4, 2 * sizeof(int16_t));
1347 if (!pic->motion_val_buf[i]) {
1348 ret = AVERROR(ENOMEM);
1349 goto fail;
1350 }
1351
1352 pic->motion_val[i] = pic->motion_val_buf[i] + 4;
1353 }
1354 }
1355
1356 ret = ff_get_buffer(avctx, pic->f,
1357 (s->pict_type != AV_PICTURE_TYPE_B) ?
1358 AV_GET_BUFFER_FLAG_REF : 0);
1359 if (ret < 0)
1360 goto fail;
1361
1362 if (!s->edge_emu_buffer) {
1363 s->edge_emu_buffer = av_calloc(pic->f->linesize[0], 17);
1364 if (!s->edge_emu_buffer)
1365 return AVERROR(ENOMEM);
1366 }
1367
1368 return 0;
1369 fail:
1370 free_picture(pic);
1371 return ret;
1372 }
1373
svq3_decode_frame(AVCodecContext * avctx,AVFrame * rframe,int * got_frame,AVPacket * avpkt)1374 static int svq3_decode_frame(AVCodecContext *avctx, AVFrame *rframe,
1375 int *got_frame, AVPacket *avpkt)
1376 {
1377 SVQ3Context *s = avctx->priv_data;
1378 int buf_size = avpkt->size;
1379 int left;
1380 int ret, m, i;
1381
1382 /* special case for last picture */
1383 if (buf_size == 0) {
1384 if (s->next_pic->f->data[0] && !s->low_delay && !s->last_frame_output) {
1385 ret = av_frame_ref(rframe, s->next_pic->f);
1386 if (ret < 0)
1387 return ret;
1388 s->last_frame_output = 1;
1389 *got_frame = 1;
1390 }
1391 return 0;
1392 }
1393
1394 s->mb_x = s->mb_y = s->mb_xy = 0;
1395
1396 ret = init_get_bits8(&s->gb, avpkt->data, avpkt->size);
1397 if (ret < 0)
1398 return ret;
1399
1400 if (svq3_decode_slice_header(avctx))
1401 return -1;
1402
1403 s->pict_type = s->slice_type;
1404
1405 if (s->pict_type != AV_PICTURE_TYPE_B)
1406 FFSWAP(SVQ3Frame*, s->next_pic, s->last_pic);
1407
1408 av_frame_unref(s->cur_pic->f);
1409
1410 /* for skipping the frame */
1411 s->cur_pic->f->pict_type = s->pict_type;
1412 s->cur_pic->f->key_frame = (s->pict_type == AV_PICTURE_TYPE_I);
1413
1414 ret = get_buffer(avctx, s->cur_pic);
1415 if (ret < 0)
1416 return ret;
1417
1418 for (i = 0; i < 16; i++) {
1419 s->block_offset[i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * s->cur_pic->f->linesize[0] * ((scan8[i] - scan8[0]) >> 3);
1420 s->block_offset[48 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * s->cur_pic->f->linesize[0] * ((scan8[i] - scan8[0]) >> 3);
1421 }
1422 for (i = 0; i < 16; i++) {
1423 s->block_offset[16 + i] =
1424 s->block_offset[32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * s->cur_pic->f->linesize[1] * ((scan8[i] - scan8[0]) >> 3);
1425 s->block_offset[48 + 16 + i] =
1426 s->block_offset[48 + 32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * s->cur_pic->f->linesize[1] * ((scan8[i] - scan8[0]) >> 3);
1427 }
1428
1429 if (s->pict_type != AV_PICTURE_TYPE_I) {
1430 if (!s->last_pic->f->data[0]) {
1431 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1432 av_frame_unref(s->last_pic->f);
1433 ret = get_buffer(avctx, s->last_pic);
1434 if (ret < 0)
1435 return ret;
1436 memset(s->last_pic->f->data[0], 0, avctx->height * s->last_pic->f->linesize[0]);
1437 memset(s->last_pic->f->data[1], 0x80, (avctx->height / 2) *
1438 s->last_pic->f->linesize[1]);
1439 memset(s->last_pic->f->data[2], 0x80, (avctx->height / 2) *
1440 s->last_pic->f->linesize[2]);
1441 }
1442
1443 if (s->pict_type == AV_PICTURE_TYPE_B && !s->next_pic->f->data[0]) {
1444 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1445 av_frame_unref(s->next_pic->f);
1446 ret = get_buffer(avctx, s->next_pic);
1447 if (ret < 0)
1448 return ret;
1449 memset(s->next_pic->f->data[0], 0, avctx->height * s->next_pic->f->linesize[0]);
1450 memset(s->next_pic->f->data[1], 0x80, (avctx->height / 2) *
1451 s->next_pic->f->linesize[1]);
1452 memset(s->next_pic->f->data[2], 0x80, (avctx->height / 2) *
1453 s->next_pic->f->linesize[2]);
1454 }
1455 }
1456
1457 if (avctx->debug & FF_DEBUG_PICT_INFO)
1458 av_log(s->avctx, AV_LOG_DEBUG,
1459 "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
1460 av_get_picture_type_char(s->pict_type),
1461 s->halfpel_flag, s->thirdpel_flag,
1462 s->adaptive_quant, s->qscale, s->slice_num);
1463
1464 if (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B ||
1465 avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I ||
1466 avctx->skip_frame >= AVDISCARD_ALL)
1467 return 0;
1468
1469 if (s->pict_type == AV_PICTURE_TYPE_B) {
1470 s->frame_num_offset = s->slice_num - s->prev_frame_num;
1471
1472 if (s->frame_num_offset < 0)
1473 s->frame_num_offset += 256;
1474 if (s->frame_num_offset == 0 ||
1475 s->frame_num_offset >= s->prev_frame_num_offset) {
1476 av_log(s->avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1477 return -1;
1478 }
1479 } else {
1480 s->prev_frame_num = s->frame_num;
1481 s->frame_num = s->slice_num;
1482 s->prev_frame_num_offset = s->frame_num - s->prev_frame_num;
1483
1484 if (s->prev_frame_num_offset < 0)
1485 s->prev_frame_num_offset += 256;
1486 }
1487
1488 for (m = 0; m < 2; m++) {
1489 int i;
1490 for (i = 0; i < 4; i++) {
1491 int j;
1492 for (j = -1; j < 4; j++)
1493 s->ref_cache[m][scan8[0] + 8 * i + j] = 1;
1494 if (i < 3)
1495 s->ref_cache[m][scan8[0] + 8 * i + j] = PART_NOT_AVAILABLE;
1496 }
1497 }
1498
1499 for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
1500 for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
1501 unsigned mb_type;
1502 s->mb_xy = s->mb_x + s->mb_y * s->mb_stride;
1503
1504 if ((get_bits_left(&s->gb_slice)) <= 7) {
1505 if (((get_bits_count(&s->gb_slice) & 7) == 0 ||
1506 show_bits(&s->gb_slice, get_bits_left(&s->gb_slice) & 7) == 0)) {
1507
1508 if (svq3_decode_slice_header(avctx))
1509 return -1;
1510 }
1511 if (s->slice_type != s->pict_type) {
1512 avpriv_request_sample(avctx, "non constant slice type");
1513 }
1514 /* TODO: support s->mb_skip_run */
1515 }
1516
1517 mb_type = get_interleaved_ue_golomb(&s->gb_slice);
1518
1519 if (s->pict_type == AV_PICTURE_TYPE_I)
1520 mb_type += 8;
1521 else if (s->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4)
1522 mb_type += 4;
1523 if (mb_type > 33 || svq3_decode_mb(s, mb_type)) {
1524 av_log(s->avctx, AV_LOG_ERROR,
1525 "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1526 return -1;
1527 }
1528
1529 if (mb_type != 0 || s->cbp)
1530 hl_decode_mb(s);
1531
1532 if (s->pict_type != AV_PICTURE_TYPE_B && !s->low_delay)
1533 s->cur_pic->mb_type[s->mb_x + s->mb_y * s->mb_stride] =
1534 (s->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1535 }
1536
1537 ff_draw_horiz_band(avctx, s->cur_pic->f,
1538 s->last_pic->f->data[0] ? s->last_pic->f : NULL,
1539 16 * s->mb_y, 16, PICT_FRAME, 0,
1540 s->low_delay);
1541 }
1542
1543 left = buf_size*8 - get_bits_count(&s->gb_slice);
1544
1545 if (s->mb_y != s->mb_height || s->mb_x != s->mb_width) {
1546 av_log(avctx, AV_LOG_INFO, "frame num %d incomplete pic x %d y %d left %d\n", avctx->frame_number, s->mb_y, s->mb_x, left);
1547 //av_hex_dump(stderr, buf+buf_size-8, 8);
1548 }
1549
1550 if (left < 0) {
1551 av_log(avctx, AV_LOG_ERROR, "frame num %d left %d\n", avctx->frame_number, left);
1552 return -1;
1553 }
1554
1555 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay)
1556 ret = av_frame_ref(rframe, s->cur_pic->f);
1557 else if (s->last_pic->f->data[0])
1558 ret = av_frame_ref(rframe, s->last_pic->f);
1559 if (ret < 0)
1560 return ret;
1561
1562 /* Do not output the last pic after seeking. */
1563 if (s->last_pic->f->data[0] || s->low_delay)
1564 *got_frame = 1;
1565
1566 if (s->pict_type != AV_PICTURE_TYPE_B) {
1567 FFSWAP(SVQ3Frame*, s->cur_pic, s->next_pic);
1568 } else {
1569 av_frame_unref(s->cur_pic->f);
1570 }
1571
1572 return buf_size;
1573 }
1574
svq3_decode_end(AVCodecContext * avctx)1575 static av_cold int svq3_decode_end(AVCodecContext *avctx)
1576 {
1577 SVQ3Context *s = avctx->priv_data;
1578
1579 for (int i = 0; i < FF_ARRAY_ELEMS(s->frames); i++) {
1580 free_picture(&s->frames[i]);
1581 av_frame_free(&s->frames[i].f);
1582 }
1583 av_freep(&s->slice_buf);
1584 av_freep(&s->intra4x4_pred_mode);
1585 av_freep(&s->edge_emu_buffer);
1586 av_freep(&s->mb2br_xy);
1587
1588 return 0;
1589 }
1590
1591 const FFCodec ff_svq3_decoder = {
1592 .p.name = "svq3",
1593 .p.long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1594 .p.type = AVMEDIA_TYPE_VIDEO,
1595 .p.id = AV_CODEC_ID_SVQ3,
1596 .priv_data_size = sizeof(SVQ3Context),
1597 .init = svq3_decode_init,
1598 .close = svq3_decode_end,
1599 FF_CODEC_DECODE_CB(svq3_decode_frame),
1600 .p.capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND |
1601 AV_CODEC_CAP_DR1 |
1602 AV_CODEC_CAP_DELAY,
1603 .p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P,
1604 AV_PIX_FMT_NONE},
1605 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
1606 };
1607