diff --git a/src/inputs/librespot-c/Makefile.am b/src/inputs/librespot-c/Makefile.am index 6916a28a..3362b294 100644 --- a/src/inputs/librespot-c/Makefile.am +++ b/src/inputs/librespot-c/Makefile.am @@ -22,7 +22,12 @@ HTTP_PROTO_SRC = \ src/proto/login5_challenges_hashcash.pb-c.h src/proto/login5_challenges_hashcash.pb-c.c \ src/proto/login5_challenges_code.pb-c.h src/proto/login5_challenges_code.pb-c.c \ src/proto/google_duration.pb-c.h src/proto/google_duration.pb-c.c \ - src/proto/storage_resolve.pb-c.h src/proto/storage_resolve.pb-c.c + src/proto/storage_resolve.pb-c.h src/proto/storage_resolve.pb-c.c \ + src/proto/extended_metadata.pb-c.h src/proto/extended_metadata.pb-c.c \ + src/proto/extension_kind.pb-c.h src/proto/extension_kind.pb-c.c \ + src/proto/entity_extension_data.pb-c.h src/proto/entity_extension_data.pb-c.c \ + src/proto/google_any.pb-c.h src/proto/google_any.pb-c.c + CORE_SRC = \ src/librespot-c.c src/connection.c src/channel.c src/crypto.c src/commands.c \ diff --git a/src/inputs/librespot-c/librespot-c.h b/src/inputs/librespot-c/librespot-c.h index 7b7da737..0f8d61f0 100644 --- a/src/inputs/librespot-c/librespot-c.h +++ b/src/inputs/librespot-c/librespot-c.h @@ -6,7 +6,7 @@ #include #define LIBRESPOT_C_VERSION_MAJOR 0 -#define LIBRESPOT_C_VERSION_MINOR 6 +#define LIBRESPOT_C_VERSION_MINOR 7 struct sp_session; diff --git a/src/inputs/librespot-c/src/connection.c b/src/inputs/librespot-c/src/connection.c index 38feee7d..c22121f8 100644 --- a/src/inputs/librespot-c/src/connection.c +++ b/src/inputs/librespot-c/src/connection.c @@ -1049,6 +1049,8 @@ handle_login5(struct sp_message *msg, struct sp_session *session) return ret; } +// If we don't get a proper response we fall back to requesting extended +// metadata, thus this function fails since that would abort the sequence static enum sp_error handle_metadata_get(struct sp_message *msg, struct sp_session *session) { @@ -1058,22 +1060,89 @@ handle_metadata_get(struct sp_message *msg, struct sp_session *session) int ret; if (hres->code != HTTP_OK) - RETURN_ERROR(SP_ERR_INVALID, "Request for metadata returned an error"); + goto fallback; - // FIXME Use Episode object for file.media_type == SP_MEDIA_EPISODE + // Also works for Episode response response = track__unpack(NULL, hres->body_len, hres->body); if (!response) - RETURN_ERROR(SP_ERR_INVALID, "Could not parse metadata response"); + goto fallback; ret = file_select(channel->file.id, sizeof(channel->file.id), response, session->bitrate_preferred); if (ret < 0) - RETURN_ERROR(SP_ERR_INVALID, "Could not find track data"); + goto fallback; track__free_unpacked(response, NULL); return SP_OK_DONE; - error: + fallback: + sp_cb.logmsg("Couldn't find file id in metadata response, will request extended metadata\n"); + track__free_unpacked(response, NULL); + return SP_OK_DONE; +} + +// We need to find the file.id (necessary to get the audio key) which is buried +// deep in the extended metadata response. Originally, it was also included in +// a metadata request, but that was broken by Spotify in spclient responses, +// except, weirdly, when requesting spclient.wg.spotify.com. The below method +// should match what go-librespot does. +static enum sp_error +handle_extended_metadata_get(struct sp_message *msg, struct sp_session *session) +{ + struct http_response *hres = &msg->payload.hres; + struct sp_channel *channel = session->now_streaming_channel; + Spotify__Extendedmetadata__BatchedExtensionResponse *response = NULL; + Spotify__Extendedmetadata__EntityExtensionData *entity_extension_data = NULL; + Track *track = NULL; + int i, j; + int ret; + + if (hres->code != HTTP_OK) + RETURN_ERROR(SP_ERR_INVALID, "Request for extended metadata returned a http error"); + + response = spotify__extendedmetadata__batched_extension_response__unpack(NULL, hres->body_len, hres->body); + if (!response) + RETURN_ERROR(SP_ERR_INVALID, "Could not parse extended metadata response"); + + for (i = 0; i < response->n_extended_metadata && !entity_extension_data; i++) + { + for (j = 0; j < response->extended_metadata[i]->n_extension_data && !entity_extension_data; j++) + { + entity_extension_data = response->extended_metadata[i]->extension_data[j]; + if (!entity_extension_data) + continue; + else if (!entity_extension_data->entity_uri || strcmp(entity_extension_data->entity_uri, channel->file.path) != 0) + entity_extension_data = NULL; + else if (!entity_extension_data->header || entity_extension_data->header->status_code != HTTP_OK) + entity_extension_data = NULL; + else if (!entity_extension_data->extension_data || !entity_extension_data->extension_data->type_url) + entity_extension_data = NULL; + } + } + + if (!entity_extension_data) + RETURN_ERROR(SP_ERR_INVALID, "Could not extract entity extension data from extended metadata response"); + + // Like go-librespot, we don't check entity_extension_data->extension_data->type_url, + // which should be either type.googleapis.com/spotify.metadata.Track or + // .Episode. If we get something else we will fail later anyway. + + // This also works for episodes + track = track__unpack(NULL, entity_extension_data->extension_data->value.len, entity_extension_data->extension_data->value.data); + if (!track) + RETURN_ERROR(SP_ERR_INVALID, "Could not parse track data in extended metadata response"); + + ret = file_select(channel->file.id, sizeof(channel->file.id), track, session->bitrate_preferred); + if (ret < 0) + RETURN_ERROR(SP_ERR_INVALID, "Could not find track data in extended metadata response"); + + spotify__extendedmetadata__batched_extension_response__free_unpacked(response, NULL); + track__free_unpacked(track, NULL); + return SP_OK_DONE; + + error: + spotify__extendedmetadata__batched_extension_response__free_unpacked(response, NULL); + track__free_unpacked(track, NULL); return ret; } @@ -1980,7 +2049,6 @@ msg_make_login5_challenges(struct sp_message *msg, struct sp_session *session) return msg_make_login5(msg, session); } -// Ref. spclient/spclient.go static int msg_make_metadata_get(struct sp_message *msg, struct sp_session *session) { @@ -2013,6 +2081,53 @@ msg_make_metadata_get(struct sp_message *msg, struct sp_session *session) return 0; } +// Ref. spclient/spclient.go +static int +msg_make_extended_metadata_get(struct sp_message *msg, struct sp_session *session) +{ + struct http_request *hreq = &msg->payload.hreq; + struct sp_server *server = &session->spclient; + Spotify__Extendedmetadata__BatchedEntityRequest req = SPOTIFY__EXTENDEDMETADATA__BATCHED_ENTITY_REQUEST__INIT; + Spotify__Extendedmetadata__EntityRequest entity_request = SPOTIFY__EXTENDEDMETADATA__ENTITY_REQUEST__INIT; + Spotify__Extendedmetadata__EntityRequest *entity_requests; + Spotify__Extendedmetadata__ExtensionQuery query = SPOTIFY__EXTENDEDMETADATA__EXTENSION_QUERY__INIT; + Spotify__Extendedmetadata__ExtensionQuery *queries; + struct sp_channel *channel = session->now_streaming_channel; + struct sp_file zerofile = { 0 }; + + if (memcmp(channel->file.id, zerofile.id, sizeof(channel->file.id)) != 0) + return 1; // Skip this request, we got the file id from metadata_get + + if (channel->file.media_type == SP_MEDIA_TRACK) + query.extension_kind = SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__TRACK_V4; + else if (channel->file.media_type == SP_MEDIA_EPISODE) + query.extension_kind = SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__EPISODE_V4; + else + return -1; + + queries = &query; + entity_request.query = &queries; + entity_request.n_query = 1; + entity_request.entity_uri = channel->file.path; + + entity_requests = &entity_request; + req.entity_request = &entity_requests; + req.n_entity_request = 1; + + hreq->body_len = spotify__extendedmetadata__batched_entity_request__get_packed_size(&req); + hreq->body = malloc(hreq->body_len); + + spotify__extendedmetadata__batched_entity_request__pack(&req, hreq->body); + + hreq->url = asprintf_or_die("https://%s:%d/extended-metadata/v0/extended-metadata", server->address, server->port); + + hreq->headers[0] = asprintf_or_die("Accept: application/x-protobuf"); + hreq->headers[1] = asprintf_or_die("Client-Token: %s", session->http_clienttoken.value); + hreq->headers[2] = asprintf_or_die("Authorization: Bearer %s", session->http_accesstoken.value); + + return 0; +} + // Resolve storage, this will just be a GET request // Ref. spclient/spclient.go static int @@ -2064,7 +2179,7 @@ msg_make_media_get(struct sp_message *msg, struct sp_session *session) } // Must be large enough to also include null terminating elements -static struct sp_seq_request seq_requests[][7] = +static struct sp_seq_request seq_requests[][15] = { { // Just a dummy so that the array is aligned with the enum @@ -2083,6 +2198,7 @@ static struct sp_seq_request seq_requests[][7] = { SP_SEQ_MEDIA_OPEN, "LOGIN5", SP_PROTO_HTTP, msg_make_login5, NULL, handle_login5, }, { SP_SEQ_MEDIA_OPEN, "LOGIN5_CHALLENGES", SP_PROTO_HTTP, msg_make_login5_challenges, NULL, handle_login5, }, { SP_SEQ_MEDIA_OPEN, "METADATA_GET", SP_PROTO_HTTP, msg_make_metadata_get, NULL, handle_metadata_get, }, + { SP_SEQ_MEDIA_OPEN, "EXTENDED_METADATA_GET", SP_PROTO_HTTP, msg_make_extended_metadata_get, NULL, handle_extended_metadata_get, }, { SP_SEQ_MEDIA_OPEN, "AUDIO_KEY_GET", SP_PROTO_TCP, msg_make_audio_key_get, prepare_tcp, handle_tcp_generic, }, { SP_SEQ_MEDIA_OPEN, "STORAGE_RESOLVE", SP_PROTO_HTTP, msg_make_storage_resolve, NULL, handle_storage_resolve, }, { SP_SEQ_MEDIA_OPEN, "MEDIA_PREFETCH", SP_PROTO_HTTP, msg_make_media_get, NULL, handle_media_get, }, diff --git a/src/inputs/librespot-c/src/librespot-c-internal.h b/src/inputs/librespot-c/src/librespot-c-internal.h index 45d51040..b2c3e37e 100644 --- a/src/inputs/librespot-c/src/librespot-c-internal.h +++ b/src/inputs/librespot-c/src/librespot-c-internal.h @@ -37,6 +37,7 @@ #include "proto/authentication.pb-c.h" #include "proto/mercury.pb-c.h" #include "proto/metadata.pb-c.h" +#include "proto/extended_metadata.pb-c.h" #include "proto/clienttoken.pb-c.h" #include "proto/login5.pb-c.h" #include "proto/storage_resolve.pb-c.h" diff --git a/src/inputs/librespot-c/src/proto/entity_extension_data.pb-c.c b/src/inputs/librespot-c/src/proto/entity_extension_data.pb-c.c new file mode 100644 index 00000000..b215ec21 --- /dev/null +++ b/src/inputs/librespot-c/src/proto/entity_extension_data.pb-c.c @@ -0,0 +1,495 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: entity_extension_data.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "entity_extension_data.pb-c.h" +void spotify__extendedmetadata__entity_extension_data_header__init + (Spotify__Extendedmetadata__EntityExtensionDataHeader *message) +{ + static const Spotify__Extendedmetadata__EntityExtensionDataHeader init_value = SPOTIFY__EXTENDEDMETADATA__ENTITY_EXTENSION_DATA_HEADER__INIT; + *message = init_value; +} +size_t spotify__extendedmetadata__entity_extension_data_header__get_packed_size + (const Spotify__Extendedmetadata__EntityExtensionDataHeader *message) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__entity_extension_data_header__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t spotify__extendedmetadata__entity_extension_data_header__pack + (const Spotify__Extendedmetadata__EntityExtensionDataHeader *message, + uint8_t *out) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__entity_extension_data_header__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t spotify__extendedmetadata__entity_extension_data_header__pack_to_buffer + (const Spotify__Extendedmetadata__EntityExtensionDataHeader *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__entity_extension_data_header__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Spotify__Extendedmetadata__EntityExtensionDataHeader * + spotify__extendedmetadata__entity_extension_data_header__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Spotify__Extendedmetadata__EntityExtensionDataHeader *) + protobuf_c_message_unpack (&spotify__extendedmetadata__entity_extension_data_header__descriptor, + allocator, len, data); +} +void spotify__extendedmetadata__entity_extension_data_header__free_unpacked + (Spotify__Extendedmetadata__EntityExtensionDataHeader *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &spotify__extendedmetadata__entity_extension_data_header__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void spotify__extendedmetadata__entity_extension_data__init + (Spotify__Extendedmetadata__EntityExtensionData *message) +{ + static const Spotify__Extendedmetadata__EntityExtensionData init_value = SPOTIFY__EXTENDEDMETADATA__ENTITY_EXTENSION_DATA__INIT; + *message = init_value; +} +size_t spotify__extendedmetadata__entity_extension_data__get_packed_size + (const Spotify__Extendedmetadata__EntityExtensionData *message) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__entity_extension_data__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t spotify__extendedmetadata__entity_extension_data__pack + (const Spotify__Extendedmetadata__EntityExtensionData *message, + uint8_t *out) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__entity_extension_data__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t spotify__extendedmetadata__entity_extension_data__pack_to_buffer + (const Spotify__Extendedmetadata__EntityExtensionData *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__entity_extension_data__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Spotify__Extendedmetadata__EntityExtensionData * + spotify__extendedmetadata__entity_extension_data__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Spotify__Extendedmetadata__EntityExtensionData *) + protobuf_c_message_unpack (&spotify__extendedmetadata__entity_extension_data__descriptor, + allocator, len, data); +} +void spotify__extendedmetadata__entity_extension_data__free_unpacked + (Spotify__Extendedmetadata__EntityExtensionData *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &spotify__extendedmetadata__entity_extension_data__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void spotify__extendedmetadata__plain_list_assoc__init + (Spotify__Extendedmetadata__PlainListAssoc *message) +{ + static const Spotify__Extendedmetadata__PlainListAssoc init_value = SPOTIFY__EXTENDEDMETADATA__PLAIN_LIST_ASSOC__INIT; + *message = init_value; +} +size_t spotify__extendedmetadata__plain_list_assoc__get_packed_size + (const Spotify__Extendedmetadata__PlainListAssoc *message) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__plain_list_assoc__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t spotify__extendedmetadata__plain_list_assoc__pack + (const Spotify__Extendedmetadata__PlainListAssoc *message, + uint8_t *out) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__plain_list_assoc__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t spotify__extendedmetadata__plain_list_assoc__pack_to_buffer + (const Spotify__Extendedmetadata__PlainListAssoc *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__plain_list_assoc__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Spotify__Extendedmetadata__PlainListAssoc * + spotify__extendedmetadata__plain_list_assoc__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Spotify__Extendedmetadata__PlainListAssoc *) + protobuf_c_message_unpack (&spotify__extendedmetadata__plain_list_assoc__descriptor, + allocator, len, data); +} +void spotify__extendedmetadata__plain_list_assoc__free_unpacked + (Spotify__Extendedmetadata__PlainListAssoc *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &spotify__extendedmetadata__plain_list_assoc__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void spotify__extendedmetadata__assoc_header__init + (Spotify__Extendedmetadata__AssocHeader *message) +{ + static const Spotify__Extendedmetadata__AssocHeader init_value = SPOTIFY__EXTENDEDMETADATA__ASSOC_HEADER__INIT; + *message = init_value; +} +size_t spotify__extendedmetadata__assoc_header__get_packed_size + (const Spotify__Extendedmetadata__AssocHeader *message) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__assoc_header__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t spotify__extendedmetadata__assoc_header__pack + (const Spotify__Extendedmetadata__AssocHeader *message, + uint8_t *out) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__assoc_header__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t spotify__extendedmetadata__assoc_header__pack_to_buffer + (const Spotify__Extendedmetadata__AssocHeader *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__assoc_header__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Spotify__Extendedmetadata__AssocHeader * + spotify__extendedmetadata__assoc_header__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Spotify__Extendedmetadata__AssocHeader *) + protobuf_c_message_unpack (&spotify__extendedmetadata__assoc_header__descriptor, + allocator, len, data); +} +void spotify__extendedmetadata__assoc_header__free_unpacked + (Spotify__Extendedmetadata__AssocHeader *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &spotify__extendedmetadata__assoc_header__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void spotify__extendedmetadata__assoc__init + (Spotify__Extendedmetadata__Assoc *message) +{ + static const Spotify__Extendedmetadata__Assoc init_value = SPOTIFY__EXTENDEDMETADATA__ASSOC__INIT; + *message = init_value; +} +size_t spotify__extendedmetadata__assoc__get_packed_size + (const Spotify__Extendedmetadata__Assoc *message) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__assoc__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t spotify__extendedmetadata__assoc__pack + (const Spotify__Extendedmetadata__Assoc *message, + uint8_t *out) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__assoc__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t spotify__extendedmetadata__assoc__pack_to_buffer + (const Spotify__Extendedmetadata__Assoc *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__assoc__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Spotify__Extendedmetadata__Assoc * + spotify__extendedmetadata__assoc__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Spotify__Extendedmetadata__Assoc *) + protobuf_c_message_unpack (&spotify__extendedmetadata__assoc__descriptor, + allocator, len, data); +} +void spotify__extendedmetadata__assoc__free_unpacked + (Spotify__Extendedmetadata__Assoc *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &spotify__extendedmetadata__assoc__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor spotify__extendedmetadata__entity_extension_data_header__field_descriptors[5] = +{ + { + "status_code", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(Spotify__Extendedmetadata__EntityExtensionDataHeader, status_code), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "etag", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Spotify__Extendedmetadata__EntityExtensionDataHeader, etag), + NULL, + &protobuf_c_empty_string, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "locale", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Spotify__Extendedmetadata__EntityExtensionDataHeader, locale), + NULL, + &protobuf_c_empty_string, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "cache_ttl_in_seconds", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT64, + 0, /* quantifier_offset */ + offsetof(Spotify__Extendedmetadata__EntityExtensionDataHeader, cache_ttl_in_seconds), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "offline_ttl_in_seconds", + 5, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT64, + 0, /* quantifier_offset */ + offsetof(Spotify__Extendedmetadata__EntityExtensionDataHeader, offline_ttl_in_seconds), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned spotify__extendedmetadata__entity_extension_data_header__field_indices_by_name[] = { + 3, /* field[3] = cache_ttl_in_seconds */ + 1, /* field[1] = etag */ + 2, /* field[2] = locale */ + 4, /* field[4] = offline_ttl_in_seconds */ + 0, /* field[0] = status_code */ +}; +static const ProtobufCIntRange spotify__extendedmetadata__entity_extension_data_header__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 5 } +}; +const ProtobufCMessageDescriptor spotify__extendedmetadata__entity_extension_data_header__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "spotify.extendedmetadata.EntityExtensionDataHeader", + "EntityExtensionDataHeader", + "Spotify__Extendedmetadata__EntityExtensionDataHeader", + "spotify.extendedmetadata", + sizeof(Spotify__Extendedmetadata__EntityExtensionDataHeader), + 5, + spotify__extendedmetadata__entity_extension_data_header__field_descriptors, + spotify__extendedmetadata__entity_extension_data_header__field_indices_by_name, + 1, spotify__extendedmetadata__entity_extension_data_header__number_ranges, + (ProtobufCMessageInit) spotify__extendedmetadata__entity_extension_data_header__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor spotify__extendedmetadata__entity_extension_data__field_descriptors[3] = +{ + { + "header", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Spotify__Extendedmetadata__EntityExtensionData, header), + &spotify__extendedmetadata__entity_extension_data_header__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "entity_uri", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Spotify__Extendedmetadata__EntityExtensionData, entity_uri), + NULL, + &protobuf_c_empty_string, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "extension_data", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Spotify__Extendedmetadata__EntityExtensionData, extension_data), + &google__protobuf__any__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned spotify__extendedmetadata__entity_extension_data__field_indices_by_name[] = { + 1, /* field[1] = entity_uri */ + 2, /* field[2] = extension_data */ + 0, /* field[0] = header */ +}; +static const ProtobufCIntRange spotify__extendedmetadata__entity_extension_data__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor spotify__extendedmetadata__entity_extension_data__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "spotify.extendedmetadata.EntityExtensionData", + "EntityExtensionData", + "Spotify__Extendedmetadata__EntityExtensionData", + "spotify.extendedmetadata", + sizeof(Spotify__Extendedmetadata__EntityExtensionData), + 3, + spotify__extendedmetadata__entity_extension_data__field_descriptors, + spotify__extendedmetadata__entity_extension_data__field_indices_by_name, + 1, spotify__extendedmetadata__entity_extension_data__number_ranges, + (ProtobufCMessageInit) spotify__extendedmetadata__entity_extension_data__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor spotify__extendedmetadata__plain_list_assoc__field_descriptors[1] = +{ + { + "entity_uri", + 1, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_STRING, + offsetof(Spotify__Extendedmetadata__PlainListAssoc, n_entity_uri), + offsetof(Spotify__Extendedmetadata__PlainListAssoc, entity_uri), + NULL, + &protobuf_c_empty_string, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned spotify__extendedmetadata__plain_list_assoc__field_indices_by_name[] = { + 0, /* field[0] = entity_uri */ +}; +static const ProtobufCIntRange spotify__extendedmetadata__plain_list_assoc__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 1 } +}; +const ProtobufCMessageDescriptor spotify__extendedmetadata__plain_list_assoc__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "spotify.extendedmetadata.PlainListAssoc", + "PlainListAssoc", + "Spotify__Extendedmetadata__PlainListAssoc", + "spotify.extendedmetadata", + sizeof(Spotify__Extendedmetadata__PlainListAssoc), + 1, + spotify__extendedmetadata__plain_list_assoc__field_descriptors, + spotify__extendedmetadata__plain_list_assoc__field_indices_by_name, + 1, spotify__extendedmetadata__plain_list_assoc__number_ranges, + (ProtobufCMessageInit) spotify__extendedmetadata__plain_list_assoc__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define spotify__extendedmetadata__assoc_header__field_descriptors NULL +#define spotify__extendedmetadata__assoc_header__field_indices_by_name NULL +#define spotify__extendedmetadata__assoc_header__number_ranges NULL +const ProtobufCMessageDescriptor spotify__extendedmetadata__assoc_header__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "spotify.extendedmetadata.AssocHeader", + "AssocHeader", + "Spotify__Extendedmetadata__AssocHeader", + "spotify.extendedmetadata", + sizeof(Spotify__Extendedmetadata__AssocHeader), + 0, + spotify__extendedmetadata__assoc_header__field_descriptors, + spotify__extendedmetadata__assoc_header__field_indices_by_name, + 0, spotify__extendedmetadata__assoc_header__number_ranges, + (ProtobufCMessageInit) spotify__extendedmetadata__assoc_header__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor spotify__extendedmetadata__assoc__field_descriptors[2] = +{ + { + "header", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Spotify__Extendedmetadata__Assoc, header), + &spotify__extendedmetadata__assoc_header__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "plain_list", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Spotify__Extendedmetadata__Assoc, plain_list), + &spotify__extendedmetadata__plain_list_assoc__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned spotify__extendedmetadata__assoc__field_indices_by_name[] = { + 0, /* field[0] = header */ + 1, /* field[1] = plain_list */ +}; +static const ProtobufCIntRange spotify__extendedmetadata__assoc__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor spotify__extendedmetadata__assoc__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "spotify.extendedmetadata.Assoc", + "Assoc", + "Spotify__Extendedmetadata__Assoc", + "spotify.extendedmetadata", + sizeof(Spotify__Extendedmetadata__Assoc), + 2, + spotify__extendedmetadata__assoc__field_descriptors, + spotify__extendedmetadata__assoc__field_indices_by_name, + 1, spotify__extendedmetadata__assoc__number_ranges, + (ProtobufCMessageInit) spotify__extendedmetadata__assoc__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/src/inputs/librespot-c/src/proto/entity_extension_data.pb-c.h b/src/inputs/librespot-c/src/proto/entity_extension_data.pb-c.h new file mode 100644 index 00000000..94903291 --- /dev/null +++ b/src/inputs/librespot-c/src/proto/entity_extension_data.pb-c.h @@ -0,0 +1,215 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: entity_extension_data.proto */ + +#ifndef PROTOBUF_C_entity_5fextension_5fdata_2eproto__INCLUDED +#define PROTOBUF_C_entity_5fextension_5fdata_2eproto__INCLUDED + +#include + +PROTOBUF_C__BEGIN_DECLS + +#if PROTOBUF_C_VERSION_NUMBER < 1003000 +# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers. +#elif 1004001 < PROTOBUF_C_MIN_COMPILER_VERSION +# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c. +#endif + +#include "google_any.pb-c.h" + +typedef struct Spotify__Extendedmetadata__EntityExtensionDataHeader Spotify__Extendedmetadata__EntityExtensionDataHeader; +typedef struct Spotify__Extendedmetadata__EntityExtensionData Spotify__Extendedmetadata__EntityExtensionData; +typedef struct Spotify__Extendedmetadata__PlainListAssoc Spotify__Extendedmetadata__PlainListAssoc; +typedef struct Spotify__Extendedmetadata__AssocHeader Spotify__Extendedmetadata__AssocHeader; +typedef struct Spotify__Extendedmetadata__Assoc Spotify__Extendedmetadata__Assoc; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct Spotify__Extendedmetadata__EntityExtensionDataHeader +{ + ProtobufCMessage base; + int32_t status_code; + char *etag; + char *locale; + int64_t cache_ttl_in_seconds; + int64_t offline_ttl_in_seconds; +}; +#define SPOTIFY__EXTENDEDMETADATA__ENTITY_EXTENSION_DATA_HEADER__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&spotify__extendedmetadata__entity_extension_data_header__descriptor) \ + , 0, (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, 0, 0 } + + +struct Spotify__Extendedmetadata__EntityExtensionData +{ + ProtobufCMessage base; + Spotify__Extendedmetadata__EntityExtensionDataHeader *header; + char *entity_uri; + Google__Protobuf__Any *extension_data; +}; +#define SPOTIFY__EXTENDEDMETADATA__ENTITY_EXTENSION_DATA__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&spotify__extendedmetadata__entity_extension_data__descriptor) \ + , NULL, (char *)protobuf_c_empty_string, NULL } + + +struct Spotify__Extendedmetadata__PlainListAssoc +{ + ProtobufCMessage base; + size_t n_entity_uri; + char **entity_uri; +}; +#define SPOTIFY__EXTENDEDMETADATA__PLAIN_LIST_ASSOC__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&spotify__extendedmetadata__plain_list_assoc__descriptor) \ + , 0,NULL } + + +struct Spotify__Extendedmetadata__AssocHeader +{ + ProtobufCMessage base; +}; +#define SPOTIFY__EXTENDEDMETADATA__ASSOC_HEADER__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&spotify__extendedmetadata__assoc_header__descriptor) \ + } + + +struct Spotify__Extendedmetadata__Assoc +{ + ProtobufCMessage base; + Spotify__Extendedmetadata__AssocHeader *header; + Spotify__Extendedmetadata__PlainListAssoc *plain_list; +}; +#define SPOTIFY__EXTENDEDMETADATA__ASSOC__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&spotify__extendedmetadata__assoc__descriptor) \ + , NULL, NULL } + + +/* Spotify__Extendedmetadata__EntityExtensionDataHeader methods */ +void spotify__extendedmetadata__entity_extension_data_header__init + (Spotify__Extendedmetadata__EntityExtensionDataHeader *message); +size_t spotify__extendedmetadata__entity_extension_data_header__get_packed_size + (const Spotify__Extendedmetadata__EntityExtensionDataHeader *message); +size_t spotify__extendedmetadata__entity_extension_data_header__pack + (const Spotify__Extendedmetadata__EntityExtensionDataHeader *message, + uint8_t *out); +size_t spotify__extendedmetadata__entity_extension_data_header__pack_to_buffer + (const Spotify__Extendedmetadata__EntityExtensionDataHeader *message, + ProtobufCBuffer *buffer); +Spotify__Extendedmetadata__EntityExtensionDataHeader * + spotify__extendedmetadata__entity_extension_data_header__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void spotify__extendedmetadata__entity_extension_data_header__free_unpacked + (Spotify__Extendedmetadata__EntityExtensionDataHeader *message, + ProtobufCAllocator *allocator); +/* Spotify__Extendedmetadata__EntityExtensionData methods */ +void spotify__extendedmetadata__entity_extension_data__init + (Spotify__Extendedmetadata__EntityExtensionData *message); +size_t spotify__extendedmetadata__entity_extension_data__get_packed_size + (const Spotify__Extendedmetadata__EntityExtensionData *message); +size_t spotify__extendedmetadata__entity_extension_data__pack + (const Spotify__Extendedmetadata__EntityExtensionData *message, + uint8_t *out); +size_t spotify__extendedmetadata__entity_extension_data__pack_to_buffer + (const Spotify__Extendedmetadata__EntityExtensionData *message, + ProtobufCBuffer *buffer); +Spotify__Extendedmetadata__EntityExtensionData * + spotify__extendedmetadata__entity_extension_data__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void spotify__extendedmetadata__entity_extension_data__free_unpacked + (Spotify__Extendedmetadata__EntityExtensionData *message, + ProtobufCAllocator *allocator); +/* Spotify__Extendedmetadata__PlainListAssoc methods */ +void spotify__extendedmetadata__plain_list_assoc__init + (Spotify__Extendedmetadata__PlainListAssoc *message); +size_t spotify__extendedmetadata__plain_list_assoc__get_packed_size + (const Spotify__Extendedmetadata__PlainListAssoc *message); +size_t spotify__extendedmetadata__plain_list_assoc__pack + (const Spotify__Extendedmetadata__PlainListAssoc *message, + uint8_t *out); +size_t spotify__extendedmetadata__plain_list_assoc__pack_to_buffer + (const Spotify__Extendedmetadata__PlainListAssoc *message, + ProtobufCBuffer *buffer); +Spotify__Extendedmetadata__PlainListAssoc * + spotify__extendedmetadata__plain_list_assoc__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void spotify__extendedmetadata__plain_list_assoc__free_unpacked + (Spotify__Extendedmetadata__PlainListAssoc *message, + ProtobufCAllocator *allocator); +/* Spotify__Extendedmetadata__AssocHeader methods */ +void spotify__extendedmetadata__assoc_header__init + (Spotify__Extendedmetadata__AssocHeader *message); +size_t spotify__extendedmetadata__assoc_header__get_packed_size + (const Spotify__Extendedmetadata__AssocHeader *message); +size_t spotify__extendedmetadata__assoc_header__pack + (const Spotify__Extendedmetadata__AssocHeader *message, + uint8_t *out); +size_t spotify__extendedmetadata__assoc_header__pack_to_buffer + (const Spotify__Extendedmetadata__AssocHeader *message, + ProtobufCBuffer *buffer); +Spotify__Extendedmetadata__AssocHeader * + spotify__extendedmetadata__assoc_header__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void spotify__extendedmetadata__assoc_header__free_unpacked + (Spotify__Extendedmetadata__AssocHeader *message, + ProtobufCAllocator *allocator); +/* Spotify__Extendedmetadata__Assoc methods */ +void spotify__extendedmetadata__assoc__init + (Spotify__Extendedmetadata__Assoc *message); +size_t spotify__extendedmetadata__assoc__get_packed_size + (const Spotify__Extendedmetadata__Assoc *message); +size_t spotify__extendedmetadata__assoc__pack + (const Spotify__Extendedmetadata__Assoc *message, + uint8_t *out); +size_t spotify__extendedmetadata__assoc__pack_to_buffer + (const Spotify__Extendedmetadata__Assoc *message, + ProtobufCBuffer *buffer); +Spotify__Extendedmetadata__Assoc * + spotify__extendedmetadata__assoc__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void spotify__extendedmetadata__assoc__free_unpacked + (Spotify__Extendedmetadata__Assoc *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*Spotify__Extendedmetadata__EntityExtensionDataHeader_Closure) + (const Spotify__Extendedmetadata__EntityExtensionDataHeader *message, + void *closure_data); +typedef void (*Spotify__Extendedmetadata__EntityExtensionData_Closure) + (const Spotify__Extendedmetadata__EntityExtensionData *message, + void *closure_data); +typedef void (*Spotify__Extendedmetadata__PlainListAssoc_Closure) + (const Spotify__Extendedmetadata__PlainListAssoc *message, + void *closure_data); +typedef void (*Spotify__Extendedmetadata__AssocHeader_Closure) + (const Spotify__Extendedmetadata__AssocHeader *message, + void *closure_data); +typedef void (*Spotify__Extendedmetadata__Assoc_Closure) + (const Spotify__Extendedmetadata__Assoc *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor spotify__extendedmetadata__entity_extension_data_header__descriptor; +extern const ProtobufCMessageDescriptor spotify__extendedmetadata__entity_extension_data__descriptor; +extern const ProtobufCMessageDescriptor spotify__extendedmetadata__plain_list_assoc__descriptor; +extern const ProtobufCMessageDescriptor spotify__extendedmetadata__assoc_header__descriptor; +extern const ProtobufCMessageDescriptor spotify__extendedmetadata__assoc__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_entity_5fextension_5fdata_2eproto__INCLUDED */ diff --git a/src/inputs/librespot-c/src/proto/entity_extension_data.proto b/src/inputs/librespot-c/src/proto/entity_extension_data.proto new file mode 100644 index 00000000..7a83ea21 --- /dev/null +++ b/src/inputs/librespot-c/src/proto/entity_extension_data.proto @@ -0,0 +1,30 @@ +syntax = "proto3"; + +package spotify.extendedmetadata; + +import "google_any.proto"; + +message EntityExtensionDataHeader { + int32 status_code = 1; + string etag = 2; + string locale = 3; + int64 cache_ttl_in_seconds = 4; + int64 offline_ttl_in_seconds = 5; +} + +message EntityExtensionData { + EntityExtensionDataHeader header = 1; + string entity_uri = 2; + google.protobuf.Any extension_data = 3; +} + +message PlainListAssoc { + repeated string entity_uri = 1; +} + +message AssocHeader {} + +message Assoc { + AssocHeader header = 1; + PlainListAssoc plain_list = 2; +} diff --git a/src/inputs/librespot-c/src/proto/extended_metadata.pb-c.c b/src/inputs/librespot-c/src/proto/extended_metadata.pb-c.c new file mode 100644 index 00000000..d751233a --- /dev/null +++ b/src/inputs/librespot-c/src/proto/extended_metadata.pb-c.c @@ -0,0 +1,826 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: extended_metadata.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "extended_metadata.pb-c.h" +void spotify__extendedmetadata__extension_query__init + (Spotify__Extendedmetadata__ExtensionQuery *message) +{ + static const Spotify__Extendedmetadata__ExtensionQuery init_value = SPOTIFY__EXTENDEDMETADATA__EXTENSION_QUERY__INIT; + *message = init_value; +} +size_t spotify__extendedmetadata__extension_query__get_packed_size + (const Spotify__Extendedmetadata__ExtensionQuery *message) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__extension_query__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t spotify__extendedmetadata__extension_query__pack + (const Spotify__Extendedmetadata__ExtensionQuery *message, + uint8_t *out) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__extension_query__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t spotify__extendedmetadata__extension_query__pack_to_buffer + (const Spotify__Extendedmetadata__ExtensionQuery *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__extension_query__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Spotify__Extendedmetadata__ExtensionQuery * + spotify__extendedmetadata__extension_query__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Spotify__Extendedmetadata__ExtensionQuery *) + protobuf_c_message_unpack (&spotify__extendedmetadata__extension_query__descriptor, + allocator, len, data); +} +void spotify__extendedmetadata__extension_query__free_unpacked + (Spotify__Extendedmetadata__ExtensionQuery *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &spotify__extendedmetadata__extension_query__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void spotify__extendedmetadata__entity_request__init + (Spotify__Extendedmetadata__EntityRequest *message) +{ + static const Spotify__Extendedmetadata__EntityRequest init_value = SPOTIFY__EXTENDEDMETADATA__ENTITY_REQUEST__INIT; + *message = init_value; +} +size_t spotify__extendedmetadata__entity_request__get_packed_size + (const Spotify__Extendedmetadata__EntityRequest *message) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__entity_request__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t spotify__extendedmetadata__entity_request__pack + (const Spotify__Extendedmetadata__EntityRequest *message, + uint8_t *out) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__entity_request__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t spotify__extendedmetadata__entity_request__pack_to_buffer + (const Spotify__Extendedmetadata__EntityRequest *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__entity_request__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Spotify__Extendedmetadata__EntityRequest * + spotify__extendedmetadata__entity_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Spotify__Extendedmetadata__EntityRequest *) + protobuf_c_message_unpack (&spotify__extendedmetadata__entity_request__descriptor, + allocator, len, data); +} +void spotify__extendedmetadata__entity_request__free_unpacked + (Spotify__Extendedmetadata__EntityRequest *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &spotify__extendedmetadata__entity_request__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void spotify__extendedmetadata__batched_entity_request_header__init + (Spotify__Extendedmetadata__BatchedEntityRequestHeader *message) +{ + static const Spotify__Extendedmetadata__BatchedEntityRequestHeader init_value = SPOTIFY__EXTENDEDMETADATA__BATCHED_ENTITY_REQUEST_HEADER__INIT; + *message = init_value; +} +size_t spotify__extendedmetadata__batched_entity_request_header__get_packed_size + (const Spotify__Extendedmetadata__BatchedEntityRequestHeader *message) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__batched_entity_request_header__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t spotify__extendedmetadata__batched_entity_request_header__pack + (const Spotify__Extendedmetadata__BatchedEntityRequestHeader *message, + uint8_t *out) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__batched_entity_request_header__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t spotify__extendedmetadata__batched_entity_request_header__pack_to_buffer + (const Spotify__Extendedmetadata__BatchedEntityRequestHeader *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__batched_entity_request_header__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Spotify__Extendedmetadata__BatchedEntityRequestHeader * + spotify__extendedmetadata__batched_entity_request_header__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Spotify__Extendedmetadata__BatchedEntityRequestHeader *) + protobuf_c_message_unpack (&spotify__extendedmetadata__batched_entity_request_header__descriptor, + allocator, len, data); +} +void spotify__extendedmetadata__batched_entity_request_header__free_unpacked + (Spotify__Extendedmetadata__BatchedEntityRequestHeader *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &spotify__extendedmetadata__batched_entity_request_header__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void spotify__extendedmetadata__batched_entity_request__init + (Spotify__Extendedmetadata__BatchedEntityRequest *message) +{ + static const Spotify__Extendedmetadata__BatchedEntityRequest init_value = SPOTIFY__EXTENDEDMETADATA__BATCHED_ENTITY_REQUEST__INIT; + *message = init_value; +} +size_t spotify__extendedmetadata__batched_entity_request__get_packed_size + (const Spotify__Extendedmetadata__BatchedEntityRequest *message) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__batched_entity_request__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t spotify__extendedmetadata__batched_entity_request__pack + (const Spotify__Extendedmetadata__BatchedEntityRequest *message, + uint8_t *out) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__batched_entity_request__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t spotify__extendedmetadata__batched_entity_request__pack_to_buffer + (const Spotify__Extendedmetadata__BatchedEntityRequest *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__batched_entity_request__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Spotify__Extendedmetadata__BatchedEntityRequest * + spotify__extendedmetadata__batched_entity_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Spotify__Extendedmetadata__BatchedEntityRequest *) + protobuf_c_message_unpack (&spotify__extendedmetadata__batched_entity_request__descriptor, + allocator, len, data); +} +void spotify__extendedmetadata__batched_entity_request__free_unpacked + (Spotify__Extendedmetadata__BatchedEntityRequest *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &spotify__extendedmetadata__batched_entity_request__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void spotify__extendedmetadata__entity_extension_data_array_header__init + (Spotify__Extendedmetadata__EntityExtensionDataArrayHeader *message) +{ + static const Spotify__Extendedmetadata__EntityExtensionDataArrayHeader init_value = SPOTIFY__EXTENDEDMETADATA__ENTITY_EXTENSION_DATA_ARRAY_HEADER__INIT; + *message = init_value; +} +size_t spotify__extendedmetadata__entity_extension_data_array_header__get_packed_size + (const Spotify__Extendedmetadata__EntityExtensionDataArrayHeader *message) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__entity_extension_data_array_header__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t spotify__extendedmetadata__entity_extension_data_array_header__pack + (const Spotify__Extendedmetadata__EntityExtensionDataArrayHeader *message, + uint8_t *out) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__entity_extension_data_array_header__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t spotify__extendedmetadata__entity_extension_data_array_header__pack_to_buffer + (const Spotify__Extendedmetadata__EntityExtensionDataArrayHeader *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__entity_extension_data_array_header__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Spotify__Extendedmetadata__EntityExtensionDataArrayHeader * + spotify__extendedmetadata__entity_extension_data_array_header__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Spotify__Extendedmetadata__EntityExtensionDataArrayHeader *) + protobuf_c_message_unpack (&spotify__extendedmetadata__entity_extension_data_array_header__descriptor, + allocator, len, data); +} +void spotify__extendedmetadata__entity_extension_data_array_header__free_unpacked + (Spotify__Extendedmetadata__EntityExtensionDataArrayHeader *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &spotify__extendedmetadata__entity_extension_data_array_header__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void spotify__extendedmetadata__entity_extension_data_array__init + (Spotify__Extendedmetadata__EntityExtensionDataArray *message) +{ + static const Spotify__Extendedmetadata__EntityExtensionDataArray init_value = SPOTIFY__EXTENDEDMETADATA__ENTITY_EXTENSION_DATA_ARRAY__INIT; + *message = init_value; +} +size_t spotify__extendedmetadata__entity_extension_data_array__get_packed_size + (const Spotify__Extendedmetadata__EntityExtensionDataArray *message) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__entity_extension_data_array__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t spotify__extendedmetadata__entity_extension_data_array__pack + (const Spotify__Extendedmetadata__EntityExtensionDataArray *message, + uint8_t *out) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__entity_extension_data_array__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t spotify__extendedmetadata__entity_extension_data_array__pack_to_buffer + (const Spotify__Extendedmetadata__EntityExtensionDataArray *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__entity_extension_data_array__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Spotify__Extendedmetadata__EntityExtensionDataArray * + spotify__extendedmetadata__entity_extension_data_array__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Spotify__Extendedmetadata__EntityExtensionDataArray *) + protobuf_c_message_unpack (&spotify__extendedmetadata__entity_extension_data_array__descriptor, + allocator, len, data); +} +void spotify__extendedmetadata__entity_extension_data_array__free_unpacked + (Spotify__Extendedmetadata__EntityExtensionDataArray *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &spotify__extendedmetadata__entity_extension_data_array__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void spotify__extendedmetadata__batched_extension_response_header__init + (Spotify__Extendedmetadata__BatchedExtensionResponseHeader *message) +{ + static const Spotify__Extendedmetadata__BatchedExtensionResponseHeader init_value = SPOTIFY__EXTENDEDMETADATA__BATCHED_EXTENSION_RESPONSE_HEADER__INIT; + *message = init_value; +} +size_t spotify__extendedmetadata__batched_extension_response_header__get_packed_size + (const Spotify__Extendedmetadata__BatchedExtensionResponseHeader *message) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__batched_extension_response_header__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t spotify__extendedmetadata__batched_extension_response_header__pack + (const Spotify__Extendedmetadata__BatchedExtensionResponseHeader *message, + uint8_t *out) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__batched_extension_response_header__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t spotify__extendedmetadata__batched_extension_response_header__pack_to_buffer + (const Spotify__Extendedmetadata__BatchedExtensionResponseHeader *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__batched_extension_response_header__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Spotify__Extendedmetadata__BatchedExtensionResponseHeader * + spotify__extendedmetadata__batched_extension_response_header__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Spotify__Extendedmetadata__BatchedExtensionResponseHeader *) + protobuf_c_message_unpack (&spotify__extendedmetadata__batched_extension_response_header__descriptor, + allocator, len, data); +} +void spotify__extendedmetadata__batched_extension_response_header__free_unpacked + (Spotify__Extendedmetadata__BatchedExtensionResponseHeader *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &spotify__extendedmetadata__batched_extension_response_header__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void spotify__extendedmetadata__batched_extension_response__init + (Spotify__Extendedmetadata__BatchedExtensionResponse *message) +{ + static const Spotify__Extendedmetadata__BatchedExtensionResponse init_value = SPOTIFY__EXTENDEDMETADATA__BATCHED_EXTENSION_RESPONSE__INIT; + *message = init_value; +} +size_t spotify__extendedmetadata__batched_extension_response__get_packed_size + (const Spotify__Extendedmetadata__BatchedExtensionResponse *message) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__batched_extension_response__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t spotify__extendedmetadata__batched_extension_response__pack + (const Spotify__Extendedmetadata__BatchedExtensionResponse *message, + uint8_t *out) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__batched_extension_response__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t spotify__extendedmetadata__batched_extension_response__pack_to_buffer + (const Spotify__Extendedmetadata__BatchedExtensionResponse *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &spotify__extendedmetadata__batched_extension_response__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Spotify__Extendedmetadata__BatchedExtensionResponse * + spotify__extendedmetadata__batched_extension_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Spotify__Extendedmetadata__BatchedExtensionResponse *) + protobuf_c_message_unpack (&spotify__extendedmetadata__batched_extension_response__descriptor, + allocator, len, data); +} +void spotify__extendedmetadata__batched_extension_response__free_unpacked + (Spotify__Extendedmetadata__BatchedExtensionResponse *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &spotify__extendedmetadata__batched_extension_response__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor spotify__extendedmetadata__extension_query__field_descriptors[2] = +{ + { + "extension_kind", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + offsetof(Spotify__Extendedmetadata__ExtensionQuery, extension_kind), + &spotify__extendedmetadata__extension_kind__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "etag", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Spotify__Extendedmetadata__ExtensionQuery, etag), + NULL, + &protobuf_c_empty_string, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned spotify__extendedmetadata__extension_query__field_indices_by_name[] = { + 1, /* field[1] = etag */ + 0, /* field[0] = extension_kind */ +}; +static const ProtobufCIntRange spotify__extendedmetadata__extension_query__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor spotify__extendedmetadata__extension_query__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "spotify.extendedmetadata.ExtensionQuery", + "ExtensionQuery", + "Spotify__Extendedmetadata__ExtensionQuery", + "spotify.extendedmetadata", + sizeof(Spotify__Extendedmetadata__ExtensionQuery), + 2, + spotify__extendedmetadata__extension_query__field_descriptors, + spotify__extendedmetadata__extension_query__field_indices_by_name, + 1, spotify__extendedmetadata__extension_query__number_ranges, + (ProtobufCMessageInit) spotify__extendedmetadata__extension_query__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor spotify__extendedmetadata__entity_request__field_descriptors[2] = +{ + { + "entity_uri", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Spotify__Extendedmetadata__EntityRequest, entity_uri), + NULL, + &protobuf_c_empty_string, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "query", + 2, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Spotify__Extendedmetadata__EntityRequest, n_query), + offsetof(Spotify__Extendedmetadata__EntityRequest, query), + &spotify__extendedmetadata__extension_query__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned spotify__extendedmetadata__entity_request__field_indices_by_name[] = { + 0, /* field[0] = entity_uri */ + 1, /* field[1] = query */ +}; +static const ProtobufCIntRange spotify__extendedmetadata__entity_request__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor spotify__extendedmetadata__entity_request__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "spotify.extendedmetadata.EntityRequest", + "EntityRequest", + "Spotify__Extendedmetadata__EntityRequest", + "spotify.extendedmetadata", + sizeof(Spotify__Extendedmetadata__EntityRequest), + 2, + spotify__extendedmetadata__entity_request__field_descriptors, + spotify__extendedmetadata__entity_request__field_indices_by_name, + 1, spotify__extendedmetadata__entity_request__number_ranges, + (ProtobufCMessageInit) spotify__extendedmetadata__entity_request__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor spotify__extendedmetadata__batched_entity_request_header__field_descriptors[3] = +{ + { + "country", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Spotify__Extendedmetadata__BatchedEntityRequestHeader, country), + NULL, + &protobuf_c_empty_string, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "catalogue", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Spotify__Extendedmetadata__BatchedEntityRequestHeader, catalogue), + NULL, + &protobuf_c_empty_string, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "task_id", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(Spotify__Extendedmetadata__BatchedEntityRequestHeader, task_id), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned spotify__extendedmetadata__batched_entity_request_header__field_indices_by_name[] = { + 1, /* field[1] = catalogue */ + 0, /* field[0] = country */ + 2, /* field[2] = task_id */ +}; +static const ProtobufCIntRange spotify__extendedmetadata__batched_entity_request_header__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor spotify__extendedmetadata__batched_entity_request_header__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "spotify.extendedmetadata.BatchedEntityRequestHeader", + "BatchedEntityRequestHeader", + "Spotify__Extendedmetadata__BatchedEntityRequestHeader", + "spotify.extendedmetadata", + sizeof(Spotify__Extendedmetadata__BatchedEntityRequestHeader), + 3, + spotify__extendedmetadata__batched_entity_request_header__field_descriptors, + spotify__extendedmetadata__batched_entity_request_header__field_indices_by_name, + 1, spotify__extendedmetadata__batched_entity_request_header__number_ranges, + (ProtobufCMessageInit) spotify__extendedmetadata__batched_entity_request_header__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor spotify__extendedmetadata__batched_entity_request__field_descriptors[2] = +{ + { + "header", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Spotify__Extendedmetadata__BatchedEntityRequest, header), + &spotify__extendedmetadata__batched_entity_request_header__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "entity_request", + 2, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Spotify__Extendedmetadata__BatchedEntityRequest, n_entity_request), + offsetof(Spotify__Extendedmetadata__BatchedEntityRequest, entity_request), + &spotify__extendedmetadata__entity_request__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned spotify__extendedmetadata__batched_entity_request__field_indices_by_name[] = { + 1, /* field[1] = entity_request */ + 0, /* field[0] = header */ +}; +static const ProtobufCIntRange spotify__extendedmetadata__batched_entity_request__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor spotify__extendedmetadata__batched_entity_request__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "spotify.extendedmetadata.BatchedEntityRequest", + "BatchedEntityRequest", + "Spotify__Extendedmetadata__BatchedEntityRequest", + "spotify.extendedmetadata", + sizeof(Spotify__Extendedmetadata__BatchedEntityRequest), + 2, + spotify__extendedmetadata__batched_entity_request__field_descriptors, + spotify__extendedmetadata__batched_entity_request__field_indices_by_name, + 1, spotify__extendedmetadata__batched_entity_request__number_ranges, + (ProtobufCMessageInit) spotify__extendedmetadata__batched_entity_request__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor spotify__extendedmetadata__entity_extension_data_array_header__field_descriptors[4] = +{ + { + "provider_error_status", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT32, + 0, /* quantifier_offset */ + offsetof(Spotify__Extendedmetadata__EntityExtensionDataArrayHeader, provider_error_status), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "cache_ttl_in_seconds", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT64, + 0, /* quantifier_offset */ + offsetof(Spotify__Extendedmetadata__EntityExtensionDataArrayHeader, cache_ttl_in_seconds), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "offline_ttl_in_seconds", + 3, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_INT64, + 0, /* quantifier_offset */ + offsetof(Spotify__Extendedmetadata__EntityExtensionDataArrayHeader, offline_ttl_in_seconds), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "extension_type", + 4, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + offsetof(Spotify__Extendedmetadata__EntityExtensionDataArrayHeader, extension_type), + &spotify__extendedmetadata__extension_type__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned spotify__extendedmetadata__entity_extension_data_array_header__field_indices_by_name[] = { + 1, /* field[1] = cache_ttl_in_seconds */ + 3, /* field[3] = extension_type */ + 2, /* field[2] = offline_ttl_in_seconds */ + 0, /* field[0] = provider_error_status */ +}; +static const ProtobufCIntRange spotify__extendedmetadata__entity_extension_data_array_header__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 4 } +}; +const ProtobufCMessageDescriptor spotify__extendedmetadata__entity_extension_data_array_header__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "spotify.extendedmetadata.EntityExtensionDataArrayHeader", + "EntityExtensionDataArrayHeader", + "Spotify__Extendedmetadata__EntityExtensionDataArrayHeader", + "spotify.extendedmetadata", + sizeof(Spotify__Extendedmetadata__EntityExtensionDataArrayHeader), + 4, + spotify__extendedmetadata__entity_extension_data_array_header__field_descriptors, + spotify__extendedmetadata__entity_extension_data_array_header__field_indices_by_name, + 1, spotify__extendedmetadata__entity_extension_data_array_header__number_ranges, + (ProtobufCMessageInit) spotify__extendedmetadata__entity_extension_data_array_header__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor spotify__extendedmetadata__entity_extension_data_array__field_descriptors[3] = +{ + { + "header", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Spotify__Extendedmetadata__EntityExtensionDataArray, header), + &spotify__extendedmetadata__entity_extension_data_array_header__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "extension_kind", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + offsetof(Spotify__Extendedmetadata__EntityExtensionDataArray, extension_kind), + &spotify__extendedmetadata__extension_kind__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "extension_data", + 3, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Spotify__Extendedmetadata__EntityExtensionDataArray, n_extension_data), + offsetof(Spotify__Extendedmetadata__EntityExtensionDataArray, extension_data), + &spotify__extendedmetadata__entity_extension_data__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned spotify__extendedmetadata__entity_extension_data_array__field_indices_by_name[] = { + 2, /* field[2] = extension_data */ + 1, /* field[1] = extension_kind */ + 0, /* field[0] = header */ +}; +static const ProtobufCIntRange spotify__extendedmetadata__entity_extension_data_array__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor spotify__extendedmetadata__entity_extension_data_array__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "spotify.extendedmetadata.EntityExtensionDataArray", + "EntityExtensionDataArray", + "Spotify__Extendedmetadata__EntityExtensionDataArray", + "spotify.extendedmetadata", + sizeof(Spotify__Extendedmetadata__EntityExtensionDataArray), + 3, + spotify__extendedmetadata__entity_extension_data_array__field_descriptors, + spotify__extendedmetadata__entity_extension_data_array__field_indices_by_name, + 1, spotify__extendedmetadata__entity_extension_data_array__number_ranges, + (ProtobufCMessageInit) spotify__extendedmetadata__entity_extension_data_array__init, + NULL,NULL,NULL /* reserved[123] */ +}; +#define spotify__extendedmetadata__batched_extension_response_header__field_descriptors NULL +#define spotify__extendedmetadata__batched_extension_response_header__field_indices_by_name NULL +#define spotify__extendedmetadata__batched_extension_response_header__number_ranges NULL +const ProtobufCMessageDescriptor spotify__extendedmetadata__batched_extension_response_header__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "spotify.extendedmetadata.BatchedExtensionResponseHeader", + "BatchedExtensionResponseHeader", + "Spotify__Extendedmetadata__BatchedExtensionResponseHeader", + "spotify.extendedmetadata", + sizeof(Spotify__Extendedmetadata__BatchedExtensionResponseHeader), + 0, + spotify__extendedmetadata__batched_extension_response_header__field_descriptors, + spotify__extendedmetadata__batched_extension_response_header__field_indices_by_name, + 0, spotify__extendedmetadata__batched_extension_response_header__number_ranges, + (ProtobufCMessageInit) spotify__extendedmetadata__batched_extension_response_header__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor spotify__extendedmetadata__batched_extension_response__field_descriptors[2] = +{ + { + "header", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Spotify__Extendedmetadata__BatchedExtensionResponse, header), + &spotify__extendedmetadata__batched_extension_response_header__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "extended_metadata", + 2, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Spotify__Extendedmetadata__BatchedExtensionResponse, n_extended_metadata), + offsetof(Spotify__Extendedmetadata__BatchedExtensionResponse, extended_metadata), + &spotify__extendedmetadata__entity_extension_data_array__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned spotify__extendedmetadata__batched_extension_response__field_indices_by_name[] = { + 1, /* field[1] = extended_metadata */ + 0, /* field[0] = header */ +}; +static const ProtobufCIntRange spotify__extendedmetadata__batched_extension_response__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor spotify__extendedmetadata__batched_extension_response__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "spotify.extendedmetadata.BatchedExtensionResponse", + "BatchedExtensionResponse", + "Spotify__Extendedmetadata__BatchedExtensionResponse", + "spotify.extendedmetadata", + sizeof(Spotify__Extendedmetadata__BatchedExtensionResponse), + 2, + spotify__extendedmetadata__batched_extension_response__field_descriptors, + spotify__extendedmetadata__batched_extension_response__field_indices_by_name, + 1, spotify__extendedmetadata__batched_extension_response__number_ranges, + (ProtobufCMessageInit) spotify__extendedmetadata__batched_extension_response__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCEnumValue spotify__extendedmetadata__extension_type__enum_values_by_number[3] = +{ + { "UNKNOWN", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_TYPE__UNKNOWN", 0 }, + { "GENERIC", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_TYPE__GENERIC", 1 }, + { "ASSOC", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_TYPE__ASSOC", 2 }, +}; +static const ProtobufCIntRange spotify__extendedmetadata__extension_type__value_ranges[] = { +{0, 0},{0, 3} +}; +static const ProtobufCEnumValueIndex spotify__extendedmetadata__extension_type__enum_values_by_name[3] = +{ + { "ASSOC", 2 }, + { "GENERIC", 1 }, + { "UNKNOWN", 0 }, +}; +const ProtobufCEnumDescriptor spotify__extendedmetadata__extension_type__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "spotify.extendedmetadata.ExtensionType", + "ExtensionType", + "Spotify__Extendedmetadata__ExtensionType", + "spotify.extendedmetadata", + 3, + spotify__extendedmetadata__extension_type__enum_values_by_number, + 3, + spotify__extendedmetadata__extension_type__enum_values_by_name, + 1, + spotify__extendedmetadata__extension_type__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; diff --git a/src/inputs/librespot-c/src/proto/extended_metadata.pb-c.h b/src/inputs/librespot-c/src/proto/extended_metadata.pb-c.h new file mode 100644 index 00000000..a3dd6f7a --- /dev/null +++ b/src/inputs/librespot-c/src/proto/extended_metadata.pb-c.h @@ -0,0 +1,332 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: extended_metadata.proto */ + +#ifndef PROTOBUF_C_extended_5fmetadata_2eproto__INCLUDED +#define PROTOBUF_C_extended_5fmetadata_2eproto__INCLUDED + +#include + +PROTOBUF_C__BEGIN_DECLS + +#if PROTOBUF_C_VERSION_NUMBER < 1003000 +# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers. +#elif 1004001 < PROTOBUF_C_MIN_COMPILER_VERSION +# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c. +#endif + +#include "entity_extension_data.pb-c.h" +#include "extension_kind.pb-c.h" + +typedef struct Spotify__Extendedmetadata__ExtensionQuery Spotify__Extendedmetadata__ExtensionQuery; +typedef struct Spotify__Extendedmetadata__EntityRequest Spotify__Extendedmetadata__EntityRequest; +typedef struct Spotify__Extendedmetadata__BatchedEntityRequestHeader Spotify__Extendedmetadata__BatchedEntityRequestHeader; +typedef struct Spotify__Extendedmetadata__BatchedEntityRequest Spotify__Extendedmetadata__BatchedEntityRequest; +typedef struct Spotify__Extendedmetadata__EntityExtensionDataArrayHeader Spotify__Extendedmetadata__EntityExtensionDataArrayHeader; +typedef struct Spotify__Extendedmetadata__EntityExtensionDataArray Spotify__Extendedmetadata__EntityExtensionDataArray; +typedef struct Spotify__Extendedmetadata__BatchedExtensionResponseHeader Spotify__Extendedmetadata__BatchedExtensionResponseHeader; +typedef struct Spotify__Extendedmetadata__BatchedExtensionResponse Spotify__Extendedmetadata__BatchedExtensionResponse; + + +/* --- enums --- */ + +typedef enum _Spotify__Extendedmetadata__ExtensionType { + SPOTIFY__EXTENDEDMETADATA__EXTENSION_TYPE__UNKNOWN = 0, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_TYPE__GENERIC = 1, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_TYPE__ASSOC = 2 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SPOTIFY__EXTENDEDMETADATA__EXTENSION_TYPE) +} Spotify__Extendedmetadata__ExtensionType; + +/* --- messages --- */ + +struct Spotify__Extendedmetadata__ExtensionQuery +{ + ProtobufCMessage base; + Spotify__Extendedmetadata__ExtensionKind extension_kind; + char *etag; +}; +#define SPOTIFY__EXTENDEDMETADATA__EXTENSION_QUERY__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&spotify__extendedmetadata__extension_query__descriptor) \ + , SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__UNKNOWN_EXTENSION, (char *)protobuf_c_empty_string } + + +struct Spotify__Extendedmetadata__EntityRequest +{ + ProtobufCMessage base; + char *entity_uri; + size_t n_query; + Spotify__Extendedmetadata__ExtensionQuery **query; +}; +#define SPOTIFY__EXTENDEDMETADATA__ENTITY_REQUEST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&spotify__extendedmetadata__entity_request__descriptor) \ + , (char *)protobuf_c_empty_string, 0,NULL } + + +struct Spotify__Extendedmetadata__BatchedEntityRequestHeader +{ + ProtobufCMessage base; + char *country; + char *catalogue; + ProtobufCBinaryData task_id; +}; +#define SPOTIFY__EXTENDEDMETADATA__BATCHED_ENTITY_REQUEST_HEADER__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&spotify__extendedmetadata__batched_entity_request_header__descriptor) \ + , (char *)protobuf_c_empty_string, (char *)protobuf_c_empty_string, {0,NULL} } + + +struct Spotify__Extendedmetadata__BatchedEntityRequest +{ + ProtobufCMessage base; + Spotify__Extendedmetadata__BatchedEntityRequestHeader *header; + size_t n_entity_request; + Spotify__Extendedmetadata__EntityRequest **entity_request; +}; +#define SPOTIFY__EXTENDEDMETADATA__BATCHED_ENTITY_REQUEST__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&spotify__extendedmetadata__batched_entity_request__descriptor) \ + , NULL, 0,NULL } + + +struct Spotify__Extendedmetadata__EntityExtensionDataArrayHeader +{ + ProtobufCMessage base; + int32_t provider_error_status; + int64_t cache_ttl_in_seconds; + int64_t offline_ttl_in_seconds; + Spotify__Extendedmetadata__ExtensionType extension_type; +}; +#define SPOTIFY__EXTENDEDMETADATA__ENTITY_EXTENSION_DATA_ARRAY_HEADER__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&spotify__extendedmetadata__entity_extension_data_array_header__descriptor) \ + , 0, 0, 0, SPOTIFY__EXTENDEDMETADATA__EXTENSION_TYPE__UNKNOWN } + + +struct Spotify__Extendedmetadata__EntityExtensionDataArray +{ + ProtobufCMessage base; + Spotify__Extendedmetadata__EntityExtensionDataArrayHeader *header; + Spotify__Extendedmetadata__ExtensionKind extension_kind; + size_t n_extension_data; + Spotify__Extendedmetadata__EntityExtensionData **extension_data; +}; +#define SPOTIFY__EXTENDEDMETADATA__ENTITY_EXTENSION_DATA_ARRAY__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&spotify__extendedmetadata__entity_extension_data_array__descriptor) \ + , NULL, SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__UNKNOWN_EXTENSION, 0,NULL } + + +struct Spotify__Extendedmetadata__BatchedExtensionResponseHeader +{ + ProtobufCMessage base; +}; +#define SPOTIFY__EXTENDEDMETADATA__BATCHED_EXTENSION_RESPONSE_HEADER__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&spotify__extendedmetadata__batched_extension_response_header__descriptor) \ + } + + +struct Spotify__Extendedmetadata__BatchedExtensionResponse +{ + ProtobufCMessage base; + Spotify__Extendedmetadata__BatchedExtensionResponseHeader *header; + size_t n_extended_metadata; + Spotify__Extendedmetadata__EntityExtensionDataArray **extended_metadata; +}; +#define SPOTIFY__EXTENDEDMETADATA__BATCHED_EXTENSION_RESPONSE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&spotify__extendedmetadata__batched_extension_response__descriptor) \ + , NULL, 0,NULL } + + +/* Spotify__Extendedmetadata__ExtensionQuery methods */ +void spotify__extendedmetadata__extension_query__init + (Spotify__Extendedmetadata__ExtensionQuery *message); +size_t spotify__extendedmetadata__extension_query__get_packed_size + (const Spotify__Extendedmetadata__ExtensionQuery *message); +size_t spotify__extendedmetadata__extension_query__pack + (const Spotify__Extendedmetadata__ExtensionQuery *message, + uint8_t *out); +size_t spotify__extendedmetadata__extension_query__pack_to_buffer + (const Spotify__Extendedmetadata__ExtensionQuery *message, + ProtobufCBuffer *buffer); +Spotify__Extendedmetadata__ExtensionQuery * + spotify__extendedmetadata__extension_query__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void spotify__extendedmetadata__extension_query__free_unpacked + (Spotify__Extendedmetadata__ExtensionQuery *message, + ProtobufCAllocator *allocator); +/* Spotify__Extendedmetadata__EntityRequest methods */ +void spotify__extendedmetadata__entity_request__init + (Spotify__Extendedmetadata__EntityRequest *message); +size_t spotify__extendedmetadata__entity_request__get_packed_size + (const Spotify__Extendedmetadata__EntityRequest *message); +size_t spotify__extendedmetadata__entity_request__pack + (const Spotify__Extendedmetadata__EntityRequest *message, + uint8_t *out); +size_t spotify__extendedmetadata__entity_request__pack_to_buffer + (const Spotify__Extendedmetadata__EntityRequest *message, + ProtobufCBuffer *buffer); +Spotify__Extendedmetadata__EntityRequest * + spotify__extendedmetadata__entity_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void spotify__extendedmetadata__entity_request__free_unpacked + (Spotify__Extendedmetadata__EntityRequest *message, + ProtobufCAllocator *allocator); +/* Spotify__Extendedmetadata__BatchedEntityRequestHeader methods */ +void spotify__extendedmetadata__batched_entity_request_header__init + (Spotify__Extendedmetadata__BatchedEntityRequestHeader *message); +size_t spotify__extendedmetadata__batched_entity_request_header__get_packed_size + (const Spotify__Extendedmetadata__BatchedEntityRequestHeader *message); +size_t spotify__extendedmetadata__batched_entity_request_header__pack + (const Spotify__Extendedmetadata__BatchedEntityRequestHeader *message, + uint8_t *out); +size_t spotify__extendedmetadata__batched_entity_request_header__pack_to_buffer + (const Spotify__Extendedmetadata__BatchedEntityRequestHeader *message, + ProtobufCBuffer *buffer); +Spotify__Extendedmetadata__BatchedEntityRequestHeader * + spotify__extendedmetadata__batched_entity_request_header__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void spotify__extendedmetadata__batched_entity_request_header__free_unpacked + (Spotify__Extendedmetadata__BatchedEntityRequestHeader *message, + ProtobufCAllocator *allocator); +/* Spotify__Extendedmetadata__BatchedEntityRequest methods */ +void spotify__extendedmetadata__batched_entity_request__init + (Spotify__Extendedmetadata__BatchedEntityRequest *message); +size_t spotify__extendedmetadata__batched_entity_request__get_packed_size + (const Spotify__Extendedmetadata__BatchedEntityRequest *message); +size_t spotify__extendedmetadata__batched_entity_request__pack + (const Spotify__Extendedmetadata__BatchedEntityRequest *message, + uint8_t *out); +size_t spotify__extendedmetadata__batched_entity_request__pack_to_buffer + (const Spotify__Extendedmetadata__BatchedEntityRequest *message, + ProtobufCBuffer *buffer); +Spotify__Extendedmetadata__BatchedEntityRequest * + spotify__extendedmetadata__batched_entity_request__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void spotify__extendedmetadata__batched_entity_request__free_unpacked + (Spotify__Extendedmetadata__BatchedEntityRequest *message, + ProtobufCAllocator *allocator); +/* Spotify__Extendedmetadata__EntityExtensionDataArrayHeader methods */ +void spotify__extendedmetadata__entity_extension_data_array_header__init + (Spotify__Extendedmetadata__EntityExtensionDataArrayHeader *message); +size_t spotify__extendedmetadata__entity_extension_data_array_header__get_packed_size + (const Spotify__Extendedmetadata__EntityExtensionDataArrayHeader *message); +size_t spotify__extendedmetadata__entity_extension_data_array_header__pack + (const Spotify__Extendedmetadata__EntityExtensionDataArrayHeader *message, + uint8_t *out); +size_t spotify__extendedmetadata__entity_extension_data_array_header__pack_to_buffer + (const Spotify__Extendedmetadata__EntityExtensionDataArrayHeader *message, + ProtobufCBuffer *buffer); +Spotify__Extendedmetadata__EntityExtensionDataArrayHeader * + spotify__extendedmetadata__entity_extension_data_array_header__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void spotify__extendedmetadata__entity_extension_data_array_header__free_unpacked + (Spotify__Extendedmetadata__EntityExtensionDataArrayHeader *message, + ProtobufCAllocator *allocator); +/* Spotify__Extendedmetadata__EntityExtensionDataArray methods */ +void spotify__extendedmetadata__entity_extension_data_array__init + (Spotify__Extendedmetadata__EntityExtensionDataArray *message); +size_t spotify__extendedmetadata__entity_extension_data_array__get_packed_size + (const Spotify__Extendedmetadata__EntityExtensionDataArray *message); +size_t spotify__extendedmetadata__entity_extension_data_array__pack + (const Spotify__Extendedmetadata__EntityExtensionDataArray *message, + uint8_t *out); +size_t spotify__extendedmetadata__entity_extension_data_array__pack_to_buffer + (const Spotify__Extendedmetadata__EntityExtensionDataArray *message, + ProtobufCBuffer *buffer); +Spotify__Extendedmetadata__EntityExtensionDataArray * + spotify__extendedmetadata__entity_extension_data_array__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void spotify__extendedmetadata__entity_extension_data_array__free_unpacked + (Spotify__Extendedmetadata__EntityExtensionDataArray *message, + ProtobufCAllocator *allocator); +/* Spotify__Extendedmetadata__BatchedExtensionResponseHeader methods */ +void spotify__extendedmetadata__batched_extension_response_header__init + (Spotify__Extendedmetadata__BatchedExtensionResponseHeader *message); +size_t spotify__extendedmetadata__batched_extension_response_header__get_packed_size + (const Spotify__Extendedmetadata__BatchedExtensionResponseHeader *message); +size_t spotify__extendedmetadata__batched_extension_response_header__pack + (const Spotify__Extendedmetadata__BatchedExtensionResponseHeader *message, + uint8_t *out); +size_t spotify__extendedmetadata__batched_extension_response_header__pack_to_buffer + (const Spotify__Extendedmetadata__BatchedExtensionResponseHeader *message, + ProtobufCBuffer *buffer); +Spotify__Extendedmetadata__BatchedExtensionResponseHeader * + spotify__extendedmetadata__batched_extension_response_header__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void spotify__extendedmetadata__batched_extension_response_header__free_unpacked + (Spotify__Extendedmetadata__BatchedExtensionResponseHeader *message, + ProtobufCAllocator *allocator); +/* Spotify__Extendedmetadata__BatchedExtensionResponse methods */ +void spotify__extendedmetadata__batched_extension_response__init + (Spotify__Extendedmetadata__BatchedExtensionResponse *message); +size_t spotify__extendedmetadata__batched_extension_response__get_packed_size + (const Spotify__Extendedmetadata__BatchedExtensionResponse *message); +size_t spotify__extendedmetadata__batched_extension_response__pack + (const Spotify__Extendedmetadata__BatchedExtensionResponse *message, + uint8_t *out); +size_t spotify__extendedmetadata__batched_extension_response__pack_to_buffer + (const Spotify__Extendedmetadata__BatchedExtensionResponse *message, + ProtobufCBuffer *buffer); +Spotify__Extendedmetadata__BatchedExtensionResponse * + spotify__extendedmetadata__batched_extension_response__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void spotify__extendedmetadata__batched_extension_response__free_unpacked + (Spotify__Extendedmetadata__BatchedExtensionResponse *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*Spotify__Extendedmetadata__ExtensionQuery_Closure) + (const Spotify__Extendedmetadata__ExtensionQuery *message, + void *closure_data); +typedef void (*Spotify__Extendedmetadata__EntityRequest_Closure) + (const Spotify__Extendedmetadata__EntityRequest *message, + void *closure_data); +typedef void (*Spotify__Extendedmetadata__BatchedEntityRequestHeader_Closure) + (const Spotify__Extendedmetadata__BatchedEntityRequestHeader *message, + void *closure_data); +typedef void (*Spotify__Extendedmetadata__BatchedEntityRequest_Closure) + (const Spotify__Extendedmetadata__BatchedEntityRequest *message, + void *closure_data); +typedef void (*Spotify__Extendedmetadata__EntityExtensionDataArrayHeader_Closure) + (const Spotify__Extendedmetadata__EntityExtensionDataArrayHeader *message, + void *closure_data); +typedef void (*Spotify__Extendedmetadata__EntityExtensionDataArray_Closure) + (const Spotify__Extendedmetadata__EntityExtensionDataArray *message, + void *closure_data); +typedef void (*Spotify__Extendedmetadata__BatchedExtensionResponseHeader_Closure) + (const Spotify__Extendedmetadata__BatchedExtensionResponseHeader *message, + void *closure_data); +typedef void (*Spotify__Extendedmetadata__BatchedExtensionResponse_Closure) + (const Spotify__Extendedmetadata__BatchedExtensionResponse *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCEnumDescriptor spotify__extendedmetadata__extension_type__descriptor; +extern const ProtobufCMessageDescriptor spotify__extendedmetadata__extension_query__descriptor; +extern const ProtobufCMessageDescriptor spotify__extendedmetadata__entity_request__descriptor; +extern const ProtobufCMessageDescriptor spotify__extendedmetadata__batched_entity_request_header__descriptor; +extern const ProtobufCMessageDescriptor spotify__extendedmetadata__batched_entity_request__descriptor; +extern const ProtobufCMessageDescriptor spotify__extendedmetadata__entity_extension_data_array_header__descriptor; +extern const ProtobufCMessageDescriptor spotify__extendedmetadata__entity_extension_data_array__descriptor; +extern const ProtobufCMessageDescriptor spotify__extendedmetadata__batched_extension_response_header__descriptor; +extern const ProtobufCMessageDescriptor spotify__extendedmetadata__batched_extension_response__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_extended_5fmetadata_2eproto__INCLUDED */ diff --git a/src/inputs/librespot-c/src/proto/extended_metadata.proto b/src/inputs/librespot-c/src/proto/extended_metadata.proto new file mode 100644 index 00000000..eb07d7f9 --- /dev/null +++ b/src/inputs/librespot-c/src/proto/extended_metadata.proto @@ -0,0 +1,53 @@ +syntax = "proto3"; + +package spotify.extendedmetadata; + +import "entity_extension_data.proto"; +import "extension_kind.proto"; + +message ExtensionQuery { + ExtensionKind extension_kind = 1; + string etag = 2; +} + +message EntityRequest { + string entity_uri = 1; + repeated ExtensionQuery query = 2; +} + +message BatchedEntityRequestHeader { + string country = 1; + string catalogue = 2; + bytes task_id = 3; +} + +message BatchedEntityRequest { + BatchedEntityRequestHeader header = 1; + repeated EntityRequest entity_request = 2; +} + +message EntityExtensionDataArrayHeader { + int32 provider_error_status = 1; + int64 cache_ttl_in_seconds = 2; + int64 offline_ttl_in_seconds = 3; + ExtensionType extension_type = 4; +} + +message EntityExtensionDataArray { + EntityExtensionDataArrayHeader header = 1; + ExtensionKind extension_kind = 2; + repeated EntityExtensionData extension_data = 3; +} + +message BatchedExtensionResponseHeader {} + +message BatchedExtensionResponse { + BatchedExtensionResponseHeader header = 1; + repeated EntityExtensionDataArray extended_metadata = 2; +} + +enum ExtensionType { + UNKNOWN = 0; + GENERIC = 1; + ASSOC = 2; +} diff --git a/src/inputs/librespot-c/src/proto/extension_kind.pb-c.c b/src/inputs/librespot-c/src/proto/extension_kind.pb-c.c new file mode 100644 index 00000000..37ab7d44 --- /dev/null +++ b/src/inputs/librespot-c/src/proto/extension_kind.pb-c.c @@ -0,0 +1,411 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: extension_kind.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "extension_kind.pb-c.h" +static const ProtobufCEnumValue spotify__extendedmetadata__extension_kind__enum_values_by_number[189] = +{ + { "UNKNOWN_EXTENSION", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__UNKNOWN_EXTENSION", 0 }, + { "CANVAZ", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CANVAZ", 1 }, + { "STORYLINES", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__STORYLINES", 2 }, + { "PODCAST_TOPICS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_TOPICS", 3 }, + { "PODCAST_SEGMENTS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_SEGMENTS", 4 }, + { "AUDIO_FILES", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__AUDIO_FILES", 5 }, + { "TRACK_DESCRIPTOR", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__TRACK_DESCRIPTOR", 6 }, + { "PODCAST_COUNTER", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_COUNTER", 7 }, + { "ARTIST_V4", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__ARTIST_V4", 8 }, + { "ALBUM_V4", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__ALBUM_V4", 9 }, + { "TRACK_V4", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__TRACK_V4", 10 }, + { "SHOW_V4", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SHOW_V4", 11 }, + { "EPISODE_V4", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__EPISODE_V4", 12 }, + { "PODCAST_HTML_DESCRIPTION", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_HTML_DESCRIPTION", 13 }, + { "PODCAST_QUOTES", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_QUOTES", 14 }, + { "USER_PROFILE", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__USER_PROFILE", 15 }, + { "CANVAS_V1", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CANVAS_V1", 16 }, + { "SHOW_V4_BASE", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SHOW_V4_BASE", 17 }, + { "SHOW_V4_EPISODES_ASSOC", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SHOW_V4_EPISODES_ASSOC", 18 }, + { "TRACK_DESCRIPTOR_SIGNATURES", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__TRACK_DESCRIPTOR_SIGNATURES", 19 }, + { "PODCAST_AD_SEGMENTS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_AD_SEGMENTS", 20 }, + { "EPISODE_TRANSCRIPTS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__EPISODE_TRANSCRIPTS", 21 }, + { "PODCAST_SUBSCRIPTIONS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_SUBSCRIPTIONS", 22 }, + { "EXTRACTED_COLOR", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__EXTRACTED_COLOR", 23 }, + { "PODCAST_VIRALITY", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_VIRALITY", 24 }, + { "IMAGE_SPARKLES_HACK", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__IMAGE_SPARKLES_HACK", 25 }, + { "PODCAST_POPULARITY_HACK", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_POPULARITY_HACK", 26 }, + { "AUTOMIX_MODE", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__AUTOMIX_MODE", 27 }, + { "CUEPOINTS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CUEPOINTS", 28 }, + { "PODCAST_POLL", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_POLL", 29 }, + { "EPISODE_ACCESS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__EPISODE_ACCESS", 30 }, + { "SHOW_ACCESS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SHOW_ACCESS", 31 }, + { "PODCAST_QNA", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_QNA", 32 }, + { "CLIPS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CLIPS", 33 }, + { "SHOW_V5", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SHOW_V5", 34 }, + { "EPISODE_V5", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__EPISODE_V5", 35 }, + { "PODCAST_CTA_CARDS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_CTA_CARDS", 36 }, + { "PODCAST_RATING", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_RATING", 37 }, + { "DISPLAY_SEGMENTS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__DISPLAY_SEGMENTS", 38 }, + { "GREENROOM", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__GREENROOM", 39 }, + { "USER_CREATED", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__USER_CREATED", 40 }, + { "SHOW_DESCRIPTION", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SHOW_DESCRIPTION", 41 }, + { "SHOW_HTML_DESCRIPTION", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SHOW_HTML_DESCRIPTION", 42 }, + { "SHOW_PLAYABILITY", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SHOW_PLAYABILITY", 43 }, + { "EPISODE_DESCRIPTION", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__EPISODE_DESCRIPTION", 44 }, + { "EPISODE_HTML_DESCRIPTION", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__EPISODE_HTML_DESCRIPTION", 45 }, + { "EPISODE_PLAYABILITY", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__EPISODE_PLAYABILITY", 46 }, + { "SHOW_EPISODES_ASSOC", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SHOW_EPISODES_ASSOC", 47 }, + { "CLIENT_CONFIG", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CLIENT_CONFIG", 48 }, + { "PLAYLISTABILITY", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PLAYLISTABILITY", 49 }, + { "AUDIOBOOK_V5", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__AUDIOBOOK_V5", 50 }, + { "CHAPTER_V5", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CHAPTER_V5", 51 }, + { "AUDIOBOOK_SPECIFICS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__AUDIOBOOK_SPECIFICS", 52 }, + { "EPISODE_RANKING", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__EPISODE_RANKING", 53 }, + { "HTML_DESCRIPTION", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__HTML_DESCRIPTION", 54 }, + { "CREATOR_CHANNEL", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CREATOR_CHANNEL", 55 }, + { "AUDIOBOOK_PROVIDERS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__AUDIOBOOK_PROVIDERS", 56 }, + { "PLAY_TRAIT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PLAY_TRAIT", 57 }, + { "CONTENT_WARNING", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CONTENT_WARNING", 58 }, + { "IMAGE_CUE", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__IMAGE_CUE", 59 }, + { "STREAM_COUNT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__STREAM_COUNT", 60 }, + { "AUDIO_ATTRIBUTES", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__AUDIO_ATTRIBUTES", 61 }, + { "NAVIGABLE_TRAIT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__NAVIGABLE_TRAIT", 62 }, + { "NEXT_BEST_EPISODE", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__NEXT_BEST_EPISODE", 63 }, + { "AUDIOBOOK_PRICE", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__AUDIOBOOK_PRICE", 64 }, + { "EXPRESSIVE_PLAYLISTS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__EXPRESSIVE_PLAYLISTS", 65 }, + { "DYNAMIC_SHOW_EPISODE", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__DYNAMIC_SHOW_EPISODE", 66 }, + { "LIVE", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__LIVE", 67 }, + { "SKIP_PLAYED", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SKIP_PLAYED", 68 }, + { "AD_BREAK_FREE_PODCASTS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__AD_BREAK_FREE_PODCASTS", 69 }, + { "ASSOCIATIONS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__ASSOCIATIONS", 70 }, + { "PLAYLIST_EVALUATION", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PLAYLIST_EVALUATION", 71 }, + { "CACHE_INVALIDATIONS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CACHE_INVALIDATIONS", 72 }, + { "LIVESTREAM_ENTITY", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__LIVESTREAM_ENTITY", 73 }, + { "SINGLE_TAP_REACTIONS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SINGLE_TAP_REACTIONS", 74 }, + { "USER_COMMENTS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__USER_COMMENTS", 75 }, + { "CLIENT_RESTRICTIONS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CLIENT_RESTRICTIONS", 76 }, + { "PODCAST_GUEST", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_GUEST", 77 }, + { "PLAYABILITY", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PLAYABILITY", 78 }, + { "COVER_IMAGE", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__COVER_IMAGE", 79 }, + { "SHARE_TRAIT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SHARE_TRAIT", 80 }, + { "INSTANCE_SHARING", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__INSTANCE_SHARING", 81 }, + { "ARTIST_TOUR", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__ARTIST_TOUR", 82 }, + { "AUDIOBOOK_GENRE", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__AUDIOBOOK_GENRE", 83 }, + { "CONCEPT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CONCEPT", 84 }, + { "ORIGINAL_VIDEO", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__ORIGINAL_VIDEO", 85 }, + { "SMART_SHUFFLE", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SMART_SHUFFLE", 86 }, + { "LIVE_EVENTS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__LIVE_EVENTS", 87 }, + { "AUDIOBOOK_RELATIONS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__AUDIOBOOK_RELATIONS", 88 }, + { "HOME_POC_BASECARD", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__HOME_POC_BASECARD", 89 }, + { "AUDIOBOOK_SUPPLEMENTS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__AUDIOBOOK_SUPPLEMENTS", 90 }, + { "PAID_PODCAST_BANNER", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PAID_PODCAST_BANNER", 91 }, + { "FEWER_ADS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__FEWER_ADS", 92 }, + { "WATCH_FEED_SHOW_EXPLORER", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__WATCH_FEED_SHOW_EXPLORER", 93 }, + { "TRACK_EXTRA_DESCRIPTORS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__TRACK_EXTRA_DESCRIPTORS", 94 }, + { "TRACK_EXTRA_AUDIO_ATTRIBUTES", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__TRACK_EXTRA_AUDIO_ATTRIBUTES", 95 }, + { "TRACK_EXTENDED_CREDITS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__TRACK_EXTENDED_CREDITS", 96 }, + { "SIMPLE_TRAIT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SIMPLE_TRAIT", 97 }, + { "AUDIO_ASSOCIATIONS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__AUDIO_ASSOCIATIONS", 98 }, + { "VIDEO_ASSOCIATIONS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__VIDEO_ASSOCIATIONS", 99 }, + { "PLAYLIST_TUNER", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PLAYLIST_TUNER", 100 }, + { "ARTIST_VIDEOS_ENTRYPOINT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__ARTIST_VIDEOS_ENTRYPOINT", 101 }, + { "ALBUM_PRERELEASE", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__ALBUM_PRERELEASE", 102 }, + { "CONTENT_ALTERNATIVES", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CONTENT_ALTERNATIVES", 103 }, + { "SNAPSHOT_SHARING", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SNAPSHOT_SHARING", 105 }, + { "DISPLAY_SEGMENTS_COUNT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__DISPLAY_SEGMENTS_COUNT", 106 }, + { "PODCAST_FEATURED_EPISODE", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_FEATURED_EPISODE", 107 }, + { "PODCAST_SPONSORED_CONTENT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_SPONSORED_CONTENT", 108 }, + { "PODCAST_EPISODE_TOPICS_LLM", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_EPISODE_TOPICS_LLM", 109 }, + { "PODCAST_EPISODE_TOPICS_KG", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_EPISODE_TOPICS_KG", 110 }, + { "EPISODE_RANKING_POPULARITY", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__EPISODE_RANKING_POPULARITY", 111 }, + { "MERCH", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__MERCH", 112 }, + { "COMPANION_CONTENT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__COMPANION_CONTENT", 113 }, + { "WATCH_FEED_ENTITY_EXPLORER", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__WATCH_FEED_ENTITY_EXPLORER", 114 }, + { "ANCHOR_CARD_TRAIT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__ANCHOR_CARD_TRAIT", 115 }, + { "AUDIO_PREVIEW_PLAYBACK_TRAIT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__AUDIO_PREVIEW_PLAYBACK_TRAIT", 116 }, + { "VIDEO_PREVIEW_STILL_TRAIT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__VIDEO_PREVIEW_STILL_TRAIT", 117 }, + { "PREVIEW_CARD_TRAIT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PREVIEW_CARD_TRAIT", 118 }, + { "SHORTCUTS_CARD_TRAIT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SHORTCUTS_CARD_TRAIT", 119 }, + { "VIDEO_PREVIEW_PLAYBACK_TRAIT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__VIDEO_PREVIEW_PLAYBACK_TRAIT", 120 }, + { "COURSE_SPECIFICS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__COURSE_SPECIFICS", 121 }, + { "CONCERT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CONCERT", 122 }, + { "CONCERT_LOCATION", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CONCERT_LOCATION", 123 }, + { "CONCERT_MARKETING", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CONCERT_MARKETING", 124 }, + { "CONCERT_PERFORMERS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CONCERT_PERFORMERS", 125 }, + { "TRACK_PAIR_TRANSITION", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__TRACK_PAIR_TRANSITION", 126 }, + { "CONTENT_TYPE_TRAIT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CONTENT_TYPE_TRAIT", 127 }, + { "NAME_TRAIT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__NAME_TRAIT", 128 }, + { "ARTWORK_TRAIT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__ARTWORK_TRAIT", 129 }, + { "RELEASE_DATE_TRAIT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__RELEASE_DATE_TRAIT", 130 }, + { "CREDITS_TRAIT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CREDITS_TRAIT", 131 }, + { "RELEASE_URI_TRAIT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__RELEASE_URI_TRAIT", 132 }, + { "ENTITY_CAPPING", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__ENTITY_CAPPING", 133 }, + { "LESSON_SPECIFICS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__LESSON_SPECIFICS", 134 }, + { "CONCERT_OFFERS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CONCERT_OFFERS", 135 }, + { "TRANSITION_MAPS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__TRANSITION_MAPS", 136 }, + { "ARTIST_HAS_CONCERTS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__ARTIST_HAS_CONCERTS", 137 }, + { "PRERELEASE", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PRERELEASE", 138 }, + { "PLAYLIST_ATTRIBUTES_V2", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PLAYLIST_ATTRIBUTES_V2", 139 }, + { "LIST_ATTRIBUTES_V2", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__LIST_ATTRIBUTES_V2", 140 }, + { "LIST_METADATA", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__LIST_METADATA", 141 }, + { "LIST_TUNER_AUDIO_ANALYSIS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__LIST_TUNER_AUDIO_ANALYSIS", 142 }, + { "LIST_TUNER_CUEPOINTS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__LIST_TUNER_CUEPOINTS", 143 }, + { "CONTENT_RATING_TRAIT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CONTENT_RATING_TRAIT", 144 }, + { "COPYRIGHT_TRAIT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__COPYRIGHT_TRAIT", 145 }, + { "SUPPORTED_BADGES", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SUPPORTED_BADGES", 146 }, + { "BADGES", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__BADGES", 147 }, + { "PREVIEW_TRAIT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PREVIEW_TRAIT", 148 }, + { "ROOTLISTABILITY_TRAIT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__ROOTLISTABILITY_TRAIT", 149 }, + { "LOCAL_CONCERTS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__LOCAL_CONCERTS", 150 }, + { "RECOMMENDED_PLAYLISTS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__RECOMMENDED_PLAYLISTS", 151 }, + { "POPULAR_RELEASES", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__POPULAR_RELEASES", 152 }, + { "RELATED_RELEASES", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__RELATED_RELEASES", 153 }, + { "SHARE_RESTRICTIONS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SHARE_RESTRICTIONS", 154 }, + { "CONCERT_OFFER", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CONCERT_OFFER", 155 }, + { "CONCERT_OFFER_PROVIDER", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CONCERT_OFFER_PROVIDER", 156 }, + { "ENTITY_BOOKMARKS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__ENTITY_BOOKMARKS", 157 }, + { "PRIVACY_TRAIT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PRIVACY_TRAIT", 158 }, + { "DUPLICATE_ITEMS_TRAIT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__DUPLICATE_ITEMS_TRAIT", 159 }, + { "REORDERING_TRAIT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__REORDERING_TRAIT", 160 }, + { "PODCAST_RESUMPTION_SEGMENTS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_RESUMPTION_SEGMENTS", 161 }, + { "ARTIST_EXPRESSION_VIDEO", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__ARTIST_EXPRESSION_VIDEO", 162 }, + { "PRERELEASE_VIDEO", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PRERELEASE_VIDEO", 163 }, + { "GATED_ENTITY_RELATIONS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__GATED_ENTITY_RELATIONS", 164 }, + { "RELATED_CREATORS_SECTION", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__RELATED_CREATORS_SECTION", 165 }, + { "CREATORS_APPEARS_ON_SECTION", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CREATORS_APPEARS_ON_SECTION", 166 }, + { "PROMO_V1_TRAIT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PROMO_V1_TRAIT", 167 }, + { "SPEECHLESS_SHARE_CARD", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SPEECHLESS_SHARE_CARD", 168 }, + { "TOP_PLAYABLES_SECTION", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__TOP_PLAYABLES_SECTION", 169 }, + { "AUTO_LENS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__AUTO_LENS", 170 }, + { "PROMO_V3_TRAIT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PROMO_V3_TRAIT", 171 }, + { "TRACK_CONTENT_FILTER", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__TRACK_CONTENT_FILTER", 172 }, + { "HIGHLIGHTABILITY", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__HIGHLIGHTABILITY", 173 }, + { "LINK_CARD_WITH_IMAGE_TRAIT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__LINK_CARD_WITH_IMAGE_TRAIT", 174 }, + { "TRACK_CLOUD_SECTION", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__TRACK_CLOUD_SECTION", 175 }, + { "EPISODE_TOPICS", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__EPISODE_TOPICS", 176 }, + { "VIDEO_THUMBNAIL", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__VIDEO_THUMBNAIL", 177 }, + { "IDENTITY_TRAIT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__IDENTITY_TRAIT", 178 }, + { "VISUAL_IDENTITY_TRAIT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__VISUAL_IDENTITY_TRAIT", 179 }, + { "CONTENT_TYPE_V2_TRAIT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CONTENT_TYPE_V2_TRAIT", 180 }, + { "PREVIEW_PLAYBACK_TRAIT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PREVIEW_PLAYBACK_TRAIT", 181 }, + { "CONSUMPTION_EXPERIENCE_TRAIT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CONSUMPTION_EXPERIENCE_TRAIT", 182 }, + { "PUBLISHING_METADATA_TRAIT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PUBLISHING_METADATA_TRAIT", 183 }, + { "DETAILED_EVALUATION_TRAIT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__DETAILED_EVALUATION_TRAIT", 184 }, + { "ON_PLATFORM_REPUTATION_TRAIT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__ON_PLATFORM_REPUTATION_TRAIT", 185 }, + { "CREDITS_V2_TRAIT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CREDITS_V2_TRAIT", 186 }, + { "HIGHLIGHT_PLAYABILITY_TRAIT", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__HIGHLIGHT_PLAYABILITY_TRAIT", 187 }, + { "SHOW_EPISODE_LIST", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SHOW_EPISODE_LIST", 188 }, + { "AVAILABLE_RELEASES", "SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__AVAILABLE_RELEASES", 189 }, +}; +static const ProtobufCIntRange spotify__extendedmetadata__extension_kind__value_ranges[] = { +{0, 0},{105, 104},{0, 189} +}; +static const ProtobufCEnumValueIndex spotify__extendedmetadata__extension_kind__enum_values_by_name[189] = +{ + { "AD_BREAK_FREE_PODCASTS", 69 }, + { "ALBUM_PRERELEASE", 102 }, + { "ALBUM_V4", 9 }, + { "ANCHOR_CARD_TRAIT", 114 }, + { "ARTIST_EXPRESSION_VIDEO", 161 }, + { "ARTIST_HAS_CONCERTS", 136 }, + { "ARTIST_TOUR", 82 }, + { "ARTIST_V4", 8 }, + { "ARTIST_VIDEOS_ENTRYPOINT", 101 }, + { "ARTWORK_TRAIT", 128 }, + { "ASSOCIATIONS", 70 }, + { "AUDIOBOOK_GENRE", 83 }, + { "AUDIOBOOK_PRICE", 64 }, + { "AUDIOBOOK_PROVIDERS", 56 }, + { "AUDIOBOOK_RELATIONS", 88 }, + { "AUDIOBOOK_SPECIFICS", 52 }, + { "AUDIOBOOK_SUPPLEMENTS", 90 }, + { "AUDIOBOOK_V5", 50 }, + { "AUDIO_ASSOCIATIONS", 98 }, + { "AUDIO_ATTRIBUTES", 61 }, + { "AUDIO_FILES", 5 }, + { "AUDIO_PREVIEW_PLAYBACK_TRAIT", 115 }, + { "AUTOMIX_MODE", 27 }, + { "AUTO_LENS", 169 }, + { "AVAILABLE_RELEASES", 188 }, + { "BADGES", 146 }, + { "CACHE_INVALIDATIONS", 72 }, + { "CANVAS_V1", 16 }, + { "CANVAZ", 1 }, + { "CHAPTER_V5", 51 }, + { "CLIENT_CONFIG", 48 }, + { "CLIENT_RESTRICTIONS", 76 }, + { "CLIPS", 33 }, + { "COMPANION_CONTENT", 112 }, + { "CONCEPT", 84 }, + { "CONCERT", 121 }, + { "CONCERT_LOCATION", 122 }, + { "CONCERT_MARKETING", 123 }, + { "CONCERT_OFFER", 154 }, + { "CONCERT_OFFERS", 134 }, + { "CONCERT_OFFER_PROVIDER", 155 }, + { "CONCERT_PERFORMERS", 124 }, + { "CONSUMPTION_EXPERIENCE_TRAIT", 181 }, + { "CONTENT_ALTERNATIVES", 103 }, + { "CONTENT_RATING_TRAIT", 143 }, + { "CONTENT_TYPE_TRAIT", 126 }, + { "CONTENT_TYPE_V2_TRAIT", 179 }, + { "CONTENT_WARNING", 58 }, + { "COPYRIGHT_TRAIT", 144 }, + { "COURSE_SPECIFICS", 120 }, + { "COVER_IMAGE", 79 }, + { "CREATORS_APPEARS_ON_SECTION", 165 }, + { "CREATOR_CHANNEL", 55 }, + { "CREDITS_TRAIT", 130 }, + { "CREDITS_V2_TRAIT", 185 }, + { "CUEPOINTS", 28 }, + { "DETAILED_EVALUATION_TRAIT", 183 }, + { "DISPLAY_SEGMENTS", 38 }, + { "DISPLAY_SEGMENTS_COUNT", 105 }, + { "DUPLICATE_ITEMS_TRAIT", 158 }, + { "DYNAMIC_SHOW_EPISODE", 66 }, + { "ENTITY_BOOKMARKS", 156 }, + { "ENTITY_CAPPING", 132 }, + { "EPISODE_ACCESS", 30 }, + { "EPISODE_DESCRIPTION", 44 }, + { "EPISODE_HTML_DESCRIPTION", 45 }, + { "EPISODE_PLAYABILITY", 46 }, + { "EPISODE_RANKING", 53 }, + { "EPISODE_RANKING_POPULARITY", 110 }, + { "EPISODE_TOPICS", 175 }, + { "EPISODE_TRANSCRIPTS", 21 }, + { "EPISODE_V4", 12 }, + { "EPISODE_V5", 35 }, + { "EXPRESSIVE_PLAYLISTS", 65 }, + { "EXTRACTED_COLOR", 23 }, + { "FEWER_ADS", 92 }, + { "GATED_ENTITY_RELATIONS", 163 }, + { "GREENROOM", 39 }, + { "HIGHLIGHTABILITY", 172 }, + { "HIGHLIGHT_PLAYABILITY_TRAIT", 186 }, + { "HOME_POC_BASECARD", 89 }, + { "HTML_DESCRIPTION", 54 }, + { "IDENTITY_TRAIT", 177 }, + { "IMAGE_CUE", 59 }, + { "IMAGE_SPARKLES_HACK", 25 }, + { "INSTANCE_SHARING", 81 }, + { "LESSON_SPECIFICS", 133 }, + { "LINK_CARD_WITH_IMAGE_TRAIT", 173 }, + { "LIST_ATTRIBUTES_V2", 139 }, + { "LIST_METADATA", 140 }, + { "LIST_TUNER_AUDIO_ANALYSIS", 141 }, + { "LIST_TUNER_CUEPOINTS", 142 }, + { "LIVE", 67 }, + { "LIVESTREAM_ENTITY", 73 }, + { "LIVE_EVENTS", 87 }, + { "LOCAL_CONCERTS", 149 }, + { "MERCH", 111 }, + { "NAME_TRAIT", 127 }, + { "NAVIGABLE_TRAIT", 62 }, + { "NEXT_BEST_EPISODE", 63 }, + { "ON_PLATFORM_REPUTATION_TRAIT", 184 }, + { "ORIGINAL_VIDEO", 85 }, + { "PAID_PODCAST_BANNER", 91 }, + { "PLAYABILITY", 78 }, + { "PLAYLISTABILITY", 49 }, + { "PLAYLIST_ATTRIBUTES_V2", 138 }, + { "PLAYLIST_EVALUATION", 71 }, + { "PLAYLIST_TUNER", 100 }, + { "PLAY_TRAIT", 57 }, + { "PODCAST_AD_SEGMENTS", 20 }, + { "PODCAST_COUNTER", 7 }, + { "PODCAST_CTA_CARDS", 36 }, + { "PODCAST_EPISODE_TOPICS_KG", 109 }, + { "PODCAST_EPISODE_TOPICS_LLM", 108 }, + { "PODCAST_FEATURED_EPISODE", 106 }, + { "PODCAST_GUEST", 77 }, + { "PODCAST_HTML_DESCRIPTION", 13 }, + { "PODCAST_POLL", 29 }, + { "PODCAST_POPULARITY_HACK", 26 }, + { "PODCAST_QNA", 32 }, + { "PODCAST_QUOTES", 14 }, + { "PODCAST_RATING", 37 }, + { "PODCAST_RESUMPTION_SEGMENTS", 160 }, + { "PODCAST_SEGMENTS", 4 }, + { "PODCAST_SPONSORED_CONTENT", 107 }, + { "PODCAST_SUBSCRIPTIONS", 22 }, + { "PODCAST_TOPICS", 3 }, + { "PODCAST_VIRALITY", 24 }, + { "POPULAR_RELEASES", 151 }, + { "PRERELEASE", 137 }, + { "PRERELEASE_VIDEO", 162 }, + { "PREVIEW_CARD_TRAIT", 117 }, + { "PREVIEW_PLAYBACK_TRAIT", 180 }, + { "PREVIEW_TRAIT", 147 }, + { "PRIVACY_TRAIT", 157 }, + { "PROMO_V1_TRAIT", 166 }, + { "PROMO_V3_TRAIT", 170 }, + { "PUBLISHING_METADATA_TRAIT", 182 }, + { "RECOMMENDED_PLAYLISTS", 150 }, + { "RELATED_CREATORS_SECTION", 164 }, + { "RELATED_RELEASES", 152 }, + { "RELEASE_DATE_TRAIT", 129 }, + { "RELEASE_URI_TRAIT", 131 }, + { "REORDERING_TRAIT", 159 }, + { "ROOTLISTABILITY_TRAIT", 148 }, + { "SHARE_RESTRICTIONS", 153 }, + { "SHARE_TRAIT", 80 }, + { "SHORTCUTS_CARD_TRAIT", 118 }, + { "SHOW_ACCESS", 31 }, + { "SHOW_DESCRIPTION", 41 }, + { "SHOW_EPISODES_ASSOC", 47 }, + { "SHOW_EPISODE_LIST", 187 }, + { "SHOW_HTML_DESCRIPTION", 42 }, + { "SHOW_PLAYABILITY", 43 }, + { "SHOW_V4", 11 }, + { "SHOW_V4_BASE", 17 }, + { "SHOW_V4_EPISODES_ASSOC", 18 }, + { "SHOW_V5", 34 }, + { "SIMPLE_TRAIT", 97 }, + { "SINGLE_TAP_REACTIONS", 74 }, + { "SKIP_PLAYED", 68 }, + { "SMART_SHUFFLE", 86 }, + { "SNAPSHOT_SHARING", 104 }, + { "SPEECHLESS_SHARE_CARD", 167 }, + { "STORYLINES", 2 }, + { "STREAM_COUNT", 60 }, + { "SUPPORTED_BADGES", 145 }, + { "TOP_PLAYABLES_SECTION", 168 }, + { "TRACK_CLOUD_SECTION", 174 }, + { "TRACK_CONTENT_FILTER", 171 }, + { "TRACK_DESCRIPTOR", 6 }, + { "TRACK_DESCRIPTOR_SIGNATURES", 19 }, + { "TRACK_EXTENDED_CREDITS", 96 }, + { "TRACK_EXTRA_AUDIO_ATTRIBUTES", 95 }, + { "TRACK_EXTRA_DESCRIPTORS", 94 }, + { "TRACK_PAIR_TRANSITION", 125 }, + { "TRACK_V4", 10 }, + { "TRANSITION_MAPS", 135 }, + { "UNKNOWN_EXTENSION", 0 }, + { "USER_COMMENTS", 75 }, + { "USER_CREATED", 40 }, + { "USER_PROFILE", 15 }, + { "VIDEO_ASSOCIATIONS", 99 }, + { "VIDEO_PREVIEW_PLAYBACK_TRAIT", 119 }, + { "VIDEO_PREVIEW_STILL_TRAIT", 116 }, + { "VIDEO_THUMBNAIL", 176 }, + { "VISUAL_IDENTITY_TRAIT", 178 }, + { "WATCH_FEED_ENTITY_EXPLORER", 113 }, + { "WATCH_FEED_SHOW_EXPLORER", 93 }, +}; +const ProtobufCEnumDescriptor spotify__extendedmetadata__extension_kind__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "spotify.extendedmetadata.ExtensionKind", + "ExtensionKind", + "Spotify__Extendedmetadata__ExtensionKind", + "spotify.extendedmetadata", + 189, + spotify__extendedmetadata__extension_kind__enum_values_by_number, + 189, + spotify__extendedmetadata__extension_kind__enum_values_by_name, + 2, + spotify__extendedmetadata__extension_kind__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; diff --git a/src/inputs/librespot-c/src/proto/extension_kind.pb-c.h b/src/inputs/librespot-c/src/proto/extension_kind.pb-c.h new file mode 100644 index 00000000..8f13b02e --- /dev/null +++ b/src/inputs/librespot-c/src/proto/extension_kind.pb-c.h @@ -0,0 +1,230 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: extension_kind.proto */ + +#ifndef PROTOBUF_C_extension_5fkind_2eproto__INCLUDED +#define PROTOBUF_C_extension_5fkind_2eproto__INCLUDED + +#include + +PROTOBUF_C__BEGIN_DECLS + +#if PROTOBUF_C_VERSION_NUMBER < 1003000 +# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers. +#elif 1004001 < PROTOBUF_C_MIN_COMPILER_VERSION +# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c. +#endif + + + + +/* --- enums --- */ + +typedef enum _Spotify__Extendedmetadata__ExtensionKind { + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__UNKNOWN_EXTENSION = 0, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CANVAZ = 1, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__STORYLINES = 2, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_TOPICS = 3, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_SEGMENTS = 4, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__AUDIO_FILES = 5, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__TRACK_DESCRIPTOR = 6, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_COUNTER = 7, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__ARTIST_V4 = 8, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__ALBUM_V4 = 9, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__TRACK_V4 = 10, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SHOW_V4 = 11, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__EPISODE_V4 = 12, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_HTML_DESCRIPTION = 13, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_QUOTES = 14, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__USER_PROFILE = 15, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CANVAS_V1 = 16, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SHOW_V4_BASE = 17, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SHOW_V4_EPISODES_ASSOC = 18, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__TRACK_DESCRIPTOR_SIGNATURES = 19, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_AD_SEGMENTS = 20, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__EPISODE_TRANSCRIPTS = 21, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_SUBSCRIPTIONS = 22, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__EXTRACTED_COLOR = 23, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_VIRALITY = 24, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__IMAGE_SPARKLES_HACK = 25, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_POPULARITY_HACK = 26, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__AUTOMIX_MODE = 27, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CUEPOINTS = 28, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_POLL = 29, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__EPISODE_ACCESS = 30, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SHOW_ACCESS = 31, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_QNA = 32, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CLIPS = 33, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SHOW_V5 = 34, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__EPISODE_V5 = 35, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_CTA_CARDS = 36, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_RATING = 37, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__DISPLAY_SEGMENTS = 38, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__GREENROOM = 39, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__USER_CREATED = 40, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SHOW_DESCRIPTION = 41, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SHOW_HTML_DESCRIPTION = 42, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SHOW_PLAYABILITY = 43, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__EPISODE_DESCRIPTION = 44, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__EPISODE_HTML_DESCRIPTION = 45, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__EPISODE_PLAYABILITY = 46, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SHOW_EPISODES_ASSOC = 47, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CLIENT_CONFIG = 48, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PLAYLISTABILITY = 49, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__AUDIOBOOK_V5 = 50, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CHAPTER_V5 = 51, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__AUDIOBOOK_SPECIFICS = 52, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__EPISODE_RANKING = 53, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__HTML_DESCRIPTION = 54, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CREATOR_CHANNEL = 55, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__AUDIOBOOK_PROVIDERS = 56, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PLAY_TRAIT = 57, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CONTENT_WARNING = 58, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__IMAGE_CUE = 59, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__STREAM_COUNT = 60, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__AUDIO_ATTRIBUTES = 61, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__NAVIGABLE_TRAIT = 62, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__NEXT_BEST_EPISODE = 63, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__AUDIOBOOK_PRICE = 64, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__EXPRESSIVE_PLAYLISTS = 65, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__DYNAMIC_SHOW_EPISODE = 66, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__LIVE = 67, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SKIP_PLAYED = 68, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__AD_BREAK_FREE_PODCASTS = 69, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__ASSOCIATIONS = 70, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PLAYLIST_EVALUATION = 71, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CACHE_INVALIDATIONS = 72, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__LIVESTREAM_ENTITY = 73, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SINGLE_TAP_REACTIONS = 74, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__USER_COMMENTS = 75, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CLIENT_RESTRICTIONS = 76, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_GUEST = 77, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PLAYABILITY = 78, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__COVER_IMAGE = 79, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SHARE_TRAIT = 80, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__INSTANCE_SHARING = 81, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__ARTIST_TOUR = 82, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__AUDIOBOOK_GENRE = 83, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CONCEPT = 84, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__ORIGINAL_VIDEO = 85, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SMART_SHUFFLE = 86, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__LIVE_EVENTS = 87, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__AUDIOBOOK_RELATIONS = 88, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__HOME_POC_BASECARD = 89, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__AUDIOBOOK_SUPPLEMENTS = 90, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PAID_PODCAST_BANNER = 91, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__FEWER_ADS = 92, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__WATCH_FEED_SHOW_EXPLORER = 93, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__TRACK_EXTRA_DESCRIPTORS = 94, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__TRACK_EXTRA_AUDIO_ATTRIBUTES = 95, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__TRACK_EXTENDED_CREDITS = 96, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SIMPLE_TRAIT = 97, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__AUDIO_ASSOCIATIONS = 98, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__VIDEO_ASSOCIATIONS = 99, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PLAYLIST_TUNER = 100, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__ARTIST_VIDEOS_ENTRYPOINT = 101, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__ALBUM_PRERELEASE = 102, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CONTENT_ALTERNATIVES = 103, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SNAPSHOT_SHARING = 105, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__DISPLAY_SEGMENTS_COUNT = 106, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_FEATURED_EPISODE = 107, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_SPONSORED_CONTENT = 108, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_EPISODE_TOPICS_LLM = 109, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_EPISODE_TOPICS_KG = 110, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__EPISODE_RANKING_POPULARITY = 111, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__MERCH = 112, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__COMPANION_CONTENT = 113, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__WATCH_FEED_ENTITY_EXPLORER = 114, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__ANCHOR_CARD_TRAIT = 115, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__AUDIO_PREVIEW_PLAYBACK_TRAIT = 116, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__VIDEO_PREVIEW_STILL_TRAIT = 117, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PREVIEW_CARD_TRAIT = 118, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SHORTCUTS_CARD_TRAIT = 119, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__VIDEO_PREVIEW_PLAYBACK_TRAIT = 120, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__COURSE_SPECIFICS = 121, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CONCERT = 122, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CONCERT_LOCATION = 123, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CONCERT_MARKETING = 124, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CONCERT_PERFORMERS = 125, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__TRACK_PAIR_TRANSITION = 126, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CONTENT_TYPE_TRAIT = 127, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__NAME_TRAIT = 128, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__ARTWORK_TRAIT = 129, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__RELEASE_DATE_TRAIT = 130, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CREDITS_TRAIT = 131, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__RELEASE_URI_TRAIT = 132, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__ENTITY_CAPPING = 133, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__LESSON_SPECIFICS = 134, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CONCERT_OFFERS = 135, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__TRANSITION_MAPS = 136, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__ARTIST_HAS_CONCERTS = 137, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PRERELEASE = 138, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PLAYLIST_ATTRIBUTES_V2 = 139, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__LIST_ATTRIBUTES_V2 = 140, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__LIST_METADATA = 141, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__LIST_TUNER_AUDIO_ANALYSIS = 142, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__LIST_TUNER_CUEPOINTS = 143, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CONTENT_RATING_TRAIT = 144, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__COPYRIGHT_TRAIT = 145, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SUPPORTED_BADGES = 146, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__BADGES = 147, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PREVIEW_TRAIT = 148, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__ROOTLISTABILITY_TRAIT = 149, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__LOCAL_CONCERTS = 150, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__RECOMMENDED_PLAYLISTS = 151, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__POPULAR_RELEASES = 152, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__RELATED_RELEASES = 153, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SHARE_RESTRICTIONS = 154, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CONCERT_OFFER = 155, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CONCERT_OFFER_PROVIDER = 156, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__ENTITY_BOOKMARKS = 157, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PRIVACY_TRAIT = 158, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__DUPLICATE_ITEMS_TRAIT = 159, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__REORDERING_TRAIT = 160, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PODCAST_RESUMPTION_SEGMENTS = 161, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__ARTIST_EXPRESSION_VIDEO = 162, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PRERELEASE_VIDEO = 163, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__GATED_ENTITY_RELATIONS = 164, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__RELATED_CREATORS_SECTION = 165, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CREATORS_APPEARS_ON_SECTION = 166, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PROMO_V1_TRAIT = 167, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SPEECHLESS_SHARE_CARD = 168, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__TOP_PLAYABLES_SECTION = 169, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__AUTO_LENS = 170, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PROMO_V3_TRAIT = 171, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__TRACK_CONTENT_FILTER = 172, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__HIGHLIGHTABILITY = 173, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__LINK_CARD_WITH_IMAGE_TRAIT = 174, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__TRACK_CLOUD_SECTION = 175, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__EPISODE_TOPICS = 176, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__VIDEO_THUMBNAIL = 177, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__IDENTITY_TRAIT = 178, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__VISUAL_IDENTITY_TRAIT = 179, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CONTENT_TYPE_V2_TRAIT = 180, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PREVIEW_PLAYBACK_TRAIT = 181, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CONSUMPTION_EXPERIENCE_TRAIT = 182, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__PUBLISHING_METADATA_TRAIT = 183, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__DETAILED_EVALUATION_TRAIT = 184, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__ON_PLATFORM_REPUTATION_TRAIT = 185, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__CREDITS_V2_TRAIT = 186, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__HIGHLIGHT_PLAYABILITY_TRAIT = 187, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__SHOW_EPISODE_LIST = 188, + SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND__AVAILABLE_RELEASES = 189 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SPOTIFY__EXTENDEDMETADATA__EXTENSION_KIND) +} Spotify__Extendedmetadata__ExtensionKind; + +/* --- messages --- */ + +/* --- per-message closures --- */ + + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCEnumDescriptor spotify__extendedmetadata__extension_kind__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_extension_5fkind_2eproto__INCLUDED */ diff --git a/src/inputs/librespot-c/src/proto/extension_kind.proto b/src/inputs/librespot-c/src/proto/extension_kind.proto new file mode 100644 index 00000000..fd94586e --- /dev/null +++ b/src/inputs/librespot-c/src/proto/extension_kind.proto @@ -0,0 +1,195 @@ +syntax = "proto3"; + +package spotify.extendedmetadata; + +enum ExtensionKind { + UNKNOWN_EXTENSION = 0; + CANVAZ = 1; + STORYLINES = 2; + PODCAST_TOPICS = 3; + PODCAST_SEGMENTS = 4; + AUDIO_FILES = 5; + TRACK_DESCRIPTOR = 6; + PODCAST_COUNTER = 7; + ARTIST_V4 = 8; + ALBUM_V4 = 9; + TRACK_V4 = 10; + SHOW_V4 = 11; + EPISODE_V4 = 12; + PODCAST_HTML_DESCRIPTION = 13; + PODCAST_QUOTES = 14; + USER_PROFILE = 15; + CANVAS_V1 = 16; + SHOW_V4_BASE = 17; + SHOW_V4_EPISODES_ASSOC = 18; + TRACK_DESCRIPTOR_SIGNATURES = 19; + PODCAST_AD_SEGMENTS = 20; + EPISODE_TRANSCRIPTS = 21; + PODCAST_SUBSCRIPTIONS = 22; + EXTRACTED_COLOR = 23; + PODCAST_VIRALITY = 24; + IMAGE_SPARKLES_HACK = 25; + PODCAST_POPULARITY_HACK = 26; + AUTOMIX_MODE = 27; + CUEPOINTS = 28; + PODCAST_POLL = 29; + EPISODE_ACCESS = 30; + SHOW_ACCESS = 31; + PODCAST_QNA = 32; + CLIPS = 33; + SHOW_V5 = 34; + EPISODE_V5 = 35; + PODCAST_CTA_CARDS = 36; + PODCAST_RATING = 37; + DISPLAY_SEGMENTS = 38; + GREENROOM = 39; + USER_CREATED = 40; + SHOW_DESCRIPTION = 41; + SHOW_HTML_DESCRIPTION = 42; + SHOW_PLAYABILITY = 43; + EPISODE_DESCRIPTION = 44; + EPISODE_HTML_DESCRIPTION = 45; + EPISODE_PLAYABILITY = 46; + SHOW_EPISODES_ASSOC = 47; + CLIENT_CONFIG = 48; + PLAYLISTABILITY = 49; + AUDIOBOOK_V5 = 50; + CHAPTER_V5 = 51; + AUDIOBOOK_SPECIFICS = 52; + EPISODE_RANKING = 53; + HTML_DESCRIPTION = 54; + CREATOR_CHANNEL = 55; + AUDIOBOOK_PROVIDERS = 56; + PLAY_TRAIT = 57; + CONTENT_WARNING = 58; + IMAGE_CUE = 59; + STREAM_COUNT = 60; + AUDIO_ATTRIBUTES = 61; + NAVIGABLE_TRAIT = 62; + NEXT_BEST_EPISODE = 63; + AUDIOBOOK_PRICE = 64; + EXPRESSIVE_PLAYLISTS = 65; + DYNAMIC_SHOW_EPISODE = 66; + LIVE = 67; + SKIP_PLAYED = 68; + AD_BREAK_FREE_PODCASTS = 69; + ASSOCIATIONS = 70; + PLAYLIST_EVALUATION = 71; + CACHE_INVALIDATIONS = 72; + LIVESTREAM_ENTITY = 73; + SINGLE_TAP_REACTIONS = 74; + USER_COMMENTS = 75; + CLIENT_RESTRICTIONS = 76; + PODCAST_GUEST = 77; + PLAYABILITY = 78; + COVER_IMAGE = 79; + SHARE_TRAIT = 80; + INSTANCE_SHARING = 81; + ARTIST_TOUR = 82; + AUDIOBOOK_GENRE = 83; + CONCEPT = 84; + ORIGINAL_VIDEO = 85; + SMART_SHUFFLE = 86; + LIVE_EVENTS = 87; + AUDIOBOOK_RELATIONS = 88; + HOME_POC_BASECARD = 89; + AUDIOBOOK_SUPPLEMENTS = 90; + PAID_PODCAST_BANNER = 91; + FEWER_ADS = 92; + WATCH_FEED_SHOW_EXPLORER = 93; + TRACK_EXTRA_DESCRIPTORS = 94; + TRACK_EXTRA_AUDIO_ATTRIBUTES = 95; + TRACK_EXTENDED_CREDITS = 96; + SIMPLE_TRAIT = 97; + AUDIO_ASSOCIATIONS = 98; + VIDEO_ASSOCIATIONS = 99; + PLAYLIST_TUNER = 100; + ARTIST_VIDEOS_ENTRYPOINT = 101; + ALBUM_PRERELEASE = 102; + CONTENT_ALTERNATIVES = 103; + SNAPSHOT_SHARING = 105; + DISPLAY_SEGMENTS_COUNT = 106; + PODCAST_FEATURED_EPISODE = 107; + PODCAST_SPONSORED_CONTENT = 108; + PODCAST_EPISODE_TOPICS_LLM = 109; + PODCAST_EPISODE_TOPICS_KG = 110; + EPISODE_RANKING_POPULARITY = 111; + MERCH = 112; + COMPANION_CONTENT = 113; + WATCH_FEED_ENTITY_EXPLORER = 114; + ANCHOR_CARD_TRAIT = 115; + AUDIO_PREVIEW_PLAYBACK_TRAIT = 116; + VIDEO_PREVIEW_STILL_TRAIT = 117; + PREVIEW_CARD_TRAIT = 118; + SHORTCUTS_CARD_TRAIT = 119; + VIDEO_PREVIEW_PLAYBACK_TRAIT = 120; + COURSE_SPECIFICS = 121; + CONCERT = 122; + CONCERT_LOCATION = 123; + CONCERT_MARKETING = 124; + CONCERT_PERFORMERS = 125; + TRACK_PAIR_TRANSITION = 126; + CONTENT_TYPE_TRAIT = 127; + NAME_TRAIT = 128; + ARTWORK_TRAIT = 129; + RELEASE_DATE_TRAIT = 130; + CREDITS_TRAIT = 131; + RELEASE_URI_TRAIT = 132; + ENTITY_CAPPING = 133; + LESSON_SPECIFICS = 134; + CONCERT_OFFERS = 135; + TRANSITION_MAPS = 136; + ARTIST_HAS_CONCERTS = 137; + PRERELEASE = 138; + PLAYLIST_ATTRIBUTES_V2 = 139; + LIST_ATTRIBUTES_V2 = 140; + LIST_METADATA = 141; + LIST_TUNER_AUDIO_ANALYSIS = 142; + LIST_TUNER_CUEPOINTS = 143; + CONTENT_RATING_TRAIT = 144; + COPYRIGHT_TRAIT = 145; + SUPPORTED_BADGES = 146; + BADGES = 147; + PREVIEW_TRAIT = 148; + ROOTLISTABILITY_TRAIT = 149; + LOCAL_CONCERTS = 150; + RECOMMENDED_PLAYLISTS = 151; + POPULAR_RELEASES = 152; + RELATED_RELEASES = 153; + SHARE_RESTRICTIONS = 154; + CONCERT_OFFER = 155; + CONCERT_OFFER_PROVIDER = 156; + ENTITY_BOOKMARKS = 157; + PRIVACY_TRAIT = 158; + DUPLICATE_ITEMS_TRAIT = 159; + REORDERING_TRAIT = 160; + PODCAST_RESUMPTION_SEGMENTS = 161; + ARTIST_EXPRESSION_VIDEO = 162; + PRERELEASE_VIDEO = 163; + GATED_ENTITY_RELATIONS = 164; + RELATED_CREATORS_SECTION = 165; + CREATORS_APPEARS_ON_SECTION = 166; + PROMO_V1_TRAIT = 167; + SPEECHLESS_SHARE_CARD = 168; + TOP_PLAYABLES_SECTION = 169; + AUTO_LENS = 170; + PROMO_V3_TRAIT = 171; + TRACK_CONTENT_FILTER = 172; + HIGHLIGHTABILITY = 173; + LINK_CARD_WITH_IMAGE_TRAIT = 174; + TRACK_CLOUD_SECTION = 175; + EPISODE_TOPICS = 176; + VIDEO_THUMBNAIL = 177; + IDENTITY_TRAIT = 178; + VISUAL_IDENTITY_TRAIT = 179; + CONTENT_TYPE_V2_TRAIT = 180; + PREVIEW_PLAYBACK_TRAIT = 181; + CONSUMPTION_EXPERIENCE_TRAIT = 182; + PUBLISHING_METADATA_TRAIT = 183; + DETAILED_EVALUATION_TRAIT = 184; + ON_PLATFORM_REPUTATION_TRAIT = 185; + CREDITS_V2_TRAIT = 186; + HIGHLIGHT_PLAYABILITY_TRAIT = 187; + SHOW_EPISODE_LIST = 188; + AVAILABLE_RELEASES = 189; +} diff --git a/src/inputs/librespot-c/src/proto/google_any.pb-c.c b/src/inputs/librespot-c/src/proto/google_any.pb-c.c new file mode 100644 index 00000000..748cb3ac --- /dev/null +++ b/src/inputs/librespot-c/src/proto/google_any.pb-c.c @@ -0,0 +1,105 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: google_any.proto */ + +/* Do not generate deprecated warnings for self */ +#ifndef PROTOBUF_C__NO_DEPRECATED +#define PROTOBUF_C__NO_DEPRECATED +#endif + +#include "google_any.pb-c.h" +void google__protobuf__any__init + (Google__Protobuf__Any *message) +{ + static const Google__Protobuf__Any init_value = GOOGLE__PROTOBUF__ANY__INIT; + *message = init_value; +} +size_t google__protobuf__any__get_packed_size + (const Google__Protobuf__Any *message) +{ + assert(message->base.descriptor == &google__protobuf__any__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t google__protobuf__any__pack + (const Google__Protobuf__Any *message, + uint8_t *out) +{ + assert(message->base.descriptor == &google__protobuf__any__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t google__protobuf__any__pack_to_buffer + (const Google__Protobuf__Any *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &google__protobuf__any__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Google__Protobuf__Any * + google__protobuf__any__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Google__Protobuf__Any *) + protobuf_c_message_unpack (&google__protobuf__any__descriptor, + allocator, len, data); +} +void google__protobuf__any__free_unpacked + (Google__Protobuf__Any *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &google__protobuf__any__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +static const ProtobufCFieldDescriptor google__protobuf__any__field_descriptors[2] = +{ + { + "type_url", + 1, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Google__Protobuf__Any, type_url), + NULL, + &protobuf_c_empty_string, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "value", + 2, + PROTOBUF_C_LABEL_NONE, + PROTOBUF_C_TYPE_BYTES, + 0, /* quantifier_offset */ + offsetof(Google__Protobuf__Any, value), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned google__protobuf__any__field_indices_by_name[] = { + 0, /* field[0] = type_url */ + 1, /* field[1] = value */ +}; +static const ProtobufCIntRange google__protobuf__any__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 2 } +}; +const ProtobufCMessageDescriptor google__protobuf__any__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "google.protobuf.Any", + "Any", + "Google__Protobuf__Any", + "google.protobuf", + sizeof(Google__Protobuf__Any), + 2, + google__protobuf__any__field_descriptors, + google__protobuf__any__field_indices_by_name, + 1, google__protobuf__any__number_ranges, + (ProtobufCMessageInit) google__protobuf__any__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/src/inputs/librespot-c/src/proto/google_any.pb-c.h b/src/inputs/librespot-c/src/proto/google_any.pb-c.h new file mode 100644 index 00000000..81b1fbe4 --- /dev/null +++ b/src/inputs/librespot-c/src/proto/google_any.pb-c.h @@ -0,0 +1,72 @@ +/* Generated by the protocol buffer compiler. DO NOT EDIT! */ +/* Generated from: google_any.proto */ + +#ifndef PROTOBUF_C_google_5fany_2eproto__INCLUDED +#define PROTOBUF_C_google_5fany_2eproto__INCLUDED + +#include + +PROTOBUF_C__BEGIN_DECLS + +#if PROTOBUF_C_VERSION_NUMBER < 1003000 +# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers. +#elif 1004001 < PROTOBUF_C_MIN_COMPILER_VERSION +# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c. +#endif + + +typedef struct Google__Protobuf__Any Google__Protobuf__Any; + + +/* --- enums --- */ + + +/* --- messages --- */ + +struct Google__Protobuf__Any +{ + ProtobufCMessage base; + char *type_url; + ProtobufCBinaryData value; +}; +#define GOOGLE__PROTOBUF__ANY__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&google__protobuf__any__descriptor) \ + , (char *)protobuf_c_empty_string, {0,NULL} } + + +/* Google__Protobuf__Any methods */ +void google__protobuf__any__init + (Google__Protobuf__Any *message); +size_t google__protobuf__any__get_packed_size + (const Google__Protobuf__Any *message); +size_t google__protobuf__any__pack + (const Google__Protobuf__Any *message, + uint8_t *out); +size_t google__protobuf__any__pack_to_buffer + (const Google__Protobuf__Any *message, + ProtobufCBuffer *buffer); +Google__Protobuf__Any * + google__protobuf__any__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void google__protobuf__any__free_unpacked + (Google__Protobuf__Any *message, + ProtobufCAllocator *allocator); +/* --- per-message closures --- */ + +typedef void (*Google__Protobuf__Any_Closure) + (const Google__Protobuf__Any *message, + void *closure_data); + +/* --- services --- */ + + +/* --- descriptors --- */ + +extern const ProtobufCMessageDescriptor google__protobuf__any__descriptor; + +PROTOBUF_C__END_DECLS + + +#endif /* PROTOBUF_C_google_5fany_2eproto__INCLUDED */ diff --git a/src/inputs/librespot-c/src/proto/google_any.proto b/src/inputs/librespot-c/src/proto/google_any.proto new file mode 100644 index 00000000..887dde4c --- /dev/null +++ b/src/inputs/librespot-c/src/proto/google_any.proto @@ -0,0 +1,15 @@ +syntax = "proto3"; + +package google.protobuf; + +option csharp_namespace = "Google.Protobuf.WellKnownTypes"; +option objc_class_prefix = "GPB"; +option go_package = "google.golang.org/protobuf/types/known/anypb"; +option java_multiple_files = true; +option java_outer_classname = "AnyProto"; +option java_package = "com.google.protobuf"; + +message Any { + string type_url = 1; + bytes value = 2; +}