docs/gst/gstreamer-decl.txt

   1 <MACRO>
   2 <NAME>COTHREAD_STACKSIZE</NAME>
   3 #define COTHREAD_STACKSIZE 8192
   4 </MACRO>
   5 <MACRO>
   6 <NAME>COTHREAD_MAXTHREADS</NAME>
   7 #define COTHREAD_MAXTHREADS 16
   8 </MACRO>
   9 <MACRO>
  10 <NAME>STACK_SIZE</NAME>
  11 #define STACK_SIZE 0x200000
  12 </MACRO>
  13 <MACRO>
  14 <NAME>CURRENT_STACK_FRAME</NAME>
  15 #define CURRENT_STACK_FRAME  ({ char __csf; &__csf; })
  16 </MACRO>
  17 <STRUCT>
  18 <NAME>cothread_state</NAME>
  19 </STRUCT>
  20 <STRUCT>
  21 <NAME>cothread_context</NAME>
  22 </STRUCT>
  23 <USER_FUNCTION>
  24 <NAME>cothread_func</NAME>
  25 <RETURNS>int </RETURNS>
  26 int argc,char **argv
  27 </USER_FUNCTION>
  28 <MACRO>
  29 <NAME>COTHREAD_STARTED</NAME>
  30 #define COTHREAD_STARTED        0x01
  31 </MACRO>
  32 <STRUCT>
  33 <NAME>cothread_state</NAME>
  34 struct cothread_state {
  35   cothread_context *ctx;
  36   int threadnum;
  37
  38   cothread_func func;
  39   int argc;
  40   char **argv;
  41
  42   int flags;
  43   int *sp;
  44   int *pc;
  45   jmp_buf jmp;
  46 };
  47 </STRUCT>
  48 <STRUCT>
  49 <NAME>cothread_context</NAME>
  50 struct cothread_context {
  51   cothread_state *threads[COTHREAD_MAXTHREADS];
  52   int nthreads;
  53   int current;
  54 };
  55 </STRUCT>
  56 <FUNCTION>
  57 <NAME>cothread_init</NAME>
  58 <RETURNS>cothread_context  *</RETURNS>
  59
  60 </FUNCTION>
  61 <FUNCTION>
  62 <NAME>cothread_create</NAME>
  63 <RETURNS>cothread_state  *</RETURNS>
  64 cothread_context *ctx
  65 </FUNCTION>
  66 <FUNCTION>
  67 <NAME>cothread_setfunc</NAME>
  68 <RETURNS>void  </RETURNS>
  69 cothread_state *thread,cothread_func func,int argc,char **argv
  70 </FUNCTION>
  71 <FUNCTION>
  72 <NAME>cothread_switch</NAME>
  73 <RETURNS>void  </RETURNS>
  74 cothread_state *thread
  75 </FUNCTION>
  76 <FUNCTION>
  77 <NAME>cothread_main</NAME>
  78 <RETURNS>cothread_state  *</RETURNS>
  79 cothread_context *ctx
  80 </FUNCTION>
  81 <FUNCTION>
  82 <NAME>gst_init</NAME>
  83 <RETURNS>void  </RETURNS>
  84 int *argc,char **argv[]
  85 </FUNCTION>
  86 <FUNCTION>
  87 <NAME>gst_main</NAME>
  88 <RETURNS>void  </RETURNS>
  89
  90 </FUNCTION>
  91 <FUNCTION>
  92 <NAME>gst_main_quit</NAME>
  93 <RETURNS>void  </RETURNS>
  94
  95 </FUNCTION>
  96 <MACRO>
  97 <NAME>DEBUG</NAME>
  98 #define DEBUG(format, args...) g_print("DEBUG:(%d) " format, getpid() , ##args)
  99 </MACRO>
 100 <MACRO>
 101 <NAME>DEBUG</NAME>
 102 #define DEBUG(format, args...)
 103 </MACRO>
 104 <VARIABLE>
 105 <NAME>gst_bin_details</NAME>
 106 extern GstElementDetails gst_bin_details;
 107 </VARIABLE>
 108 <MACRO>
 109 <NAME>GST_TYPE_BIN</NAME>
 110 #define GST_TYPE_BIN \
 111   (gst_bin_get_type())
 112 </MACRO>
 113 <MACRO>
 114 <NAME>GST_BIN</NAME>
 115 #define GST_BIN(obj) \
 116   (GTK_CHECK_CAST((obj),GST_TYPE_BIN,GstBin))
 117 </MACRO>
 118 <MACRO>
 119 <NAME>GST_BIN_CLASS</NAME>
 120 #define GST_BIN_CLASS(klass) \
 121   (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_BIN,GstBinClass))
 122 </MACRO>
 123 <MACRO>
 124 <NAME>GST_IS_BIN</NAME>
 125 #define GST_IS_BIN(obj) \
 126   (GTK_CHECK_TYPE((obj),GST_TYPE_BIN))
 127 </MACRO>
 128 <MACRO>
 129 <NAME>GST_IS_BIN_CLASS</NAME>
 130 #define GST_IS_BIN_CLASS(obj) \
 131   (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_BIN))
 132 </MACRO>
 133 <STRUCT>
 134 <NAME>GstBin</NAME>
 135 </STRUCT>
 136 <STRUCT>
 137 <NAME>GstBinClass</NAME>
 138 </STRUCT>
 139 <STRUCT>
 140 <NAME>GstBin</NAME>
 141 struct GstBin {
 142   GstElement element;
 143
 144   // our children
 145   gint numchildren;
 146   GList *children;
 147
 148   // iteration state
 149   gboolean need_cothreads;
 150   GList *entries;
 151   gint numentries;
 152
 153   cothread_context *threadcontext;
 154   gboolean use_cothreads;
 155 };
 156 </STRUCT>
 157 <STRUCT>
 158 <NAME>GstBinClass</NAME>
 159 struct GstBinClass {
 160   GstElementClass parent_class;
 161
 162   void (*object_added) (GstObject *object,GstObject *child);
 163
 164   /* change the state of elements of the given type */
 165   gboolean (*change_state_type) (GstBin *bin,
 166                                  GstElementState state,
 167                                  GtkType type);
 168
 169   /* create a plan for the execution of the bin */
 170   void (*create_plan) (GstBin *bin);
 171
 172   /* run a full iteration of operation */
 173   void (*iterate) (GstBin *bin);
 174 };
 175 </STRUCT>
 176 <FUNCTION>
 177 <NAME>gst_bin_get_type</NAME>
 178 <RETURNS>GtkType  </RETURNS>
 179 void
 180 </FUNCTION>
 181 <FUNCTION>
 182 <NAME>gst_bin_new</NAME>
 183 <RETURNS>GstElement  *</RETURNS>
 184 gchar *name
 185 </FUNCTION>
 186 <MACRO>
 187 <NAME>gst_bin_destroy</NAME>
 188 #define gst_bin_destroy(bin) gst_object_destroy(GST_OBJECT(bin))
 189 </MACRO>
 190 <FUNCTION>
 191 <NAME>gst_bin_add</NAME>
 192 <RETURNS>void  </RETURNS>
 193 GstBin *bin,GstElement *element
 194 </FUNCTION>
 195 <FUNCTION>
 196 <NAME>gst_bin_remove</NAME>
 197 <RETURNS>void  </RETURNS>
 198 GstBin *bin,GstElement *element
 199 </FUNCTION>
 200 <FUNCTION>
 201 <NAME>gst_bin_get_by_name</NAME>
 202 <RETURNS>GstElement  *</RETURNS>
 203 GstBin *bin,gchar *name
 204 </FUNCTION>
 205 <FUNCTION>
 206 <NAME>gst_bin_get_list</NAME>
 207 <RETURNS>GList  *</RETURNS>
 208 GstBin *bin
 209 </FUNCTION>
 210 <FUNCTION>
 211 <NAME>gst_bin_set_state_type</NAME>
 212 <RETURNS>gboolean  </RETURNS>
 213 GstBin *bin,GstElementState state,GtkType type
 214 </FUNCTION>
 215 <FUNCTION>
 216 <NAME>gst_bin_iterate</NAME>
 217 <RETURNS>void  </RETURNS>
 218 GstBin *bin
 219 </FUNCTION>
 220 <FUNCTION>
 221 <NAME>gst_bin_create_plan</NAME>
 222 <RETURNS>void  </RETURNS>
 223 GstBin *bin
 224 </FUNCTION>
 225 <FUNCTION>
 226 <NAME>gst_bin_use_cothreads</NAME>
 227 <RETURNS>void  </RETURNS>
 228 GstBin *bin, gboolean enabled
 229 </FUNCTION>
 230 <MACRO>
 231 <NAME>GST_BUFFER</NAME>
 232 #define GST_BUFFER(buf) \
 233   ((GstBuffer *)(buf))
 234 </MACRO>
 235 <MACRO>
 236 <NAME>GST_BUFFER_FLAGS</NAME>
 237 #define GST_BUFFER_FLAGS(buf) \
 238   (GST_BUFFER(buf)->flags)
 239 </MACRO>
 240 <MACRO>
 241 <NAME>GST_BUFFER_FLAG_IS_SET</NAME>
 242 #define GST_BUFFER_FLAG_IS_SET(buf,flag) \
 243   (GST_BUFFER_FLAGS(buf) & (flag))
 244 </MACRO>
 245 <MACRO>
 246 <NAME>GST_BUFFER_FLAG_SET</NAME>
 247 #define GST_BUFFER_FLAG_SET(buf,flag) \
 248   G_STMT_START{ (GST_BUFFER_FLAGS(buf) |= (flag)); }G_STMT_END
 249 </MACRO>
 250 <MACRO>
 251 <NAME>GST_BUFFER_FLAG_UNSET</NAME>
 252 #define GST_BUFFER_FLAG_UNSET(buf,flag) \
 253   G_STMT_START{ (GST_BUFFER_FLAGS(buf) &= ~(flag)); }G_STMT_END
 254 </MACRO>
 255 <MACRO>
 256 <NAME>GST_BUFFER_TYPE</NAME>
 257 #define GST_BUFFER_TYPE(buf)            (GST_BUFFER(buf)->type)
 258 </MACRO>
 259 <MACRO>
 260 <NAME>GST_BUFFER_DATA</NAME>
 261 #define GST_BUFFER_DATA(buf)            (GST_BUFFER(buf)->data)
 262 </MACRO>
 263 <MACRO>
 264 <NAME>GST_BUFFER_SIZE</NAME>
 265 #define GST_BUFFER_SIZE(buf)            (GST_BUFFER(buf)->size)
 266 </MACRO>
 267 <MACRO>
 268 <NAME>GST_BUFFER_OFFSET</NAME>
 269 #define GST_BUFFER_OFFSET(buf)          (GST_BUFFER(buf)->offset)
 270 </MACRO>
 271 <MACRO>
 272 <NAME>GST_BUFFER_MAXSIZE</NAME>
 273 #define GST_BUFFER_MAXSIZE(buf)         (GST_BUFFER(buf)->maxsize)
 274 </MACRO>
 275 <MACRO>
 276 <NAME>GST_BUFFER_TIMESTAMP</NAME>
 277 #define GST_BUFFER_TIMESTAMP(buf)       (GST_BUFFER(buf)->timestamp)
 278 </MACRO>
 279 <MACRO>
 280 <NAME>GST_BUFFER_LOCK</NAME>
 281 #define GST_BUFFER_LOCK(buf)    (g_mutex_lock(GST_BUFFER(buf)->lock))
 282 </MACRO>
 283 <MACRO>
 284 <NAME>GST_BUFFER_TRYLOCK</NAME>
 285 #define GST_BUFFER_TRYLOCK(buf) (g_mutex_trylock(GST_BUFFER(buf)->lock))
 286 </MACRO>
 287 <MACRO>
 288 <NAME>GST_BUFFER_UNLOCK</NAME>
 289 #define GST_BUFFER_UNLOCK(buf)  (g_mutex_unlock(GST_BUFFER(buf)->lock))
 290 </MACRO>
 291 <ENUM>
 292 <NAME>GstBufferFlags</NAME>
 293 typedef enum {
 294   GST_BUFFER_READONLY           = (1 << 0),
 295   GST_BUFFER_EOS                = (1 << 1),
 296   GST_BUFFER_ORIGINAL           = (1 << 2),
 297   GST_BUFFER_DONTFREE           = (1 << 3),
 298   GST_BUFFER_FLUSH              = (1 << 4),
 299 } GstBufferFlags;
 300 </ENUM>
 301 <STRUCT>
 302 <NAME>GstBuffer</NAME>
 303 </STRUCT>
 304 <STRUCT>
 305 <NAME>GstBuffer</NAME>
 306 struct GstBuffer {
 307   /* locking */
 308   GMutex *lock;
 309
 310   /* refcounting */
 311 #ifdef HAVE_ATOMIC_H
 312   atomic_t refcount;
 313 #define GST_BUFFER_REFCOUNT(buf)        (atomic_read(&(GST_BUFFER((buf))->refcount)))
 314 #else
 315   int refcount;
 316 #define GST_BUFFER_REFCOUNT(buf)        (GST_BUFFER(buf)->refcount)
 317 #endif
 318
 319   /* data type of this buffer */
 320   guint16 type;
 321   /* flags */
 322   guint16 flags;
 323
 324   /* pointer to data, its size, and offset in original source if known */
 325   guchar *data;
 326   guint32 size;
 327   guint32 maxsize;
 328   guint32 offset;
 329
 330   /* timestamp */
 331   guint64 timestamp;
 332   /* max age */
 333   guint64 maxage;
 334
 335   /* pointer to metadata, is really lame right now */
 336   GSList *metas;
 337
 338   /* subbuffer support, who's my parent? */
 339   GstBuffer *parent;
 340
 341   /* this is a pointer to the buffer pool (if any) */
 342   GstBufferPool *pool;
 343 };
 344 </STRUCT>
 345 <FUNCTION>
 346 <NAME>gst_buffer_new</NAME>
 347 <RETURNS>GstBuffer  *</RETURNS>
 348
 349 </FUNCTION>
 350 <FUNCTION>
 351 <NAME>gst_buffer_new_from_pool</NAME>
 352 <RETURNS>GstBuffer  *</RETURNS>
 353 GstBufferPool *pool
 354 </FUNCTION>
 355 <FUNCTION>
 356 <NAME>gst_buffer_create_sub</NAME>
 357 <RETURNS>GstBuffer  *</RETURNS>
 358 GstBuffer *parent,guint32 offset,guint32 size
 359 </FUNCTION>
 360 <FUNCTION>
 361 <NAME>gst_buffer_append</NAME>
 362 <RETURNS>GstBuffer  *</RETURNS>
 363 GstBuffer *buffer, GstBuffer *append
 364 </FUNCTION>
 365 <FUNCTION>
 366 <NAME>gst_buffer_ref</NAME>
 367 <RETURNS>void  </RETURNS>
 368 GstBuffer *buffer
 369 </FUNCTION>
 370 <FUNCTION>
 371 <NAME>gst_buffer_ref_by_count</NAME>
 372 <RETURNS>void  </RETURNS>
 373 GstBuffer *buffer,int count
 374 </FUNCTION>
 375 <FUNCTION>
 376 <NAME>gst_buffer_unref</NAME>
 377 <RETURNS>void  </RETURNS>
 378 GstBuffer *buffer
 379 </FUNCTION>
 380 <FUNCTION>
 381 <NAME>gst_buffer_destroy</NAME>
 382 <RETURNS>void  </RETURNS>
 383 GstBuffer *buffer
 384 </FUNCTION>
 385 <FUNCTION>
 386 <NAME>gst_buffer_add_meta</NAME>
 387 <RETURNS>void  </RETURNS>
 388 GstBuffer *buffer,GstMeta *meta
 389 </FUNCTION>
 390 <FUNCTION>
 391 <NAME>gst_buffer_get_first_meta</NAME>
 392 <RETURNS>GstMeta  *</RETURNS>
 393 GstBuffer *buffer
 394 </FUNCTION>
 395 <FUNCTION>
 396 <NAME>gst_buffer_get_metas</NAME>
 397 <RETURNS>GSList  *</RETURNS>
 398 GstBuffer *buffer
 399 </FUNCTION>
 400 <FUNCTION>
 401 <NAME>gst_buffer_remove_meta</NAME>
 402 <RETURNS>void  </RETURNS>
 403 GstBuffer *buffer,GstMeta *meta
 404 </FUNCTION>
 405 <TYPEDEF>
 406 <NAME>GstClockTime</NAME>
 407 typedef guint64 GstClockTime;
 408 </TYPEDEF>
 409 <TYPEDEF>
 410 <NAME>GstClockTimeDiff</NAME>
 411 typedef gint64 GstClockTimeDiff;
 412 </TYPEDEF>
 413 <MACRO>
 414 <NAME>GST_CLOCK_DIFF</NAME>
 415 #define GST_CLOCK_DIFF(s, e) (GstClockTimeDiff)((s)-(e))
 416 </MACRO>
 417 <STRUCT>
 418 <NAME>GstClock</NAME>
 419 </STRUCT>
 420 <STRUCT>
 421 <NAME>GstClock</NAME>
 422 struct GstClock {
 423   gchar *name;
 424   GstClockTime start_time;
 425   GstClockTime current_time;
 426   GstClockTimeDiff adjust;
 427   gboolean locking;
 428   GList *sinkobjects;
 429   gint num, num_locked;
 430   GMutex *sinkmutex;
 431   GMutex *lock;
 432 };
 433 </STRUCT>
 434 <FUNCTION>
 435 <NAME>gst_clock_new</NAME>
 436 <RETURNS>GstClock  *</RETURNS>
 437 gchar *name
 438 </FUNCTION>
 439 <FUNCTION>
 440 <NAME>gst_clock_get_system</NAME>
 441 <RETURNS>GstClock  *</RETURNS>
 442 void
 443 </FUNCTION>
 444 <FUNCTION>
 445 <NAME>gst_clock_register</NAME>
 446 <RETURNS>void  </RETURNS>
 447 GstClock *clock, GstObject *obj
 448 </FUNCTION>
 449 <FUNCTION>
 450 <NAME>gst_clock_set</NAME>
 451 <RETURNS>void  </RETURNS>
 452 GstClock *clock, GstClockTime time
 453 </FUNCTION>
 454 <FUNCTION>
 455 <NAME>gst_clock_reset</NAME>
 456 <RETURNS>void  </RETURNS>
 457 GstClock *clock
 458 </FUNCTION>
 459 <FUNCTION>
 460 <NAME>gst_clock_wait</NAME>
 461 <RETURNS>void  </RETURNS>
 462 GstClock *clock, GstClockTime time, GstObject *obj
 463 </FUNCTION>
 464 <FUNCTION>
 465 <NAME>gst_clock_current_diff</NAME>
 466 <RETURNS>GstClockTimeDiff  </RETURNS>
 467 GstClock *clock, GstClockTime time
 468 </FUNCTION>
 469 <MACRO>
 470 <NAME>GST_TYPE_CONNECTION</NAME>
 471 #define GST_TYPE_CONNECTION \
 472   (gst_connection_get_type())
 473 </MACRO>
 474 <MACRO>
 475 <NAME>GST_CONNECTION</NAME>
 476 #define GST_CONNECTION(obj) \
 477   (GTK_CHECK_CAST((obj),GST_TYPE_CONNECTION,GstConnection))
 478 </MACRO>
 479 <MACRO>
 480 <NAME>GST_CONNECTION_CLASS</NAME>
 481 #define GST_CONNECTION_CLASS(klass) \
 482   (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_CONNECTION,GstConnectionClass))
 483 </MACRO>
 484 <MACRO>
 485 <NAME>GST_IS_CONNECTION</NAME>
 486 #define GST_IS_CONNECTION(obj) \
 487   (GTK_CHECK_TYPE((obj),GST_TYPE_CONNECTION))
 488 </MACRO>
 489 <MACRO>
 490 <NAME>GST_IS_CONNECTION_CLASS</NAME>
 491 #define GST_IS_CONNECTION_CLASS(obj) \
 492   (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_CONNECTION)))
 493 </MACRO>
 494 <STRUCT>
 495 <NAME>GstConnection</NAME>
 496 </STRUCT>
 497 <STRUCT>
 498 <NAME>GstConnectionClass</NAME>
 499 </STRUCT>
 500 <STRUCT>
 501 <NAME>GstConnection</NAME>
 502 struct GstConnection {
 503   GstElement element;
 504 };
 505 </STRUCT>
 506 <STRUCT>
 507 <NAME>GstConnectionClass</NAME>
 508 struct GstConnectionClass {
 509   GstElementClass parent_class;
 510
 511   /* push function */
 512   void (*push) (GstConnection *connection);
 513 };
 514 </STRUCT>
 515 <FUNCTION>
 516 <NAME>gst_connection_get_type</NAME>
 517 <RETURNS>GtkType  </RETURNS>
 518 void
 519 </FUNCTION>
 520 <FUNCTION>
 521 <NAME>gst_connection_new</NAME>
 522 <RETURNS>GstElement  *</RETURNS>
 523 gchar *name
 524 </FUNCTION>
 525 <FUNCTION>
 526 <NAME>gst_connection_push</NAME>
 527 <RETURNS>void  </RETURNS>
 528 GstConnection *connection
 529 </FUNCTION>
 530 <ENUM>
 531 <NAME>GstElementState</NAME>
 532 typedef enum {
 533   GST_STATE_NONE_PENDING        = -1,
 534   GST_STATE_NULL        = 0,
 535   GST_STATE_READY       = 1,
 536   GST_STATE_PLAYING     = 2,
 537   GST_STATE_PAUSED      = 3,
 538 } GstElementState;
 539 </ENUM>
 540 <ENUM>
 541 <NAME>GstElementStateReturn</NAME>
 542 typedef enum {
 543   GST_STATE_FAILURE     = 0,
 544   GST_STATE_SUCCESS     = 1,
 545   GST_STATE_ASYNC       = 2,
 546 } GstElementStateReturn;
 547 </ENUM>
 548 <MACRO>
 549 <NAME>GST_STATE</NAME>
 550 #define GST_STATE(obj)                  (GST_ELEMENT(obj)->current_state)
 551 </MACRO>
 552 <MACRO>
 553 <NAME>GST_STATE_PENDING</NAME>
 554 #define GST_STATE_PENDING(obj)          (GST_ELEMENT(obj)->pending_state)
 555 </MACRO>
 556 <MACRO>
 557 <NAME>GST_TYPE_ELEMENT</NAME>
 558 #define GST_TYPE_ELEMENT \
 559   (gst_element_get_type())
 560 </MACRO>
 561 <MACRO>
 562 <NAME>GST_ELEMENT</NAME>
 563 #define GST_ELEMENT(obj) \
 564   (GTK_CHECK_CAST((obj),GST_TYPE_ELEMENT,GstElement))
 565 </MACRO>
 566 <MACRO>
 567 <NAME>GST_ELEMENT_CLASS</NAME>
 568 #define GST_ELEMENT_CLASS(klass) \
 569   (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_ELEMENT,GstElementClass))
 570 </MACRO>
 571 <MACRO>
 572 <NAME>GST_IS_ELEMENT</NAME>
 573 #define GST_IS_ELEMENT(obj) \
 574   (GTK_CHECK_TYPE((obj),GST_TYPE_ELEMENT))
 575 </MACRO>
 576 <MACRO>
 577 <NAME>GST_IS_ELEMENT_CLASS</NAME>
 578 #define GST_IS_ELEMENT_CLASS(obj) \
 579   (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_ELEMENT))
 580 </MACRO>
 581 <ENUM>
 582 <NAME>GstElementFlags</NAME>
 583 typedef enum {
 584   GST_ELEMENT_MULTI_IN          = (1 << 0),
 585 } GstElementFlags;
 586 </ENUM>
 587 <MACRO>
 588 <NAME>GST_ELEMENT_IS_MULTI_IN</NAME>
 589 #define GST_ELEMENT_IS_MULTI_IN(obj)    (GST_FLAGS(obj) & GST_ELEMENT_MULTI_IN)
 590 </MACRO>
 591 <STRUCT>
 592 <NAME>GstElement</NAME>
 593 </STRUCT>
 594 <STRUCT>
 595 <NAME>GstElementClass</NAME>
 596 </STRUCT>
 597 <STRUCT>
 598 <NAME>GstElementDetails</NAME>
 599 </STRUCT>
 600 <STRUCT>
 601 <NAME>GstElementFactory</NAME>
 602 </STRUCT>
 603 <USER_FUNCTION>
 604 <NAME>GstElementLoopFunction</NAME>
 605 <RETURNS>void </RETURNS>
 606 GstElement *element
 607 </USER_FUNCTION>
 608 <STRUCT>
 609 <NAME>GstElement</NAME>
 610 struct GstElement {
 611   GstObject object;
 612
 613   gchar *name;
 614
 615   guint8 current_state;
 616   guint8 pending_state;
 617
 618   GstElementLoopFunction loopfunc;
 619   cothread_state *threadstate;
 620
 621   guint16 numpads;
 622   GList *pads;
 623
 624   GstElement *manager;
 625 };
 626 </STRUCT>
 627 <STRUCT>
 628 <NAME>GstElementClass</NAME>
 629 struct GstElementClass {
 630   GstObjectClass parent_class;
 631
 632   /* the elementfactory that created us */
 633   GstElementFactory *elementfactory;
 634
 635   /* signal callbacks */
 636   void (*state_change) (GstElement *element,GstElementState state);
 637   void (*new_pad) (GstElement *element,GstPad *pad);
 638   void (*new_ghost_pad) (GstElement *element,GstPad *pad);
 639   void (*error) (GstElement *element,gchar *error);
 640
 641   /* events */
 642 //  gboolean (*start) (GstElement *element,GstElementState state);
 643 //  gboolean (*stop) (GstElement *element);
 644
 645   /* change the element state */
 646   GstElementStateReturn (*change_state) (GstElement *element);
 647
 648   /* create or read XML representation of self */
 649   xmlNodePtr (*save_thyself)(GstElement *element,xmlNodePtr parent);
 650   void (*restore_thyself)(GstElement *element,xmlNodePtr *self);
 651 };
 652 </STRUCT>
 653 <STRUCT>
 654 <NAME>GstElementDetails</NAME>
 655 struct GstElementDetails {
 656   gchar *longname;              /* long, english name */
 657   gchar *class;                 /* type of element, kinda */
 658   gchar *description;           /* insights of one form or another */
 659   gchar *version;               /* version of the element */
 660   gchar *author;                /* who wrote this thing? */
 661   gchar *copyright;             /* copyright details (year, etc.) */
 662 };
 663 </STRUCT>
 664 <STRUCT>
 665 <NAME>GstElementFactory</NAME>
 666 struct GstElementFactory {
 667   gchar *name;                  /* name of element */
 668   GtkType type;                 /* unique GtkType of element */
 669
 670   GstElementDetails *details;   /* pointer to details struct */
 671
 672   GList *src_types;
 673   GList *sink_types;
 674 };
 675 </STRUCT>
 676 <FUNCTION>
 677 <NAME>gst_element_get_type</NAME>
 678 <RETURNS>GtkType  </RETURNS>
 679 void
 680 </FUNCTION>
 681 <FUNCTION>
 682 <NAME>gst_element_new</NAME>
 683 <RETURNS>GstElement  *</RETURNS>
 684 void
 685 </FUNCTION>
 686 <FUNCTION>
 687 <NAME>gst_element_set_loop_function</NAME>
 688 <RETURNS>void  </RETURNS>
 689 GstElement *element,GstElementLoopFunction loop
 690 </FUNCTION>
 691 <FUNCTION>
 692 <NAME>gst_element_set_name</NAME>
 693 <RETURNS>void  </RETURNS>
 694 GstElement *element,gchar *name
 695 </FUNCTION>
 696 <FUNCTION>
 697 <NAME>gst_element_get_name</NAME>
 698 <RETURNS>gchar  *</RETURNS>
 699 GstElement *element
 700 </FUNCTION>
 701 <FUNCTION>
 702 <NAME>gst_element_set_manager</NAME>
 703 <RETURNS>void  </RETURNS>
 704 GstElement *element,GstElement *manager
 705 </FUNCTION>
 706 <FUNCTION>
 707 <NAME>gst_element_get_manager</NAME>
 708 <RETURNS>GstElement  *</RETURNS>
 709 GstElement *element
 710 </FUNCTION>
 711 <FUNCTION>
 712 <NAME>gst_element_add_pad</NAME>
 713 <RETURNS>void  </RETURNS>
 714 GstElement *element,GstPad *pad
 715 </FUNCTION>
 716 <FUNCTION>
 717 <NAME>gst_element_add_ghost_pad</NAME>
 718 <RETURNS>void  </RETURNS>
 719 GstElement *element,GstPad *pad
 720 </FUNCTION>
 721 <FUNCTION>
 722 <NAME>gst_element_get_pad</NAME>
 723 <RETURNS>GstPad  *</RETURNS>
 724 GstElement *element,gchar *name
 725 </FUNCTION>
 726 <FUNCTION>
 727 <NAME>gst_element_get_pad_list</NAME>
 728 <RETURNS>GList  *</RETURNS>
 729 GstElement *element
 730 </FUNCTION>
 731 <FUNCTION>
 732 <NAME>gst_element_connect</NAME>
 733 <RETURNS>void  </RETURNS>
 734 GstElement *src,gchar *srcpadname,GstElement *dest,gchar *destpadname
 735 </FUNCTION>
 736 <FUNCTION>
 737 <NAME>gst_element_set_state</NAME>
 738 <RETURNS>gint  </RETURNS>
 739 GstElement *element,GstElementState state
 740 </FUNCTION>
 741 <FUNCTION>
 742 <NAME>gst_element_error</NAME>
 743 <RETURNS>void  </RETURNS>
 744 GstElement *element,gchar *error
 745 </FUNCTION>
 746 <FUNCTION>
 747 <NAME>gst_element_get_factory</NAME>
 748 <RETURNS>GstElementFactory  *</RETURNS>
 749 GstElement *element
 750 </FUNCTION>
 751 <MACRO>
 752 <NAME>gst_element_destroy</NAME>
 753 #define gst_element_destroy(element) gst_object_destroy(GST_OBJECT(element))
 754 </MACRO>
 755 <FUNCTION>
 756 <NAME>gst_element_save_thyself</NAME>
 757 <RETURNS>xmlNodePtr  </RETURNS>
 758 GstElement *element,xmlNodePtr parent
 759 </FUNCTION>
 760 <FUNCTION>
 761 <NAME>gst_elementfactory_new</NAME>
 762 <RETURNS>GstElementFactory  *</RETURNS>
 763 gchar *name,GtkType type,GstElementDetails *details
 764 </FUNCTION>
 765 <FUNCTION>
 766 <NAME>gst_elementfactory_register</NAME>
 767 <RETURNS>void  </RETURNS>
 768 GstElementFactory *elementfactory
 769 </FUNCTION>
 770 <FUNCTION>
 771 <NAME>gst_elementfactory_add_src</NAME>
 772 <RETURNS>void  </RETURNS>
 773 GstElementFactory *elementfactory, guint16 id
 774 </FUNCTION>
 775 <FUNCTION>
 776 <NAME>gst_elementfactory_add_sink</NAME>
 777 <RETURNS>void  </RETURNS>
 778 GstElementFactory *elementfactory, guint16 id
 779 </FUNCTION>
 780 <FUNCTION>
 781 <NAME>gst_elementfactory_find</NAME>
 782 <RETURNS>GstElementFactory  *</RETURNS>
 783 gchar *name
 784 </FUNCTION>
 785 <FUNCTION>
 786 <NAME>gst_elementfactory_get_list</NAME>
 787 <RETURNS>GList  *</RETURNS>
 788
 789 </FUNCTION>
 790 <FUNCTION>
 791 <NAME>gst_elementfactory_create</NAME>
 792 <RETURNS>GstElement  *</RETURNS>
 793 GstElementFactory *factory,gchar *name
 794 </FUNCTION>
 795 <FUNCTION>
 796 <NAME>gst_elementfactory_make</NAME>
 797 <RETURNS>GstElement  *</RETURNS>
 798 gchar *factoryname,gchar *name
 799 </FUNCTION>
 800 <FUNCTION>
 801 <NAME>gst_elementfactory_save_thyself</NAME>
 802 <RETURNS>xmlNodePtr  </RETURNS>
 803 GstElementFactory *factory, xmlNodePtr parent
 804 </FUNCTION>
 805 <FUNCTION>
 806 <NAME>gst_elementfactory_load_thyself</NAME>
 807 <RETURNS>GstElementFactory  *</RETURNS>
 808 xmlNodePtr parent
 809 </FUNCTION>
 810 <FUNCTION>
 811 <NAME>gst_element_loopfunc_wrapper</NAME>
 812 <RETURNS>int  </RETURNS>
 813 int argc,char **argv
 814 </FUNCTION>
 815 <MACRO>
 816 <NAME>GST_TYPE_FILTER</NAME>
 817 #define GST_TYPE_FILTER \
 818   (gst_filter_get_type())
 819 </MACRO>
 820 <MACRO>
 821 <NAME>GST_FILTER</NAME>
 822 #define GST_FILTER(obj) \
 823   (GTK_CHECK_CAST((obj),GST_TYPE_FILTER,GstFilter))
 824 </MACRO>
 825 <MACRO>
 826 <NAME>GST_FILTER_CLASS</NAME>
 827 #define GST_FILTER_CLASS(klass) \
 828   (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_FILTER,GstFilterClass))
 829 </MACRO>
 830 <MACRO>
 831 <NAME>GST_IS_FILTER</NAME>
 832 #define GST_IS_FILTER(obj) \
 833   (GTK_CHECK_TYPE((obj),GST_TYPE_FILTER))
 834 </MACRO>
 835 <MACRO>
 836 <NAME>GST_IS_FILTER_CLASS</NAME>
 837 #define GST_IS_FILTER_CLASS(obj) \
 838   (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_FILTER))
 839 </MACRO>
 840 <STRUCT>
 841 <NAME>GstFilter</NAME>
 842 </STRUCT>
 843 <STRUCT>
 844 <NAME>GstFilterClass</NAME>
 845 </STRUCT>
 846 <STRUCT>
 847 <NAME>GstFilter</NAME>
 848 struct GstFilter {
 849   GstElement element;
 850 };
 851 </STRUCT>
 852 <STRUCT>
 853 <NAME>GstFilterClass</NAME>
 854 struct GstFilterClass {
 855   GstElementClass parent_class;
 856 };
 857 </STRUCT>
 858 <FUNCTION>
 859 <NAME>gst_filter_get_type</NAME>
 860 <RETURNS>GtkType  </RETURNS>
 861 void
 862 </FUNCTION>
 863 <FUNCTION>
 864 <NAME>gst_filter_new</NAME>
 865 <RETURNS>GstElement  *</RETURNS>
 866 gchar *name
 867 </FUNCTION>
 868 <MACRO>
 869 <NAME>GST_SHOW_INFO</NAME>
 870 #define GST_SHOW_INFO
 871 </MACRO>
 872 <MACRO>
 873 <NAME>gst_info</NAME>
 874 #define gst_info(format,args...) fprintf(stderr,format,##args)
 875 </MACRO>
 876 <MACRO>
 877 <NAME>gst_info</NAME>
 878 #define gst_info(format,args...)
 879 </MACRO>
 880 <MACRO>
 881 <NAME>GST_META</NAME>
 882 #define GST_META(meta) ((GstMeta *)(meta))
 883 </MACRO>
 884 <MACRO>
 885 <NAME>GST_META_FLAGS</NAME>
 886 #define GST_META_FLAGS(buf) \
 887   (GST_META(buf)->flags)
 888 </MACRO>
 889 <MACRO>
 890 <NAME>GST_META_FLAG_IS_SET</NAME>
 891 #define GST_META_FLAG_IS_SET(meta,flag) \
 892   (GST_META_FLAGS(meta) & (flag))
 893 </MACRO>
 894 <MACRO>
 895 <NAME>GST_META_FLAG_SET</NAME>
 896 #define GST_META_FLAG_SET(meta,flag) \
 897   G_STMT_START{ (GST_META_FLAGS(meta) |= (flag)); }G_STMT_END
 898 </MACRO>
 899 <MACRO>
 900 <NAME>GST_META_FLAG_UNSET</NAME>
 901 #define GST_META_FLAG_UNSET(meta,flag) \
 902   G_STMT_START{ (GST_META_FLAGS(meta) &= ~(flag)); }G_STMT_END
 903 </MACRO>
 904 <ENUM>
 905 <NAME>GstMetaFlags</NAME>
 906 typedef enum {
 907   GST_META_FREEABLE             = 1 << 0,
 908 } GstMetaFlags;
 909 </ENUM>
 910 <STRUCT>
 911 <NAME>GstMeta</NAME>
 912 </STRUCT>
 913 <STRUCT>
 914 <NAME>GstMeta</NAME>
 915 struct GstMeta {
 916   /* locking */
 917   GMutex *lock;
 918
 919   /* refcounting */
 920 #ifdef HAVE_ATOMIC_H
 921   atomic_t refcount;
 922 #else
 923   int refcount;
 924 #endif
 925
 926   guint16 type;
 927   guint16 flags;
 928
 929   void *data;
 930   guint16 size;
 931 };
 932 </STRUCT>
 933 <FUNCTION>
 934 <NAME>gst_meta_new_size</NAME>
 935 <RETURNS>GstMeta  *</RETURNS>
 936 gint size
 937 </FUNCTION>
 938 <MACRO>
 939 <NAME>gst_meta_new</NAME>
 940 #define gst_meta_new(type) (type *)gst_meta_new_size(sizeof(type))
 941 </MACRO>
 942 <FUNCTION>
 943 <NAME>gst_meta_ref</NAME>
 944 <RETURNS>void  </RETURNS>
 945 GstMeta *meta
 946 </FUNCTION>
 947 <FUNCTION>
 948 <NAME>gst_meta_unref</NAME>
 949 <RETURNS>void  </RETURNS>
 950 GstMeta *meta
 951 </FUNCTION>
 952 <MACRO>
 953 <NAME>GST_TYPE_OBJECT</NAME>
 954 #define GST_TYPE_OBJECT \
 955   (gst_object_get_type())
 956 </MACRO>
 957 <MACRO>
 958 <NAME>GST_OBJECT</NAME>
 959 #define GST_OBJECT(obj) \
 960   (GTK_CHECK_CAST((obj),GST_TYPE_OBJECT,GstObject))
 961 </MACRO>
 962 <MACRO>
 963 <NAME>GST_OBJECT_CLASS</NAME>
 964 #define GST_OBJECT_CLASS(klass) \
 965   (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_OBJECT,GstObjectClass))
 966 </MACRO>
 967 <MACRO>
 968 <NAME>GST_IS_OBJECT</NAME>
 969 #define GST_IS_OBJECT(obj) \
 970   (GTK_CHECK_TYPE((obj),GST_TYPE_OBJECT))
 971 </MACRO>
 972 <MACRO>
 973 <NAME>GST_IS_OBJECT_CLASS</NAME>
 974 #define GST_IS_OBJECT_CLASS(obj) \
 975   (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_OBJECT))
 976 </MACRO>
 977 <STRUCT>
 978 <NAME>GstObject</NAME>
 979 </STRUCT>
 980 <STRUCT>
 981 <NAME>GstObjectClass</NAME>
 982 </STRUCT>
 983 <STRUCT>
 984 <NAME>GstObject</NAME>
 985 struct GstObject {
 986   GtkObject object;
 987
 988   /* have to have a refcount for the object */
 989 #ifdef HAVE_ATOMIC_H
 990   atomic_t refcount;
 991 #else
 992   int refcount;
 993 #endif
 994
 995   /* locking for all sorts of things (like the refcount) */
 996   GMutex *lock;
 997
 998   /* this objects parent */
 999   GstObject *parent;
1000 };
1001 </STRUCT>
1002 <STRUCT>
1003 <NAME>GstObjectClass</NAME>
1004 struct GstObjectClass {
1005   GtkObjectClass parent_class;
1006
1007   /* signals */
1008   void (*parent_set) (GstObject *object,GstObject *parent);
1009
1010   /* functions go here */
1011 };
1012 </STRUCT>
1013 <MACRO>
1014 <NAME>GST_FLAGS</NAME>
1015 #define GST_FLAGS(obj)                  GTK_OBJECT_FLAGS(obj)
1016 </MACRO>
1017 <MACRO>
1018 <NAME>GST_FLAG_IS_SET</NAME>
1019 #define GST_FLAG_IS_SET(obj,flag)       (GST_FLAGS (obj) & (flag))
1020 </MACRO>
1021 <MACRO>
1022 <NAME>GST_FLAG_SET</NAME>
1023 #define GST_FLAG_SET(obj,flag)          G_STMT_START{ (GST_FLAGS (obj) |= (flag)); }G_STMT_END
1024 </MACRO>
1025 <MACRO>
1026 <NAME>GST_FLAG_UNSET</NAME>
1027 #define GST_FLAG_UNSET(obj,flag)        G_STMT_START{ (GST_FLAGS (obj) &= ~(flag)); }G_STMT_END
1028 </MACRO>
1029 <MACRO>
1030 <NAME>GST_LOCK</NAME>
1031 #define GST_LOCK(obj)           (g_mutex_lock(GST_OBJECT(obj)->lock))
1032 </MACRO>
1033 <MACRO>
1034 <NAME>GST_TRYLOCK</NAME>
1035 #define GST_TRYLOCK(obj)        (g_mutex_trylock(GST_OBJECT(obj)->lock))
1036 </MACRO>
1037 <MACRO>
1038 <NAME>GST_UNLOCK</NAME>
1039 #define GST_UNLOCK(obj)         (g_mutex_unlock(GST_OBJECT(obj)->lock))
1040 </MACRO>
1041 <FUNCTION>
1042 <NAME>gst_object_get_type</NAME>
1043 <RETURNS>GtkType  </RETURNS>
1044 void
1045 </FUNCTION>
1046 <FUNCTION>
1047 <NAME>gst_object_new</NAME>
1048 <RETURNS>GstObject *</RETURNS>
1049 void
1050 </FUNCTION>
1051 <FUNCTION>
1052 <NAME>gst_object_set_parent</NAME>
1053 <RETURNS>void  </RETURNS>
1054 GstObject *object,GstObject *parent
1055 </FUNCTION>
1056 <FUNCTION>
1057 <NAME>gst_object_get_parent</NAME>
1058 <RETURNS>GstObject  *</RETURNS>
1059 GstObject *object
1060 </FUNCTION>
1061 <FUNCTION>
1062 <NAME>gst_object_unparent</NAME>
1063 <RETURNS>void  </RETURNS>
1064 GstObject *object
1065 </FUNCTION>
1066 <MACRO>
1067 <NAME>gst_object_ref</NAME>
1068 #define gst_object_ref(object) gtk_object_ref(GTK_OBJECT(object));
1069 </MACRO>
1070 <MACRO>
1071 <NAME>gst_object_unref</NAME>
1072 #define gst_object_unref(object) gtk_object_unref(GTK_OBJECT(object));
1073 </MACRO>
1074 <MACRO>
1075 <NAME>gst_object_sink</NAME>
1076 #define gst_object_sink(object) gtk_object_sink(GTK_OBJECT(object));
1077 </MACRO>
1078 <MACRO>
1079 <NAME>gst_object_destroy</NAME>
1080 #define gst_object_destroy(object) gtk_object_destroy(GTK_OBJECT(object))
1081 </MACRO>
1082 <MACRO>
1083 <NAME>GST_TYPE_PAD</NAME>
1084 #define GST_TYPE_PAD                 (gst_pad_get_type())
1085 </MACRO>
1086 <MACRO>
1087 <NAME>GST_PAD</NAME>
1088 #define GST_PAD(obj)                 (GTK_CHECK_CAST((obj),GST_TYPE_PAD,GstPad))
1089 </MACRO>
1090 <MACRO>
1091 <NAME>GST_PAD_CLASS</NAME>
1092 #define GST_PAD_CLASS(klass)         (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_PAD,GstPadClass))
1093 </MACRO>
1094 <MACRO>
1095 <NAME>GST_IS_PAD</NAME>
1096 #define GST_IS_PAD(obj)              (GTK_CHECK_TYPE((obj),GST_TYPE_PAD))
1097 </MACRO>
1098 <MACRO>
1099 <NAME>GST_IS_PAD_CLASS</NAME>
1100 #define GST_IS_PAD_CLASS(obj)        (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_PAD))
1101 </MACRO>
1102 <MACRO>
1103 <NAME>GST_PAD_CONNECTED</NAME>
1104 #define GST_PAD_CONNECTED(pad) ((pad)->peer != NULL)
1105 </MACRO>
1106 <MACRO>
1107 <NAME>GST_PAD_CAN_PULL</NAME>
1108 #define GST_PAD_CAN_PULL(pad) ((pad)->pullfunc != NULL)
1109 </MACRO>
1110 <STRUCT>
1111 <NAME>GstPad</NAME>
1112 </STRUCT>
1113 <STRUCT>
1114 <NAME>GstPadClass</NAME>
1115 </STRUCT>
1116 <USER_FUNCTION>
1117 <NAME>GstPadChainFunction</NAME>
1118 <RETURNS>void </RETURNS>
1119 GstPad *pad,GstBuffer *buf
1120 </USER_FUNCTION>
1121 <USER_FUNCTION>
1122 <NAME>GstPadPullFunction</NAME>
1123 <RETURNS>void </RETURNS>
1124 GstPad *pad
1125 </USER_FUNCTION>
1126 <USER_FUNCTION>
1127 <NAME>GstPadPushFunction</NAME>
1128 <RETURNS>void </RETURNS>
1129 GstPad *pad
1130 </USER_FUNCTION>
1131 <USER_FUNCTION>
1132 <NAME>GstPadQoSFunction</NAME>
1133 <RETURNS>void </RETURNS>
1134 GstPad *pad, glong qos_message
1135 </USER_FUNCTION>
1136 <ENUM>
1137 <NAME>GstPadDirection</NAME>
1138 typedef enum {
1139   GST_PAD_UNKNOWN,
1140   GST_PAD_SRC,
1141   GST_PAD_SINK,
1142 } GstPadDirection;
1143 </ENUM>
1144 <STRUCT>
1145 <NAME>GstPad</NAME>
1146 struct GstPad {
1147   GstObject object;
1148
1149   gchar *name;
1150   guint16 type;
1151
1152   GstPadDirection direction;
1153
1154   GstPad *peer;
1155
1156   GstBuffer *bufpen;
1157
1158   GstPadChainFunction chainfunc;
1159   GstPadPullFunction pullfunc;
1160   GstPadPushFunction pushfunc;
1161   GstPadQoSFunction qosfunc;
1162
1163   GstObject *parent;
1164   GList *ghostparents;
1165 };
1166 </STRUCT>
1167 <STRUCT>
1168 <NAME>GstPadClass</NAME>
1169 struct GstPadClass {
1170   GstObjectClass parent_class;
1171 };
1172 </STRUCT>
1173 <FUNCTION>
1174 <NAME>gst_pad_get_type</NAME>
1175 <RETURNS>GtkType  </RETURNS>
1176 void
1177 </FUNCTION>
1178 <FUNCTION>
1179 <NAME>gst_pad_new</NAME>
1180 <RETURNS>GstPad  *</RETURNS>
1181 gchar *name,GstPadDirection direction
1182 </FUNCTION>
1183 <FUNCTION>
1184 <NAME>gst_pad_destroy</NAME>
1185 <RETURNS>void  </RETURNS>
1186 GstPad *pad
1187 </FUNCTION>
1188 <FUNCTION>
1189 <NAME>gst_pad_get_direction</NAME>
1190 <RETURNS>GstPadDirection  </RETURNS>
1191 GstPad *pad
1192 </FUNCTION>
1193 <FUNCTION>
1194 <NAME>gst_pad_set_chain_function</NAME>
1195 <RETURNS>void  </RETURNS>
1196 GstPad *pad,GstPadChainFunction chain
1197 </FUNCTION>
1198 <FUNCTION>
1199 <NAME>gst_pad_set_pull_function</NAME>
1200 <RETURNS>void  </RETURNS>
1201 GstPad *pad, GstPadPullFunction pull
1202 </FUNCTION>
1203 <FUNCTION>
1204 <NAME>gst_pad_set_qos_function</NAME>
1205 <RETURNS>void  </RETURNS>
1206 GstPad *pad, GstPadQoSFunction qos
1207 </FUNCTION>
1208 <FUNCTION>
1209 <NAME>gst_pad_get_type_id</NAME>
1210 <RETURNS>guint16  </RETURNS>
1211 GstPad *pad
1212 </FUNCTION>
1213 <FUNCTION>
1214 <NAME>gst_pad_set_type_id</NAME>
1215 <RETURNS>void  </RETURNS>
1216 GstPad *pad,guint16 id
1217 </FUNCTION>
1218 <FUNCTION>
1219 <NAME>gst_pad_set_name</NAME>
1220 <RETURNS>void  </RETURNS>
1221 GstPad *pad,gchar *name
1222 </FUNCTION>
1223 <FUNCTION>
1224 <NAME>gst_pad_get_name</NAME>
1225 <RETURNS>gchar  *</RETURNS>
1226 GstPad *pad
1227 </FUNCTION>
1228 <MACRO>
1229 <NAME>gst_pad_destroy</NAME>
1230 #define gst_pad_destroy(pad) gst_object_destroy(GST_OBJECT(pad))
1231 </MACRO>
1232 <FUNCTION>
1233 <NAME>gst_pad_set_parent</NAME>
1234 <RETURNS>void  </RETURNS>
1235 GstPad *pad,GstObject *parent
1236 </FUNCTION>
1237 <FUNCTION>
1238 <NAME>gst_pad_add_ghost_parent</NAME>
1239 <RETURNS>void  </RETURNS>
1240 GstPad *pad,GstObject *parent
1241 </FUNCTION>
1242 <FUNCTION>
1243 <NAME>gst_pad_remove_ghost_parent</NAME>
1244 <RETURNS>void  </RETURNS>
1245 GstPad *pad,GstObject *parent
1246 </FUNCTION>
1247 <FUNCTION>
1248 <NAME>gst_pad_get_parent</NAME>
1249 <RETURNS>GstObject  *</RETURNS>
1250 GstPad *pad
1251 </FUNCTION>
1252 <FUNCTION>
1253 <NAME>gst_pad_get_ghost_parents</NAME>
1254 <RETURNS>GList  *</RETURNS>
1255 GstPad *pad
1256 </FUNCTION>
1257 <FUNCTION>
1258 <NAME>gst_pad_get_peer</NAME>
1259 <RETURNS>GstPad  *</RETURNS>
1260 GstPad *pad
1261 </FUNCTION>
1262 <FUNCTION>
1263 <NAME>gst_pad_connect</NAME>
1264 <RETURNS>void  </RETURNS>
1265 GstPad *srcpad,GstPad *sinkpad
1266 </FUNCTION>
1267 <FUNCTION>
1268 <NAME>gst_pad_disconnect</NAME>
1269 <RETURNS>void  </RETURNS>
1270 GstPad *srcpad,GstPad *sinkpad
1271 </FUNCTION>
1272 <FUNCTION>
1273 <NAME>gst_pad_push</NAME>
1274 <RETURNS>void  </RETURNS>
1275 GstPad *pad,GstBuffer *buffer
1276 </FUNCTION>
1277 <FUNCTION>
1278 <NAME>gst_pad_pull</NAME>
1279 <RETURNS>GstBuffer  *</RETURNS>
1280 GstPad *pad
1281 </FUNCTION>
1282 <FUNCTION>
1283 <NAME>gst_pad_handle_qos</NAME>
1284 <RETURNS>void  </RETURNS>
1285 GstPad *pad, glong qos_message
1286 </FUNCTION>
1287 <FUNCTION>
1288 <NAME>gst_pad_save_thyself</NAME>
1289 <RETURNS>xmlNodePtr  </RETURNS>
1290 GstPad *pad,xmlNodePtr parent
1291 </FUNCTION>
1292 <VARIABLE>
1293 <NAME>gst_pipeline_details</NAME>
1294 extern GstElementDetails gst_pipeline_details;
1295 </VARIABLE>
1296 <MACRO>
1297 <NAME>GST_TYPE_PIPELINE</NAME>
1298 #define GST_TYPE_PIPELINE \
1299   (gst_pipeline_get_type())
1300 </MACRO>
1301 <MACRO>
1302 <NAME>GST_PIPELINE</NAME>
1303 #define GST_PIPELINE(obj) \
1304   (GTK_CHECK_CAST((obj),GST_TYPE_PIPELINE,GstPipeline))
1305 </MACRO>
1306 <MACRO>
1307 <NAME>GST_PIPELINE_CLASS</NAME>
1308 #define GST_PIPELINE_CLASS(klass) \
1309   (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_PIPELINE,GstPipelineClass))
1310 </MACRO>
1311 <MACRO>
1312 <NAME>GST_IS_PIPELINE</NAME>
1313 #define GST_IS_PIPELINE(obj) \
1314   (GTK_CHECK_TYPE((obj),GST_TYPE_PIPELINE))
1315 </MACRO>
1316 <MACRO>
1317 <NAME>GST_IS_PIPELINE_CLASS</NAME>
1318 #define GST_IS_PIPELINE_CLASS(obj) \
1319   (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_PIPELINE))
1320 </MACRO>
1321 <STRUCT>
1322 <NAME>GstPipeline</NAME>
1323 </STRUCT>
1324 <STRUCT>
1325 <NAME>GstPipelineClass</NAME>
1326 </STRUCT>
1327 <STRUCT>
1328 <NAME>GstPipeline</NAME>
1329 struct GstPipeline {
1330   GstBin bin;
1331
1332   GstElement *src;         // we only allow one src element
1333   GList      *sinks;       // and multiple sinks
1334 };
1335 </STRUCT>
1336 <STRUCT>
1337 <NAME>GstPipelineClass</NAME>
1338 struct GstPipelineClass {
1339   GstBinClass parent_class;
1340 };
1341 </STRUCT>
1342 <FUNCTION>
1343 <NAME>gst_pipeline_get_type</NAME>
1344 <RETURNS>GtkType  </RETURNS>
1345 void
1346 </FUNCTION>
1347 <FUNCTION>
1348 <NAME>gst_pipeline_new</NAME>
1349 <RETURNS>GstElement  *</RETURNS>
1350 guchar *name
1351 </FUNCTION>
1352 <MACRO>
1353 <NAME>gst_pipeline_destroy</NAME>
1354 #define gst_pipeline_destroy(pipeline) gst_object_destroy(GST_OBJECT(pipeline))
1355 </MACRO>
1356 <FUNCTION>
1357 <NAME>gst_pipeline_autoplug</NAME>
1358 <RETURNS>gboolean  </RETURNS>
1359 GstPipeline *pipeline
1360 </FUNCTION>
1361 <FUNCTION>
1362 <NAME>gst_pipeline_add_src</NAME>
1363 <RETURNS>void  </RETURNS>
1364 GstPipeline *pipeline, GstElement *src
1365 </FUNCTION>
1366 <FUNCTION>
1367 <NAME>gst_pipeline_add_sink</NAME>
1368 <RETURNS>void  </RETURNS>
1369 GstPipeline *pipeline, GstElement *sink
1370 </FUNCTION>
1371 <FUNCTION>
1372 <NAME>gst_pipeline_iterate</NAME>
1373 <RETURNS>void  </RETURNS>
1374 GstPipeline *pipeline
1375 </FUNCTION>
1376 <STRUCT>
1377 <NAME>GstPlugin</NAME>
1378 </STRUCT>
1379 <STRUCT>
1380 <NAME>GstPluginElement</NAME>
1381 </STRUCT>
1382 <STRUCT>
1383 <NAME>GstPlugin</NAME>
1384 struct GstPlugin {
1385   gchar *name;                  /* name of the plugin */
1386   gchar *longname;              /* long name of plugin */
1387   gchar *filename;              /* filename it came from */
1388
1389   GList *types;                 /* list of types provided */
1390   GList *elements;              /* list of elements provided */
1391
1392   gboolean loaded;              /* if the plugin is in memory */
1393 };
1394 </STRUCT>
1395 <USER_FUNCTION>
1396 <NAME>GstPluginInitFunc</NAME>
1397 <RETURNS>GstPlugin *</RETURNS>
1398 GModule *module
1399 </USER_FUNCTION>
1400 <FUNCTION>
1401 <NAME>gst_plugin_new</NAME>
1402 <RETURNS>GstPlugin  *</RETURNS>
1403 gchar *name
1404 </FUNCTION>
1405 <FUNCTION>
1406 <NAME>gst_plugin_set_longname</NAME>
1407 <RETURNS>void  </RETURNS>
1408 GstPlugin *plugin,gchar *longname
1409 </FUNCTION>
1410 <FUNCTION>
1411 <NAME>gst_plugin_load_all</NAME>
1412 <RETURNS>void  </RETURNS>
1413
1414 </FUNCTION>
1415 <FUNCTION>
1416 <NAME>gst_plugin_load</NAME>
1417 <RETURNS>gboolean  </RETURNS>
1418 gchar *name
1419 </FUNCTION>
1420 <FUNCTION>
1421 <NAME>gst_library_load</NAME>
1422 <RETURNS>gboolean  </RETURNS>
1423 gchar *name
1424 </FUNCTION>
1425 <FUNCTION>
1426 <NAME>gst_plugin_load_absolute</NAME>
1427 <RETURNS>gboolean  </RETURNS>
1428 gchar *name
1429 </FUNCTION>
1430 <FUNCTION>
1431 <NAME>gst_plugin_add_factory</NAME>
1432 <RETURNS>void  </RETURNS>
1433 GstPlugin *plugin,GstElementFactory *factory
1434 </FUNCTION>
1435 <FUNCTION>
1436 <NAME>gst_plugin_add_type</NAME>
1437 <RETURNS>void  </RETURNS>
1438 GstPlugin *plugin,GstTypeFactory *factory
1439 </FUNCTION>
1440 <FUNCTION>
1441 <NAME>gst_plugin_find</NAME>
1442 <RETURNS>GstPlugin  *</RETURNS>
1443 const gchar *name
1444 </FUNCTION>
1445 <FUNCTION>
1446 <NAME>gst_plugin_get_list</NAME>
1447 <RETURNS>GList  *</RETURNS>
1448
1449 </FUNCTION>
1450 <FUNCTION>
1451 <NAME>gst_plugin_find_elementfactory</NAME>
1452 <RETURNS>GstElementFactory  *</RETURNS>
1453 gchar *name
1454 </FUNCTION>
1455 <FUNCTION>
1456 <NAME>gst_plugin_load_elementfactory</NAME>
1457 <RETURNS>GstElementFactory  *</RETURNS>
1458 gchar *name
1459 </FUNCTION>
1460 <FUNCTION>
1461 <NAME>gst_plugin_load_typefactory</NAME>
1462 <RETURNS>void  </RETURNS>
1463 gchar *mime
1464 </FUNCTION>
1465 <FUNCTION>
1466 <NAME>gst_plugin_save_thyself</NAME>
1467 <RETURNS>xmlNodePtr  </RETURNS>
1468 xmlNodePtr parent
1469 </FUNCTION>
1470 <FUNCTION>
1471 <NAME>gst_plugin_load_thyself</NAME>
1472 <RETURNS>void  </RETURNS>
1473 xmlNodePtr parent
1474 </FUNCTION>
1475 <MACRO>
1476 <NAME>GST_TYPE_SINK</NAME>
1477 #define GST_TYPE_SINK \
1478   (gst_sink_get_type())
1479 </MACRO>
1480 <MACRO>
1481 <NAME>GST_SINK</NAME>
1482 #define GST_SINK(obj) \
1483   (GTK_CHECK_CAST((obj),GST_TYPE_SINK,GstSink))
1484 </MACRO>
1485 <MACRO>
1486 <NAME>GST_SINK_CLASS</NAME>
1487 #define GST_SINK_CLASS(klass) \
1488   (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_SINK,GstSinkClass))
1489 </MACRO>
1490 <MACRO>
1491 <NAME>GST_IS_SINK</NAME>
1492 #define GST_IS_SINK(obj) \
1493   (GTK_CHECK_TYPE((obj),GST_TYPE_SINK))
1494 </MACRO>
1495 <MACRO>
1496 <NAME>GST_IS_SINK_CLASS</NAME>
1497 #define GST_IS_SINK_CLASS(obj) \
1498   (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_SINK))
1499 </MACRO>
1500 <STRUCT>
1501 <NAME>GstSink</NAME>
1502 </STRUCT>
1503 <STRUCT>
1504 <NAME>GstSinkClass</NAME>
1505 </STRUCT>
1506 <STRUCT>
1507 <NAME>GstSink</NAME>
1508 struct GstSink {
1509   GstElement element;
1510 };
1511 </STRUCT>
1512 <STRUCT>
1513 <NAME>GstSinkClass</NAME>
1514 struct GstSinkClass {
1515   GstElementClass parent_class;
1516 };
1517 </STRUCT>
1518 <FUNCTION>
1519 <NAME>gst_sink_get_type</NAME>
1520 <RETURNS>GtkType  </RETURNS>
1521 void
1522 </FUNCTION>
1523 <FUNCTION>
1524 <NAME>gst_sink_new</NAME>
1525 <RETURNS>GstObject  *</RETURNS>
1526 gchar *name
1527 </FUNCTION>
1528 <MACRO>
1529 <NAME>GST_TYPE_SRC</NAME>
1530 #define GST_TYPE_SRC \
1531   (gst_src_get_type())
1532 </MACRO>
1533 <MACRO>
1534 <NAME>GST_SRC</NAME>
1535 #define GST_SRC(obj) \
1536   (GTK_CHECK_CAST((obj),GST_TYPE_SRC,GstSrc))
1537 </MACRO>
1538 <MACRO>
1539 <NAME>GST_SRC_CLASS</NAME>
1540 #define GST_SRC_CLASS(klass) \
1541   (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_SRC,GstSrcClass))
1542 </MACRO>
1543 <MACRO>
1544 <NAME>GST_IS_SRC</NAME>
1545 #define GST_IS_SRC(obj) \
1546   (GTK_CHECK_TYPE((obj),GST_TYPE_SRC))
1547 </MACRO>
1548 <MACRO>
1549 <NAME>GST_IS_SRC_CLASS</NAME>
1550 #define GST_IS_SRC_CLASS(obj) \
1551   (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_SRC))
1552 </MACRO>
1553 <ENUM>
1554 <NAME>GstSrcFlags</NAME>
1555 typedef enum {
1556   GST_SRC_ASYNC         = 1 << 0,
1557 } GstSrcFlags;
1558 </ENUM>
1559 <MACRO>
1560 <NAME>GST_SRC_FLAGS</NAME>
1561 #define GST_SRC_FLAGS(obj) \
1562         (GST_SRC(obj)->flags)
1563 </MACRO>
1564 <MACRO>
1565 <NAME>GST_SRC_ASYNC</NAME>
1566 #define GST_SRC_ASYNC(obj) \
1567   ((GST_SRC_FLAGS(obj) & GST_SRC_ASYNC))
1568 </MACRO>
1569 <STRUCT>
1570 <NAME>GstSrc</NAME>
1571 </STRUCT>
1572 <STRUCT>
1573 <NAME>GstSrcClass</NAME>
1574 </STRUCT>
1575 <STRUCT>
1576 <NAME>GstSrc</NAME>
1577 struct GstSrc {
1578   GstElement element;
1579   gint32 flags;
1580 };
1581 </STRUCT>
1582 <STRUCT>
1583 <NAME>GstSrcClass</NAME>
1584 struct GstSrcClass {
1585   GstElementClass parent_class;
1586
1587   /* subclass functions */
1588   void (*push) (GstSrc *src);
1589   void (*push_region) (GstSrc *src,gulong offset,gulong size);
1590
1591   /* signals */
1592   void (*eos) (GstSrc *src);
1593 };
1594 </STRUCT>
1595 <MACRO>
1596 <NAME>GST_SRC_SET_FLAGS</NAME>
1597 #define GST_SRC_SET_FLAGS(src,flag) \
1598   G_STMT_START{ (GST_SRC_FLAGS (src) |= (flag)); }G_STMT_END
1599 </MACRO>
1600 <MACRO>
1601 <NAME>GST_SRC_UNSET_FLAGS</NAME>
1602 #define GST_SRC_UNSET_FLAGS(src,flag) \
1603         G_STMT_START{ (GST_SRC_FLAGS (src) &= ~(flag)); }G_STMT_END
1604 </MACRO>
1605 <FUNCTION>
1606 <NAME>gst_src_get_type</NAME>
1607 <RETURNS>GtkType  </RETURNS>
1608 void
1609 </FUNCTION>
1610 <FUNCTION>
1611 <NAME>gst_src_signal_eos</NAME>
1612 <RETURNS>void  </RETURNS>
1613 GstSrc *src
1614 </FUNCTION>
1615 <FUNCTION>
1616 <NAME>gst_src_push</NAME>
1617 <RETURNS>void  </RETURNS>
1618 GstSrc *src
1619 </FUNCTION>
1620 <FUNCTION>
1621 <NAME>gst_src_push_region</NAME>
1622 <RETURNS>void  </RETURNS>
1623 GstSrc *src,gulong offset,gulong size
1624 </FUNCTION>
1625 <MACRO>
1626 <NAME>GST_TYPE_TEE</NAME>
1627 #define GST_TYPE_TEE \
1628   (gst_tee_get_type())
1629 </MACRO>
1630 <MACRO>
1631 <NAME>GST_TEE</NAME>
1632 #define GST_TEE(obj) \
1633   (GTK_CHECK_CAST((obj),GST_TYPE_TEE,GstTee))
1634 </MACRO>
1635 <MACRO>
1636 <NAME>GST_TEE_CLASS</NAME>
1637 #define GST_TEE_CLASS(klass) \
1638   (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_TEE,GstTeeClass))
1639 </MACRO>
1640 <MACRO>
1641 <NAME>GST_IS_TEE</NAME>
1642 #define GST_IS_TEE(obj) \
1643   (GTK_CHECK_TYPE((obj),GST_TYPE_TEE))
1644 </MACRO>
1645 <MACRO>
1646 <NAME>GST_IS_TEE_CLASS</NAME>
1647 #define GST_IS_TEE_CLASS(obj) \
1648   (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_TEE)))
1649 </MACRO>
1650 <STRUCT>
1651 <NAME>GstTee</NAME>
1652 </STRUCT>
1653 <STRUCT>
1654 <NAME>GstTeeClass</NAME>
1655 </STRUCT>
1656 <STRUCT>
1657 <NAME>GstTee</NAME>
1658 struct GstTee {
1659   GstFilter filter;
1660
1661   GstPad *sinkpad;
1662
1663   gint numsrcpads;
1664   GSList *srcpads;
1665 };
1666 </STRUCT>
1667 <STRUCT>
1668 <NAME>GstTeeClass</NAME>
1669 struct GstTeeClass {
1670   GstFilterClass parent_class;
1671 };
1672 </STRUCT>
1673 <FUNCTION>
1674 <NAME>gst_tee_get_type</NAME>
1675 <RETURNS>GtkType  </RETURNS>
1676 void
1677 </FUNCTION>
1678 <FUNCTION>
1679 <NAME>gst_tee_new</NAME>
1680 <RETURNS>GstElement  *</RETURNS>
1681 gchar *name
1682 </FUNCTION>
1683 <FUNCTION>
1684 <NAME>gst_tee_chain</NAME>
1685 <RETURNS>void  </RETURNS>
1686 GstPad *pad,GstBuffer *buf
1687 </FUNCTION>
1688 <FUNCTION>
1689 <NAME>gst_tee_new_pad</NAME>
1690 <RETURNS>gchar  *</RETURNS>
1691 GstTee *tee
1692 </FUNCTION>
1693 <VARIABLE>
1694 <NAME>gst_thread_details</NAME>
1695 extern GstElementDetails gst_thread_details;
1696 </VARIABLE>
1697 <ENUM>
1698 <NAME>GstThreadState</NAME>
1699 typedef enum {
1700   GST_THREAD_CREATE             = (1 << 16),
1701   GST_THREAD_STATE_SPINNING     = (1 << 17),
1702   GST_THREAD_STATE_REAPING      = (1 << 18),
1703 } GstThreadState;
1704 </ENUM>
1705 <MACRO>
1706 <NAME>GST_TYPE_THREAD</NAME>
1707 #define GST_TYPE_THREAD \
1708   (gst_thread_get_type())
1709 </MACRO>
1710 <MACRO>
1711 <NAME>GST_THREAD</NAME>
1712 #define GST_THREAD(obj) \
1713   (GTK_CHECK_CAST((obj),GST_TYPE_THREAD,GstThread))
1714 </MACRO>
1715 <MACRO>
1716 <NAME>GST_THREAD_CLASS</NAME>
1717 #define GST_THREAD_CLASS(klass) \
1718   (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_THREAD,GstThreadClass))
1719 </MACRO>
1720 <MACRO>
1721 <NAME>GST_IS_THREAD</NAME>
1722 #define GST_IS_THREAD(obj) \
1723   (GTK_CHECK_TYPE((obj),GST_TYPE_THREAD))
1724 </MACRO>
1725 <MACRO>
1726 <NAME>GST_IS_THREAD_CLASS</NAME>
1727 #define GST_IS_THREAD_CLASS(obj) \
1728   (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_THREAD)))
1729 </MACRO>
1730 <STRUCT>
1731 <NAME>GstThread</NAME>
1732 </STRUCT>
1733 <STRUCT>
1734 <NAME>GstThreadClass</NAME>
1735 </STRUCT>
1736 <STRUCT>
1737 <NAME>GstThread</NAME>
1738 struct GstThread {
1739   GstBin bin;
1740
1741   pthread_t thread_id;          /* id of the thread, if any */
1742   GMutex *lock;                 /* thread lock/condititon pair... */
1743   GCond *cond;                  /* used to control the thread */
1744 };
1745 </STRUCT>
1746 <STRUCT>
1747 <NAME>GstThreadClass</NAME>
1748 struct GstThreadClass {
1749   GstBinClass parent_class;
1750 };
1751 </STRUCT>
1752 <FUNCTION>
1753 <NAME>gst_thread_get_type</NAME>
1754 <RETURNS>GtkType  </RETURNS>
1755 void
1756 </FUNCTION>
1757 <FUNCTION>
1758 <NAME>gst_thread_new</NAME>
1759 <RETURNS>GstElement  *</RETURNS>
1760 guchar *name
1761 </FUNCTION>
1762 <FUNCTION>
1763 <NAME>gst_thread_main_loop</NAME>
1764 <RETURNS>void  *</RETURNS>
1765 void *arg
1766 </FUNCTION>
1767 <FUNCTION>
1768 <NAME>gst_thread_iterate</NAME>
1769 <RETURNS>void  </RETURNS>
1770 GstThread *thread
1771 </FUNCTION>
1772 <FUNCTION>
1773 <NAME>gst_trace_read_tsc</NAME>
1774 <RETURNS>void  </RETURNS>
1775 guint64 *dst
1776 </FUNCTION>
1777 <STRUCT>
1778 <NAME>GstTrace</NAME>
1779 </STRUCT>
1780 <STRUCT>
1781 <NAME>GstTraceEntry</NAME>
1782 </STRUCT>
1783 <STRUCT>
1784 <NAME>GstTrace</NAME>
1785 struct GstTrace {
1786   /* where this trace is going */
1787   gchar *filename;
1788   int fd;
1789
1790   /* current buffer, size, head offset */
1791   GstTraceEntry *buf;
1792   gint bufsize;
1793   gint bufoffset;
1794 };
1795 </STRUCT>
1796 <STRUCT>
1797 <NAME>GstTraceEntry</NAME>
1798 struct GstTraceEntry {
1799   guint64 timestamp;
1800   guint32 sequence;
1801   guint32 data;
1802   gchar message[112];
1803 };
1804 </STRUCT>
1805 <FUNCTION>
1806 <NAME>gst_trace_new</NAME>
1807 <RETURNS>GstTrace  *</RETURNS>
1808 guchar *filename,gint size
1809 </FUNCTION>
1810 <FUNCTION>
1811 <NAME>gst_trace_destroy</NAME>
1812 <RETURNS>void  </RETURNS>
1813 GstTrace *trace
1814 </FUNCTION>
1815 <FUNCTION>
1816 <NAME>gst_trace_flush</NAME>
1817 <RETURNS>void  </RETURNS>
1818 GstTrace *trace
1819 </FUNCTION>
1820 <MACRO>
1821 <NAME>gst_trace_get_size</NAME>
1822 #define gst_trace_get_size(trace) ((trace)->bufsize)
1823 </MACRO>
1824 <MACRO>
1825 <NAME>gst_trace_get_offset</NAME>
1826 #define gst_trace_get_offset(trace) ((trace)->bufoffset)
1827 </MACRO>
1828 <MACRO>
1829 <NAME>gst_trace_get_remaining</NAME>
1830 #define gst_trace_get_remaining(trace) ((trace)->bufsize - (trace)->bufoffset)
1831 </MACRO>
1832 <FUNCTION>
1833 <NAME>gst_trace_set_default</NAME>
1834 <RETURNS>void  </RETURNS>
1835 GstTrace *trace
1836 </FUNCTION>
1837 <MACRO>
1838 <NAME>TRACE_ENABLE</NAME>
1839 #define TRACE_ENABLE
1840 </MACRO>
1841 <MACRO>
1842 <NAME>gst_trace_add_entry</NAME>
1843 #define gst_trace_add_entry(trace,seq,data,msg) \
1844   if (_gst_trace_on) { \
1845     _gst_trace_add_entry(trace,(guint32)seq,(guint32)data,msg); \
1846   }
1847 </MACRO>
1848 <MACRO>
1849 <NAME>gst_trace_add_entry</NAME>
1850 #define gst_trace_add_entry(trace,seq,data,msg)
1851 </MACRO>
1852 <USER_FUNCTION>
1853 <NAME>GstTypeFindFunc</NAME>
1854 <RETURNS>gboolean </RETURNS>
1855 GstBuffer *buf,gpointer priv
1856 </USER_FUNCTION>
1857 <STRUCT>
1858 <NAME>GstType</NAME>
1859 </STRUCT>
1860 <STRUCT>
1861 <NAME>GstTypeFactory</NAME>
1862 </STRUCT>
1863 <STRUCT>
1864 <NAME>GstType</NAME>
1865 struct GstType {
1866   guint16 id;                   /* type id (assigned) */
1867
1868   gchar *mime;                  /* MIME type */
1869   gchar *exts;                  /* space-delimited list of extensions */
1870
1871   GstTypeFindFunc typefindfunc; /* typefind function */
1872
1873   GList *srcs;                  /* list of src objects for this type */
1874   GList *sinks;                 /* list of sink objects for type */
1875
1876   GHashTable *converters;       /* a hashtable of factories that can convert
1877                                    from this type to destination type. The
1878                                    factories are indexed by destination type */
1879 };
1880 </STRUCT>
1881 <STRUCT>
1882 <NAME>GstTypeFactory</NAME>
1883 struct GstTypeFactory {
1884   gchar *mime;
1885   gchar *exts;
1886   GstTypeFindFunc typefindfunc;
1887 };
1888 </STRUCT>
1889 <FUNCTION>
1890 <NAME>gst_type_register</NAME>
1891 <RETURNS>guint16  </RETURNS>
1892 GstTypeFactory *factory
1893 </FUNCTION>
1894 <FUNCTION>
1895 <NAME>gst_type_find_by_mime</NAME>
1896 <RETURNS>guint16  </RETURNS>
1897 gchar *mime
1898 </FUNCTION>
1899 <FUNCTION>
1900 <NAME>gst_type_find_by_ext</NAME>
1901 <RETURNS>guint16  </RETURNS>
1902 gchar *ext
1903 </FUNCTION>
1904 <FUNCTION>
1905 <NAME>gst_type_add_src</NAME>
1906 <RETURNS>void  </RETURNS>
1907 guint16 id,GstElementFactory *src
1908 </FUNCTION>
1909 <FUNCTION>
1910 <NAME>gst_type_add_sink</NAME>
1911 <RETURNS>void  </RETURNS>
1912 guint16 id,GstElementFactory *sink
1913 </FUNCTION>
1914 <FUNCTION>
1915 <NAME>gst_type_get_srcs</NAME>
1916 <RETURNS>GList  *</RETURNS>
1917 guint16 id
1918 </FUNCTION>
1919 <FUNCTION>
1920 <NAME>gst_type_get_sinks</NAME>
1921 <RETURNS>GList  *</RETURNS>
1922 guint16 id
1923 </FUNCTION>
1924 <FUNCTION>
1925 <NAME>gst_type_find_by_id</NAME>
1926 <RETURNS>GstType  *</RETURNS>
1927 guint16 id
1928 </FUNCTION>
1929 <FUNCTION>
1930 <NAME>gst_type_get_sink_to_src</NAME>
1931 <RETURNS>GList  *</RETURNS>
1932 guint16 sinkid, guint16 srcid
1933 </FUNCTION>
1934 <FUNCTION>
1935 <NAME>gst_type_get_list</NAME>
1936 <RETURNS>GList  *</RETURNS>
1937
1938 </FUNCTION>
1939 <FUNCTION>
1940 <NAME>gst_type_dump</NAME>
1941 <RETURNS>void  </RETURNS>
1942
1943 </FUNCTION>
1944 <FUNCTION>
1945 <NAME>gst_type_save_thyself</NAME>
1946 <RETURNS>xmlNodePtr  </RETURNS>
1947 GstType *type, xmlNodePtr parent
1948 </FUNCTION>
1949 <FUNCTION>
1950 <NAME>gst_type_load_thyself</NAME>
1951 <RETURNS>guint16  </RETURNS>
1952 xmlNodePtr parent
1953 </FUNCTION>
1954 <FUNCTION>
1955 <NAME>gst_typefactory_save_thyself</NAME>
1956 <RETURNS>xmlNodePtr  </RETURNS>
1957 GstTypeFactory *factory, xmlNodePtr parent
1958 </FUNCTION>
1959 <FUNCTION>
1960 <NAME>gst_typefactory_load_thyself</NAME>
1961 <RETURNS>GstTypeFactory  *</RETURNS>
1962 xmlNodePtr parent
1963 </FUNCTION>
1964 <FUNCTION>
1965 <NAME>gst_util_get_int_arg</NAME>
1966 <RETURNS>gint  </RETURNS>
1967 GtkObject *object,guchar *argname
1968 </FUNCTION>
1969 <FUNCTION>
1970 <NAME>gst_util_get_long_arg</NAME>
1971 <RETURNS>glong  </RETURNS>
1972 GtkObject *object,guchar *argname
1973 </FUNCTION>
1974 <FUNCTION>
1975 <NAME>gst_util_get_float_arg</NAME>
1976 <RETURNS>gfloat  </RETURNS>
1977 GtkObject *object,guchar *argname
1978 </FUNCTION>
1979 <FUNCTION>
1980 <NAME>gst_util_get_double_arg</NAME>
1981 <RETURNS>gdouble  </RETURNS>
1982 GtkObject *object,guchar *argname
1983 </FUNCTION>
1984 <FUNCTION>
1985 <NAME>gst_util_get_string_arg</NAME>
1986 <RETURNS>guchar  *</RETURNS>
1987 GtkObject *object,guchar *argname
1988 </FUNCTION>
1989 <FUNCTION>
1990 <NAME>gst_util_get_pointer_arg</NAME>
1991 <RETURNS>gpointer  </RETURNS>
1992 GtkObject *object,guchar *argname
1993 </FUNCTION>
1994 <FUNCTION>
1995 <NAME>gst_util_get_widget_arg</NAME>
1996 <RETURNS>GtkWidget  *</RETURNS>
1997 GtkObject *object,guchar *argname
1998 </FUNCTION>
1999 <FUNCTION>
2000 <NAME>gst_util_dump_mem</NAME>
2001 <RETURNS>void  </RETURNS>
2002 guchar *mem, guint size
2003 </FUNCTION>
2004 <FUNCTION>
2005 <NAME>gst_xml_write</NAME>
2006 <RETURNS>xmlDocPtr  </RETURNS>
2007 GstElement *element
2008 </FUNCTION>
2009 <MACRO>
2010 <NAME>GST_BUFFER_POOL</NAME>
2011 #define GST_BUFFER_POOL(buf) \
2012   ((GstBufferPool *)(buf))
2013 </MACRO>
2014 <STRUCT>
2015 <NAME>GstBufferPool</NAME>
2016 </STRUCT>
2017 <USER_FUNCTION>
2018 <NAME>GstBufferPoolCreateFunction</NAME>
2019 <RETURNS>GstBuffer *</RETURNS>
2020 GstBufferPool *pool, gpointer user_data
2021 </USER_FUNCTION>
2022 <USER_FUNCTION>
2023 <NAME>GstBufferPoolDestroyFunction</NAME>
2024 <RETURNS>void </RETURNS>
2025 GstBufferPool *pool, GstBuffer *buffer, gpointer user_data
2026 </USER_FUNCTION>
2027 <STRUCT>
2028 <NAME>GstBufferPool</NAME>
2029 struct GstBufferPool {
2030   /* will be called when a new buffer is to be created */
2031   GstBufferPoolCreateFunction new_buffer;
2032   /* user data to pass with the new_buffer function */
2033   gpointer new_user_data;
2034
2035   gpointer destroy_user_data;
2036   GstBufferPoolDestroyFunction destroy_buffer;
2037 };
2038 </STRUCT>
2039 <FUNCTION>
2040 <NAME>gst_buffer_pool_new</NAME>
2041 <RETURNS>GstBufferPool  *</RETURNS>
2042
2043 </FUNCTION>
2044 <FUNCTION>
2045 <NAME>gst_buffer_pool_new_buffer</NAME>
2046 <RETURNS>GstBuffer  *</RETURNS>
2047 GstBufferPool *pool
2048 </FUNCTION>
2049 <FUNCTION>
2050 <NAME>gst_buffer_pool_destroy_buffer</NAME>
2051 <RETURNS>void  </RETURNS>
2052 GstBufferPool *pool, GstBuffer *buffer
2053 </FUNCTION>
2054 <FUNCTION>
2055 <NAME>gst_buffer_pool_set_create_function</NAME>
2056 <RETURNS>void  </RETURNS>
2057 GstBufferPool *pool, GstBufferPoolCreateFunction create, gpointer user_data
2058 </FUNCTION>
2059 <FUNCTION>
2060 <NAME>gst_buffer_pool_set_destroy_function</NAME>
2061 <RETURNS>void  </RETURNS>
2062 GstBufferPool *pool, GstBufferPoolDestroyFunction destroy, gpointer user_data
2063 </FUNCTION>
2064 <FUNCTION>
2065 <NAME>gst_buffer_pool_destroy</NAME>
2066 <RETURNS>void  </RETURNS>
2067 GstBufferPool *pool
2068 </FUNCTION>
2069 <MACRO>
2070 <NAME>GST_CPU_FLAG_MMX</NAME>
2071 #define  GST_CPU_FLAG_MMX               (1 << 0)
2072 </MACRO>
2073 <MACRO>
2074 <NAME>GST_CPU_FLAG_SSE</NAME>
2075 #define  GST_CPU_FLAG_SSE               (1 << 1)
2076 </MACRO>
2077 <FUNCTION>
2078 <NAME>gst_cpu_get_flags</NAME>
2079 <RETURNS>guint32  </RETURNS>
2080
2081 </FUNCTION>
2082 <MACRO>
2083 <NAME>GET_SP</NAME>
2084 #define GET_SP(target) \
2085   __asm__("movl %%esp, %0" : "=m"(target) : : "esp", "ebp");
2086 </MACRO>
2087 <MACRO>
2088 <NAME>SET_SP</NAME>
2089 #define SET_SP(source) \
2090   __asm__("movl %0, %%esp\n" : "=m"(thread->sp));
2091 </MACRO>
2092 <MACRO>
2093 <NAME>JUMP</NAME>
2094 #define JUMP(target) \
2095     __asm__("jmp " SYMBOL_NAME_STR(cothread_stub))
2096 </MACRO>
2097 <MACRO>
2098 <NAME>GET_SP</NAME>
2099 #define GET_SP(target) \
2100         __asm__("stw 1,%0" : "=m"(target) : : "r1");
2101 </MACRO>
2102 <MACRO>
2103 <NAME>SET_SP</NAME>
2104 #define SET_SP(source) \
2105         __asm__("lwz 1,%0" : "=m"(source))
2106 </MACRO>
2107 <MACRO>
2108 <NAME>JUMP</NAME>
2109 #define JUMP(target) \
2110     __asm__("b " SYMBOL_NAME_STR(cothread_stub))
2111 </MACRO>
2112 <MACRO>
2113 <NAME>GST_TYPE_ASYNCDISKSRC</NAME>
2114 #define GST_TYPE_ASYNCDISKSRC \
2115   (gst_asyncdisksrc_get_type())
2116 </MACRO>
2117 <MACRO>
2118 <NAME>GST_ASYNCDISKSRC</NAME>
2119 #define GST_ASYNCDISKSRC(obj) \
2120   (GTK_CHECK_CAST((obj),GST_TYPE_ASYNCDISKSRC,GstAsyncDiskSrc))
2121 </MACRO>
2122 <MACRO>
2123 <NAME>GST_ASYNCDISKSRC_CLASS</NAME>
2124 #define GST_ASYNCDISKSRC_CLASS(klass) \
2125   (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_ASYNCDISKSRC,GstAsyncDiskSrcClass))
2126 </MACRO>
2127 <MACRO>
2128 <NAME>GST_IS_ASYNCDISKSRC</NAME>
2129 #define GST_IS_ASYNCDISKSRC(obj) \
2130   (GTK_CHECK_TYPE((obj),GST_TYPE_ASYNCDISKSRC))
2131 </MACRO>
2132 <MACRO>
2133 <NAME>GST_IS_ASYNCDISKSRC_CLASS</NAME>
2134 #define GST_IS_ASYNCDISKSRC_CLASS(obj) \
2135   (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_ASYNCDISKSRC))
2136 </MACRO>
2137 <ENUM>
2138 <NAME>GstAsyncDiskSrcFlags</NAME>
2139 typedef enum {
2140   GST_ASYNCDISKSRC_OPEN = (1 << 16),
2141 } GstAsyncDiskSrcFlags;
2142 </ENUM>
2143 <STRUCT>
2144 <NAME>GstAsyncDiskSrc</NAME>
2145 </STRUCT>
2146 <STRUCT>
2147 <NAME>GstAsyncDiskSrcClass</NAME>
2148 </STRUCT>
2149 <STRUCT>
2150 <NAME>GstAsyncDiskSrc</NAME>
2151 struct GstAsyncDiskSrc {
2152   GstSrc src;
2153   /* pads */
2154   GstPad *srcpad;
2155
2156   /* filename */
2157   gchar *filename;
2158   /* fd */
2159   gint fd;
2160
2161   /* mapping parameters */
2162   gulong size;                          /* how long is the file? */
2163   guchar *map;                          /* where the file is mapped to */
2164
2165   /* details for fallback synchronous read */
2166   gulong curoffset;                     /* current offset in file */
2167   gulong bytes_per_read;                /* bytes per read */
2168
2169   gulong seq;                           /* buffer sequence number */
2170 };
2171 </STRUCT>
2172 <STRUCT>
2173 <NAME>GstAsyncDiskSrcClass</NAME>
2174 struct GstAsyncDiskSrcClass {
2175   GstSrcClass parent_class;
2176 };
2177 </STRUCT>
2178 <FUNCTION>
2179 <NAME>gst_asyncdisksrc_get_type</NAME>
2180 <RETURNS>GtkType  </RETURNS>
2181 void
2182 </FUNCTION>
2183 <MACRO>
2184 <NAME>GST_TYPE_AUDIOSINK</NAME>
2185 #define GST_TYPE_AUDIOSINK \
2186   (gst_audiosink_get_type())
2187 </MACRO>
2188 <MACRO>
2189 <NAME>GST_AUDIOSINK</NAME>
2190 #define GST_AUDIOSINK(obj) \
2191   (GTK_CHECK_CAST((obj),GST_TYPE_AUDIOSINK,GstAudioSink))
2192 </MACRO>
2193 <MACRO>
2194 <NAME>GST_AUDIOSINK_CLASS</NAME>
2195 #define GST_AUDIOSINK_CLASS(klass) \
2196   (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_AUDIOSINK,GstAudioSinkClass))
2197 </MACRO>
2198 <MACRO>
2199 <NAME>GST_IS_AUDIOSINK</NAME>
2200 #define GST_IS_AUDIOSINK(obj) \
2201   (GTK_CHECK_TYPE((obj),GST_TYPE_AUDIOSINK))
2202 </MACRO>
2203 <MACRO>
2204 <NAME>GST_IS_AUDIOSINK_CLASS</NAME>
2205 #define GST_IS_AUDIOSINK_CLASS(obj) \
2206   (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_AUDIOSINK))
2207 </MACRO>
2208 <ENUM>
2209 <NAME>GstAudioSinkFlags</NAME>
2210 typedef enum {
2211   GST_AUDIOSINK_OPEN            = (1 << 16),
2212 } GstAudioSinkFlags;
2213 </ENUM>
2214 <STRUCT>
2215 <NAME>GstAudioSink</NAME>
2216 </STRUCT>
2217 <STRUCT>
2218 <NAME>GstAudioSinkClass</NAME>
2219 </STRUCT>
2220 <STRUCT>
2221 <NAME>GstAudioSink</NAME>
2222 struct GstAudioSink {
2223   GstSink sink;
2224
2225   GstPad *sinkpad;
2226
2227   //GstClockTime clocktime;
2228   GstClock *clock;
2229   /* soundcard state */
2230   int fd;
2231   int caps; /* the capabilities */
2232   gint format;
2233   gint channels;
2234   gint frequency;
2235   gboolean mute;
2236 };
2237 </STRUCT>
2238 <STRUCT>
2239 <NAME>GstAudioSinkClass</NAME>
2240 struct GstAudioSinkClass {
2241   GstSinkClass parent_class;
2242
2243   /* signals */
2244   void (*handoff) (GstElement *element,GstPad *pad);
2245 };
2246 </STRUCT>
2247 <FUNCTION>
2248 <NAME>gst_audiosink_get_type</NAME>
2249 <RETURNS>GtkType  </RETURNS>
2250 void
2251 </FUNCTION>
2252 <FUNCTION>
2253 <NAME>gst_audiosink_factory_init</NAME>
2254 <RETURNS>gboolean  </RETURNS>
2255 GstElementFactory *factory
2256 </FUNCTION>
2257 <MACRO>
2258 <NAME>GST_TYPE_AUDIOSRC</NAME>
2259 #define GST_TYPE_AUDIOSRC \
2260   (gst_audiosrc_get_type())
2261 </MACRO>
2262 <MACRO>
2263 <NAME>GST_AUDIOSRC</NAME>
2264 #define GST_AUDIOSRC(obj) \
2265   (GTK_CHECK_CAST((obj),GST_TYPE_AUDIOSRC,GstAudioSrc))
2266 </MACRO>
2267 <MACRO>
2268 <NAME>GST_AUDIOSRC_CLASS</NAME>
2269 #define GST_AUDIOSRC_CLASS(klass) \
2270   (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_AUDIOSRC,GstAudioSrcClass))
2271 </MACRO>
2272 <MACRO>
2273 <NAME>GST_IS_AUDIOSRC</NAME>
2274 #define GST_IS_AUDIOSRC(obj) \
2275   (GTK_CHECK_TYPE((obj),GST_TYPE_AUDIOSRC))
2276 </MACRO>
2277 <MACRO>
2278 <NAME>GST_IS_AUDIOSRC_CLASS</NAME>
2279 #define GST_IS_AUDIOSRC_CLASS(obj) \
2280   (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_AUDIOSRC)))
2281 </MACRO>
2282 <ENUM>
2283 <NAME>GstAudioSrcFlags</NAME>
2284 typedef enum {
2285   GST_AUDIOSRC_OPEN             = (1 < 16),
2286 } GstAudioSrcFlags;
2287 </ENUM>
2288 <STRUCT>
2289 <NAME>GstAudioSrc</NAME>
2290 </STRUCT>
2291 <STRUCT>
2292 <NAME>GstAudioSrcClass</NAME>
2293 </STRUCT>
2294 <STRUCT>
2295 <NAME>GstAudioSrc</NAME>
2296 struct GstAudioSrc {
2297   GstSrc src;
2298
2299   /* pads */
2300   GstPad *srcpad;
2301
2302   /* sound card */
2303   gint fd;
2304
2305   /* audio parameters */
2306   gint format;
2307   gint channels;
2308   gint frequency;
2309
2310   /* blocking */
2311   gulong curoffset;
2312   gulong bytes_per_read;
2313
2314   gulong seq;
2315
2316   MetaAudioRaw *meta;
2317 };
2318 </STRUCT>
2319 <STRUCT>
2320 <NAME>GstAudioSrcClass</NAME>
2321 struct GstAudioSrcClass {
2322   GstSrcClass parent_class;
2323 };
2324 </STRUCT>
2325 <FUNCTION>
2326 <NAME>gst_audiosrc_get_type</NAME>
2327 <RETURNS>GtkType  </RETURNS>
2328 void
2329 </FUNCTION>
2330 <VARIABLE>
2331 <NAME>gst_disksrc_details</NAME>
2332 extern GstElementDetails gst_disksrc_details;
2333 </VARIABLE>
2334 <MACRO>
2335 <NAME>GST_TYPE_DISKSRC</NAME>
2336 #define GST_TYPE_DISKSRC \
2337   (gst_disksrc_get_type())
2338 </MACRO>
2339 <MACRO>
2340 <NAME>GST_DISKSRC</NAME>
2341 #define GST_DISKSRC(obj) \
2342   (GTK_CHECK_CAST((obj),GST_TYPE_DISKSRC,GstDiskSrc))
2343 </MACRO>
2344 <MACRO>
2345 <NAME>GST_DISKSRC_CLASS</NAME>
2346 #define GST_DISKSRC_CLASS(klass) \
2347   (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_DISKSRC,GstDiskSrcClass))
2348 </MACRO>
2349 <MACRO>
2350 <NAME>GST_IS_DISKSRC</NAME>
2351 #define GST_IS_DISKSRC(obj) \
2352   (GTK_CHECK_TYPE((obj),GST_TYPE_DISKSRC))
2353 </MACRO>
2354 <MACRO>
2355 <NAME>GST_IS_DISKSRC_CLASS</NAME>
2356 #define GST_IS_DISKSRC_CLASS(obj) \
2357   (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_DISKSRC))
2358 </MACRO>
2359 <ENUM>
2360 <NAME>GstDiskSrcFlags</NAME>
2361 typedef enum {
2362   GST_DISKSRC_OPEN              = (1 << 16),
2363 } GstDiskSrcFlags;
2364 </ENUM>
2365 <STRUCT>
2366 <NAME>GstDiskSrc</NAME>
2367 </STRUCT>
2368 <STRUCT>
2369 <NAME>GstDiskSrcClass</NAME>
2370 </STRUCT>
2371 <STRUCT>
2372 <NAME>GstDiskSrc</NAME>
2373 struct GstDiskSrc {
2374   GstSrc src;
2375   /* pads */
2376   GstPad *srcpad;
2377
2378   /* file state */
2379   gchar *filename;
2380   gint fd;
2381
2382   gulong curoffset;                     /* current offset in file */
2383   gulong bytes_per_read;                /* bytes per read */
2384   gboolean new_seek;
2385
2386   gulong seq;                           /* buffer sequence number */
2387   gulong size;
2388 };
2389 </STRUCT>
2390 <STRUCT>
2391 <NAME>GstDiskSrcClass</NAME>
2392 struct GstDiskSrcClass {
2393   GstSrcClass parent_class;
2394 };
2395 </STRUCT>
2396 <FUNCTION>
2397 <NAME>gst_disksrc_get_type</NAME>
2398 <RETURNS>GtkType  </RETURNS>
2399 void
2400 </FUNCTION>
2401 <MACRO>
2402 <NAME>GST_TYPE_ESDSINK</NAME>
2403 #define GST_TYPE_ESDSINK \
2404   (gst_esdsink_get_type())
2405 </MACRO>
2406 <MACRO>
2407 <NAME>GST_ESDSINK</NAME>
2408 #define GST_ESDSINK(obj) \
2409   (GTK_CHECK_CAST((obj),GST_TYPE_ESDSINK,GstEsdSink))
2410 </MACRO>
2411 <MACRO>
2412 <NAME>GST_ESDSINK_CLASS</NAME>
2413 #define GST_ESDSINK_CLASS(klass) \
2414   (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_ESDSINK,GstEsdSinkClass))
2415 </MACRO>
2416 <MACRO>
2417 <NAME>GST_IS_ESDSINK</NAME>
2418 #define GST_IS_ESDSINK(obj) \
2419   (GTK_CHECK_TYPE((obj),GST_TYPE_ESDSINK))
2420 </MACRO>
2421 <MACRO>
2422 <NAME>GST_IS_ESDSINK_CLASS</NAME>
2423 #define GST_IS_ESDSINK_CLASS(obj) \
2424   (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_ESDSINK)))
2425 </MACRO>
2426 <STRUCT>
2427 <NAME>GstEsdSink</NAME>
2428 </STRUCT>
2429 <STRUCT>
2430 <NAME>GstEsdSinkClass</NAME>
2431 </STRUCT>
2432 <STRUCT>
2433 <NAME>GstEsdSink</NAME>
2434 struct GstEsdSink {
2435   GstFilter filter;
2436
2437   GstPad *sinkpad;
2438
2439   /* soundcard state */
2440
2441   int fd;
2442   gint format;
2443   gint channels;
2444   gint frequency;
2445 };
2446 </STRUCT>
2447 <STRUCT>
2448 <NAME>GstEsdSinkClass</NAME>
2449 struct GstEsdSinkClass {
2450   GstFilterClass parent_class;
2451
2452   /* signals */
2453   void (*handoff) (GstElement *element,GstPad *pad);
2454 };
2455 </STRUCT>
2456 <FUNCTION>
2457 <NAME>gst_esdsink_get_type</NAME>
2458 <RETURNS>GtkType  </RETURNS>
2459 void
2460 </FUNCTION>
2461 <MACRO>
2462 <NAME>GST_TYPE_FAKESINK</NAME>
2463 #define GST_TYPE_FAKESINK \
2464   (gst_fakesink_get_type())
2465 </MACRO>
2466 <MACRO>
2467 <NAME>GST_FAKESINK</NAME>
2468 #define GST_FAKESINK(obj) \
2469   (GTK_CHECK_CAST((obj),GST_TYPE_FAKESINK,GstFakeSink))
2470 </MACRO>
2471 <MACRO>
2472 <NAME>GST_FAKESINK_CLASS</NAME>
2473 #define GST_FAKESINK_CLASS(klass) \
2474   (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_FAKESINK,GstFakeSinkClass))
2475 </MACRO>
2476 <MACRO>
2477 <NAME>GST_IS_FAKESINK</NAME>
2478 #define GST_IS_FAKESINK(obj) \
2479   (GTK_CHECK_TYPE((obj),GST_TYPE_FAKESINK))
2480 </MACRO>
2481 <MACRO>
2482 <NAME>GST_IS_FAKESINK_CLASS</NAME>
2483 #define GST_IS_FAKESINK_CLASS(obj) \
2484   (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_FAKESINK)))
2485 </MACRO>
2486 <STRUCT>
2487 <NAME>GstFakeSink</NAME>
2488 </STRUCT>
2489 <STRUCT>
2490 <NAME>GstFakeSinkClass</NAME>
2491 </STRUCT>
2492 <STRUCT>
2493 <NAME>GstFakeSink</NAME>
2494 struct GstFakeSink {
2495   GstSink sink;
2496
2497   GstPad *sinkpad;
2498 };
2499 </STRUCT>
2500 <STRUCT>
2501 <NAME>GstFakeSinkClass</NAME>
2502 struct GstFakeSinkClass {
2503   GstSinkClass parent_class;
2504 };
2505 </STRUCT>
2506 <FUNCTION>
2507 <NAME>gst_fakesink_get_type</NAME>
2508 <RETURNS>GtkType  </RETURNS>
2509 void
2510 </FUNCTION>
2511 <MACRO>
2512 <NAME>GST_TYPE_FAKESRC</NAME>
2513 #define GST_TYPE_FAKESRC \
2514   (gst_fakesrc_get_type())
2515 </MACRO>
2516 <MACRO>
2517 <NAME>GST_FAKESRC</NAME>
2518 #define GST_FAKESRC(obj) \
2519   (GTK_CHECK_CAST((obj),GST_TYPE_FAKESRC,GstFakeSrc))
2520 </MACRO>
2521 <MACRO>
2522 <NAME>GST_FAKESRC_CLASS</NAME>
2523 #define GST_FAKESRC_CLASS(klass) \
2524   (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_FAKESRC,GstFakeSrcClass))
2525 </MACRO>
2526 <MACRO>
2527 <NAME>GST_IS_FAKESRC</NAME>
2528 #define GST_IS_FAKESRC(obj) \
2529   (GTK_CHECK_TYPE((obj),GST_TYPE_FAKESRC))
2530 </MACRO>
2531 <MACRO>
2532 <NAME>GST_IS_FAKESRC_CLASS</NAME>
2533 #define GST_IS_FAKESRC_CLASS(obj) \
2534   (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_FAKESRC)))
2535 </MACRO>
2536 <STRUCT>
2537 <NAME>GstFakeSrc</NAME>
2538 </STRUCT>
2539 <STRUCT>
2540 <NAME>GstFakeSrcClass</NAME>
2541 </STRUCT>
2542 <STRUCT>
2543 <NAME>GstFakeSrc</NAME>
2544 struct GstFakeSrc {
2545   GstSrc src;
2546
2547   GstPad *srcpad;
2548 };
2549 </STRUCT>
2550 <STRUCT>
2551 <NAME>GstFakeSrcClass</NAME>
2552 struct GstFakeSrcClass {
2553   GstSrcClass parent_class;
2554 };
2555 </STRUCT>
2556 <FUNCTION>
2557 <NAME>gst_fakesrc_get_type</NAME>
2558 <RETURNS>GtkType  </RETURNS>
2559 void
2560 </FUNCTION>
2561 <MACRO>
2562 <NAME>GST_TYPE_FDSINK</NAME>
2563 #define GST_TYPE_FDSINK \
2564   (gst_fdsink_get_type())
2565 </MACRO>
2566 <MACRO>
2567 <NAME>GST_FDSINK</NAME>
2568 #define GST_FDSINK(obj) \
2569   (GTK_CHECK_CAST((obj),GST_TYPE_FDSINK,GstFdSink))
2570 </MACRO>
2571 <MACRO>
2572 <NAME>GST_FDSINK_CLASS</NAME>
2573 #define GST_FDSINK_CLASS(klass) \
2574   (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_FDSINK,GstFdSinkClass))
2575 </MACRO>
2576 <MACRO>
2577 <NAME>GST_IS_FDSINK</NAME>
2578 #define GST_IS_FDSINK(obj) \
2579   (GTK_CHECK_TYPE((obj),GST_TYPE_FDSINK))
2580 </MACRO>
2581 <MACRO>
2582 <NAME>GST_IS_FDSINK_CLASS</NAME>
2583 #define GST_IS_FDSINK_CLASS(obj) \
2584   (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_FDSINK)))
2585 </MACRO>
2586 <STRUCT>
2587 <NAME>GstFdSink</NAME>
2588 </STRUCT>
2589 <STRUCT>
2590 <NAME>GstFdSinkClass</NAME>
2591 </STRUCT>
2592 <STRUCT>
2593 <NAME>GstFdSink</NAME>
2594 struct GstFdSink {
2595   GstSink sink;
2596
2597   GstPad *sinkpad;
2598
2599   int fd;
2600 };
2601 </STRUCT>
2602 <STRUCT>
2603 <NAME>GstFdSinkClass</NAME>
2604 struct GstFdSinkClass {
2605   GstSinkClass parent_class;
2606 };
2607 </STRUCT>
2608 <FUNCTION>
2609 <NAME>gst_fdsink_get_type</NAME>
2610 <RETURNS>GtkType  </RETURNS>
2611 void
2612 </FUNCTION>
2613 <MACRO>
2614 <NAME>GST_TYPE_FDSRC</NAME>
2615 #define GST_TYPE_FDSRC \
2616   (gst_fdsrc_get_type())
2617 </MACRO>
2618 <MACRO>
2619 <NAME>GST_FDSRC</NAME>
2620 #define GST_FDSRC(obj) \
2621   (GTK_CHECK_CAST((obj),GST_TYPE_FDSRC,GstFdSrc))
2622 </MACRO>
2623 <MACRO>
2624 <NAME>GST_FDSRC_CLASS</NAME>
2625 #define GST_FDSRC_CLASS(klass) \
2626   (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_FDSRC,GstFdSrcClass))
2627 </MACRO>
2628 <MACRO>
2629 <NAME>GST_IS_FDSRC</NAME>
2630 #define GST_IS_FDSRC(obj) \
2631   (GTK_CHECK_TYPE((obj),GST_TYPE_FDSRC))
2632 </MACRO>
2633 <MACRO>
2634 <NAME>GST_IS_FDSRC_CLASS</NAME>
2635 #define GST_IS_FDSRC_CLASS(obj) \
2636   (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_FDSRC)))
2637 </MACRO>
2638 <STRUCT>
2639 <NAME>GstFdSrc</NAME>
2640 </STRUCT>
2641 <STRUCT>
2642 <NAME>GstFdSrcClass</NAME>
2643 </STRUCT>
2644 <STRUCT>
2645 <NAME>GstFdSrc</NAME>
2646 struct GstFdSrc {
2647   GstSrc src;
2648   /* pads */
2649   GstPad *srcpad;
2650
2651   /* fd */
2652   gint fd;
2653
2654   gulong curoffset;                     /* current offset in file */
2655   gulong bytes_per_read;                /* bytes per read */
2656
2657   gulong seq;                           /* buffer sequence number */
2658 };
2659 </STRUCT>
2660 <STRUCT>
2661 <NAME>GstFdSrcClass</NAME>
2662 struct GstFdSrcClass {
2663   GstSrcClass parent_class;
2664 };
2665 </STRUCT>
2666 <FUNCTION>
2667 <NAME>gst_fdsrc_get_type</NAME>
2668 <RETURNS>GtkType  </RETURNS>
2669 void
2670 </FUNCTION>
2671 <MACRO>
2672 <NAME>GST_TYPE_HTTPSRC</NAME>
2673 #define GST_TYPE_HTTPSRC \
2674   (gst_httpsrc_get_type())
2675 </MACRO>
2676 <MACRO>
2677 <NAME>GST_HTTPSRC</NAME>
2678 #define GST_HTTPSRC(obj) \
2679   (GTK_CHECK_CAST((obj),GST_TYPE_HTTPSRC,GstHttpSrc))
2680 </MACRO>
2681 <MACRO>
2682 <NAME>GST_HTTPSRC_CLASS</NAME>
2683 #define GST_HTTPSRC_CLASS(klass) \
2684   (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_HTTPSRC,GstHttpSrcClass))
2685 </MACRO>
2686 <MACRO>
2687 <NAME>GST_IS_HTTPSRC</NAME>
2688 #define GST_IS_HTTPSRC(obj) \
2689   (GTK_CHECK_TYPE((obj),GST_TYPE_HTTPSRC))
2690 </MACRO>
2691 <MACRO>
2692 <NAME>GST_IS_HTTPSRC_CLASS</NAME>
2693 #define GST_IS_HTTPSRC_CLASS(obj) \
2694   (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_HTTPSRC)))
2695 </MACRO>
2696 <ENUM>
2697 <NAME>GstHttpSrcFlags</NAME>
2698 typedef enum {
2699   GST_HTTPSRC_OPEN              = (1 << 16),
2700 } GstHttpSrcFlags;
2701 </ENUM>
2702 <STRUCT>
2703 <NAME>GstHttpSrc</NAME>
2704 </STRUCT>
2705 <STRUCT>
2706 <NAME>GstHttpSrcClass</NAME>
2707 </STRUCT>
2708 <STRUCT>
2709 <NAME>GstHttpSrc</NAME>
2710 struct GstHttpSrc {
2711   GstSrc src;
2712   /* pads */
2713   GstPad *srcpad;
2714
2715   gchar *url;
2716   ghttp_request *request;
2717   int fd;
2718
2719   gulong curoffset;                     /* current offset in file */
2720   gulong bytes_per_read;                /* bytes per read */
2721 };
2722 </STRUCT>
2723 <STRUCT>
2724 <NAME>GstHttpSrcClass</NAME>
2725 struct GstHttpSrcClass {
2726   GstSrcClass parent_class;
2727 };
2728 </STRUCT>
2729 <FUNCTION>
2730 <NAME>gst_httpsrc_get_type</NAME>
2731 <RETURNS>GtkType  </RETURNS>
2732 void
2733 </FUNCTION>
2734 <MACRO>
2735 <NAME>GST_TYPE_IDENTITY</NAME>
2736 #define GST_TYPE_IDENTITY \
2737   (gst_identity_get_type())
2738 </MACRO>
2739 <MACRO>
2740 <NAME>GST_IDENTITY</NAME>
2741 #define GST_IDENTITY(obj) \
2742   (GTK_CHECK_CAST((obj),GST_TYPE_IDENTITY,GstIdentity))
2743 </MACRO>
2744 <MACRO>
2745 <NAME>GST_IDENTITY_CLASS</NAME>
2746 #define GST_IDENTITY_CLASS(klass) \
2747   (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_IDENTITY,GstIdentityClass))
2748 </MACRO>
2749 <MACRO>
2750 <NAME>GST_IS_IDENTITY</NAME>
2751 #define GST_IS_IDENTITY(obj) \
2752   (GTK_CHECK_TYPE((obj),GST_TYPE_IDENTITY))
2753 </MACRO>
2754 <MACRO>
2755 <NAME>GST_IS_IDENTITY_CLASS</NAME>
2756 #define GST_IS_IDENTITY_CLASS(obj) \
2757   (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_IDENTITY)))
2758 </MACRO>
2759 <STRUCT>
2760 <NAME>GstIdentity</NAME>
2761 </STRUCT>
2762 <STRUCT>
2763 <NAME>GstIdentityClass</NAME>
2764 </STRUCT>
2765 <STRUCT>
2766 <NAME>GstIdentity</NAME>
2767 struct GstIdentity {
2768   GstFilter filter;
2769
2770   GstPad *sinkpad;
2771   GstPad *srcpad;
2772
2773   gint control;
2774 };
2775 </STRUCT>
2776 <STRUCT>
2777 <NAME>GstIdentityClass</NAME>
2778 struct GstIdentityClass {
2779   GstFilterClass parent_class;
2780 };
2781 </STRUCT>
2782 <FUNCTION>
2783 <NAME>gst_identity_get_type</NAME>
2784 <RETURNS>GtkType  </RETURNS>
2785 void
2786 </FUNCTION>
2787 <MACRO>
2788 <NAME>GST_TYPE_QUEUE</NAME>
2789 #define GST_TYPE_QUEUE \
2790   (gst_queue_get_type())
2791 </MACRO>
2792 <MACRO>
2793 <NAME>GST_QUEUE</NAME>
2794 #define GST_QUEUE(obj) \
2795   (GTK_CHECK_CAST((obj),GST_TYPE_QUEUE,GstQueue))
2796 </MACRO>
2797 <MACRO>
2798 <NAME>GST_QUEUE_CLASS</NAME>
2799 #define GST_QUEUE_CLASS(klass) \
2800   (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_QUEUE,GstQueueClass))
2801 </MACRO>
2802 <MACRO>
2803 <NAME>GST_IS_QUEUE</NAME>
2804 #define GST_IS_QUEUE(obj) \
2805   (GTK_CHECK_TYPE((obj),GST_TYPE_QUEUE))
2806 </MACRO>
2807 <MACRO>
2808 <NAME>GST_IS_QUEUE_CLASS</NAME>
2809 #define GST_IS_QUEUE_CLASS(obj) \
2810   (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_QUEUE))
2811 </MACRO>
2812 <STRUCT>
2813 <NAME>GstQueue</NAME>
2814 </STRUCT>
2815 <STRUCT>
2816 <NAME>GstQueueClass</NAME>
2817 </STRUCT>
2818 <STRUCT>
2819 <NAME>GstQueue</NAME>
2820 struct GstQueue {
2821   GstConnection Connection;
2822
2823   GstPad *sinkpad;
2824   GstPad *srcpad;
2825
2826   /* the queue of buffers we're keeping our grubby hands on */
2827   GList *queue;
2828   GList *tail;          /* have to keep track of this myself */
2829
2830   gint level_buffers;   /* number of buffers queued here */
2831   gint max_buffers;     /* maximum number of buffers queued here */
2832   gint level_bytes;     /* number of bytes queued here */
2833   gint size_buffers;    /* size of queue in buffers */
2834   gint size_bytes;      /* size of queue in bytes */
2835
2836   GMutex *emptylock;    /* used when the queue is empty */
2837   GCond *emptycond;
2838   GMutex *fulllock;     /* used when the queue is full */
2839   GCond *fullcond;
2840 };
2841 </STRUCT>
2842 <STRUCT>
2843 <NAME>GstQueueClass</NAME>
2844 struct GstQueueClass {
2845   GstConnectionClass parent_class;
2846 };
2847 </STRUCT>
2848 <FUNCTION>
2849 <NAME>gst_queue_get_type</NAME>
2850 <RETURNS>GtkType  </RETURNS>
2851 void
2852 </FUNCTION>
2853 <MACRO>
2854 <NAME>GST_TYPE_SINESRC</NAME>
2855 #define GST_TYPE_SINESRC \
2856   (gst_sinesrc_get_type())
2857 </MACRO>
2858 <MACRO>
2859 <NAME>GST_SINESRC</NAME>
2860 #define GST_SINESRC(obj) \
2861   (GTK_CHECK_CAST((obj),GST_TYPE_SINESRC,GstSineSrc))
2862 </MACRO>
2863 <MACRO>
2864 <NAME>GST_SINESRC_CLASS</NAME>
2865 #define GST_SINESRC_CLASS(klass) \
2866   (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_SINESRC,GstSineSrcClass))
2867 </MACRO>
2868 <MACRO>
2869 <NAME>GST_IS_SINESRC</NAME>
2870 #define GST_IS_SINESRC(obj) \
2871   (GTK_CHECK_TYPE((obj),GST_TYPE_SINESRC))
2872 </MACRO>
2873 <MACRO>
2874 <NAME>GST_IS_SINESRC_CLASS</NAME>
2875 #define GST_IS_SINESRC_CLASS(obj) \
2876   (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_SINESRC)))
2877 </MACRO>
2878 <STRUCT>
2879 <NAME>GstSineSrc</NAME>
2880 </STRUCT>
2881 <STRUCT>
2882 <NAME>GstSineSrcClass</NAME>
2883 </STRUCT>
2884 <STRUCT>
2885 <NAME>GstSineSrc</NAME>
2886 struct GstSineSrc {
2887   GstSrc src;
2888
2889   /* pads */
2890   GstPad *srcpad;
2891
2892   /* parameters */
2893   gdouble volume;
2894   gint freq;
2895
2896   /* audio parameters */
2897   gint format;
2898   gint channels;
2899   gint frequency;
2900
2901   gulong seq;
2902
2903   MetaAudioRaw meta;
2904   gboolean sentmeta;
2905 };
2906 </STRUCT>
2907 <STRUCT>
2908 <NAME>GstSineSrcClass</NAME>
2909 struct GstSineSrcClass {
2910   GstSrcClass parent_class;
2911 };
2912 </STRUCT>
2913 <FUNCTION>
2914 <NAME>gst_sinesrc_get_type</NAME>
2915 <RETURNS>GtkType  </RETURNS>
2916 void
2917 </FUNCTION>
2918 <MACRO>
2919 <NAME>GST_TYPE_PIPEFILTER</NAME>
2920 #define GST_TYPE_PIPEFILTER \
2921   (gst_pipefilter_get_type())
2922 </MACRO>
2923 <MACRO>
2924 <NAME>GST_PIPEFILTER</NAME>
2925 #define GST_PIPEFILTER(obj) \
2926   (GTK_CHECK_CAST((obj),GST_TYPE_PIPEFILTER,GstPipefilter))
2927 </MACRO>
2928 <MACRO>
2929 <NAME>GST_PIPEFILTER_CLASS</NAME>
2930 #define GST_PIPEFILTER_CLASS(klass) \
2931   (GTK_CHECK_CLASS_CAST((klass),GST_TYPE_PIPEFILTER,GstPipefilterClass))
2932 </MACRO>
2933 <MACRO>
2934 <NAME>GST_IS_PIPEFILTER</NAME>
2935 #define GST_IS_PIPEFILTER(obj) \
2936   (GTK_CHECK_TYPE((obj),GST_TYPE_PIPEFILTER))
2937 </MACRO>
2938 <MACRO>
2939 <NAME>GST_IS_PIPEFILTER_CLASS</NAME>
2940 #define GST_IS_PIPEFILTER_CLASS(obj) \
2941   (GTK_CHECK_CLASS_TYPE((klass),GST_TYPE_PIPEFILTER))
2942 </MACRO>
2943 <ENUM>
2944 <NAME>GstPipeFilterFlags</NAME>
2945 typedef enum {
2946   GST_PIPEFILTER_OPEN           = (1 << 16 ),
2947 } GstPipeFilterFlags;
2948 </ENUM>
2949 <STRUCT>
2950 <NAME>GstPipefilter</NAME>
2951 </STRUCT>
2952 <STRUCT>
2953 <NAME>GstPipefilterClass</NAME>
2954 </STRUCT>
2955 <STRUCT>
2956 <NAME>GstPipefilter</NAME>
2957 struct GstPipefilter {
2958   GstFilter filter;
2959
2960   GstPad *sinkpad;
2961   GstPad *srcpad;
2962
2963   /* command */
2964   gchar **command;
2965   gchar *orig_command;
2966   /* fd */
2967   gint fdout[2];
2968   gint fdin[2];
2969   pid_t   childpid;
2970
2971   gulong curoffset;                     /* current offset in file */
2972   gulong bytes_per_read;                /* bytes per read */
2973
2974   gulong seq;                           /* buffer sequence number */
2975 };
2976 </STRUCT>
2977 <STRUCT>
2978 <NAME>GstPipefilterClass</NAME>
2979 struct GstPipefilterClass {
2980   GstFilterClass parent_class;
2981 };
2982 </STRUCT>
2983 <FUNCTION>
2984 <NAME>gst_pipefilter_get_type</NAME>
2985 <RETURNS>GtkType  </RETURNS>
2986 void
2987 </FUNCTION>
2988 <STRUCT>
2989 <NAME>MetaAudioRaw</NAME>
2990 </STRUCT>
2991 <STRUCT>
2992 <NAME>MetaAudioRaw</NAME>
2993 struct MetaAudioRaw {
2994   GstMeta meta;
2995
2996   /* formatting information */
2997   gint format;
2998   gint channels;
2999   gint frequency;
3000   gint bps;
3001 };
3002 </STRUCT>
3003 <STRUCT>
3004 <NAME>MetaAudioSpectrum</NAME>
3005 </STRUCT>
3006 <STRUCT>
3007 <NAME>MetaAudioSpectrum</NAME>
3008 struct MetaAudioSpectrum {
3009   GstMeta meta;
3010
3011   /* data representation */
3012   gint16 bands;                 /* how many bands are represented */
3013   gint8 channels;               /* how many audio channels are there? */
3014   gboolean interleaved;         /* are the channels interleaved? */
3015
3016   /* spectrum details */
3017   gint16 lowfreq;
3018   gint16 highfreq;
3019   gint16 steps;
3020 };
3021 </STRUCT>
3022 <STRUCT>
3023 <NAME>MetaVideoRaw</NAME>
3024 </STRUCT>
3025 <STRUCT>
3026 <NAME>MetaDGA</NAME>
3027 </STRUCT>
3028 <STRUCT>
3029 <NAME>MetaOverlay</NAME>
3030 </STRUCT>
3031 <STRUCT>
3032 <NAME>OverlayClip</NAME>
3033 </STRUCT>
3034 <STRUCT>
3035 <NAME>OverlayClip</NAME>
3036 struct OverlayClip {
3037   int x1, x2, y1, y2;
3038 };
3039 </STRUCT>
3040 <STRUCT>
3041 <NAME>MetaDGA</NAME>
3042 struct MetaDGA {
3043   // the base address of the screen
3044   void *base;
3045   // the dimensions of the screen
3046   int swidth, sheight;
3047   // the number of bytes in a line
3048   int bytes_per_line;
3049 };
3050 </STRUCT>
3051 <STRUCT>
3052 <NAME>MetaOverlay</NAME>
3053 struct MetaOverlay {
3054   // the position of the window
3055   int wx, wy;
3056   // a reference to the object sending overlay change events
3057   GtkWidget *overlay_element;
3058   // the number of overlay regions
3059   int clip_count;
3060   // the overlay regions of the display window
3061   struct _OverlayClip overlay_clip[32];
3062
3063   gint width;
3064   gint height;
3065
3066   gboolean did_overlay;
3067   gboolean fully_obscured;
3068 };
3069 </STRUCT>
3070 <STRUCT>
3071 <NAME>MetaVideoRaw</NAME>
3072 struct MetaVideoRaw {
3073   GstMeta meta;
3074
3075   /* formatting information */
3076   GstColorSpaceType format;
3077   GdkVisual *visual;
3078   // dimensions of the video buffer
3079   gint width;
3080   gint height;
3081   // a pointer to the overlay info if the sink supports this
3082   MetaOverlay *overlay_info;
3083   // a pointer to the DGA info if the sink supports this
3084   MetaDGA *dga_info;
3085 };
3086 </STRUCT>