From 069f5affceb5fb7b6344f4ea358a6fe1287f1221 Mon Sep 17 00:00:00 2001 From: "cathy-cloud[bot]" <154095190+cathy-cloud[bot]@users.noreply.github.com> Date: Fri, 5 Sep 2025 00:02:14 +0000 Subject: [PATCH] Bump OBS websocket protocol to 5.6.0 --- README.md | 12 ++-- .../xx_generated.inputs.inputcreated.go | 3 + ...generated.getinputdeinterlacefieldorder.go | 58 +++++++++++++++++ .../xx_generated.getinputdeinterlacemode.go | 65 +++++++++++++++++++ ...generated.setinputdeinterlacefieldorder.go | 56 ++++++++++++++++ .../xx_generated.setinputdeinterlacemode.go | 53 +++++++++++++++ docs/request-mapping.md | 4 ++ version.go | 2 +- zz_generated._test.go | 34 ++++++++++ 9 files changed, 280 insertions(+), 7 deletions(-) create mode 100644 api/requests/inputs/xx_generated.getinputdeinterlacefieldorder.go create mode 100644 api/requests/inputs/xx_generated.getinputdeinterlacemode.go create mode 100644 api/requests/inputs/xx_generated.setinputdeinterlacefieldorder.go create mode 100644 api/requests/inputs/xx_generated.setinputdeinterlacemode.go diff --git a/README.md b/README.md index 779c8896..6908d203 100644 --- a/README.md +++ b/README.md @@ -5,8 +5,8 @@ [![Build Status][build-img]][build-url] [![Go Report][goreport-img]][goreport-url] -[protocol-img]: https://img.shields.io/badge/obs--websocket-v5.5.6-blue?logo=obs-studio&style=flat-square -[protocol-url]: https://github.com/obsproject/obs-websocket/blob/5.5.6/docs/generated/protocol.md +[protocol-img]: https://img.shields.io/badge/obs--websocket-v5.6.0-blue?logo=obs-studio&style=flat-square +[protocol-url]: https://github.com/obsproject/obs-websocket/blob/5.6.0/docs/generated/protocol.md [doc-img]: https://img.shields.io/badge/pkg.go.dev-reference-blue?logo=go&logoColor=white&style=flat-square [doc-url]: https://pkg.go.dev/github.com/andreykaipov/goobs [build-img]: https://img.shields.io/github/actions/workflow/status/andreykaipov/goobs/ci.yml?logo=github&style=flat-square&branch=main @@ -66,9 +66,9 @@ The corresponding output: [//]: # (snippet-2-begin) ```console ❯ go run _examples/basic/main.go -OBS Studio version: 31.0.1 -Server protocol version: 5.5.4 -Client protocol version: 5.5.6 -Client library version: 1.5.6 +OBS Studio version: 32.0.0 +Server protocol version: 5.6.2 +Client protocol version: 5.6.0 +Client library version: 1.6.0 ``` [//]: # (snippet-2-end) diff --git a/api/events/xx_generated.inputs.inputcreated.go b/api/events/xx_generated.inputs.inputcreated.go index 9c5a7735..4389d1ff 100644 --- a/api/events/xx_generated.inputs.inputcreated.go +++ b/api/events/xx_generated.inputs.inputcreated.go @@ -14,6 +14,9 @@ type InputCreated struct { // The kind of the input InputKind string `json:"inputKind,omitempty"` + // Bitflag value for the caps that an input supports. See obs_source_info.output_flags in the libobs docs + InputKindCaps float64 `json:"inputKindCaps,omitempty"` + // Name of the input InputName string `json:"inputName,omitempty"` diff --git a/api/requests/inputs/xx_generated.getinputdeinterlacefieldorder.go b/api/requests/inputs/xx_generated.getinputdeinterlacefieldorder.go new file mode 100644 index 00000000..5fd4671e --- /dev/null +++ b/api/requests/inputs/xx_generated.getinputdeinterlacefieldorder.go @@ -0,0 +1,58 @@ +// This file has been automatically generated. Don't edit it. + +package inputs + +// Represents the request body for the GetInputDeinterlaceFieldOrder request. +type GetInputDeinterlaceFieldOrderParams struct { + // Name of the input + InputName *string `json:"inputName,omitempty"` + + // UUID of the input + InputUuid *string `json:"inputUuid,omitempty"` +} + +func NewGetInputDeinterlaceFieldOrderParams() *GetInputDeinterlaceFieldOrderParams { + return &GetInputDeinterlaceFieldOrderParams{} +} +func (o *GetInputDeinterlaceFieldOrderParams) WithInputName(x string) *GetInputDeinterlaceFieldOrderParams { + o.InputName = &x + return o +} +func (o *GetInputDeinterlaceFieldOrderParams) WithInputUuid(x string) *GetInputDeinterlaceFieldOrderParams { + o.InputUuid = &x + return o +} + +// Returns the associated request. +func (o *GetInputDeinterlaceFieldOrderParams) GetRequestName() string { + return "GetInputDeinterlaceFieldOrder" +} + +// Represents the response body for the GetInputDeinterlaceFieldOrder request. +type GetInputDeinterlaceFieldOrderResponse struct { + _response + + // Deinterlace field order of the input + InputDeinterlaceFieldOrder string `json:"inputDeinterlaceFieldOrder,omitempty"` +} + +/* +Gets the deinterlace field order of an input. + +Deinterlace Field Orders: + +- `OBS_DEINTERLACE_FIELD_ORDER_TOP` +- `OBS_DEINTERLACE_FIELD_ORDER_BOTTOM` + +Note: Deinterlacing functionality is restricted to async inputs only. +*/ +func (c *Client) GetInputDeinterlaceFieldOrder( + paramss ...*GetInputDeinterlaceFieldOrderParams, +) (*GetInputDeinterlaceFieldOrderResponse, error) { + if len(paramss) == 0 { + paramss = []*GetInputDeinterlaceFieldOrderParams{{}} + } + params := paramss[0] + data := &GetInputDeinterlaceFieldOrderResponse{} + return data, c.client.SendRequest(params, data) +} diff --git a/api/requests/inputs/xx_generated.getinputdeinterlacemode.go b/api/requests/inputs/xx_generated.getinputdeinterlacemode.go new file mode 100644 index 00000000..e813c709 --- /dev/null +++ b/api/requests/inputs/xx_generated.getinputdeinterlacemode.go @@ -0,0 +1,65 @@ +// This file has been automatically generated. Don't edit it. + +package inputs + +// Represents the request body for the GetInputDeinterlaceMode request. +type GetInputDeinterlaceModeParams struct { + // Name of the input + InputName *string `json:"inputName,omitempty"` + + // UUID of the input + InputUuid *string `json:"inputUuid,omitempty"` +} + +func NewGetInputDeinterlaceModeParams() *GetInputDeinterlaceModeParams { + return &GetInputDeinterlaceModeParams{} +} +func (o *GetInputDeinterlaceModeParams) WithInputName(x string) *GetInputDeinterlaceModeParams { + o.InputName = &x + return o +} +func (o *GetInputDeinterlaceModeParams) WithInputUuid(x string) *GetInputDeinterlaceModeParams { + o.InputUuid = &x + return o +} + +// Returns the associated request. +func (o *GetInputDeinterlaceModeParams) GetRequestName() string { + return "GetInputDeinterlaceMode" +} + +// Represents the response body for the GetInputDeinterlaceMode request. +type GetInputDeinterlaceModeResponse struct { + _response + + // Deinterlace mode of the input + InputDeinterlaceMode string `json:"inputDeinterlaceMode,omitempty"` +} + +/* +Gets the deinterlace mode of an input. + +Deinterlace Modes: + +- `OBS_DEINTERLACE_MODE_DISABLE` +- `OBS_DEINTERLACE_MODE_DISCARD` +- `OBS_DEINTERLACE_MODE_RETRO` +- `OBS_DEINTERLACE_MODE_BLEND` +- `OBS_DEINTERLACE_MODE_BLEND_2X` +- `OBS_DEINTERLACE_MODE_LINEAR` +- `OBS_DEINTERLACE_MODE_LINEAR_2X` +- `OBS_DEINTERLACE_MODE_YADIF` +- `OBS_DEINTERLACE_MODE_YADIF_2X` + +Note: Deinterlacing functionality is restricted to async inputs only. +*/ +func (c *Client) GetInputDeinterlaceMode( + paramss ...*GetInputDeinterlaceModeParams, +) (*GetInputDeinterlaceModeResponse, error) { + if len(paramss) == 0 { + paramss = []*GetInputDeinterlaceModeParams{{}} + } + params := paramss[0] + data := &GetInputDeinterlaceModeResponse{} + return data, c.client.SendRequest(params, data) +} diff --git a/api/requests/inputs/xx_generated.setinputdeinterlacefieldorder.go b/api/requests/inputs/xx_generated.setinputdeinterlacefieldorder.go new file mode 100644 index 00000000..75d8ee0e --- /dev/null +++ b/api/requests/inputs/xx_generated.setinputdeinterlacefieldorder.go @@ -0,0 +1,56 @@ +// This file has been automatically generated. Don't edit it. + +package inputs + +// Represents the request body for the SetInputDeinterlaceFieldOrder request. +type SetInputDeinterlaceFieldOrderParams struct { + // Deinterlace field order for the input + InputDeinterlaceFieldOrder *string `json:"inputDeinterlaceFieldOrder,omitempty"` + + // Name of the input + InputName *string `json:"inputName,omitempty"` + + // UUID of the input + InputUuid *string `json:"inputUuid,omitempty"` +} + +func NewSetInputDeinterlaceFieldOrderParams() *SetInputDeinterlaceFieldOrderParams { + return &SetInputDeinterlaceFieldOrderParams{} +} + +func (o *SetInputDeinterlaceFieldOrderParams) WithInputDeinterlaceFieldOrder( + x string, +) *SetInputDeinterlaceFieldOrderParams { + o.InputDeinterlaceFieldOrder = &x + return o +} +func (o *SetInputDeinterlaceFieldOrderParams) WithInputName(x string) *SetInputDeinterlaceFieldOrderParams { + o.InputName = &x + return o +} +func (o *SetInputDeinterlaceFieldOrderParams) WithInputUuid(x string) *SetInputDeinterlaceFieldOrderParams { + o.InputUuid = &x + return o +} + +// Returns the associated request. +func (o *SetInputDeinterlaceFieldOrderParams) GetRequestName() string { + return "SetInputDeinterlaceFieldOrder" +} + +// Represents the response body for the SetInputDeinterlaceFieldOrder request. +type SetInputDeinterlaceFieldOrderResponse struct { + _response +} + +/* +Sets the deinterlace field order of an input. + +Note: Deinterlacing functionality is restricted to async inputs only. +*/ +func (c *Client) SetInputDeinterlaceFieldOrder( + params *SetInputDeinterlaceFieldOrderParams, +) (*SetInputDeinterlaceFieldOrderResponse, error) { + data := &SetInputDeinterlaceFieldOrderResponse{} + return data, c.client.SendRequest(params, data) +} diff --git a/api/requests/inputs/xx_generated.setinputdeinterlacemode.go b/api/requests/inputs/xx_generated.setinputdeinterlacemode.go new file mode 100644 index 00000000..c44acd25 --- /dev/null +++ b/api/requests/inputs/xx_generated.setinputdeinterlacemode.go @@ -0,0 +1,53 @@ +// This file has been automatically generated. Don't edit it. + +package inputs + +// Represents the request body for the SetInputDeinterlaceMode request. +type SetInputDeinterlaceModeParams struct { + // Deinterlace mode for the input + InputDeinterlaceMode *string `json:"inputDeinterlaceMode,omitempty"` + + // Name of the input + InputName *string `json:"inputName,omitempty"` + + // UUID of the input + InputUuid *string `json:"inputUuid,omitempty"` +} + +func NewSetInputDeinterlaceModeParams() *SetInputDeinterlaceModeParams { + return &SetInputDeinterlaceModeParams{} +} +func (o *SetInputDeinterlaceModeParams) WithInputDeinterlaceMode(x string) *SetInputDeinterlaceModeParams { + o.InputDeinterlaceMode = &x + return o +} +func (o *SetInputDeinterlaceModeParams) WithInputName(x string) *SetInputDeinterlaceModeParams { + o.InputName = &x + return o +} +func (o *SetInputDeinterlaceModeParams) WithInputUuid(x string) *SetInputDeinterlaceModeParams { + o.InputUuid = &x + return o +} + +// Returns the associated request. +func (o *SetInputDeinterlaceModeParams) GetRequestName() string { + return "SetInputDeinterlaceMode" +} + +// Represents the response body for the SetInputDeinterlaceMode request. +type SetInputDeinterlaceModeResponse struct { + _response +} + +/* +Sets the deinterlace mode of an input. + +Note: Deinterlacing functionality is restricted to async inputs only. +*/ +func (c *Client) SetInputDeinterlaceMode( + params *SetInputDeinterlaceModeParams, +) (*SetInputDeinterlaceModeResponse, error) { + data := &SetInputDeinterlaceModeResponse{} + return data, c.client.SendRequest(params, data) +} diff --git a/docs/request-mapping.md b/docs/request-mapping.md index cfce69fd..622d2c3a 100644 --- a/docs/request-mapping.md +++ b/docs/request-mapping.md @@ -64,6 +64,8 @@ The following tables show how to make the appropriate `goobs` request for any gi | GetInputAudioSyncOffset | `client.Inputs.GetInputAudioSyncOffset(...)` | | GetInputAudioTracks | `client.Inputs.GetInputAudioTracks(...)` | | GetInputDefaultSettings | `client.Inputs.GetInputDefaultSettings(...)` | +| GetInputDeinterlaceFieldOrder | `client.Inputs.GetInputDeinterlaceFieldOrder(...)` | +| GetInputDeinterlaceMode | `client.Inputs.GetInputDeinterlaceMode(...)` | | GetInputKindList | `client.Inputs.GetInputKindList(...)` | | GetInputList | `client.Inputs.GetInputList(...)` | | GetInputMute | `client.Inputs.GetInputMute(...)` | @@ -77,6 +79,8 @@ The following tables show how to make the appropriate `goobs` request for any gi | SetInputAudioMonitorType | `client.Inputs.SetInputAudioMonitorType(...)` | | SetInputAudioSyncOffset | `client.Inputs.SetInputAudioSyncOffset(...)` | | SetInputAudioTracks | `client.Inputs.SetInputAudioTracks(...)` | +| SetInputDeinterlaceFieldOrder | `client.Inputs.SetInputDeinterlaceFieldOrder(...)` | +| SetInputDeinterlaceMode | `client.Inputs.SetInputDeinterlaceMode(...)` | | SetInputMute | `client.Inputs.SetInputMute(...)` | | SetInputName | `client.Inputs.SetInputName(...)` | | SetInputSettings | `client.Inputs.SetInputSettings(...)` | diff --git a/version.go b/version.go index 7765c1e7..17b8a7d5 100644 --- a/version.go +++ b/version.go @@ -7,7 +7,7 @@ import ( const lib = "github.com/andreykaipov/goobs" -var ProtocolVersion = "5.5.6" +var ProtocolVersion = "5.6.0" var LibraryVersion = func() string { bi, ok := debug.ReadBuildInfo() diff --git a/zz_generated._test.go b/zz_generated._test.go index aa26866e..5c89cdbb 100644 --- a/zz_generated._test.go +++ b/zz_generated._test.go @@ -384,6 +384,22 @@ func Test_inputs(t *testing.T) { t.Logf("%s", err) } assert.NoError(t, err) + _, err = client.Inputs.GetInputDeinterlaceFieldOrder(&inputs.GetInputDeinterlaceFieldOrderParams{ + InputName: &[]string{"test2"}[0], + InputUuid: &[]string{"test2"}[0], + }) + if err != nil { + t.Logf("%s", err) + } + assert.NoError(t, err) + _, err = client.Inputs.GetInputDeinterlaceMode(&inputs.GetInputDeinterlaceModeParams{ + InputName: &[]string{"test2"}[0], + InputUuid: &[]string{"test2"}[0], + }) + if err != nil { + t.Logf("%s", err) + } + assert.NoError(t, err) _, err = client.Inputs.GetInputKindList(&inputs.GetInputKindListParams{Unversioned: &[]bool{true}[0]}) if err != nil { t.Logf("%s", err) @@ -477,6 +493,24 @@ func Test_inputs(t *testing.T) { t.Logf("%s", err) } assert.NoError(t, err) + _, err = client.Inputs.SetInputDeinterlaceFieldOrder(&inputs.SetInputDeinterlaceFieldOrderParams{ + InputDeinterlaceFieldOrder: &[]string{"test2"}[0], + InputName: &[]string{"test2"}[0], + InputUuid: &[]string{"test2"}[0], + }) + if err != nil { + t.Logf("%s", err) + } + assert.NoError(t, err) + _, err = client.Inputs.SetInputDeinterlaceMode(&inputs.SetInputDeinterlaceModeParams{ + InputDeinterlaceMode: &[]string{"test2"}[0], + InputName: &[]string{"test2"}[0], + InputUuid: &[]string{"test2"}[0], + }) + if err != nil { + t.Logf("%s", err) + } + assert.NoError(t, err) _, err = client.Inputs.SetInputMute(&inputs.SetInputMuteParams{ InputMuted: &[]bool{true}[0], InputName: &[]string{"test2"}[0],