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;
99 uint32_t watermark_key;
103 int next_p_frame_damaged;
106 int last_frame_output;
111 int frame_num_offset;
112 int prev_frame_num_offset;
115 enum AVPictureType pict_type;
116 enum AVPictureType slice_type;
121 int mb_width, mb_height;
122 int mb_stride, mb_num;
127 int chroma_pred_mode;
128 int intra16x16_pred_mode;
130 int8_t intra4x4_pred_mode_cache[5 * 8];
131 int8_t (*intra4x4_pred_mode);
133 unsigned int top_samples_available;
134 unsigned int topright_samples_available;
135 unsigned int left_samples_available;
137 uint8_t *edge_emu_buffer;
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)];
149 #define FULLPEL_MODE 1
150 #define HALFPEL_MODE 2
151 #define THIRDPEL_MODE 3
152 #define PREDICT_MODE 4
154 /* dual scan (from some older H.264 draft)
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,
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,
177 static const uint8_t svq3_pred_0[25][2] = {
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 },
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 } },
204 static const struct {
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 } }
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
221 static void svq3_luma_dc_dequant_idct_c(int16_t *output, int16_t *input, int qp)
223 const unsigned qmul = svq3_dequant_coeff[qp];
227 static const uint8_t x_offset[4] = { 0, 1 * stride, 4 * stride, 5 * stride };
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];
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;
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];
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;
256 static void svq3_add_idct_c(uint8_t *dst, int16_t *block,
257 int stride, int qp, int dc)
259 const int qmul = svq3_dequant_coeff[qp];
263 dc = 13 * 13 * (dc == 1 ? 1538U* block[0]
264 : qmul * (block[0] >> 3) / 2);
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];
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;
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);
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));
293 memset(block, 0, 16 * sizeof(int16_t));
296 static inline int svq3_decode_block(GetBitContext *gb, int16_t *block,
297 int index, const int type)
299 static const uint8_t *const scan_patterns[4] = {
300 luma_dc_zigzag_scan, ff_zigzag_scan, svq3_scan, ff_h264_chroma_dc_scan
303 int run, level, sign, limit;
305 const int intra = 3 * type >> 2;
306 const uint8_t *const scan = scan_patterns[type];
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)
313 sign = (vlc & 1) ? 0 : -1;
320 } else if (vlc < 4) {
325 level = (vlc + 9 >> 2) - run;
329 run = svq3_dct_tables[intra][vlc].run;
330 level = svq3_dct_tables[intra][vlc].level;
333 level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
336 level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
341 if ((index += run) >= limit)
344 block[scan[index]] = (level ^ sign) - sign;
355 static av_always_inline int
356 svq3_fetch_diagonal_mv(const SVQ3Context *s, const int16_t **C,
357 int i, int list, int part_width)
359 const int topright_ref = s->ref_cache[list][i - 8 + part_width];
361 if (topright_ref != PART_NOT_AVAILABLE) {
362 *C = s->mv_cache[list][i - 8 + part_width];
365 *C = s->mv_cache[list][i - 8 - 1];
366 return s->ref_cache[list][i - 8 - 1];
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
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)
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];
387 int diagonal_ref, match_count;
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) {
406 } else if (top_ref == ref) {
414 if (top_ref == PART_NOT_AVAILABLE &&
415 diagonal_ref == PART_NOT_AVAILABLE &&
416 left_ref != PART_NOT_AVAILABLE) {
420 *mx = mid_pred(A[0], B[0], C[0]);
421 *my = mid_pred(A[1], B[1], C[1]);
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)
431 const SVQ3Frame *pic = (dir == 0) ? s->last_pic : s->next_pic;
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];
441 if (mx < 0 || mx >= s->h_edge_pos - width - 1 ||
442 my < 0 || my >= s->v_edge_pos - height - 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);
448 /* form component predictions */
449 dest = s->cur_pic->f->data[0] + x + y * linesize;
450 src = pic->f->data[0] + mx + my * linesize;
453 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src,
455 width + 1, height + 1,
456 mx, my, s->h_edge_pos, s->v_edge_pos);
457 src = s->edge_emu_buffer;
460 (avg ? s->tdsp.avg_tpel_pixels_tab
461 : s->tdsp.put_tpel_pixels_tab)[dxy](dest, src, linesize,
464 (avg ? s->hdsp.avg_pixels_tab
465 : s->hdsp.put_pixels_tab)[blocksize][dxy](dest, src, linesize,
468 if (!(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
469 mx = mx + (mx < (int) x) >> 1;
470 my = my + (my < (int) y) >> 1;
472 height = height >> 1;
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;
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),
485 src = s->edge_emu_buffer;
488 (avg ? s->tdsp.avg_tpel_pixels_tab
489 : s->tdsp.put_tpel_pixels_tab)[dxy](dest, src,
493 (avg ? s->hdsp.avg_pixels_tab
494 : s->hdsp.put_pixels_tab)[blocksize][dxy](dest, src,
501 static inline int svq3_mc_dir(SVQ3Context *s, int size, int mode,
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;
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;
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);
521 if (mode != PREDICT_MODE) {
522 svq3_pred_motion(s, k, part_width >> 2, dir, 1, &mx, &my);
524 mx = s->next_pic->motion_val[0][b_xy][0] * 2;
525 my = s->next_pic->motion_val[0][b_xy][1] * 2;
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;
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;
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);
544 /* get (optional) motion vector differential */
545 if (mode == PREDICT_MODE) {
548 dy = get_interleaved_se_golomb(&s->gb_slice);
549 dx = get_interleaved_se_golomb(&s->gb_slice);
551 if (dx != (int16_t)dx || dy != (int16_t)dy) {
552 av_log(s->avctx, AV_LOG_ERROR, "invalid MV vlc\n");
557 /* compute motion vector */
558 if (mode == THIRDPEL_MODE) {
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);
566 svq3_mc_dir_part(s, x, y, part_width, part_height,
567 fx, fy, dxy, 1, dir, avg);
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);
575 svq3_mc_dir_part(s, x, y, part_width, part_height,
576 mx >> 1, my >> 1, dxy, 0, dir, avg);
580 mx = (unsigned)(mx + 3 + 0x60000) / 6 + dx - 0x10000;
581 my = (unsigned)(my + 3 + 0x60000) / 6 + dy - 0x10000;
583 svq3_mc_dir_part(s, x, y, part_width, part_height,
584 mx, my, 0, 0, dir, avg);
589 /* update mv_cache */
590 if (mode != PREDICT_MODE) {
591 int32_t mv = pack16to32(mx, my);
593 if (part_height == 8 && i < 8) {
594 AV_WN32A(s->mv_cache[dir][scan8[k] + 1 * 8], mv);
596 if (part_width == 8 && j < 8)
597 AV_WN32A(s->mv_cache[dir][scan8[k] + 1 + 1 * 8], mv);
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);
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);
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)
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);
629 static av_always_inline void hl_decode_mb_predict_luma(SVQ3Context *s,
631 const int *block_offset,
636 int qscale = s->qscale;
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]];
645 if (dir == DIAG_DOWN_LEFT_PRED || dir == VERT_LEFT_PRED) {
646 const int topright_avail = (s->topright_samples_available << i) & 0x8000;
647 av_assert2(s->mb_y || linesize <= block_offset[i]);
648 if (!topright_avail) {
649 tr = ptr[3 - linesize] * 0x01010101u;
650 topright = (uint8_t *)&tr;
652 topright = ptr + 4 - linesize;
656 s->hpc.pred4x4[dir](ptr, topright, linesize);
657 nnz = s->non_zero_count_cache[scan8[i]];
659 svq3_add_idct_c(ptr, s->mb + i * 16, linesize, qscale, 0);
663 s->hpc.pred16x16[s->intra16x16_pred_mode](dest_y, linesize);
664 svq3_luma_dc_dequant_idct_c(s->mb, s->mb_luma_dc[0], qscale);
668 static void hl_decode_mb(SVQ3Context *s)
670 const int mb_x = s->mb_x;
671 const int mb_y = s->mb_y;
672 const int mb_xy = s->mb_xy;
673 const int mb_type = s->cur_pic->mb_type[mb_xy];
674 uint8_t *dest_y, *dest_cb, *dest_cr;
675 int linesize, uvlinesize;
677 const int *block_offset = &s->block_offset[0];
678 const int block_h = 16 >> 1;
680 linesize = s->cur_pic->f->linesize[0];
681 uvlinesize = s->cur_pic->f->linesize[1];
683 dest_y = s->cur_pic->f->data[0] + (mb_x + mb_y * linesize) * 16;
684 dest_cb = s->cur_pic->f->data[1] + mb_x * 8 + mb_y * uvlinesize * block_h;
685 dest_cr = s->cur_pic->f->data[2] + mb_x * 8 + mb_y * uvlinesize * block_h;
687 s->vdsp.prefetch(dest_y + (s->mb_x & 3) * 4 * linesize + 64, linesize, 4);
688 s->vdsp.prefetch(dest_cb + (s->mb_x & 7) * uvlinesize + 64, dest_cr - dest_cb, 2);
690 if (IS_INTRA(mb_type)) {
691 s->hpc.pred8x8[s->chroma_pred_mode](dest_cb, uvlinesize);
692 s->hpc.pred8x8[s->chroma_pred_mode](dest_cr, uvlinesize);
694 hl_decode_mb_predict_luma(s, mb_type, block_offset, linesize, dest_y);
697 hl_decode_mb_idct_luma(s, mb_type, block_offset, linesize, dest_y);
700 uint8_t *dest[2] = { dest_cb, dest_cr };
701 s->h264dsp.h264_chroma_dc_dequant_idct(s->mb + 16 * 16 * 1,
702 s->dequant4_coeff[4][0]);
703 s->h264dsp.h264_chroma_dc_dequant_idct(s->mb + 16 * 16 * 2,
704 s->dequant4_coeff[4][0]);
705 for (j = 1; j < 3; j++) {
706 for (i = j * 16; i < j * 16 + 4; i++)
707 if (s->non_zero_count_cache[scan8[i]] || s->mb[i * 16]) {
708 uint8_t *const ptr = dest[j - 1] + block_offset[i];
709 svq3_add_idct_c(ptr, s->mb + i * 16,
710 uvlinesize, ff_h264_chroma_qp[0][s->qscale + 12] - 12, 2);
716 static int svq3_decode_mb(SVQ3Context *s, unsigned int mb_type)
718 int i, j, k, m, dir, mode;
722 const int mb_xy = s->mb_xy;
723 const int b_xy = 4 * s->mb_x + 4 * s->mb_y * s->b_stride;
725 s->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
726 s->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
727 s->topright_samples_available = 0xFFFF;
729 if (mb_type == 0) { /* SKIP */
730 if (s->pict_type == AV_PICTURE_TYPE_P ||
731 s->next_pic->mb_type[mb_xy] == -1) {
732 svq3_mc_dir_part(s, 16 * s->mb_x, 16 * s->mb_y, 16, 16,
735 if (s->pict_type == AV_PICTURE_TYPE_B)
736 svq3_mc_dir_part(s, 16 * s->mb_x, 16 * s->mb_y, 16, 16,
739 mb_type = MB_TYPE_SKIP;
741 mb_type = FFMIN(s->next_pic->mb_type[mb_xy], 6);
742 if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 0, 0) < 0)
744 if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 1, 1) < 0)
747 mb_type = MB_TYPE_16x16;
749 } else if (mb_type < 8) { /* INTER */
750 if (s->thirdpel_flag && s->halfpel_flag == !get_bits1(&s->gb_slice))
751 mode = THIRDPEL_MODE;
752 else if (s->halfpel_flag &&
753 s->thirdpel_flag == !get_bits1(&s->gb_slice))
759 /* note ref_cache should contain here:
767 for (m = 0; m < 2; m++) {
768 if (s->mb_x > 0 && s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - 1] + 6] != -1) {
769 for (i = 0; i < 4; i++)
770 AV_COPY32(s->mv_cache[m][scan8[0] - 1 + i * 8],
771 s->cur_pic->motion_val[m][b_xy - 1 + i * s->b_stride]);
773 for (i = 0; i < 4; i++)
774 AV_ZERO32(s->mv_cache[m][scan8[0] - 1 + i * 8]);
777 memcpy(s->mv_cache[m][scan8[0] - 1 * 8],
778 s->cur_pic->motion_val[m][b_xy - s->b_stride],
779 4 * 2 * sizeof(int16_t));
780 memset(&s->ref_cache[m][scan8[0] - 1 * 8],
781 (s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1, 4);
783 if (s->mb_x < s->mb_width - 1) {
784 AV_COPY32(s->mv_cache[m][scan8[0] + 4 - 1 * 8],
785 s->cur_pic->motion_val[m][b_xy - s->b_stride + 4]);
786 s->ref_cache[m][scan8[0] + 4 - 1 * 8] =
787 (s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride + 1] + 6] == -1 ||
788 s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1;
790 s->ref_cache[m][scan8[0] + 4 - 1 * 8] = PART_NOT_AVAILABLE;
792 AV_COPY32(s->mv_cache[m][scan8[0] - 1 - 1 * 8],
793 s->cur_pic->motion_val[m][b_xy - s->b_stride - 1]);
794 s->ref_cache[m][scan8[0] - 1 - 1 * 8] =
795 (s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride - 1] + 3] == -1) ? PART_NOT_AVAILABLE : 1;
797 s->ref_cache[m][scan8[0] - 1 - 1 * 8] = PART_NOT_AVAILABLE;
799 memset(&s->ref_cache[m][scan8[0] - 1 * 8 - 1],
800 PART_NOT_AVAILABLE, 8);
802 if (s->pict_type != AV_PICTURE_TYPE_B)
806 /* decode motion vector(s) and form prediction(s) */
807 if (s->pict_type == AV_PICTURE_TYPE_P) {
808 if (svq3_mc_dir(s, mb_type - 1, mode, 0, 0) < 0)
810 } else { /* AV_PICTURE_TYPE_B */
812 if (svq3_mc_dir(s, 0, mode, 0, 0) < 0)
815 for (i = 0; i < 4; i++)
816 memset(s->cur_pic->motion_val[0][b_xy + i * s->b_stride],
817 0, 4 * 2 * sizeof(int16_t));
820 if (svq3_mc_dir(s, 0, mode, 1, mb_type == 3) < 0)
823 for (i = 0; i < 4; i++)
824 memset(s->cur_pic->motion_val[1][b_xy + i * s->b_stride],
825 0, 4 * 2 * sizeof(int16_t));
829 mb_type = MB_TYPE_16x16;
830 } else if (mb_type == 8 || mb_type == 33) { /* INTRA4x4 */
831 int8_t *i4x4 = s->intra4x4_pred_mode + s->mb2br_xy[s->mb_xy];
832 int8_t *i4x4_cache = s->intra4x4_pred_mode_cache;
834 memset(s->intra4x4_pred_mode_cache, -1, 8 * 5 * sizeof(int8_t));
838 for (i = 0; i < 4; i++)
839 s->intra4x4_pred_mode_cache[scan8[0] - 1 + i * 8] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - 1] + 6 - i];
840 if (s->intra4x4_pred_mode_cache[scan8[0] - 1] == -1)
841 s->left_samples_available = 0x5F5F;
844 s->intra4x4_pred_mode_cache[4 + 8 * 0] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride] + 0];
845 s->intra4x4_pred_mode_cache[5 + 8 * 0] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride] + 1];
846 s->intra4x4_pred_mode_cache[6 + 8 * 0] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride] + 2];
847 s->intra4x4_pred_mode_cache[7 + 8 * 0] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride] + 3];
849 if (s->intra4x4_pred_mode_cache[4 + 8 * 0] == -1)
850 s->top_samples_available = 0x33FF;
853 /* decode prediction codes for luma blocks */
854 for (i = 0; i < 16; i += 2) {
855 vlc = get_interleaved_ue_golomb(&s->gb_slice);
858 av_log(s->avctx, AV_LOG_ERROR,
859 "luma prediction:%"PRIu32"\n", vlc);
863 left = &s->intra4x4_pred_mode_cache[scan8[i] - 1];
864 top = &s->intra4x4_pred_mode_cache[scan8[i] - 8];
866 left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
867 left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
869 if (left[1] == -1 || left[2] == -1) {
870 av_log(s->avctx, AV_LOG_ERROR, "weird prediction\n");
874 } else { /* mb_type == 33, DC_128_PRED block type */
875 for (i = 0; i < 4; i++)
876 memset(&s->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_PRED, 4);
879 AV_COPY32(i4x4, i4x4_cache + 4 + 8 * 4);
880 i4x4[4] = i4x4_cache[7 + 8 * 3];
881 i4x4[5] = i4x4_cache[7 + 8 * 2];
882 i4x4[6] = i4x4_cache[7 + 8 * 1];
885 ff_h264_check_intra4x4_pred_mode(s->intra4x4_pred_mode_cache,
886 s->avctx, s->top_samples_available,
887 s->left_samples_available);
889 s->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
890 s->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
892 for (i = 0; i < 4; i++)
893 memset(&s->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_128_PRED, 4);
895 s->top_samples_available = 0x33FF;
896 s->left_samples_available = 0x5F5F;
899 mb_type = MB_TYPE_INTRA4x4;
900 } else { /* INTRA16x16 */
901 dir = ff_h264_i_mb_type_info[mb_type - 8].pred_mode;
902 dir = (dir >> 1) ^ 3 * (dir & 1) ^ 1;
904 if ((s->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(s->avctx, s->top_samples_available,
905 s->left_samples_available, dir, 0)) < 0) {
906 av_log(s->avctx, AV_LOG_ERROR, "ff_h264_check_intra_pred_mode < 0\n");
907 return s->intra16x16_pred_mode;
910 cbp = ff_h264_i_mb_type_info[mb_type - 8].cbp;
911 mb_type = MB_TYPE_INTRA16x16;
914 if (!IS_INTER(mb_type) && s->pict_type != AV_PICTURE_TYPE_I) {
915 for (i = 0; i < 4; i++)
916 memset(s->cur_pic->motion_val[0][b_xy + i * s->b_stride],
917 0, 4 * 2 * sizeof(int16_t));
918 if (s->pict_type == AV_PICTURE_TYPE_B) {
919 for (i = 0; i < 4; i++)
920 memset(s->cur_pic->motion_val[1][b_xy + i * s->b_stride],
921 0, 4 * 2 * sizeof(int16_t));
924 if (!IS_INTRA4x4(mb_type)) {
925 memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy], DC_PRED, 8);
927 if (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B) {
928 memset(s->non_zero_count_cache + 8, 0, 14 * 8 * sizeof(uint8_t));
931 if (!IS_INTRA16x16(mb_type) &&
932 (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B)) {
933 if ((vlc = get_interleaved_ue_golomb(&s->gb_slice)) >= 48U){
934 av_log(s->avctx, AV_LOG_ERROR, "cbp_vlc=%"PRIu32"\n", vlc);
938 cbp = IS_INTRA(mb_type) ? ff_h264_golomb_to_intra4x4_cbp[vlc]
939 : ff_h264_golomb_to_inter_cbp[vlc];
941 if (IS_INTRA16x16(mb_type) ||
942 (s->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
943 s->qscale += get_interleaved_se_golomb(&s->gb_slice);
945 if (s->qscale > 31u) {
946 av_log(s->avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
950 if (IS_INTRA16x16(mb_type)) {
951 AV_ZERO128(s->mb_luma_dc[0] + 0);
952 AV_ZERO128(s->mb_luma_dc[0] + 8);
953 if (svq3_decode_block(&s->gb_slice, s->mb_luma_dc[0], 0, 1)) {
954 av_log(s->avctx, AV_LOG_ERROR,
955 "error while decoding intra luma dc\n");
961 const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
962 const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
964 for (i = 0; i < 4; i++)
965 if ((cbp & (1 << i))) {
966 for (j = 0; j < 4; j++) {
967 k = index ? (1 * (j & 1) + 2 * (i & 1) +
968 2 * (j & 2) + 4 * (i & 2))
970 s->non_zero_count_cache[scan8[k]] = 1;
972 if (svq3_decode_block(&s->gb_slice, &s->mb[16 * k], index, type)) {
973 av_log(s->avctx, AV_LOG_ERROR,
974 "error while decoding block\n");
981 for (i = 1; i < 3; ++i)
982 if (svq3_decode_block(&s->gb_slice, &s->mb[16 * 16 * i], 0, 3)) {
983 av_log(s->avctx, AV_LOG_ERROR,
984 "error while decoding chroma dc block\n");
989 for (i = 1; i < 3; i++) {
990 for (j = 0; j < 4; j++) {
992 s->non_zero_count_cache[scan8[k]] = 1;
994 if (svq3_decode_block(&s->gb_slice, &s->mb[16 * k], 1, 1)) {
995 av_log(s->avctx, AV_LOG_ERROR,
996 "error while decoding chroma ac block\n");
1006 s->cur_pic->mb_type[mb_xy] = mb_type;
1008 if (IS_INTRA(mb_type))
1009 s->chroma_pred_mode = ff_h264_check_intra_pred_mode(s->avctx, s->top_samples_available,
1010 s->left_samples_available, DC_PRED8x8, 1);
1015 static int svq3_decode_slice_header(AVCodecContext *avctx)
1017 SVQ3Context *s = avctx->priv_data;
1018 const int mb_xy = s->mb_xy;
1022 header = get_bits(&s->gb, 8);
1024 if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
1026 av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
1029 int slice_bits, slice_bytes, slice_length;
1030 int length = header >> 5 & 3;
1032 slice_length = show_bits(&s->gb, 8 * length);
1033 slice_bits = slice_length * 8;
1034 slice_bytes = slice_length + length - 1;
1036 skip_bits(&s->gb, 8);
1038 av_fast_malloc(&s->slice_buf, &s->slice_size, slice_bytes + AV_INPUT_BUFFER_PADDING_SIZE);
1040 return AVERROR(ENOMEM);
1042 if (slice_bytes * 8LL > get_bits_left(&s->gb)) {
1043 av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
1044 return AVERROR_INVALIDDATA;
1046 memcpy(s->slice_buf, s->gb.buffer + s->gb.index / 8, slice_bytes);
1048 if (s->watermark_key) {
1049 uint32_t header = AV_RL32(&s->slice_buf[1]);
1050 AV_WL32(&s->slice_buf[1], header ^ s->watermark_key);
1052 init_get_bits(&s->gb_slice, s->slice_buf, slice_bits);
1055 memmove(s->slice_buf, &s->slice_buf[slice_length], length - 1);
1057 skip_bits_long(&s->gb, slice_bytes * 8);
1060 if ((slice_id = get_interleaved_ue_golomb(&s->gb_slice)) >= 3) {
1061 av_log(s->avctx, AV_LOG_ERROR, "illegal slice type %u \n", slice_id);
1065 s->slice_type = ff_h264_golomb_to_pict_type[slice_id];
1067 if ((header & 0x9F) == 2) {
1068 i = (s->mb_num < 64) ? 6 : (1 + av_log2(s->mb_num - 1));
1069 get_bits(&s->gb_slice, i);
1070 } else if (get_bits1(&s->gb_slice)) {
1071 avpriv_report_missing_feature(s->avctx, "Media key encryption");
1072 return AVERROR_PATCHWELCOME;
1075 s->slice_num = get_bits(&s->gb_slice, 8);
1076 s->qscale = get_bits(&s->gb_slice, 5);
1077 s->adaptive_quant = get_bits1(&s->gb_slice);
1079 /* unknown fields */
1080 skip_bits1(&s->gb_slice);
1082 if (s->has_watermark)
1083 skip_bits1(&s->gb_slice);
1085 skip_bits1(&s->gb_slice);
1086 skip_bits(&s->gb_slice, 2);
1088 if (skip_1stop_8data_bits(&s->gb_slice) < 0)
1089 return AVERROR_INVALIDDATA;
1091 /* reset intra predictors and invalidate motion vector references */
1093 memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy - 1] + 3,
1094 -1, 4 * sizeof(int8_t));
1095 memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy - s->mb_x],
1096 -1, 8 * sizeof(int8_t) * s->mb_x);
1099 memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy - s->mb_stride],
1100 -1, 8 * sizeof(int8_t) * (s->mb_width - s->mb_x));
1103 s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride - 1] + 3] = -1;
1109 static void init_dequant4_coeff_table(SVQ3Context *s)
1112 const int max_qp = 51;
1114 for (q = 0; q < max_qp + 1; q++) {
1115 int shift = ff_h264_quant_div6[q] + 2;
1116 int idx = ff_h264_quant_rem6[q];
1117 for (x = 0; x < 16; x++)
1118 s->dequant4_coeff[q][(x >> 2) | ((x << 2) & 0xF)] =
1119 ((uint32_t)ff_h264_dequant4_coeff_init[idx][(x & 1) + ((x >> 2) & 1)] * 16) << shift;
1123 static av_cold int svq3_decode_init(AVCodecContext *avctx)
1125 SVQ3Context *s = avctx->priv_data;
1127 unsigned char *extradata;
1128 unsigned char *extradata_end;
1130 int marker_found = 0;
1133 s->cur_pic = &s->frames[0];
1134 s->last_pic = &s->frames[1];
1135 s->next_pic = &s->frames[2];
1137 s->cur_pic->f = av_frame_alloc();
1138 s->last_pic->f = av_frame_alloc();
1139 s->next_pic->f = av_frame_alloc();
1140 if (!s->cur_pic->f || !s->last_pic->f || !s->next_pic->f)
1141 return AVERROR(ENOMEM);
1143 ff_h264dsp_init(&s->h264dsp, 8, 1);
1144 ff_h264_pred_init(&s->hpc, AV_CODEC_ID_SVQ3, 8, 1);
1145 ff_videodsp_init(&s->vdsp, 8);
1148 avctx->bits_per_raw_sample = 8;
1150 ff_hpeldsp_init(&s->hdsp, avctx->flags);
1151 ff_tpeldsp_init(&s->tdsp);
1153 avctx->pix_fmt = AV_PIX_FMT_YUVJ420P;
1154 avctx->color_range = AVCOL_RANGE_JPEG;
1157 s->halfpel_flag = 1;
1158 s->thirdpel_flag = 1;
1159 s->has_watermark = 0;
1161 /* prowl for the "SEQH" marker in the extradata */
1162 extradata = (unsigned char *)avctx->extradata;
1163 extradata_end = avctx->extradata + avctx->extradata_size;
1165 for (m = 0; m + 8 < avctx->extradata_size; m++) {
1166 if (!memcmp(extradata, "SEQH", 4)) {
1174 /* if a match was found, parse the extra data */
1177 int frame_size_code;
1178 int unk0, unk1, unk2, unk3, unk4;
1181 size = AV_RB32(&extradata[4]);
1182 if (size > extradata_end - extradata - 8)
1183 return AVERROR_INVALIDDATA;
1184 init_get_bits(&gb, extradata + 8, size * 8);
1186 /* 'frame size code' and optional 'width, height' */
1187 frame_size_code = get_bits(&gb, 3);
1188 switch (frame_size_code) {
1218 w = get_bits(&gb, 12);
1219 h = get_bits(&gb, 12);
1222 ret = ff_set_dimensions(avctx, w, h);
1226 s->halfpel_flag = get_bits1(&gb);
1227 s->thirdpel_flag = get_bits1(&gb);
1229 /* unknown fields */
1230 unk0 = get_bits1(&gb);
1231 unk1 = get_bits1(&gb);
1232 unk2 = get_bits1(&gb);
1233 unk3 = get_bits1(&gb);
1235 s->low_delay = get_bits1(&gb);
1238 unk4 = get_bits1(&gb);
1240 av_log(avctx, AV_LOG_DEBUG, "Unknown fields %d %d %d %d %d\n",
1241 unk0, unk1, unk2, unk3, unk4);
1243 if (skip_1stop_8data_bits(&gb) < 0)
1244 return AVERROR_INVALIDDATA;
1246 s->has_watermark = get_bits1(&gb);
1247 avctx->has_b_frames = !s->low_delay;
1248 if (s->has_watermark) {
1250 unsigned watermark_width = get_interleaved_ue_golomb(&gb);
1251 unsigned watermark_height = get_interleaved_ue_golomb(&gb);
1252 int u1 = get_interleaved_ue_golomb(&gb);
1253 int u2 = get_bits(&gb, 8);
1254 int u3 = get_bits(&gb, 2);
1255 int u4 = get_interleaved_ue_golomb(&gb);
1256 unsigned long buf_len = watermark_width *
1257 watermark_height * 4;
1258 int offset = get_bits_count(&gb) + 7 >> 3;
1261 if (watermark_height <= 0 ||
1262 (uint64_t)watermark_width * 4 > UINT_MAX / watermark_height)
1263 return AVERROR_INVALIDDATA;
1265 buf = av_malloc(buf_len);
1267 return AVERROR(ENOMEM);
1269 av_log(avctx, AV_LOG_DEBUG, "watermark size: %ux%u\n",
1270 watermark_width, watermark_height);
1271 av_log(avctx, AV_LOG_DEBUG,
1272 "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n",
1273 u1, u2, u3, u4, offset);
1274 if (uncompress(buf, &buf_len, extradata + 8 + offset,
1275 size - offset) != Z_OK) {
1276 av_log(avctx, AV_LOG_ERROR,
1277 "could not uncompress watermark logo\n");
1281 s->watermark_key = av_bswap16(av_crc(av_crc_get_table(AV_CRC_16_CCITT), 0, buf, buf_len));
1283 s->watermark_key = s->watermark_key << 16 | s->watermark_key;
1284 av_log(avctx, AV_LOG_DEBUG,
1285 "watermark key %#"PRIx32"\n", s->watermark_key);
1288 av_log(avctx, AV_LOG_ERROR,
1289 "this svq3 file contains watermark which need zlib support compiled in\n");
1290 return AVERROR(ENOSYS);
1295 s->mb_width = (avctx->width + 15) / 16;
1296 s->mb_height = (avctx->height + 15) / 16;
1297 s->mb_stride = s->mb_width + 1;
1298 s->mb_num = s->mb_width * s->mb_height;
1299 s->b_stride = 4 * s->mb_width;
1300 s->h_edge_pos = s->mb_width * 16;
1301 s->v_edge_pos = s->mb_height * 16;
1303 s->intra4x4_pred_mode = av_mallocz(s->mb_stride * 2 * 8);
1304 if (!s->intra4x4_pred_mode)
1305 return AVERROR(ENOMEM);
1307 s->mb2br_xy = av_mallocz(s->mb_stride * (s->mb_height + 1) *
1308 sizeof(*s->mb2br_xy));
1310 return AVERROR(ENOMEM);
1312 for (y = 0; y < s->mb_height; y++)
1313 for (x = 0; x < s->mb_width; x++) {
1314 const int mb_xy = x + y * s->mb_stride;
1316 s->mb2br_xy[mb_xy] = 8 * (mb_xy % (2 * s->mb_stride));
1319 init_dequant4_coeff_table(s);
1324 static void free_picture(AVCodecContext *avctx, SVQ3Frame *pic)
1327 for (i = 0; i < 2; i++) {
1328 av_freep(&pic->motion_val_buf[i]);
1330 av_freep(&pic->mb_type_buf);
1332 av_frame_unref(pic->f);
1335 static int get_buffer(AVCodecContext *avctx, SVQ3Frame *pic)
1337 SVQ3Context *s = avctx->priv_data;
1338 const int big_mb_num = s->mb_stride * (s->mb_height + 1) + 1;
1339 const int b4_stride = s->mb_width * 4 + 1;
1340 const int b4_array_size = b4_stride * s->mb_height * 4;
1343 if (!pic->motion_val_buf[0]) {
1346 pic->mb_type_buf = av_calloc(big_mb_num + s->mb_stride, sizeof(uint32_t));
1347 if (!pic->mb_type_buf)
1348 return AVERROR(ENOMEM);
1349 pic->mb_type = pic->mb_type_buf + 2 * s->mb_stride + 1;
1351 for (i = 0; i < 2; i++) {
1352 pic->motion_val_buf[i] = av_calloc(b4_array_size + 4, 2 * sizeof(int16_t));
1353 if (!pic->motion_val_buf[i]) {
1354 ret = AVERROR(ENOMEM);
1358 pic->motion_val[i] = pic->motion_val_buf[i] + 4;
1362 ret = ff_get_buffer(avctx, pic->f,
1363 (s->pict_type != AV_PICTURE_TYPE_B) ?
1364 AV_GET_BUFFER_FLAG_REF : 0);
1368 if (!s->edge_emu_buffer) {
1369 s->edge_emu_buffer = av_mallocz_array(pic->f->linesize[0], 17);
1370 if (!s->edge_emu_buffer)
1371 return AVERROR(ENOMEM);
1376 free_picture(avctx, pic);
1380 static int svq3_decode_frame(AVCodecContext *avctx, void *data,
1381 int *got_frame, AVPacket *avpkt)
1383 SVQ3Context *s = avctx->priv_data;
1384 int buf_size = avpkt->size;
1389 /* special case for last picture */
1390 if (buf_size == 0) {
1391 if (s->next_pic->f->data[0] && !s->low_delay && !s->last_frame_output) {
1392 ret = av_frame_ref(data, s->next_pic->f);
1395 s->last_frame_output = 1;
1401 s->mb_x = s->mb_y = s->mb_xy = 0;
1403 if (s->watermark_key) {
1404 av_fast_padded_malloc(&s->buf, &s->buf_size, buf_size);
1406 return AVERROR(ENOMEM);
1407 memcpy(s->buf, avpkt->data, buf_size);
1413 ret = init_get_bits(&s->gb, buf, 8 * buf_size);
1417 if (svq3_decode_slice_header(avctx))
1420 s->pict_type = s->slice_type;
1422 if (s->pict_type != AV_PICTURE_TYPE_B)
1423 FFSWAP(SVQ3Frame*, s->next_pic, s->last_pic);
1425 av_frame_unref(s->cur_pic->f);
1427 /* for skipping the frame */
1428 s->cur_pic->f->pict_type = s->pict_type;
1429 s->cur_pic->f->key_frame = (s->pict_type == AV_PICTURE_TYPE_I);
1431 ret = get_buffer(avctx, s->cur_pic);
1435 for (i = 0; i < 16; i++) {
1436 s->block_offset[i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * s->cur_pic->f->linesize[0] * ((scan8[i] - scan8[0]) >> 3);
1437 s->block_offset[48 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * s->cur_pic->f->linesize[0] * ((scan8[i] - scan8[0]) >> 3);
1439 for (i = 0; i < 16; i++) {
1440 s->block_offset[16 + i] =
1441 s->block_offset[32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * s->cur_pic->f->linesize[1] * ((scan8[i] - scan8[0]) >> 3);
1442 s->block_offset[48 + 16 + i] =
1443 s->block_offset[48 + 32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * s->cur_pic->f->linesize[1] * ((scan8[i] - scan8[0]) >> 3);
1446 if (s->pict_type != AV_PICTURE_TYPE_I) {
1447 if (!s->last_pic->f->data[0]) {
1448 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1449 av_frame_unref(s->last_pic->f);
1450 ret = get_buffer(avctx, s->last_pic);
1453 memset(s->last_pic->f->data[0], 0, avctx->height * s->last_pic->f->linesize[0]);
1454 memset(s->last_pic->f->data[1], 0x80, (avctx->height / 2) *
1455 s->last_pic->f->linesize[1]);
1456 memset(s->last_pic->f->data[2], 0x80, (avctx->height / 2) *
1457 s->last_pic->f->linesize[2]);
1460 if (s->pict_type == AV_PICTURE_TYPE_B && !s->next_pic->f->data[0]) {
1461 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1462 av_frame_unref(s->next_pic->f);
1463 ret = get_buffer(avctx, s->next_pic);
1466 memset(s->next_pic->f->data[0], 0, avctx->height * s->next_pic->f->linesize[0]);
1467 memset(s->next_pic->f->data[1], 0x80, (avctx->height / 2) *
1468 s->next_pic->f->linesize[1]);
1469 memset(s->next_pic->f->data[2], 0x80, (avctx->height / 2) *
1470 s->next_pic->f->linesize[2]);
1474 if (avctx->debug & FF_DEBUG_PICT_INFO)
1475 av_log(s->avctx, AV_LOG_DEBUG,
1476 "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
1477 av_get_picture_type_char(s->pict_type),
1478 s->halfpel_flag, s->thirdpel_flag,
1479 s->adaptive_quant, s->qscale, s->slice_num);
1481 if (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B ||
1482 avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I ||
1483 avctx->skip_frame >= AVDISCARD_ALL)
1486 if (s->next_p_frame_damaged) {
1487 if (s->pict_type == AV_PICTURE_TYPE_B)
1490 s->next_p_frame_damaged = 0;
1493 if (s->pict_type == AV_PICTURE_TYPE_B) {
1494 s->frame_num_offset = s->slice_num - s->prev_frame_num;
1496 if (s->frame_num_offset < 0)
1497 s->frame_num_offset += 256;
1498 if (s->frame_num_offset == 0 ||
1499 s->frame_num_offset >= s->prev_frame_num_offset) {
1500 av_log(s->avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1504 s->prev_frame_num = s->frame_num;
1505 s->frame_num = s->slice_num;
1506 s->prev_frame_num_offset = s->frame_num - s->prev_frame_num;
1508 if (s->prev_frame_num_offset < 0)
1509 s->prev_frame_num_offset += 256;
1512 for (m = 0; m < 2; m++) {
1514 for (i = 0; i < 4; i++) {
1516 for (j = -1; j < 4; j++)
1517 s->ref_cache[m][scan8[0] + 8 * i + j] = 1;
1519 s->ref_cache[m][scan8[0] + 8 * i + j] = PART_NOT_AVAILABLE;
1523 for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
1524 for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
1526 s->mb_xy = s->mb_x + s->mb_y * s->mb_stride;
1528 if ((get_bits_left(&s->gb_slice)) <= 7) {
1529 if (((get_bits_count(&s->gb_slice) & 7) == 0 ||
1530 show_bits(&s->gb_slice, get_bits_left(&s->gb_slice) & 7) == 0)) {
1532 if (svq3_decode_slice_header(avctx))
1535 if (s->slice_type != s->pict_type) {
1536 avpriv_request_sample(avctx, "non constant slice type");
1538 /* TODO: support s->mb_skip_run */
1541 mb_type = get_interleaved_ue_golomb(&s->gb_slice);
1543 if (s->pict_type == AV_PICTURE_TYPE_I)
1545 else if (s->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4)
1547 if (mb_type > 33 || svq3_decode_mb(s, mb_type)) {
1548 av_log(s->avctx, AV_LOG_ERROR,
1549 "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1553 if (mb_type != 0 || s->cbp)
1556 if (s->pict_type != AV_PICTURE_TYPE_B && !s->low_delay)
1557 s->cur_pic->mb_type[s->mb_x + s->mb_y * s->mb_stride] =
1558 (s->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1561 ff_draw_horiz_band(avctx, s->cur_pic->f,
1562 s->last_pic->f->data[0] ? s->last_pic->f : NULL,
1563 16 * s->mb_y, 16, PICT_FRAME, 0,
1567 left = buf_size*8 - get_bits_count(&s->gb_slice);
1569 if (s->mb_y != s->mb_height || s->mb_x != s->mb_width) {
1570 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);
1571 //av_hex_dump(stderr, buf+buf_size-8, 8);
1575 av_log(avctx, AV_LOG_ERROR, "frame num %d left %d\n", avctx->frame_number, left);
1579 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay)
1580 ret = av_frame_ref(data, s->cur_pic->f);
1581 else if (s->last_pic->f->data[0])
1582 ret = av_frame_ref(data, s->last_pic->f);
1586 /* Do not output the last pic after seeking. */
1587 if (s->last_pic->f->data[0] || s->low_delay)
1590 if (s->pict_type != AV_PICTURE_TYPE_B) {
1591 FFSWAP(SVQ3Frame*, s->cur_pic, s->next_pic);
1593 av_frame_unref(s->cur_pic->f);
1599 static av_cold int svq3_decode_end(AVCodecContext *avctx)
1601 SVQ3Context *s = avctx->priv_data;
1603 free_picture(avctx, s->cur_pic);
1604 free_picture(avctx, s->next_pic);
1605 free_picture(avctx, s->last_pic);
1606 av_frame_free(&s->cur_pic->f);
1607 av_frame_free(&s->next_pic->f);
1608 av_frame_free(&s->last_pic->f);
1609 av_freep(&s->slice_buf);
1610 av_freep(&s->intra4x4_pred_mode);
1611 av_freep(&s->edge_emu_buffer);
1612 av_freep(&s->mb2br_xy);
1621 AVCodec ff_svq3_decoder = {
1623 .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1624 .type = AVMEDIA_TYPE_VIDEO,
1625 .id = AV_CODEC_ID_SVQ3,
1626 .priv_data_size = sizeof(SVQ3Context),
1627 .init = svq3_decode_init,
1628 .close = svq3_decode_end,
1629 .decode = svq3_decode_frame,
1630 .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND |
1633 .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P,
1635 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,