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(DCTELEM *output, DCTELEM *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, DCTELEM *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, DCTELEM *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, sign, vlc, limit;
220 const int intra = 3 * type >> 2;
221 const uint8_t *const scan = scan_patterns[type];
223 for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
224 for (; (vlc = svq3_get_ue_golomb(gb)) != 0; index++) {
225 if (vlc == INVALID_VLC)
228 sign = (vlc & 0x1) - 1;
235 } else if (vlc < 4) {
240 level = (vlc + 9 >> 2) - run;
244 run = svq3_dct_tables[intra][vlc].run;
245 level = svq3_dct_tables[intra][vlc].level;
249 ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
253 ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
257 if ((index += run) >= limit)
260 block[scan[index]] = (level ^ sign) - sign;
271 static inline void svq3_mc_dir_part(MpegEncContext *s,
272 int x, int y, int width, int height,
273 int mx, int my, int dxy,
274 int thirdpel, int dir, int avg)
276 const Picture *pic = (dir == 0) ? &s->last_picture : &s->next_picture;
279 int blocksize = 2 - (width >> 3); // 16->0, 8->1, 4->2
284 if (mx < 0 || mx >= s->h_edge_pos - width - 1 ||
285 my < 0 || my >= s->v_edge_pos - height - 1) {
286 if ((s->flags & CODEC_FLAG_EMU_EDGE))
289 mx = av_clip(mx, -16, s->h_edge_pos - width + 15);
290 my = av_clip(my, -16, s->v_edge_pos - height + 15);
293 /* form component predictions */
294 dest = s->current_picture.f.data[0] + x + y * s->linesize;
295 src = pic->f.data[0] + mx + my * s->linesize;
298 s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize,
299 width + 1, height + 1,
300 mx, my, s->h_edge_pos, s->v_edge_pos);
301 src = s->edge_emu_buffer;
304 (avg ? s->dsp.avg_tpel_pixels_tab
305 : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->linesize,
308 (avg ? s->dsp.avg_pixels_tab
309 : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->linesize,
312 if (!(s->flags & CODEC_FLAG_GRAY)) {
313 mx = mx + (mx < (int) x) >> 1;
314 my = my + (my < (int) y) >> 1;
316 height = height >> 1;
319 for (i = 1; i < 3; i++) {
320 dest = s->current_picture.f.data[i] + (x >> 1) + (y >> 1) * s->uvlinesize;
321 src = pic->f.data[i] + mx + my * s->uvlinesize;
324 s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->uvlinesize,
325 width + 1, height + 1,
326 mx, my, (s->h_edge_pos >> 1),
328 src = s->edge_emu_buffer;
331 (avg ? s->dsp.avg_tpel_pixels_tab
332 : s->dsp.put_tpel_pixels_tab)[dxy](dest, src,
336 (avg ? s->dsp.avg_pixels_tab
337 : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src,
344 static inline int svq3_mc_dir(H264Context *h, int size, int mode,
347 int i, j, k, mx, my, dx, dy, x, y;
348 MpegEncContext *const s = (MpegEncContext *)h;
349 const int part_width = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
350 const int part_height = 16 >> ((unsigned)(size + 1) / 3);
351 const int extra_width = (mode == PREDICT_MODE) ? -16 * 6 : 0;
352 const int h_edge_pos = 6 * (s->h_edge_pos - part_width) - extra_width;
353 const int v_edge_pos = 6 * (s->v_edge_pos - part_height) - extra_width;
355 for (i = 0; i < 16; i += part_height)
356 for (j = 0; j < 16; j += part_width) {
357 const int b_xy = (4 * s->mb_x + (j >> 2)) +
358 (4 * s->mb_y + (i >> 2)) * h->b_stride;
360 x = 16 * s->mb_x + j;
361 y = 16 * s->mb_y + i;
362 k = (j >> 2 & 1) + (i >> 1 & 2) +
363 (j >> 1 & 4) + (i & 8);
365 if (mode != PREDICT_MODE) {
366 pred_motion(h, k, part_width >> 2, dir, 1, &mx, &my);
368 mx = s->next_picture.f.motion_val[0][b_xy][0] << 1;
369 my = s->next_picture.f.motion_val[0][b_xy][1] << 1;
372 mx = mx * h->frame_num_offset /
373 h->prev_frame_num_offset + 1 >> 1;
374 my = my * h->frame_num_offset /
375 h->prev_frame_num_offset + 1 >> 1;
377 mx = mx * (h->frame_num_offset - h->prev_frame_num_offset) /
378 h->prev_frame_num_offset + 1 >> 1;
379 my = my * (h->frame_num_offset - h->prev_frame_num_offset) /
380 h->prev_frame_num_offset + 1 >> 1;
384 /* clip motion vector prediction to frame border */
385 mx = av_clip(mx, extra_width - 6 * x, h_edge_pos - 6 * x);
386 my = av_clip(my, extra_width - 6 * y, v_edge_pos - 6 * y);
388 /* get (optional) motion vector differential */
389 if (mode == PREDICT_MODE) {
392 dy = svq3_get_se_golomb(&s->gb);
393 dx = svq3_get_se_golomb(&s->gb);
395 if (dx == INVALID_VLC || dy == INVALID_VLC) {
396 av_log(h->s.avctx, AV_LOG_ERROR, "invalid MV vlc\n");
401 /* compute motion vector */
402 if (mode == THIRDPEL_MODE) {
404 mx = (mx + 1 >> 1) + dx;
405 my = (my + 1 >> 1) + dy;
406 fx = (unsigned)(mx + 0x3000) / 3 - 0x1000;
407 fy = (unsigned)(my + 0x3000) / 3 - 0x1000;
408 dxy = (mx - 3 * fx) + 4 * (my - 3 * fy);
410 svq3_mc_dir_part(s, x, y, part_width, part_height,
411 fx, fy, dxy, 1, dir, avg);
414 } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
415 mx = (unsigned)(mx + 1 + 0x3000) / 3 + dx - 0x1000;
416 my = (unsigned)(my + 1 + 0x3000) / 3 + dy - 0x1000;
417 dxy = (mx & 1) + 2 * (my & 1);
419 svq3_mc_dir_part(s, x, y, part_width, part_height,
420 mx >> 1, my >> 1, dxy, 0, dir, avg);
424 mx = (unsigned)(mx + 3 + 0x6000) / 6 + dx - 0x1000;
425 my = (unsigned)(my + 3 + 0x6000) / 6 + dy - 0x1000;
427 svq3_mc_dir_part(s, x, y, part_width, part_height,
428 mx, my, 0, 0, dir, avg);
433 /* update mv_cache */
434 if (mode != PREDICT_MODE) {
435 int32_t mv = pack16to32(mx, my);
437 if (part_height == 8 && i < 8) {
438 AV_WN32A(h->mv_cache[dir][scan8[k] + 1 * 8], mv);
440 if (part_width == 8 && j < 8)
441 AV_WN32A(h->mv_cache[dir][scan8[k] + 1 + 1 * 8], mv);
443 if (part_width == 8 && j < 8)
444 AV_WN32A(h->mv_cache[dir][scan8[k] + 1], mv);
445 if (part_width == 4 || part_height == 4)
446 AV_WN32A(h->mv_cache[dir][scan8[k]], mv);
449 /* write back motion vectors */
450 fill_rectangle(s->current_picture.f.motion_val[dir][b_xy],
451 part_width >> 2, part_height >> 2, h->b_stride,
452 pack16to32(mx, my), 4);
458 static int svq3_decode_mb(SVQ3Context *svq3, unsigned int mb_type)
460 H264Context *h = &svq3->h;
461 int i, j, k, m, dir, mode;
465 MpegEncContext *const s = (MpegEncContext *)h;
466 const int mb_xy = h->mb_xy;
467 const int b_xy = 4 * s->mb_x + 4 * s->mb_y * h->b_stride;
469 h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
470 h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
471 h->topright_samples_available = 0xFFFF;
473 if (mb_type == 0) { /* SKIP */
474 if (s->pict_type == AV_PICTURE_TYPE_P ||
475 s->next_picture.f.mb_type[mb_xy] == -1) {
476 svq3_mc_dir_part(s, 16 * s->mb_x, 16 * s->mb_y, 16, 16,
479 if (s->pict_type == AV_PICTURE_TYPE_B)
480 svq3_mc_dir_part(s, 16 * s->mb_x, 16 * s->mb_y, 16, 16,
483 mb_type = MB_TYPE_SKIP;
485 mb_type = FFMIN(s->next_picture.f.mb_type[mb_xy], 6);
486 if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 0, 0) < 0)
488 if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 1, 1) < 0)
491 mb_type = MB_TYPE_16x16;
493 } else if (mb_type < 8) { /* INTER */
494 if (svq3->thirdpel_flag && svq3->halfpel_flag == !get_bits1(&s->gb))
495 mode = THIRDPEL_MODE;
496 else if (svq3->halfpel_flag &&
497 svq3->thirdpel_flag == !get_bits1(&s->gb))
503 /* note ref_cache should contain here:
511 for (m = 0; m < 2; m++) {
512 if (s->mb_x > 0 && h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1] + 6] != -1) {
513 for (i = 0; i < 4; i++)
514 AV_COPY32(h->mv_cache[m][scan8[0] - 1 + i * 8],
515 s->current_picture.f.motion_val[m][b_xy - 1 + i * h->b_stride]);
517 for (i = 0; i < 4; i++)
518 AV_ZERO32(h->mv_cache[m][scan8[0] - 1 + i * 8]);
521 memcpy(h->mv_cache[m][scan8[0] - 1 * 8],
522 s->current_picture.f.motion_val[m][b_xy - h->b_stride],
523 4 * 2 * sizeof(int16_t));
524 memset(&h->ref_cache[m][scan8[0] - 1 * 8],
525 (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1, 4);
527 if (s->mb_x < s->mb_width - 1) {
528 AV_COPY32(h->mv_cache[m][scan8[0] + 4 - 1 * 8],
529 s->current_picture.f.motion_val[m][b_xy - h->b_stride + 4]);
530 h->ref_cache[m][scan8[0] + 4 - 1 * 8] =
531 (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride + 1] + 6] == -1 ||
532 h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1;
534 h->ref_cache[m][scan8[0] + 4 - 1 * 8] = PART_NOT_AVAILABLE;
536 AV_COPY32(h->mv_cache[m][scan8[0] - 1 - 1 * 8],
537 s->current_picture.f.motion_val[m][b_xy - h->b_stride - 1]);
538 h->ref_cache[m][scan8[0] - 1 - 1 * 8] =
539 (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride - 1] + 3] == -1) ? PART_NOT_AVAILABLE : 1;
541 h->ref_cache[m][scan8[0] - 1 - 1 * 8] = PART_NOT_AVAILABLE;
543 memset(&h->ref_cache[m][scan8[0] - 1 * 8 - 1],
544 PART_NOT_AVAILABLE, 8);
546 if (s->pict_type != AV_PICTURE_TYPE_B)
550 /* decode motion vector(s) and form prediction(s) */
551 if (s->pict_type == AV_PICTURE_TYPE_P) {
552 if (svq3_mc_dir(h, mb_type - 1, mode, 0, 0) < 0)
554 } else { /* AV_PICTURE_TYPE_B */
556 if (svq3_mc_dir(h, 0, mode, 0, 0) < 0)
559 for (i = 0; i < 4; i++)
560 memset(s->current_picture.f.motion_val[0][b_xy + i * h->b_stride],
561 0, 4 * 2 * sizeof(int16_t));
563 if (svq3_mc_dir(h, 0, mode, 1, mb_type == 3) < 0)
566 for (i = 0; i < 4; i++)
567 memset(s->current_picture.f.motion_val[1][b_xy + i * h->b_stride],
568 0, 4 * 2 * sizeof(int16_t));
571 mb_type = MB_TYPE_16x16;
572 } else if (mb_type == 8 || mb_type == 33) { /* INTRA4x4 */
573 memset(h->intra4x4_pred_mode_cache, -1, 8 * 5 * sizeof(int8_t));
577 for (i = 0; i < 4; i++)
578 h->intra4x4_pred_mode_cache[scan8[0] - 1 + i * 8] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1] + 6 - i];
579 if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1)
580 h->left_samples_available = 0x5F5F;
583 h->intra4x4_pred_mode_cache[4 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride] + 0];
584 h->intra4x4_pred_mode_cache[5 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride] + 1];
585 h->intra4x4_pred_mode_cache[6 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride] + 2];
586 h->intra4x4_pred_mode_cache[7 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride] + 3];
588 if (h->intra4x4_pred_mode_cache[4 + 8 * 0] == -1)
589 h->top_samples_available = 0x33FF;
592 /* decode prediction codes for luma blocks */
593 for (i = 0; i < 16; i += 2) {
594 vlc = svq3_get_ue_golomb(&s->gb);
597 av_log(h->s.avctx, AV_LOG_ERROR, "luma prediction:%d\n", vlc);
601 left = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
602 top = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
604 left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
605 left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
607 if (left[1] == -1 || left[2] == -1) {
608 av_log(h->s.avctx, AV_LOG_ERROR, "weird prediction\n");
612 } else { /* mb_type == 33, DC_128_PRED block type */
613 for (i = 0; i < 4; i++)
614 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_PRED, 4);
617 write_back_intra_pred_mode(h);
620 ff_h264_check_intra4x4_pred_mode(h);
622 h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
623 h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
625 for (i = 0; i < 4; i++)
626 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_128_PRED, 4);
628 h->top_samples_available = 0x33FF;
629 h->left_samples_available = 0x5F5F;
632 mb_type = MB_TYPE_INTRA4x4;
633 } else { /* INTRA16x16 */
634 dir = i_mb_type_info[mb_type - 8].pred_mode;
635 dir = (dir >> 1) ^ 3 * (dir & 1) ^ 1;
637 if ((h->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, dir, 0)) == -1) {
638 av_log(h->s.avctx, AV_LOG_ERROR, "check_intra_pred_mode = -1\n");
642 cbp = i_mb_type_info[mb_type - 8].cbp;
643 mb_type = MB_TYPE_INTRA16x16;
646 if (!IS_INTER(mb_type) && s->pict_type != AV_PICTURE_TYPE_I) {
647 for (i = 0; i < 4; i++)
648 memset(s->current_picture.f.motion_val[0][b_xy + i * h->b_stride],
649 0, 4 * 2 * sizeof(int16_t));
650 if (s->pict_type == AV_PICTURE_TYPE_B) {
651 for (i = 0; i < 4; i++)
652 memset(s->current_picture.f.motion_val[1][b_xy + i * h->b_stride],
653 0, 4 * 2 * sizeof(int16_t));
656 if (!IS_INTRA4x4(mb_type)) {
657 memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy], DC_PRED, 8);
659 if (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B) {
660 memset(h->non_zero_count_cache + 8, 0, 14 * 8 * sizeof(uint8_t));
661 s->dsp.clear_blocks(h->mb + 0);
662 s->dsp.clear_blocks(h->mb + 384);
665 if (!IS_INTRA16x16(mb_type) &&
666 (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B)) {
667 if ((vlc = svq3_get_ue_golomb(&s->gb)) >= 48) {
668 av_log(h->s.avctx, AV_LOG_ERROR, "cbp_vlc=%d\n", vlc);
672 cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc]
673 : golomb_to_inter_cbp[vlc];
675 if (IS_INTRA16x16(mb_type) ||
676 (s->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
677 s->qscale += svq3_get_se_golomb(&s->gb);
679 if (s->qscale > 31u) {
680 av_log(h->s.avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
684 if (IS_INTRA16x16(mb_type)) {
685 AV_ZERO128(h->mb_luma_dc[0] + 0);
686 AV_ZERO128(h->mb_luma_dc[0] + 8);
687 if (svq3_decode_block(&s->gb, h->mb_luma_dc[0], 0, 1)) {
688 av_log(h->s.avctx, AV_LOG_ERROR,
689 "error while decoding intra luma dc\n");
695 const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
696 const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
698 for (i = 0; i < 4; i++)
699 if ((cbp & (1 << i))) {
700 for (j = 0; j < 4; j++) {
701 k = index ? (1 * (j & 1) + 2 * (i & 1) +
702 2 * (j & 2) + 4 * (i & 2))
704 h->non_zero_count_cache[scan8[k]] = 1;
706 if (svq3_decode_block(&s->gb, &h->mb[16 * k], index, type)) {
707 av_log(h->s.avctx, AV_LOG_ERROR,
708 "error while decoding block\n");
715 for (i = 1; i < 3; ++i)
716 if (svq3_decode_block(&s->gb, &h->mb[16 * 16 * i], 0, 3)) {
717 av_log(h->s.avctx, AV_LOG_ERROR,
718 "error while decoding chroma dc block\n");
723 for (i = 1; i < 3; i++) {
724 for (j = 0; j < 4; j++) {
726 h->non_zero_count_cache[scan8[k]] = 1;
728 if (svq3_decode_block(&s->gb, &h->mb[16 * k], 1, 1)) {
729 av_log(h->s.avctx, AV_LOG_ERROR,
730 "error while decoding chroma ac block\n");
740 s->current_picture.f.mb_type[mb_xy] = mb_type;
742 if (IS_INTRA(mb_type))
743 h->chroma_pred_mode = ff_h264_check_intra_pred_mode(h, DC_PRED8x8, 1);
748 static int svq3_decode_slice_header(AVCodecContext *avctx)
750 SVQ3Context *svq3 = avctx->priv_data;
751 H264Context *h = &svq3->h;
752 MpegEncContext *s = &h->s;
753 const int mb_xy = h->mb_xy;
756 header = get_bits(&s->gb, 8);
758 if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
760 av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
763 int length = header >> 5 & 3;
765 svq3->next_slice_index = get_bits_count(&s->gb) +
766 8 * show_bits(&s->gb, 8 * length) +
769 if (svq3->next_slice_index > s->gb.size_in_bits) {
770 av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
774 s->gb.size_in_bits = svq3->next_slice_index - 8 * (length - 1);
775 skip_bits(&s->gb, 8);
777 if (svq3->watermark_key) {
778 uint32_t header = AV_RL32(&s->gb.buffer[(get_bits_count(&s->gb) >> 3) + 1]);
779 AV_WL32(&s->gb.buffer[(get_bits_count(&s->gb) >> 3) + 1],
780 header ^ svq3->watermark_key);
783 memcpy((uint8_t *) &s->gb.buffer[get_bits_count(&s->gb) >> 3],
784 &s->gb.buffer[s->gb.size_in_bits >> 3], length - 1);
786 skip_bits_long(&s->gb, 0);
789 if ((i = svq3_get_ue_golomb(&s->gb)) == INVALID_VLC || i >= 3) {
790 av_log(h->s.avctx, AV_LOG_ERROR, "illegal slice type %d \n", i);
794 h->slice_type = golomb_to_pict_type[i];
796 if ((header & 0x9F) == 2) {
797 i = (s->mb_num < 64) ? 6 : (1 + av_log2(s->mb_num - 1));
798 s->mb_skip_run = get_bits(&s->gb, i) -
799 (s->mb_y * s->mb_width + s->mb_x);
805 h->slice_num = get_bits(&s->gb, 8);
806 s->qscale = get_bits(&s->gb, 5);
807 s->adaptive_quant = get_bits1(&s->gb);
812 if (svq3->unknown_flag)
816 skip_bits(&s->gb, 2);
818 while (get_bits1(&s->gb))
819 skip_bits(&s->gb, 8);
821 /* reset intra predictors and invalidate motion vector references */
823 memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy - 1] + 3,
824 -1, 4 * sizeof(int8_t));
825 memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy - s->mb_x],
826 -1, 8 * sizeof(int8_t) * s->mb_x);
829 memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy - s->mb_stride],
830 -1, 8 * sizeof(int8_t) * (s->mb_width - s->mb_x));
833 h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride - 1] + 3] = -1;
839 static av_cold int svq3_decode_init(AVCodecContext *avctx)
841 SVQ3Context *svq3 = avctx->priv_data;
842 H264Context *h = &svq3->h;
843 MpegEncContext *s = &h->s;
845 unsigned char *extradata;
846 unsigned char *extradata_end;
848 int marker_found = 0;
850 if (ff_h264_decode_init(avctx) < 0)
853 s->flags = avctx->flags;
854 s->flags2 = avctx->flags2;
855 s->unrestricted_mv = 1;
857 avctx->pix_fmt = avctx->codec->pix_fmts[0];
859 if (!s->context_initialized) {
860 h->chroma_qp[0] = h->chroma_qp[1] = 4;
862 svq3->halfpel_flag = 1;
863 svq3->thirdpel_flag = 1;
864 svq3->unknown_flag = 0;
866 /* prowl for the "SEQH" marker in the extradata */
867 extradata = (unsigned char *)avctx->extradata;
868 extradata_end = avctx->extradata + avctx->extradata_size;
870 for (m = 0; m + 8 < avctx->extradata_size; m++) {
871 if (!memcmp(extradata, "SEQH", 4)) {
879 /* if a match was found, parse the extra data */
884 size = AV_RB32(&extradata[4]);
885 if (size > extradata_end - extradata - 8)
886 return AVERROR_INVALIDDATA;
887 init_get_bits(&gb, extradata + 8, size * 8);
889 /* 'frame size code' and optional 'width, height' */
890 frame_size_code = get_bits(&gb, 3);
891 switch (frame_size_code) {
921 avctx->width = get_bits(&gb, 12);
922 avctx->height = get_bits(&gb, 12);
926 svq3->halfpel_flag = get_bits1(&gb);
927 svq3->thirdpel_flag = get_bits1(&gb);
935 s->low_delay = get_bits1(&gb);
940 while (get_bits1(&gb))
943 svq3->unknown_flag = get_bits1(&gb);
944 avctx->has_b_frames = !s->low_delay;
945 if (svq3->unknown_flag) {
947 unsigned watermark_width = svq3_get_ue_golomb(&gb);
948 unsigned watermark_height = svq3_get_ue_golomb(&gb);
949 int u1 = svq3_get_ue_golomb(&gb);
950 int u2 = get_bits(&gb, 8);
951 int u3 = get_bits(&gb, 2);
952 int u4 = svq3_get_ue_golomb(&gb);
953 unsigned long buf_len = watermark_width *
954 watermark_height * 4;
955 int offset = get_bits_count(&gb) + 7 >> 3;
958 if ((uint64_t)watermark_width * 4 > UINT_MAX / watermark_height)
961 buf = av_malloc(buf_len);
962 av_log(avctx, AV_LOG_DEBUG, "watermark size: %dx%d\n",
963 watermark_width, watermark_height);
964 av_log(avctx, AV_LOG_DEBUG,
965 "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n",
966 u1, u2, u3, u4, offset);
967 if (uncompress(buf, &buf_len, extradata + 8 + offset,
968 size - offset) != Z_OK) {
969 av_log(avctx, AV_LOG_ERROR,
970 "could not uncompress watermark logo\n");
974 svq3->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
975 svq3->watermark_key = svq3->watermark_key << 16 |
977 av_log(avctx, AV_LOG_DEBUG,
978 "watermark key %#x\n", svq3->watermark_key);
981 av_log(avctx, AV_LOG_ERROR,
982 "this svq3 file contains watermark which need zlib support compiled in\n");
988 s->width = avctx->width;
989 s->height = avctx->height;
991 if (ff_MPV_common_init(s) < 0)
994 h->b_stride = 4 * s->mb_width;
996 if (ff_h264_alloc_tables(h) < 0) {
997 av_log(avctx, AV_LOG_ERROR, "svq3 memory allocation failed\n");
998 return AVERROR(ENOMEM);
1005 static int svq3_decode_frame(AVCodecContext *avctx, void *data,
1006 int *got_frame, AVPacket *avpkt)
1008 const uint8_t *buf = avpkt->data;
1009 SVQ3Context *svq3 = avctx->priv_data;
1010 H264Context *h = &svq3->h;
1011 MpegEncContext *s = &h->s;
1012 int buf_size = avpkt->size;
1015 /* special case for last picture */
1016 if (buf_size == 0) {
1017 if (s->next_picture_ptr && !s->low_delay) {
1018 *(AVFrame *) data = s->next_picture.f;
1019 s->next_picture_ptr = NULL;
1025 init_get_bits(&s->gb, buf, 8 * buf_size);
1027 s->mb_x = s->mb_y = h->mb_xy = 0;
1029 if (svq3_decode_slice_header(avctx))
1032 s->pict_type = h->slice_type;
1033 s->picture_number = h->slice_num;
1035 if (avctx->debug & FF_DEBUG_PICT_INFO)
1036 av_log(h->s.avctx, AV_LOG_DEBUG,
1037 "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
1038 av_get_picture_type_char(s->pict_type),
1039 svq3->halfpel_flag, svq3->thirdpel_flag,
1040 s->adaptive_quant, s->qscale, h->slice_num);
1042 /* for skipping the frame */
1043 s->current_picture.f.pict_type = s->pict_type;
1044 s->current_picture.f.key_frame = (s->pict_type == AV_PICTURE_TYPE_I);
1046 /* Skip B-frames if we do not have reference frames. */
1047 if (s->last_picture_ptr == NULL && s->pict_type == AV_PICTURE_TYPE_B)
1049 if (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B ||
1050 avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I ||
1051 avctx->skip_frame >= AVDISCARD_ALL)
1054 if (s->next_p_frame_damaged) {
1055 if (s->pict_type == AV_PICTURE_TYPE_B)
1058 s->next_p_frame_damaged = 0;
1061 if (ff_h264_frame_start(h) < 0)
1064 if (s->pict_type == AV_PICTURE_TYPE_B) {
1065 h->frame_num_offset = h->slice_num - h->prev_frame_num;
1067 if (h->frame_num_offset < 0)
1068 h->frame_num_offset += 256;
1069 if (h->frame_num_offset == 0 ||
1070 h->frame_num_offset >= h->prev_frame_num_offset) {
1071 av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1075 h->prev_frame_num = h->frame_num;
1076 h->frame_num = h->slice_num;
1077 h->prev_frame_num_offset = h->frame_num - h->prev_frame_num;
1079 if (h->prev_frame_num_offset < 0)
1080 h->prev_frame_num_offset += 256;
1083 for (m = 0; m < 2; m++) {
1085 for (i = 0; i < 4; i++) {
1087 for (j = -1; j < 4; j++)
1088 h->ref_cache[m][scan8[0] + 8 * i + j] = 1;
1090 h->ref_cache[m][scan8[0] + 8 * i + j] = PART_NOT_AVAILABLE;
1094 for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
1095 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 ((unsigned)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,