mirror of
https://github.com/mappu/miqt.git
synced 2024-12-22 17:08:38 +00:00
784 lines
28 KiB
Go
784 lines
28 KiB
Go
package multimedia
|
|
|
|
/*
|
|
|
|
#include "gen_qmediaserviceproviderplugin.h"
|
|
#include <stdlib.h>
|
|
|
|
*/
|
|
import "C"
|
|
|
|
import (
|
|
"github.com/mappu/miqt/qt"
|
|
"runtime"
|
|
"unsafe"
|
|
)
|
|
|
|
type QMediaServiceProviderHint__Type int
|
|
|
|
const (
|
|
QMediaServiceProviderHint__Null QMediaServiceProviderHint__Type = 0
|
|
QMediaServiceProviderHint__ContentType QMediaServiceProviderHint__Type = 1
|
|
QMediaServiceProviderHint__Device QMediaServiceProviderHint__Type = 2
|
|
QMediaServiceProviderHint__SupportedFeatures QMediaServiceProviderHint__Type = 3
|
|
QMediaServiceProviderHint__CameraPosition QMediaServiceProviderHint__Type = 4
|
|
)
|
|
|
|
type QMediaServiceProviderHint__Feature int
|
|
|
|
const (
|
|
QMediaServiceProviderHint__LowLatencyPlayback QMediaServiceProviderHint__Feature = 1
|
|
QMediaServiceProviderHint__RecordingSupport QMediaServiceProviderHint__Feature = 2
|
|
QMediaServiceProviderHint__StreamPlayback QMediaServiceProviderHint__Feature = 4
|
|
QMediaServiceProviderHint__VideoSurface QMediaServiceProviderHint__Feature = 8
|
|
)
|
|
|
|
type QMediaServiceProviderHint struct {
|
|
h *C.QMediaServiceProviderHint
|
|
isSubclass bool
|
|
}
|
|
|
|
func (this *QMediaServiceProviderHint) cPointer() *C.QMediaServiceProviderHint {
|
|
if this == nil {
|
|
return nil
|
|
}
|
|
return this.h
|
|
}
|
|
|
|
func (this *QMediaServiceProviderHint) UnsafePointer() unsafe.Pointer {
|
|
if this == nil {
|
|
return nil
|
|
}
|
|
return unsafe.Pointer(this.h)
|
|
}
|
|
|
|
// newQMediaServiceProviderHint constructs the type using only CGO pointers.
|
|
func newQMediaServiceProviderHint(h *C.QMediaServiceProviderHint) *QMediaServiceProviderHint {
|
|
if h == nil {
|
|
return nil
|
|
}
|
|
return &QMediaServiceProviderHint{h: h}
|
|
}
|
|
|
|
// UnsafeNewQMediaServiceProviderHint constructs the type using only unsafe pointers.
|
|
func UnsafeNewQMediaServiceProviderHint(h unsafe.Pointer) *QMediaServiceProviderHint {
|
|
if h == nil {
|
|
return nil
|
|
}
|
|
|
|
return &QMediaServiceProviderHint{h: (*C.QMediaServiceProviderHint)(h)}
|
|
}
|
|
|
|
// NewQMediaServiceProviderHint constructs a new QMediaServiceProviderHint object.
|
|
func NewQMediaServiceProviderHint() *QMediaServiceProviderHint {
|
|
var outptr_QMediaServiceProviderHint *C.QMediaServiceProviderHint = nil
|
|
|
|
C.QMediaServiceProviderHint_new(&outptr_QMediaServiceProviderHint)
|
|
ret := newQMediaServiceProviderHint(outptr_QMediaServiceProviderHint)
|
|
ret.isSubclass = true
|
|
return ret
|
|
}
|
|
|
|
// NewQMediaServiceProviderHint2 constructs a new QMediaServiceProviderHint object.
|
|
func NewQMediaServiceProviderHint2(mimeType string, codecs []string) *QMediaServiceProviderHint {
|
|
mimeType_ms := C.struct_miqt_string{}
|
|
mimeType_ms.data = C.CString(mimeType)
|
|
mimeType_ms.len = C.size_t(len(mimeType))
|
|
defer C.free(unsafe.Pointer(mimeType_ms.data))
|
|
codecs_CArray := (*[0xffff]C.struct_miqt_string)(C.malloc(C.size_t(int(unsafe.Sizeof(C.struct_miqt_string{})) * len(codecs))))
|
|
defer C.free(unsafe.Pointer(codecs_CArray))
|
|
for i := range codecs {
|
|
codecs_i_ms := C.struct_miqt_string{}
|
|
codecs_i_ms.data = C.CString(codecs[i])
|
|
codecs_i_ms.len = C.size_t(len(codecs[i]))
|
|
defer C.free(unsafe.Pointer(codecs_i_ms.data))
|
|
codecs_CArray[i] = codecs_i_ms
|
|
}
|
|
codecs_ma := C.struct_miqt_array{len: C.size_t(len(codecs)), data: unsafe.Pointer(codecs_CArray)}
|
|
var outptr_QMediaServiceProviderHint *C.QMediaServiceProviderHint = nil
|
|
|
|
C.QMediaServiceProviderHint_new2(mimeType_ms, codecs_ma, &outptr_QMediaServiceProviderHint)
|
|
ret := newQMediaServiceProviderHint(outptr_QMediaServiceProviderHint)
|
|
ret.isSubclass = true
|
|
return ret
|
|
}
|
|
|
|
// NewQMediaServiceProviderHint3 constructs a new QMediaServiceProviderHint object.
|
|
func NewQMediaServiceProviderHint3(device []byte) *QMediaServiceProviderHint {
|
|
device_alias := C.struct_miqt_string{}
|
|
device_alias.data = (*C.char)(unsafe.Pointer(&device[0]))
|
|
device_alias.len = C.size_t(len(device))
|
|
var outptr_QMediaServiceProviderHint *C.QMediaServiceProviderHint = nil
|
|
|
|
C.QMediaServiceProviderHint_new3(device_alias, &outptr_QMediaServiceProviderHint)
|
|
ret := newQMediaServiceProviderHint(outptr_QMediaServiceProviderHint)
|
|
ret.isSubclass = true
|
|
return ret
|
|
}
|
|
|
|
// NewQMediaServiceProviderHint4 constructs a new QMediaServiceProviderHint object.
|
|
func NewQMediaServiceProviderHint4(position QCamera__Position) *QMediaServiceProviderHint {
|
|
var outptr_QMediaServiceProviderHint *C.QMediaServiceProviderHint = nil
|
|
|
|
C.QMediaServiceProviderHint_new4((C.int)(position), &outptr_QMediaServiceProviderHint)
|
|
ret := newQMediaServiceProviderHint(outptr_QMediaServiceProviderHint)
|
|
ret.isSubclass = true
|
|
return ret
|
|
}
|
|
|
|
// NewQMediaServiceProviderHint5 constructs a new QMediaServiceProviderHint object.
|
|
func NewQMediaServiceProviderHint5(features QMediaServiceProviderHint__Feature) *QMediaServiceProviderHint {
|
|
var outptr_QMediaServiceProviderHint *C.QMediaServiceProviderHint = nil
|
|
|
|
C.QMediaServiceProviderHint_new5((C.int)(features), &outptr_QMediaServiceProviderHint)
|
|
ret := newQMediaServiceProviderHint(outptr_QMediaServiceProviderHint)
|
|
ret.isSubclass = true
|
|
return ret
|
|
}
|
|
|
|
// NewQMediaServiceProviderHint6 constructs a new QMediaServiceProviderHint object.
|
|
func NewQMediaServiceProviderHint6(other *QMediaServiceProviderHint) *QMediaServiceProviderHint {
|
|
var outptr_QMediaServiceProviderHint *C.QMediaServiceProviderHint = nil
|
|
|
|
C.QMediaServiceProviderHint_new6(other.cPointer(), &outptr_QMediaServiceProviderHint)
|
|
ret := newQMediaServiceProviderHint(outptr_QMediaServiceProviderHint)
|
|
ret.isSubclass = true
|
|
return ret
|
|
}
|
|
|
|
func (this *QMediaServiceProviderHint) OperatorAssign(other *QMediaServiceProviderHint) {
|
|
C.QMediaServiceProviderHint_OperatorAssign(this.h, other.cPointer())
|
|
}
|
|
|
|
func (this *QMediaServiceProviderHint) OperatorEqual(other *QMediaServiceProviderHint) bool {
|
|
return (bool)(C.QMediaServiceProviderHint_OperatorEqual(this.h, other.cPointer()))
|
|
}
|
|
|
|
func (this *QMediaServiceProviderHint) OperatorNotEqual(other *QMediaServiceProviderHint) bool {
|
|
return (bool)(C.QMediaServiceProviderHint_OperatorNotEqual(this.h, other.cPointer()))
|
|
}
|
|
|
|
func (this *QMediaServiceProviderHint) IsNull() bool {
|
|
return (bool)(C.QMediaServiceProviderHint_IsNull(this.h))
|
|
}
|
|
|
|
func (this *QMediaServiceProviderHint) Type() QMediaServiceProviderHint__Type {
|
|
return (QMediaServiceProviderHint__Type)(C.QMediaServiceProviderHint_Type(this.h))
|
|
}
|
|
|
|
func (this *QMediaServiceProviderHint) MimeType() string {
|
|
var _ms C.struct_miqt_string = C.QMediaServiceProviderHint_MimeType(this.h)
|
|
_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
|
|
C.free(unsafe.Pointer(_ms.data))
|
|
return _ret
|
|
}
|
|
|
|
func (this *QMediaServiceProviderHint) Codecs() []string {
|
|
var _ma C.struct_miqt_array = C.QMediaServiceProviderHint_Codecs(this.h)
|
|
_ret := make([]string, int(_ma.len))
|
|
_outCast := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(_ma.data)) // hey ya
|
|
for i := 0; i < int(_ma.len); i++ {
|
|
var _lv_ms C.struct_miqt_string = _outCast[i]
|
|
_lv_ret := C.GoStringN(_lv_ms.data, C.int(int64(_lv_ms.len)))
|
|
C.free(unsafe.Pointer(_lv_ms.data))
|
|
_ret[i] = _lv_ret
|
|
}
|
|
return _ret
|
|
}
|
|
|
|
func (this *QMediaServiceProviderHint) Device() []byte {
|
|
var _bytearray C.struct_miqt_string = C.QMediaServiceProviderHint_Device(this.h)
|
|
_ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len)))
|
|
C.free(unsafe.Pointer(_bytearray.data))
|
|
return _ret
|
|
}
|
|
|
|
func (this *QMediaServiceProviderHint) CameraPosition() QCamera__Position {
|
|
return (QCamera__Position)(C.QMediaServiceProviderHint_CameraPosition(this.h))
|
|
}
|
|
|
|
func (this *QMediaServiceProviderHint) Features() QMediaServiceProviderHint__Feature {
|
|
return (QMediaServiceProviderHint__Feature)(C.QMediaServiceProviderHint_Features(this.h))
|
|
}
|
|
|
|
// Delete this object from C++ memory.
|
|
func (this *QMediaServiceProviderHint) Delete() {
|
|
C.QMediaServiceProviderHint_Delete(this.h, C.bool(this.isSubclass))
|
|
}
|
|
|
|
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
|
|
// from C++ memory once it is unreachable from Go memory.
|
|
func (this *QMediaServiceProviderHint) GoGC() {
|
|
runtime.SetFinalizer(this, func(this *QMediaServiceProviderHint) {
|
|
this.Delete()
|
|
runtime.KeepAlive(this.h)
|
|
})
|
|
}
|
|
|
|
type QMediaServiceProviderFactoryInterface struct {
|
|
h *C.QMediaServiceProviderFactoryInterface
|
|
isSubclass bool
|
|
}
|
|
|
|
func (this *QMediaServiceProviderFactoryInterface) cPointer() *C.QMediaServiceProviderFactoryInterface {
|
|
if this == nil {
|
|
return nil
|
|
}
|
|
return this.h
|
|
}
|
|
|
|
func (this *QMediaServiceProviderFactoryInterface) UnsafePointer() unsafe.Pointer {
|
|
if this == nil {
|
|
return nil
|
|
}
|
|
return unsafe.Pointer(this.h)
|
|
}
|
|
|
|
// newQMediaServiceProviderFactoryInterface constructs the type using only CGO pointers.
|
|
func newQMediaServiceProviderFactoryInterface(h *C.QMediaServiceProviderFactoryInterface) *QMediaServiceProviderFactoryInterface {
|
|
if h == nil {
|
|
return nil
|
|
}
|
|
return &QMediaServiceProviderFactoryInterface{h: h}
|
|
}
|
|
|
|
// UnsafeNewQMediaServiceProviderFactoryInterface constructs the type using only unsafe pointers.
|
|
func UnsafeNewQMediaServiceProviderFactoryInterface(h unsafe.Pointer) *QMediaServiceProviderFactoryInterface {
|
|
if h == nil {
|
|
return nil
|
|
}
|
|
|
|
return &QMediaServiceProviderFactoryInterface{h: (*C.QMediaServiceProviderFactoryInterface)(h)}
|
|
}
|
|
|
|
func (this *QMediaServiceProviderFactoryInterface) Create(key string) *QMediaService {
|
|
key_ms := C.struct_miqt_string{}
|
|
key_ms.data = C.CString(key)
|
|
key_ms.len = C.size_t(len(key))
|
|
defer C.free(unsafe.Pointer(key_ms.data))
|
|
return UnsafeNewQMediaService(unsafe.Pointer(C.QMediaServiceProviderFactoryInterface_Create(this.h, key_ms)), nil)
|
|
}
|
|
|
|
func (this *QMediaServiceProviderFactoryInterface) Release(service *QMediaService) {
|
|
C.QMediaServiceProviderFactoryInterface_Release(this.h, service.cPointer())
|
|
}
|
|
|
|
func (this *QMediaServiceProviderFactoryInterface) OperatorAssign(param1 *QMediaServiceProviderFactoryInterface) {
|
|
C.QMediaServiceProviderFactoryInterface_OperatorAssign(this.h, param1.cPointer())
|
|
}
|
|
|
|
// Delete this object from C++ memory.
|
|
func (this *QMediaServiceProviderFactoryInterface) Delete() {
|
|
C.QMediaServiceProviderFactoryInterface_Delete(this.h, C.bool(this.isSubclass))
|
|
}
|
|
|
|
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
|
|
// from C++ memory once it is unreachable from Go memory.
|
|
func (this *QMediaServiceProviderFactoryInterface) GoGC() {
|
|
runtime.SetFinalizer(this, func(this *QMediaServiceProviderFactoryInterface) {
|
|
this.Delete()
|
|
runtime.KeepAlive(this.h)
|
|
})
|
|
}
|
|
|
|
type QMediaServiceSupportedFormatsInterface struct {
|
|
h *C.QMediaServiceSupportedFormatsInterface
|
|
isSubclass bool
|
|
}
|
|
|
|
func (this *QMediaServiceSupportedFormatsInterface) cPointer() *C.QMediaServiceSupportedFormatsInterface {
|
|
if this == nil {
|
|
return nil
|
|
}
|
|
return this.h
|
|
}
|
|
|
|
func (this *QMediaServiceSupportedFormatsInterface) UnsafePointer() unsafe.Pointer {
|
|
if this == nil {
|
|
return nil
|
|
}
|
|
return unsafe.Pointer(this.h)
|
|
}
|
|
|
|
// newQMediaServiceSupportedFormatsInterface constructs the type using only CGO pointers.
|
|
func newQMediaServiceSupportedFormatsInterface(h *C.QMediaServiceSupportedFormatsInterface) *QMediaServiceSupportedFormatsInterface {
|
|
if h == nil {
|
|
return nil
|
|
}
|
|
return &QMediaServiceSupportedFormatsInterface{h: h}
|
|
}
|
|
|
|
// UnsafeNewQMediaServiceSupportedFormatsInterface constructs the type using only unsafe pointers.
|
|
func UnsafeNewQMediaServiceSupportedFormatsInterface(h unsafe.Pointer) *QMediaServiceSupportedFormatsInterface {
|
|
if h == nil {
|
|
return nil
|
|
}
|
|
|
|
return &QMediaServiceSupportedFormatsInterface{h: (*C.QMediaServiceSupportedFormatsInterface)(h)}
|
|
}
|
|
|
|
func (this *QMediaServiceSupportedFormatsInterface) HasSupport(mimeType string, codecs []string) QMultimedia__SupportEstimate {
|
|
mimeType_ms := C.struct_miqt_string{}
|
|
mimeType_ms.data = C.CString(mimeType)
|
|
mimeType_ms.len = C.size_t(len(mimeType))
|
|
defer C.free(unsafe.Pointer(mimeType_ms.data))
|
|
codecs_CArray := (*[0xffff]C.struct_miqt_string)(C.malloc(C.size_t(int(unsafe.Sizeof(C.struct_miqt_string{})) * len(codecs))))
|
|
defer C.free(unsafe.Pointer(codecs_CArray))
|
|
for i := range codecs {
|
|
codecs_i_ms := C.struct_miqt_string{}
|
|
codecs_i_ms.data = C.CString(codecs[i])
|
|
codecs_i_ms.len = C.size_t(len(codecs[i]))
|
|
defer C.free(unsafe.Pointer(codecs_i_ms.data))
|
|
codecs_CArray[i] = codecs_i_ms
|
|
}
|
|
codecs_ma := C.struct_miqt_array{len: C.size_t(len(codecs)), data: unsafe.Pointer(codecs_CArray)}
|
|
return (QMultimedia__SupportEstimate)(C.QMediaServiceSupportedFormatsInterface_HasSupport(this.h, mimeType_ms, codecs_ma))
|
|
}
|
|
|
|
func (this *QMediaServiceSupportedFormatsInterface) SupportedMimeTypes() []string {
|
|
var _ma C.struct_miqt_array = C.QMediaServiceSupportedFormatsInterface_SupportedMimeTypes(this.h)
|
|
_ret := make([]string, int(_ma.len))
|
|
_outCast := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(_ma.data)) // hey ya
|
|
for i := 0; i < int(_ma.len); i++ {
|
|
var _lv_ms C.struct_miqt_string = _outCast[i]
|
|
_lv_ret := C.GoStringN(_lv_ms.data, C.int(int64(_lv_ms.len)))
|
|
C.free(unsafe.Pointer(_lv_ms.data))
|
|
_ret[i] = _lv_ret
|
|
}
|
|
return _ret
|
|
}
|
|
|
|
func (this *QMediaServiceSupportedFormatsInterface) OperatorAssign(param1 *QMediaServiceSupportedFormatsInterface) {
|
|
C.QMediaServiceSupportedFormatsInterface_OperatorAssign(this.h, param1.cPointer())
|
|
}
|
|
|
|
// Delete this object from C++ memory.
|
|
func (this *QMediaServiceSupportedFormatsInterface) Delete() {
|
|
C.QMediaServiceSupportedFormatsInterface_Delete(this.h, C.bool(this.isSubclass))
|
|
}
|
|
|
|
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
|
|
// from C++ memory once it is unreachable from Go memory.
|
|
func (this *QMediaServiceSupportedFormatsInterface) GoGC() {
|
|
runtime.SetFinalizer(this, func(this *QMediaServiceSupportedFormatsInterface) {
|
|
this.Delete()
|
|
runtime.KeepAlive(this.h)
|
|
})
|
|
}
|
|
|
|
type QMediaServiceSupportedDevicesInterface struct {
|
|
h *C.QMediaServiceSupportedDevicesInterface
|
|
isSubclass bool
|
|
}
|
|
|
|
func (this *QMediaServiceSupportedDevicesInterface) cPointer() *C.QMediaServiceSupportedDevicesInterface {
|
|
if this == nil {
|
|
return nil
|
|
}
|
|
return this.h
|
|
}
|
|
|
|
func (this *QMediaServiceSupportedDevicesInterface) UnsafePointer() unsafe.Pointer {
|
|
if this == nil {
|
|
return nil
|
|
}
|
|
return unsafe.Pointer(this.h)
|
|
}
|
|
|
|
// newQMediaServiceSupportedDevicesInterface constructs the type using only CGO pointers.
|
|
func newQMediaServiceSupportedDevicesInterface(h *C.QMediaServiceSupportedDevicesInterface) *QMediaServiceSupportedDevicesInterface {
|
|
if h == nil {
|
|
return nil
|
|
}
|
|
return &QMediaServiceSupportedDevicesInterface{h: h}
|
|
}
|
|
|
|
// UnsafeNewQMediaServiceSupportedDevicesInterface constructs the type using only unsafe pointers.
|
|
func UnsafeNewQMediaServiceSupportedDevicesInterface(h unsafe.Pointer) *QMediaServiceSupportedDevicesInterface {
|
|
if h == nil {
|
|
return nil
|
|
}
|
|
|
|
return &QMediaServiceSupportedDevicesInterface{h: (*C.QMediaServiceSupportedDevicesInterface)(h)}
|
|
}
|
|
|
|
func (this *QMediaServiceSupportedDevicesInterface) Devices(service []byte) [][]byte {
|
|
service_alias := C.struct_miqt_string{}
|
|
service_alias.data = (*C.char)(unsafe.Pointer(&service[0]))
|
|
service_alias.len = C.size_t(len(service))
|
|
var _ma C.struct_miqt_array = C.QMediaServiceSupportedDevicesInterface_Devices(this.h, service_alias)
|
|
_ret := make([][]byte, int(_ma.len))
|
|
_outCast := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(_ma.data)) // hey ya
|
|
for i := 0; i < int(_ma.len); i++ {
|
|
var _lv_bytearray C.struct_miqt_string = _outCast[i]
|
|
_lv_ret := C.GoBytes(unsafe.Pointer(_lv_bytearray.data), C.int(int64(_lv_bytearray.len)))
|
|
C.free(unsafe.Pointer(_lv_bytearray.data))
|
|
_ret[i] = _lv_ret
|
|
}
|
|
return _ret
|
|
}
|
|
|
|
func (this *QMediaServiceSupportedDevicesInterface) DeviceDescription(service []byte, device []byte) string {
|
|
service_alias := C.struct_miqt_string{}
|
|
service_alias.data = (*C.char)(unsafe.Pointer(&service[0]))
|
|
service_alias.len = C.size_t(len(service))
|
|
device_alias := C.struct_miqt_string{}
|
|
device_alias.data = (*C.char)(unsafe.Pointer(&device[0]))
|
|
device_alias.len = C.size_t(len(device))
|
|
var _ms C.struct_miqt_string = C.QMediaServiceSupportedDevicesInterface_DeviceDescription(this.h, service_alias, device_alias)
|
|
_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
|
|
C.free(unsafe.Pointer(_ms.data))
|
|
return _ret
|
|
}
|
|
|
|
func (this *QMediaServiceSupportedDevicesInterface) OperatorAssign(param1 *QMediaServiceSupportedDevicesInterface) {
|
|
C.QMediaServiceSupportedDevicesInterface_OperatorAssign(this.h, param1.cPointer())
|
|
}
|
|
|
|
// Delete this object from C++ memory.
|
|
func (this *QMediaServiceSupportedDevicesInterface) Delete() {
|
|
C.QMediaServiceSupportedDevicesInterface_Delete(this.h, C.bool(this.isSubclass))
|
|
}
|
|
|
|
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
|
|
// from C++ memory once it is unreachable from Go memory.
|
|
func (this *QMediaServiceSupportedDevicesInterface) GoGC() {
|
|
runtime.SetFinalizer(this, func(this *QMediaServiceSupportedDevicesInterface) {
|
|
this.Delete()
|
|
runtime.KeepAlive(this.h)
|
|
})
|
|
}
|
|
|
|
type QMediaServiceDefaultDeviceInterface struct {
|
|
h *C.QMediaServiceDefaultDeviceInterface
|
|
isSubclass bool
|
|
}
|
|
|
|
func (this *QMediaServiceDefaultDeviceInterface) cPointer() *C.QMediaServiceDefaultDeviceInterface {
|
|
if this == nil {
|
|
return nil
|
|
}
|
|
return this.h
|
|
}
|
|
|
|
func (this *QMediaServiceDefaultDeviceInterface) UnsafePointer() unsafe.Pointer {
|
|
if this == nil {
|
|
return nil
|
|
}
|
|
return unsafe.Pointer(this.h)
|
|
}
|
|
|
|
// newQMediaServiceDefaultDeviceInterface constructs the type using only CGO pointers.
|
|
func newQMediaServiceDefaultDeviceInterface(h *C.QMediaServiceDefaultDeviceInterface) *QMediaServiceDefaultDeviceInterface {
|
|
if h == nil {
|
|
return nil
|
|
}
|
|
return &QMediaServiceDefaultDeviceInterface{h: h}
|
|
}
|
|
|
|
// UnsafeNewQMediaServiceDefaultDeviceInterface constructs the type using only unsafe pointers.
|
|
func UnsafeNewQMediaServiceDefaultDeviceInterface(h unsafe.Pointer) *QMediaServiceDefaultDeviceInterface {
|
|
if h == nil {
|
|
return nil
|
|
}
|
|
|
|
return &QMediaServiceDefaultDeviceInterface{h: (*C.QMediaServiceDefaultDeviceInterface)(h)}
|
|
}
|
|
|
|
func (this *QMediaServiceDefaultDeviceInterface) DefaultDevice(service []byte) []byte {
|
|
service_alias := C.struct_miqt_string{}
|
|
service_alias.data = (*C.char)(unsafe.Pointer(&service[0]))
|
|
service_alias.len = C.size_t(len(service))
|
|
var _bytearray C.struct_miqt_string = C.QMediaServiceDefaultDeviceInterface_DefaultDevice(this.h, service_alias)
|
|
_ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len)))
|
|
C.free(unsafe.Pointer(_bytearray.data))
|
|
return _ret
|
|
}
|
|
|
|
func (this *QMediaServiceDefaultDeviceInterface) OperatorAssign(param1 *QMediaServiceDefaultDeviceInterface) {
|
|
C.QMediaServiceDefaultDeviceInterface_OperatorAssign(this.h, param1.cPointer())
|
|
}
|
|
|
|
// Delete this object from C++ memory.
|
|
func (this *QMediaServiceDefaultDeviceInterface) Delete() {
|
|
C.QMediaServiceDefaultDeviceInterface_Delete(this.h, C.bool(this.isSubclass))
|
|
}
|
|
|
|
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
|
|
// from C++ memory once it is unreachable from Go memory.
|
|
func (this *QMediaServiceDefaultDeviceInterface) GoGC() {
|
|
runtime.SetFinalizer(this, func(this *QMediaServiceDefaultDeviceInterface) {
|
|
this.Delete()
|
|
runtime.KeepAlive(this.h)
|
|
})
|
|
}
|
|
|
|
type QMediaServiceCameraInfoInterface struct {
|
|
h *C.QMediaServiceCameraInfoInterface
|
|
isSubclass bool
|
|
}
|
|
|
|
func (this *QMediaServiceCameraInfoInterface) cPointer() *C.QMediaServiceCameraInfoInterface {
|
|
if this == nil {
|
|
return nil
|
|
}
|
|
return this.h
|
|
}
|
|
|
|
func (this *QMediaServiceCameraInfoInterface) UnsafePointer() unsafe.Pointer {
|
|
if this == nil {
|
|
return nil
|
|
}
|
|
return unsafe.Pointer(this.h)
|
|
}
|
|
|
|
// newQMediaServiceCameraInfoInterface constructs the type using only CGO pointers.
|
|
func newQMediaServiceCameraInfoInterface(h *C.QMediaServiceCameraInfoInterface) *QMediaServiceCameraInfoInterface {
|
|
if h == nil {
|
|
return nil
|
|
}
|
|
return &QMediaServiceCameraInfoInterface{h: h}
|
|
}
|
|
|
|
// UnsafeNewQMediaServiceCameraInfoInterface constructs the type using only unsafe pointers.
|
|
func UnsafeNewQMediaServiceCameraInfoInterface(h unsafe.Pointer) *QMediaServiceCameraInfoInterface {
|
|
if h == nil {
|
|
return nil
|
|
}
|
|
|
|
return &QMediaServiceCameraInfoInterface{h: (*C.QMediaServiceCameraInfoInterface)(h)}
|
|
}
|
|
|
|
func (this *QMediaServiceCameraInfoInterface) CameraPosition(device []byte) QCamera__Position {
|
|
device_alias := C.struct_miqt_string{}
|
|
device_alias.data = (*C.char)(unsafe.Pointer(&device[0]))
|
|
device_alias.len = C.size_t(len(device))
|
|
return (QCamera__Position)(C.QMediaServiceCameraInfoInterface_CameraPosition(this.h, device_alias))
|
|
}
|
|
|
|
func (this *QMediaServiceCameraInfoInterface) CameraOrientation(device []byte) int {
|
|
device_alias := C.struct_miqt_string{}
|
|
device_alias.data = (*C.char)(unsafe.Pointer(&device[0]))
|
|
device_alias.len = C.size_t(len(device))
|
|
return (int)(C.QMediaServiceCameraInfoInterface_CameraOrientation(this.h, device_alias))
|
|
}
|
|
|
|
func (this *QMediaServiceCameraInfoInterface) OperatorAssign(param1 *QMediaServiceCameraInfoInterface) {
|
|
C.QMediaServiceCameraInfoInterface_OperatorAssign(this.h, param1.cPointer())
|
|
}
|
|
|
|
// Delete this object from C++ memory.
|
|
func (this *QMediaServiceCameraInfoInterface) Delete() {
|
|
C.QMediaServiceCameraInfoInterface_Delete(this.h, C.bool(this.isSubclass))
|
|
}
|
|
|
|
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
|
|
// from C++ memory once it is unreachable from Go memory.
|
|
func (this *QMediaServiceCameraInfoInterface) GoGC() {
|
|
runtime.SetFinalizer(this, func(this *QMediaServiceCameraInfoInterface) {
|
|
this.Delete()
|
|
runtime.KeepAlive(this.h)
|
|
})
|
|
}
|
|
|
|
type QMediaServiceFeaturesInterface struct {
|
|
h *C.QMediaServiceFeaturesInterface
|
|
isSubclass bool
|
|
}
|
|
|
|
func (this *QMediaServiceFeaturesInterface) cPointer() *C.QMediaServiceFeaturesInterface {
|
|
if this == nil {
|
|
return nil
|
|
}
|
|
return this.h
|
|
}
|
|
|
|
func (this *QMediaServiceFeaturesInterface) UnsafePointer() unsafe.Pointer {
|
|
if this == nil {
|
|
return nil
|
|
}
|
|
return unsafe.Pointer(this.h)
|
|
}
|
|
|
|
// newQMediaServiceFeaturesInterface constructs the type using only CGO pointers.
|
|
func newQMediaServiceFeaturesInterface(h *C.QMediaServiceFeaturesInterface) *QMediaServiceFeaturesInterface {
|
|
if h == nil {
|
|
return nil
|
|
}
|
|
return &QMediaServiceFeaturesInterface{h: h}
|
|
}
|
|
|
|
// UnsafeNewQMediaServiceFeaturesInterface constructs the type using only unsafe pointers.
|
|
func UnsafeNewQMediaServiceFeaturesInterface(h unsafe.Pointer) *QMediaServiceFeaturesInterface {
|
|
if h == nil {
|
|
return nil
|
|
}
|
|
|
|
return &QMediaServiceFeaturesInterface{h: (*C.QMediaServiceFeaturesInterface)(h)}
|
|
}
|
|
|
|
func (this *QMediaServiceFeaturesInterface) SupportedFeatures(service []byte) QMediaServiceProviderHint__Feature {
|
|
service_alias := C.struct_miqt_string{}
|
|
service_alias.data = (*C.char)(unsafe.Pointer(&service[0]))
|
|
service_alias.len = C.size_t(len(service))
|
|
return (QMediaServiceProviderHint__Feature)(C.QMediaServiceFeaturesInterface_SupportedFeatures(this.h, service_alias))
|
|
}
|
|
|
|
func (this *QMediaServiceFeaturesInterface) OperatorAssign(param1 *QMediaServiceFeaturesInterface) {
|
|
C.QMediaServiceFeaturesInterface_OperatorAssign(this.h, param1.cPointer())
|
|
}
|
|
|
|
// Delete this object from C++ memory.
|
|
func (this *QMediaServiceFeaturesInterface) Delete() {
|
|
C.QMediaServiceFeaturesInterface_Delete(this.h, C.bool(this.isSubclass))
|
|
}
|
|
|
|
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
|
|
// from C++ memory once it is unreachable from Go memory.
|
|
func (this *QMediaServiceFeaturesInterface) GoGC() {
|
|
runtime.SetFinalizer(this, func(this *QMediaServiceFeaturesInterface) {
|
|
this.Delete()
|
|
runtime.KeepAlive(this.h)
|
|
})
|
|
}
|
|
|
|
type QMediaServiceProviderPlugin struct {
|
|
h *C.QMediaServiceProviderPlugin
|
|
isSubclass bool
|
|
*qt.QObject
|
|
*QMediaServiceProviderFactoryInterface
|
|
}
|
|
|
|
func (this *QMediaServiceProviderPlugin) cPointer() *C.QMediaServiceProviderPlugin {
|
|
if this == nil {
|
|
return nil
|
|
}
|
|
return this.h
|
|
}
|
|
|
|
func (this *QMediaServiceProviderPlugin) UnsafePointer() unsafe.Pointer {
|
|
if this == nil {
|
|
return nil
|
|
}
|
|
return unsafe.Pointer(this.h)
|
|
}
|
|
|
|
// newQMediaServiceProviderPlugin constructs the type using only CGO pointers.
|
|
func newQMediaServiceProviderPlugin(h *C.QMediaServiceProviderPlugin, h_QObject *C.QObject, h_QMediaServiceProviderFactoryInterface *C.QMediaServiceProviderFactoryInterface) *QMediaServiceProviderPlugin {
|
|
if h == nil {
|
|
return nil
|
|
}
|
|
return &QMediaServiceProviderPlugin{h: h,
|
|
QObject: qt.UnsafeNewQObject(unsafe.Pointer(h_QObject)),
|
|
QMediaServiceProviderFactoryInterface: newQMediaServiceProviderFactoryInterface(h_QMediaServiceProviderFactoryInterface)}
|
|
}
|
|
|
|
// UnsafeNewQMediaServiceProviderPlugin constructs the type using only unsafe pointers.
|
|
func UnsafeNewQMediaServiceProviderPlugin(h unsafe.Pointer, h_QObject unsafe.Pointer, h_QMediaServiceProviderFactoryInterface unsafe.Pointer) *QMediaServiceProviderPlugin {
|
|
if h == nil {
|
|
return nil
|
|
}
|
|
|
|
return &QMediaServiceProviderPlugin{h: (*C.QMediaServiceProviderPlugin)(h),
|
|
QObject: qt.UnsafeNewQObject(h_QObject),
|
|
QMediaServiceProviderFactoryInterface: UnsafeNewQMediaServiceProviderFactoryInterface(h_QMediaServiceProviderFactoryInterface)}
|
|
}
|
|
|
|
func (this *QMediaServiceProviderPlugin) MetaObject() *qt.QMetaObject {
|
|
return qt.UnsafeNewQMetaObject(unsafe.Pointer(C.QMediaServiceProviderPlugin_MetaObject(this.h)))
|
|
}
|
|
|
|
func (this *QMediaServiceProviderPlugin) Metacast(param1 string) unsafe.Pointer {
|
|
param1_Cstring := C.CString(param1)
|
|
defer C.free(unsafe.Pointer(param1_Cstring))
|
|
return (unsafe.Pointer)(C.QMediaServiceProviderPlugin_Metacast(this.h, param1_Cstring))
|
|
}
|
|
|
|
func QMediaServiceProviderPlugin_Tr(s string) string {
|
|
s_Cstring := C.CString(s)
|
|
defer C.free(unsafe.Pointer(s_Cstring))
|
|
var _ms C.struct_miqt_string = C.QMediaServiceProviderPlugin_Tr(s_Cstring)
|
|
_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
|
|
C.free(unsafe.Pointer(_ms.data))
|
|
return _ret
|
|
}
|
|
|
|
func QMediaServiceProviderPlugin_TrUtf8(s string) string {
|
|
s_Cstring := C.CString(s)
|
|
defer C.free(unsafe.Pointer(s_Cstring))
|
|
var _ms C.struct_miqt_string = C.QMediaServiceProviderPlugin_TrUtf8(s_Cstring)
|
|
_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
|
|
C.free(unsafe.Pointer(_ms.data))
|
|
return _ret
|
|
}
|
|
|
|
func (this *QMediaServiceProviderPlugin) Create(key string) *QMediaService {
|
|
key_ms := C.struct_miqt_string{}
|
|
key_ms.data = C.CString(key)
|
|
key_ms.len = C.size_t(len(key))
|
|
defer C.free(unsafe.Pointer(key_ms.data))
|
|
return UnsafeNewQMediaService(unsafe.Pointer(C.QMediaServiceProviderPlugin_Create(this.h, key_ms)), nil)
|
|
}
|
|
|
|
func (this *QMediaServiceProviderPlugin) Release(service *QMediaService) {
|
|
C.QMediaServiceProviderPlugin_Release(this.h, service.cPointer())
|
|
}
|
|
|
|
func QMediaServiceProviderPlugin_Tr2(s string, c string) string {
|
|
s_Cstring := C.CString(s)
|
|
defer C.free(unsafe.Pointer(s_Cstring))
|
|
c_Cstring := C.CString(c)
|
|
defer C.free(unsafe.Pointer(c_Cstring))
|
|
var _ms C.struct_miqt_string = C.QMediaServiceProviderPlugin_Tr2(s_Cstring, c_Cstring)
|
|
_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
|
|
C.free(unsafe.Pointer(_ms.data))
|
|
return _ret
|
|
}
|
|
|
|
func QMediaServiceProviderPlugin_Tr3(s string, c string, n int) string {
|
|
s_Cstring := C.CString(s)
|
|
defer C.free(unsafe.Pointer(s_Cstring))
|
|
c_Cstring := C.CString(c)
|
|
defer C.free(unsafe.Pointer(c_Cstring))
|
|
var _ms C.struct_miqt_string = C.QMediaServiceProviderPlugin_Tr3(s_Cstring, c_Cstring, (C.int)(n))
|
|
_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
|
|
C.free(unsafe.Pointer(_ms.data))
|
|
return _ret
|
|
}
|
|
|
|
func QMediaServiceProviderPlugin_TrUtf82(s string, c string) string {
|
|
s_Cstring := C.CString(s)
|
|
defer C.free(unsafe.Pointer(s_Cstring))
|
|
c_Cstring := C.CString(c)
|
|
defer C.free(unsafe.Pointer(c_Cstring))
|
|
var _ms C.struct_miqt_string = C.QMediaServiceProviderPlugin_TrUtf82(s_Cstring, c_Cstring)
|
|
_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
|
|
C.free(unsafe.Pointer(_ms.data))
|
|
return _ret
|
|
}
|
|
|
|
func QMediaServiceProviderPlugin_TrUtf83(s string, c string, n int) string {
|
|
s_Cstring := C.CString(s)
|
|
defer C.free(unsafe.Pointer(s_Cstring))
|
|
c_Cstring := C.CString(c)
|
|
defer C.free(unsafe.Pointer(c_Cstring))
|
|
var _ms C.struct_miqt_string = C.QMediaServiceProviderPlugin_TrUtf83(s_Cstring, c_Cstring, (C.int)(n))
|
|
_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
|
|
C.free(unsafe.Pointer(_ms.data))
|
|
return _ret
|
|
}
|
|
|
|
// Delete this object from C++ memory.
|
|
func (this *QMediaServiceProviderPlugin) Delete() {
|
|
C.QMediaServiceProviderPlugin_Delete(this.h, C.bool(this.isSubclass))
|
|
}
|
|
|
|
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
|
|
// from C++ memory once it is unreachable from Go memory.
|
|
func (this *QMediaServiceProviderPlugin) GoGC() {
|
|
runtime.SetFinalizer(this, func(this *QMediaServiceProviderPlugin) {
|
|
this.Delete()
|
|
runtime.KeepAlive(this.h)
|
|
})
|
|
}
|