2 * Copyright (c) 2003 The Libav Project
4 * This file is part of Libav.
6 * Libav 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 * Libav 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 Libav; 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.libav.org/V-codecs/SVQ3/Vertical400kbit.sorenson3.mov
45 #include "mpegvideo.h"
48 #include "h264data.h" // FIXME FIXME FIXME
50 #include "h264_mvpred.h"
52 #include "rectangle.h"
53 #include "vdpau_internal.h"
72 uint32_t watermark_key;
75 #define FULLPEL_MODE 1
76 #define HALFPEL_MODE 2
77 #define THIRDPEL_MODE 3
78 #define PREDICT_MODE 4
80 /* dual scan (from some older h264 draft)
89 static const uint8_t svq3_scan[16] = {
90 0 + 0 * 4, 1 + 0 * 4, 2 + 0 * 4, 2 + 1 * 4,
91 2 + 2 * 4, 3 + 0 * 4, 3 + 1 * 4, 3 + 2 * 4,
92 0 + 1 * 4, 0 + 2 * 4, 1 + 1 * 4, 1 + 2 * 4,
93 0 + 3 * 4, 1 + 3 * 4, 2 + 3 * 4, 3 + 3 * 4,
96 static const uint8_t svq3_pred_0[25][2] = {
99 { 0, 2 }, { 1, 1 }, { 2, 0 },
100 { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
101 { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
102 { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
103 { 2, 4 }, { 3, 3 }, { 4, 2 },
108 static const int8_t svq3_pred_1[6][6][5] = {
109 { { 2, -1, -1, -1, -1 }, { 2, 1, -1, -1, -1 }, { 1, 2, -1, -1, -1 },
110 { 2, 1, -1, -1, -1 }, { 1, 2, -1, -1, -1 }, { 1, 2, -1, -1, -1 } },
111 { { 0, 2, -1, -1, -1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
112 { 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
113 { { 2, 0, -1, -1, -1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
114 { 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
115 { { 2, 0, -1, -1, -1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
116 { 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
117 { { 0, 2, -1, -1, -1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
118 { 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
119 { { 0, 2, -1, -1, -1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
120 { 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
123 static const struct {
126 } svq3_dct_tables[2][16] = {
127 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
128 { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
129 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
130 { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
133 static const uint32_t svq3_dequant_coeff[32] = {
134 3881, 4351, 4890, 5481, 6154, 6914, 7761, 8718,
135 9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
136 24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
137 61694, 68745, 77615, 89113, 100253, 109366, 126635, 141533
140 void ff_svq3_luma_dc_dequant_idct_c(int16_t *output, int16_t *input, int qp)
142 const int qmul = svq3_dequant_coeff[qp];
146 static const uint8_t x_offset[4] = { 0, 1 * stride, 4 * stride, 5 * stride };
148 for (i = 0; i < 4; i++) {
149 const int z0 = 13 * (input[4 * i + 0] + input[4 * i + 2]);
150 const int z1 = 13 * (input[4 * i + 0] - input[4 * i + 2]);
151 const int z2 = 7 * input[4 * i + 1] - 17 * input[4 * i + 3];
152 const int z3 = 17 * input[4 * i + 1] + 7 * input[4 * i + 3];
154 temp[4 * i + 0] = z0 + z3;
155 temp[4 * i + 1] = z1 + z2;
156 temp[4 * i + 2] = z1 - z2;
157 temp[4 * i + 3] = z0 - z3;
160 for (i = 0; i < 4; i++) {
161 const int offset = x_offset[i];
162 const int z0 = 13 * (temp[4 * 0 + i] + temp[4 * 2 + i]);
163 const int z1 = 13 * (temp[4 * 0 + i] - temp[4 * 2 + i]);
164 const int z2 = 7 * temp[4 * 1 + i] - 17 * temp[4 * 3 + i];
165 const int z3 = 17 * temp[4 * 1 + i] + 7 * temp[4 * 3 + i];
167 output[stride * 0 + offset] = (z0 + z3) * qmul + 0x80000 >> 20;
168 output[stride * 2 + offset] = (z1 + z2) * qmul + 0x80000 >> 20;
169 output[stride * 8 + offset] = (z1 - z2) * qmul + 0x80000 >> 20;
170 output[stride * 10 + offset] = (z0 - z3) * qmul + 0x80000 >> 20;
175 void ff_svq3_add_idct_c(uint8_t *dst, int16_t *block,
176 int stride, int qp, int dc)
178 const int qmul = svq3_dequant_coeff[qp];
182 dc = 13 * 13 * (dc == 1 ? 1538 * block[0]
183 : qmul * (block[0] >> 3) / 2);
187 for (i = 0; i < 4; i++) {
188 const int z0 = 13 * (block[0 + 4 * i] + block[2 + 4 * i]);
189 const int z1 = 13 * (block[0 + 4 * i] - block[2 + 4 * i]);
190 const int z2 = 7 * block[1 + 4 * i] - 17 * block[3 + 4 * i];
191 const int z3 = 17 * block[1 + 4 * i] + 7 * block[3 + 4 * i];
193 block[0 + 4 * i] = z0 + z3;
194 block[1 + 4 * i] = z1 + z2;
195 block[2 + 4 * i] = z1 - z2;
196 block[3 + 4 * i] = z0 - z3;
199 for (i = 0; i < 4; i++) {
200 const int z0 = 13 * (block[i + 4 * 0] + block[i + 4 * 2]);
201 const int z1 = 13 * (block[i + 4 * 0] - block[i + 4 * 2]);
202 const int z2 = 7 * block[i + 4 * 1] - 17 * block[i + 4 * 3];
203 const int z3 = 17 * block[i + 4 * 1] + 7 * block[i + 4 * 3];
204 const int rr = (dc + 0x80000);
206 dst[i + stride * 0] = av_clip_uint8(dst[i + stride * 0] + ((z0 + z3) * qmul + rr >> 20));
207 dst[i + stride * 1] = av_clip_uint8(dst[i + stride * 1] + ((z1 + z2) * qmul + rr >> 20));
208 dst[i + stride * 2] = av_clip_uint8(dst[i + stride * 2] + ((z1 - z2) * qmul + rr >> 20));
209 dst[i + stride * 3] = av_clip_uint8(dst[i + stride * 3] + ((z0 - z3) * qmul + rr >> 20));
213 static inline int svq3_decode_block(GetBitContext *gb, int16_t *block,
214 int index, const int type)
216 static const uint8_t *const scan_patterns[4] =
217 { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
219 int run, level, limit;
221 const int intra = 3 * type >> 2;
222 const uint8_t *const scan = scan_patterns[type];
224 for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
225 for (; (vlc = svq3_get_ue_golomb(gb)) != 0; index++) {
226 int sign = (vlc & 1) ? 0 : -1;
233 } else if (vlc < 4) {
238 level = (vlc + 9 >> 2) - run;
242 run = svq3_dct_tables[intra][vlc].run;
243 level = svq3_dct_tables[intra][vlc].level;
247 ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
251 ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
255 if ((index += run) >= limit)
258 block[scan[index]] = (level ^ sign) - sign;
269 static inline void svq3_mc_dir_part(MpegEncContext *s,
270 int x, int y, int width, int height,
271 int mx, int my, int dxy,
272 int thirdpel, int dir, int avg)
274 const Picture *pic = (dir == 0) ? &s->last_picture : &s->next_picture;
277 int blocksize = 2 - (width >> 3); // 16->0, 8->1, 4->2
282 if (mx < 0 || mx >= s->h_edge_pos - width - 1 ||
283 my < 0 || my >= s->v_edge_pos - height - 1) {
284 if ((s->flags & CODEC_FLAG_EMU_EDGE))
287 mx = av_clip(mx, -16, s->h_edge_pos - width + 15);
288 my = av_clip(my, -16, s->v_edge_pos - height + 15);
291 /* form component predictions */
292 dest = s->current_picture.f.data[0] + x + y * s->linesize;
293 src = pic->f.data[0] + mx + my * s->linesize;
296 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize,
297 width + 1, height + 1,
298 mx, my, s->h_edge_pos, s->v_edge_pos);
299 src = s->edge_emu_buffer;
302 (avg ? s->dsp.avg_tpel_pixels_tab
303 : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->linesize,
306 (avg ? s->dsp.avg_pixels_tab
307 : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->linesize,
310 if (!(s->flags & CODEC_FLAG_GRAY)) {
311 mx = mx + (mx < (int) x) >> 1;
312 my = my + (my < (int) y) >> 1;
314 height = height >> 1;
317 for (i = 1; i < 3; i++) {
318 dest = s->current_picture.f.data[i] + (x >> 1) + (y >> 1) * s->uvlinesize;
319 src = pic->f.data[i] + mx + my * s->uvlinesize;
322 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src, s->uvlinesize,
323 width + 1, height + 1,
324 mx, my, (s->h_edge_pos >> 1),
326 src = s->edge_emu_buffer;
329 (avg ? s->dsp.avg_tpel_pixels_tab
330 : s->dsp.put_tpel_pixels_tab)[dxy](dest, src,
334 (avg ? s->dsp.avg_pixels_tab
335 : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src,
342 static inline int svq3_mc_dir(H264Context *h, int size, int mode,
345 int i, j, k, mx, my, dx, dy, x, y;
346 MpegEncContext *const s = (MpegEncContext *)h;
347 const int part_width = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
348 const int part_height = 16 >> ((unsigned)(size + 1) / 3);
349 const int extra_width = (mode == PREDICT_MODE) ? -16 * 6 : 0;
350 const int h_edge_pos = 6 * (s->h_edge_pos - part_width) - extra_width;
351 const int v_edge_pos = 6 * (s->v_edge_pos - part_height) - extra_width;
353 for (i = 0; i < 16; i += part_height)
354 for (j = 0; j < 16; j += part_width) {
355 const int b_xy = (4 * s->mb_x + (j >> 2)) +
356 (4 * s->mb_y + (i >> 2)) * h->b_stride;
358 x = 16 * s->mb_x + j;
359 y = 16 * s->mb_y + i;
360 k = (j >> 2 & 1) + (i >> 1 & 2) +
361 (j >> 1 & 4) + (i & 8);
363 if (mode != PREDICT_MODE) {
364 pred_motion(h, k, part_width >> 2, dir, 1, &mx, &my);
366 mx = s->next_picture.f.motion_val[0][b_xy][0] << 1;
367 my = s->next_picture.f.motion_val[0][b_xy][1] << 1;
370 mx = mx * h->frame_num_offset /
371 h->prev_frame_num_offset + 1 >> 1;
372 my = my * h->frame_num_offset /
373 h->prev_frame_num_offset + 1 >> 1;
375 mx = mx * (h->frame_num_offset - h->prev_frame_num_offset) /
376 h->prev_frame_num_offset + 1 >> 1;
377 my = my * (h->frame_num_offset - h->prev_frame_num_offset) /
378 h->prev_frame_num_offset + 1 >> 1;
382 /* clip motion vector prediction to frame border */
383 mx = av_clip(mx, extra_width - 6 * x, h_edge_pos - 6 * x);
384 my = av_clip(my, extra_width - 6 * y, v_edge_pos - 6 * y);
386 /* get (optional) motion vector differential */
387 if (mode == PREDICT_MODE) {
390 dy = svq3_get_se_golomb(&s->gb);
391 dx = svq3_get_se_golomb(&s->gb);
393 if (dx == INVALID_VLC || dy == INVALID_VLC) {
394 av_log(h->s.avctx, AV_LOG_ERROR, "invalid MV vlc\n");
399 /* compute motion vector */
400 if (mode == THIRDPEL_MODE) {
402 mx = (mx + 1 >> 1) + dx;
403 my = (my + 1 >> 1) + dy;
404 fx = (unsigned)(mx + 0x3000) / 3 - 0x1000;
405 fy = (unsigned)(my + 0x3000) / 3 - 0x1000;
406 dxy = (mx - 3 * fx) + 4 * (my - 3 * fy);
408 svq3_mc_dir_part(s, x, y, part_width, part_height,
409 fx, fy, dxy, 1, dir, avg);
412 } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
413 mx = (unsigned)(mx + 1 + 0x3000) / 3 + dx - 0x1000;
414 my = (unsigned)(my + 1 + 0x3000) / 3 + dy - 0x1000;
415 dxy = (mx & 1) + 2 * (my & 1);
417 svq3_mc_dir_part(s, x, y, part_width, part_height,
418 mx >> 1, my >> 1, dxy, 0, dir, avg);
422 mx = (unsigned)(mx + 3 + 0x6000) / 6 + dx - 0x1000;
423 my = (unsigned)(my + 3 + 0x6000) / 6 + dy - 0x1000;
425 svq3_mc_dir_part(s, x, y, part_width, part_height,
426 mx, my, 0, 0, dir, avg);
431 /* update mv_cache */
432 if (mode != PREDICT_MODE) {
433 int32_t mv = pack16to32(mx, my);
435 if (part_height == 8 && i < 8) {
436 AV_WN32A(h->mv_cache[dir][scan8[k] + 1 * 8], mv);
438 if (part_width == 8 && j < 8)
439 AV_WN32A(h->mv_cache[dir][scan8[k] + 1 + 1 * 8], mv);
441 if (part_width == 8 && j < 8)
442 AV_WN32A(h->mv_cache[dir][scan8[k] + 1], mv);
443 if (part_width == 4 || part_height == 4)
444 AV_WN32A(h->mv_cache[dir][scan8[k]], mv);
447 /* write back motion vectors */
448 fill_rectangle(s->current_picture.f.motion_val[dir][b_xy],
449 part_width >> 2, part_height >> 2, h->b_stride,
450 pack16to32(mx, my), 4);
456 static int svq3_decode_mb(SVQ3Context *svq3, unsigned int mb_type)
458 H264Context *h = &svq3->h;
459 int i, j, k, m, dir, mode;
463 MpegEncContext *const s = (MpegEncContext *)h;
464 const int mb_xy = h->mb_xy;
465 const int b_xy = 4 * s->mb_x + 4 * s->mb_y * h->b_stride;
467 h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
468 h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
469 h->topright_samples_available = 0xFFFF;
471 if (mb_type == 0) { /* SKIP */
472 if (s->pict_type == AV_PICTURE_TYPE_P ||
473 s->next_picture.f.mb_type[mb_xy] == -1) {
474 svq3_mc_dir_part(s, 16 * s->mb_x, 16 * s->mb_y, 16, 16,
477 if (s->pict_type == AV_PICTURE_TYPE_B)
478 svq3_mc_dir_part(s, 16 * s->mb_x, 16 * s->mb_y, 16, 16,
481 mb_type = MB_TYPE_SKIP;
483 mb_type = FFMIN(s->next_picture.f.mb_type[mb_xy], 6);
484 if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 0, 0) < 0)
486 if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 1, 1) < 0)
489 mb_type = MB_TYPE_16x16;
491 } else if (mb_type < 8) { /* INTER */
492 if (svq3->thirdpel_flag && svq3->halfpel_flag == !get_bits1(&s->gb))
493 mode = THIRDPEL_MODE;
494 else if (svq3->halfpel_flag &&
495 svq3->thirdpel_flag == !get_bits1(&s->gb))
501 /* note ref_cache should contain here:
509 for (m = 0; m < 2; m++) {
510 if (s->mb_x > 0 && h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1] + 6] != -1) {
511 for (i = 0; i < 4; i++)
512 AV_COPY32(h->mv_cache[m][scan8[0] - 1 + i * 8],
513 s->current_picture.f.motion_val[m][b_xy - 1 + i * h->b_stride]);
515 for (i = 0; i < 4; i++)
516 AV_ZERO32(h->mv_cache[m][scan8[0] - 1 + i * 8]);
519 memcpy(h->mv_cache[m][scan8[0] - 1 * 8],
520 s->current_picture.f.motion_val[m][b_xy - h->b_stride],
521 4 * 2 * sizeof(int16_t));
522 memset(&h->ref_cache[m][scan8[0] - 1 * 8],
523 (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1, 4);
525 if (s->mb_x < s->mb_width - 1) {
526 AV_COPY32(h->mv_cache[m][scan8[0] + 4 - 1 * 8],
527 s->current_picture.f.motion_val[m][b_xy - h->b_stride + 4]);
528 h->ref_cache[m][scan8[0] + 4 - 1 * 8] =
529 (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride + 1] + 6] == -1 ||
530 h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1;
532 h->ref_cache[m][scan8[0] + 4 - 1 * 8] = PART_NOT_AVAILABLE;
534 AV_COPY32(h->mv_cache[m][scan8[0] - 1 - 1 * 8],
535 s->current_picture.f.motion_val[m][b_xy - h->b_stride - 1]);
536 h->ref_cache[m][scan8[0] - 1 - 1 * 8] =
537 (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride - 1] + 3] == -1) ? PART_NOT_AVAILABLE : 1;
539 h->ref_cache[m][scan8[0] - 1 - 1 * 8] = PART_NOT_AVAILABLE;
541 memset(&h->ref_cache[m][scan8[0] - 1 * 8 - 1],
542 PART_NOT_AVAILABLE, 8);
544 if (s->pict_type != AV_PICTURE_TYPE_B)
548 /* decode motion vector(s) and form prediction(s) */
549 if (s->pict_type == AV_PICTURE_TYPE_P) {
550 if (svq3_mc_dir(h, mb_type - 1, mode, 0, 0) < 0)
552 } else { /* AV_PICTURE_TYPE_B */
554 if (svq3_mc_dir(h, 0, mode, 0, 0) < 0)
557 for (i = 0; i < 4; i++)
558 memset(s->current_picture.f.motion_val[0][b_xy + i * h->b_stride],
559 0, 4 * 2 * sizeof(int16_t));
561 if (svq3_mc_dir(h, 0, mode, 1, mb_type == 3) < 0)
564 for (i = 0; i < 4; i++)
565 memset(s->current_picture.f.motion_val[1][b_xy + i * h->b_stride],
566 0, 4 * 2 * sizeof(int16_t));
569 mb_type = MB_TYPE_16x16;
570 } else if (mb_type == 8 || mb_type == 33) { /* INTRA4x4 */
571 memset(h->intra4x4_pred_mode_cache, -1, 8 * 5 * sizeof(int8_t));
575 for (i = 0; i < 4; i++)
576 h->intra4x4_pred_mode_cache[scan8[0] - 1 + i * 8] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1] + 6 - i];
577 if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1)
578 h->left_samples_available = 0x5F5F;
581 h->intra4x4_pred_mode_cache[4 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride] + 0];
582 h->intra4x4_pred_mode_cache[5 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride] + 1];
583 h->intra4x4_pred_mode_cache[6 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride] + 2];
584 h->intra4x4_pred_mode_cache[7 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride] + 3];
586 if (h->intra4x4_pred_mode_cache[4 + 8 * 0] == -1)
587 h->top_samples_available = 0x33FF;
590 /* decode prediction codes for luma blocks */
591 for (i = 0; i < 16; i += 2) {
592 vlc = svq3_get_ue_golomb(&s->gb);
595 av_log(h->s.avctx, AV_LOG_ERROR, "luma prediction:%d\n", vlc);
599 left = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
600 top = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
602 left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
603 left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
605 if (left[1] == -1 || left[2] == -1) {
606 av_log(h->s.avctx, AV_LOG_ERROR, "weird prediction\n");
610 } else { /* mb_type == 33, DC_128_PRED block type */
611 for (i = 0; i < 4; i++)
612 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_PRED, 4);
615 write_back_intra_pred_mode(h);
618 ff_h264_check_intra4x4_pred_mode(h);
620 h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
621 h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
623 for (i = 0; i < 4; i++)
624 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_128_PRED, 4);
626 h->top_samples_available = 0x33FF;
627 h->left_samples_available = 0x5F5F;
630 mb_type = MB_TYPE_INTRA4x4;
631 } else { /* INTRA16x16 */
632 dir = i_mb_type_info[mb_type - 8].pred_mode;
633 dir = (dir >> 1) ^ 3 * (dir & 1) ^ 1;
635 if ((h->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, dir, 0)) == -1) {
636 av_log(h->s.avctx, AV_LOG_ERROR, "check_intra_pred_mode = -1\n");
640 cbp = i_mb_type_info[mb_type - 8].cbp;
641 mb_type = MB_TYPE_INTRA16x16;
644 if (!IS_INTER(mb_type) && s->pict_type != AV_PICTURE_TYPE_I) {
645 for (i = 0; i < 4; i++)
646 memset(s->current_picture.f.motion_val[0][b_xy + i * h->b_stride],
647 0, 4 * 2 * sizeof(int16_t));
648 if (s->pict_type == AV_PICTURE_TYPE_B) {
649 for (i = 0; i < 4; i++)
650 memset(s->current_picture.f.motion_val[1][b_xy + i * h->b_stride],
651 0, 4 * 2 * sizeof(int16_t));
654 if (!IS_INTRA4x4(mb_type)) {
655 memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy], DC_PRED, 8);
657 if (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B) {
658 memset(h->non_zero_count_cache + 8, 0, 14 * 8 * sizeof(uint8_t));
659 s->dsp.clear_blocks(h->mb + 0);
660 s->dsp.clear_blocks(h->mb + 384);
663 if (!IS_INTRA16x16(mb_type) &&
664 (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B)) {
665 if ((vlc = svq3_get_ue_golomb(&s->gb)) >= 48) {
666 av_log(h->s.avctx, AV_LOG_ERROR, "cbp_vlc=%d\n", vlc);
670 cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc]
671 : golomb_to_inter_cbp[vlc];
673 if (IS_INTRA16x16(mb_type) ||
674 (s->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
675 s->qscale += svq3_get_se_golomb(&s->gb);
677 if (s->qscale > 31u) {
678 av_log(h->s.avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
682 if (IS_INTRA16x16(mb_type)) {
683 AV_ZERO128(h->mb_luma_dc[0] + 0);
684 AV_ZERO128(h->mb_luma_dc[0] + 8);
685 if (svq3_decode_block(&s->gb, h->mb_luma_dc[0], 0, 1)) {
686 av_log(h->s.avctx, AV_LOG_ERROR,
687 "error while decoding intra luma dc\n");
693 const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
694 const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
696 for (i = 0; i < 4; i++)
697 if ((cbp & (1 << i))) {
698 for (j = 0; j < 4; j++) {
699 k = index ? (1 * (j & 1) + 2 * (i & 1) +
700 2 * (j & 2) + 4 * (i & 2))
702 h->non_zero_count_cache[scan8[k]] = 1;
704 if (svq3_decode_block(&s->gb, &h->mb[16 * k], index, type)) {
705 av_log(h->s.avctx, AV_LOG_ERROR,
706 "error while decoding block\n");
713 for (i = 1; i < 3; ++i)
714 if (svq3_decode_block(&s->gb, &h->mb[16 * 16 * i], 0, 3)) {
715 av_log(h->s.avctx, AV_LOG_ERROR,
716 "error while decoding chroma dc block\n");
721 for (i = 1; i < 3; i++) {
722 for (j = 0; j < 4; j++) {
724 h->non_zero_count_cache[scan8[k]] = 1;
726 if (svq3_decode_block(&s->gb, &h->mb[16 * k], 1, 1)) {
727 av_log(h->s.avctx, AV_LOG_ERROR,
728 "error while decoding chroma ac block\n");
738 s->current_picture.f.mb_type[mb_xy] = mb_type;
740 if (IS_INTRA(mb_type))
741 h->chroma_pred_mode = ff_h264_check_intra_pred_mode(h, DC_PRED8x8, 1);
746 static int svq3_decode_slice_header(AVCodecContext *avctx)
748 SVQ3Context *svq3 = avctx->priv_data;
749 H264Context *h = &svq3->h;
750 MpegEncContext *s = &h->s;
751 const int mb_xy = h->mb_xy;
755 header = get_bits(&s->gb, 8);
757 if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
759 av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
762 int length = header >> 5 & 3;
764 svq3->next_slice_index = get_bits_count(&s->gb) +
765 8 * show_bits(&s->gb, 8 * length) +
768 if (svq3->next_slice_index > s->gb.size_in_bits) {
769 av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
773 s->gb.size_in_bits = svq3->next_slice_index - 8 * (length - 1);
774 skip_bits(&s->gb, 8);
776 if (svq3->watermark_key) {
777 uint32_t header = AV_RL32(&s->gb.buffer[(get_bits_count(&s->gb) >> 3) + 1]);
778 AV_WL32(&s->gb.buffer[(get_bits_count(&s->gb) >> 3) + 1],
779 header ^ svq3->watermark_key);
782 memcpy((uint8_t *) &s->gb.buffer[get_bits_count(&s->gb) >> 3],
783 &s->gb.buffer[s->gb.size_in_bits >> 3], length - 1);
785 skip_bits_long(&s->gb, 0);
788 if ((slice_id = svq3_get_ue_golomb(&s->gb)) >= 3) {
789 av_log(h->s.avctx, AV_LOG_ERROR, "illegal slice type %d \n", slice_id);
793 h->slice_type = golomb_to_pict_type[slice_id];
795 if ((header & 0x9F) == 2) {
796 i = (s->mb_num < 64) ? 6 : (1 + av_log2(s->mb_num - 1));
797 s->mb_skip_run = get_bits(&s->gb, i) -
798 (s->mb_y * s->mb_width + s->mb_x);
804 h->slice_num = get_bits(&s->gb, 8);
805 s->qscale = get_bits(&s->gb, 5);
806 s->adaptive_quant = get_bits1(&s->gb);
811 if (svq3->unknown_flag)
815 skip_bits(&s->gb, 2);
817 while (get_bits1(&s->gb))
818 skip_bits(&s->gb, 8);
820 /* reset intra predictors and invalidate motion vector references */
822 memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy - 1] + 3,
823 -1, 4 * sizeof(int8_t));
824 memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy - s->mb_x],
825 -1, 8 * sizeof(int8_t) * s->mb_x);
828 memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy - s->mb_stride],
829 -1, 8 * sizeof(int8_t) * (s->mb_width - s->mb_x));
832 h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride - 1] + 3] = -1;
838 static av_cold int svq3_decode_init(AVCodecContext *avctx)
840 SVQ3Context *svq3 = avctx->priv_data;
841 H264Context *h = &svq3->h;
842 MpegEncContext *s = &h->s;
844 unsigned char *extradata;
845 unsigned char *extradata_end;
847 int marker_found = 0;
849 if (ff_h264_decode_init(avctx) < 0)
852 s->flags = avctx->flags;
853 s->flags2 = avctx->flags2;
854 s->unrestricted_mv = 1;
856 avctx->pix_fmt = avctx->codec->pix_fmts[0];
858 if (!s->context_initialized) {
859 h->chroma_qp[0] = h->chroma_qp[1] = 4;
861 svq3->halfpel_flag = 1;
862 svq3->thirdpel_flag = 1;
863 svq3->unknown_flag = 0;
865 /* prowl for the "SEQH" marker in the extradata */
866 extradata = (unsigned char *)avctx->extradata;
867 extradata_end = avctx->extradata + avctx->extradata_size;
869 for (m = 0; m + 8 < avctx->extradata_size; m++) {
870 if (!memcmp(extradata, "SEQH", 4)) {
878 /* if a match was found, parse the extra data */
883 size = AV_RB32(&extradata[4]);
884 if (size > extradata_end - extradata - 8)
885 return AVERROR_INVALIDDATA;
886 init_get_bits(&gb, extradata + 8, size * 8);
888 /* 'frame size code' and optional 'width, height' */
889 frame_size_code = get_bits(&gb, 3);
890 switch (frame_size_code) {
920 avctx->width = get_bits(&gb, 12);
921 avctx->height = get_bits(&gb, 12);
925 svq3->halfpel_flag = get_bits1(&gb);
926 svq3->thirdpel_flag = get_bits1(&gb);
934 s->low_delay = get_bits1(&gb);
939 while (get_bits1(&gb))
942 svq3->unknown_flag = get_bits1(&gb);
943 avctx->has_b_frames = !s->low_delay;
944 if (svq3->unknown_flag) {
946 unsigned watermark_width = svq3_get_ue_golomb(&gb);
947 unsigned watermark_height = svq3_get_ue_golomb(&gb);
948 int u1 = svq3_get_ue_golomb(&gb);
949 int u2 = get_bits(&gb, 8);
950 int u3 = get_bits(&gb, 2);
951 int u4 = svq3_get_ue_golomb(&gb);
952 unsigned long buf_len = watermark_width *
953 watermark_height * 4;
954 int offset = get_bits_count(&gb) + 7 >> 3;
957 if ((uint64_t)watermark_width * 4 > UINT_MAX / watermark_height)
960 buf = av_malloc(buf_len);
961 av_log(avctx, AV_LOG_DEBUG, "watermark size: %dx%d\n",
962 watermark_width, watermark_height);
963 av_log(avctx, AV_LOG_DEBUG,
964 "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n",
965 u1, u2, u3, u4, offset);
966 if (uncompress(buf, &buf_len, extradata + 8 + offset,
967 size - offset) != Z_OK) {
968 av_log(avctx, AV_LOG_ERROR,
969 "could not uncompress watermark logo\n");
973 svq3->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
974 svq3->watermark_key = svq3->watermark_key << 16 |
976 av_log(avctx, AV_LOG_DEBUG,
977 "watermark key %#x\n", svq3->watermark_key);
980 av_log(avctx, AV_LOG_ERROR,
981 "this svq3 file contains watermark which need zlib support compiled in\n");
987 s->width = avctx->width;
988 s->height = avctx->height;
990 if (ff_MPV_common_init(s) < 0)
993 h->b_stride = 4 * s->mb_width;
995 if (ff_h264_alloc_tables(h) < 0) {
996 av_log(avctx, AV_LOG_ERROR, "svq3 memory allocation failed\n");
997 return AVERROR(ENOMEM);
1004 static int svq3_decode_frame(AVCodecContext *avctx, void *data,
1005 int *got_frame, AVPacket *avpkt)
1007 const uint8_t *buf = avpkt->data;
1008 SVQ3Context *svq3 = avctx->priv_data;
1009 H264Context *h = &svq3->h;
1010 MpegEncContext *s = &h->s;
1011 int buf_size = avpkt->size;
1014 /* special case for last picture */
1015 if (buf_size == 0) {
1016 if (s->next_picture_ptr && !s->low_delay) {
1017 *(AVFrame *) data = s->next_picture.f;
1018 s->next_picture_ptr = NULL;
1024 init_get_bits(&s->gb, buf, 8 * buf_size);
1026 s->mb_x = s->mb_y = h->mb_xy = 0;
1028 if (svq3_decode_slice_header(avctx))
1031 s->pict_type = h->slice_type;
1032 s->picture_number = h->slice_num;
1034 if (avctx->debug & FF_DEBUG_PICT_INFO)
1035 av_log(h->s.avctx, AV_LOG_DEBUG,
1036 "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
1037 av_get_picture_type_char(s->pict_type),
1038 svq3->halfpel_flag, svq3->thirdpel_flag,
1039 s->adaptive_quant, s->qscale, h->slice_num);
1041 /* for skipping the frame */
1042 s->current_picture.f.pict_type = s->pict_type;
1043 s->current_picture.f.key_frame = (s->pict_type == AV_PICTURE_TYPE_I);
1045 /* Skip B-frames if we do not have reference frames. */
1046 if (s->last_picture_ptr == NULL && s->pict_type == AV_PICTURE_TYPE_B)
1048 if (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B ||
1049 avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I ||
1050 avctx->skip_frame >= AVDISCARD_ALL)
1053 if (s->next_p_frame_damaged) {
1054 if (s->pict_type == AV_PICTURE_TYPE_B)
1057 s->next_p_frame_damaged = 0;
1060 if (ff_h264_frame_start(h) < 0)
1063 if (s->pict_type == AV_PICTURE_TYPE_B) {
1064 h->frame_num_offset = h->slice_num - h->prev_frame_num;
1066 if (h->frame_num_offset < 0)
1067 h->frame_num_offset += 256;
1068 if (h->frame_num_offset == 0 ||
1069 h->frame_num_offset >= h->prev_frame_num_offset) {
1070 av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1074 h->prev_frame_num = h->frame_num;
1075 h->frame_num = h->slice_num;
1076 h->prev_frame_num_offset = h->frame_num - h->prev_frame_num;
1078 if (h->prev_frame_num_offset < 0)
1079 h->prev_frame_num_offset += 256;
1082 for (m = 0; m < 2; m++) {
1084 for (i = 0; i < 4; i++) {
1086 for (j = -1; j < 4; j++)
1087 h->ref_cache[m][scan8[0] + 8 * i + j] = 1;
1089 h->ref_cache[m][scan8[0] + 8 * i + j] = PART_NOT_AVAILABLE;
1093 for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
1094 for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
1096 h->mb_xy = s->mb_x + s->mb_y * s->mb_stride;
1098 if ((get_bits_count(&s->gb) + 7) >= s->gb.size_in_bits &&
1099 ((get_bits_count(&s->gb) & 7) == 0 ||
1100 show_bits(&s->gb, -get_bits_count(&s->gb) & 7) == 0)) {
1101 skip_bits(&s->gb, svq3->next_slice_index - get_bits_count(&s->gb));
1102 s->gb.size_in_bits = 8 * buf_size;
1104 if (svq3_decode_slice_header(avctx))
1107 /* TODO: support s->mb_skip_run */
1110 mb_type = svq3_get_ue_golomb(&s->gb);
1112 if (s->pict_type == AV_PICTURE_TYPE_I)
1114 else if (s->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4)
1116 if (mb_type > 33 || svq3_decode_mb(svq3, mb_type)) {
1117 av_log(h->s.avctx, AV_LOG_ERROR,
1118 "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1123 ff_h264_hl_decode_mb(h);
1125 if (s->pict_type != AV_PICTURE_TYPE_B && !s->low_delay)
1126 s->current_picture.f.mb_type[s->mb_x + s->mb_y * s->mb_stride] =
1127 (s->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1130 ff_draw_horiz_band(s, 16 * s->mb_y, 16);
1133 ff_MPV_frame_end(s);
1135 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay)
1136 *(AVFrame *)data = s->current_picture.f;
1138 *(AVFrame *)data = s->last_picture.f;
1140 /* Do not output the last pic after seeking. */
1141 if (s->last_picture_ptr || s->low_delay)
1147 static int svq3_decode_end(AVCodecContext *avctx)
1149 SVQ3Context *svq3 = avctx->priv_data;
1150 H264Context *h = &svq3->h;
1151 MpegEncContext *s = &h->s;
1153 ff_h264_free_context(h);
1155 ff_MPV_common_end(s);
1160 AVCodec ff_svq3_decoder = {
1162 .type = AVMEDIA_TYPE_VIDEO,
1163 .id = AV_CODEC_ID_SVQ3,
1164 .priv_data_size = sizeof(SVQ3Context),
1165 .init = svq3_decode_init,
1166 .close = svq3_decode_end,
1167 .decode = svq3_decode_frame,
1168 .capabilities = CODEC_CAP_DRAW_HORIZ_BAND |
1171 .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1172 .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P,