1/* 2 INTEL CONFIDENTIAL 3 Copyright 2009 Intel Corporation All Rights Reserved. 4 The source code contained or described herein and all documents related to the source code ("Material") are owned by Intel Corporation or its suppliers or licensors. Title to the Material remains with Intel Corporation or its suppliers and licensors. The Material contains trade secrets and proprietary and confidential information of Intel or its suppliers and licensors. The Material is protected by worldwide copyright and trade secret laws and treaty provisions. No part of the Material may be used, copied, reproduced, modified, published, uploaded, posted, transmitted, distributed, or disclosed in any way without Intel’s prior express written permission. 5 6 No license under any patent, copyright, trade secret or other intellectual property right is granted to or conferred upon you by disclosure or delivery of the Materials, either expressly, by implication, inducement, estoppel or otherwise. Any license under such intellectual property rights must be express and approved by Intel in writing. 7 */ 8 9 10#include <glib.h> 11#include <dlfcn.h> 12#include <string.h> 13 14#include "vc1.h" 15#include "vbp_loader.h" 16#include "vbp_utils.h" 17#include "vbp_vc1_parser.h" 18 19/* maximum number of Macroblock divided by 2, see va.h */ 20#define MAX_BITPLANE_SIZE 16384 21 22/* Start code prefix is 001 which is 3 bytes. */ 23#define PREFIX_SIZE 3 24 25static uint32 b_fraction_table[][9] = { 26 /* num 0 1 2 3 4 5 6 7 8 den */ 27 /* 0 */ { 0, 0, 0, 0, 0, 0, 0, 0, 0 }, 28 /* 1 */ { 0, 0, 0, 1, 3, 5, 9, 11, 17 }, 29 /* 2 */ { 0, 0, 0, 2, 0, 6, 0, 12, 0 }, 30 /* 3 */ { 0, 0, 0, 0, 4, 7, 0, 13, 18 }, 31 /* 4 */ { 0, 0, 0, 0, 0, 8, 0, 14, 0 }, 32 /* 5 */ { 0, 0, 0, 0, 0, 0, 10, 15, 19 }, 33 /* 6 */ { 0, 0, 0, 0, 0, 0, 0, 16, 0 }, 34 /* 7 */ { 0, 0, 0, 0, 0, 0, 0, 0, 20 } 35}; 36 37 38 39/** 40 * set parser entry points 41 */ 42uint32 vbp_init_parser_entries_vc1(vbp_context *pcontext) 43{ 44 if (NULL == pcontext->parser_ops) 45 { 46 /* impossible, just sanity check */ 47 return VBP_PARM; 48 } 49 50 pcontext->parser_ops->init = dlsym(pcontext->fd_parser, "viddec_vc1_init"); 51 if (NULL == pcontext->parser_ops->init) 52 { 53 ETRACE ("Failed to set entry point."); 54 return VBP_LOAD; 55 } 56 57 pcontext->parser_ops->parse_sc = viddec_parse_sc; 58 59 pcontext->parser_ops->parse_syntax = dlsym(pcontext->fd_parser, "viddec_vc1_parse"); 60 if (NULL == pcontext->parser_ops->parse_syntax) 61 { 62 ETRACE ("Failed to set entry point."); 63 return VBP_LOAD; 64 } 65 66 pcontext->parser_ops->get_cxt_size = dlsym(pcontext->fd_parser, "viddec_vc1_get_context_size"); 67 if (NULL == pcontext->parser_ops->get_cxt_size) 68 { 69 ETRACE ("Failed to set entry point."); 70 return VBP_LOAD; 71 } 72 73 pcontext->parser_ops->is_wkld_done = dlsym(pcontext->fd_parser, "viddec_vc1_wkld_done"); 74 if (NULL == pcontext->parser_ops->is_wkld_done) 75 { 76 ETRACE ("Failed to set entry point."); 77 return VBP_LOAD; 78 } 79 80 pcontext->parser_ops->is_frame_start = dlsym(pcontext->fd_parser, "viddec_vc1_is_start_frame"); 81 if (NULL == pcontext->parser_ops->is_frame_start) 82 { 83 ETRACE ("Failed to set entry point."); 84 return VBP_LOAD; 85 } 86 87 return VBP_OK; 88} 89 90/** 91 * allocate query data structure 92 */ 93uint32 vbp_allocate_query_data_vc1(vbp_context *pcontext) 94{ 95 if (NULL != pcontext->query_data) 96 { 97 /* impossible, just sanity check */ 98 return VBP_PARM; 99 } 100 101 pcontext->query_data = NULL; 102 103 vbp_data_vc1 *query_data = NULL; 104 query_data = g_try_new0(vbp_data_vc1, 1); 105 if (NULL == query_data) 106 { 107 return VBP_MEM; 108 } 109 110 /* assign the pointer */ 111 pcontext->query_data = (void *)query_data; 112 113 query_data->se_data = g_try_new0(vbp_codec_data_vc1, 1); 114 if (NULL == query_data->se_data) 115 { 116 goto cleanup; 117 } 118 query_data->pic_data = g_try_new0(vbp_picture_data_vc1, MAX_NUM_PICTURES); 119 if (NULL == query_data->pic_data) 120 { 121 goto cleanup; 122 } 123 124 int i; 125 for (i = 0; i < MAX_NUM_PICTURES; i++) 126 { 127 query_data->pic_data[i].pic_parms = g_try_new0(VAPictureParameterBufferVC1, 1); 128 if (NULL == query_data->pic_data[i].pic_parms) 129 { 130 goto cleanup; 131 } 132 133 query_data->pic_data[i].packed_bitplanes = g_try_malloc0(MAX_BITPLANE_SIZE); 134 if (NULL == query_data->pic_data[i].packed_bitplanes) 135 { 136 goto cleanup; 137 } 138 139 query_data->pic_data[i].slc_data = g_try_malloc0(MAX_NUM_SLICES * sizeof(vbp_slice_data_vc1)); 140 if (NULL == query_data->pic_data[i].slc_data) 141 { 142 goto cleanup; 143 } 144 } 145 146 return VBP_OK; 147 148cleanup: 149 vbp_free_query_data_vc1(pcontext); 150 151 return VBP_MEM; 152} 153 154 155/** 156 * free query data structure 157 */ 158uint32 vbp_free_query_data_vc1(vbp_context *pcontext) 159{ 160 vbp_data_vc1 *query_data = NULL; 161 162 if (NULL == pcontext->query_data) 163 { 164 return VBP_OK; 165 } 166 167 query_data = (vbp_data_vc1 *)pcontext->query_data; 168 169 if (query_data->pic_data) 170 { 171 int i = 0; 172 for (i = 0; i < MAX_NUM_PICTURES; i++) 173 { 174 g_free(query_data->pic_data[i].slc_data); 175 g_free(query_data->pic_data[i].packed_bitplanes); 176 g_free(query_data->pic_data[i].pic_parms); 177 } 178 } 179 180 g_free(query_data->pic_data); 181 182 g_free(query_data->se_data); 183 184 g_free(query_data); 185 186 pcontext->query_data = NULL; 187 188 return VBP_OK; 189} 190 191 192/** 193 * We want to create a list of buffer segments where each segment is a start 194 * code followed by all the data up to the next start code or to the end of 195 * the buffer. In VC-1, it is common to get buffers with no start codes. The 196 * parser proper, doesn't really handle the situation where there are no SCs. 197 * In this case, I will bypass the stripping of the SC code and assume a frame. 198 */ 199static uint32 vbp_parse_start_code_helper_vc1( 200 viddec_pm_cxt_t *cxt, 201 viddec_parser_ops_t *ops, 202 int init_data_flag) 203{ 204 uint32_t ret = VBP_OK; 205 viddec_sc_parse_cubby_cxt_t cubby; 206 207 /* make copy of cubby */ 208 /* this doesn't copy the buffer, merely the structure that holds the buffer */ 209 /* pointer. Below, where we call parse_sc() the code starts the search for */ 210 /* SCs at the beginning of the buffer pointed to by the cubby, so in our */ 211 /* cubby copy we increment the pointer as we move through the buffer. If */ 212 /* you think of each start code followed either by another start code or the */ 213 /* end of the buffer, then parse_sc() is returning information relative to */ 214 /* current segment. */ 215 216 cubby = cxt->parse_cubby; 217 218 cxt->list.num_items = 0; 219 cxt->list.data[0].stpos = 0; 220 cxt->getbits.is_emul_reqd = 1; 221 222 /* codec initialization data is always start code prefixed. (may not start at position 0) 223 * sample buffer for AP has three start code patterns here: 224 * pattern 0: no start code at all, the whole buffer is a single segment item 225 * pattern 1: start codes for all segment items 226 * pattern 2: no start code for the first segment item, start codes for the rest segment items 227 */ 228 229 gboolean is_pattern_two = FALSE; 230 231 unsigned char start_code = 0; 232 233 while(1) 234 { 235 /* parse the created buffer for sc */ 236 ret = ops->parse_sc((void *)&cubby, (void *)&(cxt->codec_data[0]), &(cxt->sc_prefix_info)); 237 if(ret == 1) 238 { 239 cubby.phase = 0; 240 start_code = *(unsigned char*)(cubby.buf + cubby.sc_end_pos); 241#if 1 242 if (0 == init_data_flag && 243 PREFIX_SIZE != cubby.sc_end_pos && 244 0 == cxt->list.num_items) 245 { 246 /* buffer does not have start code at the beginning */ 247 vc1_viddec_parser_t *parser = NULL; 248 vc1_metadata_t *seqLayerHeader = NULL; 249 250 parser = (vc1_viddec_parser_t *)cxt->codec_data; 251 seqLayerHeader = &(parser->info.metadata); 252 if (1 == seqLayerHeader->INTERLACE) 253 { 254 /* this is a hack for interlaced field coding */ 255 /* handle field interlace coding. One sample contains two fields, where: 256 * the first field does not have start code prefix, 257 * the second field has start code prefix. 258 */ 259 cxt->list.num_items = 1; 260 cxt->list.data[0].stpos = 0; 261 is_pattern_two = TRUE; 262 } 263 } 264#endif 265 if (cxt->list.num_items == 0) /* found first SC. */ 266 { 267 /* sc_end_pos gets us to the SC type. We need to back up to the first zero */ 268 cxt->list.data[0].stpos = cubby.sc_end_pos - PREFIX_SIZE; 269 } 270 else 271 { 272 /* First we set the end position of the last segment. */ 273 /* Since the SC parser searches from SC type to SC type and the */ 274 /* sc_end_pos is relative to this segment only, we merely add */ 275 /* sc_end_pos to the start to find the end. */ 276 cxt->list.data[cxt->list.num_items - 1].edpos = 277 cubby.sc_end_pos + cxt->list.data[cxt->list.num_items - 1].stpos; 278 279 /* Then we set the start position of the current segment. */ 280 /* So I need to subtract 1 ??? */ 281 cxt->list.data[cxt->list.num_items].stpos = 282 cxt->list.data[cxt->list.num_items - 1].edpos; 283 284 if (is_pattern_two) 285 { 286 cxt->list.data[cxt->list.num_items].stpos -= PREFIX_SIZE; 287 /* restore to normal pattern */ 288 is_pattern_two = FALSE; 289 } 290 } 291 /* We need to set up the cubby buffer for the next time through parse_sc(). */ 292 /* But even though we want the list to contain a segment as described */ 293 /* above, we want the cubby buffer to start just past the prefix, or it will */ 294 /* find the same SC again. So I bump the cubby buffer past the prefix. */ 295 cubby.buf = cubby.buf + 296 cxt->list.data[cxt->list.num_items].stpos + 297 PREFIX_SIZE; 298 299 cubby.size = cxt->parse_cubby.size - 300 cxt->list.data[cxt->list.num_items].stpos - 301 PREFIX_SIZE; 302 303 if (start_code >= 0x0A && start_code <= 0x0F) 304 { 305 /* only put known start code to the list 306 * 0x0A: end of sequence 307 * 0x0B: slice header 308 * 0x0C: frame header 309 * 0x0D: field header 310 * 0x0E: entry point header 311 * 0x0F: sequence header 312 */ 313 cxt->list.num_items++; 314 } 315 else 316 { 317 ITRACE("skipping unknown start code :%d", start_code); 318 } 319 320 if (cxt->list.num_items >= MAX_IBUFS_PER_SC) 321 { 322 WTRACE("Num items exceeds the limit!"); 323 /* not fatal, just stop parsing */ 324 break; 325 } 326 } 327 else 328 { 329 /* we get here, if we reach the end of the buffer while looking or a SC. */ 330 /* If we never found a SC, then num_items will never get incremented. */ 331 if (cxt->list.num_items == 0) 332 { 333 /* If we don't find a SC we probably still have a frame of data. */ 334 /* So let's bump the num_items or else later we will not parse the */ 335 /* frame. */ 336 cxt->list.num_items = 1; 337 } 338 /* now we can set the end position of the last segment. */ 339 cxt->list.data[cxt->list.num_items - 1].edpos = cxt->parse_cubby.size; 340 break; 341 } 342 } 343 return VBP_OK; 344} 345 346/* 347* parse initialization data (decoder configuration data) 348* for VC1 advanced profile, data is sequence header and 349* entry pointer header. 350* for VC1 main/simple profile, data format 351* is defined in VC1 spec: Annex J, (Decoder initialization metadata 352* structure 1 and structure 3 353*/ 354uint32 vbp_parse_init_data_vc1(vbp_context *pcontext) 355{ 356 /** 357 * init data (aka decoder configuration data) must 358 * be start-code prefixed 359 */ 360 361 viddec_pm_cxt_t *cxt = pcontext->parser_cxt; 362 viddec_parser_ops_t *ops = pcontext->parser_ops; 363 return vbp_parse_start_code_helper_vc1(cxt, ops, 1); 364} 365 366 367 368/** 369* Parse start codes, VC1 main/simple profile does not have start code; 370* VC1 advanced may not have start code either. 371*/ 372uint32_t vbp_parse_start_code_vc1(vbp_context *pcontext) 373{ 374 viddec_pm_cxt_t *cxt = pcontext->parser_cxt; 375 viddec_parser_ops_t *ops = pcontext->parser_ops; 376 377 vc1_viddec_parser_t *parser = NULL; 378 vc1_metadata_t *seqLayerHeader = NULL; 379 380 vbp_data_vc1 *query_data = (vbp_data_vc1 *) pcontext->query_data; 381 382 /* Reset query data for the new sample buffer */ 383 int i = 0; 384 for (i = 0; i < MAX_NUM_PICTURES; i++) 385 { 386 query_data->num_pictures = 0; 387 query_data->pic_data[i].num_slices = 0; 388 query_data->pic_data[i].picture_is_skipped = 0; 389 } 390 391 parser = (vc1_viddec_parser_t *)cxt->codec_data; 392 seqLayerHeader = &(parser->info.metadata); 393 394 395 /* WMV codec data will have a start code, but the WMV picture data won't. */ 396 if (VC1_PROFILE_ADVANCED == seqLayerHeader->PROFILE) 397 { 398 return vbp_parse_start_code_helper_vc1(cxt, ops, 0); 399 } 400 else 401 { 402 /* WMV: vc1 simple or main profile. No start code present. 403 */ 404 405 /* must set is_emul_reqd to 0! */ 406 cxt->getbits.is_emul_reqd = 0; 407 cxt->list.num_items = 1; 408 cxt->list.data[0].stpos = 0; 409 cxt->list.data[0].edpos = cxt->parse_cubby.size; 410 } 411 412 return VBP_OK; 413} 414 415 416/** 417 * 418 */ 419static inline uint8 vbp_get_bit_vc1(uint32 *data, uint32 *current_word, uint32 *current_bit) 420{ 421 uint8 value; 422 423 value = (data[*current_word] >> *current_bit) & 1; 424 425 /* Fix up bit/byte offsets. endianess?? */ 426 if (*current_bit < 31) 427 { 428 ++(*current_bit); 429 } 430 else 431 { 432 ++(*current_word); 433 *current_bit = 0; 434 } 435 436 return value; 437} 438 439 440/** 441 * 442 */ 443static uint32 vbp_pack_bitplane_vc1( 444 uint32 *from_plane, 445 uint8 *to_plane, 446 uint32 width, 447 uint32 height, 448 uint32 nibble_shift) 449{ 450 uint32 error = VBP_OK; 451 uint32 current_word = 0; 452 uint32 current_bit = 0; /* must agree with number in vbp_get_bit_vc1 */ 453 uint32 i, j, n; 454 uint8 value; 455 uint32 stride = 0; 456 457 stride = 32 * ((width + 31) / 32); 458 459 for (i = 0, n = 0; i < height; i++) 460 { 461 for (j = 0; j < stride; j++) 462 { 463 if (j < width) 464 { 465 value = vbp_get_bit_vc1( 466 from_plane, 467 ¤t_word, 468 ¤t_bit); 469 470 to_plane[n / 2] |= value << (nibble_shift + ((n % 2) ? 0 : 4)); 471 n++; 472 } 473 else 474 { 475 break; 476 } 477 } 478 if (stride > width) 479 { 480 current_word++; 481 current_bit = 0; 482 } 483 } 484 485 return error; 486} 487 488 489/** 490 * 491 */ 492static inline uint32 vbp_map_bfraction(uint32 numerator, uint32 denominator) 493{ 494 uint32 b_fraction = 0; 495 496 if ((numerator < 8) && (denominator < 9)) 497 { 498 b_fraction = b_fraction_table[numerator][denominator]; 499 } 500 501 return b_fraction; 502} 503 504/** 505 * 506 */ 507static uint32 vbp_pack_bitplanes_vc1( 508 vbp_context *pcontext, 509 int index, 510 vbp_picture_data_vc1* pic_data) 511{ 512 uint32 error = VBP_OK; 513 if (0 == pic_data->pic_parms->bitplane_present.value) 514 { 515 /* return if bitplane is not present */ 516 pic_data->size_bitplanes = 0; 517 memset(pic_data->packed_bitplanes, 0, MAX_BITPLANE_SIZE); 518 return error; 519 } 520 521 vc1_viddec_parser_t *parser = (vc1_viddec_parser_t *)pcontext->parser_cxt->codec_data; 522 vc1_metadata_t *seqLayerHeader = &(parser->info.metadata); 523 vc1_PictureLayerHeader *picLayerHeader = &(parser->info.picLayerHeader); 524 525 526 /* set bit plane size */ 527 pic_data->size_bitplanes = ((seqLayerHeader->widthMB * seqLayerHeader->heightMB) + 1) / 2; 528 529 530 memset(pic_data->packed_bitplanes, 0, pic_data->size_bitplanes); 531 532 /* see libva library va.h for nibble bit */ 533 switch (picLayerHeader->PTYPE) 534 { 535 case VC1_I_FRAME: 536 case VC1_BI_FRAME: 537 if (picLayerHeader->OVERFLAGS.imode) 538 { 539 vbp_pack_bitplane_vc1( 540 picLayerHeader->OVERFLAGS.databits, 541 pic_data->packed_bitplanes, 542 seqLayerHeader->widthMB, 543 seqLayerHeader->heightMB, 544 2); 545 } 546 if (picLayerHeader->ACPRED.imode) 547 { 548 vbp_pack_bitplane_vc1( 549 picLayerHeader->ACPRED.databits, 550 pic_data->packed_bitplanes, 551 seqLayerHeader->widthMB, 552 seqLayerHeader->heightMB, 553 1); 554 } 555 if (picLayerHeader->FIELDTX.imode) 556 { 557 vbp_pack_bitplane_vc1( 558 picLayerHeader->FIELDTX.databits, 559 pic_data->packed_bitplanes, 560 seqLayerHeader->widthMB, 561 seqLayerHeader->heightMB, 562 0); 563 } 564 /* sanity check */ 565 if (picLayerHeader->MVTYPEMB.imode || 566 picLayerHeader->DIRECTMB.imode || 567 picLayerHeader->SKIPMB.imode || 568 picLayerHeader->FORWARDMB.imode) 569 { 570 ETRACE("Unexpected bit-plane type."); 571 error = VBP_TYPE; 572 } 573 break; 574 575 case VC1_P_FRAME: 576 if (picLayerHeader->MVTYPEMB.imode) 577 { 578 vbp_pack_bitplane_vc1( 579 picLayerHeader->MVTYPEMB.databits, 580 pic_data->packed_bitplanes, 581 seqLayerHeader->widthMB, 582 seqLayerHeader->heightMB, 583 2); 584 } 585 if (picLayerHeader->SKIPMB.imode) 586 { 587 vbp_pack_bitplane_vc1( 588 picLayerHeader->SKIPMB.databits, 589 pic_data->packed_bitplanes, 590 seqLayerHeader->widthMB, 591 seqLayerHeader->heightMB, 592 1); 593 } 594 if (picLayerHeader->DIRECTMB.imode) 595 { 596 vbp_pack_bitplane_vc1( 597 picLayerHeader->DIRECTMB.databits, 598 pic_data->packed_bitplanes, 599 seqLayerHeader->widthMB, 600 seqLayerHeader->heightMB, 601 0); 602 } 603 /* sanity check */ 604 if (picLayerHeader->FIELDTX.imode || 605 picLayerHeader->FORWARDMB.imode || 606 picLayerHeader->ACPRED.imode || 607 picLayerHeader->OVERFLAGS.imode ) 608 { 609 ETRACE("Unexpected bit-plane type."); 610 error = VBP_TYPE; 611 } 612 break; 613 614 case VC1_B_FRAME: 615 if (picLayerHeader->FORWARDMB.imode) 616 { 617 vbp_pack_bitplane_vc1( 618 picLayerHeader->FORWARDMB.databits, 619 pic_data->packed_bitplanes, 620 seqLayerHeader->widthMB, 621 seqLayerHeader->heightMB, 622 2); 623 } 624 if (picLayerHeader->SKIPMB.imode) 625 { 626 vbp_pack_bitplane_vc1( 627 picLayerHeader->SKIPMB.databits, 628 pic_data->packed_bitplanes, 629 seqLayerHeader->widthMB, 630 seqLayerHeader->heightMB, 631 1); 632 } 633 if (picLayerHeader->DIRECTMB.imode) 634 { 635 vbp_pack_bitplane_vc1( 636 picLayerHeader->DIRECTMB.databits, 637 pic_data->packed_bitplanes, 638 seqLayerHeader->widthMB, 639 seqLayerHeader->heightMB, 640 0); 641 } 642 /* sanity check */ 643 if (picLayerHeader->MVTYPEMB.imode || 644 picLayerHeader->FIELDTX.imode || 645 picLayerHeader->ACPRED.imode || 646 picLayerHeader->OVERFLAGS.imode) 647 { 648 ETRACE("Unexpected bit-plane type."); 649 error = VBP_TYPE; 650 } 651 break; 652 } 653 return error; 654} 655 656 657/** 658 * fill the query data structure after sequence header, entry point header 659 * or a complete frame is parsed. 660 * NOTE: currently partial frame is not handled properly 661 */ 662uint32 vbp_populate_query_data_vc1(vbp_context *pcontext) 663{ 664 uint32 error = VBP_OK; 665 666 vc1_viddec_parser_t *parser = (vc1_viddec_parser_t *)pcontext->parser_cxt->codec_data; 667 vc1_metadata_t *seqLayerHeader = &(parser->info.metadata); 668 669 vbp_data_vc1 *query_data = (vbp_data_vc1 *)pcontext->query_data; 670 671 /* first we get the SH/EP data. Can we cut down on this? */ 672 vbp_codec_data_vc1 *se_data = query_data->se_data; 673 se_data->PROFILE = seqLayerHeader->PROFILE; 674 se_data->LEVEL = seqLayerHeader->LEVEL; 675 se_data->POSTPROCFLAG = seqLayerHeader->POSTPROCFLAG; 676 se_data->PULLDOWN = seqLayerHeader->PULLDOWN; 677 se_data->INTERLACE = seqLayerHeader->INTERLACE; 678 se_data->TFCNTRFLAG = seqLayerHeader->TFCNTRFLAG; 679 se_data->FINTERPFLAG = seqLayerHeader->FINTERPFLAG; 680 se_data->PSF = seqLayerHeader->PSF; 681 se_data->BROKEN_LINK = seqLayerHeader->BROKEN_LINK; 682 se_data->CLOSED_ENTRY = seqLayerHeader->CLOSED_ENTRY; 683 se_data->PANSCAN_FLAG = seqLayerHeader->PANSCAN_FLAG; 684 se_data->REFDIST_FLAG = seqLayerHeader->REFDIST_FLAG; 685 se_data->LOOPFILTER = seqLayerHeader->LOOPFILTER; 686 se_data->FASTUVMC = seqLayerHeader->FASTUVMC; 687 se_data->EXTENDED_MV = seqLayerHeader->EXTENDED_MV; 688 se_data->DQUANT = seqLayerHeader->DQUANT; 689 se_data->VSTRANSFORM = seqLayerHeader->VSTRANSFORM; 690 se_data->OVERLAP = seqLayerHeader->OVERLAP; 691 se_data->QUANTIZER = seqLayerHeader->QUANTIZER; 692 se_data->CODED_WIDTH = (seqLayerHeader->width + 1) << 1; 693 se_data->CODED_HEIGHT = (seqLayerHeader->height + 1) << 1; 694 se_data->EXTENDED_DMV = seqLayerHeader->EXTENDED_DMV; 695 se_data->RANGE_MAPY_FLAG = seqLayerHeader->RANGE_MAPY_FLAG; 696 se_data->RANGE_MAPY = seqLayerHeader->RANGE_MAPY; 697 se_data->RANGE_MAPUV_FLAG = seqLayerHeader->RANGE_MAPUV_FLAG; 698 se_data->RANGE_MAPUV = seqLayerHeader->RANGE_MAPUV; 699 se_data->RANGERED = seqLayerHeader->RANGERED; 700 se_data->MAXBFRAMES = seqLayerHeader->MAXBFRAMES; 701 se_data->MULTIRES = seqLayerHeader->MULTIRES; 702 se_data->SYNCMARKER = seqLayerHeader->SYNCMARKER; 703 se_data->RNDCTRL = seqLayerHeader->RNDCTRL; 704 se_data->REFDIST = seqLayerHeader->REFDIST; 705 se_data->widthMB = seqLayerHeader->widthMB; 706 se_data->heightMB = seqLayerHeader->heightMB; 707 se_data->INTCOMPFIELD = seqLayerHeader->INTCOMPFIELD; 708 se_data->LUMSCALE2 = seqLayerHeader->LUMSCALE2; 709 se_data->LUMSHIFT2 = seqLayerHeader->LUMSHIFT2; 710 711 /* update buffer number */ 712 query_data->buf_number = buffer_counter; 713 714 if (query_data->num_pictures > 2) 715 { 716 WTRACE("sampe buffer contains %d pictures", query_data->num_pictures); 717 } 718 return error; 719} 720 721 722 723static void vbp_pack_picture_params_vc1( 724 vbp_context *pcontext, 725 int index, 726 vbp_picture_data_vc1* pic_data) 727{ 728 viddec_pm_cxt_t *cxt = pcontext->parser_cxt; 729 vc1_viddec_parser_t *parser = (vc1_viddec_parser_t *)cxt->codec_data; 730 vc1_metadata_t *seqLayerHeader = &(parser->info.metadata); 731 vc1_PictureLayerHeader *picLayerHeader = &(parser->info.picLayerHeader); 732 733 734 VAPictureParameterBufferVC1 *pic_parms = pic_data->pic_parms; 735 736 /* Then we get the picture header data. Picture type need translation. */ 737 pic_parms->forward_reference_picture = VA_INVALID_SURFACE; 738 pic_parms->backward_reference_picture = VA_INVALID_SURFACE; 739 pic_parms->inloop_decoded_picture = VA_INVALID_SURFACE; 740 741 pic_parms->sequence_fields.value = 0; 742 pic_parms->sequence_fields.bits.interlace = seqLayerHeader->INTERLACE; 743 pic_parms->sequence_fields.bits.syncmarker = seqLayerHeader->SYNCMARKER; 744 pic_parms->sequence_fields.bits.overlap = seqLayerHeader->OVERLAP; 745 746 pic_parms->coded_width = (seqLayerHeader->width + 1) << 1; 747 pic_parms->coded_height = (seqLayerHeader->height + 1) << 1; 748 749 pic_parms->entrypoint_fields.value = 0; 750 pic_parms->entrypoint_fields.bits.closed_entry = seqLayerHeader->CLOSED_ENTRY; 751 pic_parms->entrypoint_fields.bits.broken_link = seqLayerHeader->BROKEN_LINK; 752 pic_parms->entrypoint_fields.bits.loopfilter = seqLayerHeader->LOOPFILTER; 753 754 pic_parms->conditional_overlap_flag = picLayerHeader->CONDOVER; 755 pic_parms->fast_uvmc_flag = seqLayerHeader->FASTUVMC; 756 757 pic_parms->range_mapping_fields.value = 0; 758 pic_parms->range_mapping_fields.bits.luma_flag = seqLayerHeader->RANGE_MAPY_FLAG; 759 pic_parms->range_mapping_fields.bits.luma = seqLayerHeader->RANGE_MAPY; 760 pic_parms->range_mapping_fields.bits.chroma_flag = seqLayerHeader->RANGE_MAPUV_FLAG; 761 pic_parms->range_mapping_fields.bits.chroma = seqLayerHeader->RANGE_MAPUV; 762 763 pic_parms->b_picture_fraction = 764 vbp_map_bfraction(picLayerHeader->BFRACTION_NUM, picLayerHeader->BFRACTION_DEN); 765 766 pic_parms->cbp_table = picLayerHeader->CBPTAB; 767 pic_parms->mb_mode_table = picLayerHeader->MBMODETAB; 768 pic_parms->range_reduction_frame = picLayerHeader->RANGEREDFRM; 769 pic_parms->rounding_control = picLayerHeader->RNDCTRL; 770 pic_parms->post_processing = picLayerHeader->POSTPROC; 771 /* fix this. Add RESPIC to parser. */ 772 pic_parms->picture_resolution_index = 0; 773 pic_parms->luma_scale = picLayerHeader->LUMSCALE; 774 pic_parms->luma_shift = picLayerHeader->LUMSHIFT; 775 776 pic_parms->picture_fields.value = 0; 777 switch (picLayerHeader->PTYPE) 778 { 779 case VC1_I_FRAME: 780 pic_parms->picture_fields.bits.picture_type = VC1_PTYPE_I; 781 break; 782 783 case VC1_P_FRAME: 784 pic_parms->picture_fields.bits.picture_type = VC1_PTYPE_P; 785 break; 786 787 case VC1_B_FRAME: 788 pic_parms->picture_fields.bits.picture_type = VC1_PTYPE_B; 789 break; 790 791 case VC1_BI_FRAME: 792 pic_parms->picture_fields.bits.picture_type = VC1_PTYPE_BI; 793 break; 794 795 case VC1_SKIPPED_FRAME: 796 pic_data->picture_is_skipped = VC1_PTYPE_SKIPPED; 797 break; 798 799 default: 800 /* to do: handle this case */ 801 break; 802 } 803 pic_parms->picture_fields.bits.frame_coding_mode = picLayerHeader->FCM; 804 if (0 == seqLayerHeader->PROFILE || 1 == seqLayerHeader->PROFILE) 805 { 806 /* simple or main profile, top field flag is not present, default to 1.*/ 807 pic_parms->picture_fields.bits.top_field_first = 1; 808 } 809 else 810 { 811 pic_parms->picture_fields.bits.top_field_first = picLayerHeader->TFF; 812 } 813 814 pic_parms->picture_fields.bits.is_first_field = !(picLayerHeader->CurrField); 815 /* This seems to be set based on the MVMODE and MVMODE2 syntax. */ 816 /* This is a hack. Probably will need refining. */ 817 if ((VC1_MVMODE_INTENSCOMP == picLayerHeader->MVMODE) || 818 (VC1_MVMODE_INTENSCOMP == picLayerHeader->MVMODE2)) 819 { 820 pic_parms->picture_fields.bits.intensity_compensation = 1; 821 } 822 else 823 { 824 pic_parms->picture_fields.bits.intensity_compensation = picLayerHeader->INTCOMP; 825 } 826 827 /* Lets store the raw-mode BP bits. */ 828 pic_parms->raw_coding.value = 0; 829 pic_parms->raw_coding.flags.mv_type_mb = picLayerHeader->raw_MVTYPEMB; 830 pic_parms->raw_coding.flags.direct_mb = picLayerHeader->raw_DIRECTMB; 831 pic_parms->raw_coding.flags.skip_mb = picLayerHeader->raw_SKIPMB; 832 pic_parms->raw_coding.flags.field_tx = picLayerHeader->raw_FIELDTX; 833 pic_parms->raw_coding.flags.forward_mb = picLayerHeader->raw_FORWARDMB; 834 pic_parms->raw_coding.flags.ac_pred = picLayerHeader->raw_ACPRED; 835 pic_parms->raw_coding.flags.overflags = picLayerHeader->raw_OVERFLAGS; 836 837 /* imode 1/0 indicates bitmap presence in Pic Hdr. */ 838 pic_parms->bitplane_present.value = 0; 839 840 pic_parms->bitplane_present.flags.bp_mv_type_mb = 841 pic_parms->raw_coding.flags.mv_type_mb ? 1 : 842 (picLayerHeader->MVTYPEMB.imode ? 1: 0); 843 844 pic_parms->bitplane_present.flags.bp_direct_mb = 845 pic_parms->raw_coding.flags.direct_mb ? 1 : 846 (picLayerHeader->DIRECTMB.imode ? 1: 0); 847 848 pic_parms->bitplane_present.flags.bp_skip_mb = 849 pic_parms->raw_coding.flags.skip_mb ? 1 : 850 (picLayerHeader->SKIPMB.imode ? 1: 0); 851 852 pic_parms->bitplane_present.flags.bp_field_tx = 853 pic_parms->raw_coding.flags.field_tx ? 1 : 854 (picLayerHeader->FIELDTX.imode ? 1: 0); 855 856 pic_parms->bitplane_present.flags.bp_forward_mb = 857 pic_parms->raw_coding.flags.forward_mb ? 1 : 858 (picLayerHeader->FORWARDMB.imode ? 1: 0); 859 860 pic_parms->bitplane_present.flags.bp_ac_pred = 861 pic_parms->raw_coding.flags.ac_pred ? 1 : 862 (picLayerHeader->ACPRED.imode ? 1: 0); 863 864 pic_parms->bitplane_present.flags.bp_overflags = 865 pic_parms->raw_coding.flags.overflags ? 1 : 866 (picLayerHeader->OVERFLAGS.imode ? 1: 0); 867 868 pic_parms->reference_fields.value = 0; 869 pic_parms->reference_fields.bits.reference_distance_flag = 870 seqLayerHeader->REFDIST_FLAG; 871 872 pic_parms->reference_fields.bits.reference_distance = 873 seqLayerHeader->REFDIST; 874 875 pic_parms->reference_fields.bits.num_reference_pictures = 876 picLayerHeader->NUMREF; 877 878 pic_parms->reference_fields.bits.reference_field_pic_indicator = 879 picLayerHeader->REFFIELD; 880 881 pic_parms->mv_fields.value = 0; 882 pic_parms->mv_fields.bits.mv_mode = picLayerHeader->MVMODE; 883 pic_parms->mv_fields.bits.mv_mode2 = picLayerHeader->MVMODE2; 884 885 pic_parms->mv_fields.bits.mv_table = picLayerHeader->MVTAB; 886 pic_parms->mv_fields.bits.two_mv_block_pattern_table = picLayerHeader->MV2BPTAB; 887 pic_parms->mv_fields.bits.four_mv_switch = picLayerHeader->MV4SWITCH; 888 pic_parms->mv_fields.bits.four_mv_block_pattern_table = picLayerHeader->MV4BPTAB; 889 pic_parms->mv_fields.bits.extended_mv_flag = seqLayerHeader->EXTENDED_MV; 890 pic_parms->mv_fields.bits.extended_mv_range = picLayerHeader->MVRANGE; 891 pic_parms->mv_fields.bits.extended_dmv_flag = seqLayerHeader->EXTENDED_DMV; 892 pic_parms->mv_fields.bits.extended_dmv_range = picLayerHeader->DMVRANGE; 893 894 pic_parms->pic_quantizer_fields.value = 0; 895 pic_parms->pic_quantizer_fields.bits.dquant = seqLayerHeader->DQUANT; 896 pic_parms->pic_quantizer_fields.bits.quantizer = seqLayerHeader->QUANTIZER; 897 pic_parms->pic_quantizer_fields.bits.half_qp = picLayerHeader->HALFQP; 898 pic_parms->pic_quantizer_fields.bits.pic_quantizer_scale = picLayerHeader->PQUANT; 899 pic_parms->pic_quantizer_fields.bits.pic_quantizer_type = picLayerHeader->UniformQuant; 900 pic_parms->pic_quantizer_fields.bits.dq_frame = picLayerHeader->DQUANTFRM; 901 pic_parms->pic_quantizer_fields.bits.dq_profile = picLayerHeader->DQPROFILE; 902 pic_parms->pic_quantizer_fields.bits.dq_sb_edge = picLayerHeader->DQSBEDGE; 903 pic_parms->pic_quantizer_fields.bits.dq_db_edge = picLayerHeader->DQDBEDGE; 904 pic_parms->pic_quantizer_fields.bits.dq_binary_level = picLayerHeader->DQBILEVEL; 905 pic_parms->pic_quantizer_fields.bits.alt_pic_quantizer = picLayerHeader->ALTPQUANT; 906 907 pic_parms->transform_fields.value = 0; 908 pic_parms->transform_fields.bits.variable_sized_transform_flag = 909 seqLayerHeader->VSTRANSFORM; 910 911 pic_parms->transform_fields.bits.mb_level_transform_type_flag = picLayerHeader->TTMBF; 912 pic_parms->transform_fields.bits.frame_level_transform_type = picLayerHeader->TTFRM; 913 914 pic_parms->transform_fields.bits.transform_ac_codingset_idx1 = 915 (picLayerHeader->TRANSACFRM > 0) ? picLayerHeader->TRANSACFRM - 1 : 0; 916 917 pic_parms->transform_fields.bits.transform_ac_codingset_idx2 = 918 (picLayerHeader->TRANSACFRM2 > 0) ? picLayerHeader->TRANSACFRM2 - 1 : 0; 919 920 pic_parms->transform_fields.bits.intra_transform_dc_table = picLayerHeader->TRANSDCTAB; 921} 922 923 924static void vbp_pack_slice_data_vc1( 925 vbp_context *pcontext, 926 int index, 927 vbp_picture_data_vc1* pic_data) 928{ 929 viddec_pm_cxt_t *cxt = pcontext->parser_cxt; 930 uint32 slice_size = cxt->list.data[index].edpos - cxt->list.data[index].stpos; 931 uint32 bit; 932 uint32 byte; 933 uint8 is_emul; 934 viddec_pm_get_au_pos(cxt, &bit, &byte, &is_emul); 935 936 vbp_slice_data_vc1 *slc_data = &(pic_data->slc_data[pic_data->num_slices]); 937 VASliceParameterBufferVC1 *slc_parms = &(slc_data->slc_parms); 938 939 /*uint32 data_offset = byte - cxt->list.data[index].stpos;*/ 940 941 slc_data->buffer_addr = cxt->parse_cubby.buf + cxt->list.data[index].stpos; 942 slc_data->slice_size = slice_size - byte; 943 slc_data->slice_offset = byte; 944 945 slc_parms->slice_data_size = slc_data->slice_size; 946 slc_parms->slice_data_offset = 0; 947 948 /* fix this. we need to be able to handle partial slices. */ 949 slc_parms->slice_data_flag = VA_SLICE_DATA_FLAG_ALL; 950 951 slc_parms->macroblock_offset = bit; 952 953 /* fix this. we need o get the slice_vertical_position from the code */ 954 slc_parms->slice_vertical_position = pic_data->num_slices; 955 956 pic_data->num_slices++; 957} 958 959/** 960 * process parsing result 961 */ 962uint32_t vbp_process_parsing_result_vc1(vbp_context *pcontext, int index) 963{ 964 viddec_pm_cxt_t *cxt = pcontext->parser_cxt; 965 uint32 error = VBP_OK; 966 967 vc1_viddec_parser_t *parser = (vc1_viddec_parser_t *)cxt->codec_data; 968 if (parser->start_code != VC1_SC_FRM && parser->start_code != VC1_SC_FLD && 969 parser->start_code != VC1_SC_SLC) 970 { 971 /* only handle frame data, field data and slice data here 972 */ 973 return VBP_OK; 974 } 975 vbp_data_vc1 *query_data = (vbp_data_vc1 *)pcontext->query_data; 976 977 if (parser->start_code == VC1_SC_FRM || parser->start_code == VC1_SC_FLD) 978 { 979 query_data->num_pictures++; 980 } 981 982 if (query_data->num_pictures > MAX_NUM_PICTURES) 983 { 984 ETRACE("Num of pictures per sample buffer exceeds the limit (%d).", MAX_NUM_PICTURES); 985 return VBP_DATA; 986 } 987 988 if (query_data->num_pictures == 0) 989 { 990 ETRACE("Unexpected num of pictures."); 991 return VBP_DATA; 992 } 993 994 /* start packing data */ 995 int picture_index = query_data->num_pictures - 1; 996 vbp_picture_data_vc1* pic_data = &(query_data->pic_data[picture_index]); 997 998 if (parser->start_code == VC1_SC_FRM || parser->start_code == VC1_SC_FLD) 999 { 1000 /* setup picture parameter first*/ 1001 vbp_pack_picture_params_vc1(pcontext, index, pic_data); 1002 1003 /* setup bitplane after setting up picture parameter (so that bitplane_present is updated) */ 1004 error = vbp_pack_bitplanes_vc1(pcontext, index, pic_data); 1005 if (VBP_OK != error) 1006 { 1007 ETRACE("Failed to pack bitplane."); 1008 return error; 1009 } 1010 1011 } 1012 1013 /* Always pack slice parameter. The first macroblock in the picture CANNOT 1014 * be preceeded by a slice header, so we will have first slice parsed always. 1015 * 1016 */ 1017 1018 if (pic_data->num_slices >= MAX_NUM_SLICES) 1019 { 1020 ETRACE("Num of slices exceeds the limit (%d).", MAX_NUM_SLICES); 1021 return VBP_DATA; 1022 } 1023 1024 /* set up slice parameter */ 1025 vbp_pack_slice_data_vc1(pcontext, index, pic_data); 1026 1027 1028 return VBP_OK; 1029} 1030