2 * Copyright (c) 2003 The FFmpeg Project
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 * How to use this decoder:
23 * SVQ3 data is transported within Apple Quicktime files. Quicktime files
24 * have stsd atoms to describe media trak properties. A stsd atom for a
25 * video trak contains 1 or more ImageDescription atoms. These atoms begin
26 * with the 4-byte length of the atom followed by the codec fourcc. Some
27 * decoders need information in this atom to operate correctly. Such
28 * is the case with SVQ3. In order to get the best use out of this decoder,
29 * the calling app must make the SVQ3 ImageDescription atom available
30 * via the AVCodecContext's extradata[_size] field:
32 * AVCodecContext.extradata = pointer to ImageDescription, first characters
33 * are expected to be 'S', 'V', 'Q', and '3', NOT the 4-byte atom length
34 * AVCodecContext.extradata_size = size of ImageDescription atom memory
35 * buffer (which will be the same as the ImageDescription atom size field
36 * from the QT file, minus 4 bytes since the length is missing)
38 * You will know you have these parameters passed correctly when the decoder
39 * correctly decodes this file:
40 * http://samples.mplayerhq.hu/V-codecs/SVQ3/Vertical400kbit.sorenson3.mov
45 #include "libavutil/attributes.h"
46 #include "libavutil/crc.h"
50 #include "mpegutils.h"
56 #include "rectangle.h"
70 typedef struct SVQ3Frame {
73 int16_t (*motion_val_buf[2])[2];
74 int16_t (*motion_val[2])[2];
76 uint32_t *mb_type_buf, *mb_type;
79 typedef struct SVQ3Context {
80 AVCodecContext *avctx;
82 H264DSPContext h264dsp;
92 GetBitContext gb_slice;
98 uint32_t watermark_key;
102 int next_p_frame_damaged;
105 int last_frame_output;
110 int frame_num_offset;
111 int prev_frame_num_offset;
114 enum AVPictureType pict_type;
115 enum AVPictureType slice_type;
120 int mb_width, mb_height;
121 int mb_stride, mb_num;
126 int chroma_pred_mode;
127 int intra16x16_pred_mode;
129 int8_t intra4x4_pred_mode_cache[5 * 8];
130 int8_t (*intra4x4_pred_mode);
132 unsigned int top_samples_available;
133 unsigned int topright_samples_available;
134 unsigned int left_samples_available;
136 uint8_t *edge_emu_buffer;
138 DECLARE_ALIGNED(16, int16_t, mv_cache)[2][5 * 8][2];
139 DECLARE_ALIGNED(8, int8_t, ref_cache)[2][5 * 8];
140 DECLARE_ALIGNED(16, int16_t, mb)[16 * 48 * 2];
141 DECLARE_ALIGNED(16, int16_t, mb_luma_dc)[3][16 * 2];
142 DECLARE_ALIGNED(8, uint8_t, non_zero_count_cache)[15 * 8];
143 uint32_t dequant4_coeff[QP_MAX_NUM + 1][16];
144 int block_offset[2 * (16 * 3)];
148 #define FULLPEL_MODE 1
149 #define HALFPEL_MODE 2
150 #define THIRDPEL_MODE 3
151 #define PREDICT_MODE 4
153 /* dual scan (from some older H.264 draft)
162 static const uint8_t svq3_scan[16] = {
163 0 + 0 * 4, 1 + 0 * 4, 2 + 0 * 4, 2 + 1 * 4,
164 2 + 2 * 4, 3 + 0 * 4, 3 + 1 * 4, 3 + 2 * 4,
165 0 + 1 * 4, 0 + 2 * 4, 1 + 1 * 4, 1 + 2 * 4,
166 0 + 3 * 4, 1 + 3 * 4, 2 + 3 * 4, 3 + 3 * 4,
169 static const uint8_t luma_dc_zigzag_scan[16] = {
170 0 * 16 + 0 * 64, 1 * 16 + 0 * 64, 2 * 16 + 0 * 64, 0 * 16 + 2 * 64,
171 3 * 16 + 0 * 64, 0 * 16 + 1 * 64, 1 * 16 + 1 * 64, 2 * 16 + 1 * 64,
172 1 * 16 + 2 * 64, 2 * 16 + 2 * 64, 3 * 16 + 2 * 64, 0 * 16 + 3 * 64,
173 3 * 16 + 1 * 64, 1 * 16 + 3 * 64, 2 * 16 + 3 * 64, 3 * 16 + 3 * 64,
176 static const uint8_t svq3_pred_0[25][2] = {
179 { 0, 2 }, { 1, 1 }, { 2, 0 },
180 { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
181 { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
182 { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
183 { 2, 4 }, { 3, 3 }, { 4, 2 },
188 static const int8_t svq3_pred_1[6][6][5] = {
189 { { 2, -1, -1, -1, -1 }, { 2, 1, -1, -1, -1 }, { 1, 2, -1, -1, -1 },
190 { 2, 1, -1, -1, -1 }, { 1, 2, -1, -1, -1 }, { 1, 2, -1, -1, -1 } },
191 { { 0, 2, -1, -1, -1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
192 { 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
193 { { 2, 0, -1, -1, -1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
194 { 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
195 { { 2, 0, -1, -1, -1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
196 { 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
197 { { 0, 2, -1, -1, -1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
198 { 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
199 { { 0, 2, -1, -1, -1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
200 { 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
203 static const struct {
206 } svq3_dct_tables[2][16] = {
207 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
208 { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
209 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
210 { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
213 static const uint32_t svq3_dequant_coeff[32] = {
214 3881, 4351, 4890, 5481, 6154, 6914, 7761, 8718,
215 9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
216 24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
217 61694, 68745, 77615, 89113, 100253, 109366, 126635, 141533
220 static void svq3_luma_dc_dequant_idct_c(int16_t *output, int16_t *input, int qp)
222 const unsigned qmul = svq3_dequant_coeff[qp];
226 static const uint8_t x_offset[4] = { 0, 1 * stride, 4 * stride, 5 * stride };
228 for (i = 0; i < 4; i++) {
229 const int z0 = 13 * (input[4 * i + 0] + input[4 * i + 2]);
230 const int z1 = 13 * (input[4 * i + 0] - input[4 * i + 2]);
231 const int z2 = 7 * input[4 * i + 1] - 17 * input[4 * i + 3];
232 const int z3 = 17 * input[4 * i + 1] + 7 * input[4 * i + 3];
234 temp[4 * i + 0] = z0 + z3;
235 temp[4 * i + 1] = z1 + z2;
236 temp[4 * i + 2] = z1 - z2;
237 temp[4 * i + 3] = z0 - z3;
240 for (i = 0; i < 4; i++) {
241 const int offset = x_offset[i];
242 const int z0 = 13 * (temp[4 * 0 + i] + temp[4 * 2 + i]);
243 const int z1 = 13 * (temp[4 * 0 + i] - temp[4 * 2 + i]);
244 const int z2 = 7 * temp[4 * 1 + i] - 17 * temp[4 * 3 + i];
245 const int z3 = 17 * temp[4 * 1 + i] + 7 * temp[4 * 3 + i];
247 output[stride * 0 + offset] = (int)((z0 + z3) * qmul + 0x80000) >> 20;
248 output[stride * 2 + offset] = (int)((z1 + z2) * qmul + 0x80000) >> 20;
249 output[stride * 8 + offset] = (int)((z1 - z2) * qmul + 0x80000) >> 20;
250 output[stride * 10 + offset] = (int)((z0 - z3) * qmul + 0x80000) >> 20;
255 static void svq3_add_idct_c(uint8_t *dst, int16_t *block,
256 int stride, int qp, int dc)
258 const int qmul = svq3_dequant_coeff[qp];
262 dc = 13 * 13 * (dc == 1 ? 1538U* block[0]
263 : qmul * (block[0] >> 3) / 2);
267 for (i = 0; i < 4; i++) {
268 const int z0 = 13 * (block[0 + 4 * i] + block[2 + 4 * i]);
269 const int z1 = 13 * (block[0 + 4 * i] - block[2 + 4 * i]);
270 const int z2 = 7 * block[1 + 4 * i] - 17 * block[3 + 4 * i];
271 const int z3 = 17 * block[1 + 4 * i] + 7 * block[3 + 4 * i];
273 block[0 + 4 * i] = z0 + z3;
274 block[1 + 4 * i] = z1 + z2;
275 block[2 + 4 * i] = z1 - z2;
276 block[3 + 4 * i] = z0 - z3;
279 for (i = 0; i < 4; i++) {
280 const unsigned z0 = 13 * (block[i + 4 * 0] + block[i + 4 * 2]);
281 const unsigned z1 = 13 * (block[i + 4 * 0] - block[i + 4 * 2]);
282 const unsigned z2 = 7 * block[i + 4 * 1] - 17 * block[i + 4 * 3];
283 const unsigned z3 = 17 * block[i + 4 * 1] + 7 * block[i + 4 * 3];
284 const int rr = (dc + 0x80000u);
286 dst[i + stride * 0] = av_clip_uint8(dst[i + stride * 0] + ((int)((z0 + z3) * qmul + rr) >> 20));
287 dst[i + stride * 1] = av_clip_uint8(dst[i + stride * 1] + ((int)((z1 + z2) * qmul + rr) >> 20));
288 dst[i + stride * 2] = av_clip_uint8(dst[i + stride * 2] + ((int)((z1 - z2) * qmul + rr) >> 20));
289 dst[i + stride * 3] = av_clip_uint8(dst[i + stride * 3] + ((int)((z0 - z3) * qmul + rr) >> 20));
292 memset(block, 0, 16 * sizeof(int16_t));
295 static inline int svq3_decode_block(GetBitContext *gb, int16_t *block,
296 int index, const int type)
298 static const uint8_t *const scan_patterns[4] = {
299 luma_dc_zigzag_scan, ff_zigzag_scan, svq3_scan, ff_h264_chroma_dc_scan
302 int run, level, sign, limit;
304 const int intra = 3 * type >> 2;
305 const uint8_t *const scan = scan_patterns[type];
307 for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
308 for (; (vlc = get_interleaved_ue_golomb(gb)) != 0; index++) {
309 if ((int32_t)vlc < 0)
312 sign = (vlc & 1) ? 0 : -1;
319 } else if (vlc < 4) {
324 level = (vlc + 9 >> 2) - run;
328 run = svq3_dct_tables[intra][vlc].run;
329 level = svq3_dct_tables[intra][vlc].level;
332 level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
335 level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
340 if ((index += run) >= limit)
343 block[scan[index]] = (level ^ sign) - sign;
354 static av_always_inline int
355 svq3_fetch_diagonal_mv(const SVQ3Context *s, const int16_t **C,
356 int i, int list, int part_width)
358 const int topright_ref = s->ref_cache[list][i - 8 + part_width];
360 if (topright_ref != PART_NOT_AVAILABLE) {
361 *C = s->mv_cache[list][i - 8 + part_width];
364 *C = s->mv_cache[list][i - 8 - 1];
365 return s->ref_cache[list][i - 8 - 1];
370 * Get the predicted MV.
371 * @param n the block index
372 * @param part_width the width of the partition (4, 8,16) -> (1, 2, 4)
373 * @param mx the x component of the predicted motion vector
374 * @param my the y component of the predicted motion vector
376 static av_always_inline void svq3_pred_motion(const SVQ3Context *s, int n,
377 int part_width, int list,
378 int ref, int *const mx, int *const my)
380 const int index8 = scan8[n];
381 const int top_ref = s->ref_cache[list][index8 - 8];
382 const int left_ref = s->ref_cache[list][index8 - 1];
383 const int16_t *const A = s->mv_cache[list][index8 - 1];
384 const int16_t *const B = s->mv_cache[list][index8 - 8];
386 int diagonal_ref, match_count;
396 diagonal_ref = svq3_fetch_diagonal_mv(s, &C, index8, list, part_width);
397 match_count = (diagonal_ref == ref) + (top_ref == ref) + (left_ref == ref);
398 if (match_count > 1) { //most common
399 *mx = mid_pred(A[0], B[0], C[0]);
400 *my = mid_pred(A[1], B[1], C[1]);
401 } else if (match_count == 1) {
402 if (left_ref == ref) {
405 } else if (top_ref == ref) {
413 if (top_ref == PART_NOT_AVAILABLE &&
414 diagonal_ref == PART_NOT_AVAILABLE &&
415 left_ref != PART_NOT_AVAILABLE) {
419 *mx = mid_pred(A[0], B[0], C[0]);
420 *my = mid_pred(A[1], B[1], C[1]);
425 static inline void svq3_mc_dir_part(SVQ3Context *s,
426 int x, int y, int width, int height,
427 int mx, int my, int dxy,
428 int thirdpel, int dir, int avg)
430 const SVQ3Frame *pic = (dir == 0) ? s->last_pic : s->next_pic;
433 int blocksize = 2 - (width >> 3); // 16->0, 8->1, 4->2
434 int linesize = s->cur_pic->f->linesize[0];
435 int uvlinesize = s->cur_pic->f->linesize[1];
440 if (mx < 0 || mx >= s->h_edge_pos - width - 1 ||
441 my < 0 || my >= s->v_edge_pos - height - 1) {
443 mx = av_clip(mx, -16, s->h_edge_pos - width + 15);
444 my = av_clip(my, -16, s->v_edge_pos - height + 15);
447 /* form component predictions */
448 dest = s->cur_pic->f->data[0] + x + y * linesize;
449 src = pic->f->data[0] + mx + my * linesize;
452 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src,
454 width + 1, height + 1,
455 mx, my, s->h_edge_pos, s->v_edge_pos);
456 src = s->edge_emu_buffer;
459 (avg ? s->tdsp.avg_tpel_pixels_tab
460 : s->tdsp.put_tpel_pixels_tab)[dxy](dest, src, linesize,
463 (avg ? s->hdsp.avg_pixels_tab
464 : s->hdsp.put_pixels_tab)[blocksize][dxy](dest, src, linesize,
467 if (!(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
468 mx = mx + (mx < (int) x) >> 1;
469 my = my + (my < (int) y) >> 1;
471 height = height >> 1;
474 for (i = 1; i < 3; i++) {
475 dest = s->cur_pic->f->data[i] + (x >> 1) + (y >> 1) * uvlinesize;
476 src = pic->f->data[i] + mx + my * uvlinesize;
479 s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src,
480 uvlinesize, uvlinesize,
481 width + 1, height + 1,
482 mx, my, (s->h_edge_pos >> 1),
484 src = s->edge_emu_buffer;
487 (avg ? s->tdsp.avg_tpel_pixels_tab
488 : s->tdsp.put_tpel_pixels_tab)[dxy](dest, src,
492 (avg ? s->hdsp.avg_pixels_tab
493 : s->hdsp.put_pixels_tab)[blocksize][dxy](dest, src,
500 static inline int svq3_mc_dir(SVQ3Context *s, int size, int mode,
503 int i, j, k, mx, my, dx, dy, x, y;
504 const int part_width = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
505 const int part_height = 16 >> ((unsigned)(size + 1) / 3);
506 const int extra_width = (mode == PREDICT_MODE) ? -16 * 6 : 0;
507 const int h_edge_pos = 6 * (s->h_edge_pos - part_width) - extra_width;
508 const int v_edge_pos = 6 * (s->v_edge_pos - part_height) - extra_width;
510 for (i = 0; i < 16; i += part_height)
511 for (j = 0; j < 16; j += part_width) {
512 const int b_xy = (4 * s->mb_x + (j >> 2)) +
513 (4 * s->mb_y + (i >> 2)) * s->b_stride;
515 x = 16 * s->mb_x + j;
516 y = 16 * s->mb_y + i;
517 k = (j >> 2 & 1) + (i >> 1 & 2) +
518 (j >> 1 & 4) + (i & 8);
520 if (mode != PREDICT_MODE) {
521 svq3_pred_motion(s, k, part_width >> 2, dir, 1, &mx, &my);
523 mx = s->next_pic->motion_val[0][b_xy][0] * 2;
524 my = s->next_pic->motion_val[0][b_xy][1] * 2;
527 mx = mx * s->frame_num_offset /
528 s->prev_frame_num_offset + 1 >> 1;
529 my = my * s->frame_num_offset /
530 s->prev_frame_num_offset + 1 >> 1;
532 mx = mx * (s->frame_num_offset - s->prev_frame_num_offset) /
533 s->prev_frame_num_offset + 1 >> 1;
534 my = my * (s->frame_num_offset - s->prev_frame_num_offset) /
535 s->prev_frame_num_offset + 1 >> 1;
539 /* clip motion vector prediction to frame border */
540 mx = av_clip(mx, extra_width - 6 * x, h_edge_pos - 6 * x);
541 my = av_clip(my, extra_width - 6 * y, v_edge_pos - 6 * y);
543 /* get (optional) motion vector differential */
544 if (mode == PREDICT_MODE) {
547 dy = get_interleaved_se_golomb(&s->gb_slice);
548 dx = get_interleaved_se_golomb(&s->gb_slice);
550 if (dx != (int16_t)dx || dy != (int16_t)dy) {
551 av_log(s->avctx, AV_LOG_ERROR, "invalid MV vlc\n");
556 /* compute motion vector */
557 if (mode == THIRDPEL_MODE) {
559 mx = (mx + 1 >> 1) + dx;
560 my = (my + 1 >> 1) + dy;
561 fx = (unsigned)(mx + 0x30000) / 3 - 0x10000;
562 fy = (unsigned)(my + 0x30000) / 3 - 0x10000;
563 dxy = (mx - 3 * fx) + 4 * (my - 3 * fy);
565 svq3_mc_dir_part(s, x, y, part_width, part_height,
566 fx, fy, dxy, 1, dir, avg);
569 } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
570 mx = (unsigned)(mx + 1 + 0x30000) / 3 + dx - 0x10000;
571 my = (unsigned)(my + 1 + 0x30000) / 3 + dy - 0x10000;
572 dxy = (mx & 1) + 2 * (my & 1);
574 svq3_mc_dir_part(s, x, y, part_width, part_height,
575 mx >> 1, my >> 1, dxy, 0, dir, avg);
579 mx = (unsigned)(mx + 3 + 0x60000) / 6 + dx - 0x10000;
580 my = (unsigned)(my + 3 + 0x60000) / 6 + dy - 0x10000;
582 svq3_mc_dir_part(s, x, y, part_width, part_height,
583 mx, my, 0, 0, dir, avg);
588 /* update mv_cache */
589 if (mode != PREDICT_MODE) {
590 int32_t mv = pack16to32(mx, my);
592 if (part_height == 8 && i < 8) {
593 AV_WN32A(s->mv_cache[dir][scan8[k] + 1 * 8], mv);
595 if (part_width == 8 && j < 8)
596 AV_WN32A(s->mv_cache[dir][scan8[k] + 1 + 1 * 8], mv);
598 if (part_width == 8 && j < 8)
599 AV_WN32A(s->mv_cache[dir][scan8[k] + 1], mv);
600 if (part_width == 4 || part_height == 4)
601 AV_WN32A(s->mv_cache[dir][scan8[k]], mv);
604 /* write back motion vectors */
605 fill_rectangle(s->cur_pic->motion_val[dir][b_xy],
606 part_width >> 2, part_height >> 2, s->b_stride,
607 pack16to32(mx, my), 4);
613 static av_always_inline void hl_decode_mb_idct_luma(SVQ3Context *s,
614 int mb_type, const int *block_offset,
615 int linesize, uint8_t *dest_y)
618 if (!IS_INTRA4x4(mb_type)) {
619 for (i = 0; i < 16; i++)
620 if (s->non_zero_count_cache[scan8[i]] || s->mb[i * 16]) {
621 uint8_t *const ptr = dest_y + block_offset[i];
622 svq3_add_idct_c(ptr, s->mb + i * 16, linesize,
623 s->qscale, IS_INTRA(mb_type) ? 1 : 0);
628 static av_always_inline void hl_decode_mb_predict_luma(SVQ3Context *s,
630 const int *block_offset,
635 int qscale = s->qscale;
637 if (IS_INTRA4x4(mb_type)) {
638 for (i = 0; i < 16; i++) {
639 uint8_t *const ptr = dest_y + block_offset[i];
640 const int dir = s->intra4x4_pred_mode_cache[scan8[i]];
644 if (dir == DIAG_DOWN_LEFT_PRED || dir == VERT_LEFT_PRED) {
645 const int topright_avail = (s->topright_samples_available << i) & 0x8000;
646 av_assert2(s->mb_y || linesize <= block_offset[i]);
647 if (!topright_avail) {
648 tr = ptr[3 - linesize] * 0x01010101u;
649 topright = (uint8_t *)&tr;
651 topright = ptr + 4 - linesize;
655 s->hpc.pred4x4[dir](ptr, topright, linesize);
656 nnz = s->non_zero_count_cache[scan8[i]];
658 svq3_add_idct_c(ptr, s->mb + i * 16, linesize, qscale, 0);
662 s->hpc.pred16x16[s->intra16x16_pred_mode](dest_y, linesize);
663 svq3_luma_dc_dequant_idct_c(s->mb, s->mb_luma_dc[0], qscale);
667 static void hl_decode_mb(SVQ3Context *s)
669 const int mb_x = s->mb_x;
670 const int mb_y = s->mb_y;
671 const int mb_xy = s->mb_xy;
672 const int mb_type = s->cur_pic->mb_type[mb_xy];
673 uint8_t *dest_y, *dest_cb, *dest_cr;
674 int linesize, uvlinesize;
676 const int *block_offset = &s->block_offset[0];
677 const int block_h = 16 >> 1;
679 linesize = s->cur_pic->f->linesize[0];
680 uvlinesize = s->cur_pic->f->linesize[1];
682 dest_y = s->cur_pic->f->data[0] + (mb_x + mb_y * linesize) * 16;
683 dest_cb = s->cur_pic->f->data[1] + mb_x * 8 + mb_y * uvlinesize * block_h;
684 dest_cr = s->cur_pic->f->data[2] + mb_x * 8 + mb_y * uvlinesize * block_h;
686 s->vdsp.prefetch(dest_y + (s->mb_x & 3) * 4 * linesize + 64, linesize, 4);
687 s->vdsp.prefetch(dest_cb + (s->mb_x & 7) * uvlinesize + 64, dest_cr - dest_cb, 2);
689 if (IS_INTRA(mb_type)) {
690 s->hpc.pred8x8[s->chroma_pred_mode](dest_cb, uvlinesize);
691 s->hpc.pred8x8[s->chroma_pred_mode](dest_cr, uvlinesize);
693 hl_decode_mb_predict_luma(s, mb_type, block_offset, linesize, dest_y);
696 hl_decode_mb_idct_luma(s, mb_type, block_offset, linesize, dest_y);
699 uint8_t *dest[2] = { dest_cb, dest_cr };
700 s->h264dsp.h264_chroma_dc_dequant_idct(s->mb + 16 * 16 * 1,
701 s->dequant4_coeff[4][0]);
702 s->h264dsp.h264_chroma_dc_dequant_idct(s->mb + 16 * 16 * 2,
703 s->dequant4_coeff[4][0]);
704 for (j = 1; j < 3; j++) {
705 for (i = j * 16; i < j * 16 + 4; i++)
706 if (s->non_zero_count_cache[scan8[i]] || s->mb[i * 16]) {
707 uint8_t *const ptr = dest[j - 1] + block_offset[i];
708 svq3_add_idct_c(ptr, s->mb + i * 16,
709 uvlinesize, ff_h264_chroma_qp[0][s->qscale + 12] - 12, 2);
715 static int svq3_decode_mb(SVQ3Context *s, unsigned int mb_type)
717 int i, j, k, m, dir, mode;
721 const int mb_xy = s->mb_xy;
722 const int b_xy = 4 * s->mb_x + 4 * s->mb_y * s->b_stride;
724 s->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
725 s->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
726 s->topright_samples_available = 0xFFFF;
728 if (mb_type == 0) { /* SKIP */
729 if (s->pict_type == AV_PICTURE_TYPE_P ||
730 s->next_pic->mb_type[mb_xy] == -1) {
731 svq3_mc_dir_part(s, 16 * s->mb_x, 16 * s->mb_y, 16, 16,
734 if (s->pict_type == AV_PICTURE_TYPE_B)
735 svq3_mc_dir_part(s, 16 * s->mb_x, 16 * s->mb_y, 16, 16,
738 mb_type = MB_TYPE_SKIP;
740 mb_type = FFMIN(s->next_pic->mb_type[mb_xy], 6);
741 if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 0, 0) < 0)
743 if (svq3_mc_dir(s, mb_type, PREDICT_MODE, 1, 1) < 0)
746 mb_type = MB_TYPE_16x16;
748 } else if (mb_type < 8) { /* INTER */
749 if (s->thirdpel_flag && s->halfpel_flag == !get_bits1(&s->gb_slice))
750 mode = THIRDPEL_MODE;
751 else if (s->halfpel_flag &&
752 s->thirdpel_flag == !get_bits1(&s->gb_slice))
758 /* note ref_cache should contain here:
766 for (m = 0; m < 2; m++) {
767 if (s->mb_x > 0 && s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - 1] + 6] != -1) {
768 for (i = 0; i < 4; i++)
769 AV_COPY32(s->mv_cache[m][scan8[0] - 1 + i * 8],
770 s->cur_pic->motion_val[m][b_xy - 1 + i * s->b_stride]);
772 for (i = 0; i < 4; i++)
773 AV_ZERO32(s->mv_cache[m][scan8[0] - 1 + i * 8]);
776 memcpy(s->mv_cache[m][scan8[0] - 1 * 8],
777 s->cur_pic->motion_val[m][b_xy - s->b_stride],
778 4 * 2 * sizeof(int16_t));
779 memset(&s->ref_cache[m][scan8[0] - 1 * 8],
780 (s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1, 4);
782 if (s->mb_x < s->mb_width - 1) {
783 AV_COPY32(s->mv_cache[m][scan8[0] + 4 - 1 * 8],
784 s->cur_pic->motion_val[m][b_xy - s->b_stride + 4]);
785 s->ref_cache[m][scan8[0] + 4 - 1 * 8] =
786 (s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride + 1] + 6] == -1 ||
787 s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1;
789 s->ref_cache[m][scan8[0] + 4 - 1 * 8] = PART_NOT_AVAILABLE;
791 AV_COPY32(s->mv_cache[m][scan8[0] - 1 - 1 * 8],
792 s->cur_pic->motion_val[m][b_xy - s->b_stride - 1]);
793 s->ref_cache[m][scan8[0] - 1 - 1 * 8] =
794 (s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride - 1] + 3] == -1) ? PART_NOT_AVAILABLE : 1;
796 s->ref_cache[m][scan8[0] - 1 - 1 * 8] = PART_NOT_AVAILABLE;
798 memset(&s->ref_cache[m][scan8[0] - 1 * 8 - 1],
799 PART_NOT_AVAILABLE, 8);
801 if (s->pict_type != AV_PICTURE_TYPE_B)
805 /* decode motion vector(s) and form prediction(s) */
806 if (s->pict_type == AV_PICTURE_TYPE_P) {
807 if (svq3_mc_dir(s, mb_type - 1, mode, 0, 0) < 0)
809 } else { /* AV_PICTURE_TYPE_B */
811 if (svq3_mc_dir(s, 0, mode, 0, 0) < 0)
814 for (i = 0; i < 4; i++)
815 memset(s->cur_pic->motion_val[0][b_xy + i * s->b_stride],
816 0, 4 * 2 * sizeof(int16_t));
819 if (svq3_mc_dir(s, 0, mode, 1, mb_type == 3) < 0)
822 for (i = 0; i < 4; i++)
823 memset(s->cur_pic->motion_val[1][b_xy + i * s->b_stride],
824 0, 4 * 2 * sizeof(int16_t));
828 mb_type = MB_TYPE_16x16;
829 } else if (mb_type == 8 || mb_type == 33) { /* INTRA4x4 */
830 int8_t *i4x4 = s->intra4x4_pred_mode + s->mb2br_xy[s->mb_xy];
831 int8_t *i4x4_cache = s->intra4x4_pred_mode_cache;
833 memset(s->intra4x4_pred_mode_cache, -1, 8 * 5 * sizeof(int8_t));
837 for (i = 0; i < 4; i++)
838 s->intra4x4_pred_mode_cache[scan8[0] - 1 + i * 8] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - 1] + 6 - i];
839 if (s->intra4x4_pred_mode_cache[scan8[0] - 1] == -1)
840 s->left_samples_available = 0x5F5F;
843 s->intra4x4_pred_mode_cache[4 + 8 * 0] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride] + 0];
844 s->intra4x4_pred_mode_cache[5 + 8 * 0] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride] + 1];
845 s->intra4x4_pred_mode_cache[6 + 8 * 0] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride] + 2];
846 s->intra4x4_pred_mode_cache[7 + 8 * 0] = s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride] + 3];
848 if (s->intra4x4_pred_mode_cache[4 + 8 * 0] == -1)
849 s->top_samples_available = 0x33FF;
852 /* decode prediction codes for luma blocks */
853 for (i = 0; i < 16; i += 2) {
854 vlc = get_interleaved_ue_golomb(&s->gb_slice);
857 av_log(s->avctx, AV_LOG_ERROR,
858 "luma prediction:%"PRIu32"\n", vlc);
862 left = &s->intra4x4_pred_mode_cache[scan8[i] - 1];
863 top = &s->intra4x4_pred_mode_cache[scan8[i] - 8];
865 left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
866 left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
868 if (left[1] == -1 || left[2] == -1) {
869 av_log(s->avctx, AV_LOG_ERROR, "weird prediction\n");
873 } else { /* mb_type == 33, DC_128_PRED block type */
874 for (i = 0; i < 4; i++)
875 memset(&s->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_PRED, 4);
878 AV_COPY32(i4x4, i4x4_cache + 4 + 8 * 4);
879 i4x4[4] = i4x4_cache[7 + 8 * 3];
880 i4x4[5] = i4x4_cache[7 + 8 * 2];
881 i4x4[6] = i4x4_cache[7 + 8 * 1];
884 ff_h264_check_intra4x4_pred_mode(s->intra4x4_pred_mode_cache,
885 s->avctx, s->top_samples_available,
886 s->left_samples_available);
888 s->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
889 s->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
891 for (i = 0; i < 4; i++)
892 memset(&s->intra4x4_pred_mode_cache[scan8[0] + 8 * i], DC_128_PRED, 4);
894 s->top_samples_available = 0x33FF;
895 s->left_samples_available = 0x5F5F;
898 mb_type = MB_TYPE_INTRA4x4;
899 } else { /* INTRA16x16 */
900 dir = ff_h264_i_mb_type_info[mb_type - 8].pred_mode;
901 dir = (dir >> 1) ^ 3 * (dir & 1) ^ 1;
903 if ((s->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(s->avctx, s->top_samples_available,
904 s->left_samples_available, dir, 0)) < 0) {
905 av_log(s->avctx, AV_LOG_ERROR, "ff_h264_check_intra_pred_mode < 0\n");
906 return s->intra16x16_pred_mode;
909 cbp = ff_h264_i_mb_type_info[mb_type - 8].cbp;
910 mb_type = MB_TYPE_INTRA16x16;
913 if (!IS_INTER(mb_type) && s->pict_type != AV_PICTURE_TYPE_I) {
914 for (i = 0; i < 4; i++)
915 memset(s->cur_pic->motion_val[0][b_xy + i * s->b_stride],
916 0, 4 * 2 * sizeof(int16_t));
917 if (s->pict_type == AV_PICTURE_TYPE_B) {
918 for (i = 0; i < 4; i++)
919 memset(s->cur_pic->motion_val[1][b_xy + i * s->b_stride],
920 0, 4 * 2 * sizeof(int16_t));
923 if (!IS_INTRA4x4(mb_type)) {
924 memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy], DC_PRED, 8);
926 if (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B) {
927 memset(s->non_zero_count_cache + 8, 0, 14 * 8 * sizeof(uint8_t));
930 if (!IS_INTRA16x16(mb_type) &&
931 (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B)) {
932 if ((vlc = get_interleaved_ue_golomb(&s->gb_slice)) >= 48U){
933 av_log(s->avctx, AV_LOG_ERROR, "cbp_vlc=%"PRIu32"\n", vlc);
937 cbp = IS_INTRA(mb_type) ? ff_h264_golomb_to_intra4x4_cbp[vlc]
938 : ff_h264_golomb_to_inter_cbp[vlc];
940 if (IS_INTRA16x16(mb_type) ||
941 (s->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
942 s->qscale += get_interleaved_se_golomb(&s->gb_slice);
944 if (s->qscale > 31u) {
945 av_log(s->avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
949 if (IS_INTRA16x16(mb_type)) {
950 AV_ZERO128(s->mb_luma_dc[0] + 0);
951 AV_ZERO128(s->mb_luma_dc[0] + 8);
952 if (svq3_decode_block(&s->gb_slice, s->mb_luma_dc[0], 0, 1)) {
953 av_log(s->avctx, AV_LOG_ERROR,
954 "error while decoding intra luma dc\n");
960 const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
961 const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
963 for (i = 0; i < 4; i++)
964 if ((cbp & (1 << i))) {
965 for (j = 0; j < 4; j++) {
966 k = index ? (1 * (j & 1) + 2 * (i & 1) +
967 2 * (j & 2) + 4 * (i & 2))
969 s->non_zero_count_cache[scan8[k]] = 1;
971 if (svq3_decode_block(&s->gb_slice, &s->mb[16 * k], index, type)) {
972 av_log(s->avctx, AV_LOG_ERROR,
973 "error while decoding block\n");
980 for (i = 1; i < 3; ++i)
981 if (svq3_decode_block(&s->gb_slice, &s->mb[16 * 16 * i], 0, 3)) {
982 av_log(s->avctx, AV_LOG_ERROR,
983 "error while decoding chroma dc block\n");
988 for (i = 1; i < 3; i++) {
989 for (j = 0; j < 4; j++) {
991 s->non_zero_count_cache[scan8[k]] = 1;
993 if (svq3_decode_block(&s->gb_slice, &s->mb[16 * k], 1, 1)) {
994 av_log(s->avctx, AV_LOG_ERROR,
995 "error while decoding chroma ac block\n");
1005 s->cur_pic->mb_type[mb_xy] = mb_type;
1007 if (IS_INTRA(mb_type))
1008 s->chroma_pred_mode = ff_h264_check_intra_pred_mode(s->avctx, s->top_samples_available,
1009 s->left_samples_available, DC_PRED8x8, 1);
1014 static int svq3_decode_slice_header(AVCodecContext *avctx)
1016 SVQ3Context *s = avctx->priv_data;
1017 const int mb_xy = s->mb_xy;
1021 header = get_bits(&s->gb, 8);
1023 if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
1025 av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
1028 int slice_bits, slice_bytes, slice_length;
1029 int length = header >> 5 & 3;
1031 slice_length = show_bits(&s->gb, 8 * length);
1032 slice_bits = slice_length * 8;
1033 slice_bytes = slice_length + length - 1;
1035 skip_bits(&s->gb, 8);
1037 av_fast_malloc(&s->slice_buf, &s->slice_size, slice_bytes + AV_INPUT_BUFFER_PADDING_SIZE);
1039 return AVERROR(ENOMEM);
1041 if (slice_bytes * 8LL > get_bits_left(&s->gb)) {
1042 av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
1043 return AVERROR_INVALIDDATA;
1045 memcpy(s->slice_buf, s->gb.buffer + s->gb.index / 8, slice_bytes);
1047 if (s->watermark_key) {
1048 uint32_t header = AV_RL32(&s->slice_buf[1]);
1049 AV_WL32(&s->slice_buf[1], header ^ s->watermark_key);
1051 init_get_bits(&s->gb_slice, s->slice_buf, slice_bits);
1054 memmove(s->slice_buf, &s->slice_buf[slice_length], length - 1);
1056 skip_bits_long(&s->gb, slice_bytes * 8);
1059 if ((slice_id = get_interleaved_ue_golomb(&s->gb_slice)) >= 3) {
1060 av_log(s->avctx, AV_LOG_ERROR, "illegal slice type %u \n", slice_id);
1064 s->slice_type = ff_h264_golomb_to_pict_type[slice_id];
1066 if ((header & 0x9F) == 2) {
1067 i = (s->mb_num < 64) ? 6 : (1 + av_log2(s->mb_num - 1));
1068 get_bits(&s->gb_slice, i);
1069 } else if (get_bits1(&s->gb_slice)) {
1070 avpriv_report_missing_feature(s->avctx, "Media key encryption");
1071 return AVERROR_PATCHWELCOME;
1074 s->slice_num = get_bits(&s->gb_slice, 8);
1075 s->qscale = get_bits(&s->gb_slice, 5);
1076 s->adaptive_quant = get_bits1(&s->gb_slice);
1078 /* unknown fields */
1079 skip_bits1(&s->gb_slice);
1081 if (s->has_watermark)
1082 skip_bits1(&s->gb_slice);
1084 skip_bits1(&s->gb_slice);
1085 skip_bits(&s->gb_slice, 2);
1087 if (skip_1stop_8data_bits(&s->gb_slice) < 0)
1088 return AVERROR_INVALIDDATA;
1090 /* reset intra predictors and invalidate motion vector references */
1092 memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy - 1] + 3,
1093 -1, 4 * sizeof(int8_t));
1094 memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy - s->mb_x],
1095 -1, 8 * sizeof(int8_t) * s->mb_x);
1098 memset(s->intra4x4_pred_mode + s->mb2br_xy[mb_xy - s->mb_stride],
1099 -1, 8 * sizeof(int8_t) * (s->mb_width - s->mb_x));
1102 s->intra4x4_pred_mode[s->mb2br_xy[mb_xy - s->mb_stride - 1] + 3] = -1;
1108 static void init_dequant4_coeff_table(SVQ3Context *s)
1111 const int max_qp = 51;
1113 for (q = 0; q < max_qp + 1; q++) {
1114 int shift = ff_h264_quant_div6[q] + 2;
1115 int idx = ff_h264_quant_rem6[q];
1116 for (x = 0; x < 16; x++)
1117 s->dequant4_coeff[q][(x >> 2) | ((x << 2) & 0xF)] =
1118 ((uint32_t)ff_h264_dequant4_coeff_init[idx][(x & 1) + ((x >> 2) & 1)] * 16) << shift;
1122 static av_cold int svq3_decode_init(AVCodecContext *avctx)
1124 SVQ3Context *s = avctx->priv_data;
1126 unsigned char *extradata;
1127 unsigned char *extradata_end;
1129 int marker_found = 0;
1132 s->cur_pic = &s->frames[0];
1133 s->last_pic = &s->frames[1];
1134 s->next_pic = &s->frames[2];
1136 s->cur_pic->f = av_frame_alloc();
1137 s->last_pic->f = av_frame_alloc();
1138 s->next_pic->f = av_frame_alloc();
1139 if (!s->cur_pic->f || !s->last_pic->f || !s->next_pic->f)
1140 return AVERROR(ENOMEM);
1142 ff_h264dsp_init(&s->h264dsp, 8, 1);
1143 ff_h264_pred_init(&s->hpc, AV_CODEC_ID_SVQ3, 8, 1);
1144 ff_videodsp_init(&s->vdsp, 8);
1147 avctx->bits_per_raw_sample = 8;
1149 ff_hpeldsp_init(&s->hdsp, avctx->flags);
1150 ff_tpeldsp_init(&s->tdsp);
1152 avctx->pix_fmt = AV_PIX_FMT_YUVJ420P;
1153 avctx->color_range = AVCOL_RANGE_JPEG;
1156 s->halfpel_flag = 1;
1157 s->thirdpel_flag = 1;
1158 s->has_watermark = 0;
1160 /* prowl for the "SEQH" marker in the extradata */
1161 extradata = (unsigned char *)avctx->extradata;
1162 extradata_end = avctx->extradata + avctx->extradata_size;
1164 for (m = 0; m + 8 < avctx->extradata_size; m++) {
1165 if (!memcmp(extradata, "SEQH", 4)) {
1173 /* if a match was found, parse the extra data */
1176 int frame_size_code;
1177 int unk0, unk1, unk2, unk3, unk4;
1180 size = AV_RB32(&extradata[4]);
1181 if (size > extradata_end - extradata - 8)
1182 return AVERROR_INVALIDDATA;
1183 init_get_bits(&gb, extradata + 8, size * 8);
1185 /* 'frame size code' and optional 'width, height' */
1186 frame_size_code = get_bits(&gb, 3);
1187 switch (frame_size_code) {
1217 w = get_bits(&gb, 12);
1218 h = get_bits(&gb, 12);
1221 ret = ff_set_dimensions(avctx, w, h);
1225 s->halfpel_flag = get_bits1(&gb);
1226 s->thirdpel_flag = get_bits1(&gb);
1228 /* unknown fields */
1229 unk0 = get_bits1(&gb);
1230 unk1 = get_bits1(&gb);
1231 unk2 = get_bits1(&gb);
1232 unk3 = get_bits1(&gb);
1234 s->low_delay = get_bits1(&gb);
1237 unk4 = get_bits1(&gb);
1239 av_log(avctx, AV_LOG_DEBUG, "Unknown fields %d %d %d %d %d\n",
1240 unk0, unk1, unk2, unk3, unk4);
1242 if (skip_1stop_8data_bits(&gb) < 0)
1243 return AVERROR_INVALIDDATA;
1245 s->has_watermark = get_bits1(&gb);
1246 avctx->has_b_frames = !s->low_delay;
1247 if (s->has_watermark) {
1249 unsigned watermark_width = get_interleaved_ue_golomb(&gb);
1250 unsigned watermark_height = get_interleaved_ue_golomb(&gb);
1251 int u1 = get_interleaved_ue_golomb(&gb);
1252 int u2 = get_bits(&gb, 8);
1253 int u3 = get_bits(&gb, 2);
1254 int u4 = get_interleaved_ue_golomb(&gb);
1255 unsigned long buf_len = watermark_width *
1256 watermark_height * 4;
1257 int offset = get_bits_count(&gb) + 7 >> 3;
1260 if (watermark_height <= 0 ||
1261 (uint64_t)watermark_width * 4 > UINT_MAX / watermark_height)
1262 return AVERROR_INVALIDDATA;
1264 buf = av_malloc(buf_len);
1266 return AVERROR(ENOMEM);
1268 av_log(avctx, AV_LOG_DEBUG, "watermark size: %ux%u\n",
1269 watermark_width, watermark_height);
1270 av_log(avctx, AV_LOG_DEBUG,
1271 "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n",
1272 u1, u2, u3, u4, offset);
1273 if (uncompress(buf, &buf_len, extradata + 8 + offset,
1274 size - offset) != Z_OK) {
1275 av_log(avctx, AV_LOG_ERROR,
1276 "could not uncompress watermark logo\n");
1280 s->watermark_key = av_bswap16(av_crc(av_crc_get_table(AV_CRC_16_CCITT), 0, buf, buf_len));
1282 s->watermark_key = s->watermark_key << 16 | s->watermark_key;
1283 av_log(avctx, AV_LOG_DEBUG,
1284 "watermark key %#"PRIx32"\n", s->watermark_key);
1287 av_log(avctx, AV_LOG_ERROR,
1288 "this svq3 file contains watermark which need zlib support compiled in\n");
1289 return AVERROR(ENOSYS);
1294 s->mb_width = (avctx->width + 15) / 16;
1295 s->mb_height = (avctx->height + 15) / 16;
1296 s->mb_stride = s->mb_width + 1;
1297 s->mb_num = s->mb_width * s->mb_height;
1298 s->b_stride = 4 * s->mb_width;
1299 s->h_edge_pos = s->mb_width * 16;
1300 s->v_edge_pos = s->mb_height * 16;
1302 s->intra4x4_pred_mode = av_mallocz(s->mb_stride * 2 * 8);
1303 if (!s->intra4x4_pred_mode)
1304 return AVERROR(ENOMEM);
1306 s->mb2br_xy = av_mallocz(s->mb_stride * (s->mb_height + 1) *
1307 sizeof(*s->mb2br_xy));
1309 return AVERROR(ENOMEM);
1311 for (y = 0; y < s->mb_height; y++)
1312 for (x = 0; x < s->mb_width; x++) {
1313 const int mb_xy = x + y * s->mb_stride;
1315 s->mb2br_xy[mb_xy] = 8 * (mb_xy % (2 * s->mb_stride));
1318 init_dequant4_coeff_table(s);
1323 static void free_picture(AVCodecContext *avctx, SVQ3Frame *pic)
1326 for (i = 0; i < 2; i++) {
1327 av_freep(&pic->motion_val_buf[i]);
1329 av_freep(&pic->mb_type_buf);
1331 av_frame_unref(pic->f);
1334 static int get_buffer(AVCodecContext *avctx, SVQ3Frame *pic)
1336 SVQ3Context *s = avctx->priv_data;
1337 const int big_mb_num = s->mb_stride * (s->mb_height + 1) + 1;
1338 const int b4_stride = s->mb_width * 4 + 1;
1339 const int b4_array_size = b4_stride * s->mb_height * 4;
1342 if (!pic->motion_val_buf[0]) {
1345 pic->mb_type_buf = av_calloc(big_mb_num + s->mb_stride, sizeof(uint32_t));
1346 if (!pic->mb_type_buf)
1347 return AVERROR(ENOMEM);
1348 pic->mb_type = pic->mb_type_buf + 2 * s->mb_stride + 1;
1350 for (i = 0; i < 2; i++) {
1351 pic->motion_val_buf[i] = av_calloc(b4_array_size + 4, 2 * sizeof(int16_t));
1352 if (!pic->motion_val_buf[i]) {
1353 ret = AVERROR(ENOMEM);
1357 pic->motion_val[i] = pic->motion_val_buf[i] + 4;
1361 ret = ff_get_buffer(avctx, pic->f,
1362 (s->pict_type != AV_PICTURE_TYPE_B) ?
1363 AV_GET_BUFFER_FLAG_REF : 0);
1367 if (!s->edge_emu_buffer) {
1368 s->edge_emu_buffer = av_mallocz_array(pic->f->linesize[0], 17);
1369 if (!s->edge_emu_buffer)
1370 return AVERROR(ENOMEM);
1375 free_picture(avctx, pic);
1379 static int svq3_decode_frame(AVCodecContext *avctx, void *data,
1380 int *got_frame, AVPacket *avpkt)
1382 SVQ3Context *s = avctx->priv_data;
1383 int buf_size = avpkt->size;
1388 /* special case for last picture */
1389 if (buf_size == 0) {
1390 if (s->next_pic->f->data[0] && !s->low_delay && !s->last_frame_output) {
1391 ret = av_frame_ref(data, s->next_pic->f);
1394 s->last_frame_output = 1;
1400 s->mb_x = s->mb_y = s->mb_xy = 0;
1402 if (s->watermark_key) {
1403 av_fast_padded_malloc(&s->buf, &s->buf_size, buf_size);
1405 return AVERROR(ENOMEM);
1406 memcpy(s->buf, avpkt->data, buf_size);
1412 ret = init_get_bits(&s->gb, buf, 8 * buf_size);
1416 if (svq3_decode_slice_header(avctx))
1419 s->pict_type = s->slice_type;
1421 if (s->pict_type != AV_PICTURE_TYPE_B)
1422 FFSWAP(SVQ3Frame*, s->next_pic, s->last_pic);
1424 av_frame_unref(s->cur_pic->f);
1426 /* for skipping the frame */
1427 s->cur_pic->f->pict_type = s->pict_type;
1428 s->cur_pic->f->key_frame = (s->pict_type == AV_PICTURE_TYPE_I);
1430 ret = get_buffer(avctx, s->cur_pic);
1434 for (i = 0; i < 16; i++) {
1435 s->block_offset[i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * s->cur_pic->f->linesize[0] * ((scan8[i] - scan8[0]) >> 3);
1436 s->block_offset[48 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * s->cur_pic->f->linesize[0] * ((scan8[i] - scan8[0]) >> 3);
1438 for (i = 0; i < 16; i++) {
1439 s->block_offset[16 + i] =
1440 s->block_offset[32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 4 * s->cur_pic->f->linesize[1] * ((scan8[i] - scan8[0]) >> 3);
1441 s->block_offset[48 + 16 + i] =
1442 s->block_offset[48 + 32 + i] = (4 * ((scan8[i] - scan8[0]) & 7)) + 8 * s->cur_pic->f->linesize[1] * ((scan8[i] - scan8[0]) >> 3);
1445 if (s->pict_type != AV_PICTURE_TYPE_I) {
1446 if (!s->last_pic->f->data[0]) {
1447 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1448 av_frame_unref(s->last_pic->f);
1449 ret = get_buffer(avctx, s->last_pic);
1452 memset(s->last_pic->f->data[0], 0, avctx->height * s->last_pic->f->linesize[0]);
1453 memset(s->last_pic->f->data[1], 0x80, (avctx->height / 2) *
1454 s->last_pic->f->linesize[1]);
1455 memset(s->last_pic->f->data[2], 0x80, (avctx->height / 2) *
1456 s->last_pic->f->linesize[2]);
1459 if (s->pict_type == AV_PICTURE_TYPE_B && !s->next_pic->f->data[0]) {
1460 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
1461 av_frame_unref(s->next_pic->f);
1462 ret = get_buffer(avctx, s->next_pic);
1465 memset(s->next_pic->f->data[0], 0, avctx->height * s->next_pic->f->linesize[0]);
1466 memset(s->next_pic->f->data[1], 0x80, (avctx->height / 2) *
1467 s->next_pic->f->linesize[1]);
1468 memset(s->next_pic->f->data[2], 0x80, (avctx->height / 2) *
1469 s->next_pic->f->linesize[2]);
1473 if (avctx->debug & FF_DEBUG_PICT_INFO)
1474 av_log(s->avctx, AV_LOG_DEBUG,
1475 "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
1476 av_get_picture_type_char(s->pict_type),
1477 s->halfpel_flag, s->thirdpel_flag,
1478 s->adaptive_quant, s->qscale, s->slice_num);
1480 if (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B ||
1481 avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I ||
1482 avctx->skip_frame >= AVDISCARD_ALL)
1485 if (s->next_p_frame_damaged) {
1486 if (s->pict_type == AV_PICTURE_TYPE_B)
1489 s->next_p_frame_damaged = 0;
1492 if (s->pict_type == AV_PICTURE_TYPE_B) {
1493 s->frame_num_offset = s->slice_num - s->prev_frame_num;
1495 if (s->frame_num_offset < 0)
1496 s->frame_num_offset += 256;
1497 if (s->frame_num_offset == 0 ||
1498 s->frame_num_offset >= s->prev_frame_num_offset) {
1499 av_log(s->avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1503 s->prev_frame_num = s->frame_num;
1504 s->frame_num = s->slice_num;
1505 s->prev_frame_num_offset = s->frame_num - s->prev_frame_num;
1507 if (s->prev_frame_num_offset < 0)
1508 s->prev_frame_num_offset += 256;
1511 for (m = 0; m < 2; m++) {
1513 for (i = 0; i < 4; i++) {
1515 for (j = -1; j < 4; j++)
1516 s->ref_cache[m][scan8[0] + 8 * i + j] = 1;
1518 s->ref_cache[m][scan8[0] + 8 * i + j] = PART_NOT_AVAILABLE;
1522 for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
1523 for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
1525 s->mb_xy = s->mb_x + s->mb_y * s->mb_stride;
1527 if ((get_bits_left(&s->gb_slice)) <= 7) {
1528 if (((get_bits_count(&s->gb_slice) & 7) == 0 ||
1529 show_bits(&s->gb_slice, get_bits_left(&s->gb_slice) & 7) == 0)) {
1531 if (svq3_decode_slice_header(avctx))
1534 if (s->slice_type != s->pict_type) {
1535 avpriv_request_sample(avctx, "non constant slice type");
1537 /* TODO: support s->mb_skip_run */
1540 mb_type = get_interleaved_ue_golomb(&s->gb_slice);
1542 if (s->pict_type == AV_PICTURE_TYPE_I)
1544 else if (s->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4)
1546 if (mb_type > 33 || svq3_decode_mb(s, mb_type)) {
1547 av_log(s->avctx, AV_LOG_ERROR,
1548 "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1552 if (mb_type != 0 || s->cbp)
1555 if (s->pict_type != AV_PICTURE_TYPE_B && !s->low_delay)
1556 s->cur_pic->mb_type[s->mb_x + s->mb_y * s->mb_stride] =
1557 (s->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1560 ff_draw_horiz_band(avctx, s->cur_pic->f,
1561 s->last_pic->f->data[0] ? s->last_pic->f : NULL,
1562 16 * s->mb_y, 16, PICT_FRAME, 0,
1566 left = buf_size*8 - get_bits_count(&s->gb_slice);
1568 if (s->mb_y != s->mb_height || s->mb_x != s->mb_width) {
1569 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);
1570 //av_hex_dump(stderr, buf+buf_size-8, 8);
1574 av_log(avctx, AV_LOG_ERROR, "frame num %d left %d\n", avctx->frame_number, left);
1578 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay)
1579 ret = av_frame_ref(data, s->cur_pic->f);
1580 else if (s->last_pic->f->data[0])
1581 ret = av_frame_ref(data, s->last_pic->f);
1585 /* Do not output the last pic after seeking. */
1586 if (s->last_pic->f->data[0] || s->low_delay)
1589 if (s->pict_type != AV_PICTURE_TYPE_B) {
1590 FFSWAP(SVQ3Frame*, s->cur_pic, s->next_pic);
1592 av_frame_unref(s->cur_pic->f);
1598 static av_cold int svq3_decode_end(AVCodecContext *avctx)
1600 SVQ3Context *s = avctx->priv_data;
1602 free_picture(avctx, s->cur_pic);
1603 free_picture(avctx, s->next_pic);
1604 free_picture(avctx, s->last_pic);
1605 av_frame_free(&s->cur_pic->f);
1606 av_frame_free(&s->next_pic->f);
1607 av_frame_free(&s->last_pic->f);
1608 av_freep(&s->slice_buf);
1609 av_freep(&s->intra4x4_pred_mode);
1610 av_freep(&s->edge_emu_buffer);
1611 av_freep(&s->mb2br_xy);
1620 AVCodec ff_svq3_decoder = {
1622 .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1623 .type = AVMEDIA_TYPE_VIDEO,
1624 .id = AV_CODEC_ID_SVQ3,
1625 .priv_data_size = sizeof(SVQ3Context),
1626 .init = svq3_decode_init,
1627 .close = svq3_decode_end,
1628 .decode = svq3_decode_frame,
1629 .capabilities = AV_CODEC_CAP_DRAW_HORIZ_BAND |
1632 .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P,
1634 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,