1 |
|
|
/* |
2 |
|
|
* RV30 decoder |
3 |
|
|
* Copyright (c) 2007 Konstantin Shishkov |
4 |
|
|
* |
5 |
|
|
* This file is part of FFmpeg. |
6 |
|
|
* |
7 |
|
|
* FFmpeg is free software; you can redistribute it and/or |
8 |
|
|
* modify it under the terms of the GNU Lesser General Public |
9 |
|
|
* License as published by the Free Software Foundation; either |
10 |
|
|
* version 2.1 of the License, or (at your option) any later version. |
11 |
|
|
* |
12 |
|
|
* FFmpeg is distributed in the hope that it will be useful, |
13 |
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
14 |
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
15 |
|
|
* Lesser General Public License for more details. |
16 |
|
|
* |
17 |
|
|
* You should have received a copy of the GNU Lesser General Public |
18 |
|
|
* License along with FFmpeg; if not, write to the Free Software |
19 |
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
20 |
|
|
*/ |
21 |
|
|
|
22 |
|
|
/** |
23 |
|
|
* @file |
24 |
|
|
* RV30 decoder |
25 |
|
|
*/ |
26 |
|
|
|
27 |
|
|
#include "avcodec.h" |
28 |
|
|
#include "mpegutils.h" |
29 |
|
|
#include "mpegvideo.h" |
30 |
|
|
#include "golomb.h" |
31 |
|
|
|
32 |
|
|
#include "rv34.h" |
33 |
|
|
#include "rv30data.h" |
34 |
|
|
|
35 |
|
|
|
36 |
|
707 |
static int rv30_parse_slice_header(RV34DecContext *r, GetBitContext *gb, SliceInfo *si) |
37 |
|
|
{ |
38 |
|
707 |
AVCodecContext *avctx = r->s.avctx; |
39 |
|
|
int mb_bits; |
40 |
|
707 |
int w = r->s.width, h = r->s.height; |
41 |
|
|
int mb_size; |
42 |
|
|
int rpr; |
43 |
|
|
|
44 |
|
707 |
memset(si, 0, sizeof(SliceInfo)); |
45 |
✓✓ |
707 |
if(get_bits(gb, 3)) |
46 |
|
1 |
return -1; |
47 |
|
706 |
si->type = get_bits(gb, 2); |
48 |
✗✓ |
706 |
if(si->type == 1) si->type = 0; |
49 |
✗✓ |
706 |
if(get_bits1(gb)) |
50 |
|
|
return -1; |
51 |
|
706 |
si->quant = get_bits(gb, 5); |
52 |
|
706 |
skip_bits1(gb); |
53 |
|
706 |
si->pts = get_bits(gb, 13); |
54 |
|
706 |
rpr = get_bits(gb, av_log2(r->max_rpr) + 1); |
55 |
✗✓ |
706 |
if(rpr){ |
56 |
|
|
if (rpr > r->max_rpr) { |
57 |
|
|
av_log(avctx, AV_LOG_ERROR, "rpr too large\n"); |
58 |
|
|
return AVERROR_INVALIDDATA; |
59 |
|
|
} |
60 |
|
|
|
61 |
|
|
if (avctx->extradata_size < rpr * 2 + 8) { |
62 |
|
|
av_log(avctx, AV_LOG_ERROR, |
63 |
|
|
"Insufficient extradata - need at least %d bytes, got %d\n", |
64 |
|
|
8 + rpr * 2, avctx->extradata_size); |
65 |
|
|
return AVERROR(EINVAL); |
66 |
|
|
} |
67 |
|
|
|
68 |
|
|
w = r->s.avctx->extradata[6 + rpr*2] << 2; |
69 |
|
|
h = r->s.avctx->extradata[7 + rpr*2] << 2; |
70 |
|
|
} else { |
71 |
|
706 |
w = r->orig_width; |
72 |
|
706 |
h = r->orig_height; |
73 |
|
|
} |
74 |
|
706 |
si->width = w; |
75 |
|
706 |
si->height = h; |
76 |
|
706 |
mb_size = ((w + 15) >> 4) * ((h + 15) >> 4); |
77 |
|
706 |
mb_bits = ff_rv34_get_start_offset(gb, mb_size); |
78 |
|
706 |
si->start = get_bits(gb, mb_bits); |
79 |
|
706 |
skip_bits1(gb); |
80 |
|
706 |
return 0; |
81 |
|
|
} |
82 |
|
|
|
83 |
|
|
/** |
84 |
|
|
* Decode 4x4 intra types array. |
85 |
|
|
*/ |
86 |
|
2739 |
static int rv30_decode_intra_types(RV34DecContext *r, GetBitContext *gb, int8_t *dst) |
87 |
|
|
{ |
88 |
|
|
int i, j, k; |
89 |
|
|
|
90 |
✓✓ |
13695 |
for(i = 0; i < 4; i++, dst += r->intra_types_stride - 4){ |
91 |
✓✓ |
32868 |
for(j = 0; j < 4; j+= 2){ |
92 |
|
21912 |
unsigned code = get_interleaved_ue_golomb(gb) << 1; |
93 |
✗✓ |
21912 |
if (code > 80U*2U) { |
94 |
|
|
av_log(r->s.avctx, AV_LOG_ERROR, "Incorrect intra prediction code\n"); |
95 |
|
|
return -1; |
96 |
|
|
} |
97 |
✓✓ |
65736 |
for(k = 0; k < 2; k++){ |
98 |
|
43824 |
int A = dst[-r->intra_types_stride] + 1; |
99 |
|
43824 |
int B = dst[-1] + 1; |
100 |
|
43824 |
*dst++ = rv30_itype_from_context[A * 90 + B * 9 + rv30_itype_code[code + k]]; |
101 |
✗✓ |
43824 |
if(dst[-1] == 9){ |
102 |
|
|
av_log(r->s.avctx, AV_LOG_ERROR, "Incorrect intra prediction mode\n"); |
103 |
|
|
return -1; |
104 |
|
|
} |
105 |
|
|
} |
106 |
|
|
} |
107 |
|
|
} |
108 |
|
2739 |
return 0; |
109 |
|
|
} |
110 |
|
|
|
111 |
|
|
/** |
112 |
|
|
* Decode macroblock information. |
113 |
|
|
*/ |
114 |
|
68640 |
static int rv30_decode_mb_info(RV34DecContext *r) |
115 |
|
|
{ |
116 |
|
|
static const int rv30_p_types[6] = { RV34_MB_SKIP, RV34_MB_P_16x16, RV34_MB_P_8x8, -1, RV34_MB_TYPE_INTRA, RV34_MB_TYPE_INTRA16x16 }; |
117 |
|
|
static const int rv30_b_types[6] = { RV34_MB_SKIP, RV34_MB_B_DIRECT, RV34_MB_B_FORWARD, RV34_MB_B_BACKWARD, RV34_MB_TYPE_INTRA, RV34_MB_TYPE_INTRA16x16 }; |
118 |
|
68640 |
MpegEncContext *s = &r->s; |
119 |
|
68640 |
GetBitContext *gb = &s->gb; |
120 |
|
68640 |
unsigned code = get_interleaved_ue_golomb(gb); |
121 |
|
|
|
122 |
✗✓ |
68640 |
if (code > 11) { |
123 |
|
|
av_log(s->avctx, AV_LOG_ERROR, "Incorrect MB type code\n"); |
124 |
|
|
return -1; |
125 |
|
|
} |
126 |
✗✓ |
68640 |
if(code > 5){ |
127 |
|
|
av_log(s->avctx, AV_LOG_ERROR, "dquant needed\n"); |
128 |
|
|
code -= 6; |
129 |
|
|
} |
130 |
✓✓ |
68640 |
if(s->pict_type != AV_PICTURE_TYPE_B) |
131 |
|
15180 |
return rv30_p_types[code]; |
132 |
|
|
else |
133 |
|
53460 |
return rv30_b_types[code]; |
134 |
|
|
} |
135 |
|
|
|
136 |
|
1048204 |
static inline void rv30_weak_loop_filter(uint8_t *src, const int step, |
137 |
|
|
const int stride, const int lim) |
138 |
|
|
{ |
139 |
|
1048204 |
const uint8_t *cm = ff_crop_tab + MAX_NEG_CROP; |
140 |
|
|
int i, diff; |
141 |
|
|
|
142 |
✓✓ |
5241020 |
for(i = 0; i < 4; i++){ |
143 |
|
4192816 |
diff = ((src[-2*step] - src[1*step]) - (src[-1*step] - src[0*step])*4) >> 3; |
144 |
|
4192816 |
diff = av_clip(diff, -lim, lim); |
145 |
|
4192816 |
src[-1*step] = cm[src[-1*step] + diff]; |
146 |
|
4192816 |
src[ 0*step] = cm[src[ 0*step] - diff]; |
147 |
|
4192816 |
src += stride; |
148 |
|
|
} |
149 |
|
1048204 |
} |
150 |
|
|
|
151 |
|
3308 |
static void rv30_loop_filter(RV34DecContext *r, int row) |
152 |
|
|
{ |
153 |
|
3308 |
MpegEncContext *s = &r->s; |
154 |
|
|
int mb_pos, mb_x; |
155 |
|
|
int i, j, k; |
156 |
|
|
uint8_t *Y, *C; |
157 |
|
3308 |
int loc_lim, cur_lim, left_lim = 0, top_lim = 0; |
158 |
|
|
|
159 |
|
3308 |
mb_pos = row * s->mb_stride; |
160 |
✓✓ |
75988 |
for(mb_x = 0; mb_x < s->mb_width; mb_x++, mb_pos++){ |
161 |
|
72680 |
int mbtype = s->current_picture_ptr->mb_type[mb_pos]; |
162 |
✓✓✗✓
|
72680 |
if(IS_INTRA(mbtype) || IS_SEPARATE_DC(mbtype)) |
163 |
|
9106 |
r->deblock_coefs[mb_pos] = 0xFFFF; |
164 |
✓✓ |
72680 |
if(IS_INTRA(mbtype)) |
165 |
|
9106 |
r->cbp_chroma[mb_pos] = 0xFF; |
166 |
|
|
} |
167 |
|
|
|
168 |
|
|
/* all vertical edges are filtered first |
169 |
|
|
* and horizontal edges are filtered on the next iteration |
170 |
|
|
*/ |
171 |
|
3308 |
mb_pos = row * s->mb_stride; |
172 |
✓✓ |
75988 |
for(mb_x = 0; mb_x < s->mb_width; mb_x++, mb_pos++){ |
173 |
|
72680 |
cur_lim = rv30_loop_filt_lim[s->current_picture_ptr->qscale_table[mb_pos]]; |
174 |
✓✓ |
72680 |
if(mb_x) |
175 |
|
69372 |
left_lim = rv30_loop_filt_lim[s->current_picture_ptr->qscale_table[mb_pos - 1]]; |
176 |
✓✓ |
363400 |
for(j = 0; j < 16; j += 4){ |
177 |
✓✓ |
290720 |
Y = s->current_picture_ptr->f->data[0] + mb_x*16 + (row*16 + j) * s->linesize + 4 * !mb_x; |
178 |
✓✓ |
1440368 |
for(i = !mb_x; i < 4; i++, Y += 4){ |
179 |
|
1149648 |
int ij = i + j; |
180 |
|
1149648 |
loc_lim = 0; |
181 |
✓✓ |
1149648 |
if(r->deblock_coefs[mb_pos] & (1 << ij)) |
182 |
|
351712 |
loc_lim = cur_lim; |
183 |
✓✓✓✓
|
797936 |
else if(!i && r->deblock_coefs[mb_pos - 1] & (1 << (ij + 3))) |
184 |
|
14120 |
loc_lim = left_lim; |
185 |
✓✓✓✓
|
783816 |
else if( i && r->deblock_coefs[mb_pos] & (1 << (ij - 1))) |
186 |
|
38450 |
loc_lim = cur_lim; |
187 |
✓✓ |
1149648 |
if(loc_lim) |
188 |
|
373358 |
rv30_weak_loop_filter(Y, 1, s->linesize, loc_lim); |
189 |
|
|
} |
190 |
|
|
} |
191 |
✓✓ |
218040 |
for(k = 0; k < 2; k++){ |
192 |
|
145360 |
int cur_cbp, left_cbp = 0; |
193 |
|
145360 |
cur_cbp = (r->cbp_chroma[mb_pos] >> (k*4)) & 0xF; |
194 |
✓✓ |
145360 |
if(mb_x) |
195 |
|
138744 |
left_cbp = (r->cbp_chroma[mb_pos - 1] >> (k*4)) & 0xF; |
196 |
✓✓ |
436080 |
for(j = 0; j < 8; j += 4){ |
197 |
✓✓ |
290720 |
C = s->current_picture_ptr->f->data[k + 1] + mb_x*8 + (row*8 + j) * s->uvlinesize + 4 * !mb_x; |
198 |
✓✓ |
858928 |
for(i = !mb_x; i < 2; i++, C += 4){ |
199 |
|
568208 |
int ij = i + (j >> 1); |
200 |
|
568208 |
loc_lim = 0; |
201 |
✓✓ |
568208 |
if (cur_cbp & (1 << ij)) |
202 |
|
132602 |
loc_lim = cur_lim; |
203 |
✓✓✓✓
|
435606 |
else if(!i && left_cbp & (1 << (ij + 1))) |
204 |
|
24668 |
loc_lim = left_lim; |
205 |
✓✓✓✓
|
410938 |
else if( i && cur_cbp & (1 << (ij - 1))) |
206 |
|
16738 |
loc_lim = cur_lim; |
207 |
✓✓ |
568208 |
if(loc_lim) |
208 |
|
143764 |
rv30_weak_loop_filter(C, 1, s->uvlinesize, loc_lim); |
209 |
|
|
} |
210 |
|
|
} |
211 |
|
|
} |
212 |
|
|
} |
213 |
|
3308 |
mb_pos = row * s->mb_stride; |
214 |
✓✓ |
75988 |
for(mb_x = 0; mb_x < s->mb_width; mb_x++, mb_pos++){ |
215 |
|
72680 |
cur_lim = rv30_loop_filt_lim[s->current_picture_ptr->qscale_table[mb_pos]]; |
216 |
✓✓ |
72680 |
if(row) |
217 |
|
67830 |
top_lim = rv30_loop_filt_lim[s->current_picture_ptr->qscale_table[mb_pos - s->mb_stride]]; |
218 |
✓✓✓✓
|
358550 |
for(j = 4*!row; j < 16; j += 4){ |
219 |
|
285870 |
Y = s->current_picture_ptr->f->data[0] + mb_x*16 + (row*16 + j) * s->linesize; |
220 |
✓✓ |
1429350 |
for(i = 0; i < 4; i++, Y += 4){ |
221 |
|
1143480 |
int ij = i + j; |
222 |
|
1143480 |
loc_lim = 0; |
223 |
✓✓ |
1143480 |
if(r->deblock_coefs[mb_pos] & (1 << ij)) |
224 |
|
350204 |
loc_lim = cur_lim; |
225 |
✓✓✓✓
|
793276 |
else if(!j && r->deblock_coefs[mb_pos - s->mb_stride] & (1 << (ij + 12))) |
226 |
|
15928 |
loc_lim = top_lim; |
227 |
✓✓✓✓
|
777348 |
else if( j && r->deblock_coefs[mb_pos] & (1 << (ij - 4))) |
228 |
|
45866 |
loc_lim = cur_lim; |
229 |
✓✓ |
1143480 |
if(loc_lim) |
230 |
|
381230 |
rv30_weak_loop_filter(Y, s->linesize, 1, loc_lim); |
231 |
|
|
} |
232 |
|
|
} |
233 |
✓✓ |
218040 |
for(k = 0; k < 2; k++){ |
234 |
|
145360 |
int cur_cbp, top_cbp = 0; |
235 |
|
145360 |
cur_cbp = (r->cbp_chroma[mb_pos] >> (k*4)) & 0xF; |
236 |
✓✓ |
145360 |
if(row) |
237 |
|
135660 |
top_cbp = (r->cbp_chroma[mb_pos - s->mb_stride] >> (k*4)) & 0xF; |
238 |
✓✓✓✓
|
426380 |
for(j = 4*!row; j < 8; j += 4){ |
239 |
|
281020 |
C = s->current_picture_ptr->f->data[k+1] + mb_x*8 + (row*8 + j) * s->uvlinesize; |
240 |
✓✓ |
843060 |
for(i = 0; i < 2; i++, C += 4){ |
241 |
|
562040 |
int ij = i + (j >> 1); |
242 |
|
562040 |
loc_lim = 0; |
243 |
✓✓ |
562040 |
if (r->cbp_chroma[mb_pos] & (1 << ij)) |
244 |
|
129332 |
loc_lim = cur_lim; |
245 |
✓✓✓✓
|
432708 |
else if(!j && top_cbp & (1 << (ij + 2))) |
246 |
|
28486 |
loc_lim = top_lim; |
247 |
✓✓✓✓
|
404222 |
else if( j && cur_cbp & (1 << (ij - 2))) |
248 |
|
22304 |
loc_lim = cur_lim; |
249 |
✓✓ |
562040 |
if(loc_lim) |
250 |
|
149852 |
rv30_weak_loop_filter(C, s->uvlinesize, 1, loc_lim); |
251 |
|
|
} |
252 |
|
|
} |
253 |
|
|
} |
254 |
|
|
} |
255 |
|
3308 |
} |
256 |
|
|
|
257 |
|
|
/** |
258 |
|
|
* Initialize decoder. |
259 |
|
|
*/ |
260 |
|
5 |
static av_cold int rv30_decode_init(AVCodecContext *avctx) |
261 |
|
|
{ |
262 |
|
5 |
RV34DecContext *r = avctx->priv_data; |
263 |
|
|
int ret; |
264 |
|
|
|
265 |
|
5 |
r->orig_width = avctx->coded_width; |
266 |
|
5 |
r->orig_height = avctx->coded_height; |
267 |
|
|
|
268 |
✗✓ |
5 |
if (avctx->extradata_size < 2) { |
269 |
|
|
av_log(avctx, AV_LOG_ERROR, "Extradata is too small.\n"); |
270 |
|
|
return AVERROR(EINVAL); |
271 |
|
|
} |
272 |
|
5 |
r->rv30 = 1; |
273 |
✗✓ |
5 |
if ((ret = ff_rv34_decode_init(avctx)) < 0) |
274 |
|
|
return ret; |
275 |
|
|
|
276 |
|
5 |
r->max_rpr = avctx->extradata[1] & 7; |
277 |
✗✓ |
5 |
if(avctx->extradata_size < 2*r->max_rpr + 8){ |
278 |
|
|
av_log(avctx, AV_LOG_WARNING, "Insufficient extradata - need at least %d bytes, got %d\n", |
279 |
|
|
2*r->max_rpr + 8, avctx->extradata_size); |
280 |
|
|
} |
281 |
|
|
|
282 |
|
5 |
r->parse_slice_header = rv30_parse_slice_header; |
283 |
|
5 |
r->decode_intra_types = rv30_decode_intra_types; |
284 |
|
5 |
r->decode_mb_info = rv30_decode_mb_info; |
285 |
|
5 |
r->loop_filter = rv30_loop_filter; |
286 |
|
5 |
r->luma_dc_quant_i = rv30_luma_dc_quant; |
287 |
|
5 |
r->luma_dc_quant_p = rv30_luma_dc_quant; |
288 |
|
5 |
ff_rv30dsp_init(&r->rdsp); |
289 |
|
5 |
return 0; |
290 |
|
|
} |
291 |
|
|
|
292 |
|
|
AVCodec ff_rv30_decoder = { |
293 |
|
|
.name = "rv30", |
294 |
|
|
.long_name = NULL_IF_CONFIG_SMALL("RealVideo 3.0"), |
295 |
|
|
.type = AVMEDIA_TYPE_VIDEO, |
296 |
|
|
.id = AV_CODEC_ID_RV30, |
297 |
|
|
.priv_data_size = sizeof(RV34DecContext), |
298 |
|
|
.init = rv30_decode_init, |
299 |
|
|
.close = ff_rv34_decode_end, |
300 |
|
|
.decode = ff_rv34_decode_frame, |
301 |
|
|
.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY | |
302 |
|
|
AV_CODEC_CAP_FRAME_THREADS, |
303 |
|
|
.flush = ff_mpeg_flush, |
304 |
|
|
.pix_fmts = (const enum AVPixelFormat[]) { |
305 |
|
|
AV_PIX_FMT_YUV420P, |
306 |
|
|
AV_PIX_FMT_NONE |
307 |
|
|
}, |
308 |
|
|
.update_thread_context = ONLY_IF_THREADS_ENABLED(ff_rv34_decode_update_thread_context), |
309 |
|
|
.caps_internal = FF_CODEC_CAP_ALLOCATE_PROGRESS, |
310 |
|
|
}; |