Mercurial > libavcodec.hg
comparison svq3.c @ 1319:449f6e32b425 libavcodec
added support for B-frames and multiple slices
author | tmmm |
---|---|
date | Thu, 19 Jun 2003 01:44:44 +0000 |
parents | 26c44d2433c1 |
children | 2365b4dfc450 |
comparison
equal
deleted
inserted
replaced
1318:209abbb4c4f7 | 1319:449f6e32b425 |
---|---|
260 } | 260 } |
261 | 261 |
262 return 0; | 262 return 0; |
263 } | 263 } |
264 | 264 |
265 static inline void svq3_mc_dir_part (MpegEncContext *s, int x, int y, | 265 static inline void svq3_mc_dir_part (MpegEncContext *s, |
266 int width, int height, int mx, int my, int dxy, int thirdpel) { | 266 int x, int y, int width, int height, |
267 int mx, int my, int dxy, | |
268 int thirdpel, int dir, int avg) { | |
269 | |
270 const Picture *pic = (dir == 0) ? &s->last_picture : &s->next_picture; | |
267 uint8_t *src, *dest; | 271 uint8_t *src, *dest; |
268 int i, emu = 0; | 272 int i, emu = 0; |
269 int blocksize= 2 - (width>>3); //16->0, 8->1, 4->2 | 273 int blocksize= 2 - (width>>3); //16->0, 8->1, 4->2 |
270 | 274 |
271 mx += x; | 275 mx += x; |
282 my = clip (my, -16, (s->v_edge_pos - height + 15)); | 286 my = clip (my, -16, (s->v_edge_pos - height + 15)); |
283 } | 287 } |
284 | 288 |
285 /* form component predictions */ | 289 /* form component predictions */ |
286 dest = s->current_picture.data[0] + x + y*s->linesize; | 290 dest = s->current_picture.data[0] + x + y*s->linesize; |
287 src = s->last_picture.data[0] + mx + my*s->linesize; | 291 src = pic->data[0] + mx + my*s->linesize; |
288 | 292 |
289 if (emu) { | 293 if (emu) { |
290 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, (width + 1), (height + 1), | 294 ff_emulated_edge_mc (s, src, s->linesize, (width + 1), (height + 1), |
291 mx, my, s->h_edge_pos, s->v_edge_pos); | 295 mx, my, s->h_edge_pos, s->v_edge_pos); |
292 src = s->edge_emu_buffer; | 296 src = s->edge_emu_buffer; |
293 } | 297 } |
294 if(thirdpel) | 298 if(thirdpel) |
295 s->dsp.put_tpel_pixels_tab[dxy](dest, src, s->linesize, width, height); | 299 (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->linesize, width, height); |
296 else | 300 else |
297 s->dsp.put_pixels_tab[blocksize][dxy](dest, src, s->linesize, height); | 301 (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->linesize, height); |
298 | 302 |
299 if (!(s->flags & CODEC_FLAG_GRAY)) { | 303 if (!(s->flags & CODEC_FLAG_GRAY)) { |
300 mx = (mx + (mx < (int) x)) >> 1; | 304 mx = (mx + (mx < (int) x)) >> 1; |
301 my = (my + (my < (int) y)) >> 1; | 305 my = (my + (my < (int) y)) >> 1; |
302 width = (width >> 1); | 306 width = (width >> 1); |
303 height = (height >> 1); | 307 height = (height >> 1); |
304 blocksize++; | 308 blocksize++; |
305 | 309 |
306 for (i=1; i < 3; i++) { | 310 for (i=1; i < 3; i++) { |
307 dest = s->current_picture.data[i] + (x >> 1) + (y >> 1)*s->uvlinesize; | 311 dest = s->current_picture.data[i] + (x >> 1) + (y >> 1)*s->uvlinesize; |
308 src = s->last_picture.data[i] + mx + my*s->uvlinesize; | 312 src = pic->data[i] + mx + my*s->uvlinesize; |
309 | 313 |
310 if (emu) { | 314 if (emu) { |
311 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->uvlinesize, (width + 1), (height + 1), | 315 ff_emulated_edge_mc (s, src, s->uvlinesize, (width + 1), (height + 1), |
312 mx, my, (s->h_edge_pos >> 1), (s->v_edge_pos >> 1)); | 316 mx, my, (s->h_edge_pos >> 1), (s->v_edge_pos >> 1)); |
313 src = s->edge_emu_buffer; | 317 src = s->edge_emu_buffer; |
314 } | 318 } |
315 if(thirdpel) | 319 if(thirdpel) |
316 s->dsp.put_tpel_pixels_tab[dxy](dest, src, s->uvlinesize, width, height); | 320 (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->uvlinesize, width, height); |
317 else | 321 else |
318 s->dsp.put_pixels_tab[blocksize][dxy](dest, src, s->uvlinesize, height); | 322 (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->uvlinesize, height); |
319 } | 323 } |
320 } | 324 } |
321 } | 325 } |
322 | 326 |
323 static int svq3_decode_mb (H264Context *h, unsigned int mb_type) { | 327 static int svq3_decode_mb (H264Context *h, unsigned int mb_type) { |
332 h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF; | 336 h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF; |
333 h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF; | 337 h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF; |
334 h->topright_samples_available = 0xFFFF; | 338 h->topright_samples_available = 0xFFFF; |
335 | 339 |
336 if (mb_type == 0) { /* SKIP */ | 340 if (mb_type == 0) { /* SKIP */ |
337 svq3_mc_dir_part (s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0); | 341 if (s->pict_type == P_TYPE) { |
338 | 342 svq3_mc_dir_part (s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 0, 0); |
339 cbp = 0; | 343 |
340 mb_type = MB_TYPE_SKIP; | 344 cbp = 0; |
345 mb_type = MB_TYPE_SKIP; | |
346 } else { | |
347 for (dir=0; dir < 2; dir++) { | |
348 for (i=0; i < 4; i++) { | |
349 for (j=0; j < 4; j++) { | |
350 int dxy; | |
351 x = 16*s->mb_x + 4*j; | |
352 y = 16*s->mb_y + 4*i; | |
353 | |
354 mx = 2*s->next_picture.motion_val[0][b_xy + j + i*h->b_stride][0]; | |
355 my = 2*s->next_picture.motion_val[0][b_xy + j + i*h->b_stride][1]; | |
356 | |
357 if (dir == 0) { | |
358 mx = (mx * h->frame_num_offset) / h->prev_frame_num_offset; | |
359 my = (my * h->frame_num_offset) / h->prev_frame_num_offset; | |
360 } else { | |
361 mx = (mx * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset; | |
362 my = (my * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset; | |
363 } | |
364 | |
365 mx = ((unsigned)(mx + 3 + 0x6000))/6 - 0x1000; | |
366 my = ((unsigned)(my + 3 + 0x6000))/6 - 0x1000; | |
367 dxy= (mx&1) + 2*(my&1); | |
368 | |
369 /* update mv_cache */ | |
370 s->current_picture.motion_val[dir][b_xy + j + i*h->b_stride][0] = 3*mx; | |
371 s->current_picture.motion_val[dir][b_xy + j + i*h->b_stride][1] = 3*my; | |
372 | |
373 svq3_mc_dir_part (s, x, y, 4, 4, mx>>1, my>>1, dxy, 0, dir, (dir == 1)); | |
374 } | |
375 } | |
376 } | |
377 | |
378 if ((vlc = svq3_get_ue_golomb (&s->gb)) >= 48) | |
379 return -1; | |
380 | |
381 cbp = golomb_to_inter_cbp[vlc]; | |
382 mb_type = MB_TYPE_16x16; | |
383 } | |
341 } else if (mb_type < 8) { /* INTER */ | 384 } else if (mb_type < 8) { /* INTER */ |
385 int dir0, dir1; | |
386 | |
342 if (h->thirdpel_flag && h->halfpel_flag == !get_bits (&s->gb, 1)) { | 387 if (h->thirdpel_flag && h->halfpel_flag == !get_bits (&s->gb, 1)) { |
343 mode = THIRDPEL_MODE; | 388 mode = THIRDPEL_MODE; |
344 } else if (h->halfpel_flag && h->thirdpel_flag == !get_bits (&s->gb, 1)) { | 389 } else if (h->halfpel_flag && h->thirdpel_flag == !get_bits (&s->gb, 1)) { |
345 mode = HALFPEL_MODE; | 390 mode = HALFPEL_MODE; |
346 } else { | 391 } else { |
347 mode = FULLPEL_MODE; | 392 mode = FULLPEL_MODE; |
348 } | 393 } |
349 | 394 |
350 /* fill caches */ | 395 /* fill caches */ |
351 /* note ref_cache[0] should contain here: | 396 /* note ref_cache should contain here: |
352 ???????? | 397 ???????? |
353 ???11111 | 398 ???11111 |
354 N??11111 | 399 N??11111 |
355 N??11111 | 400 N??11111 |
356 N??11111 | 401 N??11111 |
357 N | 402 N |
358 */ | 403 */ |
359 | 404 |
360 if (s->mb_x > 0) { | 405 for (m=0; m < 2; m++) { |
361 for (i=0; i < 4; i++) { | 406 if (s->mb_x > 0 && h->intra4x4_pred_mode[mb_xy - 1][0] != -1) { |
362 *(uint32_t *) h->mv_cache[0][scan8[0] - 1 + i*8] = *(uint32_t *) s->current_picture.motion_val[0][b_xy - 1 + i*h->b_stride]; | 407 for (i=0; i < 4; i++) { |
363 } | 408 *(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]; |
364 } else { | 409 } |
365 for (i=0; i < 4; i++) { | 410 } else { |
366 *(uint32_t *) h->mv_cache[0][scan8[0] - 1 + i*8] = 0; | 411 for (i=0; i < 4; i++) { |
367 } | 412 *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = 0; |
368 } | 413 } |
369 if (s->mb_y > 0) { | 414 } |
370 memcpy (h->mv_cache[0][scan8[0] - 1*8], s->current_picture.motion_val[0][b_xy - h->b_stride], 4*2*sizeof(int16_t)); | 415 if (s->mb_y > 0) { |
371 memset (&h->ref_cache[0][scan8[0] - 1*8], 1, 4); | 416 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)); |
372 | 417 memset (&h->ref_cache[m][scan8[0] - 1*8], (h->intra4x4_pred_mode[mb_xy - s->mb_stride][4] == -1) ? PART_NOT_AVAILABLE : 1, 4); |
373 if (s->mb_x < (s->mb_width - 1)) { | 418 |
374 *(uint32_t *) h->mv_cache[0][scan8[0] + 4 - 1*8] = *(uint32_t *) s->current_picture.motion_val[0][b_xy - h->b_stride + 4]; | 419 if (s->mb_x < (s->mb_width - 1)) { |
375 h->ref_cache[0][scan8[0] + 4 - 1*8] = 1; | 420 *(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]; |
421 h->ref_cache[m][scan8[0] + 4 - 1*8] = | |
422 (h->intra4x4_pred_mode[mb_xy - s->mb_stride + 1][0] == -1 || | |
423 h->intra4x4_pred_mode[mb_xy - s->mb_stride][4] == -1) ? PART_NOT_AVAILABLE : 1; | |
424 }else | |
425 h->ref_cache[m][scan8[0] + 4 - 1*8] = PART_NOT_AVAILABLE; | |
426 if (s->mb_x > 0) { | |
427 *(uint32_t *) h->mv_cache[0][scan8[0] - 1 - 1*8] = *(uint32_t *) s->current_picture.motion_val[m][b_xy - h->b_stride - 1]; | |
428 h->ref_cache[m][scan8[0] - 1 - 1*8] = (h->intra4x4_pred_mode[mb_xy - s->mb_stride - 1][3] == -1) ? PART_NOT_AVAILABLE : 1; | |
429 }else | |
430 h->ref_cache[m][scan8[0] - 1 - 1*8] = PART_NOT_AVAILABLE; | |
376 }else | 431 }else |
377 h->ref_cache[0][scan8[0] + 4 - 1*8] = PART_NOT_AVAILABLE; | 432 memset (&h->ref_cache[m][scan8[0] - 1*8 - 1], PART_NOT_AVAILABLE, 8); |
378 if (s->mb_x > 0) { | 433 |
379 *(uint32_t *) h->mv_cache[0][scan8[0] - 1 - 1*8] = *(uint32_t *) s->current_picture.motion_val[0][b_xy - h->b_stride - 1]; | 434 if (s->pict_type != B_TYPE) |
380 h->ref_cache[0][scan8[0] - 1 - 1*8] = 1; | 435 break; |
381 }else | 436 } |
382 h->ref_cache[0][scan8[0] - 1 - 1*8] = PART_NOT_AVAILABLE; | |
383 }else | |
384 memset (&h->ref_cache[0][scan8[0] - 1*8 - 1], PART_NOT_AVAILABLE, 8); | |
385 | 437 |
386 /* decode motion vector(s) and form prediction(s) */ | 438 /* decode motion vector(s) and form prediction(s) */ |
387 part_width = ((mb_type & 5) == 5) ? 4 : 8 << (mb_type & 1); | 439 if (s->pict_type == P_TYPE) { |
388 part_height = 16 >> ((unsigned) mb_type / 3); | 440 part_width = ((mb_type & 5) == 5) ? 4 : 8 << (mb_type & 1); |
389 | 441 part_height = 16 >> ((unsigned) mb_type / 3); |
442 dir0 = 0; | |
443 dir1 = 0; | |
444 } else { /* B_TYPE */ | |
445 part_width = 16; | |
446 part_height = 16; | |
447 dir0 = (mb_type == 2) ? 1 : 0; | |
448 dir1 = (mb_type == 1) ? 0 : 1; | |
449 } | |
450 | |
451 for (dir=dir0; dir <= dir1; dir++) { | |
390 for (i=0; i < 16; i+=part_height) { | 452 for (i=0; i < 16; i+=part_height) { |
391 for (j=0; j < 16; j+=part_width) { | 453 for (j=0; j < 16; j+=part_width) { |
392 int dxy; | 454 int avg=(dir == 1 && dir0 != dir1); |
455 int dxy; | |
393 x = 16*s->mb_x + j; | 456 x = 16*s->mb_x + j; |
394 y = 16*s->mb_y + i; | 457 y = 16*s->mb_y + i; |
395 k = ((j>>2)&1) + ((i>>1)&2) + ((j>>1)&4) + (i&8); | 458 k = ((j>>2)&1) + ((i>>1)&2) + ((j>>1)&4) + (i&8); |
396 | 459 |
397 pred_motion (h, k, (part_width >> 2), 0, 1, &mx, &my); | 460 pred_motion (h, k, (part_width >> 2), dir, 1, &mx, &my); |
398 | 461 |
399 /* clip motion vector prediction to frame border */ | 462 /* clip motion vector prediction to frame border */ |
400 mx = clip (mx, -6*x, 6*(s->h_edge_pos - part_width - x)); | 463 mx = clip (mx, -6*x, 6*(s->h_edge_pos - part_width - x)); |
401 my = clip (my, -6*y, 6*(s->v_edge_pos - part_height - y)); | 464 my = clip (my, -6*y, 6*(s->v_edge_pos - part_height - y)); |
402 | 465 |
414 my = ((my + 1)>>1) + dy; | 477 my = ((my + 1)>>1) + dy; |
415 fx= ((unsigned)(mx + 0x3000))/3 - 0x1000; | 478 fx= ((unsigned)(mx + 0x3000))/3 - 0x1000; |
416 fy= ((unsigned)(my + 0x3000))/3 - 0x1000; | 479 fy= ((unsigned)(my + 0x3000))/3 - 0x1000; |
417 dxy= (mx - 3*fx) + 4*(my - 3*fy); | 480 dxy= (mx - 3*fx) + 4*(my - 3*fy); |
418 | 481 |
419 svq3_mc_dir_part (s, x, y, part_width, part_height, fx, fy, dxy, 1); | 482 svq3_mc_dir_part (s, x, y, part_width, part_height, fx, fy, dxy, 1, dir, avg); |
420 mx += mx; | 483 mx += mx; |
421 my += my; | 484 my += my; |
422 } else if (mode == HALFPEL_MODE) { | 485 } else if (mode == HALFPEL_MODE) { |
423 mx = ((unsigned)(mx + 1 + 0x3000))/3 + dx - 0x1000; | 486 mx = ((unsigned)(mx + 1 + 0x3000))/3 + dx - 0x1000; |
424 my = ((unsigned)(my + 1 + 0x3000))/3 + dy - 0x1000; | 487 my = ((unsigned)(my + 1 + 0x3000))/3 + dy - 0x1000; |
425 dxy= (mx&1) + 2*(my&1); | 488 dxy= (mx&1) + 2*(my&1); |
426 | 489 |
427 svq3_mc_dir_part (s, x, y, part_width, part_height, mx>>1, my>>1, dxy, 0); | 490 svq3_mc_dir_part (s, x, y, part_width, part_height, mx>>1, my>>1, dxy, 0, dir, avg); |
428 mx *= 3; | 491 mx *= 3; |
429 my *= 3; | 492 my *= 3; |
430 } else { | 493 } else { |
431 assert(mode == FULLPEL_MODE); | 494 assert(mode == FULLPEL_MODE); |
432 mx = ((unsigned)(mx + 3 + 0x6000))/6 + dx - 0x1000; | 495 mx = ((unsigned)(mx + 3 + 0x6000))/6 + dx - 0x1000; |
433 my = ((unsigned)(my + 3 + 0x6000))/6 + dy - 0x1000; | 496 my = ((unsigned)(my + 3 + 0x6000))/6 + dy - 0x1000; |
434 | 497 |
435 svq3_mc_dir_part (s, x, y, part_width, part_height, mx, my, 0, 0); | 498 svq3_mc_dir_part (s, x, y, part_width, part_height, mx, my, 0, 0, dir, avg); |
436 mx *= 6; | 499 mx *= 6; |
437 my *= 6; | 500 my *= 6; |
438 } | 501 } |
439 | 502 |
440 /* update mv_cache */ | 503 /* update mv_cache */ |
441 fill_rectangle(h->mv_cache[0][scan8[k]], part_width>>2, part_height>>2, 8, pack16to32(mx,my), 4); | 504 fill_rectangle(h->mv_cache[dir][scan8[k]], part_width>>2, part_height>>2, 8, pack16to32(mx,my), 4); |
442 } | 505 } |
443 } | 506 } |
444 | 507 } |
445 for (i=0; i < 4; i++) { | 508 |
446 memcpy (s->current_picture.motion_val[0][b_xy + i*h->b_stride], h->mv_cache[0][scan8[0] + 8*i], 4*2*sizeof(int16_t)); | 509 /* write back or clear motion vectors */ |
510 if (s->pict_type == P_TYPE || mb_type != 2) { | |
511 for (i=0; i < 4; i++) { | |
512 memcpy (s->current_picture.motion_val[0][b_xy + i*h->b_stride], h->mv_cache[0][scan8[0] + 8*i], 4*2*sizeof(int16_t)); | |
513 } | |
514 } else { | |
515 for (i=0; i < 4; i++) { | |
516 memset (s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t)); | |
517 } | |
518 } | |
519 if (s->pict_type == B_TYPE) { | |
520 if (mb_type != 1) { | |
521 for (i=0; i < 4; i++) { | |
522 memcpy (s->current_picture.motion_val[1][b_xy + i*h->b_stride], h->mv_cache[1][scan8[0] + 8*i], 4*2*sizeof(int16_t)); | |
523 } | |
524 } else { | |
525 for (i=0; i < 4; i++) { | |
526 memset (s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t)); | |
527 } | |
528 } | |
447 } | 529 } |
448 | 530 |
449 if ((vlc = svq3_get_ue_golomb (&s->gb)) >= 48) | 531 if ((vlc = svq3_get_ue_golomb (&s->gb)) >= 48) |
450 return -1; | 532 return -1; |
451 | 533 |
452 cbp = golomb_to_inter_cbp[vlc]; | 534 cbp = golomb_to_inter_cbp[vlc]; |
453 mb_type = MB_TYPE_16x16; | 535 mb_type = MB_TYPE_16x16; |
454 } else if (mb_type == 8) { /* INTRA4x4 */ | 536 } else if (mb_type == 8 || mb_type == 33) { /* INTRA4x4 */ |
455 memset (h->intra4x4_pred_mode_cache, -1, 8*5*sizeof(int8_t)); | 537 memset (h->intra4x4_pred_mode_cache, -1, 8*5*sizeof(int8_t)); |
456 | 538 |
457 if (s->mb_x > 0) { | 539 if (mb_type == 8) { |
540 if (s->mb_x > 0) { | |
541 for (i=0; i < 4; i++) { | |
542 h->intra4x4_pred_mode_cache[scan8[0] - 1 + i*8] = h->intra4x4_pred_mode[mb_xy - 1][i]; | |
543 } | |
544 if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1) { | |
545 h->left_samples_available = 0x5F5F; | |
546 } | |
547 } | |
548 if (s->mb_y > 0) { | |
549 h->intra4x4_pred_mode_cache[4+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][4]; | |
550 h->intra4x4_pred_mode_cache[5+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][5]; | |
551 h->intra4x4_pred_mode_cache[6+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][6]; | |
552 h->intra4x4_pred_mode_cache[7+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][3]; | |
553 | |
554 if (h->intra4x4_pred_mode_cache[4+8*0] == -1) { | |
555 h->top_samples_available = 0x33FF; | |
556 } | |
557 } | |
558 | |
559 /* decode prediction codes for luma blocks */ | |
560 for (i=0; i < 16; i+=2) { | |
561 vlc = svq3_get_ue_golomb (&s->gb); | |
562 | |
563 if (vlc >= 25) | |
564 return -1; | |
565 | |
566 left = &h->intra4x4_pred_mode_cache[scan8[i] - 1]; | |
567 top = &h->intra4x4_pred_mode_cache[scan8[i] - 8]; | |
568 | |
569 left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]]; | |
570 left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]]; | |
571 | |
572 if (left[1] == -1 || left[2] == -1) | |
573 return -1; | |
574 } | |
575 } else { | |
576 /* DC_128_PRED block type */ | |
458 for (i=0; i < 4; i++) { | 577 for (i=0; i < 4; i++) { |
459 h->intra4x4_pred_mode_cache[scan8[0] - 1 + i*8] = h->intra4x4_pred_mode[mb_xy - 1][i]; | 578 memset (&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_PRED, 4); |
460 } | 579 } |
461 } | |
462 if (s->mb_y > 0) { | |
463 h->intra4x4_pred_mode_cache[4+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][4]; | |
464 h->intra4x4_pred_mode_cache[5+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][5]; | |
465 h->intra4x4_pred_mode_cache[6+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][6]; | |
466 h->intra4x4_pred_mode_cache[7+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][3]; | |
467 } | |
468 | |
469 /* decode prediction codes for luma blocks */ | |
470 for (i=0; i < 16; i+=2) { | |
471 vlc = svq3_get_ue_golomb (&s->gb); | |
472 | |
473 if (vlc >= 25) | |
474 return -1; | |
475 | |
476 left = &h->intra4x4_pred_mode_cache[scan8[i] - 1]; | |
477 top = &h->intra4x4_pred_mode_cache[scan8[i] - 8]; | |
478 | |
479 left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]]; | |
480 left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]]; | |
481 | |
482 if (left[1] == -1 || left[2] == -1) | |
483 return -1; | |
484 } | 580 } |
485 | 581 |
486 write_back_intra_pred_mode (h); | 582 write_back_intra_pred_mode (h); |
487 check_intra4x4_pred_mode (h); | 583 |
584 if (mb_type == 8) { | |
585 check_intra4x4_pred_mode (h); | |
586 | |
587 h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF; | |
588 h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF; | |
589 } else { | |
590 for (i=0; i < 4; i++) { | |
591 memset (&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_128_PRED, 4); | |
592 } | |
593 | |
594 h->top_samples_available = 0x33FF; | |
595 h->left_samples_available = 0x5F5F; | |
596 } | |
488 | 597 |
489 if ((vlc = svq3_get_ue_golomb (&s->gb)) >= 48) | 598 if ((vlc = svq3_get_ue_golomb (&s->gb)) >= 48) |
490 return -1; | 599 return -1; |
491 | 600 |
492 cbp = golomb_to_intra4x4_cbp[vlc]; | 601 cbp = golomb_to_intra4x4_cbp[vlc]; |
504 | 613 |
505 if (!IS_INTER(mb_type) && s->pict_type != I_TYPE) { | 614 if (!IS_INTER(mb_type) && s->pict_type != I_TYPE) { |
506 for (i=0; i < 4; i++) { | 615 for (i=0; i < 4; i++) { |
507 memset (s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t)); | 616 memset (s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t)); |
508 } | 617 } |
618 if (s->pict_type == B_TYPE) { | |
619 for (i=0; i < 4; i++) { | |
620 memset (s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t)); | |
621 } | |
622 } | |
509 } | 623 } |
510 if (!IS_INTRA4x4(mb_type)) { | 624 if (!IS_INTRA4x4(mb_type)) { |
511 memset (h->intra4x4_pred_mode[mb_xy], DC_PRED, 8); | 625 memset (h->intra4x4_pred_mode[mb_xy], DC_PRED, 8); |
512 } | 626 } |
513 if (!IS_SKIP(mb_type)) { | 627 if (!IS_SKIP(mb_type)) { |
566 } | 680 } |
567 | 681 |
568 return 0; | 682 return 0; |
569 } | 683 } |
570 | 684 |
685 static int svq3_decode_slice_header (H264Context *h) { | |
686 MpegEncContext *const s = (MpegEncContext *) h; | |
687 const int mb_xy = s->mb_x + s->mb_y*s->mb_stride; | |
688 int i, header; | |
689 | |
690 header = get_bits (&s->gb, 8); | |
691 | |
692 if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) { | |
693 /* TODO: what? */ | |
694 fprintf (stderr, "unsupported slice header (%02X)\n", header); | |
695 return -1; | |
696 } else { | |
697 int length = (header >> 5) & 3; | |
698 | |
699 h->next_slice_index = s->gb.index + 8*show_bits (&s->gb, 8*length) + 8*length; | |
700 | |
701 if (h->next_slice_index > s->gb.size_in_bits) | |
702 return -1; | |
703 | |
704 s->gb.size_in_bits = h->next_slice_index - 8*(length - 1); | |
705 s->gb.index += 8; | |
706 | |
707 if (length > 0) { | |
708 memcpy ((uint8_t *) &s->gb.buffer[s->gb.index >> 3], | |
709 &s->gb.buffer[s->gb.size_in_bits >> 3], (length - 1)); | |
710 } | |
711 } | |
712 | |
713 if ((i = svq3_get_ue_golomb (&s->gb)) == INVALID_VLC || i >= 3) | |
714 return -1; | |
715 | |
716 h->slice_type = golomb_to_pict_type[i]; | |
717 | |
718 if ((header & 0x9F) == 2) { | |
719 i = (s->mb_num < 64) ? 6 : (1 + av_log2 (s->mb_num - 1)); | |
720 s->mb_skip_run = get_bits (&s->gb, i) - (s->mb_x + (s->mb_y * s->mb_width)); | |
721 } else { | |
722 get_bits1 (&s->gb); | |
723 s->mb_skip_run = 0; | |
724 } | |
725 | |
726 h->slice_num = get_bits (&s->gb, 8); | |
727 s->qscale = get_bits (&s->gb, 5); | |
728 s->adaptive_quant = get_bits1 (&s->gb); | |
729 | |
730 /* unknown fields */ | |
731 get_bits1 (&s->gb); | |
732 | |
733 if (h->unknown_svq3_flag) { | |
734 get_bits1 (&s->gb); | |
735 } | |
736 | |
737 get_bits1 (&s->gb); | |
738 get_bits (&s->gb, 2); | |
739 | |
740 while (get_bits1 (&s->gb)) { | |
741 get_bits (&s->gb, 8); | |
742 } | |
743 | |
744 /* reset intra predictors and invalidate motion vector references */ | |
745 if (s->mb_x > 0) { | |
746 memset (h->intra4x4_pred_mode[mb_xy - 1], -1, 4*sizeof(int8_t)); | |
747 memset (h->intra4x4_pred_mode[mb_xy - s->mb_x], -1, 8*sizeof(int8_t)*s->mb_x); | |
748 } | |
749 if (s->mb_y > 0) { | |
750 memset (h->intra4x4_pred_mode[mb_xy - s->mb_stride], -1, 8*sizeof(int8_t)*(s->mb_width - s->mb_x)); | |
751 | |
752 if (s->mb_x > 0) { | |
753 h->intra4x4_pred_mode[mb_xy - s->mb_stride - 1][3] = -1; | |
754 } | |
755 } | |
756 | |
757 return 0; | |
758 } | |
759 | |
571 static int svq3_decode_frame (AVCodecContext *avctx, | 760 static int svq3_decode_frame (AVCodecContext *avctx, |
572 void *data, int *data_size, | 761 void *data, int *data_size, |
573 uint8_t *buf, int buf_size) { | 762 uint8_t *buf, int buf_size) { |
574 MpegEncContext *const s = avctx->priv_data; | 763 MpegEncContext *const s = avctx->priv_data; |
575 H264Context *const h = avctx->priv_data; | 764 H264Context *const h = avctx->priv_data; |
576 int i; | 765 int m, mb_type; |
766 | |
767 *data_size = 0; | |
577 | 768 |
578 s->flags = avctx->flags; | 769 s->flags = avctx->flags; |
579 | 770 |
580 if (!s->context_initialized) { | 771 if (!s->context_initialized) { |
581 s->width = avctx->width; | 772 s->width = avctx->width; |
582 s->height = avctx->height; | 773 s->height = avctx->height; |
583 h->pred4x4[DIAG_DOWN_LEFT_PRED] = pred4x4_down_left_svq3_c; | 774 h->pred4x4[DIAG_DOWN_LEFT_PRED] = pred4x4_down_left_svq3_c; |
584 h->pred16x16[PLANE_PRED8x8] = pred16x16_plane_svq3_c; | 775 h->pred16x16[PLANE_PRED8x8] = pred16x16_plane_svq3_c; |
585 h->halfpel_flag = 1; | 776 h->halfpel_flag = 1; |
586 h->thirdpel_flag = 1; | 777 h->thirdpel_flag = 1; |
778 h->unknown_svq3_flag = 0; | |
587 h->chroma_qp = 4; | 779 h->chroma_qp = 4; |
588 | 780 |
589 if (MPV_common_init (s) < 0) | 781 if (MPV_common_init (s) < 0) |
590 return -1; | 782 return -1; |
591 | 783 |
592 h->b_stride = 4*s->mb_width; | 784 h->b_stride = 4*s->mb_width; |
593 | 785 |
594 alloc_tables (h); | 786 alloc_tables (h); |
595 } | 787 |
596 | 788 if (avctx->extradata && avctx->extradata_size >= 0x64 |
597 s->low_delay= 1; | 789 && !memcmp (avctx->extradata, "SVQ3", 4)) { |
598 | 790 |
599 if (avctx->extradata && avctx->extradata_size >= 0x63 | 791 GetBitContext gb; |
600 && !memcmp (avctx->extradata, "SVQ3", 4)) { | 792 |
601 | 793 init_get_bits (&gb, (uint8_t *) avctx->extradata + 0x62, |
602 uint8_t *stsd = (uint8_t *) avctx->extradata + 0x62; | 794 8*(avctx->extradata_size - 0x62)); |
603 | 795 |
604 if ((*stsd >> 5) != 7 || avctx->extradata_size >= 0x66) { | 796 /* 'frame size code' and optional 'width, height' */ |
605 | 797 if (get_bits (&gb, 3) == 7) { |
606 if ((*stsd >> 5) == 7) { | 798 get_bits (&gb, 12); |
607 stsd += 3; /* skip width, height (12 bits each) */ | 799 get_bits (&gb, 12); |
608 } | 800 } |
609 | 801 |
610 h->halfpel_flag = (*stsd >> 4) & 1; | 802 h->halfpel_flag = get_bits1 (&gb); |
611 h->thirdpel_flag = (*stsd >> 3) & 1; | 803 h->thirdpel_flag = get_bits1 (&gb); |
612 } | 804 |
613 } | 805 /* unknown fields */ |
614 | 806 get_bits1 (&gb); |
615 if ((buf[0] & 0x9F) != 1) { | 807 get_bits1 (&gb); |
616 /* TODO: what? */ | 808 get_bits1 (&gb); |
617 fprintf (stderr, "unsupported header (%02X)\n", buf[0]); | 809 get_bits1 (&gb); |
810 | |
811 s->low_delay = get_bits1 (&gb); | |
812 | |
813 /* unknown field */ | |
814 get_bits1 (&gb); | |
815 | |
816 while (get_bits1 (&gb)) { | |
817 get_bits (&gb, 8); | |
818 } | |
819 | |
820 h->unknown_svq3_flag = get_bits1 (&gb); | |
821 avctx->has_b_frames = !s->low_delay; | |
822 } | |
823 } | |
824 | |
825 /* special case for last picture */ | |
826 if (buf_size == 0) { | |
827 if (s->next_picture_ptr && !s->low_delay) { | |
828 *(AVFrame *) data = *(AVFrame *) &s->next_picture; | |
829 *data_size = sizeof(AVFrame); | |
830 } | |
831 return 0; | |
832 } | |
833 | |
834 init_get_bits (&s->gb, buf, 8*buf_size); | |
835 | |
836 s->mb_x = s->mb_y = 0; | |
837 | |
838 if (svq3_decode_slice_header (h)) | |
618 return -1; | 839 return -1; |
619 } else { | 840 |
620 int length = (buf[0] >> 5) & 3; | 841 s->pict_type = h->slice_type; |
621 int offset = 0; | 842 s->picture_number = h->slice_num; |
622 | 843 |
623 for (i=0; i < length; i++) { | |
624 offset = (offset << 8) | buf[i + 1]; | |
625 } | |
626 | |
627 if (buf_size < (offset + length + 1) || length == 0) | |
628 return -1; | |
629 | |
630 memcpy (&buf[2], &buf[offset + 2], (length - 1)); | |
631 } | |
632 | |
633 init_get_bits (&s->gb, &buf[2], 8*(buf_size - 2)); | |
634 | |
635 if ((i = svq3_get_ue_golomb (&s->gb)) == INVALID_VLC || i >= 3) | |
636 return -1; | |
637 | |
638 s->pict_type = golomb_to_pict_type[i]; | |
639 | |
640 /* unknown fields */ | |
641 get_bits (&s->gb, 1); | |
642 get_bits (&s->gb, 8); | |
643 | |
644 s->qscale = get_bits (&s->gb, 5); | |
645 s->adaptive_quant = get_bits (&s->gb, 1); | |
646 | |
647 /* unknown fields */ | |
648 get_bits (&s->gb, 1); | |
649 get_bits (&s->gb, 1); | |
650 get_bits (&s->gb, 2); | |
651 | |
652 while (get_bits (&s->gb, 1)) { | |
653 get_bits (&s->gb, 8); | |
654 } | |
655 | |
656 if(avctx->debug&FF_DEBUG_PICT_INFO){ | 844 if(avctx->debug&FF_DEBUG_PICT_INFO){ |
657 printf("%c hpel:%d, tpel:%d aqp:%d qp:%d\n", | 845 printf("%c hpel:%d, tpel:%d aqp:%d qp:%d\n", |
658 av_get_pict_type_char(s->pict_type), h->halfpel_flag, h->thirdpel_flag, | 846 av_get_pict_type_char(s->pict_type), h->halfpel_flag, h->thirdpel_flag, |
659 s->adaptive_quant, s->qscale | 847 s->adaptive_quant, s->qscale |
660 ); | 848 ); |
661 } | 849 } |
662 | 850 |
663 /* B-frames are not supported */ | 851 /* for hurry_up==5 */ |
664 if (s->pict_type == B_TYPE/* && avctx->hurry_up*/) | 852 s->current_picture.pict_type = s->pict_type; |
665 return buf_size; | 853 s->current_picture.key_frame = (s->pict_type == I_TYPE); |
854 | |
855 /* skip b frames if we dont have reference frames */ | |
856 if (s->last_picture_ptr == NULL && s->pict_type == B_TYPE) return 0; | |
857 /* skip b frames if we are in a hurry */ | |
858 if (avctx->hurry_up && s->pict_type == B_TYPE) return 0; | |
859 /* skip everything if we are in a hurry >= 5 */ | |
860 if (avctx->hurry_up >= 5) return 0; | |
861 | |
862 if (s->next_p_frame_damaged) { | |
863 if (s->pict_type == B_TYPE) | |
864 return 0; | |
865 else | |
866 s->next_p_frame_damaged = 0; | |
867 } | |
666 | 868 |
667 frame_start (h); | 869 frame_start (h); |
668 | 870 |
669 for(i=0; i<4; i++){ | 871 if (s->pict_type == B_TYPE) { |
670 int j; | 872 h->frame_num_offset = (h->slice_num - h->prev_frame_num); |
671 for(j=-1; j<4; j++) | 873 |
672 h->ref_cache[0][scan8[0] + 8*i + j]= 1; | 874 if (h->frame_num_offset < 0) { |
673 h->ref_cache[0][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE; | 875 h->frame_num_offset += 256; |
876 } | |
877 if (h->frame_num_offset == 0 || h->frame_num_offset >= h->prev_frame_num_offset) { | |
878 printf ("error in B-frame picture id\n"); | |
879 return -1; | |
880 } | |
881 } else { | |
882 h->prev_frame_num = h->frame_num; | |
883 h->frame_num = h->slice_num; | |
884 h->prev_frame_num_offset = (h->frame_num - h->prev_frame_num); | |
885 | |
886 if (h->prev_frame_num_offset < 0) { | |
887 h->prev_frame_num_offset += 256; | |
888 } | |
889 } | |
890 | |
891 for(m=0; m<2; m++){ | |
892 int i; | |
893 for(i=0; i<4; i++){ | |
894 int j; | |
895 for(j=-1; j<4; j++) | |
896 h->ref_cache[m][scan8[0] + 8*i + j]= 1; | |
897 h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE; | |
898 } | |
674 } | 899 } |
675 | 900 |
676 for (s->mb_y=0; s->mb_y < s->mb_height; s->mb_y++) { | 901 for (s->mb_y=0; s->mb_y < s->mb_height; s->mb_y++) { |
677 for (s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) { | 902 for (s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) { |
678 int mb_type = svq3_get_ue_golomb (&s->gb); | 903 |
904 if ( (s->gb.index + 7) >= s->gb.size_in_bits && | |
905 ((s->gb.index & 7) == 0 || show_bits (&s->gb, (-s->gb.index & 7)) == 0)) { | |
906 | |
907 s->gb.index = h->next_slice_index; | |
908 s->gb.size_in_bits = 8*buf_size; | |
909 | |
910 if (svq3_decode_slice_header (h)) | |
911 return -1; | |
912 | |
913 /* TODO: support s->mb_skip_run */ | |
914 } | |
915 | |
916 mb_type = svq3_get_ue_golomb (&s->gb); | |
679 | 917 |
680 if (s->pict_type == I_TYPE) { | 918 if (s->pict_type == I_TYPE) { |
681 mb_type += 8; | 919 mb_type += 8; |
682 } | 920 } else if (s->pict_type == B_TYPE && mb_type >= 4) { |
683 if (mb_type > 32 || svq3_decode_mb (h, mb_type)) { | 921 mb_type += 4; |
922 } | |
923 if (mb_type > 33 || svq3_decode_mb (h, mb_type)) { | |
684 fprintf (stderr, "error while decoding MB %d %d\n", s->mb_x, s->mb_y); | 924 fprintf (stderr, "error while decoding MB %d %d\n", s->mb_x, s->mb_y); |
685 return -1; | 925 return -1; |
686 } | 926 } |
687 | 927 |
688 if (mb_type != 0) { | 928 if (mb_type != 0) { |
691 } | 931 } |
692 | 932 |
693 ff_draw_horiz_band(s, 16*s->mb_y, 16); | 933 ff_draw_horiz_band(s, 16*s->mb_y, 16); |
694 } | 934 } |
695 | 935 |
696 *(AVFrame *) data = *(AVFrame *) &s->current_picture; | |
697 *data_size = sizeof(AVFrame); | |
698 | |
699 MPV_frame_end(s); | 936 MPV_frame_end(s); |
700 | 937 |
938 if (s->pict_type == B_TYPE || s->low_delay) { | |
939 *(AVFrame *) data = *(AVFrame *) &s->current_picture; | |
940 } else { | |
941 *(AVFrame *) data = *(AVFrame *) &s->last_picture; | |
942 } | |
943 | |
944 avctx->frame_number = s->picture_number - 1; | |
945 | |
946 /* dont output the last pic after seeking */ | |
947 if (s->last_picture_ptr || s->low_delay) { | |
948 *data_size = sizeof(AVFrame); | |
949 } | |
950 | |
701 return buf_size; | 951 return buf_size; |
702 } | 952 } |
703 | 953 |
704 | 954 |
705 AVCodec svq3_decoder = { | 955 AVCodec svq3_decoder = { |