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 * ftp://ftp.mplayerhq.hu/MPlayer/samples/V-codecs/SVQ3/Vertical400kbit.sorenson3.mov
54 #define FULLPEL_MODE 1
55 #define HALFPEL_MODE 2
56 #define THIRDPEL_MODE 3
57 #define PREDICT_MODE 4
59 /* dual scan (from some older h264 draft)
68 static const uint8_t svq3_scan
[16]={
69 0+0*4, 1+0*4, 2+0*4, 2+1*4,
70 2+2*4, 3+0*4, 3+1*4, 3+2*4,
71 0+1*4, 0+2*4, 1+1*4, 1+2*4,
72 0+3*4, 1+3*4, 2+3*4, 3+3*4,
75 static const uint8_t svq3_pred_0
[25][2] = {
78 { 0, 2 }, { 1, 1 }, { 2, 0 },
79 { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
80 { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
81 { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
82 { 2, 4 }, { 3, 3 }, { 4, 2 },
87 static const int8_t svq3_pred_1
[6][6][5] = {
88 { { 2,-1,-1,-1,-1 }, { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 },
89 { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 }, { 1, 2,-1,-1,-1 } },
90 { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
91 { 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
92 { { 2, 0,-1,-1,-1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
93 { 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
94 { { 2, 0,-1,-1,-1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
95 { 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
96 { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
97 { 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
98 { { 0, 2,-1,-1,-1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
99 { 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
102 static const struct { uint8_t run
; uint8_t level
; } svq3_dct_tables
[2][16] = {
103 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
104 { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
105 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
106 { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
109 static const uint32_t svq3_dequant_coeff
[32] = {
110 3881, 4351, 4890, 5481, 6154, 6914, 7761, 8718,
111 9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
112 24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
113 61694, 68745, 77615, 89113,100253,109366,126635,141533
117 static void svq3_luma_dc_dequant_idct_c(DCTELEM
*block
, int qp
){
118 const int qmul
= svq3_dequant_coeff
[qp
];
122 static const int x_offset
[4]={0, 1*stride
, 4* stride
, 5*stride
};
123 static const int y_offset
[4]={0, 2*stride
, 8* stride
, 10*stride
};
126 const int offset
= y_offset
[i
];
127 const int z0
= 13*(block
[offset
+stride
*0] + block
[offset
+stride
*4]);
128 const int z1
= 13*(block
[offset
+stride
*0] - block
[offset
+stride
*4]);
129 const int z2
= 7* block
[offset
+stride
*1] - 17*block
[offset
+stride
*5];
130 const int z3
= 17* block
[offset
+stride
*1] + 7*block
[offset
+stride
*5];
139 const int offset
= x_offset
[i
];
140 const int z0
= 13*(temp
[4*0+i
] + temp
[4*2+i
]);
141 const int z1
= 13*(temp
[4*0+i
] - temp
[4*2+i
]);
142 const int z2
= 7* temp
[4*1+i
] - 17*temp
[4*3+i
];
143 const int z3
= 17* temp
[4*1+i
] + 7*temp
[4*3+i
];
145 block
[stride
*0 +offset
]= ((z0
+ z3
)*qmul
+ 0x80000)>>20;
146 block
[stride
*2 +offset
]= ((z1
+ z2
)*qmul
+ 0x80000)>>20;
147 block
[stride
*8 +offset
]= ((z1
- z2
)*qmul
+ 0x80000)>>20;
148 block
[stride
*10+offset
]= ((z0
- z3
)*qmul
+ 0x80000)>>20;
153 static void svq3_add_idct_c (uint8_t *dst
, DCTELEM
*block
, int stride
, int qp
, int dc
){
154 const int qmul
= svq3_dequant_coeff
[qp
];
156 uint8_t *cm
= ff_cropTbl
+ MAX_NEG_CROP
;
159 dc
= 13*13*((dc
== 1) ? 1538*block
[0] : ((qmul
*(block
[0] >> 3)) / 2));
163 for (i
=0; i
< 4; i
++) {
164 const int z0
= 13*(block
[0 + 4*i
] + block
[2 + 4*i
]);
165 const int z1
= 13*(block
[0 + 4*i
] - block
[2 + 4*i
]);
166 const int z2
= 7* block
[1 + 4*i
] - 17*block
[3 + 4*i
];
167 const int z3
= 17* block
[1 + 4*i
] + 7*block
[3 + 4*i
];
169 block
[0 + 4*i
]= z0
+ z3
;
170 block
[1 + 4*i
]= z1
+ z2
;
171 block
[2 + 4*i
]= z1
- z2
;
172 block
[3 + 4*i
]= z0
- z3
;
175 for (i
=0; i
< 4; i
++) {
176 const int z0
= 13*(block
[i
+ 4*0] + block
[i
+ 4*2]);
177 const int z1
= 13*(block
[i
+ 4*0] - block
[i
+ 4*2]);
178 const int z2
= 7* block
[i
+ 4*1] - 17*block
[i
+ 4*3];
179 const int z3
= 17* block
[i
+ 4*1] + 7*block
[i
+ 4*3];
180 const int rr
= (dc
+ 0x80000);
182 dst
[i
+ stride
*0]= cm
[ dst
[i
+ stride
*0] + (((z0
+ z3
)*qmul
+ rr
) >> 20) ];
183 dst
[i
+ stride
*1]= cm
[ dst
[i
+ stride
*1] + (((z1
+ z2
)*qmul
+ rr
) >> 20) ];
184 dst
[i
+ stride
*2]= cm
[ dst
[i
+ stride
*2] + (((z1
- z2
)*qmul
+ rr
) >> 20) ];
185 dst
[i
+ stride
*3]= cm
[ dst
[i
+ stride
*3] + (((z0
- z3
)*qmul
+ rr
) >> 20) ];
189 static inline int svq3_decode_block (GetBitContext
*gb
, DCTELEM
*block
,
190 int index
, const int type
) {
192 static const uint8_t *const scan_patterns
[4] =
193 { luma_dc_zigzag_scan
, zigzag_scan
, svq3_scan
, chroma_dc_scan
};
195 int run
, level
, sign
, vlc
, limit
;
196 const int intra
= (3 * type
) >> 2;
197 const uint8_t *const scan
= scan_patterns
[type
];
199 for (limit
=(16 >> intra
); index
< 16; index
=limit
, limit
+=8) {
200 for (; (vlc
= svq3_get_ue_golomb (gb
)) != 0; index
++) {
202 if (vlc
== INVALID_VLC
)
205 sign
= (vlc
& 0x1) - 1;
206 vlc
= (vlc
+ 1) >> 1;
212 } else if (vlc
< 4) {
217 level
= ((vlc
+ 9) >> 2) - run
;
221 run
= svq3_dct_tables
[intra
][vlc
].run
;
222 level
= svq3_dct_tables
[intra
][vlc
].level
;
225 level
= (vlc
>> 3) + ((run
== 0) ? 8 : ((run
< 2) ? 2 : ((run
< 5) ? 0 : -1)));
228 level
= (vlc
>> 4) + ((run
== 0) ? 4 : ((run
< 3) ? 2 : ((run
< 10) ? 1 : 0)));
232 if ((index
+= run
) >= limit
)
235 block
[scan
[index
]] = (level
^ sign
) - sign
;
246 static inline void svq3_mc_dir_part (MpegEncContext
*s
,
247 int x
, int y
, int width
, int height
,
248 int mx
, int my
, int dxy
,
249 int thirdpel
, int dir
, int avg
) {
251 const Picture
*pic
= (dir
== 0) ? &s
->last_picture
: &s
->next_picture
;
254 int blocksize
= 2 - (width
>>3); //16->0, 8->1, 4->2
259 if (mx
< 0 || mx
>= (s
->h_edge_pos
- width
- 1) ||
260 my
< 0 || my
>= (s
->v_edge_pos
- height
- 1)) {
262 if ((s
->flags
& CODEC_FLAG_EMU_EDGE
)) {
266 mx
= av_clip (mx
, -16, (s
->h_edge_pos
- width
+ 15));
267 my
= av_clip (my
, -16, (s
->v_edge_pos
- height
+ 15));
270 /* form component predictions */
271 dest
= s
->current_picture
.data
[0] + x
+ y
*s
->linesize
;
272 src
= pic
->data
[0] + mx
+ my
*s
->linesize
;
275 ff_emulated_edge_mc (s
->edge_emu_buffer
, src
, s
->linesize
, (width
+ 1), (height
+ 1),
276 mx
, my
, s
->h_edge_pos
, s
->v_edge_pos
);
277 src
= s
->edge_emu_buffer
;
280 (avg
? s
->dsp
.avg_tpel_pixels_tab
: s
->dsp
.put_tpel_pixels_tab
)[dxy
](dest
, src
, s
->linesize
, width
, height
);
282 (avg
? s
->dsp
.avg_pixels_tab
: s
->dsp
.put_pixels_tab
)[blocksize
][dxy
](dest
, src
, s
->linesize
, height
);
284 if (!(s
->flags
& CODEC_FLAG_GRAY
)) {
285 mx
= (mx
+ (mx
< (int) x
)) >> 1;
286 my
= (my
+ (my
< (int) y
)) >> 1;
287 width
= (width
>> 1);
288 height
= (height
>> 1);
291 for (i
=1; i
< 3; i
++) {
292 dest
= s
->current_picture
.data
[i
] + (x
>> 1) + (y
>> 1)*s
->uvlinesize
;
293 src
= pic
->data
[i
] + mx
+ my
*s
->uvlinesize
;
296 ff_emulated_edge_mc (s
->edge_emu_buffer
, src
, s
->uvlinesize
, (width
+ 1), (height
+ 1),
297 mx
, my
, (s
->h_edge_pos
>> 1), (s
->v_edge_pos
>> 1));
298 src
= s
->edge_emu_buffer
;
301 (avg
? s
->dsp
.avg_tpel_pixels_tab
: s
->dsp
.put_tpel_pixels_tab
)[dxy
](dest
, src
, s
->uvlinesize
, width
, height
);
303 (avg
? s
->dsp
.avg_pixels_tab
: s
->dsp
.put_pixels_tab
)[blocksize
][dxy
](dest
, src
, s
->uvlinesize
, height
);
308 static inline int svq3_mc_dir (H264Context
*h
, int size
, int mode
, int dir
, int avg
) {
310 int i
, j
, k
, mx
, my
, dx
, dy
, x
, y
;
311 MpegEncContext
*const s
= (MpegEncContext
*) h
;
312 const int part_width
= ((size
& 5) == 4) ? 4 : 16 >> (size
& 1);
313 const int part_height
= 16 >> ((unsigned) (size
+ 1) / 3);
314 const int extra_width
= (mode
== PREDICT_MODE
) ? -16*6 : 0;
315 const int h_edge_pos
= 6*(s
->h_edge_pos
- part_width
) - extra_width
;
316 const int v_edge_pos
= 6*(s
->v_edge_pos
- part_height
) - extra_width
;
318 for (i
=0; i
< 16; i
+=part_height
) {
319 for (j
=0; j
< 16; j
+=part_width
) {
320 const int b_xy
= (4*s
->mb_x
+(j
>>2)) + (4*s
->mb_y
+(i
>>2))*h
->b_stride
;
324 k
= ((j
>>2)&1) + ((i
>>1)&2) + ((j
>>1)&4) + (i
&8);
326 if (mode
!= PREDICT_MODE
) {
327 pred_motion (h
, k
, (part_width
>> 2), dir
, 1, &mx
, &my
);
329 mx
= s
->next_picture
.motion_val
[0][b_xy
][0]<<1;
330 my
= s
->next_picture
.motion_val
[0][b_xy
][1]<<1;
333 mx
= ((mx
* h
->frame_num_offset
) / h
->prev_frame_num_offset
+ 1)>>1;
334 my
= ((my
* h
->frame_num_offset
) / h
->prev_frame_num_offset
+ 1)>>1;
336 mx
= ((mx
* (h
->frame_num_offset
- h
->prev_frame_num_offset
)) / h
->prev_frame_num_offset
+ 1)>>1;
337 my
= ((my
* (h
->frame_num_offset
- h
->prev_frame_num_offset
)) / h
->prev_frame_num_offset
+ 1)>>1;
341 /* clip motion vector prediction to frame border */
342 mx
= av_clip (mx
, extra_width
- 6*x
, h_edge_pos
- 6*x
);
343 my
= av_clip (my
, extra_width
- 6*y
, v_edge_pos
- 6*y
);
345 /* get (optional) motion vector differential */
346 if (mode
== PREDICT_MODE
) {
349 dy
= svq3_get_se_golomb (&s
->gb
);
350 dx
= svq3_get_se_golomb (&s
->gb
);
352 if (dx
== INVALID_VLC
|| dy
== INVALID_VLC
) {
353 av_log(h
->s
.avctx
, AV_LOG_ERROR
, "invalid MV vlc\n");
358 /* compute motion vector */
359 if (mode
== THIRDPEL_MODE
) {
361 mx
= ((mx
+ 1)>>1) + dx
;
362 my
= ((my
+ 1)>>1) + dy
;
363 fx
= ((unsigned)(mx
+ 0x3000))/3 - 0x1000;
364 fy
= ((unsigned)(my
+ 0x3000))/3 - 0x1000;
365 dxy
= (mx
- 3*fx
) + 4*(my
- 3*fy
);
367 svq3_mc_dir_part (s
, x
, y
, part_width
, part_height
, fx
, fy
, dxy
, 1, dir
, avg
);
370 } else if (mode
== HALFPEL_MODE
|| mode
== PREDICT_MODE
) {
371 mx
= ((unsigned)(mx
+ 1 + 0x3000))/3 + dx
- 0x1000;
372 my
= ((unsigned)(my
+ 1 + 0x3000))/3 + dy
- 0x1000;
373 dxy
= (mx
&1) + 2*(my
&1);
375 svq3_mc_dir_part (s
, x
, y
, part_width
, part_height
, mx
>>1, my
>>1, dxy
, 0, dir
, avg
);
379 mx
= ((unsigned)(mx
+ 3 + 0x6000))/6 + dx
- 0x1000;
380 my
= ((unsigned)(my
+ 3 + 0x6000))/6 + dy
- 0x1000;
382 svq3_mc_dir_part (s
, x
, y
, part_width
, part_height
, mx
, my
, 0, 0, dir
, avg
);
387 /* update mv_cache */
388 if (mode
!= PREDICT_MODE
) {
389 int32_t mv
= pack16to32(mx
,my
);
391 if (part_height
== 8 && i
< 8) {
392 *(int32_t *) h
->mv_cache
[dir
][scan8
[k
] + 1*8] = mv
;
394 if (part_width
== 8 && j
< 8) {
395 *(int32_t *) h
->mv_cache
[dir
][scan8
[k
] + 1 + 1*8] = mv
;
398 if (part_width
== 8 && j
< 8) {
399 *(int32_t *) h
->mv_cache
[dir
][scan8
[k
] + 1] = mv
;
401 if (part_width
== 4 || part_height
== 4) {
402 *(int32_t *) h
->mv_cache
[dir
][scan8
[k
]] = mv
;
406 /* write back motion vectors */
407 fill_rectangle(s
->current_picture
.motion_val
[dir
][b_xy
], part_width
>>2, part_height
>>2, h
->b_stride
, pack16to32(mx
,my
), 4);
414 static int svq3_decode_mb (H264Context
*h
, unsigned int mb_type
) {
415 int i
, j
, k
, m
, dir
, mode
;
419 MpegEncContext
*const s
= (MpegEncContext
*) h
;
420 const int mb_xy
= h
->mb_xy
;
421 const int b_xy
= 4*s
->mb_x
+ 4*s
->mb_y
*h
->b_stride
;
423 h
->top_samples_available
= (s
->mb_y
== 0) ? 0x33FF : 0xFFFF;
424 h
->left_samples_available
= (s
->mb_x
== 0) ? 0x5F5F : 0xFFFF;
425 h
->topright_samples_available
= 0xFFFF;
427 if (mb_type
== 0) { /* SKIP */
428 if (s
->pict_type
== FF_P_TYPE
|| s
->next_picture
.mb_type
[mb_xy
] == -1) {
429 svq3_mc_dir_part (s
, 16*s
->mb_x
, 16*s
->mb_y
, 16, 16, 0, 0, 0, 0, 0, 0);
431 if (s
->pict_type
== FF_B_TYPE
) {
432 svq3_mc_dir_part (s
, 16*s
->mb_x
, 16*s
->mb_y
, 16, 16, 0, 0, 0, 0, 1, 1);
435 mb_type
= MB_TYPE_SKIP
;
437 mb_type
= FFMIN(s
->next_picture
.mb_type
[mb_xy
], 6);
438 if(svq3_mc_dir (h
, mb_type
, PREDICT_MODE
, 0, 0) < 0)
440 if(svq3_mc_dir (h
, mb_type
, PREDICT_MODE
, 1, 1) < 0)
443 mb_type
= MB_TYPE_16x16
;
445 } else if (mb_type
< 8) { /* INTER */
446 if (h
->thirdpel_flag
&& h
->halfpel_flag
== !get_bits1 (&s
->gb
)) {
447 mode
= THIRDPEL_MODE
;
448 } else if (h
->halfpel_flag
&& h
->thirdpel_flag
== !get_bits1 (&s
->gb
)) {
455 /* note ref_cache should contain here:
463 for (m
=0; m
< 2; m
++) {
464 if (s
->mb_x
> 0 && h
->intra4x4_pred_mode
[mb_xy
- 1][0] != -1) {
465 for (i
=0; i
< 4; i
++) {
466 *(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
];
469 for (i
=0; i
< 4; i
++) {
470 *(uint32_t *) h
->mv_cache
[m
][scan8
[0] - 1 + i
*8] = 0;
474 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));
475 memset (&h
->ref_cache
[m
][scan8
[0] - 1*8], (h
->intra4x4_pred_mode
[mb_xy
- s
->mb_stride
][4] == -1) ? PART_NOT_AVAILABLE
: 1, 4);
477 if (s
->mb_x
< (s
->mb_width
- 1)) {
478 *(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];
479 h
->ref_cache
[m
][scan8
[0] + 4 - 1*8] =
480 (h
->intra4x4_pred_mode
[mb_xy
- s
->mb_stride
+ 1][0] == -1 ||
481 h
->intra4x4_pred_mode
[mb_xy
- s
->mb_stride
][4] == -1) ? PART_NOT_AVAILABLE
: 1;
483 h
->ref_cache
[m
][scan8
[0] + 4 - 1*8] = PART_NOT_AVAILABLE
;
485 *(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];
486 h
->ref_cache
[m
][scan8
[0] - 1 - 1*8] = (h
->intra4x4_pred_mode
[mb_xy
- s
->mb_stride
- 1][3] == -1) ? PART_NOT_AVAILABLE
: 1;
488 h
->ref_cache
[m
][scan8
[0] - 1 - 1*8] = PART_NOT_AVAILABLE
;
490 memset (&h
->ref_cache
[m
][scan8
[0] - 1*8 - 1], PART_NOT_AVAILABLE
, 8);
492 if (s
->pict_type
!= FF_B_TYPE
)
496 /* decode motion vector(s) and form prediction(s) */
497 if (s
->pict_type
== FF_P_TYPE
) {
498 if(svq3_mc_dir (h
, (mb_type
- 1), mode
, 0, 0) < 0)
500 } else { /* FF_B_TYPE */
502 if(svq3_mc_dir (h
, 0, mode
, 0, 0) < 0)
505 for (i
=0; i
< 4; i
++) {
506 memset (s
->current_picture
.motion_val
[0][b_xy
+ i
*h
->b_stride
], 0, 4*2*sizeof(int16_t));
510 if(svq3_mc_dir (h
, 0, mode
, 1, (mb_type
== 3)) < 0)
513 for (i
=0; i
< 4; i
++) {
514 memset (s
->current_picture
.motion_val
[1][b_xy
+ i
*h
->b_stride
], 0, 4*2*sizeof(int16_t));
519 mb_type
= MB_TYPE_16x16
;
520 } else if (mb_type
== 8 || mb_type
== 33) { /* INTRA4x4 */
521 memset (h
->intra4x4_pred_mode_cache
, -1, 8*5*sizeof(int8_t));
525 for (i
=0; i
< 4; i
++) {
526 h
->intra4x4_pred_mode_cache
[scan8
[0] - 1 + i
*8] = h
->intra4x4_pred_mode
[mb_xy
- 1][i
];
528 if (h
->intra4x4_pred_mode_cache
[scan8
[0] - 1] == -1) {
529 h
->left_samples_available
= 0x5F5F;
533 h
->intra4x4_pred_mode_cache
[4+8*0] = h
->intra4x4_pred_mode
[mb_xy
- s
->mb_stride
][4];
534 h
->intra4x4_pred_mode_cache
[5+8*0] = h
->intra4x4_pred_mode
[mb_xy
- s
->mb_stride
][5];
535 h
->intra4x4_pred_mode_cache
[6+8*0] = h
->intra4x4_pred_mode
[mb_xy
- s
->mb_stride
][6];
536 h
->intra4x4_pred_mode_cache
[7+8*0] = h
->intra4x4_pred_mode
[mb_xy
- s
->mb_stride
][3];
538 if (h
->intra4x4_pred_mode_cache
[4+8*0] == -1) {
539 h
->top_samples_available
= 0x33FF;
543 /* decode prediction codes for luma blocks */
544 for (i
=0; i
< 16; i
+=2) {
545 vlc
= svq3_get_ue_golomb (&s
->gb
);
548 av_log(h
->s
.avctx
, AV_LOG_ERROR
, "luma prediction:%d\n", vlc
);
552 left
= &h
->intra4x4_pred_mode_cache
[scan8
[i
] - 1];
553 top
= &h
->intra4x4_pred_mode_cache
[scan8
[i
] - 8];
555 left
[1] = svq3_pred_1
[top
[0] + 1][left
[0] + 1][svq3_pred_0
[vlc
][0]];
556 left
[2] = svq3_pred_1
[top
[1] + 1][left
[1] + 1][svq3_pred_0
[vlc
][1]];
558 if (left
[1] == -1 || left
[2] == -1){
559 av_log(h
->s
.avctx
, AV_LOG_ERROR
, "weird prediction\n");
563 } else { /* mb_type == 33, DC_128_PRED block type */
564 for (i
=0; i
< 4; i
++) {
565 memset (&h
->intra4x4_pred_mode_cache
[scan8
[0] + 8*i
], DC_PRED
, 4);
569 write_back_intra_pred_mode (h
);
572 check_intra4x4_pred_mode (h
);
574 h
->top_samples_available
= (s
->mb_y
== 0) ? 0x33FF : 0xFFFF;
575 h
->left_samples_available
= (s
->mb_x
== 0) ? 0x5F5F : 0xFFFF;
577 for (i
=0; i
< 4; i
++) {
578 memset (&h
->intra4x4_pred_mode_cache
[scan8
[0] + 8*i
], DC_128_PRED
, 4);
581 h
->top_samples_available
= 0x33FF;
582 h
->left_samples_available
= 0x5F5F;
585 mb_type
= MB_TYPE_INTRA4x4
;
586 } else { /* INTRA16x16 */
587 dir
= i_mb_type_info
[mb_type
- 8].pred_mode
;
588 dir
= (dir
>> 1) ^ 3*(dir
& 1) ^ 1;
590 if ((h
->intra16x16_pred_mode
= check_intra_pred_mode (h
, dir
)) == -1){
591 av_log(h
->s
.avctx
, AV_LOG_ERROR
, "check_intra_pred_mode = -1\n");
595 cbp
= i_mb_type_info
[mb_type
- 8].cbp
;
596 mb_type
= MB_TYPE_INTRA16x16
;
599 if (!IS_INTER(mb_type
) && s
->pict_type
!= FF_I_TYPE
) {
600 for (i
=0; i
< 4; i
++) {
601 memset (s
->current_picture
.motion_val
[0][b_xy
+ i
*h
->b_stride
], 0, 4*2*sizeof(int16_t));
603 if (s
->pict_type
== FF_B_TYPE
) {
604 for (i
=0; i
< 4; i
++) {
605 memset (s
->current_picture
.motion_val
[1][b_xy
+ i
*h
->b_stride
], 0, 4*2*sizeof(int16_t));
609 if (!IS_INTRA4x4(mb_type
)) {
610 memset (h
->intra4x4_pred_mode
[mb_xy
], DC_PRED
, 8);
612 if (!IS_SKIP(mb_type
) || s
->pict_type
== FF_B_TYPE
) {
613 memset (h
->non_zero_count_cache
+ 8, 0, 4*9*sizeof(uint8_t));
614 s
->dsp
.clear_blocks(h
->mb
);
617 if (!IS_INTRA16x16(mb_type
) && (!IS_SKIP(mb_type
) || s
->pict_type
== FF_B_TYPE
)) {
618 if ((vlc
= svq3_get_ue_golomb (&s
->gb
)) >= 48){
619 av_log(h
->s
.avctx
, AV_LOG_ERROR
, "cbp_vlc=%d\n", vlc
);
623 cbp
= IS_INTRA(mb_type
) ? golomb_to_intra4x4_cbp
[vlc
] : golomb_to_inter_cbp
[vlc
];
625 if (IS_INTRA16x16(mb_type
) || (s
->pict_type
!= FF_I_TYPE
&& s
->adaptive_quant
&& cbp
)) {
626 s
->qscale
+= svq3_get_se_golomb (&s
->gb
);
629 av_log(h
->s
.avctx
, AV_LOG_ERROR
, "qscale:%d\n", s
->qscale
);
633 if (IS_INTRA16x16(mb_type
)) {
634 if (svq3_decode_block (&s
->gb
, h
->mb
, 0, 0)){
635 av_log(h
->s
.avctx
, AV_LOG_ERROR
, "error while decoding intra luma dc\n");
641 const int index
= IS_INTRA16x16(mb_type
) ? 1 : 0;
642 const int type
= ((s
->qscale
< 24 && IS_INTRA4x4(mb_type
)) ? 2 : 1);
644 for (i
=0; i
< 4; i
++) {
645 if ((cbp
& (1 << i
))) {
646 for (j
=0; j
< 4; j
++) {
647 k
= index
? ((j
&1) + 2*(i
&1) + 2*(j
&2) + 4*(i
&2)) : (4*i
+ j
);
648 h
->non_zero_count_cache
[ scan8
[k
] ] = 1;
650 if (svq3_decode_block (&s
->gb
, &h
->mb
[16*k
], index
, type
)){
651 av_log(h
->s
.avctx
, AV_LOG_ERROR
, "error while decoding block\n");
659 for (i
=0; i
< 2; ++i
) {
660 if (svq3_decode_block (&s
->gb
, &h
->mb
[16*(16 + 4*i
)], 0, 3)){
661 av_log(h
->s
.avctx
, AV_LOG_ERROR
, "error while decoding chroma dc block\n");
667 for (i
=0; i
< 8; i
++) {
668 h
->non_zero_count_cache
[ scan8
[16+i
] ] = 1;
670 if (svq3_decode_block (&s
->gb
, &h
->mb
[16*(16 + i
)], 1, 1)){
671 av_log(h
->s
.avctx
, AV_LOG_ERROR
, "error while decoding chroma ac block\n");
679 s
->current_picture
.mb_type
[mb_xy
] = mb_type
;
681 if (IS_INTRA(mb_type
)) {
682 h
->chroma_pred_mode
= check_intra_pred_mode (h
, DC_PRED8x8
);
688 static int svq3_decode_slice_header (H264Context
*h
) {
689 MpegEncContext
*const s
= (MpegEncContext
*) h
;
690 const int mb_xy
= h
->mb_xy
;
693 header
= get_bits (&s
->gb
, 8);
695 if (((header
& 0x9F) != 1 && (header
& 0x9F) != 2) || (header
& 0x60) == 0) {
697 av_log(h
->s
.avctx
, AV_LOG_ERROR
, "unsupported slice header (%02X)\n", header
);
700 int length
= (header
>> 5) & 3;
702 h
->next_slice_index
= get_bits_count(&s
->gb
) + 8*show_bits (&s
->gb
, 8*length
) + 8*length
;
704 if (h
->next_slice_index
> s
->gb
.size_in_bits
){
705 av_log(h
->s
.avctx
, AV_LOG_ERROR
, "slice after bitstream end\n");
709 s
->gb
.size_in_bits
= h
->next_slice_index
- 8*(length
- 1);
710 skip_bits(&s
->gb
, 8);
712 if (h
->svq3_watermark_key
) {
713 uint32_t header
= AV_RL32(&s
->gb
.buffer
[(get_bits_count(&s
->gb
)>>3)+1]);
714 AV_WL32(&s
->gb
.buffer
[(get_bits_count(&s
->gb
)>>3)+1], header
^ h
->svq3_watermark_key
);
717 memcpy ((uint8_t *) &s
->gb
.buffer
[get_bits_count(&s
->gb
) >> 3],
718 &s
->gb
.buffer
[s
->gb
.size_in_bits
>> 3], (length
- 1));
722 if ((i
= svq3_get_ue_golomb (&s
->gb
)) == INVALID_VLC
|| i
>= 3){
723 av_log(h
->s
.avctx
, AV_LOG_ERROR
, "illegal slice type %d \n", i
);
727 h
->slice_type
= golomb_to_pict_type
[i
];
729 if ((header
& 0x9F) == 2) {
730 i
= (s
->mb_num
< 64) ? 6 : (1 + av_log2 (s
->mb_num
- 1));
731 s
->mb_skip_run
= get_bits (&s
->gb
, i
) - (s
->mb_x
+ (s
->mb_y
* s
->mb_width
));
737 h
->slice_num
= get_bits (&s
->gb
, 8);
738 s
->qscale
= get_bits (&s
->gb
, 5);
739 s
->adaptive_quant
= get_bits1 (&s
->gb
);
744 if (h
->unknown_svq3_flag
) {
749 skip_bits (&s
->gb
, 2);
751 while (get_bits1 (&s
->gb
)) {
752 skip_bits (&s
->gb
, 8);
755 /* reset intra predictors and invalidate motion vector references */
757 memset (h
->intra4x4_pred_mode
[mb_xy
- 1], -1, 4*sizeof(int8_t));
758 memset (h
->intra4x4_pred_mode
[mb_xy
- s
->mb_x
], -1, 8*sizeof(int8_t)*s
->mb_x
);
761 memset (h
->intra4x4_pred_mode
[mb_xy
- s
->mb_stride
], -1, 8*sizeof(int8_t)*(s
->mb_width
- s
->mb_x
));
764 h
->intra4x4_pred_mode
[mb_xy
- s
->mb_stride
- 1][3] = -1;
771 static int svq3_decode_frame (AVCodecContext
*avctx
,
772 void *data
, int *data_size
,
773 const uint8_t *buf
, int buf_size
) {
774 MpegEncContext
*const s
= avctx
->priv_data
;
775 H264Context
*const h
= avctx
->priv_data
;
777 unsigned char *extradata
;
780 s
->flags
= avctx
->flags
;
781 s
->flags2
= avctx
->flags2
;
782 s
->unrestricted_mv
= 1;
784 if (!s
->context_initialized
) {
785 s
->width
= avctx
->width
;
786 s
->height
= avctx
->height
;
788 h
->thirdpel_flag
= 1;
789 h
->unknown_svq3_flag
= 0;
790 h
->chroma_qp
[0] = h
->chroma_qp
[1] = 4;
792 if (MPV_common_init (s
) < 0)
795 h
->b_stride
= 4*s
->mb_width
;
799 /* prowl for the "SEQH" marker in the extradata */
800 extradata
= (unsigned char *)avctx
->extradata
;
801 for (m
= 0; m
< avctx
->extradata_size
; m
++) {
802 if (!memcmp (extradata
, "SEQH", 4))
807 /* if a match was found, parse the extra data */
808 if (extradata
&& !memcmp (extradata
, "SEQH", 4)) {
812 size
= AV_RB32(&extradata
[4]);
813 init_get_bits (&gb
, extradata
+ 8, size
*8);
815 /* 'frame size code' and optional 'width, height' */
816 if (get_bits (&gb
, 3) == 7) {
821 h
->halfpel_flag
= get_bits1 (&gb
);
822 h
->thirdpel_flag
= get_bits1 (&gb
);
830 s
->low_delay
= get_bits1 (&gb
);
835 while (get_bits1 (&gb
)) {
839 h
->unknown_svq3_flag
= get_bits1 (&gb
);
840 avctx
->has_b_frames
= !s
->low_delay
;
841 if (h
->unknown_svq3_flag
) {
843 unsigned watermark_width
= svq3_get_ue_golomb(&gb
);
844 unsigned watermark_height
= svq3_get_ue_golomb(&gb
);
845 int u1
= svq3_get_ue_golomb(&gb
);
846 int u2
= get_bits(&gb
, 8);
847 int u3
= get_bits(&gb
, 2);
848 int u4
= svq3_get_ue_golomb(&gb
);
849 unsigned buf_len
= watermark_width
*watermark_height
*4;
850 int offset
= (get_bits_count(&gb
)+7)>>3;
853 if ((uint64_t)watermark_width
*4 > UINT_MAX
/watermark_height
)
856 buf
= av_malloc(buf_len
);
857 av_log(avctx
, AV_LOG_DEBUG
, "watermark size: %dx%d\n", watermark_width
, watermark_height
);
858 av_log(avctx
, AV_LOG_DEBUG
, "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n", u1
, u2
, u3
, u4
, offset
);
859 if (uncompress(buf
, (uLong
*)&buf_len
, extradata
+ 8 + offset
, size
- offset
) != Z_OK
) {
860 av_log(avctx
, AV_LOG_ERROR
, "could not uncompress watermark logo\n");
864 h
->svq3_watermark_key
= ff_svq1_packet_checksum(buf
, buf_len
, 0);
865 h
->svq3_watermark_key
= h
->svq3_watermark_key
<< 16 | h
->svq3_watermark_key
;
866 av_log(avctx
, AV_LOG_DEBUG
, "watermark key %#x\n", h
->svq3_watermark_key
);
869 av_log(avctx
, AV_LOG_ERROR
, "this svq3 file contains watermark which need zlib support compiled in\n");
876 /* special case for last picture */
878 if (s
->next_picture_ptr
&& !s
->low_delay
) {
879 *(AVFrame
*) data
= *(AVFrame
*) &s
->next_picture
;
880 s
->next_picture_ptr
= NULL
;
881 *data_size
= sizeof(AVFrame
);
886 init_get_bits (&s
->gb
, buf
, 8*buf_size
);
888 s
->mb_x
= s
->mb_y
= h
->mb_xy
= 0;
890 if (svq3_decode_slice_header (h
))
893 s
->pict_type
= h
->slice_type
;
894 s
->picture_number
= h
->slice_num
;
896 if(avctx
->debug
&FF_DEBUG_PICT_INFO
){
897 av_log(h
->s
.avctx
, AV_LOG_DEBUG
, "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
898 av_get_pict_type_char(s
->pict_type
), h
->halfpel_flag
, h
->thirdpel_flag
,
899 s
->adaptive_quant
, s
->qscale
, h
->slice_num
903 /* for hurry_up==5 */
904 s
->current_picture
.pict_type
= s
->pict_type
;
905 s
->current_picture
.key_frame
= (s
->pict_type
== FF_I_TYPE
);
907 /* Skip B-frames if we do not have reference frames. */
908 if (s
->last_picture_ptr
== NULL
&& s
->pict_type
== FF_B_TYPE
) return 0;
909 /* Skip B-frames if we are in a hurry. */
910 if (avctx
->hurry_up
&& s
->pict_type
== FF_B_TYPE
) return 0;
911 /* Skip everything if we are in a hurry >= 5. */
912 if (avctx
->hurry_up
>= 5) return 0;
913 if( (avctx
->skip_frame
>= AVDISCARD_NONREF
&& s
->pict_type
==FF_B_TYPE
)
914 ||(avctx
->skip_frame
>= AVDISCARD_NONKEY
&& s
->pict_type
!=FF_I_TYPE
)
915 || avctx
->skip_frame
>= AVDISCARD_ALL
)
918 if (s
->next_p_frame_damaged
) {
919 if (s
->pict_type
== FF_B_TYPE
)
922 s
->next_p_frame_damaged
= 0;
925 if (frame_start (h
) < 0)
928 if (s
->pict_type
== FF_B_TYPE
) {
929 h
->frame_num_offset
= (h
->slice_num
- h
->prev_frame_num
);
931 if (h
->frame_num_offset
< 0) {
932 h
->frame_num_offset
+= 256;
934 if (h
->frame_num_offset
== 0 || h
->frame_num_offset
>= h
->prev_frame_num_offset
) {
935 av_log(h
->s
.avctx
, AV_LOG_ERROR
, "error in B-frame picture id\n");
939 h
->prev_frame_num
= h
->frame_num
;
940 h
->frame_num
= h
->slice_num
;
941 h
->prev_frame_num_offset
= (h
->frame_num
- h
->prev_frame_num
);
943 if (h
->prev_frame_num_offset
< 0) {
944 h
->prev_frame_num_offset
+= 256;
953 h
->ref_cache
[m
][scan8
[0] + 8*i
+ j
]= 1;
955 h
->ref_cache
[m
][scan8
[0] + 8*i
+ j
]= PART_NOT_AVAILABLE
;
959 for (s
->mb_y
=0; s
->mb_y
< s
->mb_height
; s
->mb_y
++) {
960 for (s
->mb_x
=0; s
->mb_x
< s
->mb_width
; s
->mb_x
++) {
961 h
->mb_xy
= s
->mb_x
+ s
->mb_y
*s
->mb_stride
;
963 if ( (get_bits_count(&s
->gb
) + 7) >= s
->gb
.size_in_bits
&&
964 ((get_bits_count(&s
->gb
) & 7) == 0 || show_bits (&s
->gb
, (-get_bits_count(&s
->gb
) & 7)) == 0)) {
966 skip_bits(&s
->gb
, h
->next_slice_index
- get_bits_count(&s
->gb
));
967 s
->gb
.size_in_bits
= 8*buf_size
;
969 if (svq3_decode_slice_header (h
))
972 /* TODO: support s->mb_skip_run */
975 mb_type
= svq3_get_ue_golomb (&s
->gb
);
977 if (s
->pict_type
== FF_I_TYPE
) {
979 } else if (s
->pict_type
== FF_B_TYPE
&& mb_type
>= 4) {
982 if (mb_type
> 33 || svq3_decode_mb (h
, mb_type
)) {
983 av_log(h
->s
.avctx
, AV_LOG_ERROR
, "error while decoding MB %d %d\n", s
->mb_x
, s
->mb_y
);
991 if (s
->pict_type
!= FF_B_TYPE
&& !s
->low_delay
) {
992 s
->current_picture
.mb_type
[s
->mb_x
+ s
->mb_y
*s
->mb_stride
] =
993 (s
->pict_type
== FF_P_TYPE
&& mb_type
< 8) ? (mb_type
- 1) : -1;
997 ff_draw_horiz_band(s
, 16*s
->mb_y
, 16);
1002 if (s
->pict_type
== FF_B_TYPE
|| s
->low_delay
) {
1003 *(AVFrame
*) data
= *(AVFrame
*) &s
->current_picture
;
1005 *(AVFrame
*) data
= *(AVFrame
*) &s
->last_picture
;
1008 avctx
->frame_number
= s
->picture_number
- 1;
1010 /* Do not output the last pic after seeking. */
1011 if (s
->last_picture_ptr
|| s
->low_delay
) {
1012 *data_size
= sizeof(AVFrame
);
1019 AVCodec svq3_decoder
= {
1023 sizeof(H264Context
),
1028 CODEC_CAP_DRAW_HORIZ_BAND
| CODEC_CAP_DR1
| CODEC_CAP_DELAY
,
1029 .long_name
= NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3"),