michaelh/zephyr
1
0
Fork 0
Code Releases Activity
zephyr/subsys/bluetooth/audio/mpl.c
Emil Gydesen ebadb11645 Bluetooth: Audio: Spring cleaning 
Adds, removes and modifies includes in all LE audio
files.

Fixes any found spelling mistakes as well.

Fixes a few places where incorrect types were used.

Signed-off-by: Emil Gydesen <emil.gydesen@nordicsemi.no>
2024-06-04 13:37:53 +02:00

2636 lines
69 KiB
C
Raw Blame History

/* Media player skeleton implementation */
/*
* Copyright (c) 2019 - 2023 Nordic Semiconductor ASA
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <errno.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <string.h>
#include <sys/types.h>
#include <zephyr/autoconf.h>
#include <zephyr/bluetooth/audio/mcs.h>
#include <zephyr/bluetooth/audio/media_proxy.h>
#include <zephyr/bluetooth/bluetooth.h>
#include <zephyr/bluetooth/services/ots.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/uuid.h>
#include <zephyr/kernel.h>
#include <zephyr/logging/log.h>
#include <zephyr/net/buf.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/sys/util.h>
#include <zephyr/sys/time_units.h>
#include <zephyr/sys/util_macro.h>
#include "ccid_internal.h"
#include "media_proxy_internal.h"
#include "mcs_internal.h"
#include "mpl_internal.h"
LOG_MODULE_REGISTER(bt_mpl, CONFIG_BT_MPL_LOG_LEVEL);
#define TRACK_STATUS_INVALID 0x00
#define TRACK_STATUS_VALID 0x01
#define TRACK_POS_WORK_DELAY_MS 1000
#define TRACK_POS_WORK_DELAY K_MSEC(TRACK_POS_WORK_DELAY_MS)
#define PLAYBACK_SPEED_PARAM_DEFAULT MEDIA_PROXY_PLAYBACK_SPEED_UNITY
/* Temporary hardcoded setup for groups, tracks and segments */
/* There is one parent group, which is the parent of a number of groups. */
/* The groups have a number of tracks. */
/* (There is only one level of groups, there are no groups of groups.) */
/* The first track of the first group has track segments, other tracks not. */
/* Track segments */
static struct mpl_tseg seg_2;
static struct mpl_tseg seg_3;
static struct mpl_tseg seg_1 = {
.name_len = 5,
.name = "Start",
.pos = 0,
.prev = NULL,
.next = &seg_2,
};
static struct mpl_tseg seg_2 = {
.name_len = 6,
.name = "Middle",
.pos = 2000,
.prev = &seg_1,
.next = &seg_3,
};
static struct mpl_tseg seg_3 = {
.name_len = 3,
.name = "End",
.pos = 5000,
.prev = &seg_2,
.next = NULL,
};
static struct mpl_track track_1_2;
static struct mpl_track track_1_3;
static struct mpl_track track_1_4;
static struct mpl_track track_1_5;
/* Tracks */
static struct mpl_track track_1_1 = {
.title = "Interlude #1 (Song for Alison)",
.duration = 6300,
.segment = &seg_1,
.prev = NULL,
.next = &track_1_2,
};
static struct mpl_track track_1_2 = {
.title = "Interlude #2 (For Bobbye)",
.duration = 7500,
.segment = NULL,
.prev = &track_1_1,
.next = &track_1_3,
};
static struct mpl_track track_1_3 = {
.title = "Interlude #3 (Levanto Seventy)",
.duration = 7800,
.segment = NULL,
.prev = &track_1_2,
.next = &track_1_4,
};
static struct mpl_track track_1_4 = {
.title = "Interlude #4 (Vesper Dreams)",
.duration = 13500,
.segment = NULL,
.prev = &track_1_3,
.next = &track_1_5,
};
static struct mpl_track track_1_5 = {
.title = "Interlude #5 (Shasti)",
.duration = 7500,
.segment = NULL,
.prev = &track_1_4,
.next = NULL,
};
static struct mpl_track track_2_2;
static struct mpl_track track_2_3;
static struct mpl_track track_2_1 = {
.title = "Track 2.1",
.duration = 30000,
.segment = NULL,
.prev = NULL,
.next = &track_2_2,
};
static struct mpl_track track_2_2 = {
.title = "Track 2.2",
.duration = 30000,
.segment = NULL,
.prev = &track_2_1,
.next = &track_2_3,
};
static struct mpl_track track_2_3 = {
.title = "Track 2.3",
.duration = 30000,
.segment = NULL,
.prev = &track_2_2,
.next = NULL,
};
static struct mpl_track track_3_2;
static struct mpl_track track_3_3;
static struct mpl_track track_3_1 = {
.title = "Track 3.1",
.duration = 30000,
.segment = NULL,
.prev = NULL,
.next = &track_3_2,
};
static struct mpl_track track_3_2 = {
.title = "Track 3.2",
.duration = 30000,
.segment = NULL,
.prev = &track_3_1,
.next = &track_3_3,
};
static struct mpl_track track_3_3 = {
.title = "Track 3.3",
.duration = 30000,
.segment = NULL,
.prev = &track_3_2,
.next = NULL,
};
static struct mpl_track track_4_2;
static struct mpl_track track_4_1 = {
.title = "Track 4.1",
.duration = 30000,
.segment = NULL,
.prev = NULL,
.next = &track_4_2,
};
static struct mpl_track track_4_2 = {
.title = "Track 4.2",
.duration = 30000,
.segment = NULL,
.prev = &track_4_1,
.next = NULL,
};
/* Groups */
static struct mpl_group group_2;
static struct mpl_group group_3;
static struct mpl_group group_4;
static struct mpl_group group_p;
static struct mpl_group group_1 = {
.title = "Joe Pass - Guitar Interludes",
.track = &track_1_1,
.parent = &group_p,
.prev = NULL,
.next = &group_2,
};
static struct mpl_group group_2 = {
.title = "Group 2",
.track = &track_2_2,
.parent = &group_p,
.prev = &group_1,
.next = &group_3,
};
static struct mpl_group group_3 = {
.title = "Group 3",
.track = &track_3_3,
.parent = &group_p,
.prev = &group_2,
.next = &group_4,
};
static struct mpl_group group_4 = {
.title = "Group 4",
.track = &track_4_2,
.parent = &group_p,
.prev = &group_3,
.next = NULL,
};
static struct mpl_group group_p = {
.title = "Parent group",
.track = &track_4_1,
.parent = &group_p,
.prev = NULL,
.next = NULL,
};
static struct mpl_mediaplayer media_player = {
.name = CONFIG_BT_MPL_MEDIA_PLAYER_NAME,
.icon_url = CONFIG_BT_MPL_ICON_URL,
.group = &group_1,
.track_pos = 0,
.state = MEDIA_PROXY_STATE_PAUSED,
.playback_speed_param = PLAYBACK_SPEED_PARAM_DEFAULT,
.seeking_speed_factor = MEDIA_PROXY_SEEKING_SPEED_FACTOR_ZERO,
.playing_order = MEDIA_PROXY_PLAYING_ORDER_INORDER_REPEAT,
.playing_orders_supported = MEDIA_PROXY_PLAYING_ORDERS_SUPPORTED_INORDER_ONCE |
MEDIA_PROXY_PLAYING_ORDERS_SUPPORTED_INORDER_REPEAT,
.opcodes_supported = 0x001fffff, /* All opcodes */
#ifdef CONFIG_BT_MPL_OBJECTS
.search_results_id = 0,
.calls = { 0 },
#endif /* CONFIG_BT_MPL_OBJECTS */
.next_track_set = false
};
static void set_track_position(int32_t position);
static void set_relative_track_position(int32_t rel_pos);
static void do_track_change_notifications(struct mpl_mediaplayer *pl);
static void do_group_change_notifications(struct mpl_mediaplayer *pl);
#ifdef CONFIG_BT_MPL_OBJECTS
/* The types of objects we keep in the Object Transfer Service */
enum mpl_objects {
MPL_OBJ_NONE = 0,
MPL_OBJ_ICON,
MPL_OBJ_TRACK_SEGMENTS,
MPL_OBJ_TRACK,
MPL_OBJ_PARENT_GROUP,
MPL_OBJ_GROUP,
MPL_OBJ_SEARCH_RESULTS,
};
/* The active object */
/* Only a single object is selected or being added (active) at a time. */
/* And, except for the icon object, all objects can be created dynamically. */
/* So a single buffer to hold object content is sufficient. */
struct obj_t {
/* ID of the currently selected object*/
uint64_t selected_id;
bool busy;
/* Type of object being added, e.g. MPL_OBJ_ICON */
uint8_t add_type;
/* Descriptor of object being added */
struct bt_ots_obj_created_desc *desc;
union {
/* Pointer to track being added */
struct mpl_track *add_track;
/* Pointer to group being added */
struct mpl_group *add_group;
};
struct net_buf_simple *content;
};
static struct obj_t obj = {
.selected_id = 0,
.add_type = MPL_OBJ_NONE,
.busy = false,
.add_track = NULL,
.add_group = NULL,
.content = NET_BUF_SIMPLE(CONFIG_BT_MPL_MAX_OBJ_SIZE)
};
/* Set up content buffer for the icon object */
static int setup_icon_object(void)
{
uint16_t index;
uint8_t k;
/* The icon object is supposed to be a bitmap. */
/* For now, fill it with dummy data. */
net_buf_simple_reset(obj.content);
/* Size may be larger than what fits in 8 bits, use 16-bit for index */
for (index = 0, k = 0;
index < MIN(CONFIG_BT_MPL_MAX_OBJ_SIZE,
CONFIG_BT_MPL_ICON_BITMAP_SIZE);
index++, k++) {
net_buf_simple_add_u8(obj.content, k);
}
return obj.content->len;
}
/* Set up content buffer for a track segments object */
static uint32_t setup_segments_object(struct mpl_track *track)
{
struct mpl_tseg *seg = track->segment;
net_buf_simple_reset(obj.content);
if (seg) {
uint32_t tot_size = 0;
while (seg->prev) {
seg = seg->prev;
}
while (seg) {
uint32_t seg_size = sizeof(seg->name_len);
seg_size += seg->name_len;
seg_size += sizeof(seg->pos);
if (tot_size + seg_size > obj.content->size) {
LOG_DBG("Segments object out of space");
break;
}
net_buf_simple_add_u8(obj.content, seg->name_len);
net_buf_simple_add_mem(obj.content, seg->name,
seg->name_len);
net_buf_simple_add_le32(obj.content, seg->pos);
tot_size += seg_size;
seg = seg->next;
}
LOG_HEXDUMP_DBG(obj.content->data, obj.content->len, "Segments Object");
LOG_DBG("Segments object length: %d", obj.content->len);
} else {
LOG_ERR("No seg!");
}
return obj.content->len;
}
/* Set up content buffer for a track object */
static uint32_t setup_track_object(struct mpl_track *track)
{
uint16_t index;
uint8_t k;
/* The track object is supposed to be in Id3v2 format */
/* For now, fill it with dummy data */
net_buf_simple_reset(obj.content);
/* Size may be larger than what fits in 8 bits, use 16-bit for index */
for (index = 0, k = 0;
index < MIN(CONFIG_BT_MPL_MAX_OBJ_SIZE,
CONFIG_BT_MPL_TRACK_MAX_SIZE);
index++, k++) {
net_buf_simple_add_u8(obj.content, k);
}
return obj.content->len;
}
/* Set up content buffer for the parent group object */
static uint32_t setup_parent_group_object(struct mpl_group *group)
{
/* This function actually does not use the parent. */
/* It just follows the list of groups. */
/* The implementation has a fixed structure, with one parent group, */
/* and one level of groups containing tracks only. */
/* The track groups have a pointer to the parent, but there is no */
/* pointer in the other direction, so it is not possible to go from */
/* the parent group to a group of tracks. */
uint8_t type = MEDIA_PROXY_GROUP_OBJECT_GROUP_TYPE;
uint8_t record_size = sizeof(type) + BT_OTS_OBJ_ID_SIZE;
int next_size = record_size;
net_buf_simple_reset(obj.content);
if (group) {
while (group->prev) {
group = group->prev;
}
/* While there is a group, and the record fits in the object */
while (group && (next_size <= obj.content->size)) {
net_buf_simple_add_u8(obj.content, type);
net_buf_simple_add_le48(obj.content, group->id);
group = group->next;
next_size += record_size;
}
if (next_size > obj.content->size) {
LOG_WRN("Not room for full group in object");
}
LOG_HEXDUMP_DBG(obj.content->data, obj.content->len, "Parent Group Object");
LOG_DBG("Group object length: %d", obj.content->len);
}
return obj.content->len;
}
/* Set up contents for a group object */
/* The group object contains a concatenated list of records, where each */
/* record consists of a type byte and a UUID */
static uint32_t setup_group_object(struct mpl_group *group)
{
struct mpl_track *track = group->track;
uint8_t type = MEDIA_PROXY_GROUP_OBJECT_TRACK_TYPE;
uint8_t record_size = sizeof(type) + BT_OTS_OBJ_ID_SIZE;
int next_size = record_size;
net_buf_simple_reset(obj.content);
if (track) {
while (track->prev) {
track = track->prev;
}
/* While there is a track, and the record fits in the object */
while (track && (next_size <= obj.content->size)) {
net_buf_simple_add_u8(obj.content, type);
net_buf_simple_add_le48(obj.content, track->id);
track = track->next;
next_size += record_size;
}
if (next_size > obj.content->size) {
LOG_WRN("Not room for full group in object");
}
LOG_HEXDUMP_DBG(obj.content->data, obj.content->len, "Group Object");
LOG_DBG("Group object length: %d", obj.content->len);
}
return obj.content->len;
}
/* Add the icon object to the OTS */
static int add_icon_object(struct mpl_mediaplayer *pl)
{
int ret;
struct bt_ots_obj_add_param add_param = {};
struct bt_ots_obj_created_desc created_desc = {};
const struct bt_uuid *icon_type = BT_UUID_OTS_TYPE_MPL_ICON;
static char *icon_name = "Icon";
if (obj.busy) {
/* TODO: Can there be a collision between select and internal */
/* activities, like adding new objects? */
LOG_ERR("Object busy");
return 0;
}
obj.busy = true;
obj.add_type = MPL_OBJ_ICON;
obj.desc = &created_desc;
obj.desc->size.alloc = obj.desc->size.cur = setup_icon_object();
obj.desc->name = icon_name;
BT_OTS_OBJ_SET_PROP_READ(obj.desc->props);
add_param.size = obj.desc->size.alloc;
add_param.type.uuid.type = BT_UUID_TYPE_16;
add_param.type.uuid_16.val = BT_UUID_16(icon_type)->val;
ret = bt_ots_obj_add(bt_mcs_get_ots(), &add_param);
if (ret < 0) {
LOG_WRN("Unable to add icon object, error %d", ret);
obj.busy = false;
return ret;
}
return 0;
}
/* Add a track segments object to the OTS */
static int add_current_track_segments_object(struct mpl_mediaplayer *pl)
{
int ret;
struct bt_ots_obj_add_param add_param = {};
struct bt_ots_obj_created_desc created_desc = {};
const struct bt_uuid *segs_type = BT_UUID_OTS_TYPE_TRACK_SEGMENT;
if (obj.busy) {
LOG_ERR("Object busy");
return 0;
}
obj.busy = true;
obj.add_type = MPL_OBJ_TRACK_SEGMENTS;
obj.desc = &created_desc;
obj.desc->size.alloc = obj.desc->size.cur = setup_segments_object(pl->group->track);
obj.desc->name = pl->group->track->title;
BT_OTS_OBJ_SET_PROP_READ(obj.desc->props);
add_param.size = obj.desc->size.alloc;
add_param.type.uuid.type = BT_UUID_TYPE_16;
add_param.type.uuid_16.val = BT_UUID_16(segs_type)->val;
ret = bt_ots_obj_add(bt_mcs_get_ots(), &add_param);
if (ret < 0) {
LOG_WRN("Unable to add track segments object: %d", ret);
obj.busy = false;
return ret;
}
return 0;
}
/* Add a single track to the OTS */
static int add_track_object(struct mpl_track *track)
{
struct bt_ots_obj_add_param add_param = {};
struct bt_ots_obj_created_desc created_desc = {};
const struct bt_uuid *track_type = BT_UUID_OTS_TYPE_TRACK;
int ret;
if (obj.busy) {
LOG_ERR("Object busy");
return 0;
}
if (!track) {
LOG_ERR("No track");
return -EINVAL;
}
obj.busy = true;
obj.add_type = MPL_OBJ_TRACK;
obj.add_track = track;
obj.desc = &created_desc;
obj.desc->size.alloc = obj.desc->size.cur = setup_track_object(track);
obj.desc->name = track->title;
BT_OTS_OBJ_SET_PROP_READ(obj.desc->props);
add_param.size = obj.desc->size.alloc;
add_param.type.uuid.type = BT_UUID_TYPE_16;
add_param.type.uuid_16.val = BT_UUID_16(track_type)->val;
ret = bt_ots_obj_add(bt_mcs_get_ots(), &add_param);
if (ret < 0) {
LOG_WRN("Unable to add track object: %d", ret);
obj.busy = false;
return ret;
}
return 0;
}
/* Add the parent group to the OTS */
static int add_parent_group_object(struct mpl_mediaplayer *pl)
{
int ret;
struct bt_ots_obj_add_param add_param = {};
struct bt_ots_obj_created_desc created_desc = {};
const struct bt_uuid *group_type = BT_UUID_OTS_TYPE_GROUP;
if (obj.busy) {
LOG_ERR("Object busy");
return 0;
}
obj.busy = true;
obj.add_type = MPL_OBJ_PARENT_GROUP;
obj.desc = &created_desc;
obj.desc->size.alloc = obj.desc->size.cur = setup_parent_group_object(pl->group);
obj.desc->name = pl->group->parent->title;
BT_OTS_OBJ_SET_PROP_READ(obj.desc->props);
add_param.size = obj.desc->size.alloc;
add_param.type.uuid.type = BT_UUID_TYPE_16;
add_param.type.uuid_16.val = BT_UUID_16(group_type)->val;
ret = bt_ots_obj_add(bt_mcs_get_ots(), &add_param);
if (ret < 0) {
LOG_WRN("Unable to add parent group object");
obj.busy = false;
return ret;
}
return 0;
}
/* Add a single group to the OTS */
static int add_group_object(struct mpl_group *group)
{
struct bt_ots_obj_add_param add_param = {};
struct bt_ots_obj_created_desc created_desc = {};
const struct bt_uuid *group_type = BT_UUID_OTS_TYPE_GROUP;
int ret;
if (obj.busy) {
LOG_ERR("Object busy");
return 0;
}
if (!group) {
LOG_ERR("No group");
return -EINVAL;
}
obj.busy = true;
obj.add_type = MPL_OBJ_GROUP;
obj.add_group = group;
obj.desc = &created_desc;
obj.desc->size.alloc = obj.desc->size.cur = setup_group_object(group);
obj.desc->name = group->title;
BT_OTS_OBJ_SET_PROP_READ(obj.desc->props);
add_param.size = obj.desc->size.alloc;
add_param.type.uuid.type = BT_UUID_TYPE_16;
add_param.type.uuid_16.val = BT_UUID_16(group_type)->val;
ret = bt_ots_obj_add(bt_mcs_get_ots(), &add_param);
if (ret < 0) {
LOG_WRN("Unable to add group object: %d", ret);
obj.busy = false;
return ret;
}
return 0;
}
/* Add all tracks of a group to the OTS */
static int add_group_tracks(struct mpl_group *group)
{
int ret_overall = 0;
struct mpl_track *track = group->track;
if (track) {
while (track->prev) {
track = track->prev;
}
while (track) {
int ret = add_track_object(track);
if (ret && !ret_overall) {
ret_overall = ret;
}
track = track->next;
}
}
return ret_overall;
}
/* Add all groups (except the parent group) and their tracks to the OTS */
static int add_group_and_track_objects(struct mpl_mediaplayer *pl)
{
int ret_overall = 0;
int ret;
struct mpl_group *group = pl->group;
if (group) {
while (group->prev) {
group = group->prev;
}
while (group) {
ret = add_group_tracks(group);
if (ret && !ret_overall) {
ret_overall = ret;
}
ret = add_group_object(group);
if (ret && !ret_overall) {
ret_overall = ret;
}
group = group->next;
}
}
ret = add_parent_group_object(pl);
if (ret && !ret_overall) {
ret_overall = ret;
}
return ret_overall;
}
/**** Callbacks from the object transfer service ******************************/
static int on_obj_deleted(struct bt_ots *ots, struct bt_conn *conn,
uint64_t id)
{
LOG_DBG_OBJ_ID("Object Id deleted: ", id);
return 0;
}
static void on_obj_selected(struct bt_ots *ots, struct bt_conn *conn,
uint64_t id)
{
if (obj.busy) {
/* TODO: Can there be a collision between select and internal */
/* activities, like adding new objects? */
LOG_ERR("Object busy - select not performed");
return;
}
obj.busy = true;
LOG_DBG_OBJ_ID("Object Id selected: ", id);
if (id == media_player.icon_id) {
LOG_DBG("Icon Object ID");
(void)setup_icon_object();
} else if (id == media_player.group->track->segments_id) {
LOG_DBG("Current Track Segments Object ID");
(void)setup_segments_object(media_player.group->track);
} else if (id == media_player.group->track->id) {
LOG_DBG("Current Track Object ID");
(void)setup_track_object(media_player.group->track);
} else if (media_player.next_track_set && id == media_player.next.track->id) {
/* Next track, if the next track has been explicitly set */
LOG_DBG("Next Track Object ID");
(void)setup_track_object(media_player.next.track);
} else if (id == media_player.group->track->next->id) {
/* Next track, if next track has not been explicitly set */
LOG_DBG("Next Track Object ID");
(void)setup_track_object(media_player.group->track->next);
} else if (id == media_player.group->parent->id) {
LOG_DBG("Parent Group Object ID");
(void)setup_parent_group_object(media_player.group);
} else if (id == media_player.group->id) {
LOG_DBG("Current Group Object ID");
(void)setup_group_object(media_player.group);
} else {
LOG_ERR("Unknown Object ID");
obj.busy = false;
return;
}
obj.selected_id = id;
obj.busy = false;
}
static int on_obj_created(struct bt_ots *ots, struct bt_conn *conn, uint64_t id,
const struct bt_ots_obj_add_param *add_param,
struct bt_ots_obj_created_desc *created_desc)
{
LOG_DBG_OBJ_ID("Object Id created: ", id);
*created_desc = *obj.desc;
if (!bt_uuid_cmp(&add_param->type.uuid, BT_UUID_OTS_TYPE_MPL_ICON)) {
LOG_DBG("Icon Obj Type");
if (obj.add_type == MPL_OBJ_ICON) {
obj.add_type = MPL_OBJ_NONE;
media_player.icon_id = id;
} else {
LOG_DBG("Unexpected object creation");
}
} else if (!bt_uuid_cmp(&add_param->type.uuid,
BT_UUID_OTS_TYPE_TRACK_SEGMENT)) {
LOG_DBG("Track Segments Obj Type");
if (obj.add_type == MPL_OBJ_TRACK_SEGMENTS) {
obj.add_type = MPL_OBJ_NONE;
media_player.group->track->segments_id = id;
} else {
LOG_DBG("Unexpected object creation");
}
} else if (!bt_uuid_cmp(&add_param->type.uuid,
BT_UUID_OTS_TYPE_TRACK)) {
LOG_DBG("Track Obj Type");
if (obj.add_type == MPL_OBJ_TRACK) {
obj.add_type = MPL_OBJ_NONE;
obj.add_track->id = id;
obj.add_track = NULL;
} else {
LOG_DBG("Unexpected object creation");
}
} else if (!bt_uuid_cmp(&add_param->type.uuid,
BT_UUID_OTS_TYPE_GROUP)) {
LOG_DBG("Group Obj Type");
if (obj.add_type == MPL_OBJ_PARENT_GROUP) {
LOG_DBG("Parent group");
obj.add_type = MPL_OBJ_NONE;
media_player.group->parent->id = id;
} else if (obj.add_type == MPL_OBJ_GROUP) {
LOG_DBG("Other group");
obj.add_type = MPL_OBJ_NONE;
obj.add_group->id = id;
obj.add_group = NULL;
} else {
LOG_DBG("Unexpected object creation");
}
} else {
LOG_DBG("Unknown Object ID");
}
if (obj.add_type == MPL_OBJ_NONE) {
obj.busy = false;
}
return 0;
}
static ssize_t on_object_send(struct bt_ots *ots, struct bt_conn *conn,
uint64_t id, void **data, size_t len,
off_t offset)
{
if (obj.busy) {
/* TODO: Can there be a collision between select and internal */
/* activities, like adding new objects? */
LOG_ERR("Object busy");
return 0;
}
obj.busy = true;
if (IS_ENABLED(CONFIG_BT_MPL_LOG_LEVEL_DBG)) {
char t[BT_OTS_OBJ_ID_STR_LEN];
(void)bt_ots_obj_id_to_str(id, t, sizeof(t));
LOG_DBG("Object Id %s, offset %lu, length %zu", t, (long)offset, len);
}
if (id != obj.selected_id) {
LOG_ERR("Read from unselected object");
obj.busy = false;
return 0;
}
if (!data) {
LOG_DBG("Read complete");
obj.busy = false;
return 0;
}
if (offset >= obj.content->len) {
LOG_DBG("Offset too large");
obj.busy = false;
return 0;
}
if (IS_ENABLED(CONFIG_BT_MPL_LOG_LEVEL_DBG)) {
if (len > obj.content->len - offset) {
LOG_DBG("Requested len too large");
}
}
*data = &obj.content->data[offset];
obj.busy = false;
return MIN(len, obj.content->len - offset);
}
static struct bt_ots_cb ots_cbs = {
.obj_created = on_obj_created,
.obj_read = on_object_send,
.obj_selected = on_obj_selected,
.obj_deleted = on_obj_deleted,
};
#endif /* CONFIG_BT_MPL_OBJECTS */
/* TODO: It must be possible to replace the do_prev_segment(), do_prev_track */
/* and do_prev_group() with a generic do_prev() command that can be used at */
/* all levels. Similarly for do_next, do_prev, and so on. */
static void do_prev_segment(struct mpl_mediaplayer *pl)
{
LOG_DBG("Segment name before: %s", pl->group->track->segment->name);
if (pl->group->track->segment->prev != NULL) {
pl->group->track->segment = pl->group->track->segment->prev;
}
LOG_DBG("Segment name after: %s", pl->group->track->segment->name);
}
static void do_next_segment(struct mpl_mediaplayer *pl)
{
LOG_DBG("Segment name before: %s", pl->group->track->segment->name);
if (pl->group->track->segment->next != NULL) {
pl->group->track->segment = pl->group->track->segment->next;
}
LOG_DBG("Segment name after: %s", pl->group->track->segment->name);
}
static void do_first_segment(struct mpl_mediaplayer *pl)
{
LOG_DBG("Segment name before: %s", pl->group->track->segment->name);
while (pl->group->track->segment->prev != NULL) {
pl->group->track->segment = pl->group->track->segment->prev;
}
LOG_DBG("Segment name after: %s", pl->group->track->segment->name);
}
static void do_last_segment(struct mpl_mediaplayer *pl)
{
LOG_DBG("Segment name before: %s", pl->group->track->segment->name);
while (pl->group->track->segment->next != NULL) {
pl->group->track->segment = pl->group->track->segment->next;
}
LOG_DBG("Segment name after: %s", pl->group->track->segment->name);
}
static void do_goto_segment(struct mpl_mediaplayer *pl, int32_t segnum)
{
int32_t k;
LOG_DBG("Segment name before: %s", pl->group->track->segment->name);
if (segnum > 0) {
/* Goto first segment */
while (pl->group->track->segment->prev != NULL) {
pl->group->track->segment =
pl->group->track->segment->prev;
}
/* Then go segnum - 1 tracks forward */
for (k = 0; k < (segnum - 1); k++) {
if (pl->group->track->segment->next != NULL) {
pl->group->track->segment =
pl->group->track->segment->next;
}
}
} else if (segnum < 0) {
/* Goto last track */
while (pl->group->track->segment->next != NULL) {
pl->group->track->segment =
pl->group->track->segment->next;
}
/* Then go |segnum - 1| tracks back */
for (k = 0; k < (-segnum - 1); k++) {
if (pl->group->track->segment->prev != NULL) {
pl->group->track->segment =
pl->group->track->segment->prev;
}
}
}
LOG_DBG("Segment name after: %s", pl->group->track->segment->name);
set_track_position(pl->group->track->segment->pos);
}
static void do_prev_track(struct mpl_mediaplayer *pl)
{
#ifdef CONFIG_BT_MPL_OBJECTS
LOG_DBG_OBJ_ID("Track ID before: ", pl->group->track->id);
#endif /* CONFIG_BT_MPL_OBJECTS */
if (pl->group->track->prev != NULL) {
pl->group->track = pl->group->track->prev;
pl->track_pos = 0;
do_track_change_notifications(pl);
} else {
/* For previous track, the position is reset to 0 */
/* even if we stay at the same track (goto start of */
/* track) */
set_track_position(0);
}
#ifdef CONFIG_BT_MPL_OBJECTS
LOG_DBG_OBJ_ID("Track ID after: ", pl->group->track->id);
#endif /* CONFIG_BT_MPL_OBJECTS */
}
/* Change to next track according to the current track's next track */
static void do_next_track_normal_order(struct mpl_mediaplayer *pl)
{
#ifdef CONFIG_BT_MPL_OBJECTS
LOG_DBG_OBJ_ID("Track ID before: ", pl->group->track->id);
#endif /* CONFIG_BT_MPL_OBJECTS */
if (pl->group->track->next != NULL) {
pl->group->track = pl->group->track->next;
pl->track_pos = 0;
do_track_change_notifications(pl);
}
#ifdef CONFIG_BT_MPL_OBJECTS
LOG_DBG_OBJ_ID("Track ID after: ", pl->group->track->id);
#endif /* CONFIG_BT_MPL_OBJECTS */
}
/* Change to next track when the next track has been explicitly set
*
* ALWAYS changes the track, changes the group if required
* Resets the next_track_set and the "next" pointers
*
* Returns true if the _group_ has been changed, otherwise false
*/
static void do_next_track_next_track_set(struct mpl_mediaplayer *pl)
{
if (pl->next.group != pl->group) {
pl->group = pl->next.group;
do_group_change_notifications(pl);
}
pl->group->track = pl->next.track;
pl->next.track = NULL;
pl->next.group = NULL;
pl->next_track_set = false;
pl->track_pos = 0;
do_track_change_notifications(pl);
}
static void do_next_track(struct mpl_mediaplayer *pl)
{
if (pl->next_track_set) {
LOG_DBG("Next track set");
do_next_track_next_track_set(pl);
} else {
do_next_track_normal_order(pl);
}
}
static void do_first_track(struct mpl_mediaplayer *pl, bool group_change)
{
bool track_changed = false;
#ifdef CONFIG_BT_MPL_OBJECTS
LOG_DBG_OBJ_ID("Track ID before: ", pl->group->track->id);
#endif /* CONFIG_BT_MPL_OBJECTS */
/* Set first track */
while (pl->group->track->prev != NULL) {
pl->group->track = pl->group->track->prev;
track_changed = true;
}
/* Notify about new track */
if (group_change || track_changed) {
media_player.track_pos = 0;
do_track_change_notifications(&media_player);
} else {
/* For first track, the position is reset to 0 even */
/* if we stay at the same track (goto start of track) */
set_track_position(0);
}
#ifdef CONFIG_BT_MPL_OBJECTS
LOG_DBG_OBJ_ID("Track ID after: ", pl->group->track->id);
#endif /* CONFIG_BT_MPL_OBJECTS */
}
static void do_last_track(struct mpl_mediaplayer *pl)
{
#ifdef CONFIG_BT_MPL_OBJECTS
LOG_DBG_OBJ_ID("Track ID before: ", pl->group->track->id);
#endif /* CONFIG_BT_MPL_OBJECTS */
if (pl->group->track->next != NULL) {
pl->group->track = pl->group->track->next;
media_player.track_pos = 0;
do_track_change_notifications(&media_player);
} else {
/* For last track, the position is reset to 0 even */
/* if we stay at the same track (goto start of track) */
set_track_position(0);
}
while (pl->group->track->next != NULL) {
pl->group->track = pl->group->track->next;
}
#ifdef CONFIG_BT_MPL_OBJECTS
LOG_DBG_OBJ_ID("Track ID after: ", pl->group->track->id);
#endif /* CONFIG_BT_MPL_OBJECTS */
}
static void do_goto_track(struct mpl_mediaplayer *pl, int32_t tracknum)
{
int32_t count = 0;
int32_t k;
#ifdef CONFIG_BT_MPL_OBJECTS
LOG_DBG_OBJ_ID("Track ID before: ", pl->group->track->id);
#endif /* CONFIG_BT_MPL_OBJECTS */
if (tracknum > 0) {
/* Goto first track */
while (pl->group->track->prev != NULL) {
pl->group->track = pl->group->track->prev;
count--;
}
/* Then go tracknum - 1 tracks forward */
for (k = 0; k < (tracknum - 1); k++) {
if (pl->group->track->next != NULL) {
pl->group->track = pl->group->track->next;
count++;
}
}
} else if (tracknum < 0) {
/* Goto last track */
while (pl->group->track->next != NULL) {
pl->group->track = pl->group->track->next;
count++;
}
/* Then go |tracknum - 1| tracks back */
for (k = 0; k < (-tracknum - 1); k++) {
if (pl->group->track->prev != NULL) {
pl->group->track = pl->group->track->prev;
count--;
}
}
}
#ifdef CONFIG_BT_MPL_OBJECTS
LOG_DBG_OBJ_ID("Track ID after: ", pl->group->track->id);
#endif /* CONFIG_BT_MPL_OBJECTS */
/* The track has changed if we have moved more in one direction */
/* than in the other */
if (count != 0) {
media_player.track_pos = 0;
do_track_change_notifications(&media_player);
} else {
/* For goto track, the position is reset to 0 */
/* even if we stay at the same track (goto */
/* start of track) */
set_track_position(0);
}
}
static void do_prev_group(struct mpl_mediaplayer *pl)
{
#ifdef CONFIG_BT_MPL_OBJECTS
LOG_DBG_OBJ_ID("Group ID before: ", pl->group->id);
#endif /* CONFIG_BT_MPL_OBJECTS */
if (pl->group->prev != NULL) {
pl->group = pl->group->prev;
do_group_change_notifications(pl);
}
#ifdef CONFIG_BT_MPL_OBJECTS
LOG_DBG_OBJ_ID("Group ID after: ", pl->group->id);
#endif /* CONFIG_BT_MPL_OBJECTS */
}
static void do_next_group(struct mpl_mediaplayer *pl)
{
#ifdef CONFIG_BT_MPL_OBJECTS
LOG_DBG_OBJ_ID("Group ID before: ", pl->group->id);
#endif /* CONFIG_BT_MPL_OBJECTS */
if (pl->group->next != NULL) {
pl->group = pl->group->next;
do_group_change_notifications(pl);
}
#ifdef CONFIG_BT_MPL_OBJECTS
LOG_DBG_OBJ_ID("Group ID after: ", pl->group->id);
#endif /* CONFIG_BT_MPL_OBJECTS */
}
static void do_first_group(struct mpl_mediaplayer *pl)
{
#ifdef CONFIG_BT_MPL_OBJECTS
LOG_DBG_OBJ_ID("Group ID before: ", pl->group->id);
#endif /* CONFIG_BT_MPL_OBJECTS */
if (pl->group->prev != NULL) {
pl->group = pl->group->prev;
do_group_change_notifications(pl);
}
while (pl->group->prev != NULL) {
pl->group = pl->group->prev;
}
#ifdef CONFIG_BT_MPL_OBJECTS
LOG_DBG_OBJ_ID("Group ID after: ", pl->group->id);
#endif /* CONFIG_BT_MPL_OBJECTS */
}
static void do_last_group(struct mpl_mediaplayer *pl)
{
#ifdef CONFIG_BT_MPL_OBJECTS
LOG_DBG_OBJ_ID("Group ID before: ", pl->group->id);
#endif /* CONFIG_BT_MPL_OBJECTS */
if (pl->group->next != NULL) {
pl->group = pl->group->next;
do_group_change_notifications(pl);
}
while (pl->group->next != NULL) {
pl->group = pl->group->next;
}
#ifdef CONFIG_BT_MPL_OBJECTS
LOG_DBG_OBJ_ID("Group ID after: ", pl->group->id);
#endif /* CONFIG_BT_MPL_OBJECTS */
}
static void do_goto_group(struct mpl_mediaplayer *pl, int32_t groupnum)
{
int32_t count = 0;
int32_t k;
#ifdef CONFIG_BT_MPL_OBJECTS
LOG_DBG_OBJ_ID("Group ID before: ", pl->group->id);
#endif /* CONFIG_BT_MPL_OBJECTS */
if (groupnum > 0) {
/* Goto first group */
while (pl->group->prev != NULL) {
pl->group = pl->group->prev;
count--;
}
/* Then go groupnum - 1 groups forward */
for (k = 0; k < (groupnum - 1); k++) {
if (pl->group->next != NULL) {
pl->group = pl->group->next;
count++;
}
}
} else if (groupnum < 0) {
/* Goto last group */
while (pl->group->next != NULL) {
pl->group = pl->group->next;
count++;
}
/* Then go |groupnum - 1| groups back */
for (k = 0; k < (-groupnum - 1); k++) {
if (pl->group->prev != NULL) {
pl->group = pl->group->prev;
count--;
}
}
}
#ifdef CONFIG_BT_MPL_OBJECTS
LOG_DBG_OBJ_ID("Group ID after: ", pl->group->id);
#endif /* CONFIG_BT_MPL_OBJECTS */
/* The group has changed if we have moved more in one direction */
/* than in the other */
if (count != 0) {
do_group_change_notifications(pl);
}
}
static void do_track_change_notifications(struct mpl_mediaplayer *pl)
{
media_proxy_pl_track_changed_cb();
media_proxy_pl_track_title_cb(pl->group->track->title);
media_proxy_pl_track_duration_cb(pl->group->track->duration);
media_proxy_pl_track_position_cb(pl->track_pos);
#ifdef CONFIG_BT_MPL_OBJECTS
media_proxy_pl_current_track_id_cb(pl->group->track->id);
if (pl->group->track->next) {
media_proxy_pl_next_track_id_cb(pl->group->track->next->id);
} else {
/* Send a zero value to indicate that there is no next track */
media_proxy_pl_next_track_id_cb(MPL_NO_TRACK_ID);
}
#endif /* CONFIG_BT_MPL_OBJECTS */
}
static void do_group_change_notifications(struct mpl_mediaplayer *pl)
{
#ifdef CONFIG_BT_MPL_OBJECTS
media_proxy_pl_current_group_id_cb(pl->group->id);
#endif /* CONFIG_BT_MPL_OBJECTS */
}
static void do_full_prev_group(struct mpl_mediaplayer *pl)
{
/* Change the group (if not already on first group) */
do_prev_group(pl);
/* Whether there is a group change or not, we always go to the first track */
do_first_track(pl, true);
}
static void do_full_next_group(struct mpl_mediaplayer *pl)
{
/* Change the group (if not already on last group) */
do_next_group(pl);
/* Whether there is a group change or not, we always go to the first track */
do_first_track(pl, true);
}
static void do_full_first_group(struct mpl_mediaplayer *pl)
{
/* Change the group (if not already on first group) */
do_first_group(pl);
/* Whether there is a group change or not, we always go to the first track */
do_first_track(pl, true);
}
static void do_full_last_group(struct mpl_mediaplayer *pl)
{
/* Change the group (if not already on last group) */
do_last_group(pl);
/* Whether there is a group change or not, we always go to the first track */
do_first_track(pl, true);
}
static void do_full_goto_group(struct mpl_mediaplayer *pl, int32_t groupnum)
{
/* Change the group (if not already on given group) */
do_goto_group(pl, groupnum);
/* Whether there is a group change or not, we always go to the first track */
do_first_track(pl, true);
}
static void mpl_set_state(uint8_t state)
{
switch (state) {
case MEDIA_PROXY_STATE_INACTIVE:
case MEDIA_PROXY_STATE_PLAYING:
case MEDIA_PROXY_STATE_PAUSED:
(void)k_work_cancel_delayable(&media_player.pos_work);
break;
case MEDIA_PROXY_STATE_SEEKING:
(void)k_work_schedule(&media_player.pos_work, TRACK_POS_WORK_DELAY);
break;
default:
__ASSERT(false, "Invalid state: %u", state);
}
media_player.state = state;
media_proxy_pl_media_state_cb(media_player.state);
}
/* Command handlers (state machines) */
static uint8_t inactive_state_command_handler(const struct mpl_cmd *command)
{
uint8_t result_code = MEDIA_PROXY_CMD_SUCCESS;
LOG_DBG("Command opcode: %d", command->opcode);
if (IS_ENABLED(CONFIG_BT_MPL_LOG_LEVEL_DBG)) {
if (command->use_param) {
LOG_DBG("Command parameter: %d", command->param);
}
}
switch (command->opcode) {
case MEDIA_PROXY_OP_PLAY: /* Fall-through - handle several cases identically */
case MEDIA_PROXY_OP_PAUSE:
case MEDIA_PROXY_OP_FAST_REWIND:
case MEDIA_PROXY_OP_FAST_FORWARD:
case MEDIA_PROXY_OP_STOP:
case MEDIA_PROXY_OP_MOVE_RELATIVE:
case MEDIA_PROXY_OP_PREV_SEGMENT:
case MEDIA_PROXY_OP_NEXT_SEGMENT:
case MEDIA_PROXY_OP_FIRST_SEGMENT:
case MEDIA_PROXY_OP_LAST_SEGMENT:
case MEDIA_PROXY_OP_GOTO_SEGMENT:
result_code = MEDIA_PROXY_CMD_PLAYER_INACTIVE;
break;
case MEDIA_PROXY_OP_PREV_TRACK:
do_prev_track(&media_player);
mpl_set_state(MEDIA_PROXY_STATE_PAUSED);
break;
case MEDIA_PROXY_OP_NEXT_TRACK:
/* TODO:
* The case where the next track has been set explicitly breaks somewhat
* with the "next" order hardcoded into the group and track structure
*/
do_next_track(&media_player);
/* For next track, the position is kept if the track */
/* does not change */
mpl_set_state(MEDIA_PROXY_STATE_PAUSED);
break;
case MEDIA_PROXY_OP_FIRST_TRACK:
do_first_track(&media_player, false);
mpl_set_state(MEDIA_PROXY_STATE_PAUSED);
break;
case MEDIA_PROXY_OP_LAST_TRACK:
do_last_track(&media_player);
mpl_set_state(MEDIA_PROXY_STATE_PAUSED);
break;
case MEDIA_PROXY_OP_GOTO_TRACK:
if (command->use_param) {
do_goto_track(&media_player, command->param);
mpl_set_state(MEDIA_PROXY_STATE_PAUSED);
} else {
result_code = MEDIA_PROXY_CMD_CANNOT_BE_COMPLETED;
}
break;
case MEDIA_PROXY_OP_PREV_GROUP:
do_full_prev_group(&media_player);
mpl_set_state(MEDIA_PROXY_STATE_PAUSED);
break;
case MEDIA_PROXY_OP_NEXT_GROUP:
do_full_next_group(&media_player);
mpl_set_state(MEDIA_PROXY_STATE_PAUSED);
break;
case MEDIA_PROXY_OP_FIRST_GROUP:
do_full_first_group(&media_player);
mpl_set_state(MEDIA_PROXY_STATE_PAUSED);
break;
case MEDIA_PROXY_OP_LAST_GROUP:
do_full_last_group(&media_player);
mpl_set_state(MEDIA_PROXY_STATE_PAUSED);
break;
case MEDIA_PROXY_OP_GOTO_GROUP:
if (command->use_param) {
do_full_goto_group(&media_player, command->param);
mpl_set_state(MEDIA_PROXY_STATE_PAUSED);
} else {
result_code = MEDIA_PROXY_CMD_CANNOT_BE_COMPLETED;
}
break;
default:
LOG_DBG("Invalid command: %d", command->opcode);
result_code = MEDIA_PROXY_CMD_NOT_SUPPORTED;
break;
}
return result_code;
}
static uint8_t playing_state_command_handler(const struct mpl_cmd *command)
{
uint8_t result_code = MEDIA_PROXY_CMD_SUCCESS;
LOG_DBG("Command opcode: %d", command->opcode);
if (IS_ENABLED(CONFIG_BT_MPL_LOG_LEVEL_DBG)) {
if (command->use_param) {
LOG_DBG("Command parameter: %d", command->param);
}
}
switch (command->opcode) {
case MEDIA_PROXY_OP_PLAY:
/* Continue playing - i.e. do nothing */
break;
case MEDIA_PROXY_OP_PAUSE:
mpl_set_state(MEDIA_PROXY_STATE_PAUSED);
break;
case MEDIA_PROXY_OP_FAST_REWIND:
/* We're in playing state, seeking speed must have been zero */
media_player.seeking_speed_factor = -MPL_SEEKING_SPEED_FACTOR_STEP;
mpl_set_state(MEDIA_PROXY_STATE_SEEKING);
media_proxy_pl_seeking_speed_cb(media_player.seeking_speed_factor);
break;
case MEDIA_PROXY_OP_FAST_FORWARD:
/* We're in playing state, seeking speed must have been zero */
media_player.seeking_speed_factor = MPL_SEEKING_SPEED_FACTOR_STEP;
mpl_set_state(MEDIA_PROXY_STATE_SEEKING);
media_proxy_pl_seeking_speed_cb(media_player.seeking_speed_factor);
break;
case MEDIA_PROXY_OP_STOP:
set_track_position(0);
mpl_set_state(MEDIA_PROXY_STATE_PAUSED);
break;
case MEDIA_PROXY_OP_MOVE_RELATIVE:
if (command->use_param) {
set_relative_track_position(command->param);
} else {
result_code = MEDIA_PROXY_CMD_CANNOT_BE_COMPLETED;
}
break;
case MEDIA_PROXY_OP_PREV_SEGMENT:
/* Switch to previous segment if we are less than <margin> */
/* into the segment, otherwise go to start of segment */
if (media_player.track_pos - PREV_MARGIN <
media_player.group->track->segment->pos) {
do_prev_segment(&media_player);
}
set_track_position(media_player.group->track->segment->pos);
break;
case MEDIA_PROXY_OP_NEXT_SEGMENT:
do_next_segment(&media_player);
set_track_position(media_player.group->track->segment->pos);
break;
case MEDIA_PROXY_OP_FIRST_SEGMENT:
do_first_segment(&media_player);
set_track_position(media_player.group->track->segment->pos);
break;
case MEDIA_PROXY_OP_LAST_SEGMENT:
do_last_segment(&media_player);
set_track_position(media_player.group->track->segment->pos);
break;
case MEDIA_PROXY_OP_GOTO_SEGMENT:
if (command->use_param) {
if (command->param != 0) {
do_goto_segment(&media_player, command->param);
}
/* If the argument to "goto segment" is zero, */
/* the segment shall stay the same, and the */
/* track position shall not change. */
} else {
result_code = MEDIA_PROXY_CMD_CANNOT_BE_COMPLETED;
}
break;
case MEDIA_PROXY_OP_PREV_TRACK:
do_prev_track(&media_player);
break;
case MEDIA_PROXY_OP_NEXT_TRACK:
do_next_track(&media_player);
break;
case MEDIA_PROXY_OP_FIRST_TRACK:
do_first_track(&media_player, false);
break;
case MEDIA_PROXY_OP_LAST_TRACK:
do_last_track(&media_player);
break;
case MEDIA_PROXY_OP_GOTO_TRACK:
if (command->use_param) {
do_goto_track(&media_player, command->param);
} else {
result_code = MEDIA_PROXY_CMD_CANNOT_BE_COMPLETED;
}
break;
case MEDIA_PROXY_OP_PREV_GROUP:
do_full_prev_group(&media_player);
break;
case MEDIA_PROXY_OP_NEXT_GROUP:
do_full_next_group(&media_player);
break;
case MEDIA_PROXY_OP_FIRST_GROUP:
do_full_first_group(&media_player);
break;
case MEDIA_PROXY_OP_LAST_GROUP:
do_full_last_group(&media_player);
break;
case MEDIA_PROXY_OP_GOTO_GROUP:
if (command->use_param) {
do_full_goto_group(&media_player, command->param);
} else {
result_code = MEDIA_PROXY_CMD_CANNOT_BE_COMPLETED;
}
break;
default:
LOG_DBG("Invalid command: %d", command->opcode);
result_code = MEDIA_PROXY_CMD_NOT_SUPPORTED;
break;
}
return result_code;
}
static uint8_t paused_state_command_handler(const struct mpl_cmd *command)
{
uint8_t result_code = MEDIA_PROXY_CMD_SUCCESS;
LOG_DBG("Command opcode: %d", command->opcode);
if (IS_ENABLED(CONFIG_BT_MPL_LOG_LEVEL_DBG)) {
if (command->use_param) {
LOG_DBG("Command parameter: %d", command->param);
}
}
switch (command->opcode) {
case MEDIA_PROXY_OP_PLAY:
mpl_set_state(MEDIA_PROXY_STATE_PLAYING);
break;
case MEDIA_PROXY_OP_PAUSE:
/* No change */
break;
case MEDIA_PROXY_OP_FAST_REWIND:
/* We're in paused state, seeking speed must have been zero */
media_player.seeking_speed_factor = -MPL_SEEKING_SPEED_FACTOR_STEP;
mpl_set_state(MEDIA_PROXY_STATE_SEEKING);
media_proxy_pl_seeking_speed_cb(media_player.seeking_speed_factor);
break;
case MEDIA_PROXY_OP_FAST_FORWARD:
/* We're in paused state, seeking speed must have been zero */
media_player.seeking_speed_factor = MPL_SEEKING_SPEED_FACTOR_STEP;
mpl_set_state(MEDIA_PROXY_STATE_SEEKING);
media_proxy_pl_seeking_speed_cb(media_player.seeking_speed_factor);
break;
case MEDIA_PROXY_OP_STOP:
set_track_position(0);
mpl_set_state(MEDIA_PROXY_STATE_PAUSED);
break;
case MEDIA_PROXY_OP_MOVE_RELATIVE:
if (command->use_param) {
set_relative_track_position(command->param);
} else {
result_code = MEDIA_PROXY_CMD_CANNOT_BE_COMPLETED;
}
break;
case MEDIA_PROXY_OP_PREV_SEGMENT:
/* Switch to previous segment if we are less than 5 seconds */
/* into the segment, otherwise go to start of segment */
if (media_player.group->track->segment != NULL) {
if (media_player.track_pos - PREV_MARGIN <
media_player.group->track->segment->pos) {
do_prev_segment(&media_player);
}
set_track_position(media_player.group->track->segment->pos);
} else {
result_code = MEDIA_PROXY_CMD_CANNOT_BE_COMPLETED;
}
break;
case MEDIA_PROXY_OP_NEXT_SEGMENT:
if (media_player.group->track->segment != NULL) {
do_next_segment(&media_player);
set_track_position(media_player.group->track->segment->pos);
} else {
result_code = MEDIA_PROXY_CMD_CANNOT_BE_COMPLETED;
}
break;
case MEDIA_PROXY_OP_FIRST_SEGMENT:
if (media_player.group->track->segment != NULL) {
do_first_segment(&media_player);
set_track_position(media_player.group->track->segment->pos);
} else {
result_code = MEDIA_PROXY_CMD_CANNOT_BE_COMPLETED;
}
break;
case MEDIA_PROXY_OP_LAST_SEGMENT:
if (media_player.group->track->segment != NULL) {
do_last_segment(&media_player);
set_track_position(media_player.group->track->segment->pos);
} else {
result_code = MEDIA_PROXY_CMD_CANNOT_BE_COMPLETED;
}
break;
case MEDIA_PROXY_OP_GOTO_SEGMENT:
if (command->use_param && media_player.group->track->segment != NULL) {
if (command->param != 0) {
do_goto_segment(&media_player, command->param);
}
/* If the argument to "goto segment" is zero, */
/* the segment shall stay the same, and the */
/* track position shall not change. */
} else {
result_code = MEDIA_PROXY_CMD_CANNOT_BE_COMPLETED;
}
break;
case MEDIA_PROXY_OP_PREV_TRACK:
do_prev_track(&media_player);
break;
case MEDIA_PROXY_OP_NEXT_TRACK:
do_next_track(&media_player);
/* For next track, the position is kept if the track */
/* does not change */
break;
case MEDIA_PROXY_OP_FIRST_TRACK:
do_first_track(&media_player, false);
break;
case MEDIA_PROXY_OP_LAST_TRACK:
do_last_track(&media_player);
break;
case MEDIA_PROXY_OP_GOTO_TRACK:
if (command->use_param) {
do_goto_track(&media_player, command->param);
} else {
result_code = MEDIA_PROXY_CMD_CANNOT_BE_COMPLETED;
}
break;
case MEDIA_PROXY_OP_PREV_GROUP:
do_full_prev_group(&media_player);
break;
case MEDIA_PROXY_OP_NEXT_GROUP:
do_full_next_group(&media_player);
break;
case MEDIA_PROXY_OP_FIRST_GROUP:
do_full_first_group(&media_player);
break;
case MEDIA_PROXY_OP_LAST_GROUP:
do_full_last_group(&media_player);
break;
case MEDIA_PROXY_OP_GOTO_GROUP:
if (command->use_param) {
do_full_goto_group(&media_player, command->param);
} else {
result_code = MEDIA_PROXY_CMD_CANNOT_BE_COMPLETED;
}
break;
default:
LOG_DBG("Invalid command: %d", command->opcode);
result_code = MEDIA_PROXY_CMD_NOT_SUPPORTED;
break;
}
return result_code;
}
static uint8_t seeking_state_command_handler(const struct mpl_cmd *command)
{
uint8_t result_code = MEDIA_PROXY_CMD_SUCCESS;
LOG_DBG("Command opcode: %d", command->opcode);
if (IS_ENABLED(CONFIG_BT_MPL_LOG_LEVEL_DBG)) {
if (command->use_param) {
LOG_DBG("Command parameter: %d", command->param);
}
}
switch (command->opcode) {
case MEDIA_PROXY_OP_PLAY:
media_player.seeking_speed_factor = MEDIA_PROXY_SEEKING_SPEED_FACTOR_ZERO;
mpl_set_state(MEDIA_PROXY_STATE_PLAYING);
media_proxy_pl_seeking_speed_cb(media_player.seeking_speed_factor);
break;
case MEDIA_PROXY_OP_PAUSE:
media_player.seeking_speed_factor = MEDIA_PROXY_SEEKING_SPEED_FACTOR_ZERO;
/* TODO: Set track and track position */
mpl_set_state(MEDIA_PROXY_STATE_PAUSED);
media_proxy_pl_seeking_speed_cb(media_player.seeking_speed_factor);
break;
case MEDIA_PROXY_OP_FAST_REWIND:
/* TODO: Here, and for FAST_FORWARD */
/* Decide on algorithm for multiple presses - add step (as */
/* now) or double/half? */
/* What about FR followed by FF? */
/* Currently, the seeking speed may also become zero */
/* Lowest value allowed by spec is -64, notify on change only */
if (media_player.seeking_speed_factor >= -(MEDIA_PROXY_SEEKING_SPEED_FACTOR_MAX
- MPL_SEEKING_SPEED_FACTOR_STEP)) {
media_player.seeking_speed_factor -= MPL_SEEKING_SPEED_FACTOR_STEP;
media_proxy_pl_seeking_speed_cb(media_player.seeking_speed_factor);
}
break;
case MEDIA_PROXY_OP_FAST_FORWARD:
/* Highest value allowed by spec is 64, notify on change only */
if (media_player.seeking_speed_factor <= (MEDIA_PROXY_SEEKING_SPEED_FACTOR_MAX
- MPL_SEEKING_SPEED_FACTOR_STEP)) {
media_player.seeking_speed_factor += MPL_SEEKING_SPEED_FACTOR_STEP;
media_proxy_pl_seeking_speed_cb(media_player.seeking_speed_factor);
}
break;
case MEDIA_PROXY_OP_STOP:
media_player.seeking_speed_factor = MEDIA_PROXY_SEEKING_SPEED_FACTOR_ZERO;
set_track_position(0);
mpl_set_state(MEDIA_PROXY_STATE_PAUSED);
media_proxy_pl_seeking_speed_cb(media_player.seeking_speed_factor);
break;
case MEDIA_PROXY_OP_MOVE_RELATIVE:
if (command->use_param) {
set_relative_track_position(command->param);
} else {
result_code = MEDIA_PROXY_CMD_CANNOT_BE_COMPLETED;
}
break;
case MEDIA_PROXY_OP_PREV_SEGMENT:
/* Switch to previous segment if we are less than 5 seconds */
/* into the segment, otherwise go to start of segment */
if (media_player.track_pos - PREV_MARGIN <
media_player.group->track->segment->pos) {
do_prev_segment(&media_player);
}
set_track_position(media_player.group->track->segment->pos);
break;
case MEDIA_PROXY_OP_NEXT_SEGMENT:
do_next_segment(&media_player);
set_track_position(media_player.group->track->segment->pos);
break;
case MEDIA_PROXY_OP_FIRST_SEGMENT:
do_first_segment(&media_player);
set_track_position(media_player.group->track->segment->pos);
break;
case MEDIA_PROXY_OP_LAST_SEGMENT:
do_last_segment(&media_player);
set_track_position(media_player.group->track->segment->pos);
break;
case MEDIA_PROXY_OP_GOTO_SEGMENT:
if (command->use_param) {
if (command->param != 0) {
do_goto_segment(&media_player, command->param);
}
/* If the argument to "goto segment" is zero, */
/* the segment shall stay the same, and the */
/* track position shall not change. */
} else {
result_code = MEDIA_PROXY_CMD_CANNOT_BE_COMPLETED;
}
break;
case MEDIA_PROXY_OP_PREV_TRACK:
do_prev_track(&media_player);
media_player.seeking_speed_factor = MEDIA_PROXY_SEEKING_SPEED_FACTOR_ZERO;
mpl_set_state(MEDIA_PROXY_STATE_PAUSED);
break;
case MEDIA_PROXY_OP_NEXT_TRACK:
do_next_track(&media_player);
/* For next track, the position is kept if the track */
/* does not change */
media_player.seeking_speed_factor = MEDIA_PROXY_SEEKING_SPEED_FACTOR_ZERO;
mpl_set_state(MEDIA_PROXY_STATE_PAUSED);
break;
case MEDIA_PROXY_OP_FIRST_TRACK:
do_first_track(&media_player, false);
media_player.seeking_speed_factor = MEDIA_PROXY_SEEKING_SPEED_FACTOR_ZERO;
mpl_set_state(MEDIA_PROXY_STATE_PAUSED);
break;
case MEDIA_PROXY_OP_LAST_TRACK:
do_last_track(&media_player);
media_player.seeking_speed_factor = MEDIA_PROXY_SEEKING_SPEED_FACTOR_ZERO;
mpl_set_state(MEDIA_PROXY_STATE_PAUSED);
break;
case MEDIA_PROXY_OP_GOTO_TRACK:
if (command->use_param) {
do_goto_track(&media_player, command->param);
media_player.seeking_speed_factor = MEDIA_PROXY_SEEKING_SPEED_FACTOR_ZERO;
mpl_set_state(MEDIA_PROXY_STATE_PAUSED);
} else {
result_code = MEDIA_PROXY_CMD_CANNOT_BE_COMPLETED;
}
break;
case MEDIA_PROXY_OP_PREV_GROUP:
do_full_prev_group(&media_player);
mpl_set_state(MEDIA_PROXY_STATE_PAUSED);
break;
case MEDIA_PROXY_OP_NEXT_GROUP:
do_full_next_group(&media_player);
mpl_set_state(MEDIA_PROXY_STATE_PAUSED);
break;
case MEDIA_PROXY_OP_FIRST_GROUP:
do_full_first_group(&media_player);
mpl_set_state(MEDIA_PROXY_STATE_PAUSED);
break;
case MEDIA_PROXY_OP_LAST_GROUP:
do_full_last_group(&media_player);
mpl_set_state(MEDIA_PROXY_STATE_PAUSED);
break;
case MEDIA_PROXY_OP_GOTO_GROUP:
if (command->use_param) {
do_full_goto_group(&media_player, command->param);
mpl_set_state(MEDIA_PROXY_STATE_PAUSED);
} else {
result_code = MEDIA_PROXY_CMD_CANNOT_BE_COMPLETED;
}
break;
default:
LOG_DBG("Invalid command: %d", command->opcode);
result_code = MEDIA_PROXY_CMD_NOT_SUPPORTED;
break;
}
return result_code;
}
static uint8_t (*command_handlers[MEDIA_PROXY_STATE_LAST])(const struct mpl_cmd *command) = {
inactive_state_command_handler,
playing_state_command_handler,
paused_state_command_handler,
seeking_state_command_handler,
};
#ifdef CONFIG_BT_MPL_OBJECTS
/* Find a track by ID
*
* If found, return pointers to the group of the track and the track,
* otherwise, the pointers returned are NULL
*
* Returns true if found, false otherwise
*/
static bool find_track_by_id(const struct mpl_mediaplayer *pl, uint64_t id,
struct mpl_group **group, struct mpl_track **track)
{
struct mpl_group *tmp_group = pl->group;
struct mpl_track *tmp_track;
while (tmp_group->prev != NULL) {
tmp_group = tmp_group->prev;
}
while (tmp_group != NULL) {
tmp_track = tmp_group->track;
while (tmp_track->prev != NULL) {
tmp_track = tmp_track->prev;
}
while (tmp_track != 0) {
if (tmp_track->id == id) {
/* Found the track */
*group = tmp_group;
*track = tmp_track;
return true;
}
tmp_track = tmp_track->next;
}
tmp_group = tmp_group->next;
}
/* Track not found */
*group = NULL;
*track = NULL;
return false;
}
/* Find a group by ID
*
* If found, return pointer to the group, otherwise, the pointer returned is NULL
*
* Returns true if found, false otherwise
*/
static bool find_group_by_id(const struct mpl_mediaplayer *pl, uint64_t id,
struct mpl_group **group)
{
struct mpl_group *tmp_group = pl->group;
while (tmp_group->prev != NULL) {
tmp_group = tmp_group->prev;
}
while (tmp_group != NULL) {
if (tmp_group->id == id) {
/* Found the group */
*group = tmp_group;
return true;
}
tmp_group = tmp_group->next;
}
/* Group not found */
*group = NULL;
return false;
}
#endif /* CONFIG_BT_MPL_OBJECTS */
static const char *get_player_name(void)
{
return media_player.name;
}
#ifdef CONFIG_BT_MPL_OBJECTS
static uint64_t get_icon_id(void)
{
return media_player.icon_id;
}
#endif /* CONFIG_BT_MPL_OBJECTS */
static const char *get_icon_url(void)
{
return media_player.icon_url;
}
static const char *get_track_title(void)
{
return media_player.group->track->title;
}
static int32_t get_track_duration(void)
{
return media_player.group->track->duration;
}
static int32_t get_track_position(void)
{
return media_player.track_pos;
}
static void set_track_position(int32_t position)
{
int32_t old_pos = media_player.track_pos;
int32_t new_pos;
if (position >= 0) {
if (position > media_player.group->track->duration) {
/* Do not go beyond end of track */
new_pos = media_player.group->track->duration;
} else {
new_pos = position;
}
} else {
/* Negative position, handle as offset from _end_ of track */
/* (Note minus sign below) */
if (position < -media_player.group->track->duration) {
new_pos = 0;
} else {
/* (Remember position is negative) */
new_pos = media_player.group->track->duration + position;
}
}
LOG_DBG("Pos. given: %d, resulting pos.: %d (duration is %d)", position, new_pos,
media_player.group->track->duration);
/* Notify when the position changes when not in the playing state, or if the position is set
* to 0 which is a special value that typically indicates that the track has stopped or
* changed. Since this might occur when media_player.group->track->duration is still 0, we
* should always notify this value.
*/
if (new_pos != old_pos || new_pos == 0) {
/* Set new position and notify it */
media_player.track_pos = new_pos;
/* MCS 1.0, section 3.7.1, states:
* to avoid an excessive number of notifications, the Track Position should
* not be notified when the Media State is set to “Playing” and playback happens
* at a constant speed.
*/
if (media_player.state != MEDIA_PROXY_STATE_PLAYING) {
media_proxy_pl_track_position_cb(new_pos);
}
}
}
static void set_relative_track_position(int32_t rel_pos)
{
int64_t pos;
pos = media_player.track_pos + rel_pos;
/* Clamp to allowed values */
pos = CLAMP(pos, 0, media_player.group->track->duration);
set_track_position((int32_t)pos);
}
static int8_t get_playback_speed(void)
{
return media_player.playback_speed_param;
}
static void set_playback_speed(int8_t speed)
{
/* Set new speed parameter and notify, if different from current */
if (speed != media_player.playback_speed_param) {
media_player.playback_speed_param = speed;
media_proxy_pl_playback_speed_cb(media_player.playback_speed_param);
}
}
static int8_t get_seeking_speed(void)
{
return media_player.seeking_speed_factor;
}
#ifdef CONFIG_BT_MPL_OBJECTS
static uint64_t get_track_segments_id(void)
{
return media_player.group->track->segments_id;
}
static uint64_t get_current_track_id(void)
{
return media_player.group->track->id;
}
static void set_current_track_id(uint64_t id)
{
struct mpl_group *group;
struct mpl_track *track;
LOG_DBG_OBJ_ID("Track ID to set: ", id);
if (find_track_by_id(&media_player, id, &group, &track)) {
if (media_player.group != group) {
media_player.group = group;
do_group_change_notifications(&media_player);
/* Group change implies track change (even if same track in other group) */
media_player.group->track = track;
do_track_change_notifications(&media_player);
} else if (media_player.group->track != track) {
media_player.group->track = track;
do_track_change_notifications(&media_player);
}
return;
}
LOG_DBG("Track not found");
/* TODO: Should an error be returned here?
* That would require a rewrite of the MPL api to add return values to the functions.
*/
}
static uint64_t get_next_track_id(void)
{
/* If the next track has been set explicitly */
if (media_player.next_track_set) {
return media_player.next.track->id;
}
/* Normal playing order */
if (media_player.group->track->next) {
return media_player.group->track->next->id;
}
/* Return zero value to indicate that there is no next track */
return MPL_NO_TRACK_ID;
}
static void set_next_track_id(uint64_t id)
{
struct mpl_group *group;
struct mpl_track *track;
LOG_DBG_OBJ_ID("Next Track ID to set: ", id);
if (find_track_by_id(&media_player, id, &group, &track)) {
media_player.next_track_set = true;
media_player.next.group = group;
media_player.next.track = track;
media_proxy_pl_next_track_id_cb(id);
return;
}
LOG_DBG("Track not found");
}
static uint64_t get_parent_group_id(void)
{
return media_player.group->parent->id;
}
static uint64_t get_current_group_id(void)
{
return media_player.group->id;
}
static void set_current_group_id(uint64_t id)
{
struct mpl_group *group;
LOG_DBG_OBJ_ID("Group ID to set: ", id);
if (find_group_by_id(&media_player, id, &group)) {
if (media_player.group != group) {
/* Change to found group */
media_player.group = group;
do_group_change_notifications(&media_player);
/* And change to first track in group */
do_first_track(&media_player, false);
}
return;
}
LOG_DBG("Group not found");
}
#endif /* CONFIG_BT_MPL_OBJECTS */
static uint8_t get_playing_order(void)
{
return media_player.playing_order;
}
static void set_playing_order(uint8_t order)
{
if (order != media_player.playing_order) {
if (BIT(order - 1) & media_player.playing_orders_supported) {
media_player.playing_order = order;
media_proxy_pl_playing_order_cb(media_player.playing_order);
}
}
}
static uint16_t get_playing_orders_supported(void)
{
return media_player.playing_orders_supported;
}
static uint8_t get_media_state(void)
{
return media_player.state;
}
static void send_command(const struct mpl_cmd *command)
{
struct mpl_cmd_ntf ntf;
if (command->use_param) {
LOG_DBG("opcode: %d, param: %d", command->opcode, command->param);
} else {
LOG_DBG("opcode: %d", command->opcode);
}
if (media_player.state < MEDIA_PROXY_STATE_LAST) {
ntf.requested_opcode = command->opcode;
ntf.result_code = command_handlers[media_player.state](command);
media_proxy_pl_command_cb(&ntf);
} else {
LOG_DBG("INVALID STATE");
}
}
static uint32_t get_commands_supported(void)
{
return media_player.opcodes_supported;
}
#ifdef CONFIG_BT_MPL_OBJECTS
static bool parse_sci(struct bt_data *data, void *user_data)
{
LOG_DBG("type: %u len %u", data->type, data->data_len);
LOG_HEXDUMP_DBG(data->data, data->data_len, "param:");
if (data->type < MEDIA_PROXY_SEARCH_TYPE_TRACK_NAME ||
data->type > MEDIA_PROXY_SEARCH_TYPE_ONLY_GROUPS) {
LOG_DBG("Invalid search type: %u", data->type);
return false;
}
return true;
}
static void parse_search(const struct mpl_search *search)
{
bool search_failed = false;
if (search->len > SEARCH_LEN_MAX) {
LOG_WRN("Search too long (%d) - aborting", search->len);
search_failed = true;
} else {
uint8_t search_ltv[SEARCH_LEN_MAX];
struct net_buf_simple buf;
/* Copy so that we can parse it using the net_buf_simple when search is const */
memcpy(search_ltv, search->search, search->len);
net_buf_simple_init_with_data(&buf, search_ltv, search->len);
bt_data_parse(&buf, parse_sci, NULL);
if (buf.len != 0U) {
search_failed = true;
}
}
/* TODO: Add real search functionality. */
/* For now, just fake it. */
if (search_failed) {
media_player.search_results_id = 0;
media_proxy_pl_search_cb(MEDIA_PROXY_SEARCH_FAILURE);
} else {
/* Use current group as search result for now */
media_player.search_results_id = media_player.group->id;
media_proxy_pl_search_cb(MEDIA_PROXY_SEARCH_SUCCESS);
}
media_proxy_pl_search_results_id_cb(media_player.search_results_id);
}
static void send_search(const struct mpl_search *search)
{
if (search->len > SEARCH_LEN_MAX) {
LOG_WRN("Search too long: %d", search->len);
}
LOG_HEXDUMP_DBG(search->search, search->len, "Search");
parse_search(search);
}
static uint64_t get_search_results_id(void)
{
return media_player.search_results_id;
}
#endif /* CONFIG_BT_MPL_OBJECTS */
static uint8_t get_content_ctrl_id(void)
{
return media_player.content_ctrl_id;
}
static void pos_work_cb(struct k_work *work)
{
const int32_t pos_diff_cs = TRACK_POS_WORK_DELAY_MS / 10; /* position is in centiseconds*/
if (media_player.state == MEDIA_PROXY_STATE_SEEKING) {
/* When seeking, apply the seeking speed factor */
set_relative_track_position(pos_diff_cs * media_player.seeking_speed_factor);
} else if (media_player.state == MEDIA_PROXY_STATE_PLAYING) {
set_relative_track_position(pos_diff_cs);
}
if (media_player.track_pos == media_player.group->track->duration) {
/* Go to next track */
do_next_track(&media_player);
}
(void)k_work_schedule(&media_player.pos_work, TRACK_POS_WORK_DELAY);
}
int media_proxy_pl_init(void)
{
static bool initialized;
int ret;
if (initialized) {
LOG_DBG("Already initialized");
return -EALREADY;
}
/* Set up the media control service */
/* TODO: Fix initialization - who initializes what
* https://github.com/zephyrproject-rtos/zephyr/issues/42965
* Temporarily only initializing if service is present
*/
#ifdef CONFIG_BT_MCS
#ifdef CONFIG_BT_MPL_OBJECTS
ret = bt_mcs_init(&ots_cbs);
#else
ret = bt_mcs_init(NULL);
#endif /* CONFIG_BT_MPL_OBJECTS */
if (ret < 0) {
LOG_ERR("Could not init MCS: %d", ret);
return ret;
}
#else
LOG_WRN("MCS not configured");
#endif /* CONFIG_BT_MCS */
/* Get a Content Control ID */
media_player.content_ctrl_id = bt_ccid_get_value();
#ifdef CONFIG_BT_MPL_OBJECTS
/* Initialize the object content buffer */
net_buf_simple_init(obj.content, 0);
/* Icon Object */
ret = add_icon_object(&media_player);
if (ret < 0) {
LOG_ERR("Unable to add icon object, error %d", ret);
return ret;
}
/* Add all tracks and groups to OTS */
ret = add_group_and_track_objects(&media_player);
if (ret < 0) {
LOG_ERR("Error adding tracks and groups to OTS, error %d", ret);
return ret;
}
/* Initial setup of Track Segments Object */
/* TODO: Later, this should be done when the tracks are added */
/* but for no only one of the tracks has segments .*/
ret = add_current_track_segments_object(&media_player);
if (ret < 0) {
LOG_ERR("Error adding Track Segments Object to OTS, error %d", ret);
return ret;
}
#endif /* CONFIG_BT_MPL_OBJECTS */
/* Set up the calls structure */
media_player.calls.get_player_name = get_player_name;
#ifdef CONFIG_BT_MPL_OBJECTS
media_player.calls.get_icon_id = get_icon_id;
#endif /* CONFIG_BT_MPL_OBJECTS */
media_player.calls.get_icon_url = get_icon_url;
media_player.calls.get_track_title = get_track_title;
media_player.calls.get_track_duration = get_track_duration;
media_player.calls.get_track_position = get_track_position;
media_player.calls.set_track_position = set_track_position;
media_player.calls.get_playback_speed = get_playback_speed;
media_player.calls.set_playback_speed = set_playback_speed;
media_player.calls.get_seeking_speed = get_seeking_speed;
#ifdef CONFIG_BT_MPL_OBJECTS
media_player.calls.get_track_segments_id = get_track_segments_id;
media_player.calls.get_current_track_id = get_current_track_id;
media_player.calls.set_current_track_id = set_current_track_id;
media_player.calls.get_next_track_id = get_next_track_id;
media_player.calls.set_next_track_id = set_next_track_id;
media_player.calls.get_parent_group_id = get_parent_group_id;
media_player.calls.get_current_group_id = get_current_group_id;
media_player.calls.set_current_group_id = set_current_group_id;
#endif /* CONFIG_BT_MPL_OBJECTS */
media_player.calls.get_playing_order = get_playing_order;
media_player.calls.set_playing_order = set_playing_order;
media_player.calls.get_playing_orders_supported = get_playing_orders_supported;
media_player.calls.get_media_state = get_media_state;
media_player.calls.send_command = send_command;
media_player.calls.get_commands_supported = get_commands_supported;
#ifdef CONFIG_BT_MPL_OBJECTS
media_player.calls.send_search = send_search;
media_player.calls.get_search_results_id = get_search_results_id;
#endif /* CONFIG_BT_MPL_OBJECTS */
media_player.calls.get_content_ctrl_id = get_content_ctrl_id;
ret = media_proxy_pl_register(&media_player.calls);
if (ret < 0) {
LOG_ERR("Unable to register player");
return ret;
}
k_work_init_delayable(&media_player.pos_work, pos_work_cb);
initialized = true;
return 0;
}
#if CONFIG_BT_MPL_LOG_LEVEL_DBG /* Special commands for debugging */
void mpl_debug_dump_state(void)
{
#if CONFIG_BT_MPL_OBJECTS
char t[BT_OTS_OBJ_ID_STR_LEN];
struct mpl_group *group;
struct mpl_track *track;
#endif /* CONFIG_BT_MPL_OBJECTS */
LOG_DBG("Mediaplayer name: %s", media_player.name);
#if CONFIG_BT_MPL_OBJECTS
(void)bt_ots_obj_id_to_str(media_player.icon_id, t, sizeof(t));
LOG_DBG("Icon ID: %s", t);
#endif /* CONFIG_BT_MPL_OBJECTS */
LOG_DBG("Icon URL: %s", media_player.icon_url);
LOG_DBG("Track position: %d", media_player.track_pos);
LOG_DBG("Media state: %d", media_player.state);
LOG_DBG("Playback speed parameter: %d", media_player.playback_speed_param);
LOG_DBG("Seeking speed factor: %d", media_player.seeking_speed_factor);
LOG_DBG("Playing order: %d", media_player.playing_order);
LOG_DBG("Playing orders supported: 0x%x", media_player.playing_orders_supported);
LOG_DBG("Opcodes supported: %d", media_player.opcodes_supported);
LOG_DBG("Content control ID: %d", media_player.content_ctrl_id);
#if CONFIG_BT_MPL_OBJECTS
(void)bt_ots_obj_id_to_str(media_player.group->parent->id, t, sizeof(t));
LOG_DBG("Current group's parent: %s", t);
(void)bt_ots_obj_id_to_str(media_player.group->id, t, sizeof(t));
LOG_DBG("Current group: %s", t);
(void)bt_ots_obj_id_to_str(media_player.group->track->id, t, sizeof(t));
LOG_DBG("Current track: %s", t);
if (media_player.next_track_set) {
(void)bt_ots_obj_id_to_str(media_player.next.track->id, t, sizeof(t));
LOG_DBG("Next track: %s", t);
} else if (media_player.group->track->next) {
(void)bt_ots_obj_id_to_str(media_player.group->track->next->id, t,
sizeof(t));
LOG_DBG("Next track: %s", t);
} else {
LOG_DBG("No next track");
}
if (media_player.search_results_id) {
(void)bt_ots_obj_id_to_str(media_player.search_results_id, t, sizeof(t));
LOG_DBG("Search results: %s", t);
} else {
LOG_DBG("No search results");
}
LOG_DBG("Groups and tracks:");
group = media_player.group;
while (group->prev != NULL) {
group = group->prev;
}
while (group) {
(void)bt_ots_obj_id_to_str(group->id, t, sizeof(t));
LOG_DBG("Group: %s, %s", t, group->title);
(void)bt_ots_obj_id_to_str(group->parent->id, t, sizeof(t));
LOG_DBG("\tParent: %s, %s", t, group->parent->title);
track = group->track;
while (track->prev != NULL) {
track = track->prev;
}
while (track) {
(void)bt_ots_obj_id_to_str(track->id, t, sizeof(t));
LOG_DBG("\tTrack: %s, %s, duration: %d", t, track->title, track->duration);
track = track->next;
}
group = group->next;
}
#endif /* CONFIG_BT_MPL_OBJECTS */
}
#endif /* CONFIG_BT_MPL_LOG_LEVEL_DBG */
#if defined(CONFIG_BT_MPL_LOG_LEVEL_DBG) && \
defined(CONFIG_BT_TESTING) /* Special commands for testing */
#if CONFIG_BT_MPL_OBJECTS
void mpl_test_unset_parent_group(void)
{
LOG_DBG("Setting current group to be it's own parent");
media_player.group->parent = media_player.group;
}
#endif /* CONFIG_BT_MPL_OBJECTS */
void mpl_test_media_state_set(uint8_t state)
{
mpl_set_state(state);
}
void mpl_test_player_name_changed_cb(void)
{
media_proxy_pl_name_cb(media_player.name);
}
void mpl_test_player_icon_url_changed_cb(void)
{
media_proxy_pl_icon_url_cb(media_player.icon_url);
}
void mpl_test_track_changed_cb(void)
{
media_proxy_pl_track_changed_cb();
}
void mpl_test_title_changed_cb(void)
{
media_proxy_pl_track_title_cb(media_player.group->track->title);
}
void mpl_test_duration_changed_cb(void)
{
media_proxy_pl_track_duration_cb(media_player.group->track->duration);
}
void mpl_test_position_changed_cb(void)
{
media_proxy_pl_track_position_cb(media_player.track_pos);
}
void mpl_test_playback_speed_changed_cb(void)
{
media_proxy_pl_playback_speed_cb(media_player.playback_speed_param);
}
void mpl_test_seeking_speed_changed_cb(void)
{
media_proxy_pl_seeking_speed_cb(media_player.seeking_speed_factor);
}
#ifdef CONFIG_BT_MPL_OBJECTS
void mpl_test_current_track_id_changed_cb(void)
{
media_proxy_pl_current_track_id_cb(media_player.group->track->id);
}
void mpl_test_next_track_id_changed_cb(void)
{
media_proxy_pl_next_track_id_cb(media_player.group->track->next->id);
}
void mpl_test_parent_group_id_changed_cb(void)
{
media_proxy_pl_parent_group_id_cb(media_player.group->id);
}
void mpl_test_current_group_id_changed_cb(void)
{
media_proxy_pl_current_group_id_cb(media_player.group->id);
}
#endif /* CONFIG_BT_MPL_OBJECTS */
void mpl_test_playing_order_changed_cb(void)
{
media_proxy_pl_playing_order_cb(media_player.playing_order);
}
void mpl_test_media_state_changed_cb(void)
{
media_proxy_pl_media_state_cb(media_player.playing_order);
}
void mpl_test_opcodes_supported_changed_cb(void)
{
media_proxy_pl_commands_supported_cb(media_player.opcodes_supported);
}
#ifdef CONFIG_BT_MPL_OBJECTS
void mpl_test_search_results_changed_cb(void)
{
media_proxy_pl_search_cb(media_player.search_results_id);
}
#endif /* CONFIG_BT_MPL_OBJECTS */
#endif /* CONFIG_BT_MPL_LOG_LEVEL_DBG && CONFIG_BT_TESTING */
View git blame Copy permalink