morgan/UxPlay
1
0
Fork 0
mirror of https://github.com/morgan9e/UxPlay synced 2026-04-14 00:04:13 +09:00
Code Issues Packages Projects Releases Wiki Activity

revert last two changes, and instead add a callback to report audio format

Browse Source
This commit is contained in:
fduncanh
2021-10-14 19:48:08 -04:00
parent def4678eed
commit 187cf7aaac
7 changed files with 35 additions and 138 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
lib/raop.h
View File

@@ -42,6 +42,7 @@ struct raop_callbacks_s {
void (*conn_destroy)(void *cls);
void (*audio_flush)(void *cls);
void (*video_flush)(void *cls);
void (*audio_get_format)(void *cls, unsigned int audioFormat);
void (*audio_set_volume)(void *cls, float volume);
void (*audio_set_metadata)(void *cls, const void *buffer, int buflen);
void (*audio_set_coverart)(void *cls, const void *buffer, int buflen);

9
lib/raop_buffer.c
View File

@@ -53,19 +53,10 @@ struct raop_buffer_s {
unsigned short first_seqnum;
unsigned short last_seqnum;
/* audio parameters */
audio_format_t audio_format;
bool using_screen;
/* RTP buffer entries */
raop_buffer_entry_t entries[RAOP_BUFFER_LENGTH];
};
void raop_buffer_set_audio_parameters(raop_buffer_t *raop_buffer, audio_format_t *audio_format, bool *using_screen) {
assert(raop_buffer);
raop_buffer->audio_format = *audio_format;
raop_buffer->using_screen = *using_screen;
}
void
raop_buffer_init_key_iv(raop_buffer_t *raop_buffer,
const unsigned char *aeskey,

1
lib/raop_buffer.h
View File

@@ -34,6 +34,5 @@ void raop_buffer_flush(raop_buffer_t *raop_buffer, int next_seq);
int raop_buffer_decrypt(raop_buffer_t *raop_buffer, unsigned char *data, unsigned char* output,
unsigned int datalen, unsigned int *outputlen);
void raop_buffer_destroy(raop_buffer_t *raop_buffer);
void raop_buffer_set_audio_parameters(raop_buffer_t *raop_buffer, audio_format_t *audio_format, bool *using_screen);
#endif

68
lib/raop_handlers.h
View File

@@ -432,70 +432,18 @@ raop_handler_setup(raop_conn_t *conn,
} case 96: {
// Audio
unsigned short cport = conn->raop->control_lport, dport = conn->raop->data_lport;
audio_format_t audioFormat = UNKNOWN;
bool usingScreen = false;
unsigned short spf = 0, ct = 0, redundantAudio = 0;
unsigned int latencyMax, latencyMin;
plist_type ptype;
uint64_t uint_val;
uint8_t bool_val;
/* get audio parameter of connection */
plist_t audio_format_node = plist_dict_get_item(req_stream_node, "audioFormat");
plist_get_uint_val(audio_format_node, &uint_val);
audioFormat = get_audio_format( (int) uint_val);
logger_log(conn->raop->logger, LOGGER_INFO, "audioFormat = 0X%X %s", audioFormat, audio_format_name(audioFormat));
if (audioFormat == UNKNOWN) {
logger_log(conn->raop->logger, LOGGER_ERR, "RAOP cannot play UNKNOWN audio format 0X%X\n", (int) uint_val);
http_response_set_disconnect(response, 1);
if (conn->raop->callbacks.audio_get_format) {
/* get audio format of connection */
uint64_t uint_val;
plist_t audio_format_node = plist_dict_get_item(req_stream_node, "audioFormat");
plist_get_uint_val(audio_format_node, &uint_val);
conn->raop->callbacks.audio_get_format(conn->raop->callbacks.cls, (unsigned int) uint_val);
}
plist_t using_screen_node = plist_dict_get_item(req_stream_node, "usingScreen");
ptype = plist_get_node_type(using_screen_node);
if (ptype == PLIST_BOOLEAN){
plist_get_bool_val(using_screen_node, &bool_val);
if (bool_val) {
usingScreen = true;
}
}
plist_t spf_node = plist_dict_get_item(req_stream_node, "spf");
ptype = plist_get_node_type(spf_node);
if(ptype == PLIST_UINT) {
plist_get_uint_val(spf_node, &uint_val);
spf = (unsigned short) uint_val;
}
plist_t ct_node = plist_dict_get_item(req_stream_node, "ct");
ptype = plist_get_node_type(ct_node);
if(ptype == PLIST_UINT) {
plist_get_uint_val(ct_node, &uint_val);
ct = (unsigned short) uint_val;
}
plist_t redundant_audio_node = plist_dict_get_item(req_stream_node, "redundantAudio");
ptype = plist_get_node_type(redundant_audio_node);
if(ptype == PLIST_UINT) {
plist_get_uint_val(redundant_audio_node, &uint_val);
redundantAudio = (unsigned short) uint_val;
}
plist_t latency_max_node = plist_dict_get_item(req_stream_node, "latencyMax");
plist_get_uint_val(latency_max_node, &uint_val);
latencyMax = (unsigned int) uint_val;
plist_t latency_min_node = plist_dict_get_item(req_stream_node, "latencyMin");
plist_get_uint_val(latency_min_node, &uint_val);
latencyMin = (unsigned int) uint_val;
logger_log(conn->raop->logger, LOGGER_DEBUG, "audio stream properties: %d %d %d %d %d %d", latencyMax, redundantAudio, latencyMin, ct, spf, usingScreen);
if (conn->raop_rtp) {
raop_rtp_start_audio(conn->raop_rtp, use_udp, remote_cport, &cport, &dport, &audioFormat, &usingScreen);
logger_log(conn->raop->logger, LOGGER_DEBUG, "RAOP initialized success");
raop_rtp_start_audio(conn->raop_rtp, use_udp, remote_cport, &cport, &dport);
logger_log(conn->raop->logger, LOGGER_DEBUG, "RAOP initialized success");
} else {
logger_log(conn->raop->logger, LOGGER_ERR, "RAOP not initialized at SETUP, playing will fail!");
http_response_set_disconnect(response, 1);

55
lib/raop_rtp.c
View File

@@ -526,14 +526,12 @@ raop_rtp_thread_udp(void *arg)
// Start rtp service, three udp ports
void
raop_rtp_start_audio(raop_rtp_t *raop_rtp, int use_udp, unsigned short control_rport,
unsigned short *control_lport, unsigned short *data_lport,
audio_format_t *audio_format, bool *using_screen)
unsigned short *control_lport, unsigned short *data_lport)
{
logger_log(raop_rtp->logger, LOGGER_INFO, "raop_rtp starting audio");
int use_ipv6 = 0;
assert(raop_rtp);
raop_buffer_set_audio_parameters(raop_rtp->buffer, audio_format, using_screen);
MUTEX_LOCK(raop_rtp->run_mutex);
if (raop_rtp->running || !raop_rtp->joined) {
@@ -704,54 +702,3 @@ raop_rtp_is_running(raop_rtp_t *raop_rtp)
MUTEX_UNLOCK(raop_rtp->run_mutex);
return running;
}
const char* audio_format_name(audio_format_t audio_format) {
const char * aac_eld = "AAC_ELD";
const char * alac = "ALAC";
const char * aac = "AAC";
const char * pcm = "PCM";
const char * unknown = "UNKNOWN";
const char * invalid = "";
switch (audio_format) {
case AAC_ELD:
return aac_eld;
break;
case ALAC:
return alac;
break;
case AAC:
return aac;
break;
case PCM:
return pcm;
break;
case UNKNOWN:
return unknown;
break;
default:
break;
}
return invalid;
}
audio_format_t get_audio_format(int format) {
switch (format) {
case (AAC_ELD):
return AAC_ELD;
break;
case (ALAC):
return ALAC;
break;
case (AAC):
return AAC;
break;
case (PCM):
return PCM;
break;
default:
return UNKNOWN;
break;
}
}

14
lib/raop_rtp.h
View File

@@ -26,23 +26,11 @@
typedef struct raop_rtp_s raop_rtp_t;
typedef enum audio_format_e {
AAC_ELD = 0x1000000,
ALAC = 0x400000,
AAC = 0x40000,
PCM = 0x0,
UNKNOWN
} audio_format_t ;
const char * audio_format_name(audio_format_t audio_format);
audio_format_t get_audio_format(int format);
raop_rtp_t *raop_rtp_init(logger_t *logger, raop_callbacks_t *callbacks, raop_ntp_t *ntp, const unsigned char *remote, int remotelen,
const unsigned char *aeskey, const unsigned char *aesiv, const unsigned char *ecdh_secret);
void raop_rtp_start_audio(raop_rtp_t *raop_rtp, int use_udp, unsigned short control_rport,
unsigned short *control_lport, unsigned short *data_lport,
audio_format_t *audio_format, bool *using_screen);
unsigned short *control_lport, unsigned short *data_lport);
void raop_rtp_set_volume(raop_rtp_t *raop_rtp, float volume);
void raop_rtp_set_metadata(raop_rtp_t *raop_rtp, const char *data, int datalen);

25
uxplay.cpp
View File

@@ -464,6 +464,28 @@ extern "C" void audio_set_volume (void *cls, float volume) {
}
}
extern "C" void audio_get_format (void *cls, unsigned int audioFormat) {
const char * audio_format;
switch (audioFormat) {
case 0x1000000:
audio_format = "AAC_ELD";
break;
case 0x40000:
audio_format = "ALAC";
break;
case 0x400000:
audio_format = "AAC";
break;
case 0x0:
audio_format = "PCM";
break;
default:
audio_format = "UNKNOWN";
break;
}
printf("new audio connection with audio format 0x%X %s\n", audioFormat, audio_format);
}
extern "C" void log_callback (void *cls, int level, const char *msg) {
switch (level) {
case LOGGER_DEBUG: {
@@ -500,7 +522,8 @@ int start_server (std::vector<char> hw_addr, std::string name, unsigned short di
raop_cbs.audio_flush = audio_flush;
raop_cbs.video_flush = video_flush;
raop_cbs.audio_set_volume = audio_set_volume;
raop_cbs.audio_get_format = audio_get_format;
raop = raop_init(10, &raop_cbs);
if (raop == NULL) {
LOGE("Error initializing raop!");