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"
72 uint32_t watermark_key;
77 #define FULLPEL_MODE 1
78 #define HALFPEL_MODE 2
79 #define THIRDPEL_MODE 3
80 #define PREDICT_MODE 4
82 /* dual scan (from some older h264 draft)
91 static const uint8_t svq3_scan[16] = {
92 0 + 0 * 4, 1 + 0 * 4, 2 + 0 * 4, 2 + 1 * 4,
93 2 + 2 * 4, 3 + 0 * 4, 3 + 1 * 4, 3 + 2 * 4,
94 0 + 1 * 4, 0 + 2 * 4, 1 + 1 * 4, 1 + 2 * 4,
95 0 + 3 * 4, 1 + 3 * 4, 2 + 3 * 4, 3 + 3 * 4,
98 static const uint8_t svq3_pred_0[25][2] = {
101 { 0, 2 }, { 1, 1 }, { 2, 0 },
102 { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
103 { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
104 { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
105 { 2, 4 }, { 3, 3 }, { 4, 2 },
110 static const int8_t svq3_pred_1[6][6][5] = {
111 { { 2, -1, -1, -1, -1 }, { 2, 1, -1, -1, -1 }, { 1, 2, -1, -1, -1 },
112 { 2, 1, -1, -1, -1 }, { 1, 2, -1, -1, -1 }, { 1, 2, -1, -1, -1 } },
113 { { 0, 2, -1, -1, -1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
114 { 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
115 { { 2, 0, -1, -1, -1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
116 { 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
117 { { 2, 0, -1, -1, -1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
118 { 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
119 { { 0, 2, -1, -1, -1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
120 { 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
121 { { 0, 2, -1, -1, -1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
122 { 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
125 static const struct {
128 } svq3_dct_tables[2][16] = {
129 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
130 { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
131 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
132 { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
135 static const uint32_t svq3_dequant_coeff[32] = {
136 3881, 4351, 4890, 5481, 6154, 6914, 7761, 8718,
137 9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
138 24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
139 61694, 68745, 77615, 89113, 100253, 109366, 126635, 141533
142 void ff_svq3_luma_dc_dequant_idct_c(DCTELEM *output, DCTELEM *input, int qp)
144 const int qmul = svq3_dequant_coeff[qp];
148 static const uint8_t x_offset[4] = { 0, 1 * stride, 4 * stride, 5 * stride };
150 for (i = 0; i < 4; i++) {
151 const int z0 = 13 * (input[4 * i + 0] + input[4 * i + 2]);
152 const int z1 = 13 * (input[4 * i + 0] - input[4 * i + 2]);
153 const int z2 = 7 * input[4 * i + 1] - 17 * input[4 * i + 3];
154 const int z3 = 17 * input[4 * i + 1] + 7 * input[4 * i + 3];
156 temp[4 * i + 0] = z0 + z3;
157 temp[4 * i + 1] = z1 + z2;
158 temp[4 * i + 2] = z1 - z2;
159 temp[4 * i + 3] = z0 - z3;
162 for (i = 0; i < 4; i++) {
163 const int offset = x_offset[i];
164 const int z0 = 13 * (temp[4 * 0 + i] + temp[4 * 2 + i]);
165 const int z1 = 13 * (temp[4 * 0 + i] - temp[4 * 2 + i]);
166 const int z2 = 7 * temp[4 * 1 + i] - 17 * temp[4 * 3 + i];
167 const int z3 = 17 * temp[4 * 1 + i] + 7 * temp[4 * 3 + i];
169 output[stride * 0 + offset] = (z0 + z3) * qmul + 0x80000 >> 20;
170 output[stride * 2 + offset] = (z1 + z2) * qmul + 0x80000 >> 20;
171 output[stride * 8 + offset] = (z1 - z2) * qmul + 0x80000 >> 20;
172 output[stride * 10 + offset] = (z0 - z3) * qmul + 0x80000 >> 20;
177 void ff_svq3_add_idct_c(uint8_t *dst, DCTELEM *block,
178 int stride, int qp, int dc)
180 const int qmul = svq3_dequant_coeff[qp];
184 dc = 13 * 13 * (dc == 1 ? 1538 * block[0]
185 : qmul * (block[0] >> 3) / 2);
189 for (i = 0; i < 4; i++) {
190 const int z0 = 13 * (block[0 + 4 * i] + block[2 + 4 * i]);
191 const int z1 = 13 * (block[0 + 4 * i] - block[2 + 4 * i]);
192 const int z2 = 7 * block[1 + 4 * i] - 17 * block[3 + 4 * i];
193 const int z3 = 17 * block[1 + 4 * i] + 7 * block[3 + 4 * i];
195 block[0 + 4 * i] = z0 + z3;
196 block[1 + 4 * i] = z1 + z2;
197 block[2 + 4 * i] = z1 - z2;
198 block[3 + 4 * i] = z0 - z3;
201 for (i = 0; i < 4; i++) {
202 const int z0 = 13 * (block[i + 4 * 0] + block[i + 4 * 2]);
203 const int z1 = 13 * (block[i + 4 * 0] - block[i + 4 * 2]);
204 const int z2 = 7 * block[i + 4 * 1] - 17 * block[i + 4 * 3];
205 const int z3 = 17 * block[i + 4 * 1] + 7 * block[i + 4 * 3];
206 const int rr = (dc + 0x80000);
208 dst[i + stride * 0] = av_clip_uint8(dst[i + stride * 0] + ((z0 + z3) * qmul + rr >> 20));
209 dst[i + stride * 1] = av_clip_uint8(dst[i + stride * 1] + ((z1 + z2) * qmul + rr >> 20));
210 dst[i + stride * 2] = av_clip_uint8(dst[i + stride * 2] + ((z1 - z2) * qmul + rr >> 20));
211 dst[i + stride * 3] = av_clip_uint8(dst[i + stride * 3] + ((z0 - z3) * qmul + rr >> 20));
215 static inline int svq3_decode_block(GetBitContext *gb, DCTELEM *block,
216 int index, const int type)
218 static const uint8_t *const scan_patterns[4] =
219 { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
221 int run, level, sign, vlc, limit;
222 const int intra = 3 * type >> 2;
223 const uint8_t *const scan = scan_patterns[type];
225 for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
226 for (; (vlc = svq3_get_ue_golomb(gb)) != 0; index++) {
230 sign = (vlc & 0x1) - 1;
237 } else if (vlc < 4) {
242 level = (vlc + 9 >> 2) - run;
246 run = svq3_dct_tables[intra][vlc].run;
247 level = svq3_dct_tables[intra][vlc].level;
250 level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
253 level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
258 if ((index += run) >= limit)
261 block[scan[index]] = (level ^ sign) - sign;
272 static inline void svq3_mc_dir_part(MpegEncContext *s,
273 int x, int y, int width, int height,
274 int mx, int my, int dxy,
275 int thirdpel, int dir, int avg)
277 const Picture *pic = (dir == 0) ? &s->last_picture : &s->next_picture;
280 int blocksize = 2 - (width >> 3); // 16->0, 8->1, 4->2
285 if (mx < 0 || mx >= s->h_edge_pos - width - 1 ||
286 my < 0 || my >= s->v_edge_pos - height - 1) {
287 if ((s->flags & CODEC_FLAG_EMU_EDGE))
290 mx = av_clip(mx, -16, s->h_edge_pos - width + 15);
291 my = av_clip(my, -16, s->v_edge_pos - height + 15);
294 /* form component predictions */
295 dest = s->current_picture.f.data[0] + x + y * s->linesize;
296 src = pic->f.data[0] + mx + my * s->linesize;
299 s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize,
300 width + 1, height + 1,
301 mx, my, s->h_edge_pos, s->v_edge_pos);
302 src = s->edge_emu_buffer;
305 (avg ? s->dsp.avg_tpel_pixels_tab
306 : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->linesize,
309 (avg ? s->dsp.avg_pixels_tab
310 : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->linesize,
313 if (!(s->flags & CODEC_FLAG_GRAY)) {
314 mx = mx + (mx < (int) x) >> 1;
315 my = my + (my < (int) y) >> 1;
317 height = height >> 1;
320 for (i = 1; i < 3; i++) {
321 dest = s->current_picture.f.data[i] + (x >> 1) + (y >> 1) * s->uvlinesize;
322 src = pic->f.data[i] + mx + my * s->uvlinesize;
325 s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->uvlinesize,
326 width + 1, height + 1,
327 mx, my, (s->h_edge_pos >> 1),
329 src = s->edge_emu_buffer;
332 (avg ? s->dsp.avg_tpel_pixels_tab
333 : s->dsp.put_tpel_pixels_tab)[dxy](dest, src,
337 (avg ? s->dsp.avg_pixels_tab
338 : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src,
345 static inline int svq3_mc_dir(H264Context *h, int size, int mode,
348 int i, j, k, mx, my, dx, dy, x, y;
349 MpegEncContext *const s = (MpegEncContext *)h;
350 const int part_width = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
351 const int part_height = 16 >> ((unsigned)(size + 1) / 3);
352 const int extra_width = (mode == PREDICT_MODE) ? -16 * 6 : 0;
353 const int h_edge_pos = 6 * (s->h_edge_pos - part_width) - extra_width;
354 const int v_edge_pos = 6 * (s->v_edge_pos - part_height) - extra_width;
356 for (i = 0; i < 16; i += part_height)
357 for (j = 0; j < 16; j += part_width) {
358 const int b_xy = (4 * s->mb_x + (j >> 2)) +
359 (4 * s->mb_y + (i >> 2)) * h->b_stride;
361 x = 16 * s->mb_x + j;
362 y = 16 * s->mb_y + i;
363 k = (j >> 2 & 1) + (i >> 1 & 2) +
364 (j >> 1 & 4) + (i & 8);
366 if (mode != PREDICT_MODE) {
367 pred_motion(h, k, part_width >> 2, dir, 1, &mx, &my);
369 mx = s->next_picture.f.motion_val[0][b_xy][0] << 1;
370 my = s->next_picture.f.motion_val[0][b_xy][1] << 1;
373 mx = mx * h->frame_num_offset /
374 h->prev_frame_num_offset + 1 >> 1;
375 my = my * h->frame_num_offset /
376 h->prev_frame_num_offset + 1 >> 1;
378 mx = mx * (h->frame_num_offset - h->prev_frame_num_offset) /
379 h->prev_frame_num_offset + 1 >> 1;
380 my = my * (h->frame_num_offset - h->prev_frame_num_offset) /
381 h->prev_frame_num_offset + 1 >> 1;
385 /* clip motion vector prediction to frame border */
386 mx = av_clip(mx, extra_width - 6 * x, h_edge_pos - 6 * x);
387 my = av_clip(my, extra_width - 6 * y, v_edge_pos - 6 * y);
389 /* get (optional) motion vector differential */
390 if (mode == PREDICT_MODE) {
393 dy = svq3_get_se_golomb(&s->gb);
394 dx = svq3_get_se_golomb(&s->gb);
396 if (dx == INVALID_VLC || dy == INVALID_VLC) {
397 av_log(h->s.avctx, AV_LOG_ERROR, "invalid MV vlc\n");
402 /* compute motion vector */
403 if (mode == THIRDPEL_MODE) {
405 mx = (mx + 1 >> 1) + dx;
406 my = (my + 1 >> 1) + dy;
407 fx = (unsigned)(mx + 0x3000) / 3 - 0x1000;
408 fy = (unsigned)(my + 0x3000) / 3 - 0x1000;
409 dxy = (mx - 3 * fx) + 4 * (my - 3 * fy);
411 svq3_mc_dir_part(s, x, y, part_width, part_height,
412 fx, fy, dxy, 1, dir, avg);
415 } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
416 mx = (unsigned)(mx + 1 + 0x3000) / 3 + dx - 0x1000;
417 my = (unsigned)(my + 1 + 0x3000) / 3 + dy - 0x1000;
418 dxy = (mx & 1) + 2 * (my & 1);
420 svq3_mc_dir_part(s, x, y, part_width, part_height,
421 mx >> 1, my >> 1, dxy, 0, dir, avg);
425 mx = (unsigned)(mx + 3 + 0x6000) / 6 + dx - 0x1000;
426 my = (unsigned)(my + 3 + 0x6000) / 6 + dy - 0x1000;
428 svq3_mc_dir_part(s, x, y, part_width, part_height,
429 mx, my, 0, 0, dir, avg);
434 /* update mv_cache */
435 if (mode != PREDICT_MODE) {
436 int32_t mv = pack16to32(mx, my);
438 if (part_height == 8 && i < 8) {
439 AV_WN32A(h->mv_cache[dir][scan8[k] + 1 * 8], mv);
441 if (part_width == 8 && j < 8)
442 AV_WN32A(h->mv_cache[dir][scan8[k] + 1 + 1 * 8], mv);
444 if (part_width == 8 && j < 8)
445 AV_WN32A(h->mv_cache[dir][scan8[k] + 1], mv);
446 if (part_width == 4 || part_height == 4)
447 AV_WN32A(h->mv_cache[dir][scan8[k]], mv);
450 /* write back motion vectors */
451 fill_rectangle(s->current_picture.f.motion_val[dir][b_xy],
452 part_width >> 2, part_height >> 2, h->b_stride,
453 pack16to32(mx, my), 4);
459 static int svq3_decode_mb(SVQ3Context *svq3, unsigned int mb_type)
461 H264Context *h = &svq3->h;
462 int i, j, k, m, dir, mode;
466 MpegEncContext *const s = (MpegEncContext *)h;
467 const int mb_xy = h->mb_xy;
468 const int b_xy = 4 * s->mb_x + 4 * s->mb_y * h->b_stride;
470 h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
471 h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
472 h->topright_samples_available = 0xFFFF;
474 if (mb_type == 0) { /* SKIP */
475 if (s->pict_type == AV_PICTURE_TYPE_P ||
476 s->next_picture.f.mb_type[mb_xy] == -1) {
477 svq3_mc_dir_part(s, 16 * s->mb_x, 16 * s->mb_y, 16, 16,
480 if (s->pict_type == AV_PICTURE_TYPE_B)
481 svq3_mc_dir_part(s, 16 * s->mb_x, 16 * s->mb_y, 16, 16,
484 mb_type = MB_TYPE_SKIP;
486 mb_type = FFMIN(s->next_picture.f.mb_type[mb_xy], 6);
487 if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 0, 0) < 0)
489 if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 1, 1) < 0)
492 mb_type = MB_TYPE_16x16;
494 } else if (mb_type < 8) { /* INTER */
495 if (svq3->thirdpel_flag && svq3->halfpel_flag == !get_bits1(&s->gb))
496 mode = THIRDPEL_MODE;
497 else if (svq3->halfpel_flag &&
498 svq3->thirdpel_flag == !get_bits1(&s->gb))
504 /* note ref_cache should contain here:
512 for (m = 0; m < 2; m++) {
513 if (s->mb_x > 0 && h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1] + 6] != -1) {
514 for (i = 0; i < 4; i++)
515 AV_COPY32(h->mv_cache[m][scan8[0] - 1 + i * 8],
516 s->current_picture.f.motion_val[m][b_xy - 1 + i * h->b_stride]);
518 for (i = 0; i < 4; i++)
519 AV_ZERO32(h->mv_cache[m][scan8[0] - 1 + i * 8]);
522 memcpy(h->mv_cache[m][scan8[0] - 1 * 8],
523 s->current_picture.f.motion_val[m][b_xy - h->b_stride],
524 4 * 2 * sizeof(int16_t));
525 memset(&h->ref_cache[m][scan8[0] - 1 * 8],
526 (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1, 4);
528 if (s->mb_x < s->mb_width - 1) {
529 AV_COPY32(h->mv_cache[m][scan8[0] + 4 - 1 * 8],
530 s->current_picture.f.motion_val[m][b_xy - h->b_stride + 4]);
531 h->ref_cache[m][scan8[0] + 4 - 1 * 8] =
532 (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride + 1] + 6] == -1 ||
533 h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1;
535 h->ref_cache[m][scan8[0] + 4 - 1 * 8] = PART_NOT_AVAILABLE;
537 AV_COPY32(h->mv_cache[m][scan8[0] - 1 - 1 * 8],
538 s->current_picture.f.motion_val[m][b_xy - h->b_stride - 1]);
539 h->ref_cache[m][scan8[0] - 1 - 1 * 8] =
540 (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride - 1] + 3] == -1) ? PART_NOT_AVAILABLE : 1;
542 h->ref_cache[m][scan8[0] - 1 - 1 * 8] = PART_NOT_AVAILABLE;
544 memset(&h->ref_cache[m][scan8[0] - 1 * 8 - 1],
545 PART_NOT_AVAILABLE, 8);
547 if (s->pict_type != AV_PICTURE_TYPE_B)
551 /* decode motion vector(s) and form prediction(s) */
552 if (s->pict_type == AV_PICTURE_TYPE_P) {
553 if (svq3_mc_dir(h, mb_type - 1, mode, 0, 0) < 0)
555 } else { /* AV_PICTURE_TYPE_B */
557 if (svq3_mc_dir(h, 0, mode, 0, 0) < 0)
560 for (i = 0; i < 4; i++)
561 memset(s->current_picture.f.motion_val[0][b_xy + i * h->b_stride],
562 0, 4 * 2 * sizeof(int16_t));
565 if (svq3_mc_dir(h, 0, mode, 1, mb_type == 3) < 0)
568 for (i = 0; i < 4; i++)
569 memset(s->current_picture.f.motion_val[1][b_xy + i * h->b_stride],
570 0, 4 * 2 * sizeof(int16_t));
574 mb_type = MB_TYPE_16x16;
575 } else if (mb_type == 8 || mb_type == 33) { /* INTRA4x4 */
576 memset(h->intra4x4_pred_mode_cache, -1, 8 * 5 * sizeof(int8_t));
580 for (i = 0; i < 4; i++)
581 h->intra4x4_pred_mode_cache[scan8[0] - 1 + i * 8] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1] + 6 - i];
582 if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1)
583 h->left_samples_available = 0x5F5F;
586 h->intra4x4_pred_mode_cache[4 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride] + 0];
587 h->intra4x4_pred_mode_cache[5 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride] + 1];
588 h->intra4x4_pred_mode_cache[6 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride] + 2];
589 h->intra4x4_pred_mode_cache[7 + 8 * 0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride] + 3];
591 if (h->intra4x4_pred_mode_cache[4 + 8 * 0] == -1)
592 h->top_samples_available = 0x33FF;
595 /* decode prediction codes for luma blocks */
596 for (i = 0; i < 16; i += 2) {
597 vlc = svq3_get_ue_golomb(&s->gb);
600 av_log(h->s.avctx, AV_LOG_ERROR, "luma prediction:%d\n", vlc);
604 left = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
605 top = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
607 left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
608 left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
610 if (left[1] == -1 || left[2] == -1) {
611 av_log(h->s.avctx, AV_LOG_ERROR, "weird prediction\n");
615 } else { /* mb_type == 33, DC_128_PRED block type */
616 for (i = 0; i < 4; i++)
617 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_PRED, 4);
620 write_back_intra_pred_mode(h);
623 ff_h264_check_intra4x4_pred_mode(h);
625 h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
626 h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
628 for (i = 0; i < 4; i++)
629 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_128_PRED, 4);
631 h->top_samples_available = 0x33FF;
632 h->left_samples_available = 0x5F5F;
635 mb_type = MB_TYPE_INTRA4x4;
636 } else { /* INTRA16x16 */
637 dir = i_mb_type_info[mb_type - 8].pred_mode;
638 dir = (dir >> 1) ^ 3 * (dir & 1) ^ 1;
640 if ((h->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, dir, 0)) == -1) {
641 av_log(h->s.avctx, AV_LOG_ERROR, "check_intra_pred_mode = -1\n");
645 cbp = i_mb_type_info[mb_type - 8].cbp;
646 mb_type = MB_TYPE_INTRA16x16;
649 if (!IS_INTER(mb_type) && s->pict_type != AV_PICTURE_TYPE_I) {
650 for (i = 0; i < 4; i++)
651 memset(s->current_picture.f.motion_val[0][b_xy + i * h->b_stride],
652 0, 4 * 2 * sizeof(int16_t));
653 if (s->pict_type == AV_PICTURE_TYPE_B) {
654 for (i = 0; i < 4; i++)
655 memset(s->current_picture.f.motion_val[1][b_xy + i * h->b_stride],
656 0, 4 * 2 * sizeof(int16_t));
659 if (!IS_INTRA4x4(mb_type)) {
660 memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy], DC_PRED, 8);
662 if (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B) {
663 memset(h->non_zero_count_cache + 8, 0, 14 * 8 * sizeof(uint8_t));
664 s->dsp.clear_blocks(h->mb + 0);
665 s->dsp.clear_blocks(h->mb + 384);
668 if (!IS_INTRA16x16(mb_type) &&
669 (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B)) {
670 if ((vlc = svq3_get_ue_golomb(&s->gb)) >= 48U){
671 av_log(h->s.avctx, AV_LOG_ERROR, "cbp_vlc=%d\n", vlc);
675 cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc]
676 : golomb_to_inter_cbp[vlc];
678 if (IS_INTRA16x16(mb_type) ||
679 (s->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
680 s->qscale += svq3_get_se_golomb(&s->gb);
682 if (s->qscale > 31u) {
683 av_log(h->s.avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
687 if (IS_INTRA16x16(mb_type)) {
688 AV_ZERO128(h->mb_luma_dc[0] + 0);
689 AV_ZERO128(h->mb_luma_dc[0] + 8);
690 if (svq3_decode_block(&s->gb, h->mb_luma_dc[0], 0, 1)) {
691 av_log(h->s.avctx, AV_LOG_ERROR,
692 "error while decoding intra luma dc\n");
698 const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
699 const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
701 for (i = 0; i < 4; i++)
702 if ((cbp & (1 << i))) {
703 for (j = 0; j < 4; j++) {
704 k = index ? (1 * (j & 1) + 2 * (i & 1) +
705 2 * (j & 2) + 4 * (i & 2))
707 h->non_zero_count_cache[scan8[k]] = 1;
709 if (svq3_decode_block(&s->gb, &h->mb[16 * k], index, type)) {
710 av_log(h->s.avctx, AV_LOG_ERROR,
711 "error while decoding block\n");
718 for (i = 1; i < 3; ++i)
719 if (svq3_decode_block(&s->gb, &h->mb[16 * 16 * i], 0, 3)) {
720 av_log(h->s.avctx, AV_LOG_ERROR,
721 "error while decoding chroma dc block\n");
726 for (i = 1; i < 3; i++) {
727 for (j = 0; j < 4; j++) {
729 h->non_zero_count_cache[scan8[k]] = 1;
731 if (svq3_decode_block(&s->gb, &h->mb[16 * k], 1, 1)) {
732 av_log(h->s.avctx, AV_LOG_ERROR,
733 "error while decoding chroma ac block\n");
743 s->current_picture.f.mb_type[mb_xy] = mb_type;
745 if (IS_INTRA(mb_type))
746 h->chroma_pred_mode = ff_h264_check_intra_pred_mode(h, DC_PRED8x8, 1);
751 static int svq3_decode_slice_header(AVCodecContext *avctx)
753 SVQ3Context *svq3 = avctx->priv_data;
754 H264Context *h = &svq3->h;
755 MpegEncContext *s = &h->s;
756 const int mb_xy = h->mb_xy;
759 header = get_bits(&s->gb, 8);
761 if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
763 av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
766 int length = header >> 5 & 3;
768 svq3->next_slice_index = get_bits_count(&s->gb) +
769 8 * show_bits(&s->gb, 8 * length) +
772 if (svq3->next_slice_index > s->gb.size_in_bits) {
773 av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
777 s->gb.size_in_bits = svq3->next_slice_index - 8 * (length - 1);
778 skip_bits(&s->gb, 8);
780 if (svq3->watermark_key) {
781 uint32_t header = AV_RL32(&s->gb.buffer[(get_bits_count(&s->gb) >> 3) + 1]);
782 AV_WL32(&s->gb.buffer[(get_bits_count(&s->gb) >> 3) + 1],
783 header ^ svq3->watermark_key);
786 memcpy((uint8_t *) &s->gb.buffer[get_bits_count(&s->gb) >> 3],
787 &s->gb.buffer[s->gb.size_in_bits >> 3], length - 1);
789 skip_bits_long(&s->gb, 0);
792 if ((i = svq3_get_ue_golomb(&s->gb)) >= 3U) {
793 av_log(h->s.avctx, AV_LOG_ERROR, "illegal slice type %d \n", i);
797 h->slice_type = golomb_to_pict_type[i];
799 if ((header & 0x9F) == 2) {
800 i = (s->mb_num < 64) ? 6 : (1 + av_log2(s->mb_num - 1));
801 s->mb_skip_run = get_bits(&s->gb, i) -
802 (s->mb_y * s->mb_width + s->mb_x);
808 h->slice_num = get_bits(&s->gb, 8);
809 s->qscale = get_bits(&s->gb, 5);
810 s->adaptive_quant = get_bits1(&s->gb);
815 if (svq3->unknown_flag)
819 skip_bits(&s->gb, 2);
821 while (get_bits1(&s->gb))
822 skip_bits(&s->gb, 8);
824 /* reset intra predictors and invalidate motion vector references */
826 memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy - 1] + 3,
827 -1, 4 * sizeof(int8_t));
828 memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy - s->mb_x],
829 -1, 8 * sizeof(int8_t) * s->mb_x);
832 memset(h->intra4x4_pred_mode + h->mb2br_xy[mb_xy - s->mb_stride],
833 -1, 8 * sizeof(int8_t) * (s->mb_width - s->mb_x));
836 h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride - 1] + 3] = -1;
842 static av_cold int svq3_decode_init(AVCodecContext *avctx)
844 SVQ3Context *svq3 = avctx->priv_data;
845 H264Context *h = &svq3->h;
846 MpegEncContext *s = &h->s;
848 unsigned char *extradata;
849 unsigned char *extradata_end;
851 int marker_found = 0;
853 if (ff_h264_decode_init(avctx) < 0)
856 s->flags = avctx->flags;
857 s->flags2 = avctx->flags2;
858 s->unrestricted_mv = 1;
860 h->sps.chroma_format_idc = 1;
861 avctx->pix_fmt = avctx->codec->pix_fmts[0];
863 if (!s->context_initialized) {
864 h->chroma_qp[0] = h->chroma_qp[1] = 4;
866 svq3->halfpel_flag = 1;
867 svq3->thirdpel_flag = 1;
868 svq3->unknown_flag = 0;
871 /* prowl for the "SEQH" marker in the extradata */
872 extradata = (unsigned char *)avctx->extradata;
873 extradata_end = avctx->extradata + avctx->extradata_size;
875 for (m = 0; m + 8 < avctx->extradata_size; m++) {
876 if (!memcmp(extradata, "SEQH", 4)) {
884 /* if a match was found, parse the extra data */
889 size = AV_RB32(&extradata[4]);
890 if (size > extradata_end - extradata - 8)
891 return AVERROR_INVALIDDATA;
892 init_get_bits(&gb, extradata + 8, size * 8);
894 /* 'frame size code' and optional 'width, height' */
895 frame_size_code = get_bits(&gb, 3);
896 switch (frame_size_code) {
926 avctx->width = get_bits(&gb, 12);
927 avctx->height = get_bits(&gb, 12);
931 svq3->halfpel_flag = get_bits1(&gb);
932 svq3->thirdpel_flag = get_bits1(&gb);
940 s->low_delay = get_bits1(&gb);
945 while (get_bits1(&gb))
948 svq3->unknown_flag = get_bits1(&gb);
949 avctx->has_b_frames = !s->low_delay;
950 if (svq3->unknown_flag) {
952 unsigned watermark_width = svq3_get_ue_golomb(&gb);
953 unsigned watermark_height = svq3_get_ue_golomb(&gb);
954 int u1 = svq3_get_ue_golomb(&gb);
955 int u2 = get_bits(&gb, 8);
956 int u3 = get_bits(&gb, 2);
957 int u4 = svq3_get_ue_golomb(&gb);
958 unsigned long buf_len = watermark_width *
959 watermark_height * 4;
960 int offset = get_bits_count(&gb) + 7 >> 3;
963 if (watermark_height <= 0 || (uint64_t)watermark_width*4 > UINT_MAX/watermark_height)
966 buf = av_malloc(buf_len);
967 av_log(avctx, AV_LOG_DEBUG, "watermark size: %dx%d\n",
968 watermark_width, watermark_height);
969 av_log(avctx, AV_LOG_DEBUG,
970 "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n",
971 u1, u2, u3, u4, offset);
972 if (uncompress(buf, &buf_len, extradata + 8 + offset,
973 size - offset) != Z_OK) {
974 av_log(avctx, AV_LOG_ERROR,
975 "could not uncompress watermark logo\n");
979 svq3->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
980 svq3->watermark_key = svq3->watermark_key << 16 |
982 av_log(avctx, AV_LOG_DEBUG,
983 "watermark key %#x\n", svq3->watermark_key);
986 av_log(avctx, AV_LOG_ERROR,
987 "this svq3 file contains watermark which need zlib support compiled in\n");
993 s->width = avctx->width;
994 s->height = avctx->height;
996 if (ff_MPV_common_init(s) < 0)
999 h->b_stride = 4 * s->mb_width;
1001 if (ff_h264_alloc_tables(h) < 0) {
1002 av_log(avctx, AV_LOG_ERROR, "svq3 memory allocation failed\n");
1003 return AVERROR(ENOMEM);
1010 static int svq3_decode_frame(AVCodecContext *avctx, void *data,
1011 int *data_size, AVPacket *avpkt)
1013 SVQ3Context *svq3 = avctx->priv_data;
1014 H264Context *h = &svq3->h;
1015 MpegEncContext *s = &h->s;
1016 int buf_size = avpkt->size;
1017 int m, mb_type, left;
1020 /* special case for last picture */
1021 if (buf_size == 0) {
1022 if (s->next_picture_ptr && !s->low_delay) {
1023 *(AVFrame *) data = s->next_picture.f;
1024 s->next_picture_ptr = NULL;
1025 *data_size = sizeof(AVFrame);
1030 s->mb_x = s->mb_y = h->mb_xy = 0;
1032 if (svq3->watermark_key) {
1033 av_fast_malloc(&svq3->buf, &svq3->buf_size,
1034 buf_size+FF_INPUT_BUFFER_PADDING_SIZE);
1036 return AVERROR(ENOMEM);
1037 memcpy(svq3->buf, avpkt->data, buf_size);
1043 init_get_bits(&s->gb, buf, 8 * buf_size);
1045 if (svq3_decode_slice_header(avctx))
1048 s->pict_type = h->slice_type;
1049 s->picture_number = h->slice_num;
1051 if (avctx->debug & FF_DEBUG_PICT_INFO)
1052 av_log(h->s.avctx, AV_LOG_DEBUG,
1053 "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
1054 av_get_picture_type_char(s->pict_type),
1055 svq3->halfpel_flag, svq3->thirdpel_flag,
1056 s->adaptive_quant, s->qscale, h->slice_num);
1058 /* for skipping the frame */
1059 s->current_picture.f.pict_type = s->pict_type;
1060 s->current_picture.f.key_frame = (s->pict_type == AV_PICTURE_TYPE_I);
1062 /* Skip B-frames if we do not have reference frames. */
1063 if (s->last_picture_ptr == NULL && s->pict_type == AV_PICTURE_TYPE_B)
1065 if (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B ||
1066 avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I ||
1067 avctx->skip_frame >= AVDISCARD_ALL)
1070 if (s->next_p_frame_damaged) {
1071 if (s->pict_type == AV_PICTURE_TYPE_B)
1074 s->next_p_frame_damaged = 0;
1077 if (ff_h264_frame_start(h) < 0)
1080 if (s->pict_type == AV_PICTURE_TYPE_B) {
1081 h->frame_num_offset = h->slice_num - h->prev_frame_num;
1083 if (h->frame_num_offset < 0)
1084 h->frame_num_offset += 256;
1085 if (h->frame_num_offset == 0 ||
1086 h->frame_num_offset >= h->prev_frame_num_offset) {
1087 av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1091 h->prev_frame_num = h->frame_num;
1092 h->frame_num = h->slice_num;
1093 h->prev_frame_num_offset = h->frame_num - h->prev_frame_num;
1095 if (h->prev_frame_num_offset < 0)
1096 h->prev_frame_num_offset += 256;
1099 for (m = 0; m < 2; m++) {
1101 for (i = 0; i < 4; i++) {
1103 for (j = -1; j < 4; j++)
1104 h->ref_cache[m][scan8[0] + 8 * i + j] = 1;
1106 h->ref_cache[m][scan8[0] + 8 * i + j] = PART_NOT_AVAILABLE;
1110 for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
1111 for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
1112 h->mb_xy = s->mb_x + s->mb_y * s->mb_stride;
1114 if ((get_bits_count(&s->gb) + 7) >= s->gb.size_in_bits &&
1115 ((get_bits_count(&s->gb) & 7) == 0 ||
1116 show_bits(&s->gb, -get_bits_count(&s->gb) & 7) == 0)) {
1117 skip_bits(&s->gb, svq3->next_slice_index - get_bits_count(&s->gb));
1118 s->gb.size_in_bits = 8 * buf_size;
1120 if (svq3_decode_slice_header(avctx))
1123 /* TODO: support s->mb_skip_run */
1126 mb_type = svq3_get_ue_golomb(&s->gb);
1128 if (s->pict_type == AV_PICTURE_TYPE_I)
1130 else if (s->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4)
1132 if ((unsigned)mb_type > 33 || svq3_decode_mb(svq3, mb_type)) {
1133 av_log(h->s.avctx, AV_LOG_ERROR,
1134 "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1139 ff_h264_hl_decode_mb(h);
1141 if (s->pict_type != AV_PICTURE_TYPE_B && !s->low_delay)
1142 s->current_picture.f.mb_type[s->mb_x + s->mb_y * s->mb_stride] =
1143 (s->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1146 ff_draw_horiz_band(s, 16 * s->mb_y, 16);
1149 left = buf_size*8 - get_bits_count(&s->gb);
1151 if (s->mb_y != s->mb_height || s->mb_x != s->mb_width) {
1152 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);
1153 //av_hex_dump(stderr, buf+buf_size-8, 8);
1157 av_log(avctx, AV_LOG_ERROR, "frame num %d left %d\n", avctx->frame_number, left);
1161 ff_MPV_frame_end(s);
1163 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay)
1164 *(AVFrame *)data = s->current_picture.f;
1166 *(AVFrame *)data = s->last_picture.f;
1168 /* Do not output the last pic after seeking. */
1169 if (s->last_picture_ptr || s->low_delay)
1170 *data_size = sizeof(AVFrame);
1175 static int svq3_decode_end(AVCodecContext *avctx)
1177 SVQ3Context *svq3 = avctx->priv_data;
1178 H264Context *h = &svq3->h;
1179 MpegEncContext *s = &h->s;
1181 ff_h264_free_context(h);
1183 ff_MPV_common_end(s);
1185 av_freep(&svq3->buf);
1191 AVCodec ff_svq3_decoder = {
1193 .type = AVMEDIA_TYPE_VIDEO,
1194 .id = AV_CODEC_ID_SVQ3,
1195 .priv_data_size = sizeof(SVQ3Context),
1196 .init = svq3_decode_init,
1197 .close = svq3_decode_end,
1198 .decode = svq3_decode_frame,
1199 .capabilities = CODEC_CAP_DRAW_HORIZ_BAND |
1202 .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1203 .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P,