ffmpeg / libavcodec / svq3.c @ b0e7a932
History | View | Annotate | Download (39.3 KB)
1 |
/*
|
---|---|
2 |
* Copyright (c) 2003 The FFmpeg Project
|
3 |
*
|
4 |
* This file is part of FFmpeg.
|
5 |
*
|
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.
|
10 |
*
|
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.
|
15 |
*
|
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
|
19 |
*/
|
20 |
|
21 |
/*
|
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:
|
31 |
*
|
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)
|
37 |
*
|
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
|
41 |
*/
|
42 |
#include "internal.h" |
43 |
#include "dsputil.h" |
44 |
#include "avcodec.h" |
45 |
#include "mpegvideo.h" |
46 |
#include "h264.h" |
47 |
|
48 |
#include "h264data.h" //FIXME FIXME FIXME |
49 |
|
50 |
#include "h264_mvpred.h" |
51 |
#include "golomb.h" |
52 |
#include "rectangle.h" |
53 |
#include "vdpau_internal.h" |
54 |
|
55 |
#if CONFIG_ZLIB
|
56 |
#include <zlib.h> |
57 |
#endif
|
58 |
|
59 |
#include "svq1.h" |
60 |
|
61 |
/**
|
62 |
* @file
|
63 |
* svq3 decoder.
|
64 |
*/
|
65 |
|
66 |
typedef struct { |
67 |
H264Context h; |
68 |
int halfpel_flag;
|
69 |
int thirdpel_flag;
|
70 |
int unknown_flag;
|
71 |
int next_slice_index;
|
72 |
uint32_t watermark_key; |
73 |
} SVQ3Context; |
74 |
|
75 |
#define FULLPEL_MODE 1 |
76 |
#define HALFPEL_MODE 2 |
77 |
#define THIRDPEL_MODE 3 |
78 |
#define PREDICT_MODE 4 |
79 |
|
80 |
/* dual scan (from some older h264 draft)
|
81 |
o-->o-->o o
|
82 |
| /|
|
83 |
o o o / o
|
84 |
| / | |/ |
|
85 |
o o o o
|
86 |
/
|
87 |
o-->o-->o-->o
|
88 |
*/
|
89 |
static const uint8_t svq3_scan[16] = { |
90 |
0+0*4, 1+0*4, 2+0*4, 2+1*4, |
91 |
2+2*4, 3+0*4, 3+1*4, 3+2*4, |
92 |
0+1*4, 0+2*4, 1+1*4, 1+2*4, |
93 |
0+3*4, 1+3*4, 2+3*4, 3+3*4, |
94 |
}; |
95 |
|
96 |
static const uint8_t svq3_pred_0[25][2] = { |
97 |
{ 0, 0 }, |
98 |
{ 1, 0 }, { 0, 1 }, |
99 |
{ 0, 2 }, { 1, 1 }, { 2, 0 }, |
100 |
{ 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 }, |
101 |
{ 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 }, |
102 |
{ 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 }, |
103 |
{ 2, 4 }, { 3, 3 }, { 4, 2 }, |
104 |
{ 4, 3 }, { 3, 4 }, |
105 |
{ 4, 4 } |
106 |
}; |
107 |
|
108 |
static const int8_t svq3_pred_1[6][6][5] = { |
109 |
{ { 2,-1,-1,-1,-1 }, { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 }, |
110 |
{ 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 }, { 1, 2,-1,-1,-1 } }, |
111 |
{ { 0, 2,-1,-1,-1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 }, |
112 |
{ 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } }, |
113 |
{ { 2, 0,-1,-1,-1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 }, |
114 |
{ 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } }, |
115 |
{ { 2, 0,-1,-1,-1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 }, |
116 |
{ 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } }, |
117 |
{ { 0, 2,-1,-1,-1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 }, |
118 |
{ 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } }, |
119 |
{ { 0, 2,-1,-1,-1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 }, |
120 |
{ 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } }, |
121 |
}; |
122 |
|
123 |
static const struct { uint8_t run; uint8_t level; } svq3_dct_tables[2][16] = { |
124 |
{ { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 }, |
125 |
{ 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } }, |
126 |
{ { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 }, |
127 |
{ 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } } |
128 |
}; |
129 |
|
130 |
static const uint32_t svq3_dequant_coeff[32] = { |
131 |
3881, 4351, 4890, 5481, 6154, 6914, 7761, 8718, |
132 |
9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873, |
133 |
24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683, |
134 |
61694, 68745, 77615, 89113,100253,109366,126635,141533 |
135 |
}; |
136 |
|
137 |
void ff_svq3_luma_dc_dequant_idct_c(DCTELEM *output, DCTELEM *input, int qp){ |
138 |
const int qmul = svq3_dequant_coeff[qp]; |
139 |
#define stride 16 |
140 |
int i;
|
141 |
int temp[16]; |
142 |
static const uint8_t x_offset[4]={0, 1*stride, 4*stride, 5*stride}; |
143 |
|
144 |
for(i=0; i<4; i++){ |
145 |
const int z0 = 13*(input[4*i+0] + input[4*i+2]); |
146 |
const int z1 = 13*(input[4*i+0] - input[4*i+2]); |
147 |
const int z2 = 7* input[4*i+1] - 17*input[4*i+3]; |
148 |
const int z3 = 17* input[4*i+1] + 7*input[4*i+3]; |
149 |
|
150 |
temp[4*i+0] = z0+z3; |
151 |
temp[4*i+1] = z1+z2; |
152 |
temp[4*i+2] = z1-z2; |
153 |
temp[4*i+3] = z0-z3; |
154 |
} |
155 |
|
156 |
for(i=0; i<4; i++){ |
157 |
const int offset= x_offset[i]; |
158 |
const int z0= 13*(temp[4*0+i] + temp[4*2+i]); |
159 |
const int z1= 13*(temp[4*0+i] - temp[4*2+i]); |
160 |
const int z2= 7* temp[4*1+i] - 17*temp[4*3+i]; |
161 |
const int z3= 17* temp[4*1+i] + 7*temp[4*3+i]; |
162 |
|
163 |
output[stride* 0+offset] = ((z0 + z3)*qmul + 0x80000) >> 20; |
164 |
output[stride* 2+offset] = ((z1 + z2)*qmul + 0x80000) >> 20; |
165 |
output[stride* 8+offset] = ((z1 - z2)*qmul + 0x80000) >> 20; |
166 |
output[stride*10+offset] = ((z0 - z3)*qmul + 0x80000) >> 20; |
167 |
} |
168 |
} |
169 |
#undef stride
|
170 |
|
171 |
void ff_svq3_add_idct_c(uint8_t *dst, DCTELEM *block, int stride, int qp, |
172 |
int dc)
|
173 |
{ |
174 |
const int qmul = svq3_dequant_coeff[qp]; |
175 |
int i;
|
176 |
uint8_t *cm = ff_cropTbl + MAX_NEG_CROP; |
177 |
|
178 |
if (dc) {
|
179 |
dc = 13*13*((dc == 1) ? 1538*block[0] : ((qmul*(block[0] >> 3)) / 2)); |
180 |
block[0] = 0; |
181 |
} |
182 |
|
183 |
for (i = 0; i < 4; i++) { |
184 |
const int z0 = 13*(block[0 + 4*i] + block[2 + 4*i]); |
185 |
const int z1 = 13*(block[0 + 4*i] - block[2 + 4*i]); |
186 |
const int z2 = 7* block[1 + 4*i] - 17*block[3 + 4*i]; |
187 |
const int z3 = 17* block[1 + 4*i] + 7*block[3 + 4*i]; |
188 |
|
189 |
block[0 + 4*i] = z0 + z3; |
190 |
block[1 + 4*i] = z1 + z2; |
191 |
block[2 + 4*i] = z1 - z2; |
192 |
block[3 + 4*i] = z0 - z3; |
193 |
} |
194 |
|
195 |
for (i = 0; i < 4; i++) { |
196 |
const int z0 = 13*(block[i + 4*0] + block[i + 4*2]); |
197 |
const int z1 = 13*(block[i + 4*0] - block[i + 4*2]); |
198 |
const int z2 = 7* block[i + 4*1] - 17*block[i + 4*3]; |
199 |
const int z3 = 17* block[i + 4*1] + 7*block[i + 4*3]; |
200 |
const int rr = (dc + 0x80000); |
201 |
|
202 |
dst[i + stride*0] = cm[ dst[i + stride*0] + (((z0 + z3)*qmul + rr) >> 20) ]; |
203 |
dst[i + stride*1] = cm[ dst[i + stride*1] + (((z1 + z2)*qmul + rr) >> 20) ]; |
204 |
dst[i + stride*2] = cm[ dst[i + stride*2] + (((z1 - z2)*qmul + rr) >> 20) ]; |
205 |
dst[i + stride*3] = cm[ dst[i + stride*3] + (((z0 - z3)*qmul + rr) >> 20) ]; |
206 |
} |
207 |
} |
208 |
|
209 |
static inline int svq3_decode_block(GetBitContext *gb, DCTELEM *block, |
210 |
int index, const int type) |
211 |
{ |
212 |
static const uint8_t *const scan_patterns[4] = |
213 |
{ luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan }; |
214 |
|
215 |
int run, level, sign, vlc, limit;
|
216 |
const int intra = (3 * type) >> 2; |
217 |
const uint8_t *const scan = scan_patterns[type]; |
218 |
|
219 |
for (limit = (16 >> intra); index < 16; index = limit, limit += 8) { |
220 |
for (; (vlc = svq3_get_ue_golomb(gb)) != 0; index++) { |
221 |
|
222 |
if (vlc == INVALID_VLC)
|
223 |
return -1; |
224 |
|
225 |
sign = (vlc & 0x1) - 1; |
226 |
vlc = (vlc + 1) >> 1; |
227 |
|
228 |
if (type == 3) { |
229 |
if (vlc < 3) { |
230 |
run = 0;
|
231 |
level = vlc; |
232 |
} else if (vlc < 4) { |
233 |
run = 1;
|
234 |
level = 1;
|
235 |
} else {
|
236 |
run = (vlc & 0x3);
|
237 |
level = ((vlc + 9) >> 2) - run; |
238 |
} |
239 |
} else {
|
240 |
if (vlc < 16) { |
241 |
run = svq3_dct_tables[intra][vlc].run; |
242 |
level = svq3_dct_tables[intra][vlc].level; |
243 |
} else if (intra) { |
244 |
run = (vlc & 0x7);
|
245 |
level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1))); |
246 |
} else {
|
247 |
run = (vlc & 0xF);
|
248 |
level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0))); |
249 |
} |
250 |
} |
251 |
|
252 |
if ((index += run) >= limit)
|
253 |
return -1; |
254 |
|
255 |
block[scan[index]] = (level ^ sign) - sign; |
256 |
} |
257 |
|
258 |
if (type != 2) { |
259 |
break;
|
260 |
} |
261 |
} |
262 |
|
263 |
return 0; |
264 |
} |
265 |
|
266 |
static inline void svq3_mc_dir_part(MpegEncContext *s, |
267 |
int x, int y, int width, int height, |
268 |
int mx, int my, int dxy, |
269 |
int thirdpel, int dir, int avg) |
270 |
{ |
271 |
const Picture *pic = (dir == 0) ? &s->last_picture : &s->next_picture; |
272 |
uint8_t *src, *dest; |
273 |
int i, emu = 0; |
274 |
int blocksize = 2 - (width>>3); //16->0, 8->1, 4->2 |
275 |
|
276 |
mx += x; |
277 |
my += y; |
278 |
|
279 |
if (mx < 0 || mx >= (s->h_edge_pos - width - 1) || |
280 |
my < 0 || my >= (s->v_edge_pos - height - 1)) { |
281 |
|
282 |
if ((s->flags & CODEC_FLAG_EMU_EDGE)) {
|
283 |
emu = 1;
|
284 |
} |
285 |
|
286 |
mx = av_clip (mx, -16, (s->h_edge_pos - width + 15)); |
287 |
my = av_clip (my, -16, (s->v_edge_pos - height + 15)); |
288 |
} |
289 |
|
290 |
/* form component predictions */
|
291 |
dest = s->current_picture.data[0] + x + y*s->linesize;
|
292 |
src = pic->data[0] + mx + my*s->linesize;
|
293 |
|
294 |
if (emu) {
|
295 |
s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, (width + 1), (height + 1), |
296 |
mx, my, s->h_edge_pos, s->v_edge_pos); |
297 |
src = s->edge_emu_buffer; |
298 |
} |
299 |
if (thirdpel)
|
300 |
(avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->linesize, width, height); |
301 |
else
|
302 |
(avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->linesize, height); |
303 |
|
304 |
if (!(s->flags & CODEC_FLAG_GRAY)) {
|
305 |
mx = (mx + (mx < (int) x)) >> 1; |
306 |
my = (my + (my < (int) y)) >> 1; |
307 |
width = (width >> 1);
|
308 |
height = (height >> 1);
|
309 |
blocksize++; |
310 |
|
311 |
for (i = 1; i < 3; i++) { |
312 |
dest = s->current_picture.data[i] + (x >> 1) + (y >> 1)*s->uvlinesize; |
313 |
src = pic->data[i] + mx + my*s->uvlinesize; |
314 |
|
315 |
if (emu) {
|
316 |
s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->uvlinesize, (width + 1), (height + 1), |
317 |
mx, my, (s->h_edge_pos >> 1), (s->v_edge_pos >> 1)); |
318 |
src = s->edge_emu_buffer; |
319 |
} |
320 |
if (thirdpel)
|
321 |
(avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->uvlinesize, width, height); |
322 |
else
|
323 |
(avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->uvlinesize, height); |
324 |
} |
325 |
} |
326 |
} |
327 |
|
328 |
static inline int svq3_mc_dir(H264Context *h, int size, int mode, int dir, |
329 |
int avg)
|
330 |
{ |
331 |
int i, j, k, mx, my, dx, dy, x, y;
|
332 |
MpegEncContext *const s = (MpegEncContext *) h;
|
333 |
const int part_width = ((size & 5) == 4) ? 4 : 16 >> (size & 1); |
334 |
const int part_height = 16 >> ((unsigned) (size + 1) / 3); |
335 |
const int extra_width = (mode == PREDICT_MODE) ? -16*6 : 0; |
336 |
const int h_edge_pos = 6*(s->h_edge_pos - part_width ) - extra_width; |
337 |
const int v_edge_pos = 6*(s->v_edge_pos - part_height) - extra_width; |
338 |
|
339 |
for (i = 0; i < 16; i += part_height) { |
340 |
for (j = 0; j < 16; j += part_width) { |
341 |
const int b_xy = (4*s->mb_x + (j >> 2)) + (4*s->mb_y + (i >> 2))*h->b_stride; |
342 |
int dxy;
|
343 |
x = 16*s->mb_x + j;
|
344 |
y = 16*s->mb_y + i;
|
345 |
k = ((j >> 2) & 1) + ((i >> 1) & 2) + ((j >> 1) & 4) + (i & 8); |
346 |
|
347 |
if (mode != PREDICT_MODE) {
|
348 |
pred_motion(h, k, (part_width >> 2), dir, 1, &mx, &my); |
349 |
} else {
|
350 |
mx = s->next_picture.motion_val[0][b_xy][0]<<1; |
351 |
my = s->next_picture.motion_val[0][b_xy][1]<<1; |
352 |
|
353 |
if (dir == 0) { |
354 |
mx = ((mx * h->frame_num_offset) / h->prev_frame_num_offset + 1) >> 1; |
355 |
my = ((my * h->frame_num_offset) / h->prev_frame_num_offset + 1) >> 1; |
356 |
} else {
|
357 |
mx = ((mx * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1) >> 1; |
358 |
my = ((my * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1) >> 1; |
359 |
} |
360 |
} |
361 |
|
362 |
/* clip motion vector prediction to frame border */
|
363 |
mx = av_clip(mx, extra_width - 6*x, h_edge_pos - 6*x); |
364 |
my = av_clip(my, extra_width - 6*y, v_edge_pos - 6*y); |
365 |
|
366 |
/* get (optional) motion vector differential */
|
367 |
if (mode == PREDICT_MODE) {
|
368 |
dx = dy = 0;
|
369 |
} else {
|
370 |
dy = svq3_get_se_golomb(&s->gb); |
371 |
dx = svq3_get_se_golomb(&s->gb); |
372 |
|
373 |
if (dx == INVALID_VLC || dy == INVALID_VLC) {
|
374 |
av_log(h->s.avctx, AV_LOG_ERROR, "invalid MV vlc\n");
|
375 |
return -1; |
376 |
} |
377 |
} |
378 |
|
379 |
/* compute motion vector */
|
380 |
if (mode == THIRDPEL_MODE) {
|
381 |
int fx, fy;
|
382 |
mx = ((mx + 1)>>1) + dx; |
383 |
my = ((my + 1)>>1) + dy; |
384 |
fx = ((unsigned)(mx + 0x3000))/3 - 0x1000; |
385 |
fy = ((unsigned)(my + 0x3000))/3 - 0x1000; |
386 |
dxy = (mx - 3*fx) + 4*(my - 3*fy); |
387 |
|
388 |
svq3_mc_dir_part(s, x, y, part_width, part_height, fx, fy, dxy, 1, dir, avg);
|
389 |
mx += mx; |
390 |
my += my; |
391 |
} else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) { |
392 |
mx = ((unsigned)(mx + 1 + 0x3000))/3 + dx - 0x1000; |
393 |
my = ((unsigned)(my + 1 + 0x3000))/3 + dy - 0x1000; |
394 |
dxy = (mx&1) + 2*(my&1); |
395 |
|
396 |
svq3_mc_dir_part(s, x, y, part_width, part_height, mx>>1, my>>1, dxy, 0, dir, avg); |
397 |
mx *= 3;
|
398 |
my *= 3;
|
399 |
} else {
|
400 |
mx = ((unsigned)(mx + 3 + 0x6000))/6 + dx - 0x1000; |
401 |
my = ((unsigned)(my + 3 + 0x6000))/6 + dy - 0x1000; |
402 |
|
403 |
svq3_mc_dir_part(s, x, y, part_width, part_height, mx, my, 0, 0, dir, avg); |
404 |
mx *= 6;
|
405 |
my *= 6;
|
406 |
} |
407 |
|
408 |
/* update mv_cache */
|
409 |
if (mode != PREDICT_MODE) {
|
410 |
int32_t mv = pack16to32(mx,my); |
411 |
|
412 |
if (part_height == 8 && i < 8) { |
413 |
*(int32_t *) h->mv_cache[dir][scan8[k] + 1*8] = mv; |
414 |
|
415 |
if (part_width == 8 && j < 8) { |
416 |
*(int32_t *) h->mv_cache[dir][scan8[k] + 1 + 1*8] = mv; |
417 |
} |
418 |
} |
419 |
if (part_width == 8 && j < 8) { |
420 |
*(int32_t *) h->mv_cache[dir][scan8[k] + 1] = mv;
|
421 |
} |
422 |
if (part_width == 4 || part_height == 4) { |
423 |
*(int32_t *) h->mv_cache[dir][scan8[k]] = mv; |
424 |
} |
425 |
} |
426 |
|
427 |
/* write back motion vectors */
|
428 |
fill_rectangle(s->current_picture.motion_val[dir][b_xy], part_width>>2, part_height>>2, h->b_stride, pack16to32(mx,my), 4); |
429 |
} |
430 |
} |
431 |
|
432 |
return 0; |
433 |
} |
434 |
|
435 |
static int svq3_decode_mb(SVQ3Context *svq3, unsigned int mb_type) |
436 |
{ |
437 |
H264Context *h = &svq3->h; |
438 |
int i, j, k, m, dir, mode;
|
439 |
int cbp = 0; |
440 |
uint32_t vlc; |
441 |
int8_t *top, *left; |
442 |
MpegEncContext *const s = (MpegEncContext *) h;
|
443 |
const int mb_xy = h->mb_xy; |
444 |
const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride; |
445 |
|
446 |
h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF; |
447 |
h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF; |
448 |
h->topright_samples_available = 0xFFFF;
|
449 |
|
450 |
if (mb_type == 0) { /* SKIP */ |
451 |
if (s->pict_type == AV_PICTURE_TYPE_P || s->next_picture.mb_type[mb_xy] == -1) { |
452 |
svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 0, 0); |
453 |
|
454 |
if (s->pict_type == AV_PICTURE_TYPE_B) {
|
455 |
svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 1, 1); |
456 |
} |
457 |
|
458 |
mb_type = MB_TYPE_SKIP; |
459 |
} else {
|
460 |
mb_type = FFMIN(s->next_picture.mb_type[mb_xy], 6);
|
461 |
if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 0, 0) < 0) |
462 |
return -1; |
463 |
if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 1, 1) < 0) |
464 |
return -1; |
465 |
|
466 |
mb_type = MB_TYPE_16x16; |
467 |
} |
468 |
} else if (mb_type < 8) { /* INTER */ |
469 |
if (svq3->thirdpel_flag && svq3->halfpel_flag == !get_bits1 (&s->gb)) {
|
470 |
mode = THIRDPEL_MODE; |
471 |
} else if (svq3->halfpel_flag && svq3->thirdpel_flag == !get_bits1 (&s->gb)) { |
472 |
mode = HALFPEL_MODE; |
473 |
} else {
|
474 |
mode = FULLPEL_MODE; |
475 |
} |
476 |
|
477 |
/* fill caches */
|
478 |
/* note ref_cache should contain here:
|
479 |
????????
|
480 |
???11111
|
481 |
N??11111
|
482 |
N??11111
|
483 |
N??11111
|
484 |
*/
|
485 |
|
486 |
for (m = 0; m < 2; m++) { |
487 |
if (s->mb_x > 0 && h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1]+6] != -1) { |
488 |
for (i = 0; i < 4; i++) { |
489 |
*(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]; |
490 |
} |
491 |
} else {
|
492 |
for (i = 0; i < 4; i++) { |
493 |
*(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = 0; |
494 |
} |
495 |
} |
496 |
if (s->mb_y > 0) { |
497 |
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)); |
498 |
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); |
499 |
|
500 |
if (s->mb_x < (s->mb_width - 1)) { |
501 |
*(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]; |
502 |
h->ref_cache[m][scan8[0] + 4 - 1*8] = |
503 |
(h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride + 1]+6] == -1 || |
504 |
h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride ] ] == -1) ? PART_NOT_AVAILABLE : 1; |
505 |
}else
|
506 |
h->ref_cache[m][scan8[0] + 4 - 1*8] = PART_NOT_AVAILABLE; |
507 |
if (s->mb_x > 0) { |
508 |
*(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]; |
509 |
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; |
510 |
}else
|
511 |
h->ref_cache[m][scan8[0] - 1 - 1*8] = PART_NOT_AVAILABLE; |
512 |
}else
|
513 |
memset(&h->ref_cache[m][scan8[0] - 1*8 - 1], PART_NOT_AVAILABLE, 8); |
514 |
|
515 |
if (s->pict_type != AV_PICTURE_TYPE_B)
|
516 |
break;
|
517 |
} |
518 |
|
519 |
/* decode motion vector(s) and form prediction(s) */
|
520 |
if (s->pict_type == AV_PICTURE_TYPE_P) {
|
521 |
if (svq3_mc_dir(h, (mb_type - 1), mode, 0, 0) < 0) |
522 |
return -1; |
523 |
} else { /* AV_PICTURE_TYPE_B */ |
524 |
if (mb_type != 2) { |
525 |
if (svq3_mc_dir(h, 0, mode, 0, 0) < 0) |
526 |
return -1; |
527 |
} else {
|
528 |
for (i = 0; i < 4; i++) { |
529 |
memset(s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t)); |
530 |
} |
531 |
} |
532 |
if (mb_type != 1) { |
533 |
if (svq3_mc_dir(h, 0, mode, 1, (mb_type == 3)) < 0) |
534 |
return -1; |
535 |
} else {
|
536 |
for (i = 0; i < 4; i++) { |
537 |
memset(s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t)); |
538 |
} |
539 |
} |
540 |
} |
541 |
|
542 |
mb_type = MB_TYPE_16x16; |
543 |
} else if (mb_type == 8 || mb_type == 33) { /* INTRA4x4 */ |
544 |
memset(h->intra4x4_pred_mode_cache, -1, 8*5*sizeof(int8_t)); |
545 |
|
546 |
if (mb_type == 8) { |
547 |
if (s->mb_x > 0) { |
548 |
for (i = 0; i < 4; i++) { |
549 |
h->intra4x4_pred_mode_cache[scan8[0] - 1 + i*8] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - 1]+6-i]; |
550 |
} |
551 |
if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1) { |
552 |
h->left_samples_available = 0x5F5F;
|
553 |
} |
554 |
} |
555 |
if (s->mb_y > 0) { |
556 |
h->intra4x4_pred_mode_cache[4+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+0]; |
557 |
h->intra4x4_pred_mode_cache[5+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+1]; |
558 |
h->intra4x4_pred_mode_cache[6+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+2]; |
559 |
h->intra4x4_pred_mode_cache[7+8*0] = h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride]+3]; |
560 |
|
561 |
if (h->intra4x4_pred_mode_cache[4+8*0] == -1) { |
562 |
h->top_samples_available = 0x33FF;
|
563 |
} |
564 |
} |
565 |
|
566 |
/* decode prediction codes for luma blocks */
|
567 |
for (i = 0; i < 16; i+=2) { |
568 |
vlc = svq3_get_ue_golomb(&s->gb); |
569 |
|
570 |
if (vlc >= 25){ |
571 |
av_log(h->s.avctx, AV_LOG_ERROR, "luma prediction:%d\n", vlc);
|
572 |
return -1; |
573 |
} |
574 |
|
575 |
left = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
|
576 |
top = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
|
577 |
|
578 |
left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]]; |
579 |
left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]]; |
580 |
|
581 |
if (left[1] == -1 || left[2] == -1){ |
582 |
av_log(h->s.avctx, AV_LOG_ERROR, "weird prediction\n");
|
583 |
return -1; |
584 |
} |
585 |
} |
586 |
} else { /* mb_type == 33, DC_128_PRED block type */ |
587 |
for (i = 0; i < 4; i++) { |
588 |
memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_PRED, 4); |
589 |
} |
590 |
} |
591 |
|
592 |
ff_h264_write_back_intra_pred_mode(h); |
593 |
|
594 |
if (mb_type == 8) { |
595 |
ff_h264_check_intra4x4_pred_mode(h); |
596 |
|
597 |
h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF; |
598 |
h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF; |
599 |
} else {
|
600 |
for (i = 0; i < 4; i++) { |
601 |
memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_128_PRED, 4); |
602 |
} |
603 |
|
604 |
h->top_samples_available = 0x33FF;
|
605 |
h->left_samples_available = 0x5F5F;
|
606 |
} |
607 |
|
608 |
mb_type = MB_TYPE_INTRA4x4; |
609 |
} else { /* INTRA16x16 */ |
610 |
dir = i_mb_type_info[mb_type - 8].pred_mode;
|
611 |
dir = (dir >> 1) ^ 3*(dir & 1) ^ 1; |
612 |
|
613 |
if ((h->intra16x16_pred_mode = ff_h264_check_intra_pred_mode(h, dir)) == -1){ |
614 |
av_log(h->s.avctx, AV_LOG_ERROR, "check_intra_pred_mode = -1\n");
|
615 |
return -1; |
616 |
} |
617 |
|
618 |
cbp = i_mb_type_info[mb_type - 8].cbp;
|
619 |
mb_type = MB_TYPE_INTRA16x16; |
620 |
} |
621 |
|
622 |
if (!IS_INTER(mb_type) && s->pict_type != AV_PICTURE_TYPE_I) {
|
623 |
for (i = 0; i < 4; i++) { |
624 |
memset(s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t)); |
625 |
} |
626 |
if (s->pict_type == AV_PICTURE_TYPE_B) {
|
627 |
for (i = 0; i < 4; i++) { |
628 |
memset(s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t)); |
629 |
} |
630 |
} |
631 |
} |
632 |
if (!IS_INTRA4x4(mb_type)) {
|
633 |
memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy], DC_PRED, 8);
|
634 |
} |
635 |
if (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B) {
|
636 |
memset(h->non_zero_count_cache + 8, 0, 4*9*sizeof(uint8_t)); |
637 |
s->dsp.clear_blocks(h->mb); |
638 |
} |
639 |
|
640 |
if (!IS_INTRA16x16(mb_type) && (!IS_SKIP(mb_type) || s->pict_type == AV_PICTURE_TYPE_B)) {
|
641 |
if ((vlc = svq3_get_ue_golomb(&s->gb)) >= 48){ |
642 |
av_log(h->s.avctx, AV_LOG_ERROR, "cbp_vlc=%d\n", vlc);
|
643 |
return -1; |
644 |
} |
645 |
|
646 |
cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc] : golomb_to_inter_cbp[vlc]; |
647 |
} |
648 |
if (IS_INTRA16x16(mb_type) || (s->pict_type != AV_PICTURE_TYPE_I && s->adaptive_quant && cbp)) {
|
649 |
s->qscale += svq3_get_se_golomb(&s->gb); |
650 |
|
651 |
if (s->qscale > 31){ |
652 |
av_log(h->s.avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
|
653 |
return -1; |
654 |
} |
655 |
} |
656 |
if (IS_INTRA16x16(mb_type)) {
|
657 |
AV_ZERO128(h->mb_luma_dc+0);
|
658 |
AV_ZERO128(h->mb_luma_dc+8);
|
659 |
if (svq3_decode_block(&s->gb, h->mb_luma_dc, 0, 1)){ |
660 |
av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding intra luma dc\n");
|
661 |
return -1; |
662 |
} |
663 |
} |
664 |
|
665 |
if (cbp) {
|
666 |
const int index = IS_INTRA16x16(mb_type) ? 1 : 0; |
667 |
const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1); |
668 |
|
669 |
for (i = 0; i < 4; i++) { |
670 |
if ((cbp & (1 << i))) { |
671 |
for (j = 0; j < 4; j++) { |
672 |
k = index ? ((j&1) + 2*(i&1) + 2*(j&2) + 4*(i&2)) : (4*i + j); |
673 |
h->non_zero_count_cache[ scan8[k] ] = 1;
|
674 |
|
675 |
if (svq3_decode_block(&s->gb, &h->mb[16*k], index, type)){ |
676 |
av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding block\n");
|
677 |
return -1; |
678 |
} |
679 |
} |
680 |
} |
681 |
} |
682 |
|
683 |
if ((cbp & 0x30)) { |
684 |
for (i = 0; i < 2; ++i) { |
685 |
if (svq3_decode_block(&s->gb, &h->mb[16*(16 + 4*i)], 0, 3)){ |
686 |
av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma dc block\n");
|
687 |
return -1; |
688 |
} |
689 |
} |
690 |
|
691 |
if ((cbp & 0x20)) { |
692 |
for (i = 0; i < 8; i++) { |
693 |
h->non_zero_count_cache[ scan8[16+i] ] = 1; |
694 |
|
695 |
if (svq3_decode_block(&s->gb, &h->mb[16*(16 + i)], 1, 1)){ |
696 |
av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma ac block\n");
|
697 |
return -1; |
698 |
} |
699 |
} |
700 |
} |
701 |
} |
702 |
} |
703 |
|
704 |
h->cbp= cbp; |
705 |
s->current_picture.mb_type[mb_xy] = mb_type; |
706 |
|
707 |
if (IS_INTRA(mb_type)) {
|
708 |
h->chroma_pred_mode = ff_h264_check_intra_pred_mode(h, DC_PRED8x8); |
709 |
} |
710 |
|
711 |
return 0; |
712 |
} |
713 |
|
714 |
static int svq3_decode_slice_header(AVCodecContext *avctx) |
715 |
{ |
716 |
SVQ3Context *svq3 = avctx->priv_data; |
717 |
H264Context *h = &svq3->h; |
718 |
MpegEncContext *s = &h->s; |
719 |
const int mb_xy = h->mb_xy; |
720 |
int i, header;
|
721 |
|
722 |
header = get_bits(&s->gb, 8);
|
723 |
|
724 |
if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) { |
725 |
/* TODO: what? */
|
726 |
av_log(avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
|
727 |
return -1; |
728 |
} else {
|
729 |
int length = (header >> 5) & 3; |
730 |
|
731 |
svq3->next_slice_index = get_bits_count(&s->gb) + 8*show_bits(&s->gb, 8*length) + 8*length; |
732 |
|
733 |
if (svq3->next_slice_index > s->gb.size_in_bits) {
|
734 |
av_log(avctx, AV_LOG_ERROR, "slice after bitstream end\n");
|
735 |
return -1; |
736 |
} |
737 |
|
738 |
s->gb.size_in_bits = svq3->next_slice_index - 8*(length - 1); |
739 |
skip_bits(&s->gb, 8);
|
740 |
|
741 |
if (svq3->watermark_key) {
|
742 |
uint32_t header = AV_RL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1]); |
743 |
AV_WL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1], header ^ svq3->watermark_key); |
744 |
} |
745 |
if (length > 0) { |
746 |
memcpy((uint8_t *) &s->gb.buffer[get_bits_count(&s->gb) >> 3],
|
747 |
&s->gb.buffer[s->gb.size_in_bits >> 3], (length - 1)); |
748 |
} |
749 |
skip_bits_long(&s->gb, 0);
|
750 |
} |
751 |
|
752 |
if ((i = svq3_get_ue_golomb(&s->gb)) == INVALID_VLC || i >= 3){ |
753 |
av_log(h->s.avctx, AV_LOG_ERROR, "illegal slice type %d \n", i);
|
754 |
return -1; |
755 |
} |
756 |
|
757 |
h->slice_type = golomb_to_pict_type[i]; |
758 |
|
759 |
if ((header & 0x9F) == 2) { |
760 |
i = (s->mb_num < 64) ? 6 : (1 + av_log2 (s->mb_num - 1)); |
761 |
s->mb_skip_run = get_bits(&s->gb, i) - (s->mb_x + (s->mb_y * s->mb_width)); |
762 |
} else {
|
763 |
skip_bits1(&s->gb); |
764 |
s->mb_skip_run = 0;
|
765 |
} |
766 |
|
767 |
h->slice_num = get_bits(&s->gb, 8);
|
768 |
s->qscale = get_bits(&s->gb, 5);
|
769 |
s->adaptive_quant = get_bits1(&s->gb); |
770 |
|
771 |
/* unknown fields */
|
772 |
skip_bits1(&s->gb); |
773 |
|
774 |
if (svq3->unknown_flag) {
|
775 |
skip_bits1(&s->gb); |
776 |
} |
777 |
|
778 |
skip_bits1(&s->gb); |
779 |
skip_bits(&s->gb, 2);
|
780 |
|
781 |
while (get_bits1(&s->gb)) {
|
782 |
skip_bits(&s->gb, 8);
|
783 |
} |
784 |
|
785 |
/* reset intra predictors and invalidate motion vector references */
|
786 |
if (s->mb_x > 0) { |
787 |
memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - 1 ]+3, -1, 4*sizeof(int8_t)); |
788 |
memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - s->mb_x] , -1, 8*sizeof(int8_t)*s->mb_x); |
789 |
} |
790 |
if (s->mb_y > 0) { |
791 |
memset(h->intra4x4_pred_mode+h->mb2br_xy[mb_xy - s->mb_stride], -1, 8*sizeof(int8_t)*(s->mb_width - s->mb_x)); |
792 |
|
793 |
if (s->mb_x > 0) { |
794 |
h->intra4x4_pred_mode[h->mb2br_xy[mb_xy - s->mb_stride - 1]+3] = -1; |
795 |
} |
796 |
} |
797 |
|
798 |
return 0; |
799 |
} |
800 |
|
801 |
static av_cold int svq3_decode_init(AVCodecContext *avctx) |
802 |
{ |
803 |
SVQ3Context *svq3 = avctx->priv_data; |
804 |
H264Context *h = &svq3->h; |
805 |
MpegEncContext *s = &h->s; |
806 |
int m;
|
807 |
unsigned char *extradata; |
808 |
unsigned int size; |
809 |
|
810 |
if (ff_h264_decode_init(avctx) < 0) |
811 |
return -1; |
812 |
|
813 |
s->flags = avctx->flags; |
814 |
s->flags2 = avctx->flags2; |
815 |
s->unrestricted_mv = 1;
|
816 |
h->is_complex=1;
|
817 |
avctx->pix_fmt = avctx->codec->pix_fmts[0];
|
818 |
|
819 |
if (!s->context_initialized) {
|
820 |
s->width = avctx->width; |
821 |
s->height = avctx->height; |
822 |
h->chroma_qp[0] = h->chroma_qp[1] = 4; |
823 |
|
824 |
svq3->halfpel_flag = 1;
|
825 |
svq3->thirdpel_flag = 1;
|
826 |
svq3->unknown_flag = 0;
|
827 |
|
828 |
if (MPV_common_init(s) < 0) |
829 |
return -1; |
830 |
|
831 |
h->b_stride = 4*s->mb_width;
|
832 |
|
833 |
ff_h264_alloc_tables(h); |
834 |
|
835 |
/* prowl for the "SEQH" marker in the extradata */
|
836 |
extradata = (unsigned char *)avctx->extradata; |
837 |
for (m = 0; m < avctx->extradata_size; m++) { |
838 |
if (!memcmp(extradata, "SEQH", 4)) |
839 |
break;
|
840 |
extradata++; |
841 |
} |
842 |
|
843 |
/* if a match was found, parse the extra data */
|
844 |
if (extradata && !memcmp(extradata, "SEQH", 4)) { |
845 |
|
846 |
GetBitContext gb; |
847 |
int frame_size_code;
|
848 |
|
849 |
size = AV_RB32(&extradata[4]);
|
850 |
init_get_bits(&gb, extradata + 8, size*8); |
851 |
|
852 |
/* 'frame size code' and optional 'width, height' */
|
853 |
frame_size_code = get_bits(&gb, 3);
|
854 |
switch (frame_size_code) {
|
855 |
case 0: avctx->width = 160; avctx->height = 120; break; |
856 |
case 1: avctx->width = 128; avctx->height = 96; break; |
857 |
case 2: avctx->width = 176; avctx->height = 144; break; |
858 |
case 3: avctx->width = 352; avctx->height = 288; break; |
859 |
case 4: avctx->width = 704; avctx->height = 576; break; |
860 |
case 5: avctx->width = 240; avctx->height = 180; break; |
861 |
case 6: avctx->width = 320; avctx->height = 240; break; |
862 |
case 7: |
863 |
avctx->width = get_bits(&gb, 12);
|
864 |
avctx->height = get_bits(&gb, 12);
|
865 |
break;
|
866 |
} |
867 |
|
868 |
svq3->halfpel_flag = get_bits1(&gb); |
869 |
svq3->thirdpel_flag = get_bits1(&gb); |
870 |
|
871 |
/* unknown fields */
|
872 |
skip_bits1(&gb); |
873 |
skip_bits1(&gb); |
874 |
skip_bits1(&gb); |
875 |
skip_bits1(&gb); |
876 |
|
877 |
s->low_delay = get_bits1(&gb); |
878 |
|
879 |
/* unknown field */
|
880 |
skip_bits1(&gb); |
881 |
|
882 |
while (get_bits1(&gb)) {
|
883 |
skip_bits(&gb, 8);
|
884 |
} |
885 |
|
886 |
svq3->unknown_flag = get_bits1(&gb); |
887 |
avctx->has_b_frames = !s->low_delay; |
888 |
if (svq3->unknown_flag) {
|
889 |
#if CONFIG_ZLIB
|
890 |
unsigned watermark_width = svq3_get_ue_golomb(&gb);
|
891 |
unsigned watermark_height = svq3_get_ue_golomb(&gb);
|
892 |
int u1 = svq3_get_ue_golomb(&gb);
|
893 |
int u2 = get_bits(&gb, 8); |
894 |
int u3 = get_bits(&gb, 2); |
895 |
int u4 = svq3_get_ue_golomb(&gb);
|
896 |
unsigned long buf_len = watermark_width*watermark_height*4; |
897 |
int offset = (get_bits_count(&gb)+7)>>3; |
898 |
uint8_t *buf; |
899 |
|
900 |
if ((uint64_t)watermark_width*4 > UINT_MAX/watermark_height) |
901 |
return -1; |
902 |
|
903 |
buf = av_malloc(buf_len); |
904 |
av_log(avctx, AV_LOG_DEBUG, "watermark size: %dx%d\n", watermark_width, watermark_height);
|
905 |
av_log(avctx, AV_LOG_DEBUG, "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n", u1, u2, u3, u4, offset);
|
906 |
if (uncompress(buf, &buf_len, extradata + 8 + offset, size - offset) != Z_OK) { |
907 |
av_log(avctx, AV_LOG_ERROR, "could not uncompress watermark logo\n");
|
908 |
av_free(buf); |
909 |
return -1; |
910 |
} |
911 |
svq3->watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
|
912 |
svq3->watermark_key = svq3->watermark_key << 16 | svq3->watermark_key;
|
913 |
av_log(avctx, AV_LOG_DEBUG, "watermark key %#x\n", svq3->watermark_key);
|
914 |
av_free(buf); |
915 |
#else
|
916 |
av_log(avctx, AV_LOG_ERROR, "this svq3 file contains watermark which need zlib support compiled in\n");
|
917 |
return -1; |
918 |
#endif
|
919 |
} |
920 |
} |
921 |
} |
922 |
|
923 |
return 0; |
924 |
} |
925 |
|
926 |
static int svq3_decode_frame(AVCodecContext *avctx, |
927 |
void *data, int *data_size, |
928 |
AVPacket *avpkt) |
929 |
{ |
930 |
const uint8_t *buf = avpkt->data;
|
931 |
SVQ3Context *svq3 = avctx->priv_data; |
932 |
H264Context *h = &svq3->h; |
933 |
MpegEncContext *s = &h->s; |
934 |
int buf_size = avpkt->size;
|
935 |
int m, mb_type, left;
|
936 |
|
937 |
/* special case for last picture */
|
938 |
if (buf_size == 0) { |
939 |
if (s->next_picture_ptr && !s->low_delay) {
|
940 |
*(AVFrame *) data = *(AVFrame *) &s->next_picture; |
941 |
s->next_picture_ptr = NULL;
|
942 |
*data_size = sizeof(AVFrame);
|
943 |
} |
944 |
return 0; |
945 |
} |
946 |
|
947 |
init_get_bits (&s->gb, buf, 8*buf_size);
|
948 |
|
949 |
s->mb_x = s->mb_y = h->mb_xy = 0;
|
950 |
|
951 |
if (svq3_decode_slice_header(avctx))
|
952 |
return -1; |
953 |
|
954 |
s->pict_type = h->slice_type; |
955 |
s->picture_number = h->slice_num; |
956 |
|
957 |
if (avctx->debug&FF_DEBUG_PICT_INFO){
|
958 |
av_log(h->s.avctx, AV_LOG_DEBUG, "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
|
959 |
av_get_picture_type_char(s->pict_type), svq3->halfpel_flag, svq3->thirdpel_flag, |
960 |
s->adaptive_quant, s->qscale, h->slice_num); |
961 |
} |
962 |
|
963 |
/* for skipping the frame */
|
964 |
s->current_picture.pict_type = s->pict_type; |
965 |
s->current_picture.key_frame = (s->pict_type == AV_PICTURE_TYPE_I); |
966 |
|
967 |
/* Skip B-frames if we do not have reference frames. */
|
968 |
if (s->last_picture_ptr == NULL && s->pict_type == AV_PICTURE_TYPE_B) |
969 |
return 0; |
970 |
if ( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
|
971 |
||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) |
972 |
|| avctx->skip_frame >= AVDISCARD_ALL) |
973 |
return 0; |
974 |
|
975 |
if (s->next_p_frame_damaged) {
|
976 |
if (s->pict_type == AV_PICTURE_TYPE_B)
|
977 |
return 0; |
978 |
else
|
979 |
s->next_p_frame_damaged = 0;
|
980 |
} |
981 |
|
982 |
if (ff_h264_frame_start(h) < 0) |
983 |
return -1; |
984 |
|
985 |
if (s->pict_type == AV_PICTURE_TYPE_B) {
|
986 |
h->frame_num_offset = (h->slice_num - h->prev_frame_num); |
987 |
|
988 |
if (h->frame_num_offset < 0) { |
989 |
h->frame_num_offset += 256;
|
990 |
} |
991 |
if (h->frame_num_offset == 0 || h->frame_num_offset >= h->prev_frame_num_offset) { |
992 |
av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
|
993 |
return -1; |
994 |
} |
995 |
} else {
|
996 |
h->prev_frame_num = h->frame_num; |
997 |
h->frame_num = h->slice_num; |
998 |
h->prev_frame_num_offset = (h->frame_num - h->prev_frame_num); |
999 |
|
1000 |
if (h->prev_frame_num_offset < 0) { |
1001 |
h->prev_frame_num_offset += 256;
|
1002 |
} |
1003 |
} |
1004 |
|
1005 |
for (m = 0; m < 2; m++){ |
1006 |
int i;
|
1007 |
for (i = 0; i < 4; i++){ |
1008 |
int j;
|
1009 |
for (j = -1; j < 4; j++) |
1010 |
h->ref_cache[m][scan8[0] + 8*i + j]= 1; |
1011 |
if (i < 3) |
1012 |
h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE; |
1013 |
} |
1014 |
} |
1015 |
|
1016 |
for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) { |
1017 |
for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) { |
1018 |
h->mb_xy = s->mb_x + s->mb_y*s->mb_stride; |
1019 |
|
1020 |
if ( (get_bits_count(&s->gb) + 7) >= s->gb.size_in_bits && |
1021 |
((get_bits_count(&s->gb) & 7) == 0 || show_bits(&s->gb, (-get_bits_count(&s->gb) & 7)) == 0)) { |
1022 |
|
1023 |
skip_bits(&s->gb, svq3->next_slice_index - get_bits_count(&s->gb)); |
1024 |
s->gb.size_in_bits = 8*buf_size;
|
1025 |
|
1026 |
if (svq3_decode_slice_header(avctx))
|
1027 |
return -1; |
1028 |
|
1029 |
/* TODO: support s->mb_skip_run */
|
1030 |
} |
1031 |
|
1032 |
mb_type = svq3_get_ue_golomb(&s->gb); |
1033 |
|
1034 |
if (s->pict_type == AV_PICTURE_TYPE_I) {
|
1035 |
mb_type += 8;
|
1036 |
} else if (s->pict_type == AV_PICTURE_TYPE_B && mb_type >= 4) { |
1037 |
mb_type += 4;
|
1038 |
} |
1039 |
if (mb_type > 33 || svq3_decode_mb(svq3, mb_type)) { |
1040 |
av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
|
1041 |
return -1; |
1042 |
} |
1043 |
|
1044 |
if (mb_type != 0) { |
1045 |
ff_h264_hl_decode_mb (h); |
1046 |
} |
1047 |
|
1048 |
if (s->pict_type != AV_PICTURE_TYPE_B && !s->low_delay) {
|
1049 |
s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride] = |
1050 |
(s->pict_type == AV_PICTURE_TYPE_P && mb_type < 8) ? (mb_type - 1) : -1; |
1051 |
} |
1052 |
} |
1053 |
|
1054 |
ff_draw_horiz_band(s, 16*s->mb_y, 16); |
1055 |
} |
1056 |
|
1057 |
left = buf_size*8 - get_bits_count(&s->gb);
|
1058 |
|
1059 |
if (s->mb_y != s->mb_height || s->mb_x != s->mb_width) {
|
1060 |
av_log(avctx, AV_LOG_INFO, "frame num %d incomplete pic x %d y %d left %d\n", avctx->frame_number, s->mb_y, s->mb_x, left);
|
1061 |
//av_hex_dump(stderr, buf+buf_size-8, 8);
|
1062 |
} |
1063 |
|
1064 |
if (left < 0) { |
1065 |
av_log(avctx, AV_LOG_ERROR, "frame num %d left %d\n", avctx->frame_number, left);
|
1066 |
return -1; |
1067 |
} |
1068 |
|
1069 |
MPV_frame_end(s); |
1070 |
|
1071 |
if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
|
1072 |
*(AVFrame *) data = *(AVFrame *) &s->current_picture; |
1073 |
} else {
|
1074 |
*(AVFrame *) data = *(AVFrame *) &s->last_picture; |
1075 |
} |
1076 |
|
1077 |
/* Do not output the last pic after seeking. */
|
1078 |
if (s->last_picture_ptr || s->low_delay) {
|
1079 |
*data_size = sizeof(AVFrame);
|
1080 |
} |
1081 |
|
1082 |
return buf_size;
|
1083 |
} |
1084 |
|
1085 |
static int svq3_decode_end(AVCodecContext *avctx) |
1086 |
{ |
1087 |
SVQ3Context *svq3 = avctx->priv_data; |
1088 |
H264Context *h = &svq3->h; |
1089 |
MpegEncContext *s = &h->s; |
1090 |
|
1091 |
ff_h264_free_context(h); |
1092 |
|
1093 |
MPV_common_end(s); |
1094 |
|
1095 |
return 0; |
1096 |
} |
1097 |
|
1098 |
AVCodec ff_svq3_decoder = { |
1099 |
"svq3",
|
1100 |
AVMEDIA_TYPE_VIDEO, |
1101 |
CODEC_ID_SVQ3, |
1102 |
sizeof(SVQ3Context),
|
1103 |
svq3_decode_init, |
1104 |
NULL,
|
1105 |
svq3_decode_end, |
1106 |
svq3_decode_frame, |
1107 |
CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_DELAY, |
1108 |
.long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3 / Sorenson Video 3 / SVQ3"),
|
1109 |
.pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_NONE}, |
1110 |
}; |