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 "mpegvideo.h"
48 #include "h264data.h" // FIXME FIXME FIXME
50 #include "h264_mvpred.h"
52 #include "rectangle.h"
53 #include "vdpau_internal.h"
73 uint32_t watermark_key;
78 #define FULLPEL_MODE 1
79 #define HALFPEL_MODE 2
80 #define THIRDPEL_MODE 3
81 #define PREDICT_MODE 4
83 /* dual scan (from some older h264 draft)
92 static const uint8_t svq3_scan[16] = {
93 0 + 0 * 4, 1 + 0 * 4, 2 + 0 * 4, 2 + 1 * 4,
94 2 + 2 * 4, 3 + 0 * 4, 3 + 1 * 4, 3 + 2 * 4,
95 0 + 1 * 4, 0 + 2 * 4, 1 + 1 * 4, 1 + 2 * 4,
96 0 + 3 * 4, 1 + 3 * 4, 2 + 3 * 4, 3 + 3 * 4,
99 static const uint8_t svq3_pred_0[25][2] = {
102 { 0, 2 }, { 1, 1 }, { 2, 0 },
103 { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
104 { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
105 { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
106 { 2, 4 }, { 3, 3 }, { 4, 2 },
111 static const int8_t svq3_pred_1[6][6][5] = {
112 { { 2, -1, -1, -1, -1 }, { 2, 1, -1, -1, -1 }, { 1, 2, -1, -1, -1 },
113 { 2, 1, -1, -1, -1 }, { 1, 2, -1, -1, -1 }, { 1, 2, -1, -1, -1 } },
114 { { 0, 2, -1, -1, -1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
115 { 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
116 { { 2, 0, -1, -1, -1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
117 { 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
118 { { 2, 0, -1, -1, -1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
119 { 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
120 { { 0, 2, -1, -1, -1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
121 { 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
122 { { 0, 2, -1, -1, -1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
123 { 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
126 static const struct {
129 } svq3_dct_tables[2][16] = {
130 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
131 { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
132 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
133 { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
136 static const uint32_t svq3_dequant_coeff[32] = {
137 3881, 4351, 4890, 5481, 6154, 6914, 7761, 8718,
138 9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
139 24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
140 61694, 68745, 77615, 89113, 100253, 109366, 126635, 141533
143 void ff_svq3_luma_dc_dequant_idct_c(int16_t *output, int16_t *input, int qp)
145 const int qmul = svq3_dequant_coeff[qp];
149 static const uint8_t x_offset[4] = { 0, 1 * stride, 4 * stride, 5 * stride };
151 for (i = 0; i < 4; i++) {
152 const int z0 = 13 * (input[4 * i + 0] + input[4 * i + 2]);
153 const int z1 = 13 * (input[4 * i + 0] - input[4 * i + 2]);
154 const int z2 = 7 * input[4 * i + 1] - 17 * input[4 * i + 3];
155 const int z3 = 17 * input[4 * i + 1] + 7 * input[4 * i + 3];
157 temp[4 * i + 0] = z0 + z3;
158 temp[4 * i + 1] = z1 + z2;
159 temp[4 * i + 2] = z1 - z2;
160 temp[4 * i + 3] = z0 - z3;
163 for (i = 0; i < 4; i++) {
164 const int offset = x_offset[i];
165 const int z0 = 13 * (temp[4 * 0 + i] + temp[4 * 2 + i]);
166 const int z1 = 13 * (temp[4 * 0 + i] - temp[4 * 2 + i]);
167 const int z2 = 7 * temp[4 * 1 + i] - 17 * temp[4 * 3 + i];
168 const int z3 = 17 * temp[4 * 1 + i] + 7 * temp[4 * 3 + i];
170 output[stride * 0 + offset] = (z0 + z3) * qmul + 0x80000 >> 20;
171 output[stride * 2 + offset] = (z1 + z2) * qmul + 0x80000 >> 20;
172 output[stride * 8 + offset] = (z1 - z2) * qmul + 0x80000 >> 20;
173 output[stride * 10 + offset] = (z0 - z3) * qmul + 0x80000 >> 20;
178 void ff_svq3_add_idct_c(uint8_t *dst, int16_t *block,
179 int stride, int qp, int dc)
181 const int qmul = svq3_dequant_coeff[qp];
185 dc = 13 * 13 * (dc == 1 ? 1538 * block[0]
186 : qmul * (block[0] >> 3) / 2);
190 for (i = 0; i < 4; i++) {
191 const int z0 = 13 * (block[0 + 4 * i] + block[2 + 4 * i]);
192 const int z1 = 13 * (block[0 + 4 * i] - block[2 + 4 * i]);
193 const int z2 = 7 * block[1 + 4 * i] - 17 * block[3 + 4 * i];
194 const int z3 = 17 * block[1 + 4 * i] + 7 * block[3 + 4 * i];
196 block[0 + 4 * i] = z0 + z3;
197 block[1 + 4 * i] = z1 + z2;
198 block[2 + 4 * i] = z1 - z2;
199 block[3 + 4 * i] = z0 - z3;
202 for (i = 0; i < 4; i++) {
203 const int z0 = 13 * (block[i + 4 * 0] + block[i + 4 * 2]);
204 const int z1 = 13 * (block[i + 4 * 0] - block[i + 4 * 2]);
205 const int z2 = 7 * block[i + 4 * 1] - 17 * block[i + 4 * 3];
206 const int z3 = 17 * block[i + 4 * 1] + 7 * block[i + 4 * 3];
207 const int rr = (dc + 0x80000);
209 dst[i + stride * 0] = av_clip_uint8(dst[i + stride * 0] + ((z0 + z3) * qmul + rr >> 20));
210 dst[i + stride * 1] = av_clip_uint8(dst[i + stride * 1] + ((z1 + z2) * qmul + rr >> 20));
211 dst[i + stride * 2] = av_clip_uint8(dst[i + stride * 2] + ((z1 - z2) * qmul + rr >> 20));
212 dst[i + stride * 3] = av_clip_uint8(dst[i + stride * 3] + ((z0 - z3) * qmul + rr >> 20));
216 static inline int svq3_decode_block(GetBitContext *gb, int16_t *block,
217 int index, const int type)
219 static const uint8_t *const scan_patterns[4] =
220 { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
222 int run, level, sign, limit;
224 const int intra = 3 * type >> 2;
225 const uint8_t *const scan = scan_patterns[type];
227 for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
228 for (; (vlc = svq3_get_ue_golomb(gb)) != 0; index++) {
229 if ((int32_t)vlc < 0)
232 sign = (vlc & 1) ? 0 : -1;
239 } else if (vlc < 4) {
244 level = (vlc + 9 >> 2) - run;
248 run = svq3_dct_tables[intra][vlc].run;
249 level = svq3_dct_tables[intra][vlc].level;
252 level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
255 level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
260 if ((index += run) >= limit)
263 block[scan[index]] = (level ^ sign) - sign;
274 static inline void svq3_mc_dir_part(MpegEncContext *s,
275 int x, int y, int width, int height,
276 int mx, int my, int dxy,
277 int thirdpel, int dir, int avg)
279 const Picture *pic = (dir == 0) ? &s->last_picture : &s->next_picture;
282 int blocksize = 2 - (width >> 3); // 16->0, 8->1, 4->2
287 if (mx < 0 || mx >= s->h_edge_pos - width - 1 ||
288 my < 0 || my >= s->v_edge_pos - height - 1) {
289 if ((s->flags & CODEC_FLAG_EMU_EDGE))
292 mx = av_clip(mx, -16, s->h_edge_pos - width + 15);
293 my = av_clip(my, -16, s->v_edge_pos - height + 15);
296 /* form component predictions */
297 dest = s->current_picture.f.data[0] + x + y * s->linesize;
298 src = pic->f.data[0] + mx + my * s->linesize;
301 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize,
302 width + 1, height + 1,
303 mx, my, s->h_edge_pos, s->v_edge_pos);
304 src = s->edge_emu_buffer;
307 (avg ? s->dsp.avg_tpel_pixels_tab
308 : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->linesize,
311 (avg ? s->dsp.avg_pixels_tab
312 : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->linesize,
315 if (!(s->flags & CODEC_FLAG_GRAY)) {
316 mx = mx + (mx < (int) x) >> 1;
317 my = my + (my < (int) y) >> 1;
319 height = height >> 1;
322 for (i = 1; i < 3; i++) {
323 dest = s->current_picture.f.data[i] + (x >> 1) + (y >> 1) * s->uvlinesize;
324 src = pic->f.data[i] + mx + my * s->uvlinesize;
327 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src, s->uvlinesize,
328 width + 1, height + 1,
329 mx, my, (s->h_edge_pos >> 1),
331 src = s->edge_emu_buffer;
334 (avg ? s->dsp.avg_tpel_pixels_tab
335 : s->dsp.put_tpel_pixels_tab)[dxy](dest, src,
339 (avg ? s->dsp.avg_pixels_tab
340 : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src,
347 static inline int svq3_mc_dir(H264Context *h, int size, int mode,
350 int i, j, k, mx, my, dx, dy, x, y;
351 MpegEncContext *const s = (MpegEncContext *)h;
352 const int part_width = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
353 const int part_height = 16 >> ((unsigned)(size + 1) / 3);
354 const int extra_width = (mode == PREDICT_MODE) ? -16 * 6 : 0;
355 const int h_edge_pos = 6 * (s->h_edge_pos - part_width) - extra_width;
356 const int v_edge_pos = 6 * (s->v_edge_pos - part_height) - extra_width;
358 for (i = 0; i < 16; i += part_height)
359 for (j = 0; j < 16; j += part_width) {
360 const int b_xy = (4 * s->mb_x + (j >> 2)) +
361 (4 * s->mb_y + (i >> 2)) * h->b_stride;
363 x = 16 * s->mb_x + j;
364 y = 16 * s->mb_y + i;
365 k = (j >> 2 & 1) + (i >> 1 & 2) +
366 (j >> 1 & 4) + (i & 8);
368 if (mode != PREDICT_MODE) {
369 pred_motion(h, k, part_width >> 2, dir, 1, &mx, &my);
371 mx = s->next_picture.f.motion_val[0][b_xy][0] << 1;
372 my = s->next_picture.f.motion_val[0][b_xy][1] << 1;
375 mx = mx * h->frame_num_offset /
376 h->prev_frame_num_offset + 1 >> 1;
377 my = my * h->frame_num_offset /
378 h->prev_frame_num_offset + 1 >> 1;
380 mx = mx * (h->frame_num_offset - h->prev_frame_num_offset) /
381 h->prev_frame_num_offset + 1 >> 1;
382 my = my * (h->frame_num_offset - h->prev_frame_num_offset) /
383 h->prev_frame_num_offset + 1 >> 1;
387 /* clip motion vector prediction to frame border */
388 mx = av_clip(mx, extra_width - 6 * x, h_edge_pos - 6 * x);
389 my = av_clip(my, extra_width - 6 * y, v_edge_pos - 6 * y);
391 /* get (optional) motion vector differential */
392 if (mode == PREDICT_MODE) {
395 dy = svq3_get_se_golomb(&s->gb);
396 dx = svq3_get_se_golomb(&s->gb);
398 if (dx == INVALID_VLC || dy == INVALID_VLC) {
399 av_log(h->s.avctx, AV_LOG_ERROR, "invalid MV vlc\n");
404 /* compute motion vector */
405 if (mode == THIRDPEL_MODE) {
407 mx = (mx + 1 >> 1) + dx;
408 my = (my + 1 >> 1) + dy;
409 fx = (unsigned)(mx + 0x3000) / 3 - 0x1000;
410 fy = (unsigned)(my + 0x3000) / 3 - 0x1000;
411 dxy = (mx - 3 * fx) + 4 * (my - 3 * fy);
413 svq3_mc_dir_part(s, x, y, part_width, part_height,
414 fx, fy, dxy, 1, dir, avg);
417 } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
418 mx = (unsigned)(mx + 1 + 0x3000) / 3 + dx - 0x1000;
419 my = (unsigned)(my + 1 + 0x3000) / 3 + dy - 0x1000;
420 dxy = (mx & 1) + 2 * (my & 1);
422 svq3_mc_dir_part(s, x, y, part_width, part_height,
423 mx >> 1, my >> 1, dxy, 0, dir, avg);
427 mx = (unsigned)(mx + 3 + 0x6000) / 6 + dx - 0x1000;
428 my = (unsigned)(my + 3 + 0x6000) / 6 + dy - 0x1000;
430 svq3_mc_dir_part(s, x, y, part_width, part_height,
431 mx, my, 0, 0, dir, avg);
436 /* update mv_cache */
437 if (mode != PREDICT_MODE) {
438 int32_t mv = pack16to32(mx, my);
440 if (part_height == 8 && i < 8) {
441 AV_WN32A(h->mv_cache[dir][scan8[k] + 1 * 8], mv);
443 if (part_width == 8 && j < 8)
444 AV_WN32A(h->mv_cache[dir][scan8[k] + 1 + 1 * 8], mv);
446 if (part_width == 8 && j < 8)
447 AV_WN32A(h->mv_cache[dir][scan8[k] + 1], mv);
448 if (part_width == 4 || part_height == 4)
449 AV_WN32A(h->mv_cache[dir][scan8[k]], mv);
452 /* write back motion vectors */
453 fill_rectangle(s->current_picture.f.motion_val[dir][b_xy],
454 part_width >> 2, part_height >> 2, h->b_stride,
455 pack16to32(mx, my), 4);
461 static int svq3_decode_mb(SVQ3Context *svq3, unsigned int mb_type)
463 H264Context *h = &svq3->h;
464 int i, j, k, m, dir, mode;
468 MpegEncContext *const s = (MpegEncContext *)h;
469 const int mb_xy = h->mb_xy;
470 const int b_xy = 4 * s->mb_x + 4 * s->mb_y * h->b_stride;
472 h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
473 h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
474 h->topright_samples_available = 0xFFFF;
476 if (mb_type == 0) { /* SKIP */
477 if (s->pict_type == AV_PICTURE_TYPE_P ||
478 s->next_picture.f.mb_type[mb_xy] == -1) {
479 svq3_mc_dir_part(s, 16 * s->mb_x, 16 * s->mb_y, 16, 16,
482 if (s->pict_type == AV_PICTURE_TYPE_B)
483 svq3_mc_dir_part(s, 16 * s->mb_x, 16 * s->mb_y, 16, 16,
486 mb_type = MB_TYPE_SKIP;
488 mb_type = FFMIN(s->next_picture.f.mb_type[mb_xy], 6);
489 if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 0, 0) < 0)
491 if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 1, 1) < 0)
494 mb_type = MB_TYPE_16x16;
496 } else if (mb_type < 8) { /* INTER */
497 if (svq3->thirdpel_flag && svq3->halfpel_flag == !get_bits1(&s->gb))
498 mode = THIRDPEL_MODE;
499 else if (svq3->halfpel_flag &&
500 svq3->thirdpel_flag == !get_bits1(&s->gb))
506 /* note ref_cache should contain here:
514 for (m = 0; m < 2; m++) {
515 if (s->mb_x > 0 && h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1] + 6] != -1) {
516 for (i = 0; i < 4; i++)
517 AV_COPY32(h->mv_cache[m][scan8[0] - 1 + i * 8],
518 s->current_picture.f.motion_val[m][b_xy - 1 + i * h->b_stride]);
520 for (i = 0; i < 4; i++)
521 AV_ZERO32(h->mv_cache[m][scan8[0] - 1 + i * 8]);
524 memcpy(h->mv_cache[m][scan8[0] - 1 * 8],
525 s->current_picture.f.motion_val[m][b_xy - h->b_stride],
526 4 * 2 * sizeof(int16_t));
527 memset(&h->ref_cache[m][scan8[0] - 1 * 8],
528 (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1, 4);
530 if (s->mb_x < s->mb_width - 1) {
531 AV_COPY32(h->mv_cache[m][scan8[0] + 4 - 1 * 8],
532 s->current_picture.f.motion_val[m][b_xy - h->b_stride + 4]);
533 h->ref_cache[m][scan8[0] + 4 - 1 * 8] =
534 (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride + 1] + 6] == -1 ||
535 h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1;
537 h->ref_cache[m][scan8[0] + 4 - 1 * 8] = PART_NOT_AVAILABLE;
539 AV_COPY32(h->mv_cache[m][scan8[0] - 1 - 1 * 8],
540 s->current_picture.f.motion_val[m][b_xy - h->b_stride - 1]);
541 h->ref_cache[m][scan8[0] - 1 - 1 * 8] =
542 (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride - 1] + 3] == -1) ? PART_NOT_AVAILABLE : 1;
544 h->ref_cache[m][scan8[0] - 1 - 1 * 8] = PART_NOT_AVAILABLE;
546 memset(&h->ref_cache[m][scan8[0] - 1 * 8 - 1],
547 PART_NOT_AVAILABLE, 8);
549 if (s->pict_type != AV_PICTURE_TYPE_B)
553 /* decode motion vector(s) and form prediction(s) */
554 if (s->pict_type == AV_PICTURE_TYPE_P) {
555 if (svq3_mc_dir(h, mb_type - 1, mode, 0, 0) < 0)
557 } else { /* AV_PICTURE_TYPE_B */
559 if (svq3_mc_dir(h, 0, mode, 0, 0) < 0)
562 for (i = 0; i < 4; i++)
563 memset(s->current_picture.f.motion_val[0][b_xy + i * h->b_stride],
564 0, 4 * 2 * sizeof(int16_t));
567 if (svq3_mc_dir(h, 0, mode, 1, mb_type == 3) < 0)
570 for (i = 0; i < 4; i++)
571 memset(s->current_picture.f.motion_val[1][b_xy + i * h->b_stride],
572 0, 4 * 2 * sizeof(int16_t));
576 mb_type = MB_TYPE_16x16;
577 } else if (mb_type == 8 || mb_type == 33) { /* INTRA4x4 */
578 memset(h->intra4x4_pred_mode_cache, -1, 8 * 5 * sizeof(int8_t));
582 for (i = 0; i < 4; i++)
583 h->intra4x4_pred_mode_cache[scan8[0] - 1 + i * 8] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1] + 6 - i];
584 if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1)
585 h->left_samples_available = 0x5F5F;
588 h->intra4x4_pred_mode_cache[4 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride] + 0];
589 h->intra4x4_pred_mode_cache[5 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride] + 1];
590 h->intra4x4_pred_mode_cache[6 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride] + 2];
591 h->intra4x4_pred_mode_cache[7 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride] + 3];
593 if (h->intra4x4_pred_mode_cache[4 + 8 * 0] == -1)
594 h->top_samples_available = 0x33FF;
597 /* decode prediction codes for luma blocks */
598 for (i = 0; i < 16; i += 2) {
599 vlc = svq3_get_ue_golomb(&s->gb);
602 av_log(h->s.avctx, AV_LOG_ERROR, "luma prediction:%d\n", vlc);
606 left = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
607 top = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
609 left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
610 left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
612 if (left[1] == -1 || left[2] == -1) {
613 av_log(h->s.avctx, AV_LOG_ERROR, "weird prediction\n");
617 } else { /* mb_type == 33, DC_128_PRED block type */
618 for (i = 0; i < 4; i++)
619 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_PRED, 4);
622 write_back_intra_pred_mode(h);
625 ff_h264_check_intra4x4_pred_mode(h);
627 h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
628 h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
630 for (i = 0; i < 4; i++)
631 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_128_PRED, 4);
633 h->top_samples_available = 0x33FF;
634 h->left_samples_available = 0x5F5F;
637 mb_type = MB_TYPE_INTRA4x4;
638 } else { /* INTRA16x16 */
639 dir = i_mb_type_info[mb_type - 8].pred_mode;
640 dir = (dir >> 1) ^ 3 * (dir & 1) ^ 1;
642 if ((h->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, dir, 0)) == -1) {
643 av_log(h->s.avctx, AV_LOG_ERROR, "check_intra_pred_mode = -1\n");
647 cbp = i_mb_type_info[mb_type - 8].cbp;
648 mb_type = MB_TYPE_INTRA16x16;
651 if (!IS_INTER(mb_type) && s->pict_type != AV_PICTURE_TYPE_I) {
652 for (i = 0; i < 4; i++)
653 memset(s->current_picture.f.motion_val[0][b_xy + i * h->b_stride],
654 0, 4 * 2 * sizeof(int16_t));
655 if (s->pict_type == AV_PICTURE_TYPE_B) {
656 for (i = 0; i < 4; i++)
657 memset(s->current_picture.f.motion_val[1][b_xy + i * h->b_stride],
658 0, 4 * 2 * sizeof(int16_t));
661 if (!IS_INTRA4x4(mb_type)) {
662 memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy], DC_PRED, 8);
664 if (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B) {
665 memset(h->non_zero_count_cache + 8, 0, 14 * 8 * sizeof(uint8_t));
666 s->dsp.clear_blocks(h->mb + 0);
667 s->dsp.clear_blocks(h->mb + 384);
670 if (!IS_INTRA16x16(mb_type) &&
671 (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B)) {
672 if ((vlc = svq3_get_ue_golomb(&s->gb)) >= 48U){
673 av_log(h->s.avctx, AV_LOG_ERROR, "cbp_vlc=%d\n", vlc);
677 cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc]
678 : golomb_to_inter_cbp[vlc];
680 if (IS_INTRA16x16(mb_type) ||
681 (s->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
682 s->qscale += svq3_get_se_golomb(&s->gb);
684 if (s->qscale > 31u) {
685 av_log(h->s.avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
689 if (IS_INTRA16x16(mb_type)) {
690 AV_ZERO128(h->mb_luma_dc[0] + 0);
691 AV_ZERO128(h->mb_luma_dc[0] + 8);
692 if (svq3_decode_block(&s->gb, h->mb_luma_dc[0], 0, 1)) {
693 av_log(h->s.avctx, AV_LOG_ERROR,
694 "error while decoding intra luma dc\n");
700 const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
701 const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
703 for (i = 0; i < 4; i++)
704 if ((cbp & (1 << i))) {
705 for (j = 0; j < 4; j++) {
706 k = index ? (1 * (j & 1) + 2 * (i & 1) +
707 2 * (j & 2) + 4 * (i & 2))
709 h->non_zero_count_cache[scan8[k]] = 1;
711 if (svq3_decode_block(&s->gb, &h->mb[16 * k], index, type)) {
712 av_log(h->s.avctx, AV_LOG_ERROR,
713 "error while decoding block\n");
720 for (i = 1; i < 3; ++i)
721 if (svq3_decode_block(&s->gb, &h->mb[16 * 16 * i], 0, 3)) {
722 av_log(h->s.avctx, AV_LOG_ERROR,
723 "error while decoding chroma dc block\n");
728 for (i = 1; i < 3; i++) {
729 for (j = 0; j < 4; j++) {
731 h->non_zero_count_cache[scan8[k]] = 1;
733 if (svq3_decode_block(&s->gb, &h->mb[16 * k], 1, 1)) {
734 av_log(h->s.avctx, AV_LOG_ERROR,
735 "error while decoding chroma ac block\n");
745 s->current_picture.f.mb_type[mb_xy] = mb_type;
747 if (IS_INTRA(mb_type))
748 h->chroma_pred_mode = ff_h264_check_intra_pred_mode(h, DC_PRED8x8, 1);
753 static int svq3_decode_slice_header(AVCodecContext *avctx)
755 SVQ3Context *svq3 = avctx->priv_data;
756 H264Context *h = &svq3->h;
757 MpegEncContext *s = &h->s;
758 const int mb_xy = h->mb_xy;
762 header = get_bits(&s->gb, 8);
764 if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
766 av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
769 int length = header >> 5 & 3;
771 svq3->next_slice_index = get_bits_count(&s->gb) +
772 8 * show_bits(&s->gb, 8 * length) +
775 if (svq3->next_slice_index > s->gb.size_in_bits) {
776 av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
780 s->gb.size_in_bits = svq3->next_slice_index - 8 * (length - 1);
781 skip_bits(&s->gb, 8);
783 if (svq3->watermark_key) {
784 uint32_t header = AV_RL32(&s->gb.buffer[(get_bits_count(&s->gb) >> 3) + 1]);
785 AV_WL32(&s->gb.buffer[(get_bits_count(&s->gb) >> 3) + 1],
786 header ^ svq3->watermark_key);
789 memcpy((uint8_t *) &s->gb.buffer[get_bits_count(&s->gb) >> 3],
790 &s->gb.buffer[s->gb.size_in_bits >> 3], length - 1);
792 skip_bits_long(&s->gb, 0);
795 if ((slice_id = svq3_get_ue_golomb(&s->gb)) >= 3) {
796 av_log(h->s.avctx, AV_LOG_ERROR, "illegal slice type %d \n", slice_id);
800 h->slice_type = golomb_to_pict_type[slice_id];
802 if ((header & 0x9F) == 2) {
803 i = (s->mb_num < 64) ? 6 : (1 + av_log2(s->mb_num - 1));
804 s->mb_skip_run = get_bits(&s->gb, i) -
805 (s->mb_y * s->mb_width + s->mb_x);
811 h->slice_num = get_bits(&s->gb, 8);
812 s->qscale = get_bits(&s->gb, 5);
813 s->adaptive_quant = get_bits1(&s->gb);
818 if (svq3->unknown_flag)
822 skip_bits(&s->gb, 2);
824 while (get_bits1(&s->gb))
825 skip_bits(&s->gb, 8);
827 /* reset intra predictors and invalidate motion vector references */
829 memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy - 1] + 3,
830 -1, 4 * sizeof(int8_t));
831 memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy - s->mb_x],
832 -1, 8 * sizeof(int8_t) * s->mb_x);
835 memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy - s->mb_stride],
836 -1, 8 * sizeof(int8_t) * (s->mb_width - s->mb_x));
839 h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride - 1] + 3] = -1;
845 static av_cold int svq3_decode_init(AVCodecContext *avctx)
847 SVQ3Context *svq3 = avctx->priv_data;
848 H264Context *h = &svq3->h;
849 MpegEncContext *s = &h->s;
851 unsigned char *extradata;
852 unsigned char *extradata_end;
854 int marker_found = 0;
856 if (ff_h264_decode_init(avctx) < 0)
859 s->flags = avctx->flags;
860 s->flags2 = avctx->flags2;
861 s->unrestricted_mv = 1;
863 h->sps.chroma_format_idc = 1;
864 avctx->pix_fmt = avctx->codec->pix_fmts[0];
866 if (!s->context_initialized) {
867 h->chroma_qp[0] = h->chroma_qp[1] = 4;
869 svq3->halfpel_flag = 1;
870 svq3->thirdpel_flag = 1;
871 svq3->unknown_flag = 0;
874 /* prowl for the "SEQH" marker in the extradata */
875 extradata = (unsigned char *)avctx->extradata;
876 extradata_end = avctx->extradata + avctx->extradata_size;
878 for (m = 0; m + 8 < avctx->extradata_size; m++) {
879 if (!memcmp(extradata, "SEQH", 4)) {
887 /* if a match was found, parse the extra data */
892 size = AV_RB32(&extradata[4]);
893 if (size > extradata_end - extradata - 8)
894 return AVERROR_INVALIDDATA;
895 init_get_bits(&gb, extradata + 8, size * 8);
897 /* 'frame size code' and optional 'width, height' */
898 frame_size_code = get_bits(&gb, 3);
899 switch (frame_size_code) {
929 avctx->width = get_bits(&gb, 12);
930 avctx->height = get_bits(&gb, 12);
934 svq3->halfpel_flag = get_bits1(&gb);
935 svq3->thirdpel_flag = get_bits1(&gb);
943 s->low_delay = get_bits1(&gb);
948 while (get_bits1(&gb))
951 svq3->unknown_flag = get_bits1(&gb);
952 avctx->has_b_frames = !s->low_delay;
953 if (svq3->unknown_flag) {
955 unsigned watermark_width = svq3_get_ue_golomb(&gb);
956 unsigned watermark_height = svq3_get_ue_golomb(&gb);
957 int u1 = svq3_get_ue_golomb(&gb);
958 int u2 = get_bits(&gb, 8);
959 int u3 = get_bits(&gb, 2);
960 int u4 = svq3_get_ue_golomb(&gb);
961 unsigned long buf_len = watermark_width *
962 watermark_height * 4;
963 int offset = get_bits_count(&gb) + 7 >> 3;
966 if (watermark_height <= 0 || (uint64_t)watermark_width*4 > UINT_MAX/watermark_height)
969 buf = av_malloc(buf_len);
970 av_log(avctx, AV_LOG_DEBUG, "watermark size: %dx%d\n",
971 watermark_width, watermark_height);
972 av_log(avctx, AV_LOG_DEBUG,
973 "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n",
974 u1, u2, u3, u4, offset);
975 if (uncompress(buf, &buf_len, extradata + 8 + offset,
976 size - offset) != Z_OK) {
977 av_log(avctx, AV_LOG_ERROR,
978 "could not uncompress watermark logo\n");
982 svq3->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
983 svq3->watermark_key = svq3->watermark_key << 16 |
985 av_log(avctx, AV_LOG_DEBUG,
986 "watermark key %#x\n", svq3->watermark_key);
989 av_log(avctx, AV_LOG_ERROR,
990 "this svq3 file contains watermark which need zlib support compiled in\n");
996 s->width = avctx->width;
997 s->height = avctx->height;
999 if (ff_MPV_common_init(s) < 0)
1002 h->b_stride = 4 * s->mb_width;
1004 if (ff_h264_alloc_tables(h) < 0) {
1005 av_log(avctx, AV_LOG_ERROR, "svq3 memory allocation failed\n");
1006 return AVERROR(ENOMEM);
1013 static int svq3_decode_frame(AVCodecContext *avctx, void *data,
1014 int *got_frame, AVPacket *avpkt)
1016 SVQ3Context *svq3 = avctx->priv_data;
1017 H264Context *h = &svq3->h;
1018 MpegEncContext *s = &h->s;
1019 int buf_size = avpkt->size;
1023 /* special case for last picture */
1024 if (buf_size == 0) {
1025 if (s->next_picture_ptr && !s->low_delay) {
1026 *(AVFrame *) data = s->next_picture.f;
1027 s->next_picture_ptr = NULL;
1033 s->mb_x = s->mb_y = h->mb_xy = 0;
1035 if (svq3->watermark_key) {
1036 av_fast_malloc(&svq3->buf, &svq3->buf_size,
1037 buf_size+FF_INPUT_BUFFER_PADDING_SIZE);
1039 return AVERROR(ENOMEM);
1040 memcpy(svq3->buf, avpkt->data, buf_size);
1046 init_get_bits(&s->gb, buf, 8 * buf_size);
1048 if (svq3_decode_slice_header(avctx))
1051 s->pict_type = h->slice_type;
1052 s->picture_number = h->slice_num;
1054 if (avctx->debug & FF_DEBUG_PICT_INFO)
1055 av_log(h->s.avctx, AV_LOG_DEBUG,
1056 "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
1057 av_get_picture_type_char(s->pict_type),
1058 svq3->halfpel_flag, svq3->thirdpel_flag,
1059 s->adaptive_quant, s->qscale, h->slice_num);
1061 /* for skipping the frame */
1062 s->current_picture.f.pict_type = s->pict_type;
1063 s->current_picture.f.key_frame = (s->pict_type == AV_PICTURE_TYPE_I);
1065 /* Skip B-frames if we do not have reference frames. */
1066 if (s->last_picture_ptr == NULL && s->pict_type == AV_PICTURE_TYPE_B)
1068 if (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B ||
1069 avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I ||
1070 avctx->skip_frame >= AVDISCARD_ALL)
1073 if (s->next_p_frame_damaged) {
1074 if (s->pict_type == AV_PICTURE_TYPE_B)
1077 s->next_p_frame_damaged = 0;
1080 if (ff_h264_frame_start(h) < 0)
1083 if (s->pict_type == AV_PICTURE_TYPE_B) {
1084 h->frame_num_offset = h->slice_num - h->prev_frame_num;
1086 if (h->frame_num_offset < 0)
1087 h->frame_num_offset += 256;
1088 if (h->frame_num_offset == 0 ||
1089 h->frame_num_offset >= h->prev_frame_num_offset) {
1090 av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1094 h->prev_frame_num = h->frame_num;
1095 h->frame_num = h->slice_num;
1096 h->prev_frame_num_offset = h->frame_num - h->prev_frame_num;
1098 if (h->prev_frame_num_offset < 0)
1099 h->prev_frame_num_offset += 256;
1102 for (m = 0; m < 2; m++) {
1104 for (i = 0; i < 4; i++) {
1106 for (j = -1; j < 4; j++)
1107 h->ref_cache[m][scan8[0] + 8 * i + j] = 1;
1109 h->ref_cache[m][scan8[0] + 8 * i + j] = PART_NOT_AVAILABLE;
1113 for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
1114 for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
1116 h->mb_xy = s->mb_x + s->mb_y * s->mb_stride;
1118 if ((get_bits_count(&s->gb) + 7) >= s->gb.size_in_bits &&
1119 ((get_bits_count(&s->gb) & 7) == 0 ||
1120 show_bits(&s->gb, -get_bits_count(&s->gb) & 7) == 0)) {
1121 skip_bits(&s->gb, svq3->next_slice_index - get_bits_count(&s->gb));
1122 s->gb.size_in_bits = 8 * buf_size;
1124 if (svq3_decode_slice_header(avctx))
1127 /* TODO: support s->mb_skip_run */
1130 mb_type = svq3_get_ue_golomb(&s->gb);
1132 if (s->pict_type == AV_PICTURE_TYPE_I)
1134 else if (s->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4)
1136 if (mb_type > 33 || svq3_decode_mb(svq3, mb_type)) {
1137 av_log(h->s.avctx, AV_LOG_ERROR,
1138 "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1143 ff_h264_hl_decode_mb(h);
1145 if (s->pict_type != AV_PICTURE_TYPE_B && !s->low_delay)
1146 s->current_picture.f.mb_type[s->mb_x + s->mb_y * s->mb_stride] =
1147 (s->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1150 ff_draw_horiz_band(s, 16 * s->mb_y, 16);
1153 left = buf_size*8 - get_bits_count(&s->gb);
1155 if (s->mb_y != s->mb_height || s->mb_x != s->mb_width) {
1156 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);
1157 //av_hex_dump(stderr, buf+buf_size-8, 8);
1161 av_log(avctx, AV_LOG_ERROR, "frame num %d left %d\n", avctx->frame_number, left);
1165 ff_MPV_frame_end(s);
1167 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay)
1168 *(AVFrame *)data = s->current_picture.f;
1170 *(AVFrame *)data = s->last_picture.f;
1172 /* Do not output the last pic after seeking. */
1173 if (s->last_picture_ptr || s->low_delay)
1179 static int svq3_decode_end(AVCodecContext *avctx)
1181 SVQ3Context *svq3 = avctx->priv_data;
1182 H264Context *h = &svq3->h;
1183 MpegEncContext *s = &h->s;
1185 ff_h264_free_context(h);
1187 ff_MPV_common_end(s);
1189 av_freep(&svq3->buf);
1195 AVCodec ff_svq3_decoder = {
1197 .type = AVMEDIA_TYPE_VIDEO,
1198 .id = AV_CODEC_ID_SVQ3,
1199 .priv_data_size = sizeof(SVQ3Context),
1200 .init = svq3_decode_init,
1201 .close = svq3_decode_end,
1202 .decode = svq3_decode_frame,
1203 .capabilities = CODEC_CAP_DRAW_HORIZ_BAND |
1206 .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1207 .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P,