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
128 void ff_svq3_luma_dc_dequant_idct_c(DCTELEM *output, DCTELEM *input, int qp){
129 const int qmul = svq3_dequant_coeff[qp];
133 static const uint8_t x_offset[4]={0, 1*stride, 4*stride, 5*stride};
136 const int z0 = 13*(input[4*i+0] + input[4*i+2]);
137 const int z1 = 13*(input[4*i+0] - input[4*i+2]);
138 const int z2 = 7* input[4*i+1] - 17*input[4*i+3];
139 const int z3 = 17* input[4*i+1] + 7*input[4*i+3];
148 const int offset= x_offset[i];
149 const int z0= 13*(temp[4*0+i] + temp[4*2+i]);
150 const int z1= 13*(temp[4*0+i] - temp[4*2+i]);
151 const int z2= 7* temp[4*1+i] - 17*temp[4*3+i];
152 const int z3= 17* temp[4*1+i] + 7*temp[4*3+i];
154 output[stride* 0+offset] = ((z0 + z3)*qmul + 0x80000) >> 20;
155 output[stride* 2+offset] = ((z1 + z2)*qmul + 0x80000) >> 20;
156 output[stride* 8+offset] = ((z1 - z2)*qmul + 0x80000) >> 20;
157 output[stride*10+offset] = ((z0 - z3)*qmul + 0x80000) >> 20;
162 void ff_svq3_add_idct_c(uint8_t *dst, DCTELEM *block, int stride, int qp,
165 const int qmul = svq3_dequant_coeff[qp];
167 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
170 dc = 13*13*((dc == 1) ? 1538*block[0] : ((qmul*(block[0] >> 3)) / 2));
174 for (i = 0; i < 4; i++) {
175 const int z0 = 13*(block[0 + 4*i] + block[2 + 4*i]);
176 const int z1 = 13*(block[0 + 4*i] - block[2 + 4*i]);
177 const int z2 = 7* block[1 + 4*i] - 17*block[3 + 4*i];
178 const int z3 = 17* block[1 + 4*i] + 7*block[3 + 4*i];
180 block[0 + 4*i] = z0 + z3;
181 block[1 + 4*i] = z1 + z2;
182 block[2 + 4*i] = z1 - z2;
183 block[3 + 4*i] = z0 - z3;
186 for (i = 0; i < 4; i++) {
187 const int z0 = 13*(block[i + 4*0] + block[i + 4*2]);
188 const int z1 = 13*(block[i + 4*0] - block[i + 4*2]);
189 const int z2 = 7* block[i + 4*1] - 17*block[i + 4*3];
190 const int z3 = 17* block[i + 4*1] + 7*block[i + 4*3];
191 const int rr = (dc + 0x80000);
193 dst[i + stride*0] = cm[ dst[i + stride*0] + (((z0 + z3)*qmul + rr) >> 20) ];
194 dst[i + stride*1] = cm[ dst[i + stride*1] + (((z1 + z2)*qmul + rr) >> 20) ];
195 dst[i + stride*2] = cm[ dst[i + stride*2] + (((z1 - z2)*qmul + rr) >> 20) ];
196 dst[i + stride*3] = cm[ dst[i + stride*3] + (((z0 - z3)*qmul + rr) >> 20) ];
200 static inline int svq3_decode_block(GetBitContext *gb, DCTELEM *block,
201 int index, const int type)
203 static const uint8_t *const scan_patterns[4] =
204 { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
206 int run, level, sign, vlc, limit;
207 const int intra = (3 * type) >> 2;
208 const uint8_t *const scan = scan_patterns[type];
210 for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
211 for (; (vlc = svq3_get_ue_golomb(gb)) != 0; index++) {
213 if (vlc == INVALID_VLC)
216 sign = (vlc & 0x1) - 1;
217 vlc = (vlc + 1) >> 1;
223 } else if (vlc < 4) {
228 level = ((vlc + 9) >> 2) - run;
232 run = svq3_dct_tables[intra][vlc].run;
233 level = svq3_dct_tables[intra][vlc].level;
236 level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
239 level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
243 if ((index += run) >= limit)
246 block[scan[index]] = (level ^ sign) - sign;
257 static inline void svq3_mc_dir_part(MpegEncContext *s,
258 int x, int y, int width, int height,
259 int mx, int my, int dxy,
260 int thirdpel, int dir, int avg)
262 const Picture *pic = (dir == 0) ? &s->last_picture : &s->next_picture;
265 int blocksize = 2 - (width>>3); //16->0, 8->1, 4->2
270 if (mx < 0 || mx >= (s->h_edge_pos - width - 1) ||
271 my < 0 || my >= (s->v_edge_pos - height - 1)) {
273 if ((s->flags & CODEC_FLAG_EMU_EDGE)) {
277 mx = av_clip (mx, -16, (s->h_edge_pos - width + 15));
278 my = av_clip (my, -16, (s->v_edge_pos - height + 15));
281 /* form component predictions */
282 dest = s->current_picture.data[0] + x + y*s->linesize;
283 src = pic->data[0] + mx + my*s->linesize;
286 s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, (width + 1), (height + 1),
287 mx, my, s->h_edge_pos, s->v_edge_pos);
288 src = s->edge_emu_buffer;
291 (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->linesize, width, height);
293 (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->linesize, height);
295 if (!(s->flags & CODEC_FLAG_GRAY)) {
296 mx = (mx + (mx < (int) x)) >> 1;
297 my = (my + (my < (int) y)) >> 1;
298 width = (width >> 1);
299 height = (height >> 1);
302 for (i = 1; i < 3; i++) {
303 dest = s->current_picture.data[i] + (x >> 1) + (y >> 1)*s->uvlinesize;
304 src = pic->data[i] + mx + my*s->uvlinesize;
307 s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->uvlinesize, (width + 1), (height + 1),
308 mx, my, (s->h_edge_pos >> 1), (s->v_edge_pos >> 1));
309 src = s->edge_emu_buffer;
312 (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->uvlinesize, width, height);
314 (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->uvlinesize, height);
319 static inline int svq3_mc_dir(H264Context *h, int size, int mode, int dir,
322 int i, j, k, mx, my, dx, dy, x, y;
323 MpegEncContext *const s = (MpegEncContext *) h;
324 const int part_width = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
325 const int part_height = 16 >> ((unsigned) (size + 1) / 3);
326 const int extra_width = (mode == PREDICT_MODE) ? -16*6 : 0;
327 const int h_edge_pos = 6*(s->h_edge_pos - part_width ) - extra_width;
328 const int v_edge_pos = 6*(s->v_edge_pos - part_height) - extra_width;
330 for (i = 0; i < 16; i += part_height) {
331 for (j = 0; j < 16; j += part_width) {
332 const int b_xy = (4*s->mb_x + (j >> 2)) + (4*s->mb_y + (i >> 2))*h->b_stride;
336 k = ((j >> 2) & 1) + ((i >> 1) & 2) + ((j >> 1) & 4) + (i & 8);
338 if (mode != PREDICT_MODE) {
339 pred_motion(h, k, (part_width >> 2), dir, 1, &mx, &my);
341 mx = s->next_picture.motion_val[0][b_xy][0]<<1;
342 my = s->next_picture.motion_val[0][b_xy][1]<<1;
345 mx = ((mx * h->frame_num_offset) / h->prev_frame_num_offset + 1) >> 1;
346 my = ((my * h->frame_num_offset) / h->prev_frame_num_offset + 1) >> 1;
348 mx = ((mx * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1) >> 1;
349 my = ((my * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1) >> 1;
353 /* clip motion vector prediction to frame border */
354 mx = av_clip(mx, extra_width - 6*x, h_edge_pos - 6*x);
355 my = av_clip(my, extra_width - 6*y, v_edge_pos - 6*y);
357 /* get (optional) motion vector differential */
358 if (mode == PREDICT_MODE) {
361 dy = svq3_get_se_golomb(&s->gb);
362 dx = svq3_get_se_golomb(&s->gb);
364 if (dx == INVALID_VLC || dy == INVALID_VLC) {
365 av_log(h->s.avctx, AV_LOG_ERROR, "invalid MV vlc\n");
370 /* compute motion vector */
371 if (mode == THIRDPEL_MODE) {
373 mx = ((mx + 1)>>1) + dx;
374 my = ((my + 1)>>1) + dy;
375 fx = ((unsigned)(mx + 0x3000))/3 - 0x1000;
376 fy = ((unsigned)(my + 0x3000))/3 - 0x1000;
377 dxy = (mx - 3*fx) + 4*(my - 3*fy);
379 svq3_mc_dir_part(s, x, y, part_width, part_height, fx, fy, dxy, 1, dir, avg);
382 } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
383 mx = ((unsigned)(mx + 1 + 0x3000))/3 + dx - 0x1000;
384 my = ((unsigned)(my + 1 + 0x3000))/3 + dy - 0x1000;
385 dxy = (mx&1) + 2*(my&1);
387 svq3_mc_dir_part(s, x, y, part_width, part_height, mx>>1, my>>1, dxy, 0, dir, avg);
391 mx = ((unsigned)(mx + 3 + 0x6000))/6 + dx - 0x1000;
392 my = ((unsigned)(my + 3 + 0x6000))/6 + dy - 0x1000;
394 svq3_mc_dir_part(s, x, y, part_width, part_height, mx, my, 0, 0, dir, avg);
399 /* update mv_cache */
400 if (mode != PREDICT_MODE) {
401 int32_t mv = pack16to32(mx,my);
403 if (part_height == 8 && i < 8) {
404 *(int32_t *) h->mv_cache[dir][scan8[k] + 1*8] = mv;
406 if (part_width == 8 && j < 8) {
407 *(int32_t *) h->mv_cache[dir][scan8[k] + 1 + 1*8] = mv;
410 if (part_width == 8 && j < 8) {
411 *(int32_t *) h->mv_cache[dir][scan8[k] + 1] = mv;
413 if (part_width == 4 || part_height == 4) {
414 *(int32_t *) h->mv_cache[dir][scan8[k]] = mv;
418 /* write back motion vectors */
419 fill_rectangle(s->current_picture.motion_val[dir][b_xy], part_width>>2, part_height>>2, h->b_stride, pack16to32(mx,my), 4);
426 static int svq3_decode_mb(H264Context *h, unsigned int mb_type)
428 int i, j, k, m, dir, mode;
432 MpegEncContext *const s = (MpegEncContext *) h;
433 const int mb_xy = h->mb_xy;
434 const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride;
436 h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
437 h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
438 h->topright_samples_available = 0xFFFF;
440 if (mb_type == 0) { /* SKIP */
441 if (s->pict_type == FF_P_TYPE || s->next_picture.mb_type[mb_xy] == -1) {
442 svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 0, 0);
444 if (s->pict_type == FF_B_TYPE) {
445 svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 1, 1);
448 mb_type = MB_TYPE_SKIP;
450 mb_type = FFMIN(s->next_picture.mb_type[mb_xy], 6);
451 if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 0, 0) < 0)
453 if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 1, 1) < 0)
456 mb_type = MB_TYPE_16x16;
458 } else if (mb_type < 8) { /* INTER */
459 if (h->thirdpel_flag && h->halfpel_flag == !get_bits1 (&s->gb)) {
460 mode = THIRDPEL_MODE;
461 } else if (h->halfpel_flag && h->thirdpel_flag == !get_bits1 (&s->gb)) {
468 /* note ref_cache should contain here:
476 for (m = 0; m < 2; m++) {
477 if (s->mb_x > 0 && h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1]+6] != -1) {
478 for (i = 0; i < 4; i++) {
479 *(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];
482 for (i = 0; i < 4; i++) {
483 *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = 0;
487 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));
488 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);
490 if (s->mb_x < (s->mb_width - 1)) {
491 *(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];
492 h->ref_cache[m][scan8[0] + 4 - 1*8] =
493 (h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride + 1]+6] == -1 ||
494 h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride ] ] == -1) ? PART_NOT_AVAILABLE : 1;
496 h->ref_cache[m][scan8[0] + 4 - 1*8] = PART_NOT_AVAILABLE;
498 *(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];
499 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;
501 h->ref_cache[m][scan8[0] - 1 - 1*8] = PART_NOT_AVAILABLE;
503 memset(&h->ref_cache[m][scan8[0] - 1*8 - 1], PART_NOT_AVAILABLE, 8);
505 if (s->pict_type != FF_B_TYPE)
509 /* decode motion vector(s) and form prediction(s) */
510 if (s->pict_type == FF_P_TYPE) {
511 if (svq3_mc_dir(h, (mb_type - 1), mode, 0, 0) < 0)
513 } else { /* FF_B_TYPE */
515 if (svq3_mc_dir(h, 0, mode, 0, 0) < 0)
518 for (i = 0; i < 4; i++) {
519 memset(s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
523 if (svq3_mc_dir(h, 0, mode, 1, (mb_type == 3)) < 0)
526 for (i = 0; i < 4; i++) {
527 memset(s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
532 mb_type = MB_TYPE_16x16;
533 } else if (mb_type == 8 || mb_type == 33) { /* INTRA4x4 */
534 memset(h->intra4x4_pred_mode_cache, -1, 8*5*sizeof(int8_t));
538 for (i = 0; i < 4; i++) {
539 h->intra4x4_pred_mode_cache[scan8[0] - 1 + i*8] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1]+6-i];
541 if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1) {
542 h->left_samples_available = 0x5F5F;
546 h->intra4x4_pred_mode_cache[4+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+0];
547 h->intra4x4_pred_mode_cache[5+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+1];
548 h->intra4x4_pred_mode_cache[6+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+2];
549 h->intra4x4_pred_mode_cache[7+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+3];
551 if (h->intra4x4_pred_mode_cache[4+8*0] == -1) {
552 h->top_samples_available = 0x33FF;
556 /* decode prediction codes for luma blocks */
557 for (i = 0; i < 16; i+=2) {
558 vlc = svq3_get_ue_golomb(&s->gb);
561 av_log(h->s.avctx, AV_LOG_ERROR, "luma prediction:%d\n", vlc);
565 left = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
566 top = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
568 left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
569 left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
571 if (left[1] == -1 || left[2] == -1){
572 av_log(h->s.avctx, AV_LOG_ERROR, "weird prediction\n");
576 } else { /* mb_type == 33, DC_128_PRED block type */
577 for (i = 0; i < 4; i++) {
578 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_PRED, 4);
582 ff_h264_write_back_intra_pred_mode(h);
585 ff_h264_check_intra4x4_pred_mode(h);
587 h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
588 h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
590 for (i = 0; i < 4; i++) {
591 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_128_PRED, 4);
594 h->top_samples_available = 0x33FF;
595 h->left_samples_available = 0x5F5F;
598 mb_type = MB_TYPE_INTRA4x4;
599 } else { /* INTRA16x16 */
600 dir = i_mb_type_info[mb_type - 8].pred_mode;
601 dir = (dir >> 1) ^ 3*(dir & 1) ^ 1;
603 if ((h->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, dir)) == -1){
604 av_log(h->s.avctx, AV_LOG_ERROR, "check_intra_pred_mode = -1\n");
608 cbp = i_mb_type_info[mb_type - 8].cbp;
609 mb_type = MB_TYPE_INTRA16x16;
612 if (!IS_INTER(mb_type) && s->pict_type != FF_I_TYPE) {
613 for (i = 0; i < 4; i++) {
614 memset(s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
616 if (s->pict_type == FF_B_TYPE) {
617 for (i = 0; i < 4; i++) {
618 memset(s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
622 if (!IS_INTRA4x4(mb_type)) {
623 memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy], DC_PRED, 8);
625 if (!IS_SKIP(mb_type) || s->pict_type == FF_B_TYPE) {
626 memset(h->non_zero_count_cache + 8, 0, 4*9*sizeof(uint8_t));
627 s->dsp.clear_blocks(h->mb);
630 if (!IS_INTRA16x16(mb_type) && (!IS_SKIP(mb_type) || s->pict_type == FF_B_TYPE)) {
631 if ((vlc = svq3_get_ue_golomb(&s->gb)) >= 48){
632 av_log(h->s.avctx, AV_LOG_ERROR, "cbp_vlc=%d\n", vlc);
636 cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc] : golomb_to_inter_cbp[vlc];
638 if (IS_INTRA16x16(mb_type) || (s->pict_type != FF_I_TYPE && s->adaptive_quant && cbp)) {
639 s->qscale += svq3_get_se_golomb(&s->gb);
642 av_log(h->s.avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
646 if (IS_INTRA16x16(mb_type)) {
647 AV_ZERO128(h->mb_luma_dc+0);
648 AV_ZERO128(h->mb_luma_dc+8);
649 if (svq3_decode_block(&s->gb, h->mb_luma_dc, 0, 1)){
650 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding intra luma dc\n");
656 const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
657 const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
659 for (i = 0; i < 4; i++) {
660 if ((cbp & (1 << i))) {
661 for (j = 0; j < 4; j++) {
662 k = index ? ((j&1) + 2*(i&1) + 2*(j&2) + 4*(i&2)) : (4*i + j);
663 h->non_zero_count_cache[ scan8[k] ] = 1;
665 if (svq3_decode_block(&s->gb, &h->mb[16*k], index, type)){
666 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding block\n");
674 for (i = 0; i < 2; ++i) {
675 if (svq3_decode_block(&s->gb, &h->mb[16*(16 + 4*i)], 0, 3)){
676 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma dc block\n");
682 for (i = 0; i < 8; i++) {
683 h->non_zero_count_cache[ scan8[16+i] ] = 1;
685 if (svq3_decode_block(&s->gb, &h->mb[16*(16 + i)], 1, 1)){
686 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma ac block\n");
695 s->current_picture.mb_type[mb_xy] = mb_type;
697 if (IS_INTRA(mb_type)) {
698 h->chroma_pred_mode = ff_h264_check_intra_pred_mode(h, DC_PRED8x8);
704 static int svq3_decode_slice_header(H264Context *h)
706 MpegEncContext *const s = (MpegEncContext *) h;
707 const int mb_xy = h->mb_xy;
710 header = get_bits(&s->gb, 8);
712 if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
714 av_log(h->s.avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
717 int length = (header >> 5) & 3;
719 h->next_slice_index = get_bits_count(&s->gb) + 8*show_bits(&s->gb, 8*length) + 8*length;
721 if (h->next_slice_index > s->gb.size_in_bits) {
722 av_log(h->s.avctx, AV_LOG_ERROR, "slice after bitstream end\n");
726 s->gb.size_in_bits = h->next_slice_index - 8*(length - 1);
727 skip_bits(&s->gb, 8);
729 if (h->svq3_watermark_key) {
730 uint32_t header = AV_RL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1]);
731 AV_WL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1], header ^ h->svq3_watermark_key);
734 memcpy((uint8_t *) &s->gb.buffer[get_bits_count(&s->gb) >> 3],
735 &s->gb.buffer[s->gb.size_in_bits >> 3], (length - 1));
737 skip_bits_long(&s->gb, 0);
740 if ((i = svq3_get_ue_golomb(&s->gb)) == INVALID_VLC || i >= 3){
741 av_log(h->s.avctx, AV_LOG_ERROR, "illegal slice type %d \n", i);
745 h->slice_type = golomb_to_pict_type[i];
747 if ((header & 0x9F) == 2) {
748 i = (s->mb_num < 64) ? 6 : (1 + av_log2 (s->mb_num - 1));
749 s->mb_skip_run = get_bits(&s->gb, i) - (s->mb_x + (s->mb_y * s->mb_width));
755 h->slice_num = get_bits(&s->gb, 8);
756 s->qscale = get_bits(&s->gb, 5);
757 s->adaptive_quant = get_bits1(&s->gb);
762 if (h->unknown_svq3_flag) {
767 skip_bits(&s->gb, 2);
769 while (get_bits1(&s->gb)) {
770 skip_bits(&s->gb, 8);
773 /* reset intra predictors and invalidate motion vector references */
775 memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - 1 ]+3, -1, 4*sizeof(int8_t));
776 memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - s->mb_x] , -1, 8*sizeof(int8_t)*s->mb_x);
779 memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - s->mb_stride], -1, 8*sizeof(int8_t)*(s->mb_width - s->mb_x));
782 h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride - 1]+3] = -1;
789 static av_cold int svq3_decode_init(AVCodecContext *avctx)
791 MpegEncContext *const s = avctx->priv_data;
792 H264Context *const h = avctx->priv_data;
794 unsigned char *extradata;
797 if (ff_h264_decode_init(avctx) < 0)
800 s->flags = avctx->flags;
801 s->flags2 = avctx->flags2;
802 s->unrestricted_mv = 1;
804 avctx->pix_fmt = avctx->codec->pix_fmts[0];
806 if (!s->context_initialized) {
807 s->width = avctx->width;
808 s->height = avctx->height;
810 h->thirdpel_flag = 1;
811 h->unknown_svq3_flag = 0;
812 h->chroma_qp[0] = h->chroma_qp[1] = 4;
814 if (MPV_common_init(s) < 0)
817 h->b_stride = 4*s->mb_width;
819 ff_h264_alloc_tables(h);
821 /* prowl for the "SEQH" marker in the extradata */
822 extradata = (unsigned char *)avctx->extradata;
823 for (m = 0; m < avctx->extradata_size; m++) {
824 if (!memcmp(extradata, "SEQH", 4))
829 /* if a match was found, parse the extra data */
830 if (extradata && !memcmp(extradata, "SEQH", 4)) {
835 size = AV_RB32(&extradata[4]);
836 init_get_bits(&gb, extradata + 8, size*8);
838 /* 'frame size code' and optional 'width, height' */
839 frame_size_code = get_bits(&gb, 3);
840 switch (frame_size_code) {
841 case 0: avctx->width = 160; avctx->height = 120; break;
842 case 1: avctx->width = 128; avctx->height = 96; break;
843 case 2: avctx->width = 176; avctx->height = 144; break;
844 case 3: avctx->width = 352; avctx->height = 288; break;
845 case 4: avctx->width = 704; avctx->height = 576; break;
846 case 5: avctx->width = 240; avctx->height = 180; break;
847 case 6: avctx->width = 320; avctx->height = 240; break;
849 avctx->width = get_bits(&gb, 12);
850 avctx->height = get_bits(&gb, 12);
854 h->halfpel_flag = get_bits1(&gb);
855 h->thirdpel_flag = get_bits1(&gb);
863 s->low_delay = get_bits1(&gb);
868 while (get_bits1(&gb)) {
872 h->unknown_svq3_flag = get_bits1(&gb);
873 avctx->has_b_frames = !s->low_delay;
874 if (h->unknown_svq3_flag) {
876 unsigned watermark_width = svq3_get_ue_golomb(&gb);
877 unsigned watermark_height = svq3_get_ue_golomb(&gb);
878 int u1 = svq3_get_ue_golomb(&gb);
879 int u2 = get_bits(&gb, 8);
880 int u3 = get_bits(&gb, 2);
881 int u4 = svq3_get_ue_golomb(&gb);
882 unsigned long buf_len = watermark_width*watermark_height*4;
883 int offset = (get_bits_count(&gb)+7)>>3;
886 if ((uint64_t)watermark_width*4 > UINT_MAX/watermark_height)
889 buf = av_malloc(buf_len);
890 av_log(avctx, AV_LOG_DEBUG, "watermark size: %dx%d\n", watermark_width, watermark_height);
891 av_log(avctx, AV_LOG_DEBUG, "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n", u1, u2, u3, u4, offset);
892 if (uncompress(buf, &buf_len, extradata + 8 + offset, size - offset) != Z_OK) {
893 av_log(avctx, AV_LOG_ERROR, "could not uncompress watermark logo\n");
897 h->svq3_watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
898 h->svq3_watermark_key = h->svq3_watermark_key << 16 | h->svq3_watermark_key;
899 av_log(avctx, AV_LOG_DEBUG, "watermark key %#x\n", h->svq3_watermark_key);
902 av_log(avctx, AV_LOG_ERROR, "this svq3 file contains watermark which need zlib support compiled in\n");
912 static int svq3_decode_frame(AVCodecContext *avctx,
913 void *data, int *data_size,
916 const uint8_t *buf = avpkt->data;
917 int buf_size = avpkt->size;
918 MpegEncContext *const s = avctx->priv_data;
919 H264Context *const h = avctx->priv_data;
922 /* special case for last picture */
924 if (s->next_picture_ptr && !s->low_delay) {
925 *(AVFrame *) data = *(AVFrame *) &s->next_picture;
926 s->next_picture_ptr = NULL;
927 *data_size = sizeof(AVFrame);
932 init_get_bits (&s->gb, buf, 8*buf_size);
934 s->mb_x = s->mb_y = h->mb_xy = 0;
936 if (svq3_decode_slice_header(h))
939 s->pict_type = h->slice_type;
940 s->picture_number = h->slice_num;
942 if (avctx->debug&FF_DEBUG_PICT_INFO){
943 av_log(h->s.avctx, AV_LOG_DEBUG, "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
944 av_get_pict_type_char(s->pict_type), h->halfpel_flag, h->thirdpel_flag,
945 s->adaptive_quant, s->qscale, h->slice_num);
948 /* for hurry_up == 5 */
949 s->current_picture.pict_type = s->pict_type;
950 s->current_picture.key_frame = (s->pict_type == FF_I_TYPE);
952 /* Skip B-frames if we do not have reference frames. */
953 if (s->last_picture_ptr == NULL && s->pict_type == FF_B_TYPE)
955 /* Skip B-frames if we are in a hurry. */
956 if (avctx->hurry_up && s->pict_type == FF_B_TYPE)
958 /* Skip everything if we are in a hurry >= 5. */
959 if (avctx->hurry_up >= 5)
961 if ( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == FF_B_TYPE)
962 ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != FF_I_TYPE)
963 || avctx->skip_frame >= AVDISCARD_ALL)
966 if (s->next_p_frame_damaged) {
967 if (s->pict_type == FF_B_TYPE)
970 s->next_p_frame_damaged = 0;
973 if (ff_h264_frame_start(h) < 0)
976 if (s->pict_type == FF_B_TYPE) {
977 h->frame_num_offset = (h->slice_num - h->prev_frame_num);
979 if (h->frame_num_offset < 0) {
980 h->frame_num_offset += 256;
982 if (h->frame_num_offset == 0 || h->frame_num_offset >= h->prev_frame_num_offset) {
983 av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
987 h->prev_frame_num = h->frame_num;
988 h->frame_num = h->slice_num;
989 h->prev_frame_num_offset = (h->frame_num - h->prev_frame_num);
991 if (h->prev_frame_num_offset < 0) {
992 h->prev_frame_num_offset += 256;
996 for (m = 0; m < 2; m++){
998 for (i = 0; i < 4; i++){
1000 for (j = -1; j < 4; j++)
1001 h->ref_cache[m][scan8[0] + 8*i + j]= 1;
1003 h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
1007 for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
1008 for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
1009 h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1011 if ( (get_bits_count(&s->gb) + 7) >= s->gb.size_in_bits &&
1012 ((get_bits_count(&s->gb) & 7) == 0 || show_bits(&s->gb, (-get_bits_count(&s->gb) & 7)) == 0)) {
1014 skip_bits(&s->gb, h->next_slice_index - get_bits_count(&s->gb));
1015 s->gb.size_in_bits = 8*buf_size;
1017 if (svq3_decode_slice_header(h))
1020 /* TODO: support s->mb_skip_run */
1023 mb_type = svq3_get_ue_golomb(&s->gb);
1025 if (s->pict_type == FF_I_TYPE) {
1027 } else if (s->pict_type == FF_B_TYPE && mb_type >= 4) {
1030 if (mb_type > 33 || svq3_decode_mb(h, mb_type)) {
1031 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1036 ff_h264_hl_decode_mb (h);
1039 if (s->pict_type != FF_B_TYPE && !s->low_delay) {
1040 s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride] =
1041 (s->pict_type == FF_P_TYPE && mb_type < 8) ? (mb_type - 1) : -1;
1045 ff_draw_horiz_band(s, 16*s->mb_y, 16);
1050 if (s->pict_type == FF_B_TYPE || s->low_delay) {
1051 *(AVFrame *) data = *(AVFrame *) &s->current_picture;
1053 *(AVFrame *) data = *(AVFrame *) &s->last_picture;
1056 /* Do not output the last pic after seeking. */
1057 if (s->last_picture_ptr || s->low_delay) {
1058 *data_size = sizeof(AVFrame);
1065 AVCodec ff_svq3_decoder = {
1069 sizeof(H264Context),
1074 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
1075 .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
1076 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_NONE},