sys/winks/ksvideohelpers.c

   1 /*
   2  * Copyright (C) 2007 Haakon Sporsheim <hakon.sporsheim@tandberg.com>
   3  *               2008 Ole André Vadla Ravnås <ole.andre.ravnas@tandberg.com>
   4  *               2009 Knut Inge Hvidsten <knut.inge.hvidsten@tandberg.com>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  19  * Boston, MA 02110-1301, USA.
  20  */
  21
  22 #include "ksvideohelpers.h"
  23
  24 #include <math.h>
  25 #include <uuids.h>
  26 #include "kshelpers.h"
  27
  28 GST_DEBUG_CATEGORY_EXTERN (gst_ks_debug);
  29 #define GST_CAT_DEFAULT gst_ks_debug
  30
  31 static const GUID MEDIASUBTYPE_FOURCC =
  32     { 0x0 /* FourCC here */ , 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xAA, 0x00,
  33     0x38, 0x9B, 0x71}
  34 };
  35
  36 typedef struct _KsVideoDeviceEntry KsVideoDeviceEntry;
  37
  38 struct _KsVideoDeviceEntry
  39 {
  40   KsDeviceEntry *device;
  41   gint priority;
  42 };
  43
  44 static void
  45 ks_video_device_entry_decide_priority (KsVideoDeviceEntry * videodevice)
  46 {
  47   HANDLE filter_handle;
  48
  49   videodevice->priority = 0;
  50
  51   filter_handle = CreateFile (videodevice->device->path,
  52       GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING,
  53       FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL);
  54   if (ks_is_valid_handle (filter_handle)) {
  55     GUID *propsets = NULL;
  56     gulong propsets_len;
  57
  58     if (ks_object_get_supported_property_sets (filter_handle, &propsets,
  59             &propsets_len)) {
  60       gulong i;
  61
  62       for (i = 0; i < propsets_len; i++) {
  63         if (memcmp (&propsets[i], &PROPSETID_VIDCAP_CAMERACONTROL,
  64                 sizeof (GUID)) == 0) {
  65           videodevice->priority++;
  66           break;
  67         }
  68       }
  69
  70       g_free (propsets);
  71     }
  72   }
  73
  74   CloseHandle (filter_handle);
  75 }
  76
  77 static gint
  78 ks_video_device_entry_compare (gconstpointer a, gconstpointer b)
  79 {
  80   const KsVideoDeviceEntry *videodevice_a = a;
  81   const KsVideoDeviceEntry *videodevice_b = b;
  82
  83   if (videodevice_a->priority > videodevice_b->priority)
  84     return -1;
  85   else if (videodevice_a->priority == videodevice_b->priority)
  86     return 0;
  87   else
  88     return 1;
  89 }
  90
  91 GList *
  92 ks_video_device_list_sort_cameras_first (GList * devices)
  93 {
  94   GList *videodevices = NULL, *walk;
  95   guint i;
  96
  97   for (walk = devices; walk != NULL; walk = walk->next) {
  98     KsDeviceEntry *device = walk->data;
  99     KsVideoDeviceEntry *videodevice;
 100
 101     videodevice = g_new (KsVideoDeviceEntry, 1);
 102     videodevice->device = device;
 103     ks_video_device_entry_decide_priority (videodevice);
 104
 105     videodevices = g_list_append (videodevices, videodevice);
 106   }
 107
 108   videodevices = g_list_sort (videodevices, ks_video_device_entry_compare);
 109
 110   g_list_free (devices);
 111   devices = NULL;
 112
 113   for (walk = videodevices, i = 0; walk != NULL; walk = walk->next, i++) {
 114     KsVideoDeviceEntry *videodevice = walk->data;
 115
 116     videodevice->device->index = i;
 117     devices = g_list_append (devices, videodevice->device);
 118
 119     g_free (videodevice);
 120   }
 121
 122   g_list_free (videodevices);
 123
 124   return devices;
 125 }
 126
 127 static GstStructure *
 128 ks_video_format_to_structure (GUID subtype_guid, GUID format_guid,
 129     gboolean * p_is_rgb)
 130 {
 131   GstStructure *structure = NULL;
 132   const gchar *media_type = NULL, *format = NULL;
 133   /* RGB formats can be bottom-up (upside down) DIB */
 134   gboolean is_rgb = FALSE;
 135
 136   if (IsEqualGUID (&subtype_guid, &MEDIASUBTYPE_MJPG) || IsEqualGUID (&subtype_guid, &MEDIASUBTYPE_TVMJ) ||     /* FIXME: NOT tested */
 137       IsEqualGUID (&subtype_guid, &MEDIASUBTYPE_WAKE) ||        /* FIXME: NOT tested */
 138       IsEqualGUID (&subtype_guid, &MEDIASUBTYPE_CFCC) ||        /* FIXME: NOT tested */
 139       IsEqualGUID (&subtype_guid, &MEDIASUBTYPE_IJPG)) {        /* FIXME: NOT tested */
 140     media_type = "image/jpeg";
 141   } else if (IsEqualGUID (&subtype_guid, &MEDIASUBTYPE_RGB555)) {
 142     media_type = "video/x-raw";
 143     format = "RGB15";
 144     is_rgb = TRUE;
 145   } else if (IsEqualGUID (&subtype_guid, &MEDIASUBTYPE_RGB565)) {
 146     media_type = "video/x-raw";
 147     format = "RGB16";
 148     is_rgb = TRUE;
 149   } else if (IsEqualGUID (&subtype_guid, &MEDIASUBTYPE_RGB24)) {
 150     media_type = "video/x-raw";
 151     format = "BGR";
 152     is_rgb = TRUE;
 153   } else if (IsEqualGUID (&subtype_guid, &MEDIASUBTYPE_RGB32)) {
 154     media_type = "video/x-raw";
 155     format = "BGRx";
 156     is_rgb = TRUE;
 157   } else if (IsEqualGUID (&subtype_guid, &MEDIASUBTYPE_ARGB32)) {
 158     media_type = "video/x-raw";
 159     format = "BGRA";
 160     is_rgb = TRUE;
 161   } else if (IsEqualGUID (&subtype_guid, &MEDIASUBTYPE_ARGB1555)) {
 162     GST_WARNING ("Unsupported video format ARGB15555");
 163   } else if (IsEqualGUID (&subtype_guid, &MEDIASUBTYPE_ARGB4444)) {
 164     GST_WARNING ("Unsupported video format ARGB4444");
 165   } else if (memcmp (&subtype_guid.Data2, &MEDIASUBTYPE_FOURCC.Data2,
 166           sizeof (subtype_guid) - sizeof (subtype_guid.Data1)) == 0) {
 167     guint8 *p = (guint8 *) & subtype_guid.Data1;
 168     gchar *format = g_strdup_printf ("%c%c%c%c", p[0], p[1], p[2], p[3]);
 169     structure = gst_structure_new ("video/x-raw", "format",
 170         G_TYPE_STRING, format, NULL);
 171     g_free (format);
 172   } else if (IsEqualGUID (&subtype_guid, &MEDIASUBTYPE_dvsd)) {
 173     if (IsEqualGUID (&format_guid, &FORMAT_DvInfo)) {
 174       structure = gst_structure_new ("video/x-dv",
 175           "systemstream", G_TYPE_BOOLEAN, TRUE, NULL);
 176     } else if (IsEqualGUID (&format_guid, &FORMAT_VideoInfo)) {
 177       structure = gst_structure_new ("video/x-dv",
 178           "systemstream", G_TYPE_BOOLEAN, FALSE,
 179           "format", G_TYPE_STRING, "dvsd", NULL);
 180     }
 181   }
 182
 183   if (media_type) {
 184     structure = gst_structure_new_empty (media_type);
 185     if (format) {
 186       gst_structure_set (structure, "format", G_TYPE_STRING, format, NULL);
 187     }
 188     if (p_is_rgb) {
 189       *p_is_rgb = is_rgb;
 190     }
 191   }
 192
 193   if (!structure) {
 194     GST_DEBUG ("Unknown DirectShow Video GUID "
 195         "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
 196         (guint) subtype_guid.Data1, subtype_guid.Data2, subtype_guid.Data3,
 197         subtype_guid.Data4[0], subtype_guid.Data4[1], subtype_guid.Data4[2],
 198         subtype_guid.Data4[3], subtype_guid.Data4[4], subtype_guid.Data4[5],
 199         subtype_guid.Data4[6], subtype_guid.Data4[7]);
 200   }
 201
 202   return structure;
 203 }
 204
 205 static void
 206 guess_aspect (gint width, gint height, gint * par_width, gint * par_height)
 207 {
 208   /*
 209    * As we dont have access to the actual pixel aspect, we will try to do a
 210    * best-effort guess. The guess is based on most sensors being either 4/3
 211    * or 16/9, and most pixel aspects being close to 1/1.
 212    */
 213   if ((width == 768) && (height == 448)) {      /* special case for w448p */
 214     *par_width = 28;
 215     *par_height = 27;
 216   } else {
 217     if (((float) width / (float) height) < 1.2778) {
 218       *par_width = 12;
 219       *par_height = 11;
 220     } else {
 221       *par_width = 1;
 222       *par_height = 1;
 223     }
 224   }
 225 }
 226
 227 /* NOTE: would probably be better to use a continued fractions approach here */
 228 static void
 229 compress_fraction (gint64 in_num, gint64 in_den, gint64 * out_num,
 230     gint64 * out_den)
 231 {
 232   gdouble on, od, orig;
 233   guint denominators[] = { 1, 2, 3, 5, 7 }, i;
 234   const gdouble max_loss = 0.1;
 235
 236   on = in_num;
 237   od = in_den;
 238   orig = on / od;
 239
 240   for (i = 0; i < G_N_ELEMENTS (denominators); i++) {
 241     gint64 cur_n, cur_d;
 242     gdouble cur, loss;
 243
 244     cur_n = floor ((on / (od / (gdouble) denominators[i])) + 0.5);
 245     cur_d = denominators[i];
 246     cur = (gdouble) cur_n / (gdouble) cur_d;
 247     loss = fabs (cur - orig);
 248
 249     if (loss <= max_loss) {
 250       *out_num = cur_n;
 251       *out_den = cur_d;
 252
 253       return;
 254     }
 255   }
 256
 257   *out_num = in_num;
 258   *out_den = in_den;
 259 }
 260
 261 static gboolean
 262 ks_video_append_video_stream_cfg_fields (GstStructure * structure,
 263     const KS_VIDEO_STREAM_CONFIG_CAPS * vscc)
 264 {
 265   GValue val = { 0, };
 266   gint64 min_n, min_d;
 267   gint64 max_n, max_d;
 268
 269   g_return_val_if_fail (structure, FALSE);
 270   g_return_val_if_fail (vscc, FALSE);
 271
 272   /* width */
 273   if (vscc->MinOutputSize.cx == vscc->MaxOutputSize.cx) {
 274     gst_structure_set (structure,
 275         "width", G_TYPE_INT, vscc->MaxOutputSize.cx, NULL);
 276   } else {
 277     gst_structure_set (structure,
 278         "width", GST_TYPE_INT_RANGE,
 279         vscc->MinOutputSize.cx, vscc->MaxOutputSize.cx, NULL);
 280   }
 281
 282   /* height */
 283   if (vscc->MinOutputSize.cy == vscc->MaxOutputSize.cy) {
 284     gst_structure_set (structure,
 285         "height", G_TYPE_INT, vscc->MaxOutputSize.cy, NULL);
 286   } else {
 287     gst_structure_set (structure,
 288         "height", GST_TYPE_INT_RANGE,
 289         vscc->MinOutputSize.cy, vscc->MaxOutputSize.cy, NULL);
 290   }
 291
 292   /* framerate */
 293   compress_fraction (NANOSECONDS, vscc->MinFrameInterval, &min_n, &min_d);
 294   compress_fraction (NANOSECONDS, vscc->MaxFrameInterval, &max_n, &max_d);
 295
 296   if (min_n == max_n && min_d == max_d) {
 297     g_value_init (&val, GST_TYPE_FRACTION);
 298     gst_value_set_fraction (&val, max_n, max_d);
 299   } else {
 300     g_value_init (&val, GST_TYPE_FRACTION_RANGE);
 301     gst_value_set_fraction_range_full (&val, max_n, max_d, min_n, min_d);
 302   }
 303
 304   gst_structure_set_value (structure, "framerate", &val);
 305   g_value_unset (&val);
 306
 307   {
 308     gint par_width, par_height;
 309
 310     guess_aspect (vscc->MaxOutputSize.cx, vscc->MaxOutputSize.cy,
 311         &par_width, &par_height);
 312
 313     gst_structure_set (structure,
 314         "pixel-aspect-ratio", GST_TYPE_FRACTION, par_width, par_height, NULL);
 315   }
 316
 317   return TRUE;
 318 }
 319
 320 KsVideoMediaType *
 321 ks_video_media_type_dup (KsVideoMediaType * media_type)
 322 {
 323   KsVideoMediaType *result = g_new (KsVideoMediaType, 1);
 324
 325   memcpy (result, media_type, sizeof (KsVideoMediaType));
 326
 327   result->range = g_malloc (media_type->range->FormatSize);
 328   memcpy ((gpointer) result->range, media_type->range,
 329       media_type->range->FormatSize);
 330
 331   result->format = g_malloc (media_type->format_size);
 332   memcpy (result->format, media_type->format, media_type->format_size);
 333
 334   result->translated_caps = gst_caps_ref (media_type->translated_caps);
 335
 336   return result;
 337 }
 338
 339 void
 340 ks_video_media_type_free (KsVideoMediaType * media_type)
 341 {
 342   if (media_type == NULL)
 343     return;
 344
 345   g_free ((gpointer) media_type->range);
 346
 347   g_free (media_type->format);
 348
 349   if (media_type->translated_caps != NULL)
 350     gst_caps_unref (media_type->translated_caps);
 351
 352   g_free (media_type);
 353 }
 354
 355 static GList *
 356 ks_video_media_type_list_remove_duplicates (GList * media_types)
 357 {
 358   GList *master, *duplicates;
 359
 360   do {
 361     GList *entry;
 362
 363     master = duplicates = NULL;
 364
 365     /* Find the first set of duplicates and their master */
 366     for (entry = media_types; entry != NULL && duplicates == NULL;
 367         entry = entry->next) {
 368       KsVideoMediaType *mt = entry->data;
 369       GList *other_entry;
 370
 371       for (other_entry = media_types; other_entry != NULL;
 372           other_entry = other_entry->next) {
 373         KsVideoMediaType *other_mt = other_entry->data;
 374
 375         if (other_mt == mt)
 376           continue;
 377
 378         if (gst_caps_is_equal (mt->translated_caps, other_mt->translated_caps))
 379           duplicates = g_list_prepend (duplicates, other_mt);
 380       }
 381
 382       if (duplicates != NULL)
 383         master = entry;
 384     }
 385
 386     if (duplicates != NULL) {
 387       KsVideoMediaType *selected_mt = master->data;
 388
 389       /*
 390        * Pick a FORMAT_VideoInfo2 if present, if not we just stay with the
 391        * first entry
 392        */
 393       for (entry = duplicates; entry != NULL; entry = entry->next) {
 394         KsVideoMediaType *mt = entry->data;
 395
 396         if (IsEqualGUID (&mt->range->Specifier, &FORMAT_VideoInfo2)) {
 397           ks_video_media_type_free (selected_mt);
 398           selected_mt = mt;
 399         } else {
 400           ks_video_media_type_free (mt);
 401         }
 402
 403         /* Remove the dupe from the main list */
 404         media_types = g_list_remove (media_types, mt);
 405       }
 406
 407       /* Update master node with the selected MediaType */
 408       master->data = selected_mt;
 409
 410       g_list_free (duplicates);
 411     }
 412   }
 413   while (master != NULL);
 414
 415   return media_types;
 416 }
 417
 418 GList *
 419 ks_video_probe_filter_for_caps (HANDLE filter_handle)
 420 {
 421   GList *ret = NULL;
 422   gulong pin_count;
 423   guint pin_id;
 424
 425   if (!ks_filter_get_pin_property (filter_handle, 0, KSPROPSETID_Pin,
 426           KSPROPERTY_PIN_CTYPES, &pin_count, sizeof (pin_count), NULL))
 427     goto beach;
 428
 429   GST_DEBUG ("pin_count = %lu", pin_count);
 430
 431   for (pin_id = 0; pin_id < pin_count; pin_id++) {
 432     KSPIN_COMMUNICATION pin_comm;
 433     KSPIN_DATAFLOW pin_flow;
 434     GUID pin_cat;
 435
 436     if (!ks_filter_get_pin_property (filter_handle, pin_id, KSPROPSETID_Pin,
 437             KSPROPERTY_PIN_COMMUNICATION, &pin_comm, sizeof (pin_comm), NULL))
 438       continue;
 439
 440     if (!ks_filter_get_pin_property (filter_handle, pin_id, KSPROPSETID_Pin,
 441             KSPROPERTY_PIN_DATAFLOW, &pin_flow, sizeof (pin_flow), NULL))
 442       continue;
 443
 444     if (!ks_filter_get_pin_property (filter_handle, pin_id, KSPROPSETID_Pin,
 445             KSPROPERTY_PIN_CATEGORY, &pin_cat, sizeof (pin_cat), NULL))
 446       continue;
 447
 448     GST_DEBUG ("pin[%u]: pin_comm=%d, pin_flow=%d", pin_id, pin_comm, pin_flow);
 449
 450     if (pin_flow == KSPIN_DATAFLOW_OUT &&
 451         memcmp (&pin_cat, &PINNAME_CAPTURE, sizeof (GUID)) == 0) {
 452       KSMULTIPLE_ITEM *items;
 453
 454       if (ks_filter_get_pin_property_multi (filter_handle, pin_id,
 455               KSPROPSETID_Pin, KSPROPERTY_PIN_DATARANGES, &items, NULL)) {
 456         KSDATARANGE *range = (KSDATARANGE *) (items + 1);
 457         guint i;
 458
 459         for (i = 0; i < items->Count; i++) {
 460           if (IsEqualGUID (&range->MajorFormat, &MEDIATYPE_Video)
 461               || IsEqualGUID (&range->MajorFormat, &MEDIATYPE_Interleaved)) {
 462             KsVideoMediaType *entry;
 463             gpointer src_vscc, src_format;
 464             GstStructure *media_structure;
 465
 466             entry = g_new0 (KsVideoMediaType, 1);
 467             entry->pin_id = pin_id;
 468
 469             entry->range = g_malloc (range->FormatSize);
 470             memcpy ((gpointer) entry->range, range, range->FormatSize);
 471
 472             if (IsEqualGUID (&range->Specifier, &FORMAT_VideoInfo)) {
 473               KS_DATARANGE_VIDEO *vr = (KS_DATARANGE_VIDEO *) entry->range;
 474
 475               src_vscc = &vr->ConfigCaps;
 476               src_format = &vr->VideoInfoHeader;
 477
 478               entry->format_size = sizeof (vr->VideoInfoHeader);
 479               entry->sample_size = vr->VideoInfoHeader.bmiHeader.biSizeImage;
 480             } else if (IsEqualGUID (&range->Specifier, &FORMAT_VideoInfo2)) {
 481               KS_DATARANGE_VIDEO2 *vr = (KS_DATARANGE_VIDEO2 *) entry->range;
 482
 483               src_vscc = &vr->ConfigCaps;
 484               src_format = &vr->VideoInfoHeader;
 485
 486               entry->format_size = sizeof (vr->VideoInfoHeader);
 487               entry->sample_size = vr->VideoInfoHeader.bmiHeader.biSizeImage;
 488             } else if (IsEqualGUID (&range->Specifier, &FORMAT_MPEGVideo)) {
 489               /* Untested and probably wrong... */
 490               KS_DATARANGE_MPEG1_VIDEO *vr =
 491                   (KS_DATARANGE_MPEG1_VIDEO *) entry->range;
 492
 493               src_vscc = &vr->ConfigCaps;
 494               src_format = &vr->VideoInfoHeader;
 495
 496               entry->format_size = sizeof (vr->VideoInfoHeader);
 497               entry->sample_size =
 498                   vr->VideoInfoHeader.hdr.bmiHeader.biSizeImage;
 499             } else if (IsEqualGUID (&range->Specifier, &FORMAT_MPEG2Video)) {
 500               KS_DATARANGE_MPEG2_VIDEO *vr =
 501                   (KS_DATARANGE_MPEG2_VIDEO *) entry->range;
 502               src_vscc = &vr->ConfigCaps;
 503               src_format = &vr->VideoInfoHeader;
 504
 505               entry->format_size = sizeof (vr->VideoInfoHeader);
 506               entry->sample_size =
 507                   vr->VideoInfoHeader.hdr.bmiHeader.biSizeImage;
 508             } else if (IsEqualGUID (&range->Specifier, &FORMAT_DvInfo)) {
 509               KS_DATARANGE_DVVIDEO *vr = (KS_DATARANGE_DVVIDEO *) entry->range;
 510
 511               src_vscc = NULL;
 512               src_format = &vr->DVVideoInfo;
 513
 514               entry->format_size = sizeof (vr->DVVideoInfo);
 515               entry->sample_size = vr->DataRange.SampleSize;
 516             } else {
 517               gchar *guid_str;
 518
 519               guid_str = ks_guid_to_string (&range->Specifier);
 520               GST_DEBUG ("pin[%u]: ignoring unknown specifier GUID %s",
 521                   pin_id, guid_str);
 522               g_free (guid_str);
 523
 524               ks_video_media_type_free (entry);
 525               entry = NULL;
 526             }
 527
 528             if (entry != NULL) {
 529               g_assert (entry->sample_size != 0);
 530
 531               if (src_vscc != NULL) {
 532                 memcpy ((gpointer) & entry->vscc, src_vscc,
 533                     sizeof (entry->vscc));
 534               }
 535
 536               entry->format = g_malloc (entry->format_size);
 537               memcpy (entry->format, src_format, entry->format_size);
 538
 539               media_structure =
 540                   ks_video_format_to_structure (range->SubFormat,
 541                   range->Specifier, &entry->is_rgb);
 542
 543               if (media_structure == NULL) {
 544                 g_warning ("ks_video_format_to_structure returned NULL");
 545                 ks_video_media_type_free (entry);
 546                 entry = NULL;
 547               } else if (src_vscc == NULL) {
 548                 entry->translated_caps = gst_caps_new_empty ();
 549                 gst_caps_append_structure (entry->translated_caps,
 550                     media_structure);
 551               } else if (ks_video_append_video_stream_cfg_fields
 552                   (media_structure, &entry->vscc)) {
 553                 entry->translated_caps = gst_caps_new_empty ();
 554                 gst_caps_append_structure (entry->translated_caps,
 555                     media_structure);
 556               } else {
 557                 gst_structure_free (media_structure);
 558                 ks_video_media_type_free (entry);
 559                 entry = NULL;
 560               }
 561
 562               if (entry != NULL)
 563                 ret = g_list_prepend (ret, entry);
 564             }
 565           }
 566
 567           /* REVISIT: Each KSDATARANGE should start on a 64-bit boundary */
 568           range = (KSDATARANGE *) (((guchar *) range) + range->FormatSize);
 569         }
 570
 571         g_free (items);
 572       }
 573     }
 574   }
 575
 576   if (ret != NULL) {
 577     ret = g_list_reverse (ret);
 578     ret = ks_video_media_type_list_remove_duplicates (ret);
 579   }
 580
 581 beach:
 582   return ret;
 583 }
 584
 585 KSPIN_CONNECT *
 586 ks_video_create_pin_conn_from_media_type (KsVideoMediaType * media_type)
 587 {
 588   KSPIN_CONNECT *conn = NULL;
 589   KSDATAFORMAT *format = NULL;
 590   guint8 *vih;
 591
 592   conn = g_malloc0 (sizeof (KSPIN_CONNECT) + sizeof (KSDATAFORMAT) +
 593       media_type->format_size);
 594
 595   conn->Interface.Set = KSINTERFACESETID_Standard;
 596   conn->Interface.Id = KSINTERFACE_STANDARD_STREAMING;
 597   conn->Interface.Flags = 0;
 598
 599   conn->Medium.Set = KSMEDIUMSETID_Standard;
 600   conn->Medium.Id = KSMEDIUM_TYPE_ANYINSTANCE;
 601   conn->Medium.Flags = 0;
 602
 603   conn->PinId = media_type->pin_id;
 604   conn->PinToHandle = NULL;
 605   conn->Priority.PriorityClass = KSPRIORITY_NORMAL;
 606   conn->Priority.PrioritySubClass = KSPRIORITY_NORMAL;
 607
 608   format = (KSDATAFORMAT *) (conn + 1);
 609   memcpy (format, media_type->range, sizeof (KSDATAFORMAT));
 610   format->FormatSize = sizeof (KSDATAFORMAT) + media_type->format_size;
 611
 612   vih = (guint8 *) (format + 1);
 613   memcpy (vih, media_type->format, media_type->format_size);
 614
 615   return conn;
 616 }
 617
 618 gboolean
 619 ks_video_fixate_media_type (const KSDATARANGE * range,
 620     guint8 * format, gint width, gint height, gint fps_n, gint fps_d)
 621 {
 622   KS_DATARANGE_VIDEO *vr;
 623   KS_VIDEOINFOHEADER *vih;
 624   KS_BITMAPINFOHEADER *bih;
 625   DWORD dwRate;
 626
 627   g_return_val_if_fail (format != NULL, FALSE);
 628
 629   if (IsEqualGUID (&range->Specifier, &FORMAT_VideoInfo)) {
 630     bih = &((KS_VIDEOINFOHEADER *) format)->bmiHeader;
 631   } else if (IsEqualGUID (&range->Specifier, &FORMAT_VideoInfo2)) {
 632     bih = &((KS_VIDEOINFOHEADER2 *) format)->bmiHeader;
 633   } else if (IsEqualGUID (&range->Specifier, &FORMAT_MPEGVideo)) {
 634     bih = &((KS_MPEG1VIDEOINFO *) format)->hdr.bmiHeader;
 635   } else if (IsEqualGUID (&range->Specifier, &FORMAT_MPEG2Video)) {
 636     bih = &((KS_MPEGVIDEOINFO2 *) format)->hdr.bmiHeader;
 637   } else {
 638     return FALSE;
 639   }
 640
 641   /* These formats' structures share the most basic stuff */
 642   vr = (KS_DATARANGE_VIDEO *) range;
 643   vih = (KS_VIDEOINFOHEADER *) format;
 644
 645   /* FIXME: Need to figure out how to properly handle ranges */
 646   if (bih->biWidth != width || bih->biHeight != height)
 647     return FALSE;
 648
 649   /* Framerate, clamped because of fraction conversion rounding errors */
 650   vih->AvgTimePerFrame =
 651       gst_util_uint64_scale_int_round (NANOSECONDS, fps_d, fps_n);
 652   vih->AvgTimePerFrame =
 653       MAX (vih->AvgTimePerFrame, vr->ConfigCaps.MinFrameInterval);
 654   vih->AvgTimePerFrame =
 655       MIN (vih->AvgTimePerFrame, vr->ConfigCaps.MaxFrameInterval);
 656
 657   /* Bitrate, clamped for the same reason as framerate */
 658   dwRate = (width * height * fps_n) / fps_d;
 659   vih->dwBitRate = dwRate * bih->biBitCount;
 660   vih->dwBitRate = MAX (vih->dwBitRate, vr->ConfigCaps.MinBitsPerSecond);
 661   vih->dwBitRate = MIN (vih->dwBitRate, vr->ConfigCaps.MaxBitsPerSecond);
 662
 663   return TRUE;
 664 }
 665
 666 static GstStructure *
 667 ks_video_append_var_video_fields (GstStructure * structure)
 668 {
 669   if (structure) {
 670     gst_structure_set (structure,
 671         "width", GST_TYPE_INT_RANGE, 1, G_MAXINT,
 672         "height", GST_TYPE_INT_RANGE, 1, G_MAXINT,
 673         "framerate", GST_TYPE_FRACTION_RANGE, 0, 1, G_MAXINT, 1, NULL);
 674   }
 675
 676   return structure;
 677 }
 678
 679 GstCaps *
 680 ks_video_get_all_caps (void)
 681 {
 682   static GstCaps *caps = NULL;
 683
 684   if (caps == NULL) {
 685     GstStructure *structure;
 686     caps = gst_caps_new_empty ();
 687
 688     /* from Windows SDK 6.0 uuids.h */
 689     /* RGB formats */
 690     structure =
 691         ks_video_append_var_video_fields (ks_video_format_to_structure
 692         (MEDIASUBTYPE_RGB555, FORMAT_VideoInfo, NULL));
 693     gst_caps_append_structure (caps, structure);
 694
 695     structure =
 696         ks_video_append_var_video_fields (ks_video_format_to_structure
 697         (MEDIASUBTYPE_RGB565, FORMAT_VideoInfo, NULL));
 698     gst_caps_append_structure (caps, structure);
 699
 700     structure =
 701         ks_video_append_var_video_fields (ks_video_format_to_structure
 702         (MEDIASUBTYPE_RGB24, FORMAT_VideoInfo, NULL));
 703     gst_caps_append_structure (caps, structure);
 704
 705     structure =
 706         ks_video_append_var_video_fields (ks_video_format_to_structure
 707         (MEDIASUBTYPE_RGB32, FORMAT_VideoInfo, NULL));
 708     gst_caps_append_structure (caps, structure);
 709
 710     /* YUV formats */
 711     structure =
 712         ks_video_append_var_video_fields (gst_structure_new_empty
 713         ("video/x-raw"));
 714     gst_caps_append_structure (caps, structure);
 715
 716     /* Other formats */
 717     structure =
 718         ks_video_append_var_video_fields (ks_video_format_to_structure
 719         (MEDIASUBTYPE_MJPG, FORMAT_VideoInfo, NULL));
 720     gst_caps_append_structure (caps, structure);
 721
 722     structure =
 723         ks_video_append_var_video_fields (ks_video_format_to_structure
 724         (MEDIASUBTYPE_dvsd, FORMAT_VideoInfo, NULL));
 725     gst_caps_append_structure (caps, structure);
 726
 727     structure =                 /* no variable video fields (width, height, framerate) */
 728         ks_video_format_to_structure (MEDIASUBTYPE_dvsd, FORMAT_DvInfo, NULL);
 729     gst_caps_append_structure (caps, structure);
 730   }
 731
 732   return caps;
 733 }