1/* gstreamermm - a C++ wrapper for gstreamer 2 * 3 * Copyright 2008 The gstreamermm Development Team 4 * 5 * This library is free software; you can redistribute it and/or 6 * modify it under the terms of the GNU Lesser General Public 7 * License as published by the Free Software Foundation; either 8 * version 2.1 of the License, or (at your option) any later version. 9 * 10 * This library is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 * Lesser General Public License for more details. 14 * 15 * You should have received a copy of the GNU Lesser General Public 16 * License along with this library; if not, write to the Free 17 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 18 */ 19 20#include <gst/gst.h> 21#include <gstreamermm/iterator.h> 22#include <gstreamermm/pad.h> 23 24_PINCLUDE(gstreamermm/private/miniobject_p.h) 25#include <iostream> 26 27namespace Gst 28{ 29 30namespace Enums 31{ 32 33Glib::ustring get_name(QueryType t) 34{ 35 return gst_query_type_get_name(static_cast<GstQueryType>(t)); 36} 37 38Gst::QueryTypeFlags get_flags(QueryType type) 39{ 40 return static_cast<Gst::QueryTypeFlags>(gst_query_type_get_flags(static_cast<GstQueryType>(type))); 41} 42 43Glib::QueryQuark get_quark(QueryType t) 44{ 45 return Glib::QueryQuark(gst_query_type_to_quark(static_cast<GstQueryType>(t))); 46} 47 48} //namespace Enums 49 50Glib::RefPtr<Query> Query::create_writable() 51{ 52 return Glib::RefPtr<Query>::cast_static(MiniObject::create_writable()); 53} 54 55Glib::RefPtr<Gst::QueryApplication> 56 QueryApplication::create(QueryType type, const Gst::Structure& structure) 57{ 58 // Create copy because query takes ownership of structure: 59 GstStructure* copy_struct = gst_structure_copy(structure.gobj()); 60 GstQuery* query = gst_query_new_custom(GstQueryType(type), 61 copy_struct); 62 return Glib::wrap_query_derived<Gst::QueryApplication>(query); 63} 64 65Glib::RefPtr<Gst::QueryConvert> 66 QueryConvert::create(Format src_format, gint64 value, Format dest_format) 67{ 68 GstQuery* query = gst_query_new_convert(GstFormat(src_format), value, 69 GstFormat(dest_format)); 70 return Glib::wrap_query_derived<Gst::QueryConvert>(query); 71} 72 73void QueryConvert::set(Format src_format, gint64 src_value, Format dest_format, gint64 dest_value) 74{ 75 gst_query_set_convert(gobj(), GstFormat(src_format), src_value, GstFormat(dest_format), dest_value); 76} 77 78void QueryConvert::parse(Format& src_format, gint64& src_value, Format& dest_format, gint64& dest_value) const 79{ 80 gst_query_parse_convert(const_cast<GstQuery*>(gobj()), 81 reinterpret_cast<GstFormat*>(&src_format), &src_value, 82 reinterpret_cast<GstFormat*>(&dest_format), &dest_value); 83} 84 85void QueryConvert::parse(Format& dest_format, gint64& dest_value) const 86{ 87 gst_query_parse_convert(const_cast<GstQuery*>(gobj()), nullptr, nullptr, 88 reinterpret_cast<GstFormat*>(&dest_format), &dest_value); 89} 90 91Format QueryConvert::parse_src_format() const 92{ 93 Format src_format = Gst::FORMAT_UNDEFINED; 94 gst_query_parse_convert(const_cast<GstQuery*>(gobj()), 95 reinterpret_cast<GstFormat*>(&src_format), nullptr, nullptr, nullptr); 96 return src_format; 97} 98 99gint64 QueryConvert::parse_src_value() const 100{ 101 gint64 src_value = 0; 102 gst_query_parse_convert(const_cast<GstQuery*>(gobj()), nullptr, &src_value, 103 nullptr, nullptr); 104 return src_value; 105} 106 107Format QueryConvert::parse_dest_format() const 108{ 109 Format dest_format = Gst::FORMAT_UNDEFINED; 110 gst_query_parse_convert(const_cast<GstQuery*>(gobj()), nullptr, nullptr, 111 reinterpret_cast<GstFormat*>(&dest_format), nullptr); 112 return dest_format; 113} 114 115gint64 QueryConvert::parse_dest_value() const 116{ 117 gint64 dest_value = 0; 118 gst_query_parse_convert(const_cast<GstQuery*>(gobj()), nullptr, nullptr, nullptr, 119 &dest_value); 120 return dest_value; 121} 122 123Glib::RefPtr<Gst::QueryPosition> QueryPosition::create(Format format) 124{ 125 GstQuery* query = gst_query_new_position(GstFormat(format)); 126 return Glib::wrap_query_derived<Gst::QueryPosition>(query); 127} 128 129void QueryPosition::set(Format format, gint64 position) 130{ 131 gst_query_set_position(gobj(), GstFormat(format), position); 132} 133 134void QueryPosition::parse(Format& format, gint64& position) const 135{ 136 gst_query_parse_position(const_cast<GstQuery*>(gobj()), 137 reinterpret_cast<GstFormat*>(&format), &position); 138} 139 140gint64 QueryPosition::parse() const 141{ 142 gint64 position = 0; 143 gst_query_parse_position(const_cast<GstQuery*>(gobj()), nullptr, &position); 144 return position; 145} 146 147Format QueryPosition::parse_format() const 148{ 149 Format format = Gst::FORMAT_UNDEFINED; 150 gst_query_parse_position(const_cast<GstQuery*>(gobj()), 151 reinterpret_cast<GstFormat*>(&format), nullptr); 152 return format; 153} 154 155Glib::RefPtr<Gst::QueryDuration> QueryDuration::create(Format format) 156{ 157 GstQuery* query = gst_query_new_duration(GstFormat(format)); 158 return Glib::wrap_query_derived<Gst::QueryDuration>(query); 159} 160 161void QueryDuration::set(Format format, gint64 duration) 162{ 163 gst_query_set_duration(gobj(), GstFormat(format), duration); 164} 165 166void QueryDuration::parse(Format& format, gint64& duration) const 167{ 168 gst_query_parse_duration(const_cast<GstQuery*>(gobj()), 169 reinterpret_cast<GstFormat*>(&format), &duration); 170} 171 172gint64 QueryDuration::parse() const 173{ 174 gint64 duration = 0; 175 gst_query_parse_duration(const_cast<GstQuery*>(gobj()), nullptr, &duration); 176 return duration; 177} 178 179Format QueryDuration::parse_format() const 180{ 181 Format format = Gst::FORMAT_UNDEFINED; 182 gst_query_parse_duration(const_cast<GstQuery*>(gobj()), 183 reinterpret_cast<GstFormat*>(&format), 0); 184 return format; 185} 186 187Glib::RefPtr<Gst::QueryLatency> QueryLatency::create() 188{ 189 GstQuery* query = gst_query_new_latency(); 190 return Glib::wrap_query_derived<Gst::QueryLatency>(query); 191} 192 193void QueryLatency::set(bool live, ClockTime min_latency, ClockTime max_latency) 194{ 195 gst_query_set_latency(gobj(), live, GstClockTime(min_latency), GstClockTime(max_latency)); 196} 197 198void QueryLatency::parse(bool& live, ClockTime& min_latency, ClockTime& max_latency) const 199{ 200 gboolean glive = FALSE; 201 gst_query_parse_latency(const_cast<GstQuery*>(gobj()), &glive, 202 reinterpret_cast<ClockTime*>(&min_latency), 203 reinterpret_cast<ClockTime*>(&max_latency)); 204 live = glive; 205} 206 207bool QueryLatency::parse_live() const 208{ 209 gboolean glive = FALSE; 210 gst_query_parse_latency(const_cast<GstQuery*>(gobj()), &glive, nullptr, nullptr); 211 return glive; 212} 213 214ClockTime QueryLatency::parse_min() const 215{ 216 ClockTime min = 0; 217 gst_query_parse_latency(const_cast<GstQuery*>(gobj()), nullptr, 218 reinterpret_cast<ClockTime*>(&min), nullptr); 219 return min; 220} 221 222ClockTime QueryLatency::parse_max() const 223{ 224 ClockTime max = 0; 225 gst_query_parse_latency(const_cast<GstQuery*>(gobj()), nullptr, nullptr, 226 reinterpret_cast<ClockTime*>(&max)); 227 return max; 228} 229 230Glib::RefPtr<Gst::QuerySeeking> QuerySeeking::create(Format format) 231{ 232 GstQuery* query = gst_query_new_seeking(GstFormat(format)); 233 return Glib::wrap_query_derived<Gst::QuerySeeking>(query); 234} 235 236void QuerySeeking::set(Format format, bool seekable, gint64 segment_start, gint64 segment_end) 237{ 238 gst_query_set_seeking(gobj(), GstFormat(format), seekable, segment_start, segment_end); 239} 240 241void QuerySeeking::parse(Format& format, bool& seekable, gint64& segment_start, gint64& segment_end) const 242{ 243 gboolean gseekable = FALSE; 244 gst_query_parse_seeking(const_cast<GstQuery*>(gobj()), 245 reinterpret_cast<GstFormat*>(&format), &gseekable, &segment_start, 246 &segment_end); 247 seekable = gseekable; 248} 249 250Format QuerySeeking::parse_format() const 251{ 252 Format format = Gst::FORMAT_UNDEFINED; 253 gst_query_parse_seeking(const_cast<GstQuery*>(gobj()), 254 reinterpret_cast<GstFormat*>(&format), nullptr, nullptr, nullptr); 255 return format; 256} 257 258bool QuerySeeking::parse_seekable() const 259{ 260 gboolean gseekable = FALSE; 261 gst_query_parse_seeking(const_cast<GstQuery*>(gobj()), nullptr, 262 &gseekable, nullptr, nullptr); 263 return gseekable; 264} 265 266gint64 QuerySeeking::parse_start() const 267{ 268 gint64 start = 0; 269 gst_query_parse_seeking(const_cast<GstQuery*>(gobj()), nullptr, nullptr, 270 &start, nullptr); 271 return start; 272} 273 274gint64 QuerySeeking::parse_end() const 275{ 276 gint64 end = 0; 277 gst_query_parse_seeking(const_cast<GstQuery*>(gobj()), nullptr, nullptr, nullptr, 278 &end); 279 return end; 280} 281 282Glib::RefPtr<Gst::QueryFormats> QueryFormats::create() 283{ 284 GstQuery* query = gst_query_new_formats(); 285 return Glib::wrap_query_derived<Gst::QueryFormats>(query); 286} 287 288void QueryFormats::set(const Glib::ArrayHandle<Format>& formats) 289{ 290 gst_query_set_formatsv(gobj(), formats.size(), 291 reinterpret_cast<GstFormat*>(const_cast<Gst::Format*>(formats.data()))); 292} 293 294void QueryFormats::set(int n_formats, const Glib::ArrayHandle<Format>& formats) 295{ 296 gst_query_set_formatsv(gobj(), n_formats, 297 reinterpret_cast<GstFormat*>(const_cast<Gst::Format*>(formats.data()))); 298} 299 300guint QueryFormats::parse_length() const 301{ 302 guint n_formats = 0; 303 gst_query_parse_n_formats(const_cast<GstQuery*>(gobj()), &n_formats); 304 return n_formats; 305} 306 307Format QueryFormats::parse(guint nth) const 308{ 309 Format format = Gst::FORMAT_UNDEFINED; 310 gst_query_parse_nth_format(const_cast<GstQuery*>(gobj()), nth, 311 reinterpret_cast<GstFormat*>(&format)); 312 return format; 313} 314 315Glib::RefPtr<Gst::QuerySegment> QuerySegment::create(Format format) 316{ 317 GstQuery* query = gst_query_new_segment(GstFormat(format)); 318 return Glib::wrap_query_derived<Gst::QuerySegment>(query); 319} 320 321void QuerySegment::set(double rate, Format format, gint64 start_value, gint64 stop_value) 322{ 323 gst_query_set_segment(gobj(), rate, static_cast<GstFormat>(format), 324 start_value, stop_value); 325} 326 327void QuerySegment::parse(double& rate, Format& format, gint64& start_value, gint64& stop_value) const 328{ 329 gst_query_parse_segment(const_cast<GstQuery*>(gobj()), &rate, 330 reinterpret_cast<GstFormat*>(&format), &start_value, &stop_value); 331} 332 333double QuerySegment::parse_rate() const 334{ 335 double rate = 0; 336 gst_query_parse_segment(const_cast<GstQuery*>(gobj()), &rate, nullptr, 337 nullptr, nullptr); 338 return rate; 339} 340 341Format QuerySegment::parse_format() const 342{ 343 Format format = Gst::FORMAT_UNDEFINED; 344 gst_query_parse_segment(const_cast<GstQuery*>(gobj()), nullptr, 345 reinterpret_cast<GstFormat*>(&format), nullptr, nullptr); 346 return format; 347} 348 349gint64 QuerySegment::parse_start() const 350{ 351 gint64 start = 0; 352 gst_query_parse_segment(const_cast<GstQuery*>(gobj()), nullptr, nullptr, 353 &start, nullptr); 354 return start; 355} 356 357gint64 QuerySegment::parse_stop() const 358{ 359 gint64 stop = 0; 360 gst_query_parse_segment(const_cast<GstQuery*>(gobj()), nullptr, nullptr, 361 nullptr, &stop); 362 return stop; 363} 364 365Glib::RefPtr<Gst::QueryBuffering> QueryBuffering::create(Format format) 366{ 367 GstQuery* query = gst_query_new_buffering(GstFormat(format)); 368 return Glib::wrap_query_derived<Gst::QueryBuffering>(query); 369} 370 371void QueryBuffering::set(bool busy, int percent) 372{ 373 gst_query_set_buffering_percent(gobj(), busy, percent); 374} 375 376void QueryBuffering::parse(bool& busy, int& percent) const 377{ 378 gboolean gbusy = FALSE; 379 gst_query_parse_buffering_percent(const_cast<GstQuery*>(gobj()), &gbusy, 380 &percent); 381 busy = gbusy; 382} 383 384bool QueryBuffering::parse_busy() const 385{ 386 gboolean gbusy = FALSE; 387 gst_query_parse_buffering_percent(const_cast<GstQuery*>(gobj()), &gbusy, 388 0); 389 return gbusy; 390} 391 392int QueryBuffering::parse_percent() const 393{ 394 int percent = 0; 395 gst_query_parse_buffering_percent(const_cast<GstQuery*>(gobj()), nullptr, 396 &percent); 397 return percent; 398} 399 400void QueryBuffering::set(BufferingMode mode, int avg_in, int avg_out, gint64 buffering_left) 401{ 402 gst_query_set_buffering_stats(gobj(), static_cast<GstBufferingMode>(mode), 403 avg_in, avg_out, buffering_left); 404} 405 406void QueryBuffering::parse(BufferingMode& mode, int& avg_in, int& avg_out, gint64 buffering_left) const 407{ 408 gst_query_parse_buffering_stats(const_cast<GstQuery*>(gobj()), 409 reinterpret_cast<GstBufferingMode*>(&mode), &avg_in, &avg_out, 410 &buffering_left); 411} 412 413BufferingMode QueryBuffering::parse_mode() const 414{ 415 BufferingMode mode = Gst::BUFFERING_STREAM; 416 gst_query_parse_buffering_stats(const_cast<GstQuery*>(gobj()), 417 reinterpret_cast<GstBufferingMode*>(&mode), nullptr, nullptr, nullptr); 418 return mode; 419} 420 421int QueryBuffering::parse_input_rate() const 422{ 423 int avg_in = 0; 424 gst_query_parse_buffering_stats(const_cast<GstQuery*>(gobj()), nullptr, 425 &avg_in, nullptr, nullptr); 426 return avg_in; 427} 428 429int QueryBuffering::parse_output_rate() const 430{ 431 int avg_out = 0; 432 gst_query_parse_buffering_stats(const_cast<GstQuery*>(gobj()), nullptr, nullptr, 433 &avg_out, nullptr); 434 return avg_out; 435} 436 437gint64 QueryBuffering::parse_time_left() const 438{ 439 gint64 buffering_left = Gst::BUFFERING_STREAM; 440 gst_query_parse_buffering_stats(const_cast<GstQuery*>(gobj()), nullptr, 441 nullptr, nullptr, &buffering_left); 442 return buffering_left; 443} 444 445void QueryBuffering::set(Format format, gint64 start, gint64 stop, gint64 estimated_total) 446{ 447 gst_query_set_buffering_range(gobj(), static_cast<GstFormat>(format), 448 start, stop, estimated_total); 449} 450 451void QueryBuffering::parse(Format& format, gint64& start, gint64& stop, gint64& estimated_total) const 452{ 453 gst_query_parse_buffering_range(const_cast<GstQuery*>(gobj()), 454 reinterpret_cast<GstFormat*>(&format), &start, &stop, &estimated_total); 455} 456 457Format QueryBuffering::parse_format() const 458{ 459 Format format = Gst::FORMAT_UNDEFINED; 460 gst_query_parse_buffering_range(const_cast<GstQuery*>(gobj()), 461 reinterpret_cast<GstFormat*>(&format), nullptr, nullptr, nullptr); 462 return format; 463} 464 465gint64 QueryBuffering::parse_start() const 466{ 467 gint64 start = 0; 468 gst_query_parse_buffering_range(const_cast<GstQuery*>(gobj()), nullptr, 469 &start, nullptr, nullptr); 470 return start; 471} 472 473gint64 QueryBuffering::parse_stop() const 474{ 475 gint64 stop = 0; 476 gst_query_parse_buffering_range(const_cast<GstQuery*>(gobj()), nullptr, 477 nullptr, &stop, nullptr); 478 return stop; 479} 480 481gint64 QueryBuffering::parse_total_time() const 482{ 483 gint64 estimated_total = 0; 484 gst_query_parse_buffering_range(const_cast<GstQuery*>(gobj()), nullptr, 485 nullptr, nullptr, &estimated_total); 486 return estimated_total; 487} 488 489Glib::RefPtr<Gst::QueryCaps> QueryCaps::create(const Glib::RefPtr<Gst::Caps>& filter) 490{ 491 GstQuery* query = gst_query_new_caps(filter->gobj()); 492 return Glib::wrap_query_derived<Gst::QueryCaps>(query); 493} 494 495Glib::RefPtr<Gst::Caps> QueryCaps::parse() const 496{ 497 GstCaps* caps; 498 gst_query_parse_caps(const_cast<GstQuery*>(gobj()), &caps); 499 return Glib::wrap(caps, true); 500} 501 502Glib::RefPtr<Gst::Caps> QueryCaps::parse_caps_result() const 503{ 504 GstCaps* caps; 505 gst_query_parse_caps_result(const_cast<GstQuery*>(gobj()), &caps); 506 return Glib::wrap(caps, false); 507} 508 509void QueryCaps::set_caps_result(const Glib::RefPtr<Gst::Caps>& caps) 510{ 511 gst_query_set_caps_result(gobj(), caps->gobj()); 512} 513 514Glib::RefPtr<QueryScheduling> QueryScheduling::create() 515{ 516 GstQuery* query = gst_query_new_scheduling(); 517 return Glib::wrap_query_derived<QueryScheduling>(query); 518} 519 520void QueryScheduling::parse(SchedulingFlags& flags, gint& minsize, gint& maxsize, gint& align) const 521{ 522 GstSchedulingFlags gst_flags; 523 gst_query_parse_scheduling(const_cast<GstQuery*>(gobj()), &gst_flags, &minsize, &maxsize, &align); 524 flags = SchedulingFlags(gst_flags); 525} 526 527void QueryScheduling::set(SchedulingFlags flags, gint minsize, gint maxsize, gint align) 528{ 529 gst_query_set_scheduling(gobj(), GstSchedulingFlags(flags), minsize, maxsize, align); 530} 531 532void QueryScheduling::add_scheduling_mode(PadMode mode) 533{ 534 gst_query_add_scheduling_mode(gobj(), GstPadMode(mode)); 535} 536 537guint QueryScheduling::get_n_scheduling_modes() const 538{ 539 return gst_query_get_n_scheduling_modes(const_cast<GstQuery*>(gobj())); 540} 541 542PadMode QueryScheduling::parse_nth_scheduling_mode(guint index) const 543{ 544 return PadMode(gst_query_parse_nth_scheduling_mode(const_cast<GstQuery*>(gobj()), index)); 545} 546 547bool QueryScheduling::has_scheduling_mode(PadMode mode) const 548{ 549 return PadMode(gst_query_has_scheduling_mode(const_cast<GstQuery*>(gobj()), GstPadMode(mode))); 550} 551 552bool QueryScheduling::has_scheduling_mode_with_flags(PadMode mode, SchedulingFlags flags) const 553{ 554 return PadMode(gst_query_has_scheduling_mode_with_flags(const_cast<GstQuery*>(gobj()), GstPadMode(mode), GstSchedulingFlags(flags))); 555} 556 557Glib::RefPtr<QueryAllocation> QueryAllocation::create(const Glib::RefPtr<Gst::Caps>& caps, bool need_pool) 558{ 559 GstQuery* query = gst_query_new_allocation(caps->gobj(), need_pool); 560 return Glib::wrap_query_derived<QueryAllocation>(query); 561} 562 563void QueryAllocation::parse(Glib::RefPtr<Caps>& caps, bool& need_pool) const 564{ 565 GstCaps* n_caps; 566 gboolean gst_need_pool; 567 gst_query_parse_allocation(const_cast<GstQuery*>(gobj()), &n_caps, &gst_need_pool); 568 caps = Glib::wrap(n_caps, false); 569 need_pool = gst_need_pool; 570} 571 572guint QueryAllocation::get_n_allocation_pools() const 573{ 574 return gst_query_get_n_allocation_pools(const_cast<GstQuery*>(gobj())); 575} 576 577void QueryAllocation::remove_nth_allocation_pool(guint index) 578{ 579 gst_query_remove_nth_allocation_pool(gobj(), index); 580} 581 582void QueryAllocation::add_allocation_param(const Glib::RefPtr<Allocator>& allocator, const AllocationParams& params) 583{ 584 gst_query_add_allocation_param(gobj(), allocator->gobj(), params.gobj()); 585} 586 587guint QueryAllocation::get_n_allocation_params() const 588{ 589 return gst_query_get_n_allocation_params(const_cast<GstQuery*>(gobj())); 590} 591 592void QueryAllocation::parse_nth_allocation_param(guint index, Glib::RefPtr<Allocator>& allocator, AllocationParams& params) const 593{ 594 GstAllocator* n_allocator; 595 gst_query_parse_nth_allocation_param(const_cast<GstQuery*>(gobj()), index, &n_allocator, params.gobj()); 596 allocator = Glib::wrap(n_allocator, false); 597} 598 599void QueryAllocation::set_nth_allocation_param(guint index, const Glib::RefPtr<Allocator>& allocator, const AllocationParams& params) 600{ 601 gst_query_set_nth_allocation_param(gobj(), index, allocator->gobj(), params.gobj()); 602} 603 604void QueryAllocation::remove_nth_allocation_param(guint index) 605{ 606 gst_query_remove_nth_allocation_param(gobj(), index); 607} 608 609void QueryAllocation::add_allocation_meta(GType api, const Structure& params) 610{ 611 gst_query_add_allocation_meta(gobj(), api, params.gobj()); 612} 613 614guint QueryAllocation::get_n_allocation_metas() const 615{ 616 return gst_query_get_n_allocation_metas(const_cast<GstQuery*>(gobj())); 617} 618 619GType QueryAllocation::parse_nth_allocation_meta(guint index, Structure& params) const 620{ 621 GstStructure *gst_params; 622 GType ret = gst_query_parse_nth_allocation_meta(const_cast<GstQuery*>(gobj()), index, (const GstStructure**)&gst_params); 623 params = Glib::wrap(gst_params, true); 624 return ret; 625} 626 627void QueryAllocation::remove_nth_allocation_meta(guint index) 628{ 629 gst_query_remove_nth_allocation_meta(gobj(), index); 630} 631 632bool QueryAllocation::find_allocation_meta(GType api, guint& index) const 633{ 634 return gst_query_find_allocation_meta(const_cast<GstQuery*>(gobj()), api, &index); 635} 636 637Glib::RefPtr<QueryUri> QueryUri::create() 638{ 639 GstQuery* query = gst_query_new_uri(); 640 return Glib::wrap_query_derived<QueryUri>(query); 641} 642 643Glib::ustring QueryUri::parse() const 644{ 645 gchar* gst_uri; 646 Glib::ustring uri; 647 gst_query_parse_uri(const_cast<GstQuery*>(gobj()), &gst_uri); 648 if (gst_uri != nullptr) 649 { 650 uri = gst_uri; 651 g_free(gst_uri); 652 } 653 654 return uri; 655} 656 657void QueryUri::set(const Glib::ustring& uri) 658{ 659 gst_query_set_uri(gobj(), uri.c_str()); 660} 661 662void QueryUri::set_uri_redirection(const Glib::ustring& uri) 663{ 664 gst_query_set_uri_redirection(gobj(), uri.c_str()); 665} 666 667Glib::ustring QueryUri::parse_uri_redirection() const 668{ 669 gchar* c_uri; 670 Glib::ustring uri; 671 gst_query_parse_uri_redirection(const_cast<GstQuery*>(gobj()), &c_uri); 672 673 if (c_uri != nullptr) 674 { 675 uri = c_uri; 676 g_free(c_uri); 677 } 678 679 return uri; 680} 681 682Glib::RefPtr<QueryAcceptCaps> QueryAcceptCaps::create(const Glib::RefPtr<Gst::Caps>& caps) 683{ 684 GstQuery* query = gst_query_new_accept_caps(caps->gobj()); 685 return Glib::wrap_query_derived<QueryAcceptCaps>(query); 686} 687 688 689Glib::RefPtr<Gst::Caps> QueryAcceptCaps::parse_accept_caps() const 690{ 691 GstCaps *c_caps; 692 gst_query_parse_accept_caps(const_cast<GstQuery*>(gobj()), &c_caps); 693 return Glib::wrap(c_caps, false); 694} 695 696bool QueryAcceptCaps::parse_accept_caps_result() const 697{ 698 gboolean c_result; 699 gst_query_parse_accept_caps_result(const_cast<GstQuery*>(gobj()), &c_result); 700 return bool(c_result); 701} 702 703void QueryAcceptCaps::set_accept_caps_result(bool result) 704{ 705 gst_query_set_accept_caps_result(gobj(), result); 706} 707} //namesapce Gst 708