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 { uint8_t run; uint8_t level; } svq3_dct_tables[2][16] = {
126 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
127 { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
128 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
129 { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
132 static const uint32_t svq3_dequant_coeff[32] = {
133 3881, 4351, 4890, 5481, 6154, 6914, 7761, 8718,
134 9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
135 24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
136 61694, 68745, 77615, 89113,100253,109366,126635,141533
139 void ff_svq3_luma_dc_dequant_idct_c(DCTELEM *output, DCTELEM *input, int qp){
140 const int qmul = svq3_dequant_coeff[qp];
144 static const uint8_t x_offset[4]={0, 1*stride, 4*stride, 5*stride};
147 const int z0 = 13*(input[4*i+0] + input[4*i+2]);
148 const int z1 = 13*(input[4*i+0] - input[4*i+2]);
149 const int z2 = 7* input[4*i+1] - 17*input[4*i+3];
150 const int z3 = 17* input[4*i+1] + 7*input[4*i+3];
159 const int offset= x_offset[i];
160 const int z0= 13*(temp[4*0+i] + temp[4*2+i]);
161 const int z1= 13*(temp[4*0+i] - temp[4*2+i]);
162 const int z2= 7* temp[4*1+i] - 17*temp[4*3+i];
163 const int z3= 17* temp[4*1+i] + 7*temp[4*3+i];
165 output[stride* 0+offset] = ((z0 + z3)*qmul + 0x80000) >> 20;
166 output[stride* 2+offset] = ((z1 + z2)*qmul + 0x80000) >> 20;
167 output[stride* 8+offset] = ((z1 - z2)*qmul + 0x80000) >> 20;
168 output[stride*10+offset] = ((z0 - z3)*qmul + 0x80000) >> 20;
173 void ff_svq3_add_idct_c(uint8_t *dst, DCTELEM *block, int stride, int qp,
176 const int qmul = svq3_dequant_coeff[qp];
180 dc = 13*13*((dc == 1) ? 1538*block[0] : ((qmul*(block[0] >> 3)) / 2));
184 for (i = 0; i < 4; i++) {
185 const int z0 = 13*(block[0 + 4*i] + block[2 + 4*i]);
186 const int z1 = 13*(block[0 + 4*i] - block[2 + 4*i]);
187 const int z2 = 7* block[1 + 4*i] - 17*block[3 + 4*i];
188 const int z3 = 17* block[1 + 4*i] + 7*block[3 + 4*i];
190 block[0 + 4*i] = z0 + z3;
191 block[1 + 4*i] = z1 + z2;
192 block[2 + 4*i] = z1 - z2;
193 block[3 + 4*i] = z0 - z3;
196 for (i = 0; i < 4; i++) {
197 const int z0 = 13*(block[i + 4*0] + block[i + 4*2]);
198 const int z1 = 13*(block[i + 4*0] - block[i + 4*2]);
199 const int z2 = 7* block[i + 4*1] - 17*block[i + 4*3];
200 const int z3 = 17* block[i + 4*1] + 7*block[i + 4*3];
201 const int rr = (dc + 0x80000);
203 dst[i + stride*0] = av_clip_uint8( dst[i + stride*0] + (((z0 + z3)*qmul + rr) >> 20) );
204 dst[i + stride*1] = av_clip_uint8( dst[i + stride*1] + (((z1 + z2)*qmul + rr) >> 20) );
205 dst[i + stride*2] = av_clip_uint8( dst[i + stride*2] + (((z1 - z2)*qmul + rr) >> 20) );
206 dst[i + stride*3] = av_clip_uint8( dst[i + stride*3] + (((z0 - z3)*qmul + rr) >> 20) );
210 static inline int svq3_decode_block(GetBitContext *gb, DCTELEM *block,
211 int index, const int type)
213 static const uint8_t *const scan_patterns[4] =
214 { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
216 int run, level, sign, vlc, limit;
217 const int intra = (3 * type) >> 2;
218 const uint8_t *const scan = scan_patterns[type];
220 for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
221 for (; (vlc = svq3_get_ue_golomb(gb)) != 0; index++) {
226 sign = (vlc & 0x1) - 1;
227 vlc = (vlc + 1) >> 1;
233 } else if (vlc < 4) {
238 level = ((vlc + 9) >> 2) - run;
242 run = svq3_dct_tables[intra][vlc].run;
243 level = svq3_dct_tables[intra][vlc].level;
246 level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
249 level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
253 if ((index += run) >= limit)
256 block[scan[index]] = (level ^ sign) - sign;
267 static inline void svq3_mc_dir_part(MpegEncContext *s,
268 int x, int y, int width, int height,
269 int mx, int my, int dxy,
270 int thirdpel, int dir, int avg)
272 const Picture *pic = (dir == 0) ? &s->last_picture : &s->next_picture;
275 int blocksize = 2 - (width>>3); //16->0, 8->1, 4->2
280 if (mx < 0 || mx >= (s->h_edge_pos - width - 1) ||
281 my < 0 || my >= (s->v_edge_pos - height - 1)) {
283 if ((s->flags & CODEC_FLAG_EMU_EDGE)) {
287 mx = av_clip (mx, -16, (s->h_edge_pos - width + 15));
288 my = av_clip (my, -16, (s->v_edge_pos - height + 15));
291 /* form component predictions */
292 dest = s->current_picture.f.data[0] + x + y*s->linesize;
293 src = pic->f.data[0] + mx + my*s->linesize;
296 s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, (width + 1), (height + 1),
297 mx, my, s->h_edge_pos, s->v_edge_pos);
298 src = s->edge_emu_buffer;
301 (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->linesize, width, height);
303 (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->linesize, height);
305 if (!(s->flags & CODEC_FLAG_GRAY)) {
306 mx = (mx + (mx < (int) x)) >> 1;
307 my = (my + (my < (int) y)) >> 1;
308 width = (width >> 1);
309 height = (height >> 1);
312 for (i = 1; i < 3; i++) {
313 dest = s->current_picture.f.data[i] + (x >> 1) + (y >> 1) * s->uvlinesize;
314 src = pic->f.data[i] + mx + my * s->uvlinesize;
317 s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->uvlinesize, (width + 1), (height + 1),
318 mx, my, (s->h_edge_pos >> 1), (s->v_edge_pos >> 1));
319 src = s->edge_emu_buffer;
322 (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->uvlinesize, width, height);
324 (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->uvlinesize, height);
329 static inline int svq3_mc_dir(H264Context *h, int size, int mode, int dir,
332 int i, j, k, mx, my, dx, dy, x, y;
333 MpegEncContext *const s = (MpegEncContext *) h;
334 const int part_width = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
335 const int part_height = 16 >> ((unsigned) (size + 1) / 3);
336 const int extra_width = (mode == PREDICT_MODE) ? -16*6 : 0;
337 const int h_edge_pos = 6*(s->h_edge_pos - part_width ) - extra_width;
338 const int v_edge_pos = 6*(s->v_edge_pos - part_height) - extra_width;
340 for (i = 0; i < 16; i += part_height) {
341 for (j = 0; j < 16; j += part_width) {
342 const int b_xy = (4*s->mb_x + (j >> 2)) + (4*s->mb_y + (i >> 2))*h->b_stride;
346 k = ((j >> 2) & 1) + ((i >> 1) & 2) + ((j >> 1) & 4) + (i & 8);
348 if (mode != PREDICT_MODE) {
349 pred_motion(h, k, (part_width >> 2), dir, 1, &mx, &my);
351 mx = s->next_picture.f.motion_val[0][b_xy][0] << 1;
352 my = s->next_picture.f.motion_val[0][b_xy][1] << 1;
355 mx = ((mx * h->frame_num_offset) / h->prev_frame_num_offset + 1) >> 1;
356 my = ((my * h->frame_num_offset) / h->prev_frame_num_offset + 1) >> 1;
358 mx = ((mx * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1) >> 1;
359 my = ((my * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1) >> 1;
363 /* clip motion vector prediction to frame border */
364 mx = av_clip(mx, extra_width - 6*x, h_edge_pos - 6*x);
365 my = av_clip(my, extra_width - 6*y, v_edge_pos - 6*y);
367 /* get (optional) motion vector differential */
368 if (mode == PREDICT_MODE) {
371 dy = svq3_get_se_golomb(&s->gb);
372 dx = svq3_get_se_golomb(&s->gb);
374 if (dx == INVALID_VLC || dy == INVALID_VLC) {
375 av_log(h->s.avctx, AV_LOG_ERROR, "invalid MV vlc\n");
380 /* compute motion vector */
381 if (mode == THIRDPEL_MODE) {
383 mx = ((mx + 1)>>1) + dx;
384 my = ((my + 1)>>1) + dy;
385 fx = ((unsigned)(mx + 0x3000))/3 - 0x1000;
386 fy = ((unsigned)(my + 0x3000))/3 - 0x1000;
387 dxy = (mx - 3*fx) + 4*(my - 3*fy);
389 svq3_mc_dir_part(s, x, y, part_width, part_height, fx, fy, dxy, 1, dir, avg);
392 } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
393 mx = ((unsigned)(mx + 1 + 0x3000))/3 + dx - 0x1000;
394 my = ((unsigned)(my + 1 + 0x3000))/3 + dy - 0x1000;
395 dxy = (mx&1) + 2*(my&1);
397 svq3_mc_dir_part(s, x, y, part_width, part_height, mx>>1, my>>1, dxy, 0, dir, avg);
401 mx = ((unsigned)(mx + 3 + 0x6000))/6 + dx - 0x1000;
402 my = ((unsigned)(my + 3 + 0x6000))/6 + dy - 0x1000;
404 svq3_mc_dir_part(s, x, y, part_width, part_height, mx, my, 0, 0, dir, avg);
409 /* update mv_cache */
410 if (mode != PREDICT_MODE) {
411 int32_t mv = pack16to32(mx,my);
413 if (part_height == 8 && i < 8) {
414 *(int32_t *) h->mv_cache[dir][scan8[k] + 1*8] = mv;
416 if (part_width == 8 && j < 8) {
417 *(int32_t *) h->mv_cache[dir][scan8[k] + 1 + 1*8] = mv;
420 if (part_width == 8 && j < 8) {
421 *(int32_t *) h->mv_cache[dir][scan8[k] + 1] = mv;
423 if (part_width == 4 || part_height == 4) {
424 *(int32_t *) h->mv_cache[dir][scan8[k]] = mv;
428 /* write back motion vectors */
429 fill_rectangle(s->current_picture.f.motion_val[dir][b_xy],
430 part_width >> 2, part_height >> 2, h->b_stride,
431 pack16to32(mx, my), 4);
438 static int svq3_decode_mb(SVQ3Context *svq3, unsigned int mb_type)
440 H264Context *h = &svq3->h;
441 int i, j, k, m, dir, mode;
445 MpegEncContext *const s = (MpegEncContext *) h;
446 const int mb_xy = h->mb_xy;
447 const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride;
449 h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
450 h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
451 h->topright_samples_available = 0xFFFF;
453 if (mb_type == 0) { /* SKIP */
454 if (s->pict_type == AV_PICTURE_TYPE_P || s->next_picture.f.mb_type[mb_xy] == -1) {
455 svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 0, 0);
457 if (s->pict_type == AV_PICTURE_TYPE_B) {
458 svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 1, 1);
461 mb_type = MB_TYPE_SKIP;
463 mb_type = FFMIN(s->next_picture.f.mb_type[mb_xy], 6);
464 if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 0, 0) < 0)
466 if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 1, 1) < 0)
469 mb_type = MB_TYPE_16x16;
471 } else if (mb_type < 8) { /* INTER */
472 if (svq3->thirdpel_flag && svq3->halfpel_flag == !get_bits1 (&s->gb)) {
473 mode = THIRDPEL_MODE;
474 } else if (svq3->halfpel_flag && svq3->thirdpel_flag == !get_bits1 (&s->gb)) {
481 /* note ref_cache should contain here:
489 for (m = 0; m < 2; m++) {
490 if (s->mb_x > 0 && h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1]+6] != -1) {
491 for (i = 0; i < 4; i++) {
492 *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = *(uint32_t *) s->current_picture.f.motion_val[m][b_xy - 1 + i*h->b_stride];
495 for (i = 0; i < 4; i++) {
496 *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = 0;
500 memcpy(h->mv_cache[m][scan8[0] - 1*8], s->current_picture.f.motion_val[m][b_xy - h->b_stride], 4*2*sizeof(int16_t));
501 memset(&h->ref_cache[m][scan8[0] - 1*8], (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]] == -1) ? PART_NOT_AVAILABLE : 1, 4);
503 if (s->mb_x < (s->mb_width - 1)) {
504 *(uint32_t *) h->mv_cache[m][scan8[0] + 4 - 1*8] = *(uint32_t *) s->current_picture.f.motion_val[m][b_xy - h->b_stride + 4];
505 h->ref_cache[m][scan8[0] + 4 - 1*8] =
506 (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride + 1]+6] == -1 ||
507 h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride ] ] == -1) ? PART_NOT_AVAILABLE : 1;
509 h->ref_cache[m][scan8[0] + 4 - 1*8] = PART_NOT_AVAILABLE;
511 *(uint32_t *) h->mv_cache[m][scan8[0] - 1 - 1*8] = *(uint32_t *) s->current_picture.f.motion_val[m][b_xy - h->b_stride - 1];
512 h->ref_cache[m][scan8[0] - 1 - 1*8] = (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride - 1]+3] == -1) ? PART_NOT_AVAILABLE : 1;
514 h->ref_cache[m][scan8[0] - 1 - 1*8] = PART_NOT_AVAILABLE;
516 memset(&h->ref_cache[m][scan8[0] - 1*8 - 1], PART_NOT_AVAILABLE, 8);
518 if (s->pict_type != AV_PICTURE_TYPE_B)
522 /* decode motion vector(s) and form prediction(s) */
523 if (s->pict_type == AV_PICTURE_TYPE_P) {
524 if (svq3_mc_dir(h, (mb_type - 1), mode, 0, 0) < 0)
526 } else { /* AV_PICTURE_TYPE_B */
528 if (svq3_mc_dir(h, 0, mode, 0, 0) < 0)
531 for (i = 0; i < 4; i++) {
532 memset(s->current_picture.f.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
536 if (svq3_mc_dir(h, 0, mode, 1, (mb_type == 3)) < 0)
539 for (i = 0; i < 4; i++) {
540 memset(s->current_picture.f.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
545 mb_type = MB_TYPE_16x16;
546 } else if (mb_type == 8 || mb_type == 33) { /* INTRA4x4 */
547 memset(h->intra4x4_pred_mode_cache, -1, 8*5*sizeof(int8_t));
551 for (i = 0; i < 4; i++) {
552 h->intra4x4_pred_mode_cache[scan8[0] - 1 + i*8] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1]+6-i];
554 if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1) {
555 h->left_samples_available = 0x5F5F;
559 h->intra4x4_pred_mode_cache[4+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+0];
560 h->intra4x4_pred_mode_cache[5+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+1];
561 h->intra4x4_pred_mode_cache[6+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+2];
562 h->intra4x4_pred_mode_cache[7+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+3];
564 if (h->intra4x4_pred_mode_cache[4+8*0] == -1) {
565 h->top_samples_available = 0x33FF;
569 /* decode prediction codes for luma blocks */
570 for (i = 0; i < 16; i+=2) {
571 vlc = svq3_get_ue_golomb(&s->gb);
574 av_log(h->s.avctx, AV_LOG_ERROR, "luma prediction:%d\n", vlc);
578 left = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
579 top = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
581 left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
582 left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
584 if (left[1] == -1 || left[2] == -1){
585 av_log(h->s.avctx, AV_LOG_ERROR, "weird prediction\n");
589 } else { /* mb_type == 33, DC_128_PRED block type */
590 for (i = 0; i < 4; i++) {
591 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_PRED, 4);
595 write_back_intra_pred_mode(h);
598 ff_h264_check_intra4x4_pred_mode(h);
600 h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
601 h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
603 for (i = 0; i < 4; i++) {
604 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_128_PRED, 4);
607 h->top_samples_available = 0x33FF;
608 h->left_samples_available = 0x5F5F;
611 mb_type = MB_TYPE_INTRA4x4;
612 } else { /* INTRA16x16 */
613 dir = i_mb_type_info[mb_type - 8].pred_mode;
614 dir = (dir >> 1) ^ 3*(dir & 1) ^ 1;
616 if ((h->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, dir, 0)) == -1){
617 av_log(h->s.avctx, AV_LOG_ERROR, "check_intra_pred_mode = -1\n");
621 cbp = i_mb_type_info[mb_type - 8].cbp;
622 mb_type = MB_TYPE_INTRA16x16;
625 if (!IS_INTER(mb_type) && s->pict_type != AV_PICTURE_TYPE_I) {
626 for (i = 0; i < 4; i++) {
627 memset(s->current_picture.f.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
629 if (s->pict_type == AV_PICTURE_TYPE_B) {
630 for (i = 0; i < 4; i++) {
631 memset(s->current_picture.f.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
635 if (!IS_INTRA4x4(mb_type)) {
636 memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy], DC_PRED, 8);
638 if (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B) {
639 memset(h->non_zero_count_cache + 8, 0, 14*8*sizeof(uint8_t));
640 s->dsp.clear_blocks(h->mb+ 0);
641 s->dsp.clear_blocks(h->mb+384);
644 if (!IS_INTRA16x16(mb_type) && (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B)) {
645 if ((vlc = svq3_get_ue_golomb(&s->gb)) >= 48U){
646 av_log(h->s.avctx, AV_LOG_ERROR, "cbp_vlc=%d\n", vlc);
650 cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc] : golomb_to_inter_cbp[vlc];
652 if (IS_INTRA16x16(mb_type) || (s->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
653 s->qscale += svq3_get_se_golomb(&s->gb);
655 if (s->qscale > 31U){
656 av_log(h->s.avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
660 if (IS_INTRA16x16(mb_type)) {
661 AV_ZERO128(h->mb_luma_dc[0]+0);
662 AV_ZERO128(h->mb_luma_dc[0]+8);
663 if (svq3_decode_block(&s->gb, *h->mb_luma_dc, 0, 1)){
664 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding intra luma dc\n");
670 const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
671 const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
673 for (i = 0; i < 4; i++) {
674 if ((cbp & (1 << i))) {
675 for (j = 0; j < 4; j++) {
676 k = index ? ((j&1) + 2*(i&1) + 2*(j&2) + 4*(i&2)) : (4*i + j);
677 h->non_zero_count_cache[ scan8[k] ] = 1;
679 if (svq3_decode_block(&s->gb, &h->mb[16*k], index, type)){
680 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding block\n");
688 for (i = 1; i < 3; ++i) {
689 if (svq3_decode_block(&s->gb, &h->mb[16*16*i], 0, 3)){
690 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma dc block\n");
696 for (i = 1; i < 3; i++) {
697 for (j = 0; j < 4; j++) {
699 h->non_zero_count_cache[ scan8[k] ] = 1;
701 if (svq3_decode_block(&s->gb, &h->mb[16*k], 1, 1)){
702 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma ac block\n");
712 s->current_picture.f.mb_type[mb_xy] = mb_type;
714 if (IS_INTRA(mb_type)) {
715 h->chroma_pred_mode = ff_h264_check_intra_pred_mode(h, DC_PRED8x8, 1);
721 static int svq3_decode_slice_header(AVCodecContext *avctx)
723 SVQ3Context *svq3 = avctx->priv_data;
724 H264Context *h = &svq3->h;
725 MpegEncContext *s = &h->s;
726 const int mb_xy = h->mb_xy;
729 header = get_bits(&s->gb, 8);
731 if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
733 av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
736 int length = (header >> 5) & 3;
738 svq3->next_slice_index = get_bits_count(&s->gb) + 8*show_bits(&s->gb, 8*length) + 8*length;
740 if (svq3->next_slice_index > s->gb.size_in_bits) {
741 av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
745 s->gb.size_in_bits = svq3->next_slice_index - 8*(length - 1);
746 skip_bits(&s->gb, 8);
748 if (svq3->watermark_key) {
749 uint32_t header = AV_RL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1]);
750 AV_WL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1], header ^ svq3->watermark_key);
753 memcpy((uint8_t *) &s->gb.buffer[get_bits_count(&s->gb) >> 3],
754 &s->gb.buffer[s->gb.size_in_bits >> 3], (length - 1));
756 skip_bits_long(&s->gb, 0);
759 if ((i = svq3_get_ue_golomb(&s->gb)) >= 3U){
760 av_log(h->s.avctx, AV_LOG_ERROR, "illegal slice type %d \n", i);
764 h->slice_type = golomb_to_pict_type[i];
766 if ((header & 0x9F) == 2) {
767 i = (s->mb_num < 64) ? 6 : (1 + av_log2 (s->mb_num - 1));
768 s->mb_skip_run = get_bits(&s->gb, i) - (s->mb_x + (s->mb_y * s->mb_width));
774 h->slice_num = get_bits(&s->gb, 8);
775 s->qscale = get_bits(&s->gb, 5);
776 s->adaptive_quant = get_bits1(&s->gb);
781 if (svq3->unknown_flag) {
786 skip_bits(&s->gb, 2);
788 while (get_bits1(&s->gb)) {
789 skip_bits(&s->gb, 8);
792 /* reset intra predictors and invalidate motion vector references */
794 memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - 1 ]+3, -1, 4*sizeof(int8_t));
795 memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - s->mb_x] , -1, 8*sizeof(int8_t)*s->mb_x);
798 memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - s->mb_stride], -1, 8*sizeof(int8_t)*(s->mb_width - s->mb_x));
801 h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride - 1]+3] = -1;
808 static av_cold int svq3_decode_init(AVCodecContext *avctx)
810 SVQ3Context *svq3 = avctx->priv_data;
811 H264Context *h = &svq3->h;
812 MpegEncContext *s = &h->s;
814 unsigned char *extradata;
815 unsigned char *extradata_end;
817 int marker_found = 0;
819 if (ff_h264_decode_init(avctx) < 0)
822 s->flags = avctx->flags;
823 s->flags2 = avctx->flags2;
824 s->unrestricted_mv = 1;
826 h->sps.chroma_format_idc = 1;
827 avctx->pix_fmt = avctx->codec->pix_fmts[0];
829 if (!s->context_initialized) {
830 h->chroma_qp[0] = h->chroma_qp[1] = 4;
832 svq3->halfpel_flag = 1;
833 svq3->thirdpel_flag = 1;
834 svq3->unknown_flag = 0;
837 /* prowl for the "SEQH" marker in the extradata */
838 extradata = (unsigned char *)avctx->extradata;
839 extradata_end = avctx->extradata + avctx->extradata_size;
841 for (m = 0; m + 8 < avctx->extradata_size; m++) {
842 if (!memcmp(extradata, "SEQH", 4)) {
850 /* if a match was found, parse the extra data */
856 size = AV_RB32(&extradata[4]);
857 if (size > extradata_end - extradata - 8)
858 return AVERROR_INVALIDDATA;
859 init_get_bits(&gb, extradata + 8, size*8);
861 /* 'frame size code' and optional 'width, height' */
862 frame_size_code = get_bits(&gb, 3);
863 switch (frame_size_code) {
864 case 0: avctx->width = 160; avctx->height = 120; break;
865 case 1: avctx->width = 128; avctx->height = 96; break;
866 case 2: avctx->width = 176; avctx->height = 144; break;
867 case 3: avctx->width = 352; avctx->height = 288; break;
868 case 4: avctx->width = 704; avctx->height = 576; break;
869 case 5: avctx->width = 240; avctx->height = 180; break;
870 case 6: avctx->width = 320; avctx->height = 240; break;
872 avctx->width = get_bits(&gb, 12);
873 avctx->height = get_bits(&gb, 12);
877 svq3->halfpel_flag = get_bits1(&gb);
878 svq3->thirdpel_flag = get_bits1(&gb);
886 s->low_delay = get_bits1(&gb);
891 while (get_bits1(&gb)) {
895 svq3->unknown_flag = get_bits1(&gb);
896 avctx->has_b_frames = !s->low_delay;
897 if (svq3->unknown_flag) {
899 unsigned watermark_width = svq3_get_ue_golomb(&gb);
900 unsigned watermark_height = svq3_get_ue_golomb(&gb);
901 int u1 = svq3_get_ue_golomb(&gb);
902 int u2 = get_bits(&gb, 8);
903 int u3 = get_bits(&gb, 2);
904 int u4 = svq3_get_ue_golomb(&gb);
905 unsigned long buf_len = watermark_width*watermark_height*4;
906 int offset = (get_bits_count(&gb)+7)>>3;
909 if (watermark_height<=0 || (uint64_t)watermark_width*4 > UINT_MAX/watermark_height)
912 buf = av_malloc(buf_len);
913 av_log(avctx, AV_LOG_DEBUG, "watermark size: %dx%d\n", watermark_width, watermark_height);
914 av_log(avctx, AV_LOG_DEBUG, "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n", u1, u2, u3, u4, offset);
915 if (uncompress(buf, &buf_len, extradata + 8 + offset, size - offset) != Z_OK) {
916 av_log(avctx, AV_LOG_ERROR, "could not uncompress watermark logo\n");
920 svq3->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
921 svq3->watermark_key = svq3->watermark_key << 16 | svq3->watermark_key;
922 av_log(avctx, AV_LOG_DEBUG, "watermark key %#x\n", svq3->watermark_key);
925 av_log(avctx, AV_LOG_ERROR, "this svq3 file contains watermark which need zlib support compiled in\n");
931 s->width = avctx->width;
932 s->height = avctx->height;
934 if (ff_MPV_common_init(s) < 0)
937 h->b_stride = 4*s->mb_width;
939 if (ff_h264_alloc_tables(h) < 0) {
940 av_log(avctx, AV_LOG_ERROR, "svq3 memory allocation failed\n");
941 return AVERROR(ENOMEM);
948 static int svq3_decode_frame(AVCodecContext *avctx,
949 void *data, int *data_size,
952 SVQ3Context *svq3 = avctx->priv_data;
953 H264Context *h = &svq3->h;
954 MpegEncContext *s = &h->s;
955 int buf_size = avpkt->size;
956 int m, mb_type, left;
959 /* special case for last picture */
961 if (s->next_picture_ptr && !s->low_delay) {
962 *(AVFrame *) data = s->next_picture.f;
963 s->next_picture_ptr = NULL;
964 *data_size = sizeof(AVFrame);
969 s->mb_x = s->mb_y = h->mb_xy = 0;
971 if (svq3->watermark_key) {
972 av_fast_malloc(&svq3->buf, &svq3->buf_size,
973 buf_size+FF_INPUT_BUFFER_PADDING_SIZE);
975 return AVERROR(ENOMEM);
976 memcpy(svq3->buf, avpkt->data, buf_size);
982 init_get_bits(&s->gb, buf, 8*buf_size);
984 if (svq3_decode_slice_header(avctx))
987 s->pict_type = h->slice_type;
988 s->picture_number = h->slice_num;
990 if (avctx->debug&FF_DEBUG_PICT_INFO){
991 av_log(h->s.avctx, AV_LOG_DEBUG, "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
992 av_get_picture_type_char(s->pict_type), svq3->halfpel_flag, svq3->thirdpel_flag,
993 s->adaptive_quant, s->qscale, h->slice_num);
996 /* for skipping the frame */
997 s->current_picture.f.pict_type = s->pict_type;
998 s->current_picture.f.key_frame = (s->pict_type == AV_PICTURE_TYPE_I);
1000 /* Skip B-frames if we do not have reference frames. */
1001 if (s->last_picture_ptr == NULL && s->pict_type == AV_PICTURE_TYPE_B)
1003 if ( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
1004 ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
1005 || avctx->skip_frame >= AVDISCARD_ALL)
1008 if (s->next_p_frame_damaged) {
1009 if (s->pict_type == AV_PICTURE_TYPE_B)
1012 s->next_p_frame_damaged = 0;
1015 if (ff_h264_frame_start(h) < 0)
1018 if (s->pict_type == AV_PICTURE_TYPE_B) {
1019 h->frame_num_offset = (h->slice_num - h->prev_frame_num);
1021 if (h->frame_num_offset < 0) {
1022 h->frame_num_offset += 256;
1024 if (h->frame_num_offset == 0 || h->frame_num_offset >= h->prev_frame_num_offset) {
1025 av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
1029 h->prev_frame_num = h->frame_num;
1030 h->frame_num = h->slice_num;
1031 h->prev_frame_num_offset = (h->frame_num - h->prev_frame_num);
1033 if (h->prev_frame_num_offset < 0) {
1034 h->prev_frame_num_offset += 256;
1038 for (m = 0; m < 2; m++){
1040 for (i = 0; i < 4; i++){
1042 for (j = -1; j < 4; j++)
1043 h->ref_cache[m][scan8[0] + 8*i + j]= 1;
1045 h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
1049 for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
1050 for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
1051 h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1053 if ( (get_bits_count(&s->gb) + 7) >= s->gb.size_in_bits &&
1054 ((get_bits_count(&s->gb) & 7) == 0 || show_bits(&s->gb, (-get_bits_count(&s->gb) & 7)) == 0)) {
1056 skip_bits(&s->gb, svq3->next_slice_index - get_bits_count(&s->gb));
1057 s->gb.size_in_bits = 8*buf_size;
1059 if (svq3_decode_slice_header(avctx))
1062 /* TODO: support s->mb_skip_run */
1065 mb_type = svq3_get_ue_golomb(&s->gb);
1067 if (s->pict_type == AV_PICTURE_TYPE_I) {
1069 } else if (s->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4) {
1072 if ((unsigned)mb_type > 33 || svq3_decode_mb(svq3, mb_type)) {
1073 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1078 ff_h264_hl_decode_mb (h);
1081 if (s->pict_type != AV_PICTURE_TYPE_B && !s->low_delay) {
1082 s->current_picture.f.mb_type[s->mb_x + s->mb_y * s->mb_stride] =
1083 (s->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1;
1087 ff_draw_horiz_band(s, 16*s->mb_y, 16);
1090 left = buf_size*8 - get_bits_count(&s->gb);
1092 if (s->mb_y != s->mb_height || s->mb_x != s->mb_width) {
1093 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);
1094 //av_hex_dump(stderr, buf+buf_size-8, 8);
1098 av_log(avctx, AV_LOG_ERROR, "frame num %d left %d\n", avctx->frame_number, left);
1102 ff_MPV_frame_end(s);
1104 if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
1105 *(AVFrame *) data = s->current_picture.f;
1107 *(AVFrame *) data = s->last_picture.f;
1110 /* Do not output the last pic after seeking. */
1111 if (s->last_picture_ptr || s->low_delay) {
1112 *data_size = sizeof(AVFrame);
1118 static int svq3_decode_end(AVCodecContext *avctx)
1120 SVQ3Context *svq3 = avctx->priv_data;
1121 H264Context *h = &svq3->h;
1122 MpegEncContext *s = &h->s;
1124 ff_h264_free_context(h);
1126 ff_MPV_common_end(s);
1128 av_freep(&svq3->buf);
1134 AVCodec ff_svq3_decoder = {
1136 .type = AVMEDIA_TYPE_VIDEO,
1137 .id = CODEC_ID_SVQ3,
1138 .priv_data_size = sizeof(SVQ3Context),
1139 .init = svq3_decode_init,
1140 .close = svq3_decode_end,
1141 .decode = svq3_decode_frame,
1142 .capabilities = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 |
1144 .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1145 .pix_fmts = (const enum PixelFormat[]){ PIX_FMT_YUVJ420P, PIX_FMT_NONE },