Mercurial > libavcodec.hg
annotate rv40.c @ 6586:01bea2407628 libavcodec
Remove redundant &.
author | michael |
---|---|
date | Sun, 13 Apr 2008 00:05:38 +0000 |
parents | 48759bfbd073 |
children | 5b3acf9fd50a |
rev | line source |
---|---|
5983 | 1 /* |
2 * RV40 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 rv40.c | |
24 * RV40 decoder | |
25 */ | |
26 | |
27 #include "avcodec.h" | |
28 #include "dsputil.h" | |
29 #include "mpegvideo.h" | |
5995 | 30 #include "golomb.h" |
5983 | 31 |
32 #include "rv34.h" | |
33 #include "rv40vlc2.h" | |
34 #include "rv40data.h" | |
35 | |
36 static VLC aic_top_vlc; | |
37 static VLC aic_mode1_vlc[AIC_MODE1_NUM], aic_mode2_vlc[AIC_MODE2_NUM]; | |
38 static VLC ptype_vlc[NUM_PTYPE_VLCS], btype_vlc[NUM_BTYPE_VLCS]; | |
39 | |
40 /** | |
41 * Initialize all tables. | |
42 */ | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6481
diff
changeset
|
43 static av_cold void rv40_init_tables() |
5983 | 44 { |
45 int i; | |
46 | |
47 init_vlc(&aic_top_vlc, AIC_TOP_BITS, AIC_TOP_SIZE, | |
48 rv40_aic_top_vlc_bits, 1, 1, | |
49 rv40_aic_top_vlc_codes, 1, 1, INIT_VLC_USE_STATIC); | |
50 for(i = 0; i < AIC_MODE1_NUM; i++){ | |
51 // Every tenth VLC table is empty | |
52 if((i % 10) == 9) continue; | |
53 init_vlc(&aic_mode1_vlc[i], AIC_MODE1_BITS, AIC_MODE1_SIZE, | |
54 aic_mode1_vlc_bits[i], 1, 1, | |
55 aic_mode1_vlc_codes[i], 1, 1, INIT_VLC_USE_STATIC); | |
56 } | |
57 for(i = 0; i < AIC_MODE2_NUM; i++){ | |
58 init_vlc(&aic_mode2_vlc[i], AIC_MODE2_BITS, AIC_MODE2_SIZE, | |
59 aic_mode2_vlc_bits[i], 1, 1, | |
60 aic_mode2_vlc_codes[i], 2, 2, INIT_VLC_USE_STATIC); | |
61 } | |
62 for(i = 0; i < NUM_PTYPE_VLCS; i++) | |
63 init_vlc_sparse(&ptype_vlc[i], PTYPE_VLC_BITS, PTYPE_VLC_SIZE, | |
64 ptype_vlc_bits[i], 1, 1, | |
65 ptype_vlc_codes[i], 1, 1, | |
66 ptype_vlc_syms, 1, 1, INIT_VLC_USE_STATIC); | |
67 for(i = 0; i < NUM_BTYPE_VLCS; i++) | |
68 init_vlc_sparse(&btype_vlc[i], BTYPE_VLC_BITS, BTYPE_VLC_SIZE, | |
69 btype_vlc_bits[i], 1, 1, | |
70 btype_vlc_codes[i], 1, 1, | |
71 btype_vlc_syms, 1, 1, INIT_VLC_USE_STATIC); | |
72 } | |
73 | |
74 /** | |
75 * Get stored dimension from bitstream. | |
76 * | |
77 * If the width/height is the standard one then it's coded as a 3-bit index. | |
78 * Otherwise it is coded as escaped 8-bit portions. | |
79 */ | |
80 static int get_dimension(GetBitContext *gb, const int *dim) | |
81 { | |
82 int t = get_bits(gb, 3); | |
83 int val = dim[t]; | |
84 if(val < 0) | |
85 val = dim[get_bits1(gb) - val]; | |
86 if(!val){ | |
87 do{ | |
88 t = get_bits(gb, 8); | |
89 val += t << 2; | |
90 }while(t == 0xFF); | |
91 } | |
92 return val; | |
93 } | |
94 | |
95 /** | |
96 * Get encoded picture size - usually this is called from rv40_parse_slice_header. | |
97 */ | |
98 static void rv40_parse_picture_size(GetBitContext *gb, int *w, int *h) | |
99 { | |
100 *w = get_dimension(gb, rv40_standard_widths); | |
101 *h = get_dimension(gb, rv40_standard_heights); | |
102 } | |
103 | |
104 static int rv40_parse_slice_header(RV34DecContext *r, GetBitContext *gb, SliceInfo *si) | |
105 { | |
106 int t, mb_bits; | |
107 int w = r->s.width, h = r->s.height; | |
108 int mb_size; | |
109 | |
110 memset(si, 0, sizeof(SliceInfo)); | |
111 if(get_bits1(gb)) | |
112 return -1; | |
113 si->type = get_bits(gb, 2); | |
114 if(si->type == 1) si->type = 0; | |
115 si->quant = get_bits(gb, 5); | |
116 if(get_bits(gb, 2)) | |
117 return -1; | |
118 si->vlc_set = get_bits(gb, 2); | |
119 skip_bits1(gb); | |
120 t = get_bits(gb, 13); /// ??? | |
121 if(!si->type || !get_bits1(gb)) | |
122 rv40_parse_picture_size(gb, &w, &h); | |
5994 | 123 if(avcodec_check_dimensions(r->s.avctx, w, h) < 0) |
124 return -1; | |
5983 | 125 si->width = w; |
126 si->height = h; | |
127 mb_size = ((w + 15) >> 4) * ((h + 15) >> 4); | |
128 mb_bits = ff_rv34_get_start_offset(gb, mb_size); | |
129 si->start = get_bits(gb, mb_bits); | |
130 | |
131 return 0; | |
132 } | |
133 | |
134 /** | |
135 * Decode 4x4 intra types array. | |
136 */ | |
5993 | 137 static int rv40_decode_intra_types(RV34DecContext *r, GetBitContext *gb, int8_t *dst) |
5983 | 138 { |
139 MpegEncContext *s = &r->s; | |
140 int i, j, k, v; | |
141 int A, B, C; | |
142 int pattern; | |
5993 | 143 int8_t *ptr; |
5983 | 144 |
145 for(i = 0; i < 4; i++, dst += s->b4_stride){ | |
146 if(!i && s->first_slice_line){ | |
147 pattern = get_vlc2(gb, aic_top_vlc.table, AIC_TOP_BITS, 1); | |
148 dst[0] = (pattern >> 2) & 2; | |
149 dst[1] = (pattern >> 1) & 2; | |
150 dst[2] = pattern & 2; | |
151 dst[3] = (pattern << 1) & 2; | |
152 continue; | |
153 } | |
154 ptr = dst; | |
155 for(j = 0; j < 4; j++){ | |
156 /* Coefficients are read using VLC chosen by the prediction pattern | |
157 * The first one (used for retrieving a pair of coefficients) is | |
158 * constructed from the top, top right and left coefficients | |
159 * The second one (used for retrieving only one coefficient) is | |
160 * top + 10 * left. | |
161 */ | |
162 A = ptr[-s->b4_stride + 1]; // it won't be used for the last coefficient in a row | |
163 B = ptr[-s->b4_stride]; | |
164 C = ptr[-1]; | |
165 pattern = A + (B << 4) + (C << 8); | |
166 for(k = 0; k < MODE2_PATTERNS_NUM; k++) | |
167 if(pattern == rv40_aic_table_index[k]) | |
168 break; | |
169 if(j < 3 && k < MODE2_PATTERNS_NUM){ //pattern is found, decoding 2 coefficients | |
170 v = get_vlc2(gb, aic_mode2_vlc[k].table, AIC_MODE2_BITS, 2); | |
171 *ptr++ = v/9; | |
172 *ptr++ = v%9; | |
173 j++; | |
174 }else{ | |
175 if(B != -1 && C != -1) | |
176 v = get_vlc2(gb, aic_mode1_vlc[B + C*10].table, AIC_MODE1_BITS, 1); | |
177 else{ // tricky decoding | |
178 v = 0; | |
179 switch(C){ | |
180 case -1: // code 0 -> 1, 1 -> 0 | |
181 if(B < 2) | |
182 v = get_bits1(gb) ^ 1; | |
183 break; | |
184 case 0: | |
185 case 2: // code 0 -> 2, 1 -> 0 | |
186 v = (get_bits1(gb) ^ 1) << 1; | |
187 break; | |
188 } | |
189 } | |
190 *ptr++ = v; | |
191 } | |
192 } | |
193 } | |
194 return 0; | |
195 } | |
196 | |
197 /** | |
198 * Decode macroblock information. | |
199 */ | |
200 static int rv40_decode_mb_info(RV34DecContext *r) | |
201 { | |
202 MpegEncContext *s = &r->s; | |
203 GetBitContext *gb = &s->gb; | |
204 int q, i; | |
205 int prev_type = 0; | |
206 int mb_pos = s->mb_x + s->mb_y * s->mb_stride; | |
207 int blocks[RV34_MB_TYPES] = {0}; | |
208 int count = 0; | |
209 | |
210 if(!r->s.mb_skip_run) | |
5995 | 211 r->s.mb_skip_run = svq3_get_ue_golomb(gb) + 1; |
5983 | 212 |
213 if(--r->s.mb_skip_run) | |
214 return RV34_MB_SKIP; | |
215 | |
6027 | 216 if(r->avail_cache[5-1]) |
5983 | 217 blocks[r->mb_type[mb_pos - 1]]++; |
6027 | 218 if(r->avail_cache[5-4]){ |
5983 | 219 blocks[r->mb_type[mb_pos - s->mb_stride]]++; |
6027 | 220 if(r->avail_cache[5-2]) |
5983 | 221 blocks[r->mb_type[mb_pos - s->mb_stride + 1]]++; |
6027 | 222 if(r->avail_cache[5-5]) |
5983 | 223 blocks[r->mb_type[mb_pos - s->mb_stride - 1]]++; |
224 } | |
225 | |
226 for(i = 0; i < RV34_MB_TYPES; i++){ | |
227 if(blocks[i] > count){ | |
228 count = blocks[i]; | |
229 prev_type = i; | |
230 } | |
231 } | |
6481 | 232 if(s->pict_type == FF_P_TYPE){ |
5983 | 233 prev_type = block_num_to_ptype_vlc_num[prev_type]; |
234 q = get_vlc2(gb, ptype_vlc[prev_type].table, PTYPE_VLC_BITS, 1); | |
235 if(q < PBTYPE_ESCAPE) | |
236 return q; | |
237 q = get_vlc2(gb, ptype_vlc[prev_type].table, PTYPE_VLC_BITS, 1); | |
238 av_log(s->avctx, AV_LOG_ERROR, "Dquant for P-frame\n"); | |
239 }else{ | |
240 prev_type = block_num_to_btype_vlc_num[prev_type]; | |
241 q = get_vlc2(gb, btype_vlc[prev_type].table, BTYPE_VLC_BITS, 1); | |
242 if(q < PBTYPE_ESCAPE) | |
243 return q; | |
244 q = get_vlc2(gb, btype_vlc[prev_type].table, BTYPE_VLC_BITS, 1); | |
245 av_log(s->avctx, AV_LOG_ERROR, "Dquant for B-frame\n"); | |
246 } | |
247 return 0; | |
248 } | |
249 | |
250 /** | |
251 * Initialize decoder. | |
252 */ | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6481
diff
changeset
|
253 static av_cold int rv40_decode_init(AVCodecContext *avctx) |
5983 | 254 { |
255 RV34DecContext *r = avctx->priv_data; | |
256 | |
257 r->rv30 = 0; | |
258 ff_rv34_decode_init(avctx); | |
259 if(!aic_top_vlc.bits) | |
260 rv40_init_tables(); | |
261 r->parse_slice_header = rv40_parse_slice_header; | |
262 r->decode_intra_types = rv40_decode_intra_types; | |
263 r->decode_mb_info = rv40_decode_mb_info; | |
264 r->luma_dc_quant_i = rv40_luma_dc_quant[0]; | |
265 r->luma_dc_quant_p = rv40_luma_dc_quant[1]; | |
266 return 0; | |
267 } | |
268 | |
269 AVCodec rv40_decoder = { | |
270 "rv40", | |
271 CODEC_TYPE_VIDEO, | |
272 CODEC_ID_RV40, | |
273 sizeof(RV34DecContext), | |
274 rv40_decode_init, | |
275 NULL, | |
276 ff_rv34_decode_end, | |
277 ff_rv34_decode_frame, | |
5992 | 278 CODEC_CAP_DR1 | CODEC_CAP_DELAY, |
5983 | 279 }; |