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 (ff_h264_decode_init(avctx) < 0)
802 s->flags = avctx->flags;
803 s->flags2 = avctx->flags2;
804 s->unrestricted_mv = 1;
806 avctx->pix_fmt = avctx->codec->pix_fmts[0];
808 if (!s->context_initialized) {
809 s->width = avctx->width;
810 s->height = avctx->height;
812 h->thirdpel_flag = 1;
813 h->unknown_svq3_flag = 0;
814 h->chroma_qp[0] = h->chroma_qp[1] = 4;
816 if (MPV_common_init(s) < 0)
819 h->b_stride = 4*s->mb_width;
821 ff_h264_alloc_tables(h);
823 /* prowl for the "SEQH" marker in the extradata */
824 extradata = (unsigned char *)avctx->extradata;
825 for (m = 0; m < avctx->extradata_size; m++) {
826 if (!memcmp(extradata, "SEQH", 4))
831 /* if a match was found, parse the extra data */
832 if (extradata && !memcmp(extradata, "SEQH", 4)) {
837 size = AV_RB32(&extradata[4]);
838 init_get_bits(&gb, extradata + 8, size*8);
840 /* 'frame size code' and optional 'width, height' */
841 frame_size_code = get_bits(&gb, 3);
842 switch (frame_size_code) {
843 case 0: avctx->width = 160; avctx->height = 120; break;
844 case 1: avctx->width = 128; avctx->height = 96; break;
845 case 2: avctx->width = 176; avctx->height = 144; break;
846 case 3: avctx->width = 352; avctx->height = 288; break;
847 case 4: avctx->width = 704; avctx->height = 576; break;
848 case 5: avctx->width = 240; avctx->height = 180; break;
849 case 6: avctx->width = 320; avctx->height = 240; break;
851 avctx->width = get_bits(&gb, 12);
852 avctx->height = get_bits(&gb, 12);
856 h->halfpel_flag = get_bits1(&gb);
857 h->thirdpel_flag = get_bits1(&gb);
865 s->low_delay = get_bits1(&gb);
870 while (get_bits1(&gb)) {
874 h->unknown_svq3_flag = get_bits1(&gb);
875 avctx->has_b_frames = !s->low_delay;
876 if (h->unknown_svq3_flag) {
878 unsigned watermark_width = svq3_get_ue_golomb(&gb);
879 unsigned watermark_height = svq3_get_ue_golomb(&gb);
880 int u1 = svq3_get_ue_golomb(&gb);
881 int u2 = get_bits(&gb, 8);
882 int u3 = get_bits(&gb, 2);
883 int u4 = svq3_get_ue_golomb(&gb);
884 unsigned long buf_len = watermark_width*watermark_height*4;
885 int offset = (get_bits_count(&gb)+7)>>3;
888 if ((uint64_t)watermark_width*4 > UINT_MAX/watermark_height)
891 buf = av_malloc(buf_len);
892 av_log(avctx, AV_LOG_DEBUG, "watermark size: %dx%d\n", watermark_width, watermark_height);
893 av_log(avctx, AV_LOG_DEBUG, "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n", u1, u2, u3, u4, offset);
894 if (uncompress(buf, &buf_len, extradata + 8 + offset, size - offset) != Z_OK) {
895 av_log(avctx, AV_LOG_ERROR, "could not uncompress watermark logo\n");
899 h->svq3_watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
900 h->svq3_watermark_key = h->svq3_watermark_key << 16 | h->svq3_watermark_key;
901 av_log(avctx, AV_LOG_DEBUG, "watermark key %#x\n", h->svq3_watermark_key);
904 av_log(avctx, AV_LOG_ERROR, "this svq3 file contains watermark which need zlib support compiled in\n");
914 static int svq3_decode_frame(AVCodecContext *avctx,
915 void *data, int *data_size,
918 const uint8_t *buf = avpkt->data;
919 int buf_size = avpkt->size;
920 MpegEncContext *const s = avctx->priv_data;
921 H264Context *const h = avctx->priv_data;
924 /* special case for last picture */
926 if (s->next_picture_ptr && !s->low_delay) {
927 *(AVFrame *) data = *(AVFrame *) &s->next_picture;
928 s->next_picture_ptr = NULL;
929 *data_size = sizeof(AVFrame);
934 init_get_bits (&s->gb, buf, 8*buf_size);
936 s->mb_x = s->mb_y = h->mb_xy = 0;
938 if (svq3_decode_slice_header(h))
941 s->pict_type = h->slice_type;
942 s->picture_number = h->slice_num;
944 if (avctx->debug&FF_DEBUG_PICT_INFO){
945 av_log(h->s.avctx, AV_LOG_DEBUG, "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
946 av_get_pict_type_char(s->pict_type), h->halfpel_flag, h->thirdpel_flag,
947 s->adaptive_quant, s->qscale, h->slice_num);
950 /* for hurry_up == 5 */
951 s->current_picture.pict_type = s->pict_type;
952 s->current_picture.key_frame = (s->pict_type == FF_I_TYPE);
954 /* Skip B-frames if we do not have reference frames. */
955 if (s->last_picture_ptr == NULL && s->pict_type == FF_B_TYPE)
957 /* Skip B-frames if we are in a hurry. */
958 if (avctx->hurry_up && s->pict_type == FF_B_TYPE)
960 /* Skip everything if we are in a hurry >= 5. */
961 if (avctx->hurry_up >= 5)
963 if ( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == FF_B_TYPE)
964 ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != FF_I_TYPE)
965 || avctx->skip_frame >= AVDISCARD_ALL)
968 if (s->next_p_frame_damaged) {
969 if (s->pict_type == FF_B_TYPE)
972 s->next_p_frame_damaged = 0;
975 if (ff_h264_frame_start(h) < 0)
978 if (s->pict_type == FF_B_TYPE) {
979 h->frame_num_offset = (h->slice_num - h->prev_frame_num);
981 if (h->frame_num_offset < 0) {
982 h->frame_num_offset += 256;
984 if (h->frame_num_offset == 0 || h->frame_num_offset >= h->prev_frame_num_offset) {
985 av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
989 h->prev_frame_num = h->frame_num;
990 h->frame_num = h->slice_num;
991 h->prev_frame_num_offset = (h->frame_num - h->prev_frame_num);
993 if (h->prev_frame_num_offset < 0) {
994 h->prev_frame_num_offset += 256;
998 for (m = 0; m < 2; m++){
1000 for (i = 0; i < 4; i++){
1002 for (j = -1; j < 4; j++)
1003 h->ref_cache[m][scan8[0] + 8*i + j]= 1;
1005 h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
1009 for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
1010 for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
1011 h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1013 if ( (get_bits_count(&s->gb) + 7) >= s->gb.size_in_bits &&
1014 ((get_bits_count(&s->gb) & 7) == 0 || show_bits(&s->gb, (-get_bits_count(&s->gb) & 7)) == 0)) {
1016 skip_bits(&s->gb, h->next_slice_index - get_bits_count(&s->gb));
1017 s->gb.size_in_bits = 8*buf_size;
1019 if (svq3_decode_slice_header(h))
1022 /* TODO: support s->mb_skip_run */
1025 mb_type = svq3_get_ue_golomb(&s->gb);
1027 if (s->pict_type == FF_I_TYPE) {
1029 } else if (s->pict_type == FF_B_TYPE && mb_type >= 4) {
1032 if (mb_type > 33 || svq3_decode_mb(h, mb_type)) {
1033 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1038 ff_h264_hl_decode_mb (h);
1041 if (s->pict_type != FF_B_TYPE && !s->low_delay) {
1042 s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride] =
1043 (s->pict_type == FF_P_TYPE && mb_type < 8) ? (mb_type - 1) : -1;
1047 ff_draw_horiz_band(s, 16*s->mb_y, 16);
1052 if (s->pict_type == FF_B_TYPE || s->low_delay) {
1053 *(AVFrame *) data = *(AVFrame *) &s->current_picture;
1055 *(AVFrame *) data = *(AVFrame *) &s->last_picture;
1058 /* Do not output the last pic after seeking. */
1059 if (s->last_picture_ptr || s->low_delay) {
1060 *data_size = sizeof(AVFrame);
1067 AVCodec svq3_decoder = {
1071 sizeof(H264Context),
1076 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
1077 .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1078 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_NONE},