dummy_drv_video/dummy_drv_video.c

   1 /*
   2  * Copyright (c) 2007 Intel Corporation. All Rights Reserved.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the
   6  * "Software"), to deal in the Software without restriction, including
   7  * without limitation the rights to use, copy, modify, merge, publish,
   8  * distribute, sub license, and/or sell copies of the Software, and to
   9  * permit persons to whom the Software is furnished to do so, subject to
  10  * the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the
  13  * next paragraph) shall be included in all copies or substantial portions
  14  * of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  19  * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
  20  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  21  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  22  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 #include "va_backend.h"
  26
  27 #include "dummy_drv_video.h"
  28
  29 #include "assert.h"
  30 #include <stdio.h>
  31 #include <string.h>
  32 #include <stdarg.h>
  33
  34 #define ASSERT  assert
  35
  36 #define INIT_DRIVER_DATA        struct dummy_driver_data *driver_data = (struct dummy_driver_data *) ctx->pDriverData;
  37
  38 #define CONFIG(id)  ((object_config_p) object_heap_lookup( &driver_data->config_heap, id ))
  39 #define CONTEXT(id) ((object_context_p) object_heap_lookup( &driver_data->context_heap, id ))
  40 #define SURFACE(id)     ((object_surface_p) object_heap_lookup( &driver_data->surface_heap, id ))
  41 #define BUFFER(id)  ((object_buffer_p) object_heap_lookup( &driver_data->buffer_heap, id ))
  42
  43 #define CONFIG_ID_OFFSET                0x01000000
  44 #define CONTEXT_ID_OFFSET               0x02000000
  45 #define SURFACE_ID_OFFSET               0x04000000
  46 #define BUFFER_ID_OFFSET                0x08000000
  47
  48 static void dummy__error_message(const char *msg, ...)
  49 {
  50     va_list args;
  51
  52     fprintf(stderr, "dummy_drv_video error: ");
  53     va_start(args, msg);
  54     vfprintf(stderr, msg, args);
  55     va_end(args);
  56 }
  57
  58 static void dummy__information_message(const char *msg, ...)
  59 {
  60     va_list args;
  61
  62     fprintf(stderr, "dummy_drv_video: ");
  63     va_start(args, msg);
  64     vfprintf(stderr, msg, args);
  65     va_end(args);
  66 }
  67
  68 VAStatus dummy_QueryConfigProfiles(
  69                 VADriverContextP ctx,
  70                 VAProfile *profile_list,        /* out */
  71                 int *num_profiles                       /* out */
  72         )
  73 {
  74     INIT_DRIVER_DATA
  75     int i = 0;
  76
  77     profile_list[i++] = VAProfileMPEG2Simple;
  78     profile_list[i++] = VAProfileMPEG2Main;
  79     profile_list[i++] = VAProfileMPEG4Simple;
  80     profile_list[i++] = VAProfileMPEG4AdvancedSimple;
  81     profile_list[i++] = VAProfileMPEG4Main;
  82     profile_list[i++] = VAProfileH264Baseline;
  83     profile_list[i++] = VAProfileH264Main;
  84     profile_list[i++] = VAProfileH264High;
  85     profile_list[i++] = VAProfileVC1Simple;
  86     profile_list[i++] = VAProfileVC1Main;
  87     profile_list[i++] = VAProfileVC1Advanced;
  88
  89     /* If the assert fails then DUMMY_MAX_PROFILES needs to be bigger */
  90     ASSERT(i <= DUMMY_MAX_PROFILES);
  91     *num_profiles = i;
  92
  93     return VA_STATUS_SUCCESS;
  94 }
  95
  96 VAStatus dummy_QueryConfigEntrypoints(
  97                 VADriverContextP ctx,
  98                 VAProfile profile,
  99                 VAEntrypoint  *entrypoint_list, /* out */
 100                 int *num_entrypoints            /* out */
 101         )
 102 {
 103     INIT_DRIVER_DATA
 104
 105     switch (profile) {
 106         case VAProfileMPEG2Simple:
 107         case VAProfileMPEG2Main:
 108                 *num_entrypoints = 2;
 109                 entrypoint_list[0] = VAEntrypointVLD;
 110                 entrypoint_list[1] = VAEntrypointMoComp;
 111                 break;
 112
 113         case VAProfileMPEG4Simple:
 114         case VAProfileMPEG4AdvancedSimple:
 115         case VAProfileMPEG4Main:
 116                 *num_entrypoints = 1;
 117                 entrypoint_list[0] = VAEntrypointVLD;
 118                 break;
 119
 120         case VAProfileH264Baseline:
 121         case VAProfileH264Main:
 122         case VAProfileH264High:
 123                 *num_entrypoints = 1;
 124                 entrypoint_list[0] = VAEntrypointVLD;
 125                 break;
 126
 127         case VAProfileVC1Simple:
 128         case VAProfileVC1Main:
 129         case VAProfileVC1Advanced:
 130                 *num_entrypoints = 1;
 131                 entrypoint_list[0] = VAEntrypointVLD;
 132                 break;
 133
 134         default:
 135                 *num_entrypoints = 0;
 136                 break;
 137     }
 138
 139     /* If the assert fails then DUMMY_MAX_ENTRYPOINTS needs to be bigger */
 140     ASSERT(*num_entrypoints <= DUMMY_MAX_ENTRYPOINTS);
 141     return VA_STATUS_SUCCESS;
 142 }
 143
 144 VAStatus dummy_GetConfigAttributes(
 145                 VADriverContextP ctx,
 146                 VAProfile profile,
 147                 VAEntrypoint entrypoint,
 148                 VAConfigAttrib *attrib_list,    /* in/out */
 149                 int num_attribs
 150         )
 151 {
 152     INIT_DRIVER_DATA
 153
 154     int i;
 155
 156     /* Other attributes don't seem to be defined */
 157     /* What to do if we don't know the attribute? */
 158     for (i = 0; i < num_attribs; i++)
 159     {
 160         switch (attrib_list[i].type)
 161         {
 162           case VAConfigAttribRTFormat:
 163               attrib_list[i].value = VA_RT_FORMAT_YUV420;
 164               break;
 165
 166           default:
 167               /* Do nothing */
 168               attrib_list[i].value = VA_ATTRIB_NOT_SUPPORTED;
 169               break;
 170         }
 171     }
 172
 173     return VA_STATUS_SUCCESS;
 174 }
 175
 176 static VAStatus dummy__update_attribute(object_config_p obj_config, VAConfigAttrib *attrib)
 177 {
 178     int i;
 179     /* Check existing attrbiutes */
 180     for(i = 0; obj_config->attrib_count < i; i++)
 181     {
 182         if (obj_config->attrib_list[i].type == attrib->type)
 183         {
 184             /* Update existing attribute */
 185             obj_config->attrib_list[i].value = attrib->value;
 186             return VA_STATUS_SUCCESS;
 187         }
 188     }
 189     if (obj_config->attrib_count < DUMMY_MAX_CONFIG_ATTRIBUTES)
 190     {
 191         i = obj_config->attrib_count;
 192         obj_config->attrib_list[i].type = attrib->type;
 193         obj_config->attrib_list[i].value = attrib->value;
 194         obj_config->attrib_count++;
 195         return VA_STATUS_SUCCESS;
 196     }
 197     return VA_STATUS_ERROR_MAX_NUM_EXCEEDED;
 198 }
 199
 200 VAStatus dummy_CreateConfig(
 201                 VADriverContextP ctx,
 202                 VAProfile profile,
 203                 VAEntrypoint entrypoint,
 204                 VAConfigAttrib *attrib_list,
 205                 int num_attribs,
 206                 VAConfigID *config_id           /* out */
 207         )
 208 {
 209     INIT_DRIVER_DATA
 210     VAStatus vaStatus;
 211     int configID;
 212     object_config_p obj_config;
 213     int i;
 214
 215     /* Validate profile & entrypoint */
 216     switch (profile) {
 217         case VAProfileMPEG2Simple:
 218         case VAProfileMPEG2Main:
 219                 if ((VAEntrypointVLD == entrypoint) ||
 220                     (VAEntrypointMoComp == entrypoint))
 221                 {
 222                     vaStatus = VA_STATUS_SUCCESS;
 223                 }
 224                 else
 225                 {
 226                     vaStatus = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
 227                 }
 228                 break;
 229
 230         case VAProfileMPEG4Simple:
 231         case VAProfileMPEG4AdvancedSimple:
 232         case VAProfileMPEG4Main:
 233                 if (VAEntrypointVLD == entrypoint)
 234                 {
 235                     vaStatus = VA_STATUS_SUCCESS;
 236                 }
 237                 else
 238                 {
 239                     vaStatus = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
 240                 }
 241                 break;
 242
 243         case VAProfileH264Baseline:
 244         case VAProfileH264Main:
 245         case VAProfileH264High:
 246                 if (VAEntrypointVLD == entrypoint)
 247                 {
 248                     vaStatus = VA_STATUS_SUCCESS;
 249                 }
 250                 else
 251                 {
 252                     vaStatus = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
 253                 }
 254                 break;
 255
 256         case VAProfileVC1Simple:
 257         case VAProfileVC1Main:
 258         case VAProfileVC1Advanced:
 259                 if (VAEntrypointVLD == entrypoint)
 260                 {
 261                     vaStatus = VA_STATUS_SUCCESS;
 262                 }
 263                 else
 264                 {
 265                     vaStatus = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT;
 266                 }
 267                 break;
 268
 269         default:
 270                 vaStatus = VA_STATUS_ERROR_UNSUPPORTED_PROFILE;
 271                 break;
 272     }
 273
 274     if (VA_STATUS_SUCCESS != vaStatus)
 275     {
 276         return vaStatus;
 277     }
 278
 279     configID = object_heap_allocate( &driver_data->config_heap );
 280     obj_config = CONFIG(configID);
 281     if (NULL == obj_config)
 282     {
 283         vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
 284         return vaStatus;
 285     }
 286
 287     obj_config->profile = profile;
 288     obj_config->entrypoint = entrypoint;
 289     obj_config->attrib_list[0].type = VAConfigAttribRTFormat;
 290     obj_config->attrib_list[0].value = VA_RT_FORMAT_YUV420;
 291     obj_config->attrib_count = 1;
 292
 293     for(i = 0; i < num_attribs; i++)
 294     {
 295         vaStatus = dummy__update_attribute(obj_config, &(attrib_list[i]));
 296         if (VA_STATUS_SUCCESS != vaStatus)
 297         {
 298             break;
 299         }
 300     }
 301
 302     /* Error recovery */
 303     if (VA_STATUS_SUCCESS != vaStatus)
 304     {
 305         object_heap_free( &driver_data->config_heap, (object_base_p) obj_config);
 306     }
 307     else
 308     {
 309         *config_id = configID;
 310     }
 311
 312     return vaStatus;
 313 }
 314
 315 VAStatus dummy_DestroyConfig(
 316                 VADriverContextP ctx,
 317                 VAConfigID config_id
 318         )
 319 {
 320     INIT_DRIVER_DATA
 321     VAStatus vaStatus;
 322     object_config_p obj_config;
 323
 324     obj_config = CONFIG(config_id);
 325     if (NULL == obj_config)
 326     {
 327         vaStatus = VA_STATUS_ERROR_INVALID_CONFIG;
 328         return vaStatus;
 329     }
 330
 331     object_heap_free( &driver_data->config_heap, (object_base_p) obj_config);
 332     return VA_STATUS_SUCCESS;
 333 }
 334
 335 VAStatus dummy_QueryConfigAttributes(
 336                 VADriverContextP ctx,
 337                 VAConfigID config_id,
 338                 VAProfile *profile,             /* out */
 339                 VAEntrypoint *entrypoint,       /* out */
 340                 VAConfigAttrib *attrib_list,    /* out */
 341                 int *num_attribs                /* out */
 342         )
 343 {
 344     INIT_DRIVER_DATA
 345     VAStatus vaStatus = VA_STATUS_SUCCESS;
 346     object_config_p obj_config;
 347     int i;
 348
 349     obj_config = CONFIG(config_id);
 350     ASSERT(obj_config);
 351
 352     *profile = obj_config->profile;
 353     *entrypoint = obj_config->entrypoint;
 354     *num_attribs =  obj_config->attrib_count;
 355     for(i = 0; i < obj_config->attrib_count; i++)
 356     {
 357         attrib_list[i] = obj_config->attrib_list[i];
 358     }
 359
 360     return vaStatus;
 361 }
 362
 363 VAStatus dummy_CreateSurfaces(
 364                 VADriverContextP ctx,
 365                 int width,
 366                 int height,
 367                 int format,
 368                 int num_surfaces,
 369                 VASurfaceID *surfaces           /* out */
 370         )
 371 {
 372     INIT_DRIVER_DATA
 373     VAStatus vaStatus = VA_STATUS_SUCCESS;
 374     int i;
 375
 376     /* We only support one format */
 377     if (VA_RT_FORMAT_YUV420 != format)
 378     {
 379         return VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT;
 380     }
 381
 382     for (i = 0; i < num_surfaces; i++)
 383     {
 384         int surfaceID = object_heap_allocate( &driver_data->surface_heap );
 385         object_surface_p obj_surface = SURFACE(surfaceID);
 386         if (NULL == obj_surface)
 387         {
 388             vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
 389             break;
 390         }
 391         obj_surface->surface_id = surfaceID;
 392         surfaces[i] = surfaceID;
 393     }
 394
 395     /* Error recovery */
 396     if (VA_STATUS_SUCCESS != vaStatus)
 397     {
 398         /* surfaces[i-1] was the last successful allocation */
 399         for(; i--; )
 400         {
 401             object_surface_p obj_surface = SURFACE(surfaces[i]);
 402             surfaces[i] = VA_INVALID_SURFACE;
 403             ASSERT(obj_surface);
 404             object_heap_free( &driver_data->surface_heap, (object_base_p) obj_surface);
 405         }
 406     }
 407
 408     return vaStatus;
 409 }
 410
 411 VAStatus dummy_DestroySurfaces(
 412                 VADriverContextP ctx,
 413                 VASurfaceID *surface_list,
 414                 int num_surfaces
 415         )
 416 {
 417     INIT_DRIVER_DATA
 418     int i;
 419     for(i = num_surfaces; i--; )
 420     {
 421         object_surface_p obj_surface = SURFACE(surface_list[i]);
 422         ASSERT(obj_surface);
 423         object_heap_free( &driver_data->surface_heap, (object_base_p) obj_surface);
 424     }
 425     return VA_STATUS_SUCCESS;
 426 }
 427
 428 VAStatus dummy_QueryImageFormats(
 429         VADriverContextP ctx,
 430         VAImageFormat *format_list,        /* out */
 431         int *num_formats           /* out */
 432 )
 433 {
 434     INIT_DRIVER_DATA
 435
 436     /* TODO */
 437     return VA_STATUS_SUCCESS;
 438 }
 439
 440 VAStatus dummy_CreateImage(
 441         VADriverContextP ctx,
 442         VAImageFormat *format,
 443         int width,
 444         int height,
 445         VAImage *image     /* out */
 446 )
 447 {
 448     INIT_DRIVER_DATA
 449
 450     /* TODO */
 451     return VA_STATUS_SUCCESS;
 452 }
 453
 454 VAStatus dummy_DeriveImage(
 455         VADriverContextP ctx,
 456         VASurfaceID surface,
 457         VAImage *image     /* out */
 458 )
 459 {
 460     INIT_DRIVER_DATA
 461
 462     /* TODO */
 463     return VA_STATUS_SUCCESS;
 464 }
 465
 466 VAStatus dummy_DestroyImage(
 467         VADriverContextP ctx,
 468         VAImageID image
 469 )
 470 {
 471     INIT_DRIVER_DATA
 472
 473     /* TODO */
 474     return VA_STATUS_SUCCESS;
 475 }
 476
 477 VAStatus dummy_SetImagePalette(
 478         VADriverContextP ctx,
 479         VAImageID image,
 480         unsigned char *palette
 481 )
 482 {
 483     INIT_DRIVER_DATA
 484
 485     /* TODO */
 486     return VA_STATUS_SUCCESS;
 487 }
 488
 489 VAStatus dummy_GetImage(
 490         VADriverContextP ctx,
 491         VASurfaceID surface,
 492         int x,     /* coordinates of the upper left source pixel */
 493         int y,
 494         unsigned int width, /* width and height of the region */
 495         unsigned int height,
 496         VAImageID image
 497 )
 498 {
 499     INIT_DRIVER_DATA
 500
 501     /* TODO */
 502     return VA_STATUS_SUCCESS;
 503 }
 504
 505
 506 VAStatus dummy_PutImage(
 507         VADriverContextP ctx,
 508         VASurfaceID surface,
 509         VAImageID image,
 510         int src_x,
 511         int src_y,
 512         unsigned int src_width,
 513         unsigned int src_height,
 514         int dest_x,
 515         int dest_y,
 516         unsigned int dest_width,
 517         unsigned int dest_height
 518 )
 519 {
 520     INIT_DRIVER_DATA
 521
 522     /* TODO */
 523     return VA_STATUS_SUCCESS;
 524 }
 525
 526 VAStatus dummy_QuerySubpictureFormats(
 527         VADriverContextP ctx,
 528         VAImageFormat *format_list,        /* out */
 529         unsigned int *flags,       /* out */
 530         unsigned int *num_formats  /* out */
 531 )
 532 {
 533     INIT_DRIVER_DATA
 534
 535     /* TODO */
 536     return VA_STATUS_SUCCESS;
 537 }
 538
 539 VAStatus dummy_CreateSubpicture(
 540         VADriverContextP ctx,
 541         VAImageID image,
 542         VASubpictureID *subpicture   /* out */
 543 )
 544 {
 545     INIT_DRIVER_DATA
 546
 547     /* TODO */
 548     return VA_STATUS_SUCCESS;
 549 }
 550
 551 VAStatus dummy_DestroySubpicture(
 552         VADriverContextP ctx,
 553         VASubpictureID subpicture
 554 )
 555 {
 556     INIT_DRIVER_DATA
 557
 558     /* TODO */
 559     return VA_STATUS_SUCCESS;
 560 }
 561
 562 VAStatus dummy_SetSubpictureImage(
 563         VADriverContextP ctx,
 564         VASubpictureID subpicture,
 565         VAImageID image
 566 )
 567 {
 568     INIT_DRIVER_DATA
 569
 570     /* TODO */
 571     return VA_STATUS_SUCCESS;
 572 }
 573
 574 VAStatus dummy_SetSubpicturePalette(
 575         VADriverContextP ctx,
 576         VASubpictureID subpicture,
 577         /*
 578          * pointer to an array holding the palette data.  The size of the array is
 579          * num_palette_entries * entry_bytes in size.  The order of the components
 580          * in the palette is described by the component_order in VASubpicture struct
 581          */
 582         unsigned char *palette
 583 )
 584 {
 585     INIT_DRIVER_DATA
 586
 587     /* TODO */
 588     return VA_STATUS_SUCCESS;
 589 }
 590
 591 VAStatus dummy_SetSubpictureChromakey(
 592         VADriverContextP ctx,
 593         VASubpictureID subpicture,
 594         unsigned int chromakey_min,
 595         unsigned int chromakey_max,
 596         unsigned int chromakey_mask
 597 )
 598 {
 599     INIT_DRIVER_DATA
 600
 601     /* TODO */
 602     return VA_STATUS_SUCCESS;
 603 }
 604
 605 VAStatus dummy_SetSubpictureGlobalAlpha(
 606         VADriverContextP ctx,
 607         VASubpictureID subpicture,
 608         float global_alpha
 609 )
 610 {
 611     INIT_DRIVER_DATA
 612
 613     /* TODO */
 614     return VA_STATUS_SUCCESS;
 615 }
 616
 617
 618 VAStatus dummy_AssociateSubpicture(
 619         VADriverContextP ctx,
 620         VASubpictureID subpicture,
 621         VASurfaceID *target_surfaces,
 622         int num_surfaces,
 623         short src_x, /* upper left offset in subpicture */
 624         short src_y,
 625         unsigned short src_width,
 626         unsigned short src_height,
 627         short dest_x, /* upper left offset in surface */
 628         short dest_y,
 629         unsigned short dest_width,
 630         unsigned short dest_height,
 631         /*
 632          * whether to enable chroma-keying or global-alpha
 633          * see VA_SUBPICTURE_XXX values
 634          */
 635         unsigned int flags
 636 )
 637 {
 638     INIT_DRIVER_DATA
 639
 640     /* TODO */
 641     return VA_STATUS_SUCCESS;
 642 }
 643
 644 VAStatus dummy_DeassociateSubpicture(
 645         VADriverContextP ctx,
 646         VASubpictureID subpicture,
 647         VASurfaceID *target_surfaces,
 648         int num_surfaces
 649 )
 650 {
 651     INIT_DRIVER_DATA
 652
 653     /* TODO */
 654     return VA_STATUS_SUCCESS;
 655 }
 656
 657 VAStatus dummy_CreateContext(
 658                 VADriverContextP ctx,
 659                 VAConfigID config_id,
 660                 int picture_width,
 661                 int picture_height,
 662                 int flag,
 663                 VASurfaceID *render_targets,
 664                 int num_render_targets,
 665                 VAContextID *context            /* out */
 666         )
 667 {
 668     INIT_DRIVER_DATA
 669     VAStatus vaStatus = VA_STATUS_SUCCESS;
 670     object_config_p obj_config;
 671     int i;
 672
 673     obj_config = CONFIG(config_id);
 674     if (NULL == obj_config)
 675     {
 676         vaStatus = VA_STATUS_ERROR_INVALID_CONFIG;
 677         return vaStatus;
 678     }
 679
 680     /* Validate flag */
 681     /* Validate picture dimensions */
 682
 683     int contextID = object_heap_allocate( &driver_data->context_heap );
 684     object_context_p obj_context = CONTEXT(contextID);
 685     if (NULL == obj_context)
 686     {
 687         vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
 688         return vaStatus;
 689     }
 690
 691     obj_context->context_id  = contextID;
 692     *context = contextID;
 693     obj_context->current_render_target = -1;
 694     obj_context->config_id = config_id;
 695     obj_context->picture_width = picture_width;
 696     obj_context->picture_height = picture_height;
 697     obj_context->num_render_targets = num_render_targets;
 698     obj_context->render_targets = (VASurfaceID *) malloc(num_render_targets * sizeof(VASurfaceID));
 699     if (obj_context->render_targets == NULL)
 700     {
 701         vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
 702         return vaStatus;
 703     }
 704
 705     for(i = 0; i < num_render_targets; i++)
 706     {
 707         if (NULL == SURFACE(render_targets[i]))
 708         {
 709             vaStatus = VA_STATUS_ERROR_INVALID_SURFACE;
 710             break;
 711         }
 712         obj_context->render_targets[i] = render_targets[i];
 713     }
 714     obj_context->flags = flag;
 715
 716     /* Error recovery */
 717     if (VA_STATUS_SUCCESS != vaStatus)
 718     {
 719         obj_context->context_id = -1;
 720         obj_context->config_id = -1;
 721         free(obj_context->render_targets);
 722         obj_context->render_targets = NULL;
 723         obj_context->num_render_targets = 0;
 724         obj_context->flags = 0;
 725         object_heap_free( &driver_data->context_heap, (object_base_p) obj_context);
 726     }
 727
 728     return vaStatus;
 729 }
 730
 731
 732 VAStatus dummy_DestroyContext(
 733                 VADriverContextP ctx,
 734                 VAContextID context
 735         )
 736 {
 737     INIT_DRIVER_DATA
 738     object_context_p obj_context = CONTEXT(context);
 739     ASSERT(obj_context);
 740
 741     obj_context->context_id = -1;
 742     obj_context->config_id = -1;
 743     obj_context->picture_width = 0;
 744     obj_context->picture_height = 0;
 745     if (obj_context->render_targets)
 746     {
 747         free(obj_context->render_targets);
 748     }
 749     obj_context->render_targets = NULL;
 750     obj_context->num_render_targets = 0;
 751     obj_context->flags = 0;
 752
 753     obj_context->current_render_target = -1;
 754
 755     object_heap_free( &driver_data->context_heap, (object_base_p) obj_context);
 756
 757     return VA_STATUS_SUCCESS;
 758 }
 759
 760
 761
 762 static VAStatus dummy__allocate_buffer(object_buffer_p obj_buffer, int size)
 763 {
 764     VAStatus vaStatus = VA_STATUS_SUCCESS;
 765
 766     obj_buffer->buffer_data = realloc(obj_buffer->buffer_data, size);
 767     if (NULL == obj_buffer->buffer_data)
 768     {
 769         vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
 770     }
 771     return vaStatus;
 772 }
 773
 774 VAStatus dummy_CreateBuffer(
 775                 VADriverContextP ctx,
 776                 VAContextID context,    /* in */
 777                 VABufferType type,      /* in */
 778                 unsigned int size,              /* in */
 779                 unsigned int num_elements,      /* in */
 780                 void *data,                     /* in */
 781                 VABufferID *buf_id              /* out */
 782 )
 783 {
 784     INIT_DRIVER_DATA
 785     VAStatus vaStatus = VA_STATUS_SUCCESS;
 786     int bufferID;
 787     object_buffer_p obj_buffer;
 788
 789     /* Validate type */
 790     switch (type)
 791     {
 792         case VAPictureParameterBufferType:
 793         case VAIQMatrixBufferType:
 794         case VABitPlaneBufferType:
 795         case VASliceGroupMapBufferType:
 796         case VASliceParameterBufferType:
 797         case VASliceDataBufferType:
 798         case VAMacroblockParameterBufferType:
 799         case VAResidualDataBufferType:
 800         case VADeblockingParameterBufferType:
 801         case VAImageBufferType:
 802             /* Ok */
 803             break;
 804         default:
 805             vaStatus = VA_STATUS_ERROR_UNSUPPORTED_BUFFERTYPE;
 806             return vaStatus;
 807     }
 808
 809     bufferID = object_heap_allocate( &driver_data->buffer_heap );
 810     obj_buffer = BUFFER(bufferID);
 811     if (NULL == obj_buffer)
 812     {
 813         vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED;
 814         return vaStatus;
 815     }
 816
 817     obj_buffer->buffer_data = NULL;
 818
 819     vaStatus = dummy__allocate_buffer(obj_buffer, size * num_elements);
 820     if (VA_STATUS_SUCCESS == vaStatus)
 821     {
 822         obj_buffer->max_num_elements = num_elements;
 823         obj_buffer->num_elements = num_elements;
 824         if (data)
 825         {
 826             memcpy(obj_buffer->buffer_data, data, size * num_elements);
 827         }
 828     }
 829
 830     if (VA_STATUS_SUCCESS == vaStatus)
 831     {
 832         *buf_id = bufferID;
 833     }
 834
 835     return vaStatus;
 836 }
 837
 838
 839 VAStatus dummy_BufferSetNumElements(
 840                 VADriverContextP ctx,
 841                 VABufferID buf_id,      /* in */
 842         unsigned int num_elements       /* in */
 843         )
 844 {
 845     INIT_DRIVER_DATA
 846     VAStatus vaStatus = VA_STATUS_SUCCESS;
 847     object_buffer_p obj_buffer = BUFFER(buf_id);
 848     ASSERT(obj_buffer);
 849
 850     if ((num_elements < 0) || (num_elements > obj_buffer->max_num_elements))
 851     {
 852         vaStatus = VA_STATUS_ERROR_UNKNOWN;
 853     }
 854     if (VA_STATUS_SUCCESS == vaStatus)
 855     {
 856         obj_buffer->num_elements = num_elements;
 857     }
 858
 859     return vaStatus;
 860 }
 861
 862 VAStatus dummy_MapBuffer(
 863                 VADriverContextP ctx,
 864                 VABufferID buf_id,      /* in */
 865                 void **pbuf         /* out */
 866         )
 867 {
 868     INIT_DRIVER_DATA
 869     VAStatus vaStatus = VA_STATUS_ERROR_UNKNOWN;
 870     object_buffer_p obj_buffer = BUFFER(buf_id);
 871     ASSERT(obj_buffer);
 872     if (NULL == obj_buffer)
 873     {
 874         vaStatus = VA_STATUS_ERROR_INVALID_BUFFER;
 875         return vaStatus;
 876     }
 877
 878     if (NULL != obj_buffer->buffer_data)
 879     {
 880         *pbuf = obj_buffer->buffer_data;
 881         vaStatus = VA_STATUS_SUCCESS;
 882     }
 883     return vaStatus;
 884 }
 885
 886 VAStatus dummy_UnmapBuffer(
 887                 VADriverContextP ctx,
 888                 VABufferID buf_id       /* in */
 889         )
 890 {
 891     /* Do nothing */
 892     return VA_STATUS_SUCCESS;
 893 }
 894
 895 static void dummy__destroy_buffer(struct dummy_driver_data *driver_data, object_buffer_p obj_buffer)
 896 {
 897     if (NULL != obj_buffer->buffer_data)
 898     {
 899         free(obj_buffer->buffer_data);
 900         obj_buffer->buffer_data = NULL;
 901     }
 902
 903     object_heap_free( &driver_data->buffer_heap, (object_base_p) obj_buffer);
 904 }
 905
 906 VAStatus dummy_DestroyBuffer(
 907                 VADriverContextP ctx,
 908                 VABufferID buffer_id
 909         )
 910 {
 911     INIT_DRIVER_DATA
 912     object_buffer_p obj_buffer = BUFFER(buffer_id);
 913     ASSERT(obj_buffer);
 914
 915     dummy__destroy_buffer(driver_data, obj_buffer);
 916     return VA_STATUS_SUCCESS;
 917 }
 918
 919 VAStatus dummy_BeginPicture(
 920                 VADriverContextP ctx,
 921                 VAContextID context,
 922                 VASurfaceID render_target
 923         )
 924 {
 925     INIT_DRIVER_DATA
 926     VAStatus vaStatus = VA_STATUS_SUCCESS;
 927     object_context_p obj_context;
 928     object_surface_p obj_surface;
 929
 930     obj_context = CONTEXT(context);
 931     ASSERT(obj_context);
 932
 933     obj_surface = SURFACE(render_target);
 934     ASSERT(obj_surface);
 935
 936     obj_context->current_render_target = obj_surface->base.id;
 937
 938     return vaStatus;
 939 }
 940
 941 VAStatus dummy_RenderPicture(
 942                 VADriverContextP ctx,
 943                 VAContextID context,
 944                 VABufferID *buffers,
 945                 int num_buffers
 946         )
 947 {
 948     INIT_DRIVER_DATA
 949     VAStatus vaStatus = VA_STATUS_SUCCESS;
 950     object_context_p obj_context;
 951     object_surface_p obj_surface;
 952     int i;
 953
 954     obj_context = CONTEXT(context);
 955     ASSERT(obj_context);
 956
 957     obj_surface = SURFACE(obj_context->current_render_target);
 958     ASSERT(obj_surface);
 959
 960     /* verify that we got valid buffer references */
 961     for(i = 0; i < num_buffers; i++)
 962     {
 963         object_buffer_p obj_buffer = BUFFER(buffers[i]);
 964         ASSERT(obj_buffer);
 965         if (NULL == obj_buffer)
 966         {
 967             vaStatus = VA_STATUS_ERROR_INVALID_BUFFER;
 968             break;
 969         }
 970     }
 971
 972     /* Release buffers */
 973     for(i = 0; i < num_buffers; i++)
 974     {
 975         object_buffer_p obj_buffer = BUFFER(buffers[i]);
 976         ASSERT(obj_buffer);
 977         dummy__destroy_buffer(driver_data, obj_buffer);
 978     }
 979
 980     return vaStatus;
 981 }
 982
 983 VAStatus dummy_EndPicture(
 984                 VADriverContextP ctx,
 985                 VAContextID context
 986         )
 987 {
 988     INIT_DRIVER_DATA
 989     VAStatus vaStatus = VA_STATUS_SUCCESS;
 990     object_context_p obj_context;
 991     object_surface_p obj_surface;
 992
 993     obj_context = CONTEXT(context);
 994     ASSERT(obj_context);
 995
 996     obj_surface = SURFACE(obj_context->current_render_target);
 997     ASSERT(obj_surface);
 998
 999     // For now, assume that we are done with rendering right away
1000     obj_context->current_render_target = -1;
1001
1002     return vaStatus;
1003 }
1004
1005
1006 VAStatus dummy_SyncSurface(
1007                 VADriverContextP ctx,
1008                 VASurfaceID render_target
1009         )
1010 {
1011     INIT_DRIVER_DATA
1012     VAStatus vaStatus = VA_STATUS_SUCCESS;
1013     object_surface_p obj_surface;
1014
1015     obj_surface = SURFACE(render_target);
1016     ASSERT(obj_surface);
1017
1018     return vaStatus;
1019 }
1020
1021 VAStatus dummy_QuerySurfaceStatus(
1022                 VADriverContextP ctx,
1023                 VASurfaceID render_target,
1024                 VASurfaceStatus *status /* out */
1025         )
1026 {
1027     INIT_DRIVER_DATA
1028     VAStatus vaStatus = VA_STATUS_SUCCESS;
1029     object_surface_p obj_surface;
1030
1031     obj_surface = SURFACE(render_target);
1032     ASSERT(obj_surface);
1033
1034     *status = VASurfaceReady;
1035
1036     return vaStatus;
1037 }
1038
1039 VAStatus dummy_PutSurface(
1040                 VADriverContextP ctx,
1041                 VASurfaceID surface,
1042                 Drawable draw, /* X Drawable */
1043                 short srcx,
1044                 short srcy,
1045                 unsigned short srcw,
1046                 unsigned short srch,
1047                 short destx,
1048                 short desty,
1049                 unsigned short destw,
1050                 unsigned short desth,
1051                 VARectangle *cliprects, /* client supplied clip list */
1052                 unsigned int number_cliprects, /* number of clip rects in the clip list */
1053                 unsigned int flags /* de-interlacing flags */
1054         )
1055 {
1056     /* TODO */
1057     return VA_STATUS_ERROR_UNKNOWN;
1058 }
1059
1060 /*
1061  * Query display attributes
1062  * The caller must provide a "attr_list" array that can hold at
1063  * least vaMaxNumDisplayAttributes() entries. The actual number of attributes
1064  * returned in "attr_list" is returned in "num_attributes".
1065  */
1066 VAStatus dummy_QueryDisplayAttributes (
1067                 VADriverContextP ctx,
1068                 VADisplayAttribute *attr_list,  /* out */
1069                 int *num_attributes             /* out */
1070         )
1071 {
1072     /* TODO */
1073     return VA_STATUS_ERROR_UNKNOWN;
1074 }
1075
1076 /*
1077  * Get display attributes
1078  * This function returns the current attribute values in "attr_list".
1079  * Only attributes returned with VA_DISPLAY_ATTRIB_GETTABLE set in the "flags" field
1080  * from vaQueryDisplayAttributes() can have their values retrieved.
1081  */
1082 VAStatus dummy_GetDisplayAttributes (
1083                 VADriverContextP ctx,
1084                 VADisplayAttribute *attr_list,  /* in/out */
1085                 int num_attributes
1086         )
1087 {
1088     /* TODO */
1089     return VA_STATUS_ERROR_UNKNOWN;
1090 }
1091
1092 /*
1093  * Set display attributes
1094  * Only attributes returned with VA_DISPLAY_ATTRIB_SETTABLE set in the "flags" field
1095  * from vaQueryDisplayAttributes() can be set.  If the attribute is not settable or
1096  * the value is out of range, the function returns VA_STATUS_ERROR_ATTR_NOT_SUPPORTED
1097  */
1098 VAStatus dummy_SetDisplayAttributes (
1099                 VADriverContextP ctx,
1100                 VADisplayAttribute *attr_list,
1101                 int num_attributes
1102         )
1103 {
1104     /* TODO */
1105     return VA_STATUS_ERROR_UNKNOWN;
1106 }
1107
1108
1109 VAStatus dummy_CopySurfaceToBuffer(
1110                 VADriverContextP ctx,
1111                 VASurfaceID surface,
1112                 unsigned int *fourcc, /* following are output argument */
1113                 unsigned int *luma_stride,
1114                 unsigned int *chroma_u_stride,
1115                 unsigned int *chroma_v_stride,
1116                 unsigned int *luma_offset,
1117                 unsigned int *chroma_u_offset,
1118                 unsigned int *chroma_v_offset,
1119                 void **buffer
1120         )
1121 {
1122     /* TODO */
1123     return VA_STATUS_ERROR_UNKNOWN;
1124 }
1125
1126 VAStatus dummy_Terminate( VADriverContextP ctx )
1127 {
1128     INIT_DRIVER_DATA
1129     object_buffer_p obj_buffer;
1130     object_surface_p obj_surface;
1131     object_context_p obj_context;
1132     object_config_p obj_config;
1133     object_heap_iterator iter;
1134
1135     /* Clean up left over buffers */
1136     obj_buffer = (object_buffer_p) object_heap_first( &driver_data->buffer_heap, &iter);
1137     while (obj_buffer)
1138     {
1139         dummy__information_message("vaTerminate: bufferID %08x still allocated, destroying\n", obj_buffer->base.id);
1140         dummy__destroy_buffer(driver_data, obj_buffer);
1141         obj_buffer = (object_buffer_p) object_heap_next( &driver_data->buffer_heap, &iter);
1142     }
1143     object_heap_destroy( &driver_data->buffer_heap );
1144
1145     /* TODO cleanup */
1146     object_heap_destroy( &driver_data->surface_heap );
1147
1148     /* TODO cleanup */
1149     object_heap_destroy( &driver_data->context_heap );
1150
1151     /* Clean up configIDs */
1152     obj_config = (object_config_p) object_heap_first( &driver_data->config_heap, &iter);
1153     while (obj_config)
1154     {
1155         object_heap_free( &driver_data->config_heap, (object_base_p) obj_config);
1156         obj_config = (object_config_p) object_heap_next( &driver_data->config_heap, &iter);
1157     }
1158     object_heap_destroy( &driver_data->config_heap );
1159
1160     free(ctx->pDriverData);
1161     ctx->pDriverData = NULL;
1162
1163     return VA_STATUS_SUCCESS;
1164 }
1165
1166 VAStatus __vaDriverInit_0_30(  VADriverContextP ctx )
1167 {
1168     object_base_p obj;
1169     int result;
1170     struct dummy_driver_data *driver_data;
1171     int i;
1172
1173     ctx->version_major = VA_MAJOR_VERSION;
1174     ctx->version_minor = VA_MINOR_VERSION;
1175     ctx->max_profiles = DUMMY_MAX_PROFILES;
1176     ctx->max_entrypoints = DUMMY_MAX_ENTRYPOINTS;
1177     ctx->max_attributes = DUMMY_MAX_CONFIG_ATTRIBUTES;
1178     ctx->max_image_formats = DUMMY_MAX_IMAGE_FORMATS;
1179     ctx->max_subpic_formats = DUMMY_MAX_SUBPIC_FORMATS;
1180     ctx->max_display_attributes = DUMMY_MAX_DISPLAY_ATTRIBUTES;
1181     ctx->str_vendor = DUMMY_STR_VENDOR;
1182
1183     ctx->vtable.vaTerminate = dummy_Terminate;
1184     ctx->vtable.vaQueryConfigEntrypoints = dummy_QueryConfigEntrypoints;
1185     ctx->vtable.vaQueryConfigProfiles = dummy_QueryConfigProfiles;
1186     ctx->vtable.vaQueryConfigEntrypoints = dummy_QueryConfigEntrypoints;
1187     ctx->vtable.vaQueryConfigAttributes = dummy_QueryConfigAttributes;
1188     ctx->vtable.vaCreateConfig = dummy_CreateConfig;
1189     ctx->vtable.vaDestroyConfig = dummy_DestroyConfig;
1190     ctx->vtable.vaGetConfigAttributes = dummy_GetConfigAttributes;
1191     ctx->vtable.vaCreateSurfaces = dummy_CreateSurfaces;
1192     ctx->vtable.vaDestroySurfaces = dummy_DestroySurfaces;
1193     ctx->vtable.vaCreateContext = dummy_CreateContext;
1194     ctx->vtable.vaDestroyContext = dummy_DestroyContext;
1195     ctx->vtable.vaCreateBuffer = dummy_CreateBuffer;
1196     ctx->vtable.vaBufferSetNumElements = dummy_BufferSetNumElements;
1197     ctx->vtable.vaMapBuffer = dummy_MapBuffer;
1198     ctx->vtable.vaUnmapBuffer = dummy_UnmapBuffer;
1199     ctx->vtable.vaDestroyBuffer = dummy_DestroyBuffer;
1200     ctx->vtable.vaBeginPicture = dummy_BeginPicture;
1201     ctx->vtable.vaRenderPicture = dummy_RenderPicture;
1202     ctx->vtable.vaEndPicture = dummy_EndPicture;
1203     ctx->vtable.vaSyncSurface = dummy_SyncSurface;
1204     ctx->vtable.vaQuerySurfaceStatus = dummy_QuerySurfaceStatus;
1205     ctx->vtable.vaPutSurface = dummy_PutSurface;
1206     ctx->vtable.vaQueryImageFormats = dummy_QueryImageFormats;
1207     ctx->vtable.vaCreateImage = dummy_CreateImage;
1208     ctx->vtable.vaDeriveImage = dummy_DeriveImage;
1209     ctx->vtable.vaDestroyImage = dummy_DestroyImage;
1210     ctx->vtable.vaSetImagePalette = dummy_SetImagePalette;
1211     ctx->vtable.vaGetImage = dummy_GetImage;
1212     ctx->vtable.vaPutImage = dummy_PutImage;
1213     ctx->vtable.vaQuerySubpictureFormats = dummy_QuerySubpictureFormats;
1214     ctx->vtable.vaCreateSubpicture = dummy_CreateSubpicture;
1215     ctx->vtable.vaDestroySubpicture = dummy_DestroySubpicture;
1216     ctx->vtable.vaSetSubpictureImage = dummy_SetSubpictureImage;
1217     ctx->vtable.vaSetSubpictureChromakey = dummy_SetSubpictureChromakey;
1218     ctx->vtable.vaSetSubpictureGlobalAlpha = dummy_SetSubpictureGlobalAlpha;
1219     ctx->vtable.vaAssociateSubpicture = dummy_AssociateSubpicture;
1220     ctx->vtable.vaDeassociateSubpicture = dummy_DeassociateSubpicture;
1221     ctx->vtable.vaQueryDisplayAttributes = dummy_QueryDisplayAttributes;
1222     ctx->vtable.vaGetDisplayAttributes = dummy_GetDisplayAttributes;
1223     ctx->vtable.vaSetDisplayAttributes = dummy_SetDisplayAttributes;
1224
1225     ctx->vtable.vaCopySurfaceToBuffer = dummy_CopySurfaceToBuffer;
1226
1227     driver_data = (struct dummy_driver_data *) malloc( sizeof(*driver_data) );
1228     ctx->pDriverData = (void *) driver_data;
1229
1230     result = object_heap_init( &driver_data->config_heap, sizeof(struct object_config), CONFIG_ID_OFFSET );
1231     ASSERT( result == 0 );
1232
1233     result = object_heap_init( &driver_data->context_heap, sizeof(struct object_context), CONTEXT_ID_OFFSET );
1234     ASSERT( result == 0 );
1235
1236     result = object_heap_init( &driver_data->surface_heap, sizeof(struct object_surface), SURFACE_ID_OFFSET );
1237     ASSERT( result == 0 );
1238
1239     result = object_heap_init( &driver_data->buffer_heap, sizeof(struct object_buffer), BUFFER_ID_OFFSET );
1240     ASSERT( result == 0 );
1241
1242
1243     return VA_STATUS_SUCCESS;
1244 }
1245