Mercurial > libavcodec.hg

comparison h263.c @ 249:42a0b7b16738 libavcodec

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
- Bug fixes in H.263+ Advanced INTRA Coding decoder. - H.263+ should be able to decode streams with AIC now :)
author pulento
date Tue, 19 Feb 2002 19:23:34 +0000
parents 56ee684c48bb
children 3449316664b5
comparison
equal deleted inserted replaced
248:56ee684c48bb 249:42a0b7b16738
271 h263_encode_block(s, block[i], i); 271 h263_encode_block(s, block[i], i);
272 } 272 }
273 } 273 }
274 } 274 }
275 275
276 static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr) 276
277 { 277 void h263_pred_acdc(MpegEncContext * s, INT16 *block, int n)
278 int a, c, x, y, wrap, pred, scale; 278 {
279 UINT16 *dc_val; 279 int x, y, wrap, a, c, pred_dc, scale, i;
280 INT16 *dc_val, *ac_val, *ac_val1;
280 281
281 /* find prediction */ 282 /* find prediction */
282 if (n < 4) { 283 if (n < 4) {
283 x = 2 * s->mb_x + 1 + (n & 1); 284 x = 2 * s->mb_x + 1 + (n & 1);
284 y = 2 * s->mb_y + 1 + ((n & 2) >> 1); 285 y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
285 wrap = s->mb_width * 2 + 2; 286 wrap = s->mb_width * 2 + 2;
286 dc_val = s->dc_val[0]; 287 dc_val = s->dc_val[0];
288 ac_val = s->ac_val[0][0];
287 scale = s->y_dc_scale; 289 scale = s->y_dc_scale;
288 } else { 290 } else {
289 x = s->mb_x + 1; 291 x = s->mb_x + 1;
290 y = s->mb_y + 1; 292 y = s->mb_y + 1;
291 wrap = s->mb_width + 2; 293 wrap = s->mb_width + 2;
292 dc_val = s->dc_val[n - 4 + 1]; 294 dc_val = s->dc_val[n - 4 + 1];
295 ac_val = s->ac_val[n - 4 + 1][0];
293 scale = s->c_dc_scale; 296 scale = s->c_dc_scale;
294 } 297 }
295 298
299 ac_val += ((y) * wrap + (x)) * 16;
300 ac_val1 = ac_val;
301
296 /* B C 302 /* B C
297 * A X 303 * A X
298 */ 304 */
299 a = dc_val[(x - 1) + (y) * wrap]; 305 a = dc_val[(x - 1) + (y) * wrap];
300 c = dc_val[(x) + (y - 1) * wrap]; 306 c = dc_val[(x) + (y - 1) * wrap];
301 307
302 if (s->ac_pred) { 308 pred_dc = 1024;
303 if (s->h263_aic_dir)
304 pred = a;
305 else
306 pred = c;
307 } else if (a != 1024 && c != 1024)
308 pred = (a + c) >> 1;
309 else if (a != 1024)
310 pred = a;
311 else
312 pred = c;
313
314
315 /* we assume pred is positive */
316 pred = (pred) / scale;
317
318 /* prepare address for prediction update */
319 *dc_val_ptr = &dc_val[(x) + (y) * wrap];
320
321 return pred;
322 }
323
324 void h263_pred_ac(MpegEncContext * s, INT16 *block, int n)
325 {
326 int x, y, wrap, i;
327 INT16 *ac_val, *ac_val1;
328
329 /* find prediction */
330 if (n < 4) {
331 x = 2 * s->mb_x + 1 + (n & 1);
332 y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
333 wrap = s->mb_width * 2 + 2;
334 ac_val = s->ac_val[0][0];
335 } else {
336 x = s->mb_x + 1;
337 y = s->mb_y + 1;
338 wrap = s->mb_width + 2;
339 ac_val = s->ac_val[n - 4 + 1][0];
340 }
341 ac_val += ((y) * wrap + (x)) * 16;
342 ac_val1 = ac_val;
343
344 if (s->ac_pred) { 309 if (s->ac_pred) {
345 if (s->h263_aic_dir) { 310 if (s->h263_aic_dir) {
346 /* left prediction */ 311 /* left prediction */
347 ac_val -= 16; 312 if (a != 1024) {
348 for(i=1;i<8;i++) { 313 ac_val -= 16;
349 block[block_permute_op(i*8)] += ac_val[i]; 314 for(i=1;i<8;i++) {
315 block[block_permute_op(i*8)] += ac_val[i];
316 }
317 pred_dc = a;
350 } 318 }
351 } else { 319 } else {
352 /* top prediction */ 320 /* top prediction */
353 ac_val -= 16 * wrap; 321 if (c != 1024) {
354 for(i=1;i<8;i++) { 322 ac_val -= 16 * wrap;
355 block[block_permute_op(i)] += ac_val[i + 8]; 323 for(i=1;i<8;i++) {
356 } 324 block[block_permute_op(i)] += ac_val[i + 8];
357 } 325 }
358 } 326 pred_dc = c;
327 }
328 }
329 } else {
330 /* just DC prediction */
331 if (a != 1024 && c != 1024)
332 pred_dc = (a + c) >> 1;
333 else if (a != 1024)
334 pred_dc = a;
335 else
336 pred_dc = c;
337 }
338
339 /* we assume pred is positive */
340 block[0]=block[0]*scale + pred_dc;
341
342 if (block[0] < 0)
343 block[0] = 0;
344 else if (!(block[0] & 1))
345 block[0]++;
346
347 /* Update AC/DC tables */
348 dc_val[(x) + (y) * wrap] = block[0];
349
359 /* left copy */ 350 /* left copy */
360 for(i=1;i<8;i++) 351 for(i=1;i<8;i++)
361 ac_val1[i] = block[block_permute_op(i * 8)]; 352 ac_val1[i] = block[block_permute_op(i * 8)];
362 /* top copy */ 353 /* top copy */
363 for(i=1;i<8;i++) 354 for(i=1;i<8;i++)
364 ac_val1[8 + i] = block[block_permute_op(i)]; 355 ac_val1[8 + i] = block[block_permute_op(i)];
365 } 356 }
357
366 358
367 static inline int mid_pred(int a, int b, int c) 359 static inline int mid_pred(int a, int b, int c)
368 { 360 {
369 int vmin, vmax; 361 int vmin, vmax;
370 vmax = vmin = a; 362 vmax = vmin = a;
1055 if (s->h263_pred || s->h263_aic) { 1047 if (s->h263_pred || s->h263_aic) {
1056 s->ac_pred = get_bits1(&s->gb); 1048 s->ac_pred = get_bits1(&s->gb);
1057 if (s->ac_pred && s->h263_aic) 1049 if (s->ac_pred && s->h263_aic)
1058 s->h263_aic_dir = get_bits1(&s->gb); 1050 s->h263_aic_dir = get_bits1(&s->gb);
1059 } 1051 }
1052 if (s->h263_aic) {
1053 s->y_dc_scale = 2 * s->qscale;
1054 s->c_dc_scale = 2 * s->qscale;
1055 }
1060 cbpy = get_vlc(&s->gb, &cbpy_vlc); 1056 cbpy = get_vlc(&s->gb, &cbpy_vlc);
1061 cbp = (cbpc & 3) | (cbpy << 2); 1057 cbp = (cbpc & 3) | (cbpy << 2);
1062 if (dquant) { 1058 if (dquant) {
1063 s->qscale += quant_tab[get_bits(&s->gb, 2)]; 1059 s->qscale += quant_tab[get_bits(&s->gb, 2)];
1064 if (s->qscale < 1) 1060 if (s->qscale < 1)
1152 static int h263_decode_block(MpegEncContext * s, DCTELEM * block, 1148 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
1153 int n, int coded) 1149 int n, int coded)
1154 { 1150 {
1155 int code, level, i, j, last, run; 1151 int code, level, i, j, last, run;
1156 RLTable *rl = &rl_inter; 1152 RLTable *rl = &rl_inter;
1157 UINT16 *dc_val;
1158 const UINT8 *scan_table; 1153 const UINT8 *scan_table;
1159 1154
1160 scan_table = zigzag_direct; 1155 scan_table = zigzag_direct;
1161 if (s->h263_aic) { 1156 if (s->h263_aic && s->mb_intra) {
1162 rl = &rl_intra_aic; 1157 rl = &rl_intra_aic;
1163 i = 0; 1158 i = 0;
1164 if (s->ac_pred) { 1159 if (s->ac_pred) {
1165 if (s->h263_aic_dir) 1160 if (s->h263_aic_dir)
1166 scan_table = ff_alternate_vertical_scan; /* left */ 1161 scan_table = ff_alternate_vertical_scan; /* left */
1192 i = 1; 1187 i = 1;
1193 } else { 1188 } else {
1194 i = 0; 1189 i = 0;
1195 } 1190 }
1196 if (!coded) { 1191 if (!coded) {
1197 if (s->mb_intra && s->h263_aic) { 1192 if (s->mb_intra && s->h263_aic)
1198 level = h263_pred_dc(s, n, &dc_val); 1193 goto not_coded;
1199 if (level < 0)
1200 level = 0;
1201 *dc_val = level * s->y_dc_scale;
1202 block[0] = level;
1203 h263_pred_ac(s, block, n);
1204 i = 64;
1205 //i = 1;
1206 }
1207 s->block_last_index[n] = i - 1; 1194 s->block_last_index[n] = i - 1;
1208 return 0; 1195 return 0;
1209 } 1196 }
1210 1197
1211 for(;;) { 1198 for(;;) {
1227 level = rl->table_level[code]; 1214 level = rl->table_level[code];
1228 last = code >= rl->last; 1215 last = code >= rl->last;
1229 if (get_bits1(&s->gb)) 1216 if (get_bits1(&s->gb))
1230 level = -level; 1217 level = -level;
1231 } 1218 }
1232 if (!i && s->h263_aic) {
1233 level += h263_pred_dc(s, n, &dc_val);
1234 if (level < 0)
1235 level = 0;
1236 else if (level & 1)
1237 level++;
1238 *dc_val = level * s->y_dc_scale;
1239
1240 }
1241 i += run; 1219 i += run;
1242 if (i >= 64) 1220 if (i >= 64)
1243 return -1; 1221 return -1;
1244 j = scan_table[i]; 1222 j = scan_table[i];
1245 block[j] = level; 1223 block[j] = level;
1246 if (last) 1224 if (last)
1247 break; 1225 break;
1248 i++; 1226 i++;
1249 } 1227 }
1250 1228 not_coded:
1251 if (s->h263_aic) { 1229 if (s->mb_intra && s->h263_aic) {
1252 h263_pred_ac(s, block, n); 1230 h263_pred_acdc(s, block, n);
1253 i = 64; 1231 i = 64;
1254 } 1232 }
1255 s->block_last_index[n] = i; 1233 s->block_last_index[n] = i;
1256 return 0; 1234 return 0;
1257 } 1235 }