2 * Copyright (c) 2003 The FFmpeg Project
4 * This file is part of FFmpeg.
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.
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.
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
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:
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)
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
45 #include "libavutil/attributes.h"
46 #include "libavutil/crc.h"
47 #include "libavutil/mem_internal.h"
51 #include "mpegutils.h"
57 #include "rectangle.h"
71 typedef struct SVQ3Frame {
74 int16_t (*motion_val_buf[2])[2];
75 int16_t (*motion_val[2])[2];
77 uint32_t *mb_type_buf, *mb_type;
80 typedef struct SVQ3Context {
81 AVCodecContext *avctx;
83 H264DSPContext h264dsp;
93 GetBitContext gb_slice;
95 unsigned slice_buf_size;
99 uint32_t watermark_key;
101 int next_p_frame_damaged;
104 int last_frame_output;
109 int frame_num_offset;
110 int prev_frame_num_offset;
113 enum AVPictureType pict_type;
114 enum AVPictureType slice_type;
119 int mb_width, mb_height;
120 int mb_stride, mb_num;
125 int chroma_pred_mode;
126 int intra16x16_pred_mode;
128 int8_t intra4x4_pred_mode_cache[5 * 8];
129 int8_t (*intra4x4_pred_mode);
131 unsigned int top_samples_available;
132 unsigned int topright_samples_available;
133 unsigned int left_samples_available;
135 uint8_t *edge_emu_buffer;
137 DECLARE_ALIGNED(16, int16_t, mv_cache)[2][5 * 8][2];
138 DECLARE_ALIGNED(8, int8_t, ref_cache)[2][5 * 8];
139 DECLARE_ALIGNED(16, int16_t, mb)[16 * 48 * 2];
140 DECLARE_ALIGNED(16, int16_t, mb_luma_dc)[3][16 * 2];
141 DECLARE_ALIGNED(8, uint8_t, non_zero_count_cache)[15 * 8];
142 uint32_t dequant4_coeff[QP_MAX_NUM + 1][16];
143 int block_offset[2 * (16 * 3)];
147 #define FULLPEL_MODE 1
148 #define HALFPEL_MODE 2
149 #define THIRDPEL_MODE 3
150 #define PREDICT_MODE 4
152 /* dual scan (from some older H.264 draft)
161 static const uint8_t svq3_scan[16] = {
162 0 + 0 * 4, 1 + 0 * 4, 2 + 0 * 4, 2 + 1 * 4,
163 2 + 2 * 4, 3 + 0 * 4, 3 + 1 * 4, 3 + 2 * 4,
164 0 + 1 * 4, 0 + 2 * 4, 1 + 1 * 4, 1 + 2 * 4,
165 0 + 3 * 4, 1 + 3 * 4, 2 + 3 * 4, 3 + 3 * 4,
168 static const uint8_t luma_dc_zigzag_scan[16] = {
169 0 * 16 + 0 * 64, 1 * 16 + 0 * 64, 2 * 16 + 0 * 64, 0 * 16 + 2 * 64,
170 3 * 16 + 0 * 64, 0 * 16 + 1 * 64, 1 * 16 + 1 * 64, 2 * 16 + 1 * 64,
171 1 * 16 + 2 * 64, 2 * 16 + 2 * 64, 3 * 16 + 2 * 64, 0 * 16 + 3 * 64,
172 3 * 16 + 1 * 64, 1 * 16 + 3 * 64, 2 * 16 + 3 * 64, 3 * 16 + 3 * 64,
175 static const uint8_t svq3_pred_0[25][2] = {
178 { 0, 2 }, { 1, 1 }, { 2, 0 },
179 { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
180 { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
181 { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
182 { 2, 4 }, { 3, 3 }, { 4, 2 },
187 static const int8_t svq3_pred_1[6][6][5] = {
188 { { 2, -1, -1, -1, -1 }, { 2, 1, -1, -1, -1 }, { 1, 2, -1, -1, -1 },
189 { 2, 1, -1, -1, -1 }, { 1, 2, -1, -1, -1 }, { 1, 2, -1, -1, -1 } },
190 { { 0, 2, -1, -1, -1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
191 { 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
192 { { 2, 0, -1, -1, -1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
193 { 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
194 { { 2, 0, -1, -1, -1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
195 { 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
196 { { 0, 2, -1, -1, -1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
197 { 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
198 { { 0, 2, -1, -1, -1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
199 { 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
202 static const struct {
205 } svq3_dct_tables[2][16] = {
206 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
207 { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
208 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
209 { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
212 static const uint32_t svq3_dequant_coeff[32] = {
213 3881, 4351, 4890, 5481, 6154, 6914, 7761, 8718,
214 9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
215 24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
216 61694, 68745, 77615, 89113, 100253, 109366, 126635, 141533
219 static void svq3_luma_dc_dequant_idct_c(int16_t *output, int16_t *input, int qp)
221 const unsigned qmul = svq3_dequant_coeff[qp];
225 static const uint8_t x_offset[4] = { 0, 1 * stride, 4 * stride, 5 * stride };
227 for (i = 0; i < 4; i++) {
228 const int z0 = 13 * (input[4 * i + 0] + input[4 * i + 2]);
229 const int z1 = 13 * (input[4 * i + 0] - input[4 * i + 2]);
230 const int z2 = 7 * input[4 * i + 1] - 17 * input[4 * i + 3];
231 const int z3 = 17 * input[4 * i + 1] + 7 * input[4 * i + 3];
233 temp[4 * i + 0] = z0 + z3;
234 temp[4 * i + 1] = z1 + z2;
235 temp[4 * i + 2] = z1 - z2;
236 temp[4 * i + 3] = z0 - z3;
239 for (i = 0; i < 4; i++) {
240 const int offset = x_offset[i];
241 const int z0 = 13 * (temp[4 * 0 + i] + temp[4 * 2 + i]);
242 const int z1 = 13 * (temp[4 * 0 + i] - temp[4 * 2 + i]);
243 const int z2 = 7 * temp[4 * 1 + i] - 17 * temp[4 * 3 + i];
244 const int z3 = 17 * temp[4 * 1 + i] + 7 * temp[4 * 3 + i];
246 output[stride * 0 + offset] = (int)((z0 + z3) * qmul + 0x80000) >> 20;
247 output[stride * 2 + offset] = (int)((z1 + z2) * qmul + 0x80000) >> 20;
248 output[stride * 8 + offset] = (int)((z1 - z2) * qmul + 0x80000) >> 20;
249 output[stride * 10 + offset] = (int)((z0 - z3) * qmul + 0x80000) >> 20;
254 static void svq3_add_idct_c(uint8_t *dst, int16_t *block,
255 int stride, int qp, int dc)
257 const int qmul = svq3_dequant_coeff[qp];
261 dc = 13 * 13 * (dc == 1 ? 1538U* block[0]
262 : qmul * (block[0] >> 3) / 2);
266 for (i = 0; i < 4; i++) {
267 const int z0 = 13 * (block[0 + 4 * i] + block[2 + 4 * i]);
268 const int z1 = 13 * (block[0 + 4 * i] - block[2 + 4 * i]);
269 const int z2 = 7 * block[1 + 4 * i] - 17 * block[3 + 4 * i];
270 const int z3 = 17 * block[1 + 4 * i] + 7 * block[3 + 4 * i];
272 block[0 + 4 * i] = z0 + z3;
273 block[1 + 4 * i] = z1 + z2;
274 block[2 + 4 * i] = z1 - z2;
275 block[3 + 4 * i] = z0 - z3;
278 for (i = 0; i < 4; i++) {
279 const unsigned z0 = 13 * (block[i + 4 * 0] + block[i + 4 * 2]);
280 const unsigned z1 = 13 * (block[i + 4 * 0] - block[i + 4 * 2]);
281 const unsigned z2 = 7 * block[i + 4 * 1] - 17 * block[i + 4 * 3];
282 const unsigned z3 = 17 * block[i + 4 * 1] + 7 * block[i + 4 * 3];
283 const int rr = (dc + 0x80000u);
285 dst[i + stride * 0] = av_clip_uint8(dst[i + stride * 0] + ((int)((z0 + z3) * qmul + rr) >> 20));
286 dst[i + stride * 1] = av_clip_uint8(dst[i + stride * 1] + ((int)((z1 + z2) * qmul + rr) >> 20));
287 dst[i + stride * 2] = av_clip_uint8(dst[i + stride * 2] + ((int)((z1 - z2) * qmul + rr) >> 20));
288 dst[i + stride * 3] = av_clip_uint8(dst[i + stride * 3] + ((int)((z0 - z3) * qmul + rr) >> 20));
291 memset(block, 0, 16 * sizeof(int16_t));
294 static inline int svq3_decode_block(GetBitContext *gb, int16_t *block,
295 int index, const int type)
297 static const uint8_t *const scan_patterns[4] = {
298 luma_dc_zigzag_scan, ff_zigzag_scan, svq3_scan, ff_h264_chroma_dc_scan
301 int run, level, sign, limit;
303 const int intra = 3 * type >> 2;
304 const uint8_t *const scan = scan_patterns[type];
306 for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
307 for (; (vlc = get_interleaved_ue_golomb(gb)) != 0; index++) {
308 if ((int32_t)vlc < 0)
311 sign = (vlc & 1) ? 0 : -1;
318 } else if (vlc < 4) {
323 level = (vlc + 9 >> 2) - run;
327 run = svq3_dct_tables[intra][vlc].run;
328 level = svq3_dct_tables[intra][vlc].level;
331 level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
334 level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
339 if ((index += run) >= limit)
342 block[scan[index]] = (level ^ sign) - sign;
353 static av_always_inline int
354 svq3_fetch_diagonal_mv(const SVQ3Context *s, const int16_t **C,
355 int i, int list, int part_width)
357 const int topright_ref = s->ref_cache[list][i - 8 + part_width];
359 if (topright_ref != PART_NOT_AVAILABLE) {
360 *C = s->mv_cache[list][i - 8 + part_width];
363 *C = s->mv_cache[list][i - 8 - 1];
364 return s->ref_cache[list][i - 8 - 1];
369 * Get the predicted MV.
370 * @param n the block index
371 * @param part_width the width of the partition (4, 8,16) -> (1, 2, 4)
372 * @param mx the x component of the predicted motion vector
373 * @param my the y component of the predicted motion vector
375 static av_always_inline void svq3_pred_motion(const SVQ3Context *s, int n,
376 int part_width, int list,
377 int ref, int *const mx, int *const my)
379 const int index8 = scan8[n];
380 const int top_ref = s->ref_cache[list][index8 - 8];
381 const int left_ref = s->ref_cache[list][index8 - 1];
382 const int16_t *const A = s->mv_cache[list][index8 - 1];
383 const int16_t *const B = s->mv_cache[list][index8 - 8];
385 int diagonal_ref, match_count;
395 diagonal_ref = svq3_fetch_diagonal_mv(s, &C, index8, list, part_width);
396 match_count = (diagonal_ref == ref) + (top_ref == ref) + (left_ref == ref);
397 if (match_count > 1) { //most common
398 *mx = mid_pred(A[0], B[0], C[0]);
399 *my = mid_pred(A[1], B[1], C[1]);
400 } else if (match_count == 1) {
401 if (left_ref == ref) {
404 } else if (top_ref == ref) {
412 if (top_ref == PART_NOT_AVAILABLE &&
413 diagonal_ref == PART_NOT_AVAILABLE &&
414 left_ref != PART_NOT_AVAILABLE) {
418 *mx = mid_pred(A[0], B[0], C[0]);
419 *my = mid_pred(A[1], B[1], C[1]);
424 static inline void svq3_mc_dir_part(SVQ3Context *s,
425 int x, int y, int width, int height,
426 int mx, int my, int dxy,
427 int thirdpel, int dir, int avg)
429 const SVQ3Frame *pic = (dir == 0) ? s->last_pic : s->next_pic;
432 int blocksize = 2 - (width >> 3); // 16->0, 8->1, 4->2
433 int linesize = s->cur_pic->f->linesize[0];
434 int uvlinesize = s->cur_pic->f->linesize[1];
439 if (mx < 0 || mx >= s->h_edge_pos - width - 1 ||
440 my < 0 || my >= s->v_edge_pos - height - 1) {
442 mx = av_clip(mx, -16, s->h_edge_pos - width + 15);
443 my = av_clip(my, -16, s->v_edge_pos - height + 15);
446 /* form component predictions */
447 dest = s->cur_pic->f->data[0] + x + y * linesize;
448 src = pic->f->data[0] + mx + my * linesize;
451 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src,
453 width + 1, height + 1,
454 mx, my, s->h_edge_pos, s->v_edge_pos);
455 src = s->edge_emu_buffer;
458 (avg ? s->tdsp.avg_tpel_pixels_tab
459 : s->tdsp.put_tpel_pixels_tab)[dxy](dest, src, linesize,
462 (avg ? s->hdsp.avg_pixels_tab
463 : s->hdsp.put_pixels_tab)[blocksize][dxy](dest, src, linesize,
466 if (!(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
467 mx = mx + (mx < (int) x) >> 1;
468 my = my + (my < (int) y) >> 1;
470 height = height >> 1;
473 for (i = 1; i < 3; i++) {
474 dest = s->cur_pic->f->data[i] + (x >> 1) + (y >> 1) * uvlinesize;
475 src = pic->f->data[i] + mx + my * uvlinesize;
478 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src,
479 uvlinesize, uvlinesize,
480 width + 1, height + 1,
481 mx, my, (s->h_edge_pos >> 1),
483 src = s->edge_emu_buffer;
486 (avg ? s->tdsp.avg_tpel_pixels_tab
487 : s->tdsp.put_tpel_pixels_tab)[dxy](dest, src,
491 (avg ? s->hdsp.avg_pixels_tab
492 : s->hdsp.put_pixels_tab)[blocksize][dxy](dest, src,
499 static inline int svq3_mc_dir(SVQ3Context *s, int size, int mode,
502 int i, j, k, mx, my, dx, dy, x, y;
503 const int part_width = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
504 const int part_height = 16 >> ((unsigned)(size + 1) / 3);
505 const int extra_width = (mode == PREDICT_MODE) ? -16 * 6 : 0;
506 const int h_edge_pos = 6 * (s->h_edge_pos - part_width) - extra_width;
507 const int v_edge_pos = 6 * (s->v_edge_pos - part_height) - extra_width;
509 for (i = 0; i < 16; i += part_height)
510 for (j = 0; j < 16; j += part_width) {
511 const int b_xy = (4 * s->mb_x + (j >> 2)) +
512 (4 * s->mb_y + (i >> 2)) * s->b_stride;
514 x = 16 * s->mb_x + j;
515 y = 16 * s->mb_y + i;
516 k = (j >> 2 & 1) + (i >> 1 & 2) +
517 (j >> 1 & 4) + (i & 8);
519 if (mode != PREDICT_MODE) {
520 svq3_pred_motion(s, k, part_width >> 2, dir, 1, &mx, &my);
522 mx = s->next_pic->motion_val[0][b_xy][0] * 2;
523 my = s->next_pic->motion_val[0][b_xy][1] * 2;
526 mx = mx * s->frame_num_offset /
527 s->prev_frame_num_offset + 1 >> 1;
528 my = my * s->frame_num_offset /
529 s->prev_frame_num_offset + 1 >> 1;
531 mx = mx * (s->frame_num_offset - s->prev_frame_num_offset) /
532 s->prev_frame_num_offset + 1 >> 1;
533 my = my * (s->frame_num_offset - s->prev_frame_num_offset) /
534 s->prev_frame_num_offset + 1 >> 1;
538 /* clip motion vector prediction to frame border */
539 mx = av_clip(mx, extra_width - 6 * x, h_edge_pos - 6 * x);
540 my = av_clip(my, extra_width - 6 * y, v_edge_pos - 6 * y);
542 /* get (optional) motion vector differential */
543 if (mode == PREDICT_MODE) {
546 dy = get_interleaved_se_golomb(&s->gb_slice);
547 dx = get_interleaved_se_golomb(&s->gb_slice);
549 if (dx != (int16_t)dx || dy != (int16_t)dy) {
550 av_log(s->avctx, AV_LOG_ERROR, "invalid MV vlc\n");
555 /* compute motion vector */
556 if (mode == THIRDPEL_MODE) {
558 mx = (mx + 1 >> 1) + dx;
559 my = (my + 1 >> 1) + dy;
560 fx = (unsigned)(mx + 0x30000) / 3 - 0x10000;
561 fy = (unsigned)(my + 0x30000) / 3 - 0x10000;
562 dxy = (mx - 3 * fx) + 4 * (my - 3 * fy);
564 svq3_mc_dir_part(s, x, y, part_width, part_height,
565 fx, fy, dxy, 1, dir, avg);
568 } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
569 mx = (unsigned)(mx + 1 + 0x30000) / 3 + dx - 0x10000;
570 my = (unsigned)(my + 1 + 0x30000) / 3 + dy - 0x10000;
571 dxy = (mx & 1) + 2 * (my & 1);
573 svq3_mc_dir_part(s, x, y, part_width, part_height,
574 mx >> 1, my >> 1, dxy, 0, dir, avg);
578 mx = (unsigned)(mx + 3 + 0x60000) / 6 + dx - 0x10000;
579 my = (unsigned)(my + 3 + 0x60000) / 6 + dy - 0x10000;
581 svq3_mc_dir_part(s, x, y, part_width, part_height,
582 mx, my, 0, 0, dir, avg);
587 /* update mv_cache */
588 if (mode != PREDICT_MODE) {
589 int32_t mv = pack16to32(mx, my);
591 if (part_height == 8 && i < 8) {
592 AV_WN32A(s->mv_cache[dir][scan8[k] + 1 * 8], mv);
594 if (part_width == 8 && j < 8)
595 AV_WN32A(s->mv_cache[dir][scan8[k] + 1 + 1 * 8], mv);
597 if (part_width == 8 && j < 8)
598 AV_WN32A(s->mv_cache[dir][scan8[k] + 1], mv);
599 if (part_width == 4 || part_height == 4)
600 AV_WN32A(s->mv_cache[dir][scan8[k]], mv);
603 /* write back motion vectors */
604 fill_rectangle(s->cur_pic->motion_val[dir][b_xy],
605 part_width >> 2, part_height >> 2, s->b_stride,
606 pack16to32(mx, my), 4);
612 static av_always_inline void hl_decode_mb_idct_luma(SVQ3Context *s,
613 int mb_type, const int *block_offset,
614 int linesize, uint8_t *dest_y)
617 if (!IS_INTRA4x4(mb_type)) {
618 for (i = 0; i < 16; i++)
619 if (s->non_zero_count_cache[scan8[i]] || s->mb[i * 16]) {
620 uint8_t *const ptr = dest_y + block_offset[i];
621 svq3_add_idct_c(ptr, s->mb + i * 16, linesize,
622 s->qscale, IS_INTRA(mb_type) ? 1 : 0);
627 static av_always_inline void hl_decode_mb_predict_luma(SVQ3Context *s,
629 const int *block_offset,
634 int qscale = s->qscale;
636 if (IS_INTRA4x4(mb_type)) {
637 for (i = 0; i < 16; i++) {
638 uint8_t *const ptr = dest_y + block_offset[i];
639 const int dir = s->intra4x4_pred_mode_cache[scan8[i]];
643 if (dir == DIAG_DOWN_LEFT_PRED || dir == VERT_LEFT_PRED) {
644 const int topright_avail = (s->topright_samples_available << i) & 0x8000;
645 av_assert2(s->mb_y || linesize <= block_offset[i]);
646 if (!topright_avail) {
647 tr = ptr[3 - linesize] * 0x01010101u;
648 topright = (uint8_t *)&tr;
650 topright = ptr + 4 - linesize;
654 s->hpc.pred4x4[dir](ptr, topright, linesize);
655 nnz = s->non_zero_count_cache[scan8[i]];
657 svq3_add_idct_c(ptr, s->mb + i * 16, linesize, qscale, 0);
661 s->hpc.pred16x16[s->intra16x16_pred_mode](dest_y, linesize);
662 svq3_luma_dc_dequant_idct_c(s->mb, s->mb_luma_dc[0], qscale);
666 static void hl_decode_mb(SVQ3Context *s)
668 const int mb_x = s->mb_x;
669 const int mb_y = s->mb_y;
670 const int mb_xy = s->mb_xy;
671 const int mb_type = s->cur_pic->mb_type[mb_xy];
672 uint8_t *dest_y, *dest_cb, *dest_cr;
673 int linesize, uvlinesize;
675 const int *block_offset = &s->block_offset[0];
676 const int block_h = 16 >> 1;
678 linesize = s->cur_pic->f->linesize[0];
679 uvlinesize = s->cur_pic->f->linesize[1];
681 dest_y = s->cur_pic->f->data[0] + (mb_x + mb_y * linesize) * 16;
682 dest_cb = s->cur_pic->f->data[1] + mb_x * 8 + mb_y * uvlinesize * block_h;
683 dest_cr = s->cur_pic->f->data[2] + mb_x * 8 + mb_y * uvlinesize * block_h;
685 s->vdsp.prefetch(dest_y + (s->mb_x & 3) * 4 * linesize + 64, linesize, 4);
686 s->vdsp.prefetch(dest_cb + (s->mb_x & 7) * uvlinesize + 64, dest_cr - dest_cb, 2);
688 if (IS_INTRA(mb_type)) {
689 s->hpc.pred8x8[s->chroma_pred_mode](dest_cb, uvlinesize);
690 s->hpc.pred8x8[s->chroma_pred_mode](dest_cr, uvlinesize);
692 hl_decode_mb_predict_luma(s, mb_type, block_offset, linesize, dest_y);
695 hl_decode_mb_idct_luma(s, mb_type, block_offset, linesize, dest_y);
698 uint8_t *dest[2] = { dest_cb, dest_cr };
699 s->h264dsp.h264_chroma_dc_dequant_idct(s->mb + 16 * 16 * 1,
700 s->dequant4_coeff[4][0]);
701 s->h264dsp.h264_chroma_dc_dequant_idct(s->mb + 16 * 16 * 2,
702 s->dequant4_coeff[4][0]);
703 for (j = 1; j < 3; j++) {
704 for (i = j * 16; i < j * 16 + 4; i++)
705 if (s->non_zero_count_cache[scan8[i]] || s->mb[i * 16]) {
706 uint8_t *const ptr = dest[j - 1] + block_offset[i];
707 svq3_add_idct_c(ptr, s->mb + i * 16,
708 uvlinesize, ff_h264_chroma_qp[0][s->qscale + 12] - 12, 2);
714 static int svq3_decode_mb(SVQ3Context *s, unsigned int mb_type)
716 int i, j, k, m, dir, mode;
720 const int mb_xy = s->mb_xy;
721 const int b_xy = 4 * s->mb_x + 4 * s->mb_y * s->b_stride;
723 s->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
724 s->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
725 s->topright_samples_available = 0xFFFF;
727 if (mb_type == 0) { /* SKIP */
728 if (s->pict_type == AV_PICTURE_TYPE_P ||
729 s->next_pic->mb_type[mb_xy] == -1) {
730 svq3_mc_dir_part(s, 16 * s->mb_x, 16 * s->mb_y, 16, 16,
733 if (s->pict_type == AV_PICTURE_TYPE_B)
734 svq3_mc_dir_part(s, 16 * s->mb_x, 16 * s->mb_y, 16, 16,
737 mb_type = MB_TYPE_SKIP;
739 mb_type = FFMIN(s->next_pic->mb_type[mb_xy], 6);
740 if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 0, 0) < 0)
742 if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 1, 1) < 0)
745 mb_type = MB_TYPE_16x16;
747 } else if (mb_type < 8) { /* INTER */
748 if (s->thirdpel_flag && s->halfpel_flag == !get_bits1(&s->gb_slice))
749 mode = THIRDPEL_MODE;
750 else if (s->halfpel_flag &&
751 s->thirdpel_flag == !get_bits1(&s->gb_slice))
757 /* note ref_cache should contain here:
765 for (m = 0; m < 2; m++) {
766 if (s->mb_x > 0 && s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - 1] + 6] != -1) {
767 for (i = 0; i < 4; i++)
768 AV_COPY32(s->mv_cache[m][scan8[0] - 1 + i * 8],
769 s->cur_pic->motion_val[m][b_xy - 1 + i * s->b_stride]);
771 for (i = 0; i < 4; i++)
772 AV_ZERO32(s->mv_cache[m][scan8[0] - 1 + i * 8]);
775 memcpy(s->mv_cache[m][scan8[0] - 1 * 8],
776 s->cur_pic->motion_val[m][b_xy - s->b_stride],
777 4 * 2 * sizeof(int16_t));
778 memset(&s->ref_cache[m][scan8[0] - 1 * 8],
779 (s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1, 4);
781 if (s->mb_x < s->mb_width - 1) {
782 AV_COPY32(s->mv_cache[m][scan8[0] + 4 - 1 * 8],
783 s->cur_pic->motion_val[m][b_xy - s->b_stride + 4]);
784 s->ref_cache[m][scan8[0] + 4 - 1 * 8] =
785 (s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride + 1] + 6] == -1 ||
786 s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1;
788 s->ref_cache[m][scan8[0] + 4 - 1 * 8] = PART_NOT_AVAILABLE;
790 AV_COPY32(s->mv_cache[m][scan8[0] - 1 - 1 * 8],
791 s->cur_pic->motion_val[m][b_xy - s->b_stride - 1]);
792 s->ref_cache[m][scan8[0] - 1 - 1 * 8] =
793 (s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride - 1] + 3] == -1) ? PART_NOT_AVAILABLE : 1;
795 s->ref_cache[m][scan8[0] - 1 - 1 * 8] = PART_NOT_AVAILABLE;
797 memset(&s->ref_cache[m][scan8[0] - 1 * 8 - 1],
798 PART_NOT_AVAILABLE, 8);
800 if (s->pict_type != AV_PICTURE_TYPE_B)
804 /* decode motion vector(s) and form prediction(s) */
805 if (s->pict_type == AV_PICTURE_TYPE_P) {
806 if (svq3_mc_dir(s, mb_type - 1, mode, 0, 0) < 0)
808 } else { /* AV_PICTURE_TYPE_B */
810 if (svq3_mc_dir(s, 0, mode, 0, 0) < 0)
813 for (i = 0; i < 4; i++)
814 memset(s->cur_pic->motion_val[0][b_xy + i * s->b_stride],
815 0, 4 * 2 * sizeof(int16_t));
818 if (svq3_mc_dir(s, 0, mode, 1, mb_type == 3) < 0)
821 for (i = 0; i < 4; i++)
822 memset(s->cur_pic->motion_val[1][b_xy + i * s->b_stride],
823 0, 4 * 2 * sizeof(int16_t));
827 mb_type = MB_TYPE_16x16;
828 } else if (mb_type == 8 || mb_type == 33) { /* INTRA4x4 */
829 int8_t *i4x4 = s->intra4x4_pred_mode + s->mb2br_xy[s->mb_xy];
830 int8_t *i4x4_cache = s->intra4x4_pred_mode_cache;
832 memset(s->intra4x4_pred_mode_cache, -1, 8 * 5 * sizeof(int8_t));
836 for (i = 0; i < 4; i++)
837 s->intra4x4_pred_mode_cache[scan8[0] - 1 + i * 8] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - 1] + 6 - i];
838 if (s->intra4x4_pred_mode_cache[scan8[0] - 1] == -1)
839 s->left_samples_available = 0x5F5F;
842 s->intra4x4_pred_mode_cache[4 + 8 * 0] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride] + 0];
843 s->intra4x4_pred_mode_cache[5 + 8 * 0] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride] + 1];
844 s->intra4x4_pred_mode_cache[6 + 8 * 0] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride] + 2];
845 s->intra4x4_pred_mode_cache[7 + 8 * 0] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride] + 3];
847 if (s->intra4x4_pred_mode_cache[4 + 8 * 0] == -1)
848 s->top_samples_available = 0x33FF;
851 /* decode prediction codes for luma blocks */
852 for (i = 0; i < 16; i += 2) {
853 vlc = get_interleaved_ue_golomb(&s->gb_slice);
856 av_log(s->avctx, AV_LOG_ERROR,
857 "luma prediction:%"PRIu32"\n", vlc);
861 left = &s->intra4x4_pred_mode_cache[scan8[i] - 1];
862 top = &s->intra4x4_pred_mode_cache[scan8[i] - 8];
864 left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
865 left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
867 if (left[1] == -1 || left[2] == -1) {
868 av_log(s->avctx, AV_LOG_ERROR, "weird prediction\n");
872 } else { /* mb_type == 33, DC_128_PRED block type */
873 for (i = 0; i < 4; i++)
874 memset(&s->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_PRED, 4);
877 AV_COPY32(i4x4, i4x4_cache + 4 + 8 * 4);
878 i4x4[4] = i4x4_cache[7 + 8 * 3];
879 i4x4[5] = i4x4_cache[7 + 8 * 2];
880 i4x4[6] = i4x4_cache[7 + 8 * 1];
883 ff_h264_check_intra4x4_pred_mode(s->intra4x4_pred_mode_cache,
884 s->avctx, s->top_samples_available,
885 s->left_samples_available);
887 s->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
888 s->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
890 for (i = 0; i < 4; i++)
891 memset(&s->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_128_PRED, 4);
893 s->top_samples_available = 0x33FF;
894 s->left_samples_available = 0x5F5F;
897 mb_type = MB_TYPE_INTRA4x4;
898 } else { /* INTRA16x16 */
899 dir = ff_h264_i_mb_type_info[mb_type - 8].pred_mode;
900 dir = (dir >> 1) ^ 3 * (dir & 1) ^ 1;
902 if ((s->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(s->avctx, s->top_samples_available,
903 s->left_samples_available, dir, 0)) < 0) {
904 av_log(s->avctx, AV_LOG_ERROR, "ff_h264_check_intra_pred_mode < 0\n");
905 return s->intra16x16_pred_mode;
908 cbp = ff_h264_i_mb_type_info[mb_type - 8].cbp;
909 mb_type = MB_TYPE_INTRA16x16;
912 if (!IS_INTER(mb_type) && s->pict_type != AV_PICTURE_TYPE_I) {
913 for (i = 0; i < 4; i++)
914 memset(s->cur_pic->motion_val[0][b_xy + i * s->b_stride],
915 0, 4 * 2 * sizeof(int16_t));
916 if (s->pict_type == AV_PICTURE_TYPE_B) {
917 for (i = 0; i < 4; i++)
918 memset(s->cur_pic->motion_val[1][b_xy + i * s->b_stride],
919 0, 4 * 2 * sizeof(int16_t));
922 if (!IS_INTRA4x4(mb_type)) {
923 memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy], DC_PRED, 8);
925 if (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B) {
926 memset(s->non_zero_count_cache + 8, 0, 14 * 8 * sizeof(uint8_t));
929 if (!IS_INTRA16x16(mb_type) &&
930 (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B)) {
931 if ((vlc = get_interleaved_ue_golomb(&s->gb_slice)) >= 48U){
932 av_log(s->avctx, AV_LOG_ERROR, "cbp_vlc=%"PRIu32"\n", vlc);
936 cbp = IS_INTRA(mb_type) ? ff_h264_golomb_to_intra4x4_cbp[vlc]
937 : ff_h264_golomb_to_inter_cbp[vlc];
939 if (IS_INTRA16x16(mb_type) ||
940 (s->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
941 s->qscale += get_interleaved_se_golomb(&s->gb_slice);
943 if (s->qscale > 31u) {
944 av_log(s->avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
948 if (IS_INTRA16x16(mb_type)) {
949 AV_ZERO128(s->mb_luma_dc[0] + 0);
950 AV_ZERO128(s->mb_luma_dc[0] + 8);
951 if (svq3_decode_block(&s->gb_slice, s->mb_luma_dc[0], 0, 1)) {
952 av_log(s->avctx, AV_LOG_ERROR,
953 "error while decoding intra luma dc\n");
959 const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
960 const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
962 for (i = 0; i < 4; i++)
963 if ((cbp & (1 << i))) {
964 for (j = 0; j < 4; j++) {
965 k = index ? (1 * (j & 1) + 2 * (i & 1) +
966 2 * (j & 2) + 4 * (i & 2))
968 s->non_zero_count_cache[scan8[k]] = 1;
970 if (svq3_decode_block(&s->gb_slice, &s->mb[16 * k], index, type)) {
971 av_log(s->avctx, AV_LOG_ERROR,
972 "error while decoding block\n");
979 for (i = 1; i < 3; ++i)
980 if (svq3_decode_block(&s->gb_slice, &s->mb[16 * 16 * i], 0, 3)) {
981 av_log(s->avctx, AV_LOG_ERROR,
982 "error while decoding chroma dc block\n");
987 for (i = 1; i < 3; i++) {
988 for (j = 0; j < 4; j++) {
990 s->non_zero_count_cache[scan8[k]] = 1;
992 if (svq3_decode_block(&s->gb_slice, &s->mb[16 * k], 1, 1)) {
993 av_log(s->avctx, AV_LOG_ERROR,
994 "error while decoding chroma ac block\n");
1004 s->cur_pic->mb_type[mb_xy] = mb_type;
1006 if (IS_INTRA(mb_type))
1007 s->chroma_pred_mode = ff_h264_check_intra_pred_mode(s->avctx, s->top_samples_available,
1008 s->left_samples_available, DC_PRED8x8, 1);
1013 static int svq3_decode_slice_header(AVCodecContext *avctx)
1015 SVQ3Context *s = avctx->priv_data;
1016 const int mb_xy = s->mb_xy;
1020 header = get_bits(&s->gb, 8);
1022 if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
1024 av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
1027 int slice_bits, slice_bytes, slice_length;
1028 int length = header >> 5 & 3;
1030 slice_length = show_bits(&s->gb, 8 * length);
1031 slice_bits = slice_length * 8;
1032 slice_bytes = slice_length + length - 1;
1034 skip_bits(&s->gb, 8);
1036 av_fast_padded_malloc(&s->slice_buf, &s->slice_buf_size, slice_bytes);
1038 return AVERROR(ENOMEM);
1040 if (slice_bytes * 8LL > get_bits_left(&s->gb)) {
1041 av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
1042 return AVERROR_INVALIDDATA;
1044 memcpy(s->slice_buf, s->gb.buffer + s->gb.index / 8, slice_bytes);
1046 if (s->watermark_key) {
1047 uint32_t header = AV_RL32(&s->slice_buf[1]);
1048 AV_WL32(&s->slice_buf[1], header ^ s->watermark_key);
1050 init_get_bits(&s->gb_slice, s->slice_buf, slice_bits);
1053 memmove(s->slice_buf, &s->slice_buf[slice_length], length - 1);
1055 skip_bits_long(&s->gb, slice_bytes * 8);
1058 if ((slice_id = get_interleaved_ue_golomb(&s->gb_slice)) >= 3) {
1059 av_log(s->avctx, AV_LOG_ERROR, "illegal slice type %u \n", slice_id);
1063 s->slice_type = ff_h264_golomb_to_pict_type[slice_id];
1065 if ((header & 0x9F) == 2) {
1066 i = (s->mb_num < 64) ? 6 : (1 + av_log2(s->mb_num - 1));
1067 get_bits(&s->gb_slice, i);
1068 } else if (get_bits1(&s->gb_slice)) {
1069 avpriv_report_missing_feature(s->avctx, "Media key encryption");
1070 return AVERROR_PATCHWELCOME;
1073 s->slice_num = get_bits(&s->gb_slice, 8);
1074 s->qscale = get_bits(&s->gb_slice, 5);
1075 s->adaptive_quant = get_bits1(&s->gb_slice);
1077 /* unknown fields */
1078 skip_bits1(&s->gb_slice);
1080 if (s->has_watermark)
1081 skip_bits1(&s->gb_slice);
1083 skip_bits1(&s->gb_slice);
1084 skip_bits(&s->gb_slice, 2);
1086 if (skip_1stop_8data_bits(&s->gb_slice) < 0)
1087 return AVERROR_INVALIDDATA;
1089 /* reset intra predictors and invalidate motion vector references */
1091 memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy - 1] + 3,
1092 -1, 4 * sizeof(int8_t));
1093 memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy - s->mb_x],
1094 -1, 8 * sizeof(int8_t) * s->mb_x);
1097 memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy - s->mb_stride],
1098 -1, 8 * sizeof(int8_t) * (s->mb_width - s->mb_x));
1101 s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride - 1] + 3] = -1;
1107 static void init_dequant4_coeff_table(SVQ3Context *s)
1110 const int max_qp = 51;
1112 for (q = 0; q < max_qp + 1; q++) {
1113 int shift = ff_h264_quant_div6[q] + 2;
1114 int idx = ff_h264_quant_rem6[q];
1115 for (x = 0; x < 16; x++)
1116 s->dequant4_coeff[q][(x >> 2) | ((x << 2) & 0xF)] =
1117 ((uint32_t)ff_h264_dequant4_coeff_init[idx][(x & 1) + ((x >> 2) & 1)] * 16) << shift;
1121 static av_cold int svq3_decode_init(AVCodecContext *avctx)
1123 SVQ3Context *s = avctx->priv_data;
1125 unsigned char *extradata;
1126 unsigned char *extradata_end;
1128 int marker_found = 0;
1131 s->cur_pic = &s->frames[0];
1132 s->last_pic = &s->frames[1];
1133 s->next_pic = &s->frames[2];
1135 s->cur_pic->f = av_frame_alloc();
1136 s->last_pic->f = av_frame_alloc();
1137 s->next_pic->f = av_frame_alloc();
1138 if (!s->cur_pic->f || !s->last_pic->f || !s->next_pic->f)
1139 return AVERROR(ENOMEM);
1141 ff_h264dsp_init(&s->h264dsp, 8, 1);
1142 ff_h264_pred_init(&s->hpc, AV_CODEC_ID_SVQ3, 8, 1);
1143 ff_videodsp_init(&s->vdsp, 8);
1146 avctx->bits_per_raw_sample = 8;
1148 ff_hpeldsp_init(&s->hdsp, avctx->flags);
1149 ff_tpeldsp_init(&s->tdsp);
1151 avctx->pix_fmt = AV_PIX_FMT_YUVJ420P;
1152 avctx->color_range = AVCOL_RANGE_JPEG;
1155 s->halfpel_flag = 1;
1156 s->thirdpel_flag = 1;
1157 s->has_watermark = 0;
1159 /* prowl for the "SEQH" marker in the extradata */
1160 extradata = (unsigned char *)avctx->extradata;
1161 extradata_end = avctx->extradata + avctx->extradata_size;
1163 for (m = 0; m + 8 < avctx->extradata_size; m++) {
1164 if (!memcmp(extradata, "SEQH", 4)) {
1172 /* if a match was found, parse the extra data */
1175 int frame_size_code;
1176 int unk0, unk1, unk2, unk3, unk4;
1179 size = AV_RB32(&extradata[4]);
1180 if (size > extradata_end - extradata - 8)
1181 return AVERROR_INVALIDDATA;
1182 init_get_bits(&gb, extradata + 8, size * 8);
1184 /* 'frame size code' and optional 'width, height' */
1185 frame_size_code = get_bits(&gb, 3);
1186 switch (frame_size_code) {
1216 w = get_bits(&gb, 12);
1217 h = get_bits(&gb, 12);
1220 ret = ff_set_dimensions(avctx, w, h);
1224 s->halfpel_flag = get_bits1(&gb);
1225 s->thirdpel_flag = get_bits1(&gb);
1227 /* unknown fields */
1228 unk0 = get_bits1(&gb);
1229 unk1 = get_bits1(&gb);
1230 unk2 = get_bits1(&gb);
1231 unk3 = get_bits1(&gb);
1233 s->low_delay = get_bits1(&gb);
1236 unk4 = get_bits1(&gb);
1238 av_log(avctx, AV_LOG_DEBUG, "Unknown fields %d %d %d %d %d\n",
1239 unk0, unk1, unk2, unk3, unk4);
1241 if (skip_1stop_8data_bits(&gb) < 0)
1242 return AVERROR_INVALIDDATA;
1244 s->has_watermark = get_bits1(&gb);
1245 avctx->has_b_frames = !s->low_delay;
1246 if (s->has_watermark) {
1248 unsigned watermark_width = get_interleaved_ue_golomb(&gb);
1249 unsigned watermark_height = get_interleaved_ue_golomb(&gb);
1250 int u1 = get_interleaved_ue_golomb(&gb);
1251 int u2 = get_bits(&gb, 8);
1252 int u3 = get_bits(&gb, 2);
1253 int u4 = get_interleaved_ue_golomb(&gb);
1254 unsigned long buf_len = watermark_width *
1255 watermark_height * 4;
1256 int offset = get_bits_count(&gb) + 7 >> 3;
1259 if (watermark_height <= 0 ||
1260 (uint64_t)watermark_width * 4 > UINT_MAX / watermark_height)
1261 return AVERROR_INVALIDDATA;
1263 buf = av_malloc(buf_len);
1265 return AVERROR(ENOMEM);
1267 av_log(avctx, AV_LOG_DEBUG, "watermark size: %ux%u\n",
1268 watermark_width, watermark_height);
1269 av_log(avctx, AV_LOG_DEBUG,
1270 "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n",
1271 u1, u2, u3, u4, offset);
1272 if (uncompress(buf, &buf_len, extradata + 8 + offset,
1273 size - offset) != Z_OK) {
1274 av_log(avctx, AV_LOG_ERROR,
1275 "could not uncompress watermark logo\n");
1279 s->watermark_key = av_bswap16(av_crc(av_crc_get_table(AV_CRC_16_CCITT), 0, buf, buf_len));
1281 s->watermark_key = s->watermark_key << 16 | s->watermark_key;
1282 av_log(avctx, AV_LOG_DEBUG,
1283 "watermark key %#"PRIx32"\n", s->watermark_key);
1286 av_log(avctx, AV_LOG_ERROR,
1287 "this svq3 file contains watermark which need zlib support compiled in\n");
1288 return AVERROR(ENOSYS);
1293 s->mb_width = (avctx->width + 15) / 16;
1294 s->mb_height = (avctx->height + 15) / 16;
1295 s->mb_stride = s->mb_width + 1;
1296 s->mb_num = s->mb_width * s->mb_height;
1297 s->b_stride = 4 * s->mb_width;
1298 s->h_edge_pos = s->mb_width * 16;
1299 s->v_edge_pos = s->mb_height * 16;
1301 s->intra4x4_pred_mode = av_mallocz(s->mb_stride * 2 * 8);
1302 if (!s->intra4x4_pred_mode)
1303 return AVERROR(ENOMEM);
1305 s->mb2br_xy = av_mallocz(s->mb_stride * (s->mb_height + 1) *
1306 sizeof(*s->mb2br_xy));
1308 return AVERROR(ENOMEM);
1310 for (y = 0; y < s->mb_height; y++)
1311 for (x = 0; x < s->mb_width; x++) {
1312 const int mb_xy = x + y * s->mb_stride;
1314 s->mb2br_xy[mb_xy] = 8 * (mb_xy % (2 * s->mb_stride));
1317 init_dequant4_coeff_table(s);
1322 static void free_picture(SVQ3Frame *pic)
1325 for (i = 0; i < 2; i++) {
1326 av_freep(&pic->motion_val_buf[i]);
1328 av_freep(&pic->mb_type_buf);
1330 av_frame_unref(pic->f);
1333 static int get_buffer(AVCodecContext *avctx, SVQ3Frame *pic)
1335 SVQ3Context *s = avctx->priv_data;
1336 const int big_mb_num = s->mb_stride * (s->mb_height + 1) + 1;
1337 const int b4_stride = s->mb_width * 4 + 1;
1338 const int b4_array_size = b4_stride * s->mb_height * 4;
1341 if (!pic->motion_val_buf[0]) {
1344 pic->mb_type_buf = av_calloc(big_mb_num + s->mb_stride, sizeof(uint32_t));
1345 if (!pic->mb_type_buf)
1346 return AVERROR(ENOMEM);
1347 pic->mb_type = pic->mb_type_buf + 2 * s->mb_stride + 1;
1349 for (i = 0; i < 2; i++) {
1350 pic->motion_val_buf[i] = av_calloc(b4_array_size + 4, 2 * sizeof(int16_t));
1351 if (!pic->motion_val_buf[i]) {
1352 ret = AVERROR(ENOMEM);
1356 pic->motion_val[i] = pic->motion_val_buf[i] + 4;
1360 ret = ff_get_buffer(avctx, pic->f,
1361 (s->pict_type != AV_PICTURE_TYPE_B) ?
1362 AV_GET_BUFFER_FLAG_REF : 0);
1366 if (!s->edge_emu_buffer) {
1367 s->edge_emu_buffer = av_mallocz_array(pic->f->linesize[0], 17);
1368 if (!s->edge_emu_buffer)
1369 return AVERROR(ENOMEM);
1378 static int svq3_decode_frame(AVCodecContext *avctx, void *data,
1379 int *got_frame, AVPacket *avpkt)
1381 SVQ3Context *s = avctx->priv_data;
1382 int buf_size = avpkt->size;
1386 /* special case for last picture */
1387 if (buf_size == 0) {
1388 if (s->next_pic->f->data[0] && !s->low_delay && !s->last_frame_output) {
1389 ret = av_frame_ref(data, s->next_pic->f);
1392 s->last_frame_output = 1;
1398 s->mb_x = s->mb_y = s->mb_xy = 0;
1400 ret = init_get_bits8(&s->gb, avpkt->data, avpkt->size);
1404 if (svq3_decode_slice_header(avctx))
1407 s->pict_type = s->slice_type;
1409 if (s->pict_type != AV_PICTURE_TYPE_B)
1410 FFSWAP(SVQ3Frame*, s->next_pic, s->last_pic);
1412 av_frame_unref(s->cur_pic->f);
1414 /* for skipping the frame */
1415 s->cur_pic->f->pict_type = s->pict_type;
1416 s->cur_pic->f->key_frame = (s->pict_type == AV_PICTURE_TYPE_I);
1418 ret = get_buffer(avctx, s->cur_pic);
1422 for (i = 0; i < 16; i++) {
1423 s->block_offset[i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * s->cur_pic->f->linesize[0] * ((scan8[i] - scan8[0]) >> 3);
1424 s->block_offset[48 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * s->cur_pic->f->linesize[0] * ((scan8[i] - scan8[0]) >> 3);
1426 for (i = 0; i < 16; i++) {
1427 s->block_offset[16 + i] =
1428 s->block_offset[32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * s->cur_pic->f->linesize[1] * ((scan8[i] - scan8[0]) >> 3);
1429 s->block_offset[48 + 16 + i] =
1430 s->block_offset[48 + 32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * s->cur_pic->f->linesize[1] * ((scan8[i] - scan8[0]) >> 3);
1433 if (s->pict_type != AV_PICTURE_TYPE_I) {
1434 if (!s->last_pic->f->data[0]) {
1435 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1436 av_frame_unref(s->last_pic->f);
1437 ret = get_buffer(avctx, s->last_pic);
1440 memset(s->last_pic->f->data[0], 0, avctx->height * s->last_pic->f->linesize[0]);
1441 memset(s->last_pic->f->data[1], 0x80, (avctx->height / 2) *
1442 s->last_pic->f->linesize[1]);
1443 memset(s->last_pic->f->data[2], 0x80, (avctx->height / 2) *
1444 s->last_pic->f->linesize[2]);
1447 if (s->pict_type == AV_PICTURE_TYPE_B && !s->next_pic->f->data[0]) {
1448 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1449 av_frame_unref(s->next_pic->f);
1450 ret = get_buffer(avctx, s->next_pic);
1453 memset(s->next_pic->f->data[0], 0, avctx->height * s->next_pic->f->linesize[0]);
1454 memset(s->next_pic->f->data[1], 0x80, (avctx->height / 2) *
1455 s->next_pic->f->linesize[1]);
1456 memset(s->next_pic->f->data[2], 0x80, (avctx->height / 2) *
1457 s->next_pic->f->linesize[2]);
1461 if (avctx->debug & FF_DEBUG_PICT_INFO)
1462 av_log(s->avctx, AV_LOG_DEBUG,
1463 "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
1464 av_get_picture_type_char(s->pict_type),
1465 s->halfpel_flag, s->thirdpel_flag,
1466 s->adaptive_quant, s->qscale, s->slice_num);
1468 if (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B ||
1469 avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I ||
1470 avctx->skip_frame >= AVDISCARD_ALL)
1473 if (s->next_p_frame_damaged) {
1474 if (s->pict_type == AV_PICTURE_TYPE_B)
1477 s->next_p_frame_damaged = 0;
1480 if (s->pict_type == AV_PICTURE_TYPE_B) {
1481 s->frame_num_offset = s->slice_num - s->prev_frame_num;
1483 if (s->frame_num_offset < 0)
1484 s->frame_num_offset += 256;
1485 if (s->frame_num_offset == 0 ||
1486 s->frame_num_offset >= s->prev_frame_num_offset) {
1487 av_log(s->avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1491 s->prev_frame_num = s->frame_num;
1492 s->frame_num = s->slice_num;
1493 s->prev_frame_num_offset = s->frame_num - s->prev_frame_num;
1495 if (s->prev_frame_num_offset < 0)
1496 s->prev_frame_num_offset += 256;
1499 for (m = 0; m < 2; m++) {
1501 for (i = 0; i < 4; i++) {
1503 for (j = -1; j < 4; j++)
1504 s->ref_cache[m][scan8[0] + 8 * i + j] = 1;
1506 s->ref_cache[m][scan8[0] + 8 * i + j] = PART_NOT_AVAILABLE;
1510 for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
1511 for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
1513 s->mb_xy = s->mb_x + s->mb_y * s->mb_stride;
1515 if ((get_bits_left(&s->gb_slice)) <= 7) {
1516 if (((get_bits_count(&s->gb_slice) & 7) == 0 ||
1517 show_bits(&s->gb_slice, get_bits_left(&s->gb_slice) & 7) == 0)) {
1519 if (svq3_decode_slice_header(avctx))
1522 if (s->slice_type != s->pict_type) {
1523 avpriv_request_sample(avctx, "non constant slice type");
1525 /* TODO: support s->mb_skip_run */
1528 mb_type = get_interleaved_ue_golomb(&s->gb_slice);
1530 if (s->pict_type == AV_PICTURE_TYPE_I)
1532 else if (s->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4)
1534 if (mb_type > 33 || svq3_decode_mb(s, mb_type)) {
1535 av_log(s->avctx, AV_LOG_ERROR,
1536 "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1540 if (mb_type != 0 || s->cbp)
1543 if (s->pict_type != AV_PICTURE_TYPE_B && !s->low_delay)
1544 s->cur_pic->mb_type[s->mb_x + s->mb_y * s->mb_stride] =
1545 (s->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1548 ff_draw_horiz_band(avctx, s->cur_pic->f,
1549 s->last_pic->f->data[0] ? s->last_pic->f : NULL,
1550 16 * s->mb_y, 16, PICT_FRAME, 0,
1554 left = buf_size*8 - get_bits_count(&s->gb_slice);
1556 if (s->mb_y != s->mb_height || s->mb_x != s->mb_width) {
1557 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);
1558 //av_hex_dump(stderr, buf+buf_size-8, 8);
1562 av_log(avctx, AV_LOG_ERROR, "frame num %d left %d\n", avctx->frame_number, left);
1566 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay)
1567 ret = av_frame_ref(data, s->cur_pic->f);
1568 else if (s->last_pic->f->data[0])
1569 ret = av_frame_ref(data, s->last_pic->f);
1573 /* Do not output the last pic after seeking. */
1574 if (s->last_pic->f->data[0] || s->low_delay)
1577 if (s->pict_type != AV_PICTURE_TYPE_B) {
1578 FFSWAP(SVQ3Frame*, s->cur_pic, s->next_pic);
1580 av_frame_unref(s->cur_pic->f);
1586 static av_cold int svq3_decode_end(AVCodecContext *avctx)
1588 SVQ3Context *s = avctx->priv_data;
1590 for (int i = 0; i < FF_ARRAY_ELEMS(s->frames); i++) {
1591 free_picture(&s->frames[i]);
1592 av_frame_free(&s->frames[i].f);
1594 av_freep(&s->slice_buf);
1595 av_freep(&s->intra4x4_pred_mode);
1596 av_freep(&s->edge_emu_buffer);
1597 av_freep(&s->mb2br_xy);
1602 const AVCodec ff_svq3_decoder = {
1604 .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1605 .type = AVMEDIA_TYPE_VIDEO,
1606 .id = AV_CODEC_ID_SVQ3,
1607 .priv_data_size = sizeof(SVQ3Context),
1608 .init = svq3_decode_init,
1609 .close = svq3_decode_end,
1610 .decode = svq3_decode_frame,
1611 .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND |
1614 .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P,
1616 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,