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"
48 #include "mpegutils.h"
54 #include "rectangle.h"
56 #include "vdpau_internal.h"
69 typedef struct SVQ3Context {
70 AVCodecContext *avctx;
72 H264DSPContext h264dsp;
79 H264Picture *next_pic;
80 H264Picture *last_pic;
82 GetBitContext gb_slice;
88 uint32_t watermark_key;
92 int next_p_frame_damaged;
95 int last_frame_output;
100 int frame_num_offset;
101 int prev_frame_num_offset;
104 enum AVPictureType pict_type;
109 int mb_width, mb_height;
110 int mb_stride, mb_num;
115 int chroma_pred_mode;
116 int intra16x16_pred_mode;
118 int8_t intra4x4_pred_mode_cache[5 * 8];
119 int8_t (*intra4x4_pred_mode);
121 unsigned int top_samples_available;
122 unsigned int topright_samples_available;
123 unsigned int left_samples_available;
125 uint8_t *edge_emu_buffer;
127 DECLARE_ALIGNED(16, int16_t, mv_cache)[2][5 * 8][2];
128 DECLARE_ALIGNED(8, int8_t, ref_cache)[2][5 * 8];
129 DECLARE_ALIGNED(16, int16_t, mb)[16 * 48 * 2];
130 DECLARE_ALIGNED(16, int16_t, mb_luma_dc)[3][16 * 2];
131 DECLARE_ALIGNED(8, uint8_t, non_zero_count_cache)[15 * 8];
132 uint32_t dequant4_coeff[QP_MAX_NUM + 1][16];
133 int block_offset[2 * (16 * 3)];
136 #define FULLPEL_MODE 1
137 #define HALFPEL_MODE 2
138 #define THIRDPEL_MODE 3
139 #define PREDICT_MODE 4
141 /* dual scan (from some older h264 draft)
150 static const uint8_t svq3_scan[16] = {
151 0 + 0 * 4, 1 + 0 * 4, 2 + 0 * 4, 2 + 1 * 4,
152 2 + 2 * 4, 3 + 0 * 4, 3 + 1 * 4, 3 + 2 * 4,
153 0 + 1 * 4, 0 + 2 * 4, 1 + 1 * 4, 1 + 2 * 4,
154 0 + 3 * 4, 1 + 3 * 4, 2 + 3 * 4, 3 + 3 * 4,
157 static const uint8_t luma_dc_zigzag_scan[16] = {
158 0 * 16 + 0 * 64, 1 * 16 + 0 * 64, 2 * 16 + 0 * 64, 0 * 16 + 2 * 64,
159 3 * 16 + 0 * 64, 0 * 16 + 1 * 64, 1 * 16 + 1 * 64, 2 * 16 + 1 * 64,
160 1 * 16 + 2 * 64, 2 * 16 + 2 * 64, 3 * 16 + 2 * 64, 0 * 16 + 3 * 64,
161 3 * 16 + 1 * 64, 1 * 16 + 3 * 64, 2 * 16 + 3 * 64, 3 * 16 + 3 * 64,
164 static const uint8_t svq3_pred_0[25][2] = {
167 { 0, 2 }, { 1, 1 }, { 2, 0 },
168 { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
169 { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
170 { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
171 { 2, 4 }, { 3, 3 }, { 4, 2 },
176 static const int8_t svq3_pred_1[6][6][5] = {
177 { { 2, -1, -1, -1, -1 }, { 2, 1, -1, -1, -1 }, { 1, 2, -1, -1, -1 },
178 { 2, 1, -1, -1, -1 }, { 1, 2, -1, -1, -1 }, { 1, 2, -1, -1, -1 } },
179 { { 0, 2, -1, -1, -1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
180 { 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
181 { { 2, 0, -1, -1, -1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
182 { 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
183 { { 2, 0, -1, -1, -1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
184 { 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
185 { { 0, 2, -1, -1, -1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
186 { 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
187 { { 0, 2, -1, -1, -1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
188 { 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
191 static const struct {
194 } svq3_dct_tables[2][16] = {
195 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
196 { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
197 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
198 { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
201 static const uint32_t svq3_dequant_coeff[32] = {
202 3881, 4351, 4890, 5481, 6154, 6914, 7761, 8718,
203 9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
204 24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
205 61694, 68745, 77615, 89113, 100253, 109366, 126635, 141533
208 static int svq3_decode_end(AVCodecContext *avctx);
210 static void svq3_luma_dc_dequant_idct_c(int16_t *output, int16_t *input, int qp)
212 const int qmul = svq3_dequant_coeff[qp];
216 static const uint8_t x_offset[4] = { 0, 1 * stride, 4 * stride, 5 * stride };
218 for (i = 0; i < 4; i++) {
219 const int z0 = 13 * (input[4 * i + 0] + input[4 * i + 2]);
220 const int z1 = 13 * (input[4 * i + 0] - input[4 * i + 2]);
221 const int z2 = 7 * input[4 * i + 1] - 17 * input[4 * i + 3];
222 const int z3 = 17 * input[4 * i + 1] + 7 * input[4 * i + 3];
224 temp[4 * i + 0] = z0 + z3;
225 temp[4 * i + 1] = z1 + z2;
226 temp[4 * i + 2] = z1 - z2;
227 temp[4 * i + 3] = z0 - z3;
230 for (i = 0; i < 4; i++) {
231 const int offset = x_offset[i];
232 const int z0 = 13 * (temp[4 * 0 + i] + temp[4 * 2 + i]);
233 const int z1 = 13 * (temp[4 * 0 + i] - temp[4 * 2 + i]);
234 const int z2 = 7 * temp[4 * 1 + i] - 17 * temp[4 * 3 + i];
235 const int z3 = 17 * temp[4 * 1 + i] + 7 * temp[4 * 3 + i];
237 output[stride * 0 + offset] = (z0 + z3) * qmul + 0x80000 >> 20;
238 output[stride * 2 + offset] = (z1 + z2) * qmul + 0x80000 >> 20;
239 output[stride * 8 + offset] = (z1 - z2) * qmul + 0x80000 >> 20;
240 output[stride * 10 + offset] = (z0 - z3) * qmul + 0x80000 >> 20;
245 static void svq3_add_idct_c(uint8_t *dst, int16_t *block,
246 int stride, int qp, int dc)
248 const int qmul = svq3_dequant_coeff[qp];
252 dc = 13 * 13 * (dc == 1 ? 1538 * block[0]
253 : qmul * (block[0] >> 3) / 2);
257 for (i = 0; i < 4; i++) {
258 const int z0 = 13 * (block[0 + 4 * i] + block[2 + 4 * i]);
259 const int z1 = 13 * (block[0 + 4 * i] - block[2 + 4 * i]);
260 const int z2 = 7 * block[1 + 4 * i] - 17 * block[3 + 4 * i];
261 const int z3 = 17 * block[1 + 4 * i] + 7 * block[3 + 4 * i];
263 block[0 + 4 * i] = z0 + z3;
264 block[1 + 4 * i] = z1 + z2;
265 block[2 + 4 * i] = z1 - z2;
266 block[3 + 4 * i] = z0 - z3;
269 for (i = 0; i < 4; i++) {
270 const int z0 = 13 * (block[i + 4 * 0] + block[i + 4 * 2]);
271 const int z1 = 13 * (block[i + 4 * 0] - block[i + 4 * 2]);
272 const int z2 = 7 * block[i + 4 * 1] - 17 * block[i + 4 * 3];
273 const int z3 = 17 * block[i + 4 * 1] + 7 * block[i + 4 * 3];
274 const int rr = (dc + 0x80000);
276 dst[i + stride * 0] = av_clip_uint8(dst[i + stride * 0] + ((z0 + z3) * qmul + rr >> 20));
277 dst[i + stride * 1] = av_clip_uint8(dst[i + stride * 1] + ((z1 + z2) * qmul + rr >> 20));
278 dst[i + stride * 2] = av_clip_uint8(dst[i + stride * 2] + ((z1 - z2) * qmul + rr >> 20));
279 dst[i + stride * 3] = av_clip_uint8(dst[i + stride * 3] + ((z0 - z3) * qmul + rr >> 20));
282 memset(block, 0, 16 * sizeof(int16_t));
285 static inline int svq3_decode_block(GetBitContext *gb, int16_t *block,
286 int index, const int type)
288 static const uint8_t *const scan_patterns[4] = {
289 luma_dc_zigzag_scan, ff_zigzag_scan, svq3_scan, ff_h264_chroma_dc_scan
292 int run, level, sign, limit;
294 const int intra = 3 * type >> 2;
295 const uint8_t *const scan = scan_patterns[type];
297 for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
298 for (; (vlc = svq3_get_ue_golomb(gb)) != 0; index++) {
299 if ((int32_t)vlc < 0)
302 sign = (vlc & 1) ? 0 : -1;
309 } else if (vlc < 4) {
314 level = (vlc + 9 >> 2) - run;
318 run = svq3_dct_tables[intra][vlc].run;
319 level = svq3_dct_tables[intra][vlc].level;
322 level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
325 level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
330 if ((index += run) >= limit)
333 block[scan[index]] = (level ^ sign) - sign;
344 static av_always_inline int
345 svq3_fetch_diagonal_mv(const SVQ3Context *s, const int16_t **C,
346 int i, int list, int part_width)
348 const int topright_ref = s->ref_cache[list][i - 8 + part_width];
350 if (topright_ref != PART_NOT_AVAILABLE) {
351 *C = s->mv_cache[list][i - 8 + part_width];
354 *C = s->mv_cache[list][i - 8 - 1];
355 return s->ref_cache[list][i - 8 - 1];
360 * Get the predicted MV.
361 * @param n the block index
362 * @param part_width the width of the partition (4, 8,16) -> (1, 2, 4)
363 * @param mx the x component of the predicted motion vector
364 * @param my the y component of the predicted motion vector
366 static av_always_inline void svq3_pred_motion(const SVQ3Context *s, int n,
367 int part_width, int list,
368 int ref, int *const mx, int *const my)
370 const int index8 = scan8[n];
371 const int top_ref = s->ref_cache[list][index8 - 8];
372 const int left_ref = s->ref_cache[list][index8 - 1];
373 const int16_t *const A = s->mv_cache[list][index8 - 1];
374 const int16_t *const B = s->mv_cache[list][index8 - 8];
376 int diagonal_ref, match_count;
386 diagonal_ref = svq3_fetch_diagonal_mv(s, &C, index8, list, part_width);
387 match_count = (diagonal_ref == ref) + (top_ref == ref) + (left_ref == ref);
388 if (match_count > 1) { //most common
389 *mx = mid_pred(A[0], B[0], C[0]);
390 *my = mid_pred(A[1], B[1], C[1]);
391 } else if (match_count == 1) {
392 if (left_ref == ref) {
395 } else if (top_ref == ref) {
403 if (top_ref == PART_NOT_AVAILABLE &&
404 diagonal_ref == PART_NOT_AVAILABLE &&
405 left_ref != PART_NOT_AVAILABLE) {
409 *mx = mid_pred(A[0], B[0], C[0]);
410 *my = mid_pred(A[1], B[1], C[1]);
415 static inline void svq3_mc_dir_part(SVQ3Context *s,
416 int x, int y, int width, int height,
417 int mx, int my, int dxy,
418 int thirdpel, int dir, int avg)
420 const H264Picture *pic = (dir == 0) ? s->last_pic : s->next_pic;
423 int blocksize = 2 - (width >> 3); // 16->0, 8->1, 4->2
424 int linesize = s->cur_pic->f->linesize[0];
425 int uvlinesize = s->cur_pic->f->linesize[1];
430 if (mx < 0 || mx >= s->h_edge_pos - width - 1 ||
431 my < 0 || my >= s->v_edge_pos - height - 1) {
433 mx = av_clip(mx, -16, s->h_edge_pos - width + 15);
434 my = av_clip(my, -16, s->v_edge_pos - height + 15);
437 /* form component predictions */
438 dest = s->cur_pic->f->data[0] + x + y * linesize;
439 src = pic->f->data[0] + mx + my * linesize;
442 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src,
444 width + 1, height + 1,
445 mx, my, s->h_edge_pos, s->v_edge_pos);
446 src = s->edge_emu_buffer;
449 (avg ? s->tdsp.avg_tpel_pixels_tab
450 : s->tdsp.put_tpel_pixels_tab)[dxy](dest, src, linesize,
453 (avg ? s->hdsp.avg_pixels_tab
454 : s->hdsp.put_pixels_tab)[blocksize][dxy](dest, src, linesize,
457 if (!(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
458 mx = mx + (mx < (int) x) >> 1;
459 my = my + (my < (int) y) >> 1;
461 height = height >> 1;
464 for (i = 1; i < 3; i++) {
465 dest = s->cur_pic->f->data[i] + (x >> 1) + (y >> 1) * uvlinesize;
466 src = pic->f->data[i] + mx + my * uvlinesize;
469 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src,
470 uvlinesize, uvlinesize,
471 width + 1, height + 1,
472 mx, my, (s->h_edge_pos >> 1),
474 src = s->edge_emu_buffer;
477 (avg ? s->tdsp.avg_tpel_pixels_tab
478 : s->tdsp.put_tpel_pixels_tab)[dxy](dest, src,
482 (avg ? s->hdsp.avg_pixels_tab
483 : s->hdsp.put_pixels_tab)[blocksize][dxy](dest, src,
490 static inline int svq3_mc_dir(SVQ3Context *s, int size, int mode,
493 int i, j, k, mx, my, dx, dy, x, y;
494 const int part_width = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
495 const int part_height = 16 >> ((unsigned)(size + 1) / 3);
496 const int extra_width = (mode == PREDICT_MODE) ? -16 * 6 : 0;
497 const int h_edge_pos = 6 * (s->h_edge_pos - part_width) - extra_width;
498 const int v_edge_pos = 6 * (s->v_edge_pos - part_height) - extra_width;
500 for (i = 0; i < 16; i += part_height)
501 for (j = 0; j < 16; j += part_width) {
502 const int b_xy = (4 * s->mb_x + (j >> 2)) +
503 (4 * s->mb_y + (i >> 2)) * s->b_stride;
505 x = 16 * s->mb_x + j;
506 y = 16 * s->mb_y + i;
507 k = (j >> 2 & 1) + (i >> 1 & 2) +
508 (j >> 1 & 4) + (i & 8);
510 if (mode != PREDICT_MODE) {
511 svq3_pred_motion(s, k, part_width >> 2, dir, 1, &mx, &my);
513 mx = s->next_pic->motion_val[0][b_xy][0] << 1;
514 my = s->next_pic->motion_val[0][b_xy][1] << 1;
517 mx = mx * s->frame_num_offset /
518 s->prev_frame_num_offset + 1 >> 1;
519 my = my * s->frame_num_offset /
520 s->prev_frame_num_offset + 1 >> 1;
522 mx = mx * (s->frame_num_offset - s->prev_frame_num_offset) /
523 s->prev_frame_num_offset + 1 >> 1;
524 my = my * (s->frame_num_offset - s->prev_frame_num_offset) /
525 s->prev_frame_num_offset + 1 >> 1;
529 /* clip motion vector prediction to frame border */
530 mx = av_clip(mx, extra_width - 6 * x, h_edge_pos - 6 * x);
531 my = av_clip(my, extra_width - 6 * y, v_edge_pos - 6 * y);
533 /* get (optional) motion vector differential */
534 if (mode == PREDICT_MODE) {
537 dy = svq3_get_se_golomb(&s->gb_slice);
538 dx = svq3_get_se_golomb(&s->gb_slice);
540 if (dx == INVALID_VLC || dy == INVALID_VLC) {
541 av_log(s->avctx, AV_LOG_ERROR, "invalid MV vlc\n");
546 /* compute motion vector */
547 if (mode == THIRDPEL_MODE) {
549 mx = (mx + 1 >> 1) + dx;
550 my = (my + 1 >> 1) + dy;
551 fx = (unsigned)(mx + 0x3000) / 3 - 0x1000;
552 fy = (unsigned)(my + 0x3000) / 3 - 0x1000;
553 dxy = (mx - 3 * fx) + 4 * (my - 3 * fy);
555 svq3_mc_dir_part(s, x, y, part_width, part_height,
556 fx, fy, dxy, 1, dir, avg);
559 } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
560 mx = (unsigned)(mx + 1 + 0x3000) / 3 + dx - 0x1000;
561 my = (unsigned)(my + 1 + 0x3000) / 3 + dy - 0x1000;
562 dxy = (mx & 1) + 2 * (my & 1);
564 svq3_mc_dir_part(s, x, y, part_width, part_height,
565 mx >> 1, my >> 1, dxy, 0, dir, avg);
569 mx = (unsigned)(mx + 3 + 0x6000) / 6 + dx - 0x1000;
570 my = (unsigned)(my + 3 + 0x6000) / 6 + dy - 0x1000;
572 svq3_mc_dir_part(s, x, y, part_width, part_height,
573 mx, my, 0, 0, dir, avg);
578 /* update mv_cache */
579 if (mode != PREDICT_MODE) {
580 int32_t mv = pack16to32(mx, my);
582 if (part_height == 8 && i < 8) {
583 AV_WN32A(s->mv_cache[dir][scan8[k] + 1 * 8], mv);
585 if (part_width == 8 && j < 8)
586 AV_WN32A(s->mv_cache[dir][scan8[k] + 1 + 1 * 8], mv);
588 if (part_width == 8 && j < 8)
589 AV_WN32A(s->mv_cache[dir][scan8[k] + 1], mv);
590 if (part_width == 4 || part_height == 4)
591 AV_WN32A(s->mv_cache[dir][scan8[k]], mv);
594 /* write back motion vectors */
595 fill_rectangle(s->cur_pic->motion_val[dir][b_xy],
596 part_width >> 2, part_height >> 2, s->b_stride,
597 pack16to32(mx, my), 4);
603 static av_always_inline void hl_decode_mb_idct_luma(SVQ3Context *s,
604 int mb_type, const int *block_offset,
605 int linesize, uint8_t *dest_y)
608 if (!IS_INTRA4x4(mb_type)) {
609 for (i = 0; i < 16; i++)
610 if (s->non_zero_count_cache[scan8[i]] || s->mb[i * 16]) {
611 uint8_t *const ptr = dest_y + block_offset[i];
612 svq3_add_idct_c(ptr, s->mb + i * 16, linesize,
613 s->qscale, IS_INTRA(mb_type) ? 1 : 0);
618 static av_always_inline int dctcoef_get(int16_t *mb, int index)
620 return AV_RN16A(mb + index);
623 static av_always_inline void hl_decode_mb_predict_luma(SVQ3Context *s,
625 const int *block_offset,
630 int qscale = s->qscale;
632 if (IS_INTRA4x4(mb_type)) {
633 for (i = 0; i < 16; i++) {
634 uint8_t *const ptr = dest_y + block_offset[i];
635 const int dir = s->intra4x4_pred_mode_cache[scan8[i]];
639 if (dir == DIAG_DOWN_LEFT_PRED || dir == VERT_LEFT_PRED) {
640 const int topright_avail = (s->topright_samples_available << i) & 0x8000;
641 av_assert2(s->mb_y || linesize <= block_offset[i]);
642 if (!topright_avail) {
643 tr = ptr[3 - linesize] * 0x01010101u;
644 topright = (uint8_t *)&tr;
646 topright = ptr + 4 - linesize;
650 s->hpc.pred4x4[dir](ptr, topright, linesize);
651 nnz = s->non_zero_count_cache[scan8[i]];
653 svq3_add_idct_c(ptr, s->mb + i * 16, linesize, qscale, 0);
657 s->hpc.pred16x16[s->intra16x16_pred_mode](dest_y, linesize);
658 svq3_luma_dc_dequant_idct_c(s->mb, s->mb_luma_dc[0], qscale);
662 static void hl_decode_mb(SVQ3Context *s)
664 const int mb_x = s->mb_x;
665 const int mb_y = s->mb_y;
666 const int mb_xy = s->mb_xy;
667 const int mb_type = s->cur_pic->mb_type[mb_xy];
668 uint8_t *dest_y, *dest_cb, *dest_cr;
669 int linesize, uvlinesize;
671 const int *block_offset = &s->block_offset[0];
672 const int block_h = 16 >> 1;
674 linesize = s->cur_pic->f->linesize[0];
675 uvlinesize = s->cur_pic->f->linesize[1];
677 dest_y = s->cur_pic->f->data[0] + (mb_x + mb_y * linesize) * 16;
678 dest_cb = s->cur_pic->f->data[1] + mb_x * 8 + mb_y * uvlinesize * block_h;
679 dest_cr = s->cur_pic->f->data[2] + mb_x * 8 + mb_y * uvlinesize * block_h;
681 s->vdsp.prefetch(dest_y + (s->mb_x & 3) * 4 * linesize + 64, linesize, 4);
682 s->vdsp.prefetch(dest_cb + (s->mb_x & 7) * uvlinesize + 64, dest_cr - dest_cb, 2);
684 if (IS_INTRA(mb_type)) {
685 s->hpc.pred8x8[s->chroma_pred_mode](dest_cb, uvlinesize);
686 s->hpc.pred8x8[s->chroma_pred_mode](dest_cr, uvlinesize);
688 hl_decode_mb_predict_luma(s, mb_type, block_offset, linesize, dest_y);
691 hl_decode_mb_idct_luma(s, mb_type, block_offset, linesize, dest_y);
694 uint8_t *dest[2] = { dest_cb, dest_cr };
695 s->h264dsp.h264_chroma_dc_dequant_idct(s->mb + 16 * 16 * 1,
696 s->dequant4_coeff[4][0]);
697 s->h264dsp.h264_chroma_dc_dequant_idct(s->mb + 16 * 16 * 2,
698 s->dequant4_coeff[4][0]);
699 for (j = 1; j < 3; j++) {
700 for (i = j * 16; i < j * 16 + 4; i++)
701 if (s->non_zero_count_cache[scan8[i]] || s->mb[i * 16]) {
702 uint8_t *const ptr = dest[j - 1] + block_offset[i];
703 svq3_add_idct_c(ptr, s->mb + i * 16,
704 uvlinesize, ff_h264_chroma_qp[0][s->qscale + 12] - 12, 2);
710 static int svq3_decode_mb(SVQ3Context *s, unsigned int mb_type)
712 int i, j, k, m, dir, mode;
716 const int mb_xy = s->mb_xy;
717 const int b_xy = 4 * s->mb_x + 4 * s->mb_y * s->b_stride;
719 s->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
720 s->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
721 s->topright_samples_available = 0xFFFF;
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,
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,
733 mb_type = MB_TYPE_SKIP;
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)
738 if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 1, 1) < 0)
741 mb_type = MB_TYPE_16x16;
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))
753 /* note ref_cache should contain here:
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]);
767 for (i = 0; i < 4; i++)
768 AV_ZERO32(s->mv_cache[m][scan8[0] - 1 + i * 8]);
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);
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;
784 s->ref_cache[m][scan8[0] + 4 - 1 * 8] = PART_NOT_AVAILABLE;
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;
791 s->ref_cache[m][scan8[0] - 1 - 1 * 8] = PART_NOT_AVAILABLE;
793 memset(&s->ref_cache[m][scan8[0] - 1 * 8 - 1],
794 PART_NOT_AVAILABLE, 8);
796 if (s->pict_type != AV_PICTURE_TYPE_B)
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)
804 } else { /* AV_PICTURE_TYPE_B */
806 if (svq3_mc_dir(s, 0, mode, 0, 0) < 0)
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));
814 if (svq3_mc_dir(s, 0, mode, 1, mb_type == 3) < 0)
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));
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;
828 memset(s->intra4x4_pred_mode_cache, -1, 8 * 5 * sizeof(int8_t));
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;
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];
843 if (s->intra4x4_pred_mode_cache[4 + 8 * 0] == -1)
844 s->top_samples_available = 0x33FF;
847 /* decode prediction codes for luma blocks */
848 for (i = 0; i < 16; i += 2) {
849 vlc = svq3_get_ue_golomb(&s->gb_slice);
852 av_log(s->avctx, AV_LOG_ERROR,
853 "luma prediction:%"PRIu32"\n", vlc);
857 left = &s->intra4x4_pred_mode_cache[scan8[i] - 1];
858 top = &s->intra4x4_pred_mode_cache[scan8[i] - 8];
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]];
863 if (left[1] == -1 || left[2] == -1) {
864 av_log(s->avctx, AV_LOG_ERROR, "weird prediction\n");
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);
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];
879 ff_h264_check_intra4x4_pred_mode(s->intra4x4_pred_mode_cache,
880 s->avctx, s->top_samples_available,
881 s->left_samples_available);
883 s->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
884 s->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
886 for (i = 0; i < 4; i++)
887 memset(&s->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_128_PRED, 4);
889 s->top_samples_available = 0x33FF;
890 s->left_samples_available = 0x5F5F;
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;
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;
904 cbp = ff_h264_i_mb_type_info[mb_type - 8].cbp;
905 mb_type = MB_TYPE_INTRA16x16;
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));
918 if (!IS_INTRA4x4(mb_type)) {
919 memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy], DC_PRED, 8);
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));
925 if (!IS_INTRA16x16(mb_type) &&
926 (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B)) {
927 if ((vlc = svq3_get_ue_golomb(&s->gb_slice)) >= 48U){
928 av_log(s->avctx, AV_LOG_ERROR, "cbp_vlc=%"PRIu32"\n", vlc);
932 cbp = IS_INTRA(mb_type) ? ff_h264_golomb_to_intra4x4_cbp[vlc]
933 : ff_h264_golomb_to_inter_cbp[vlc];
935 if (IS_INTRA16x16(mb_type) ||
936 (s->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
937 s->qscale += svq3_get_se_golomb(&s->gb_slice);
939 if (s->qscale > 31u) {
940 av_log(s->avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
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");
955 const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
956 const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
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))
964 s->non_zero_count_cache[scan8[k]] = 1;
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");
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");
983 for (i = 1; i < 3; i++) {
984 for (j = 0; j < 4; j++) {
986 s->non_zero_count_cache[scan8[k]] = 1;
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");
1000 s->cur_pic->mb_type[mb_xy] = mb_type;
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);
1009 static int svq3_decode_slice_header(AVCodecContext *avctx)
1011 SVQ3Context *s = avctx->priv_data;
1012 const int mb_xy = s->mb_xy;
1016 header = get_bits(&s->gb, 8);
1018 if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
1020 av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
1023 int slice_bits, slice_bytes, slice_length;
1024 int length = header >> 5 & 3;
1026 slice_length = show_bits(&s->gb, 8 * length);
1027 slice_bits = slice_length * 8;
1028 slice_bytes = slice_length + length - 1;
1030 if (slice_bytes > get_bits_left(&s->gb)) {
1031 av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
1035 skip_bits(&s->gb, 8);
1037 av_fast_malloc(&s->slice_buf, &s->slice_size, slice_bytes + AV_INPUT_BUFFER_PADDING_SIZE);
1039 return AVERROR(ENOMEM);
1041 memcpy(s->slice_buf, s->gb.buffer + s->gb.index / 8, slice_bytes);
1043 init_get_bits(&s->gb_slice, s->slice_buf, slice_bits);
1045 if (s->watermark_key) {
1046 uint32_t header = AV_RL32(&s->gb_slice.buffer[1]);
1047 AV_WL32(&s->gb_slice.buffer[1], header ^ s->watermark_key);
1050 memmove(s->slice_buf, &s->slice_buf[slice_length], length - 1);
1052 skip_bits_long(&s->gb, slice_bytes * 8);
1055 if ((slice_id = svq3_get_ue_golomb(&s->gb_slice)) >= 3) {
1056 av_log(s->avctx, AV_LOG_ERROR, "illegal slice type %u \n", slice_id);
1060 s->pict_type = ff_h264_golomb_to_pict_type[slice_id];
1062 if ((header & 0x9F) == 2) {
1063 i = (s->mb_num < 64) ? 6 : (1 + av_log2(s->mb_num - 1));
1064 get_bits(&s->gb_slice, i);
1066 skip_bits1(&s->gb_slice);
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);
1073 /* unknown fields */
1074 skip_bits1(&s->gb_slice);
1076 if (s->has_watermark)
1077 skip_bits1(&s->gb_slice);
1079 skip_bits1(&s->gb_slice);
1080 skip_bits(&s->gb_slice, 2);
1082 if (skip_1stop_8data_bits(&s->gb_slice) < 0)
1083 return AVERROR_INVALIDDATA;
1085 /* reset intra predictors and invalidate motion vector references */
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);
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));
1097 s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride - 1] + 3] = -1;
1103 static void init_dequant4_coeff_table(SVQ3Context *s)
1106 const int max_qp = 51;
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;
1117 static av_cold int svq3_decode_init(AVCodecContext *avctx)
1119 SVQ3Context *s = avctx->priv_data;
1121 unsigned char *extradata;
1122 unsigned char *extradata_end;
1124 int marker_found = 0;
1127 s->cur_pic = av_mallocz(sizeof(*s->cur_pic));
1128 s->last_pic = av_mallocz(sizeof(*s->last_pic));
1129 s->next_pic = av_mallocz(sizeof(*s->next_pic));
1130 if (!s->next_pic || !s->last_pic || !s->cur_pic) {
1131 ret = AVERROR(ENOMEM);
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;
1178 size = AV_RB32(&extradata[4]);
1179 if (size > extradata_end - extradata - 8) {
1180 ret = AVERROR_INVALIDDATA;
1183 init_get_bits(&gb, extradata + 8, size * 8);
1185 /* 'frame size code' and optional 'width, height' */
1186 frame_size_code = get_bits(&gb, 3);
1187 switch (frame_size_code) {
1190 avctx->height = 120;
1198 avctx->height = 144;
1202 avctx->height = 288;
1206 avctx->height = 576;
1210 avctx->height = 180;
1214 avctx->height = 240;
1217 avctx->width = get_bits(&gb, 12);
1218 avctx->height = get_bits(&gb, 12);
1222 s->halfpel_flag = get_bits1(&gb);
1223 s->thirdpel_flag = get_bits1(&gb);
1225 /* unknown fields */
1226 unk0 = get_bits1(&gb);
1227 unk1 = get_bits1(&gb);
1228 unk2 = get_bits1(&gb);
1229 unk3 = get_bits1(&gb);
1231 s->low_delay = get_bits1(&gb);
1234 unk4 = get_bits1(&gb);
1236 av_log(avctx, AV_LOG_DEBUG, "Unknown fields %d %d %d %d %d\n",
1237 unk0, unk1, unk2, unk3, unk4);
1239 if (skip_1stop_8data_bits(&gb) < 0) {
1240 ret = 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 = svq3_get_ue_golomb(&gb);
1249 unsigned watermark_height = svq3_get_ue_golomb(&gb);
1250 int u1 = svq3_get_ue_golomb(&gb);
1251 int u2 = get_bits(&gb, 8);
1252 int u3 = get_bits(&gb, 2);
1253 int u4 = svq3_get_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) {
1265 buf = av_malloc(buf_len);
1267 ret = AVERROR(ENOMEM);
1270 av_log(avctx, AV_LOG_DEBUG, "watermark size: %ux%u\n",
1271 watermark_width, watermark_height);
1272 av_log(avctx, AV_LOG_DEBUG,
1273 "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n",
1274 u1, u2, u3, u4, offset);
1275 if (uncompress(buf, &buf_len, extradata + 8 + offset,
1276 size - offset) != Z_OK) {
1277 av_log(avctx, AV_LOG_ERROR,
1278 "could not uncompress watermark logo\n");
1283 s->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
1284 s->watermark_key = s->watermark_key << 16 | s->watermark_key;
1285 av_log(avctx, AV_LOG_DEBUG,
1286 "watermark key %#"PRIx32"\n", s->watermark_key);
1289 av_log(avctx, AV_LOG_ERROR,
1290 "this svq3 file contains watermark which need zlib support compiled in\n");
1297 s->mb_width = (avctx->width + 15) / 16;
1298 s->mb_height = (avctx->height + 15) / 16;
1299 s->mb_stride = s->mb_width + 1;
1300 s->mb_num = s->mb_width * s->mb_height;
1301 s->b_stride = 4 * s->mb_width;
1302 s->h_edge_pos = s->mb_width * 16;
1303 s->v_edge_pos = s->mb_height * 16;
1305 s->intra4x4_pred_mode = av_mallocz(s->mb_stride * 2 * 8);
1306 if (!s->intra4x4_pred_mode)
1307 return AVERROR(ENOMEM);
1309 s->mb2br_xy = av_mallocz(s->mb_stride * (s->mb_height + 1) *
1310 sizeof(*s->mb2br_xy));
1312 return AVERROR(ENOMEM);
1314 for (y = 0; y < s->mb_height; y++)
1315 for (x = 0; x < s->mb_width; x++) {
1316 const int mb_xy = x + y * s->mb_stride;
1318 s->mb2br_xy[mb_xy] = 8 * (mb_xy % (2 * s->mb_stride));
1321 init_dequant4_coeff_table(s);
1325 svq3_decode_end(avctx);
1329 static void free_picture(AVCodecContext *avctx, H264Picture *pic)
1332 for (i = 0; i < 2; i++) {
1333 av_buffer_unref(&pic->motion_val_buf[i]);
1334 av_buffer_unref(&pic->ref_index_buf[i]);
1336 av_buffer_unref(&pic->mb_type_buf);
1338 av_frame_unref(pic->f);
1341 static int get_buffer(AVCodecContext *avctx, H264Picture *pic)
1343 SVQ3Context *s = avctx->priv_data;
1344 const int big_mb_num = s->mb_stride * (s->mb_height + 1) + 1;
1345 const int mb_array_size = s->mb_stride * s->mb_height;
1346 const int b4_stride = s->mb_width * 4 + 1;
1347 const int b4_array_size = b4_stride * s->mb_height * 4;
1350 if (!pic->motion_val_buf[0]) {
1353 pic->mb_type_buf = av_buffer_allocz((big_mb_num + s->mb_stride) * sizeof(uint32_t));
1354 if (!pic->mb_type_buf)
1355 return AVERROR(ENOMEM);
1356 pic->mb_type = (uint32_t*)pic->mb_type_buf->data + 2 * s->mb_stride + 1;
1358 for (i = 0; i < 2; i++) {
1359 pic->motion_val_buf[i] = av_buffer_allocz(2 * (b4_array_size + 4) * sizeof(int16_t));
1360 pic->ref_index_buf[i] = av_buffer_allocz(4 * mb_array_size);
1361 if (!pic->motion_val_buf[i] || !pic->ref_index_buf[i]) {
1362 ret = AVERROR(ENOMEM);
1366 pic->motion_val[i] = (int16_t (*)[2])pic->motion_val_buf[i]->data + 4;
1367 pic->ref_index[i] = pic->ref_index_buf[i]->data;
1370 pic->reference = !(s->pict_type == AV_PICTURE_TYPE_B);
1372 ret = ff_get_buffer(avctx, pic->f,
1373 pic->reference ? AV_GET_BUFFER_FLAG_REF : 0);
1377 if (!s->edge_emu_buffer) {
1378 s->edge_emu_buffer = av_mallocz_array(pic->f->linesize[0], 17);
1379 if (!s->edge_emu_buffer)
1380 return AVERROR(ENOMEM);
1385 free_picture(avctx, pic);
1389 static int svq3_decode_frame(AVCodecContext *avctx, void *data,
1390 int *got_frame, AVPacket *avpkt)
1392 SVQ3Context *s = avctx->priv_data;
1393 int buf_size = avpkt->size;
1398 /* special case for last picture */
1399 if (buf_size == 0) {
1400 if (s->next_pic->f->data[0] && !s->low_delay && !s->last_frame_output) {
1401 ret = av_frame_ref(data, s->next_pic->f);
1404 s->last_frame_output = 1;
1410 s->mb_x = s->mb_y = s->mb_xy = 0;
1412 if (s->watermark_key) {
1413 av_fast_padded_malloc(&s->buf, &s->buf_size, buf_size);
1415 return AVERROR(ENOMEM);
1416 memcpy(s->buf, avpkt->data, buf_size);
1422 ret = init_get_bits(&s->gb, buf, 8 * buf_size);
1426 if (svq3_decode_slice_header(avctx))
1429 if (s->pict_type != AV_PICTURE_TYPE_B)
1430 FFSWAP(H264Picture*, s->next_pic, s->last_pic);
1432 av_frame_unref(s->cur_pic->f);
1434 /* for skipping the frame */
1435 s->cur_pic->f->pict_type = s->pict_type;
1436 s->cur_pic->f->key_frame = (s->pict_type == AV_PICTURE_TYPE_I);
1438 ret = get_buffer(avctx, s->cur_pic);
1442 for (i = 0; i < 16; i++) {
1443 s->block_offset[i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * s->cur_pic->f->linesize[0] * ((scan8[i] - scan8[0]) >> 3);
1444 s->block_offset[48 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * s->cur_pic->f->linesize[0] * ((scan8[i] - scan8[0]) >> 3);
1446 for (i = 0; i < 16; i++) {
1447 s->block_offset[16 + i] =
1448 s->block_offset[32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * s->cur_pic->f->linesize[1] * ((scan8[i] - scan8[0]) >> 3);
1449 s->block_offset[48 + 16 + i] =
1450 s->block_offset[48 + 32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * s->cur_pic->f->linesize[1] * ((scan8[i] - scan8[0]) >> 3);
1453 if (s->pict_type != AV_PICTURE_TYPE_I) {
1454 if (!s->last_pic->f->data[0]) {
1455 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1456 av_frame_unref(s->last_pic->f);
1457 ret = get_buffer(avctx, s->last_pic);
1460 memset(s->last_pic->f->data[0], 0, avctx->height * s->last_pic->f->linesize[0]);
1461 memset(s->last_pic->f->data[1], 0x80, (avctx->height / 2) *
1462 s->last_pic->f->linesize[1]);
1463 memset(s->last_pic->f->data[2], 0x80, (avctx->height / 2) *
1464 s->last_pic->f->linesize[2]);
1467 if (s->pict_type == AV_PICTURE_TYPE_B && !s->next_pic->f->data[0]) {
1468 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1469 av_frame_unref(s->next_pic->f);
1470 ret = get_buffer(avctx, s->next_pic);
1473 memset(s->next_pic->f->data[0], 0, avctx->height * s->next_pic->f->linesize[0]);
1474 memset(s->next_pic->f->data[1], 0x80, (avctx->height / 2) *
1475 s->next_pic->f->linesize[1]);
1476 memset(s->next_pic->f->data[2], 0x80, (avctx->height / 2) *
1477 s->next_pic->f->linesize[2]);
1481 if (avctx->debug & FF_DEBUG_PICT_INFO)
1482 av_log(s->avctx, AV_LOG_DEBUG,
1483 "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
1484 av_get_picture_type_char(s->pict_type),
1485 s->halfpel_flag, s->thirdpel_flag,
1486 s->adaptive_quant, s->qscale, s->slice_num);
1488 if (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B ||
1489 avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I ||
1490 avctx->skip_frame >= AVDISCARD_ALL)
1493 if (s->next_p_frame_damaged) {
1494 if (s->pict_type == AV_PICTURE_TYPE_B)
1497 s->next_p_frame_damaged = 0;
1500 if (s->pict_type == AV_PICTURE_TYPE_B) {
1501 s->frame_num_offset = s->slice_num - s->prev_frame_num;
1503 if (s->frame_num_offset < 0)
1504 s->frame_num_offset += 256;
1505 if (s->frame_num_offset == 0 ||
1506 s->frame_num_offset >= s->prev_frame_num_offset) {
1507 av_log(s->avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1511 s->prev_frame_num = s->frame_num;
1512 s->frame_num = s->slice_num;
1513 s->prev_frame_num_offset = s->frame_num - s->prev_frame_num;
1515 if (s->prev_frame_num_offset < 0)
1516 s->prev_frame_num_offset += 256;
1519 for (m = 0; m < 2; m++) {
1521 for (i = 0; i < 4; i++) {
1523 for (j = -1; j < 4; j++)
1524 s->ref_cache[m][scan8[0] + 8 * i + j] = 1;
1526 s->ref_cache[m][scan8[0] + 8 * i + j] = PART_NOT_AVAILABLE;
1530 for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
1531 for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
1533 s->mb_xy = s->mb_x + s->mb_y * s->mb_stride;
1535 if ((get_bits_left(&s->gb_slice)) <= 7) {
1536 if (((get_bits_count(&s->gb_slice) & 7) == 0 ||
1537 show_bits(&s->gb_slice, get_bits_left(&s->gb_slice) & 7) == 0)) {
1539 if (svq3_decode_slice_header(avctx))
1542 /* TODO: support s->mb_skip_run */
1545 mb_type = svq3_get_ue_golomb(&s->gb_slice);
1547 if (s->pict_type == AV_PICTURE_TYPE_I)
1549 else if (s->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4)
1551 if (mb_type > 33 || svq3_decode_mb(s, mb_type)) {
1552 av_log(s->avctx, AV_LOG_ERROR,
1553 "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1557 if (mb_type != 0 || s->cbp)
1560 if (s->pict_type != AV_PICTURE_TYPE_B && !s->low_delay)
1561 s->cur_pic->mb_type[s->mb_x + s->mb_y * s->mb_stride] =
1562 (s->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1565 ff_draw_horiz_band(avctx, s->cur_pic->f,
1566 s->last_pic->f->data[0] ? s->last_pic->f : NULL,
1567 16 * s->mb_y, 16, PICT_FRAME, 0,
1571 left = buf_size*8 - get_bits_count(&s->gb_slice);
1573 if (s->mb_y != s->mb_height || s->mb_x != s->mb_width) {
1574 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);
1575 //av_hex_dump(stderr, buf+buf_size-8, 8);
1579 av_log(avctx, AV_LOG_ERROR, "frame num %d left %d\n", avctx->frame_number, left);
1583 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay)
1584 ret = av_frame_ref(data, s->cur_pic->f);
1585 else if (s->last_pic->f->data[0])
1586 ret = av_frame_ref(data, s->last_pic->f);
1590 /* Do not output the last pic after seeking. */
1591 if (s->last_pic->f->data[0] || s->low_delay)
1594 if (s->pict_type != AV_PICTURE_TYPE_B) {
1595 FFSWAP(H264Picture*, s->cur_pic, s->next_pic);
1597 av_frame_unref(s->cur_pic->f);
1603 static av_cold int svq3_decode_end(AVCodecContext *avctx)
1605 SVQ3Context *s = avctx->priv_data;
1607 free_picture(avctx, s->cur_pic);
1608 free_picture(avctx, s->next_pic);
1609 free_picture(avctx, s->last_pic);
1610 av_frame_free(&s->cur_pic->f);
1611 av_frame_free(&s->next_pic->f);
1612 av_frame_free(&s->last_pic->f);
1613 av_freep(&s->cur_pic);
1614 av_freep(&s->next_pic);
1615 av_freep(&s->last_pic);
1616 av_freep(&s->slice_buf);
1617 av_freep(&s->intra4x4_pred_mode);
1618 av_freep(&s->edge_emu_buffer);
1619 av_freep(&s->mb2br_xy);
1628 AVCodec ff_svq3_decoder = {
1630 .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1631 .type = AVMEDIA_TYPE_VIDEO,
1632 .id = AV_CODEC_ID_SVQ3,
1633 .priv_data_size = sizeof(SVQ3Context),
1634 .init = svq3_decode_init,
1635 .close = svq3_decode_end,
1636 .decode = svq3_decode_frame,
1637 .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND |
1640 .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P,