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"
66 #define FULLPEL_MODE 1
67 #define HALFPEL_MODE 2
68 #define THIRDPEL_MODE 3
69 #define PREDICT_MODE 4
71 /* dual scan (from some older h264 draft)
80 static const uint8_t svq3_scan[16] = {
81 0+0*4, 1+0*4, 2+0*4, 2+1*4,
82 2+2*4, 3+0*4, 3+1*4, 3+2*4,
83 0+1*4, 0+2*4, 1+1*4, 1+2*4,
84 0+3*4, 1+3*4, 2+3*4, 3+3*4,
87 static const uint8_t svq3_pred_0[25][2] = {
90 { 0, 2 }, { 1, 1 }, { 2, 0 },
91 { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
92 { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
93 { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
94 { 2, 4 }, { 3, 3 }, { 4, 2 },
99 static const int8_t svq3_pred_1[6][6][5] = {
100 { { 2,-1,-1,-1,-1 }, { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 },
101 { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 }, { 1, 2,-1,-1,-1 } },
102 { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
103 { 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
104 { { 2, 0,-1,-1,-1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
105 { 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
106 { { 2, 0,-1,-1,-1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
107 { 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
108 { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
109 { 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
110 { { 0, 2,-1,-1,-1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
111 { 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
114 static const struct { uint8_t run; uint8_t level; } svq3_dct_tables[2][16] = {
115 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
116 { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
117 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
118 { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
121 static const uint32_t svq3_dequant_coeff[32] = {
122 3881, 4351, 4890, 5481, 6154, 6914, 7761, 8718,
123 9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
124 24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
125 61694, 68745, 77615, 89113,100253,109366,126635,141533
129 void ff_svq3_luma_dc_dequant_idct_c(DCTELEM *block, int qp)
131 const int qmul = svq3_dequant_coeff[qp];
135 static const int x_offset[4] = {0, 1*stride, 4* stride, 5*stride};
136 static const int y_offset[4] = {0, 2*stride, 8* stride, 10*stride};
138 for (i = 0; i < 4; i++){
139 const int offset = y_offset[i];
140 const int z0 = 13*(block[offset+stride*0] + block[offset+stride*4]);
141 const int z1 = 13*(block[offset+stride*0] - block[offset+stride*4]);
142 const int z2 = 7* block[offset+stride*1] - 17*block[offset+stride*5];
143 const int z3 = 17* block[offset+stride*1] + 7*block[offset+stride*5];
151 for (i = 0; i < 4; i++){
152 const int offset = x_offset[i];
153 const int z0 = 13*(temp[4*0+i] + temp[4*2+i]);
154 const int z1 = 13*(temp[4*0+i] - temp[4*2+i]);
155 const int z2 = 7* temp[4*1+i] - 17*temp[4*3+i];
156 const int z3 = 17* temp[4*1+i] + 7*temp[4*3+i];
158 block[stride*0 +offset] = ((z0 + z3)*qmul + 0x80000) >> 20;
159 block[stride*2 +offset] = ((z1 + z2)*qmul + 0x80000) >> 20;
160 block[stride*8 +offset] = ((z1 - z2)*qmul + 0x80000) >> 20;
161 block[stride*10+offset] = ((z0 - z3)*qmul + 0x80000) >> 20;
166 void ff_svq3_add_idct_c(uint8_t *dst, DCTELEM *block, int stride, int qp,
169 const int qmul = svq3_dequant_coeff[qp];
171 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
174 dc = 13*13*((dc == 1) ? 1538*block[0] : ((qmul*(block[0] >> 3)) / 2));
178 for (i = 0; i < 4; i++) {
179 const int z0 = 13*(block[0 + 4*i] + block[2 + 4*i]);
180 const int z1 = 13*(block[0 + 4*i] - block[2 + 4*i]);
181 const int z2 = 7* block[1 + 4*i] - 17*block[3 + 4*i];
182 const int z3 = 17* block[1 + 4*i] + 7*block[3 + 4*i];
184 block[0 + 4*i] = z0 + z3;
185 block[1 + 4*i] = z1 + z2;
186 block[2 + 4*i] = z1 - z2;
187 block[3 + 4*i] = z0 - z3;
190 for (i = 0; i < 4; i++) {
191 const int z0 = 13*(block[i + 4*0] + block[i + 4*2]);
192 const int z1 = 13*(block[i + 4*0] - block[i + 4*2]);
193 const int z2 = 7* block[i + 4*1] - 17*block[i + 4*3];
194 const int z3 = 17* block[i + 4*1] + 7*block[i + 4*3];
195 const int rr = (dc + 0x80000);
197 dst[i + stride*0] = cm[ dst[i + stride*0] + (((z0 + z3)*qmul + rr) >> 20) ];
198 dst[i + stride*1] = cm[ dst[i + stride*1] + (((z1 + z2)*qmul + rr) >> 20) ];
199 dst[i + stride*2] = cm[ dst[i + stride*2] + (((z1 - z2)*qmul + rr) >> 20) ];
200 dst[i + stride*3] = cm[ dst[i + stride*3] + (((z0 - z3)*qmul + rr) >> 20) ];
204 static inline int svq3_decode_block(GetBitContext *gb, DCTELEM *block,
205 int index, const int type)
207 static const uint8_t *const scan_patterns[4] =
208 { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
210 int run, level, sign, vlc, limit;
211 const int intra = (3 * type) >> 2;
212 const uint8_t *const scan = scan_patterns[type];
214 for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
215 for (; (vlc = svq3_get_ue_golomb(gb)) != 0; index++) {
217 if (vlc == INVALID_VLC)
220 sign = (vlc & 0x1) - 1;
221 vlc = (vlc + 1) >> 1;
227 } else if (vlc < 4) {
232 level = ((vlc + 9) >> 2) - run;
236 run = svq3_dct_tables[intra][vlc].run;
237 level = svq3_dct_tables[intra][vlc].level;
240 level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
243 level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
247 if ((index += run) >= limit)
250 block[scan[index]] = (level ^ sign) - sign;
261 static inline void svq3_mc_dir_part(MpegEncContext *s,
262 int x, int y, int width, int height,
263 int mx, int my, int dxy,
264 int thirdpel, int dir, int avg)
266 const Picture *pic = (dir == 0) ? &s->last_picture : &s->next_picture;
269 int blocksize = 2 - (width>>3); //16->0, 8->1, 4->2
274 if (mx < 0 || mx >= (s->h_edge_pos - width - 1) ||
275 my < 0 || my >= (s->v_edge_pos - height - 1)) {
277 if ((s->flags & CODEC_FLAG_EMU_EDGE)) {
281 mx = av_clip (mx, -16, (s->h_edge_pos - width + 15));
282 my = av_clip (my, -16, (s->v_edge_pos - height + 15));
285 /* form component predictions */
286 dest = s->current_picture.data[0] + x + y*s->linesize;
287 src = pic->data[0] + mx + my*s->linesize;
290 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, (width + 1), (height + 1),
291 mx, my, s->h_edge_pos, s->v_edge_pos);
292 src = s->edge_emu_buffer;
295 (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->linesize, width, height);
297 (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->linesize, height);
299 if (!(s->flags & CODEC_FLAG_GRAY)) {
300 mx = (mx + (mx < (int) x)) >> 1;
301 my = (my + (my < (int) y)) >> 1;
302 width = (width >> 1);
303 height = (height >> 1);
306 for (i = 1; i < 3; i++) {
307 dest = s->current_picture.data[i] + (x >> 1) + (y >> 1)*s->uvlinesize;
308 src = pic->data[i] + mx + my*s->uvlinesize;
311 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->uvlinesize, (width + 1), (height + 1),
312 mx, my, (s->h_edge_pos >> 1), (s->v_edge_pos >> 1));
313 src = s->edge_emu_buffer;
316 (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->uvlinesize, width, height);
318 (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->uvlinesize, height);
323 static inline int svq3_mc_dir(H264Context *h, int size, int mode, int dir,
326 int i, j, k, mx, my, dx, dy, x, y;
327 MpegEncContext *const s = (MpegEncContext *) h;
328 const int part_width = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
329 const int part_height = 16 >> ((unsigned) (size + 1) / 3);
330 const int extra_width = (mode == PREDICT_MODE) ? -16*6 : 0;
331 const int h_edge_pos = 6*(s->h_edge_pos - part_width ) - extra_width;
332 const int v_edge_pos = 6*(s->v_edge_pos - part_height) - extra_width;
334 for (i = 0; i < 16; i += part_height) {
335 for (j = 0; j < 16; j += part_width) {
336 const int b_xy = (4*s->mb_x + (j >> 2)) + (4*s->mb_y + (i >> 2))*h->b_stride;
340 k = ((j >> 2) & 1) + ((i >> 1) & 2) + ((j >> 1) & 4) + (i & 8);
342 if (mode != PREDICT_MODE) {
343 pred_motion(h, k, (part_width >> 2), dir, 1, &mx, &my);
345 mx = s->next_picture.motion_val[0][b_xy][0]<<1;
346 my = s->next_picture.motion_val[0][b_xy][1]<<1;
349 mx = ((mx * h->frame_num_offset) / h->prev_frame_num_offset + 1) >> 1;
350 my = ((my * h->frame_num_offset) / h->prev_frame_num_offset + 1) >> 1;
352 mx = ((mx * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1) >> 1;
353 my = ((my * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1) >> 1;
357 /* clip motion vector prediction to frame border */
358 mx = av_clip(mx, extra_width - 6*x, h_edge_pos - 6*x);
359 my = av_clip(my, extra_width - 6*y, v_edge_pos - 6*y);
361 /* get (optional) motion vector differential */
362 if (mode == PREDICT_MODE) {
365 dy = svq3_get_se_golomb(&s->gb);
366 dx = svq3_get_se_golomb(&s->gb);
368 if (dx == INVALID_VLC || dy == INVALID_VLC) {
369 av_log(h->s.avctx, AV_LOG_ERROR, "invalid MV vlc\n");
374 /* compute motion vector */
375 if (mode == THIRDPEL_MODE) {
377 mx = ((mx + 1)>>1) + dx;
378 my = ((my + 1)>>1) + dy;
379 fx = ((unsigned)(mx + 0x3000))/3 - 0x1000;
380 fy = ((unsigned)(my + 0x3000))/3 - 0x1000;
381 dxy = (mx - 3*fx) + 4*(my - 3*fy);
383 svq3_mc_dir_part(s, x, y, part_width, part_height, fx, fy, dxy, 1, dir, avg);
386 } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
387 mx = ((unsigned)(mx + 1 + 0x3000))/3 + dx - 0x1000;
388 my = ((unsigned)(my + 1 + 0x3000))/3 + dy - 0x1000;
389 dxy = (mx&1) + 2*(my&1);
391 svq3_mc_dir_part(s, x, y, part_width, part_height, mx>>1, my>>1, dxy, 0, dir, avg);
395 mx = ((unsigned)(mx + 3 + 0x6000))/6 + dx - 0x1000;
396 my = ((unsigned)(my + 3 + 0x6000))/6 + dy - 0x1000;
398 svq3_mc_dir_part(s, x, y, part_width, part_height, mx, my, 0, 0, dir, avg);
403 /* update mv_cache */
404 if (mode != PREDICT_MODE) {
405 int32_t mv = pack16to32(mx,my);
407 if (part_height == 8 && i < 8) {
408 *(int32_t *) h->mv_cache[dir][scan8[k] + 1*8] = mv;
410 if (part_width == 8 && j < 8) {
411 *(int32_t *) h->mv_cache[dir][scan8[k] + 1 + 1*8] = mv;
414 if (part_width == 8 && j < 8) {
415 *(int32_t *) h->mv_cache[dir][scan8[k] + 1] = mv;
417 if (part_width == 4 || part_height == 4) {
418 *(int32_t *) h->mv_cache[dir][scan8[k]] = mv;
422 /* write back motion vectors */
423 fill_rectangle(s->current_picture.motion_val[dir][b_xy], part_width>>2, part_height>>2, h->b_stride, pack16to32(mx,my), 4);
430 static int svq3_decode_mb(H264Context *h, unsigned int mb_type)
432 int i, j, k, m, dir, mode;
436 MpegEncContext *const s = (MpegEncContext *) h;
437 const int mb_xy = h->mb_xy;
438 const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride;
440 h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
441 h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
442 h->topright_samples_available = 0xFFFF;
444 if (mb_type == 0) { /* SKIP */
445 if (s->pict_type == FF_P_TYPE || s->next_picture.mb_type[mb_xy] == -1) {
446 svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 0, 0);
448 if (s->pict_type == FF_B_TYPE) {
449 svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 1, 1);
452 mb_type = MB_TYPE_SKIP;
454 mb_type = FFMIN(s->next_picture.mb_type[mb_xy], 6);
455 if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 0, 0) < 0)
457 if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 1, 1) < 0)
460 mb_type = MB_TYPE_16x16;
462 } else if (mb_type < 8) { /* INTER */
463 if (h->thirdpel_flag && h->halfpel_flag == !get_bits1 (&s->gb)) {
464 mode = THIRDPEL_MODE;
465 } else if (h->halfpel_flag && h->thirdpel_flag == !get_bits1 (&s->gb)) {
472 /* note ref_cache should contain here:
480 for (m = 0; m < 2; m++) {
481 if (s->mb_x > 0 && h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1]+6] != -1) {
482 for (i = 0; i < 4; i++) {
483 *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = *(uint32_t *) s->current_picture.motion_val[m][b_xy - 1 + i*h->b_stride];
486 for (i = 0; i < 4; i++) {
487 *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = 0;
491 memcpy(h->mv_cache[m][scan8[0] - 1*8], s->current_picture.motion_val[m][b_xy - h->b_stride], 4*2*sizeof(int16_t));
492 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);
494 if (s->mb_x < (s->mb_width - 1)) {
495 *(uint32_t *) h->mv_cache[m][scan8[0] + 4 - 1*8] = *(uint32_t *) s->current_picture.motion_val[m][b_xy - h->b_stride + 4];
496 h->ref_cache[m][scan8[0] + 4 - 1*8] =
497 (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride + 1]+6] == -1 ||
498 h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride ] ] == -1) ? PART_NOT_AVAILABLE : 1;
500 h->ref_cache[m][scan8[0] + 4 - 1*8] = PART_NOT_AVAILABLE;
502 *(uint32_t *) h->mv_cache[m][scan8[0] - 1 - 1*8] = *(uint32_t *) s->current_picture.motion_val[m][b_xy - h->b_stride - 1];
503 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;
505 h->ref_cache[m][scan8[0] - 1 - 1*8] = PART_NOT_AVAILABLE;
507 memset(&h->ref_cache[m][scan8[0] - 1*8 - 1], PART_NOT_AVAILABLE, 8);
509 if (s->pict_type != FF_B_TYPE)
513 /* decode motion vector(s) and form prediction(s) */
514 if (s->pict_type == FF_P_TYPE) {
515 if (svq3_mc_dir(h, (mb_type - 1), mode, 0, 0) < 0)
517 } else { /* FF_B_TYPE */
519 if (svq3_mc_dir(h, 0, mode, 0, 0) < 0)
522 for (i = 0; i < 4; i++) {
523 memset(s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
527 if (svq3_mc_dir(h, 0, mode, 1, (mb_type == 3)) < 0)
530 for (i = 0; i < 4; i++) {
531 memset(s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
536 mb_type = MB_TYPE_16x16;
537 } else if (mb_type == 8 || mb_type == 33) { /* INTRA4x4 */
538 memset(h->intra4x4_pred_mode_cache, -1, 8*5*sizeof(int8_t));
542 for (i = 0; i < 4; i++) {
543 h->intra4x4_pred_mode_cache[scan8[0] - 1 + i*8] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1]+6-i];
545 if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1) {
546 h->left_samples_available = 0x5F5F;
550 h->intra4x4_pred_mode_cache[4+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+0];
551 h->intra4x4_pred_mode_cache[5+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+1];
552 h->intra4x4_pred_mode_cache[6+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+2];
553 h->intra4x4_pred_mode_cache[7+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+3];
555 if (h->intra4x4_pred_mode_cache[4+8*0] == -1) {
556 h->top_samples_available = 0x33FF;
560 /* decode prediction codes for luma blocks */
561 for (i = 0; i < 16; i+=2) {
562 vlc = svq3_get_ue_golomb(&s->gb);
565 av_log(h->s.avctx, AV_LOG_ERROR, "luma prediction:%d\n", vlc);
569 left = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
570 top = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
572 left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
573 left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
575 if (left[1] == -1 || left[2] == -1){
576 av_log(h->s.avctx, AV_LOG_ERROR, "weird prediction\n");
580 } else { /* mb_type == 33, DC_128_PRED block type */
581 for (i = 0; i < 4; i++) {
582 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_PRED, 4);
586 ff_h264_write_back_intra_pred_mode(h);
589 ff_h264_check_intra4x4_pred_mode(h);
591 h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
592 h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
594 for (i = 0; i < 4; i++) {
595 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_128_PRED, 4);
598 h->top_samples_available = 0x33FF;
599 h->left_samples_available = 0x5F5F;
602 mb_type = MB_TYPE_INTRA4x4;
603 } else { /* INTRA16x16 */
604 dir = i_mb_type_info[mb_type - 8].pred_mode;
605 dir = (dir >> 1) ^ 3*(dir & 1) ^ 1;
607 if ((h->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, dir)) == -1){
608 av_log(h->s.avctx, AV_LOG_ERROR, "check_intra_pred_mode = -1\n");
612 cbp = i_mb_type_info[mb_type - 8].cbp;
613 mb_type = MB_TYPE_INTRA16x16;
616 if (!IS_INTER(mb_type) && s->pict_type != FF_I_TYPE) {
617 for (i = 0; i < 4; i++) {
618 memset(s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
620 if (s->pict_type == FF_B_TYPE) {
621 for (i = 0; i < 4; i++) {
622 memset(s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
626 if (!IS_INTRA4x4(mb_type)) {
627 memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy], DC_PRED, 8);
629 if (!IS_SKIP(mb_type) || s->pict_type == FF_B_TYPE) {
630 memset(h->non_zero_count_cache + 8, 0, 4*9*sizeof(uint8_t));
631 s->dsp.clear_blocks(h->mb);
634 if (!IS_INTRA16x16(mb_type) && (!IS_SKIP(mb_type) || s->pict_type == FF_B_TYPE)) {
635 if ((vlc = svq3_get_ue_golomb(&s->gb)) >= 48){
636 av_log(h->s.avctx, AV_LOG_ERROR, "cbp_vlc=%d\n", vlc);
640 cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc] : golomb_to_inter_cbp[vlc];
642 if (IS_INTRA16x16(mb_type) || (s->pict_type != FF_I_TYPE && s->adaptive_quant && cbp)) {
643 s->qscale += svq3_get_se_golomb(&s->gb);
646 av_log(h->s.avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
650 if (IS_INTRA16x16(mb_type)) {
651 if (svq3_decode_block(&s->gb, h->mb, 0, 0)){
652 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding intra luma dc\n");
658 const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
659 const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
661 for (i = 0; i < 4; i++) {
662 if ((cbp & (1 << i))) {
663 for (j = 0; j < 4; j++) {
664 k = index ? ((j&1) + 2*(i&1) + 2*(j&2) + 4*(i&2)) : (4*i + j);
665 h->non_zero_count_cache[ scan8[k] ] = 1;
667 if (svq3_decode_block(&s->gb, &h->mb[16*k], index, type)){
668 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding block\n");
676 for (i = 0; i < 2; ++i) {
677 if (svq3_decode_block(&s->gb, &h->mb[16*(16 + 4*i)], 0, 3)){
678 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma dc block\n");
684 for (i = 0; i < 8; i++) {
685 h->non_zero_count_cache[ scan8[16+i] ] = 1;
687 if (svq3_decode_block(&s->gb, &h->mb[16*(16 + i)], 1, 1)){
688 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma ac block\n");
697 s->current_picture.mb_type[mb_xy] = mb_type;
699 if (IS_INTRA(mb_type)) {
700 h->chroma_pred_mode = ff_h264_check_intra_pred_mode(h, DC_PRED8x8);
706 static int svq3_decode_slice_header(H264Context *h)
708 MpegEncContext *const s = (MpegEncContext *) h;
709 const int mb_xy = h->mb_xy;
712 header = get_bits(&s->gb, 8);
714 if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
716 av_log(h->s.avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
719 int length = (header >> 5) & 3;
721 h->next_slice_index = get_bits_count(&s->gb) + 8*show_bits(&s->gb, 8*length) + 8*length;
723 if (h->next_slice_index > s->gb.size_in_bits) {
724 av_log(h->s.avctx, AV_LOG_ERROR, "slice after bitstream end\n");
728 s->gb.size_in_bits = h->next_slice_index - 8*(length - 1);
729 skip_bits(&s->gb, 8);
731 if (h->svq3_watermark_key) {
732 uint32_t header = AV_RL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1]);
733 AV_WL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1], header ^ h->svq3_watermark_key);
736 memcpy((uint8_t *) &s->gb.buffer[get_bits_count(&s->gb) >> 3],
737 &s->gb.buffer[s->gb.size_in_bits >> 3], (length - 1));
739 skip_bits_long(&s->gb, 0);
742 if ((i = svq3_get_ue_golomb(&s->gb)) == INVALID_VLC || i >= 3){
743 av_log(h->s.avctx, AV_LOG_ERROR, "illegal slice type %d \n", i);
747 h->slice_type = golomb_to_pict_type[i];
749 if ((header & 0x9F) == 2) {
750 i = (s->mb_num < 64) ? 6 : (1 + av_log2 (s->mb_num - 1));
751 s->mb_skip_run = get_bits(&s->gb, i) - (s->mb_x + (s->mb_y * s->mb_width));
757 h->slice_num = get_bits(&s->gb, 8);
758 s->qscale = get_bits(&s->gb, 5);
759 s->adaptive_quant = get_bits1(&s->gb);
764 if (h->unknown_svq3_flag) {
769 skip_bits(&s->gb, 2);
771 while (get_bits1(&s->gb)) {
772 skip_bits(&s->gb, 8);
775 /* reset intra predictors and invalidate motion vector references */
777 memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - 1 ]+3, -1, 4*sizeof(int8_t));
778 memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - s->mb_x] , -1, 8*sizeof(int8_t)*s->mb_x);
781 memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - s->mb_stride], -1, 8*sizeof(int8_t)*(s->mb_width - s->mb_x));
784 h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride - 1]+3] = -1;
791 static av_cold int svq3_decode_init(AVCodecContext *avctx)
793 MpegEncContext *const s = avctx->priv_data;
794 H264Context *const h = avctx->priv_data;
796 unsigned char *extradata;
799 if(avctx->thread_count > 1){
800 av_log(avctx, AV_LOG_ERROR, "SVQ3 does not support multithreaded decoding, patch welcome! (check latest SVN too)\n");
804 if (ff_h264_decode_init(avctx) < 0)
807 s->flags = avctx->flags;
808 s->flags2 = avctx->flags2;
809 s->unrestricted_mv = 1;
811 avctx->pix_fmt = avctx->codec->pix_fmts[0];
813 if (!s->context_initialized) {
814 s->width = avctx->width;
815 s->height = avctx->height;
817 h->thirdpel_flag = 1;
818 h->unknown_svq3_flag = 0;
819 h->chroma_qp[0] = h->chroma_qp[1] = 4;
821 if (MPV_common_init(s) < 0)
824 h->b_stride = 4*s->mb_width;
826 ff_h264_alloc_tables(h);
828 /* prowl for the "SEQH" marker in the extradata */
829 extradata = (unsigned char *)avctx->extradata;
830 for (m = 0; m < avctx->extradata_size; m++) {
831 if (!memcmp(extradata, "SEQH", 4))
836 /* if a match was found, parse the extra data */
837 if (extradata && !memcmp(extradata, "SEQH", 4)) {
842 size = AV_RB32(&extradata[4]);
843 init_get_bits(&gb, extradata + 8, size*8);
845 /* 'frame size code' and optional 'width, height' */
846 frame_size_code = get_bits(&gb, 3);
847 switch (frame_size_code) {
848 case 0: avctx->width = 160; avctx->height = 120; break;
849 case 1: avctx->width = 128; avctx->height = 96; break;
850 case 2: avctx->width = 176; avctx->height = 144; break;
851 case 3: avctx->width = 352; avctx->height = 288; break;
852 case 4: avctx->width = 704; avctx->height = 576; break;
853 case 5: avctx->width = 240; avctx->height = 180; break;
854 case 6: avctx->width = 320; avctx->height = 240; break;
856 avctx->width = get_bits(&gb, 12);
857 avctx->height = get_bits(&gb, 12);
861 h->halfpel_flag = get_bits1(&gb);
862 h->thirdpel_flag = get_bits1(&gb);
870 s->low_delay = get_bits1(&gb);
875 while (get_bits1(&gb)) {
879 h->unknown_svq3_flag = get_bits1(&gb);
880 avctx->has_b_frames = !s->low_delay;
881 if (h->unknown_svq3_flag) {
883 unsigned watermark_width = svq3_get_ue_golomb(&gb);
884 unsigned watermark_height = svq3_get_ue_golomb(&gb);
885 int u1 = svq3_get_ue_golomb(&gb);
886 int u2 = get_bits(&gb, 8);
887 int u3 = get_bits(&gb, 2);
888 int u4 = svq3_get_ue_golomb(&gb);
889 unsigned long buf_len = watermark_width*watermark_height*4;
890 int offset = (get_bits_count(&gb)+7)>>3;
893 if ((uint64_t)watermark_width*4 > UINT_MAX/watermark_height)
896 buf = av_malloc(buf_len);
897 av_log(avctx, AV_LOG_DEBUG, "watermark size: %dx%d\n", watermark_width, watermark_height);
898 av_log(avctx, AV_LOG_DEBUG, "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n", u1, u2, u3, u4, offset);
899 if (uncompress(buf, &buf_len, extradata + 8 + offset, size - offset) != Z_OK) {
900 av_log(avctx, AV_LOG_ERROR, "could not uncompress watermark logo\n");
904 h->svq3_watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
905 h->svq3_watermark_key = h->svq3_watermark_key << 16 | h->svq3_watermark_key;
906 av_log(avctx, AV_LOG_DEBUG, "watermark key %#x\n", h->svq3_watermark_key);
909 av_log(avctx, AV_LOG_ERROR, "this svq3 file contains watermark which need zlib support compiled in\n");
919 static int svq3_decode_frame(AVCodecContext *avctx,
920 void *data, int *data_size,
923 const uint8_t *buf = avpkt->data;
924 int buf_size = avpkt->size;
925 MpegEncContext *const s = avctx->priv_data;
926 H264Context *const h = avctx->priv_data;
929 /* special case for last picture */
931 if (s->next_picture_ptr && !s->low_delay) {
932 *(AVFrame *) data = *(AVFrame *) &s->next_picture;
933 s->next_picture_ptr = NULL;
934 *data_size = sizeof(AVFrame);
939 init_get_bits (&s->gb, buf, 8*buf_size);
941 s->mb_x = s->mb_y = h->mb_xy = 0;
943 if (svq3_decode_slice_header(h))
946 s->pict_type = h->slice_type;
947 s->picture_number = h->slice_num;
949 if (avctx->debug&FF_DEBUG_PICT_INFO){
950 av_log(h->s.avctx, AV_LOG_DEBUG, "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
951 av_get_pict_type_char(s->pict_type), h->halfpel_flag, h->thirdpel_flag,
952 s->adaptive_quant, s->qscale, h->slice_num);
955 /* for hurry_up == 5 */
956 s->current_picture.pict_type = s->pict_type;
957 s->current_picture.key_frame = (s->pict_type == FF_I_TYPE);
959 /* Skip B-frames if we do not have reference frames. */
960 if (s->last_picture_ptr == NULL && s->pict_type == FF_B_TYPE)
962 /* Skip B-frames if we are in a hurry. */
963 if (avctx->hurry_up && s->pict_type == FF_B_TYPE)
965 /* Skip everything if we are in a hurry >= 5. */
966 if (avctx->hurry_up >= 5)
968 if ( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == FF_B_TYPE)
969 ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != FF_I_TYPE)
970 || avctx->skip_frame >= AVDISCARD_ALL)
973 if (s->next_p_frame_damaged) {
974 if (s->pict_type == FF_B_TYPE)
977 s->next_p_frame_damaged = 0;
980 if (ff_h264_frame_start(h) < 0)
983 if (s->pict_type == FF_B_TYPE) {
984 h->frame_num_offset = (h->slice_num - h->prev_frame_num);
986 if (h->frame_num_offset < 0) {
987 h->frame_num_offset += 256;
989 if (h->frame_num_offset == 0 || h->frame_num_offset >= h->prev_frame_num_offset) {
990 av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
994 h->prev_frame_num = h->frame_num;
995 h->frame_num = h->slice_num;
996 h->prev_frame_num_offset = (h->frame_num - h->prev_frame_num);
998 if (h->prev_frame_num_offset < 0) {
999 h->prev_frame_num_offset += 256;
1003 for (m = 0; m < 2; m++){
1005 for (i = 0; i < 4; i++){
1007 for (j = -1; j < 4; j++)
1008 h->ref_cache[m][scan8[0] + 8*i + j]= 1;
1010 h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
1014 for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
1015 for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
1016 h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1018 if ( (get_bits_count(&s->gb) + 7) >= s->gb.size_in_bits &&
1019 ((get_bits_count(&s->gb) & 7) == 0 || show_bits(&s->gb, (-get_bits_count(&s->gb) & 7)) == 0)) {
1021 skip_bits(&s->gb, h->next_slice_index - get_bits_count(&s->gb));
1022 s->gb.size_in_bits = 8*buf_size;
1024 if (svq3_decode_slice_header(h))
1027 /* TODO: support s->mb_skip_run */
1030 mb_type = svq3_get_ue_golomb(&s->gb);
1032 if (s->pict_type == FF_I_TYPE) {
1034 } else if (s->pict_type == FF_B_TYPE && mb_type >= 4) {
1037 if (mb_type > 33 || svq3_decode_mb(h, mb_type)) {
1038 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1043 ff_h264_hl_decode_mb (h);
1046 if (s->pict_type != FF_B_TYPE && !s->low_delay) {
1047 s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride] =
1048 (s->pict_type == FF_P_TYPE && mb_type < 8) ? (mb_type - 1) : -1;
1052 ff_draw_horiz_band(s, 16*s->mb_y, 16);
1057 if (s->pict_type == FF_B_TYPE || s->low_delay) {
1058 *(AVFrame *) data = *(AVFrame *) &s->current_picture;
1060 *(AVFrame *) data = *(AVFrame *) &s->last_picture;
1063 /* Do not output the last pic after seeking. */
1064 if (s->last_picture_ptr || s->low_delay) {
1065 *data_size = sizeof(AVFrame);
1072 AVCodec svq3_decoder = {
1076 sizeof(H264Context),
1081 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
1082 .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1083 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_NONE},