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
31
34
35
37 {
39 int mb_bits;
40 int w =
r->s.width,
h =
r->s.height;
41 int mb_size;
42 int rpr;
43
46 return -1;
50 return -1;
55 if(rpr){
56 if (rpr >
r->max_rpr) {
59 }
60
63 "Insufficient extradata - need at least %d bytes, got %d\n",
66 }
67
68 w =
r->s.avctx->extradata[6 + rpr*2] << 2;
69 h =
r->s.avctx->extradata[7 + rpr*2] << 2;
70 } else {
73 }
76 mb_size = ((
w + 15) >> 4) * ((
h + 15) >> 4);
80 return 0;
81 }
82
83 /**
84 * Decode 4x4 intra types array.
85 */
87 {
89
90 for(
i = 0;
i < 4;
i++, dst +=
r->intra_types_stride - 4){
91 for(j = 0; j < 4; j+= 2){
95 return -1;
96 }
97 for(k = 0; k < 2; k++){
98 int A = dst[-
r->intra_types_stride] + 1;
101 if(dst[-1] == 9){
103 return -1;
104 }
105 }
106 }
107 }
108 return 0;
109 }
110
111 /**
112 * Decode macroblock information.
113 */
115 {
121
124 return -1;
125 }
129 }
131 return rv30_p_types[
code];
132 else
133 return rv30_b_types[
code];
134 }
135
137 const int stride,
const int lim)
138 {
141
142 for(
i = 0;
i < 4;
i++){
148 }
149 }
150
152 {
154 int mb_pos, mb_x;
157 int loc_lim, cur_lim, left_lim = 0, top_lim = 0;
158
159 mb_pos = row *
s->mb_stride;
160 for(mb_x = 0; mb_x <
s->mb_width; mb_x++, mb_pos++){
161 int mbtype =
s->current_picture_ptr->mb_type[mb_pos];
163 r->deblock_coefs[mb_pos] = 0xFFFF;
165 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 mb_pos = row *
s->mb_stride;
172 for(mb_x = 0; mb_x <
s->mb_width; mb_x++, mb_pos++){
174 if(mb_x)
176 for(j = 0; j < 16; j += 4){
177 Y =
s->current_picture_ptr->f->data[0] + mb_x*16 + (row*16 + j) *
s->linesize + 4 * !mb_x;
178 for(
i = !mb_x;
i < 4;
i++,
Y += 4){
180 loc_lim = 0;
181 if(
r->deblock_coefs[mb_pos] & (1 << ij))
182 loc_lim = cur_lim;
183 else if(!
i &&
r->deblock_coefs[mb_pos - 1] & (1 << (ij + 3)))
184 loc_lim = left_lim;
185 else if(
i &&
r->deblock_coefs[mb_pos] & (1 << (ij - 1)))
186 loc_lim = cur_lim;
187 if(loc_lim)
189 }
190 }
191 for(k = 0; k < 2; k++){
192 int cur_cbp, left_cbp = 0;
193 cur_cbp = (
r->cbp_chroma[mb_pos] >> (k*4)) & 0xF;
194 if(mb_x)
195 left_cbp = (
r->cbp_chroma[mb_pos - 1] >> (k*4)) & 0xF;
196 for(j = 0; j < 8; j += 4){
197 C =
s->current_picture_ptr->f->data[k + 1] + mb_x*8 + (row*8 + j) *
s->uvlinesize + 4 * !mb_x;
198 for(
i = !mb_x;
i < 2;
i++,
C += 4){
199 int ij =
i + (j >> 1);
200 loc_lim = 0;
201 if (cur_cbp & (1 << ij))
202 loc_lim = cur_lim;
203 else if(!
i && left_cbp & (1 << (ij + 1)))
204 loc_lim = left_lim;
205 else if(
i && cur_cbp & (1 << (ij - 1)))
206 loc_lim = cur_lim;
207 if(loc_lim)
209 }
210 }
211 }
212 }
213 mb_pos = row *
s->mb_stride;
214 for(mb_x = 0; mb_x <
s->mb_width; mb_x++, mb_pos++){
216 if(row)
218 for(j = 4*!row; j < 16; j += 4){
219 Y =
s->current_picture_ptr->f->data[0] + mb_x*16 + (row*16 + j) *
s->linesize;
220 for(
i = 0;
i < 4;
i++,
Y += 4){
222 loc_lim = 0;
223 if(
r->deblock_coefs[mb_pos] & (1 << ij))
224 loc_lim = cur_lim;
225 else if(!j &&
r->deblock_coefs[mb_pos -
s->mb_stride] & (1 << (ij + 12)))
226 loc_lim = top_lim;
227 else if( j &&
r->deblock_coefs[mb_pos] & (1 << (ij - 4)))
228 loc_lim = cur_lim;
229 if(loc_lim)
231 }
232 }
233 for(k = 0; k < 2; k++){
234 int cur_cbp, top_cbp = 0;
235 cur_cbp = (
r->cbp_chroma[mb_pos] >> (k*4)) & 0xF;
236 if(row)
237 top_cbp = (
r->cbp_chroma[mb_pos -
s->mb_stride] >> (k*4)) & 0xF;
238 for(j = 4*!row; j < 8; j += 4){
239 C =
s->current_picture_ptr->f->data[k+1] + mb_x*8 + (row*8 + j) *
s->uvlinesize;
240 for(
i = 0;
i < 2;
i++,
C += 4){
241 int ij =
i + (j >> 1);
242 loc_lim = 0;
243 if (
r->cbp_chroma[mb_pos] & (1 << ij))
244 loc_lim = cur_lim;
245 else if(!j && top_cbp & (1 << (ij + 2)))
246 loc_lim = top_lim;
247 else if( j && cur_cbp & (1 << (ij - 2)))
248 loc_lim = cur_lim;
249 if(loc_lim)
251 }
252 }
253 }
254 }
255 }
256
257 /**
258 * Initialize decoder.
259 */
261 {
264
267
271 }
275
280 }
281
289 return 0;
290 }
291
307 },
310 };