// 1. 解包数据包
if (ln_udp_unpack_packet(data, data_len, &packet) != 0) {
- printf("[LN_UDP] Failed to unpack packet\n");
+ LN_MQTT_ERROR("Failed to unpack packet\n");
return -1;
}
- printf("[LN_UDP] Packet unpacked: type=%d, flags=%d, ssrc=%u, timestamp=%u, sequence=%u, payload_len=%d\n",
+ LN_MQTT_DEBUG("Packet unpacked: type=%d, flags=%d, ssrc=%u, timestamp=%u, sequence=%u, payload_len=%d\n",
packet.type, packet.flags, packet.ssrc, packet.timestamp, packet.sequence, packet.payload_len);
// 2. 获取UDP信息（用于解密）
ln_mqtt_udp_info_t udp_info;
if (ln_mqtt_api_get_udp_info(&udp_info) != 0 || !udp_info.valid) {
- printf("[LN_UDP] UDP info not available for decryption\n");
+ LN_MQTT_WARN("UDP info not available for decryption\n");
ln_udp_free_packet(&packet);
return -1;
}
// 分配解密数据缓冲区
uint8_t *decrypted_data = (uint8_t *)malloc(packet.payload_len);
if (!decrypted_data) {
- printf("[LN_UDP] Failed to allocate memory for decrypted data\n");
+ LN_MQTT_ERROR("Failed to allocate memory for decrypted data\n");
ln_udp_free_packet(&packet);
return -1;
}
if (ln_udp_decrypt_audio(udp_info.key, udp_info.nonce, packet.payload_len,
packet.timestamp, packet.sequence,
packet.payload, packet.payload_len, decrypted_data) != 0) {
- printf("[LN_UDP] Failed to decrypt payload data\n");
+ LN_MQTT_ERROR("Failed to decrypt payload data\n");
free(decrypted_data);
ln_udp_free_packet(&packet);
return -1;
}
- printf("decrypted_data: ");
+ LN_MQTT_DEBUG("decrypted_data: ");
- printf("\n");
+ LN_MQTT_DEBUG("\n");
- printf("[LN_UDP] Payload decrypted successfully, size=%d bytes\n", packet.payload_len);
+ LN_MQTT_DEBUG("Payload decrypted successfully, size=%d bytes\n", packet.payload_len);
- printf("packet.sequence: %u\n", packet.sequence);
+ LN_MQTT_DEBUG("packet.sequence: %u\n", packet.sequence);
#if USE_DUAL_STREAM_INTERFACE
// 使用双流接口时，不进行 OGG 封装，但需要保持包顺序处理
// 注意：decrypted_data 的所有权会转移给处理函数，不需要在这里释放
if (ln_udp_dual_stream_handle_packet(packet.sequence, decrypted_data, packet.payload_len) != 0) {
- printf("[LN_UDP] Failed to handle dual stream packet (sequence=%u)\n", packet.sequence);
+ LN_MQTT_ERROR("Failed to handle dual stream packet (sequence=%u)\n", packet.sequence);
free(decrypted_data); // 处理失败时才释放
}
#else
// OGG 封装处理：使用独立函数处理，支持乱序数据包缓存和排序
// 注意：decrypted_data 的所有权会转移给处理函数，不需要在这里释放
if (ln_udp_ogg_handle_packet(packet.sequence, decrypted_data, packet.payload_len) != 0) {
- printf("[LN_UDP] Failed to handle OGG packet (sequence=%u)\n", packet.sequence);
+ LN_MQTT_ERROR("Failed to handle OGG packet (sequence=%u)\n", packet.sequence);
free(decrypted_data); // 处理失败时才释放
}
#endif /* USE_DUAL_STREAM_INTERFACE */
} else {
- printf("[LN_UDP] Packet has no payload data\n");
+ LN_MQTT_DEBUG("Packet has no payload data\n");
}
// 4. 释放数据包
int ln_udp_unpack_packet(const uint8_t *data, uint16_t data_len, ln_udp_packet_t *packet)
{
if (!data || !packet || data_len < UDP_PACKET_HEADER_SIZE) {
- printf("[LN_UDP] Invalid parameters or data too short for unpack\n");
+ LN_MQTT_WARN("Invalid parameters or data too short for unpack\n");
return -1;
}
// 验证负载长度
uint16_t expected_len = UDP_PACKET_HEADER_SIZE + packet->payload_len;
if (data_len < expected_len) {
- printf("[LN_UDP] Data length mismatch: expected %d, got %d\n", expected_len, data_len);
+ LN_MQTT_WARN("Data length mismatch: expected %d, got %d\n", expected_len, data_len);
return -1;
}
if (packet->payload_len > 0) {
packet->payload = (uint8_t *)malloc(packet->payload_len);
if (!packet->payload) {
- printf("[LN_UDP] Failed to allocate memory for payload\n");
+ LN_MQTT_ERROR("Failed to allocate memory for payload\n");
return -1;
}
memcpy(packet->payload, ptr + UDP_PACKET_HEADER_SIZE, packet->payload_len);
int ln_udp_pack_packet(const ln_udp_packet_t *packet, uint8_t *buffer, uint16_t buffer_size, uint16_t *out_len)
{
if (!packet || !buffer || !out_len) {
- printf("[LN_UDP] Invalid parameters for pack\n");
+ LN_MQTT_WARN("Invalid parameters for pack\n");
return -1;
}
// 计算所需缓冲区大小
uint16_t total_len = UDP_PACKET_HEADER_SIZE + packet->payload_len;
if (buffer_size < total_len) {
- printf("[LN_UDP] Buffer too small: need %d, have %d\n", total_len, buffer_size);
+ LN_MQTT_WARN("Buffer too small: need %d, have %d\n", total_len, buffer_size);
return -1;
}
}
if (empty_slot < 0) {
- printf("[LN_UDP] OGG cache full, dropping packet sequence=%u\n", sequence);
+ LN_MQTT_WARN("OGG cache full, dropping packet sequence=%u\n", sequence);
return;
}
// 分配内存并复制数据
uint8_t *cached_data = (uint8_t *)malloc(data_size);
if (cached_data == NULL) {
- printf("[LN_UDP] Failed to allocate memory for cached packet sequence=%u\n", sequence);
+ LN_MQTT_ERROR("Failed to allocate memory for cached packet sequence=%u\n", sequence);
return;
}
g_ogg_packet_cache[empty_slot].data_size = data_size;
g_ogg_packet_cache[empty_slot].valid = true;
- printf("[LN_UDP] Cached packet sequence=%u (slot=%d)\n", sequence, empty_slot);
+ LN_MQTT_DEBUG("Cached packet sequence=%u (slot=%d)\n", sequence, empty_slot);
}
/**
g_opus_debug_file = fopen(filename, "wb");
if (g_opus_debug_file == NULL) {
- printf("[LN_UDP] Failed to open Opus debug file: %s\n", filename);
+ LN_MQTT_ERROR("Failed to open Opus debug file: %s\n", filename);
return -1;
}
g_opus_debug_packet_count = 0;
g_opus_debug_file_index++;
- printf("[LN_UDP] Created new Opus debug file: %s (index: %u)\n", filename, g_opus_debug_file_index - 1);
+ LN_MQTT_DEBUG("Created new Opus debug file: %s (index: %u)\n", filename, g_opus_debug_file_index - 1);
return 0;
#else
fclose(g_opus_debug_file);
g_opus_debug_file = NULL;
g_opus_debug_packet_count = 0;
- printf("[LN_UDP] Completed Opus debug file #%u\n", g_opus_debug_file_index - 1);
+ LN_MQTT_DEBUG("Completed Opus debug file #%u\n", g_opus_debug_file_index - 1);
#endif
}
const uint8_t **opus_data, uint32_t *opus_data_size)
{
if (!data || data_size == 0 || !opus_data || !opus_data_size) {
- printf("[LN_UDP] Invalid parameters for Opus packet parsing\n");
+ LN_MQTT_WARN("Invalid parameters for Opus packet parsing\n");
return -1;
}
// 至少需要 TOC 字节
if (data_size < 1) {
- printf("[LN_UDP] Opus packet too small (size=%u)\n", data_size);
+ LN_MQTT_WARN("Opus packet too small (size=%u)\n", data_size);
return -1;
}
} else {
// 多帧：需要读取帧计数字节
if (remaining < 1) {
- printf("[LN_UDP] Opus packet too small for frame count byte\n");
+ LN_MQTT_WARN("Opus packet too small for frame count byte\n");
return -1;
}
frame_count = frame_count_code - 16 + 1 + ptr[0];
// 注意：我们只读取长度值，不跳过帧数据，因为所有帧数据是连续存储的
for (uint8_t i = 0; i < frame_count - 1; i++) {
if (remaining < 1) {
- printf("[LN_UDP] Opus packet too small for frame length table\n");
+ LN_MQTT_WARN("Opus packet too small for frame length table\n");
return -1;
}
} else {
// 2字节编码：0xFC + 实际长度（大端序）
if (remaining < 2) {
- printf("[LN_UDP] Opus packet too small for 2-byte frame length\n");
+ LN_MQTT_WARN("Opus packet too small for 2-byte frame length\n");
return -1;
}
ptr += 2;
// 5. 现在 header_size 包含了所有头部信息（TOC + 帧计数 + 帧长度表）
// 从 header_size 之后的所有数据都是 Opus 编码数据（包含所有帧的数据）
if (header_size >= data_size) {
- printf("[LN_UDP] Opus header size (%u) >= total size (%u)\n", header_size, data_size);
+ LN_MQTT_WARN("Opus header size (%u) >= total size (%u)\n", header_size, data_size);
return -1;
}
*opus_data = data + header_size;
*opus_data_size = data_size - header_size;
- printf("[LN_UDP] Opus parsed: frame_count=%d, header_size=%u, opus_data_size=%u\n",
+ LN_MQTT_DEBUG("Opus parsed: frame_count=%d, header_size=%u, opus_data_size=%u\n",
frame_count, header_size, *opus_data_size);
return 0;
return -1;
}
}
- printf("opus debug data: ");
+ LN_MQTT_DEBUG("opus debug data: ");
for (int i = 0; i < data_size; i++) {
- printf("%02X ", data[i]);
+ LN_MQTT_DEBUG("%02X ", data[i]);
}
- printf("\n");
+ LN_MQTT_DEBUG("\n");
// 解析 Opus 数据包（用于验证和日志输出，但不影响保存）
const uint8_t *opus_data = NULL;
uint32_t opus_data_size = 0;
int parse_ret = ln_udp_parse_opus_packet(data, data_size, &opus_data, &opus_data_size);
if (parse_ret == 0) {
- printf("[LN_UDP] Opus debug: Parsed packet sequence=%u, total_size=%u, opus_data_size=%u\n",
+ LN_MQTT_DEBUG("Opus debug: Parsed packet sequence=%u, total_size=%u, opus_data_size=%u\n",
sequence, data_size, opus_data_size);
} else {
- printf("[LN_UDP] Opus debug: Parse warning (sequence=%u, size=%u), but saving raw data anyway\n",
+ LN_MQTT_WARN("Opus debug: Parse warning (sequence=%u, size=%u), but saving raw data anyway\n",
sequence, data_size);
}
g_opus_debug_pcm_buf, OPUS_DEBUG_PCM_BUF_SAMPLES,
&pcm_samples);
if (dec_ret == 0) {
- printf("[LN_UDP] Opus decode test OK sequence=%u pcm_samples=%d\n", sequence, pcm_samples);
+ LN_MQTT_DEBUG("Opus decode test OK sequence=%u pcm_samples=%d\n", sequence, pcm_samples);
if (g_opus_debug_pcm_file == NULL) {
g_opus_debug_pcm_file = fopen("user/udp_opus_debug.pcm", "ab");
if (g_opus_debug_pcm_file != NULL) {
- printf("[LN_UDP] Opus decode PCM output: udp_opus_debug.pcm (append)\n");
+ LN_MQTT_DEBUG("Opus decode PCM output: udp_opus_debug.pcm (append)\n");
}
}
if (g_opus_debug_pcm_file != NULL && pcm_samples > 0) {
size_t n = fwrite(g_opus_debug_pcm_buf, sizeof(short), (size_t)pcm_samples, g_opus_debug_pcm_file);
if (n != (size_t)pcm_samples) {
- printf("[LN_UDP] Opus decode PCM write short: %zu/%d\n", n, pcm_samples);
+ LN_MQTT_DEBUG("Opus decode PCM write short: %zu/%d\n", n, pcm_samples);
}
fflush(g_opus_debug_pcm_file);
}
fclose(g_opus_debug_pcm_file);
g_opus_debug_pcm_file = NULL;
} else {
- printf("[LN_UDP] Opus decode test FAIL sequence=%u\n", sequence);
+ LN_MQTT_ERROR("Opus decode test FAIL sequence=%u\n", sequence);
}
}
// 保存完整的原始数据（包含 TOC 字节和帧长度表）
size_t written = fwrite(data, 1, data_size, g_opus_debug_file);
if (written != data_size) {
- printf("[LN_UDP] Opus debug: Failed to write data (sequence=%u, written=%zu, expected=%u)\n",
+ LN_MQTT_ERROR("Opus debug: Failed to write data (sequence=%u, written=%zu, expected=%u)\n",
sequence, written, data_size);
return -1;
}
fflush(g_opus_debug_file); // 立即刷新到文件
g_opus_debug_packet_count++;
- printf("[LN_UDP] Opus debug: Written packet sequence=%u (%u/%u, raw_size=%u bytes)\n",
+ LN_MQTT_DEBUG("Opus debug: Written packet sequence=%u (%u/%u, raw_size=%u bytes)\n",
sequence, g_opus_debug_packet_count, OGG_PACKETS_PER_FILE, data_size);
return 0;
// 写入数据包
if (g_ogg_ctx_handle == NULL) {
- printf("[LN_UDP] OGG context handle is null\n");
+ LN_MQTT_ERROR("OGG context handle is null\n");
return -1;
}
if (MqttOggEncapsulationWriteHandle(g_ogg_ctx_handle, data, data_size, g_ogg_file, false) != 0) {
- printf("[LN_UDP] Failed to write OGG data (sequence=%u)\n", sequence);
+ LN_MQTT_ERROR("Failed to write OGG data (sequence=%u)\n", sequence);
return -1;
}
g_ogg_packet_count++;
- printf("[LN_UDP] Written packet sequence=%u (%u/%u to OGG file)\n",
+ LN_MQTT_DEBUG("Written packet sequence=%u (%u/%u to OGG file)\n",
sequence, g_ogg_packet_count, OGG_PACKETS_PER_FILE);
return 0;
g_ogg_packet_cache[i].sequence = 0;
g_ogg_packet_cache[i].data_size = 0;
found = true;
- printf("[LN_UDP] Flushed cached packet sequence=%u\n",
+ LN_MQTT_DEBUG("Flushed cached packet sequence=%u\n",
g_ogg_expected_sequence - 1);
break; // 重新开始查找
} else {
g_ogg_file = NULL;
g_ogg_initialized = false;
- printf("[LN_UDP] Completed OGG file #%u with %u packets: %s\n",
+ LN_MQTT_INFO("Completed OGG file #%u with %u packets: %s\n",
g_ogg_file_index - 1, g_ogg_packet_count, g_completed_ogg_filename);
// 使用 MQTT 播放接口播放完成的文件
if (g_completed_ogg_filename[0] != '\0') {
int32_t play_ret = MQTT_PlayAudioFile(g_completed_ogg_filename, NULL, NULL);
if (play_ret == 0) {
- printf("[LN_UDP] Started playing OGG file: %s\n", g_completed_ogg_filename);
+ LN_MQTT_INFO("Started playing OGG file: %s\n", g_completed_ogg_filename);
} else {
- printf("[LN_UDP] Failed to play OGG file: %s (ret=%d)\n",
+ LN_MQTT_ERROR("Failed to play OGG file: %s (ret=%d)\n",
g_completed_ogg_filename, play_ret);
}
g_completed_ogg_filename[0] = '\0';
g_ogg_file = fopen(filename, "wb");
if (g_ogg_file == NULL) {
- printf("[LN_UDP] Failed to open OGG file: %s\n", filename);
+ LN_MQTT_ERROR("Failed to open OGG file: %s\n", filename);
g_completed_ogg_filename[0] = '\0';
return -1;
}
if (g_ogg_ctx_handle == NULL) {
g_ogg_ctx_handle = MqttOggGetContext();
if (g_ogg_ctx_handle == NULL) {
- printf("[LN_UDP] Failed to get OGG context handle\n");
+ LN_MQTT_ERROR("Failed to get OGG context handle\n");
fclose(g_ogg_file);
g_ogg_file = NULL;
g_completed_ogg_filename[0] = '\0';
// 初始化 OGG 上下文
if (MqttOggEncapsulationInitHandle(g_ogg_ctx_handle, g_ogg_file, 16000, 1) != 0) {
- printf("[LN_UDP] Failed to initialize OGG context\n");
+ LN_MQTT_ERROR("Failed to initialize OGG context\n");
fclose(g_ogg_file);
g_ogg_file = NULL;
g_completed_ogg_filename[0] = '\0';
g_ogg_initialized = true;
g_ogg_packet_count = 0;
g_ogg_file_index++;
- printf("[LN_UDP] Created new OGG file: %s (index: %u)\n", filename, g_ogg_file_index - 1);
+ LN_MQTT_DEBUG("Created new OGG file: %s (index: %u)\n", filename, g_ogg_file_index - 1);
return 0;
}
if (g_ogg_expected_sequence == 0) {
g_ogg_expected_sequence = sequence;
g_ogg_out_of_order_count = 0; // 重置错序计数器
- printf("[LN_UDP] Initialized expected sequence to %u\n", sequence);
+ LN_MQTT_DEBUG("Initialized expected sequence to %u\n", sequence);
}
// 检查是否是期望的下一个包
} else if (sequence > g_ogg_expected_sequence) {
// 是未来的包，缓存起来
g_ogg_out_of_order_count++; // 增加错序计数器
- printf("[LN_UDP] Received future packet sequence=%u (expected=%u), caching (out_of_order_count=%u)\n",
+ LN_MQTT_DEBUG("Received future packet sequence=%u (expected=%u), caching (out_of_order_count=%u)\n",
sequence, g_ogg_expected_sequence, g_ogg_out_of_order_count);
// 如果连续错序超过阈值，跳过期望的序列号（避免丢包时一直无法正常输出）
if (g_ogg_out_of_order_count > OGG_MAX_OUT_OF_ORDER_COUNT) {
uint32_t old_expected = g_ogg_expected_sequence;
- printf("[LN_UDP] Out of order count exceeded %d, skipping sequence %u\n",
+ LN_MQTT_DEBUG("Out of order count exceeded %d, skipping sequence %u\n",
OGG_MAX_OUT_OF_ORDER_COUNT, g_ogg_expected_sequence);
// 1. 先将期望序号往后加一（跳过丢失的包）
free((void *)data);
// 继续刷新缓存中的后续包
ln_udp_ogg_flush_cache();
- printf("[LN_UDP] Successfully wrote skipped packet sequence=%u (old_expected=%u)\n",
+ LN_MQTT_DEBUG("Successfully wrote skipped packet sequence=%u (old_expected=%u)\n",
sequence, old_expected);
return 0;
} else {
}
} else if (sequence > g_ogg_expected_sequence) {
// 当前包仍然是未来的包，缓存起来
- printf("[LN_UDP] Current packet sequence=%u still ahead of expected=%u after skip, caching\n",
+ LN_MQTT_DEBUG("Current packet sequence=%u still ahead of expected=%u after skip, caching\n",
sequence, g_ogg_expected_sequence);
ln_udp_ogg_cache_packet(sequence, data, data_size);
free((void *)data);
return 0;
} else {
// 当前包已经是过去的包（在刷新缓存时已处理），丢弃
- printf("[LN_UDP] Current packet sequence=%u is now old (expected=%u), dropping\n",
+ LN_MQTT_DEBUG("Current packet sequence=%u is now old (expected=%u), dropping\n",
sequence, g_ogg_expected_sequence);
free((void *)data);
return 0;
}
} else {
// 是过去的包（重复或乱序），丢弃
- printf("[LN_UDP] Received old/duplicate packet sequence=%u (expected=%u), dropping\n",
+ LN_MQTT_DEBUG("Received old/duplicate packet sequence=%u (expected=%u), dropping\n",
sequence, g_ogg_expected_sequence);
free((void *)data);
return 0;
uint32_t pcm_data_size = (uint32_t)(pcm_samples * sizeof(short));
int32_t send_ret = AI_SendAudioDataToQueue((const uint8_t *)g_opus_debug_pcm_buf, pcm_data_size);
if (send_ret == 0) {
- printf("[LN_UDP] Dual stream: Decoded and sent to queue: sequence=%u, pcm_samples=%d\n",
+ LN_MQTT_DEBUG("Dual stream: Decoded and sent to queue: sequence=%u, pcm_samples=%d\n",
sequence, pcm_samples);
return 0;
} else {
- printf("[LN_UDP] Dual stream: Failed to send decoded PCM to queue: sequence=%u, ret=%d\n",
+ LN_MQTT_ERROR("Dual stream: Failed to send decoded PCM to queue: sequence=%u, ret=%d\n",
sequence, (int)send_ret);
return -1;
}
} else {
- printf("[LN_UDP] Dual stream: Opus decode failed: sequence=%u, ret=%d\n",
+ LN_MQTT_ERROR("Dual stream: Opus decode failed: sequence=%u, ret=%d\n",
sequence, dec_ret);
return -1;
}
g_ogg_packet_cache[i].sequence = 0;
g_ogg_packet_cache[i].data_size = 0;
found = true; // 继续查找下一个期望的包
- printf("[LN_UDP] Dual stream: Flushed cached packet sequence=%u\n",
+ LN_MQTT_DEBUG("Dual stream: Flushed cached packet sequence=%u\n",
g_ogg_expected_sequence - 1);
break; // 重新开始查找
} else {
if (g_ogg_expected_sequence == 0) {
g_ogg_expected_sequence = sequence;
g_ogg_out_of_order_count = 0; // 重置错序计数器
- printf("[LN_UDP] Dual stream: Initialized expected sequence to %u\n", sequence);
+ LN_MQTT_DEBUG("Dual stream: Initialized expected sequence to %u\n", sequence);
}
// 检查是否是期望的下一个包
} else if (sequence > g_ogg_expected_sequence) {
// 是未来的包，缓存起来
g_ogg_out_of_order_count++; // 增加错序计数器
- printf("[LN_UDP] Dual stream: Received future packet sequence=%u (expected=%u), caching (out_of_order_count=%u)\n",
+ LN_MQTT_DEBUG("Dual stream: Received future packet sequence=%u (expected=%u), caching (out_of_order_count=%u)\n",
sequence, g_ogg_expected_sequence, g_ogg_out_of_order_count);
// 如果连续错序超过阈值，跳过期望的序列号（避免丢包时一直无法正常输出）
if (g_ogg_out_of_order_count > OGG_MAX_OUT_OF_ORDER_COUNT) {
uint32_t old_expected = g_ogg_expected_sequence;
- printf("[LN_UDP] Dual stream: Out of order count exceeded %d, skipping sequence %u\n",
+ LN_MQTT_DEBUG("Dual stream: Out of order count exceeded %d, skipping sequence %u\n",
OGG_MAX_OUT_OF_ORDER_COUNT, g_ogg_expected_sequence);
// 1. 先将期望序号往后加一（跳过丢失的包）
free((void *)data);
// 继续刷新缓存中的后续包
ln_udp_dual_stream_flush_cache();
- printf("[LN_UDP] Dual stream: Successfully decoded and sent skipped packet sequence=%u (old_expected=%u)\n",
+ LN_MQTT_DEBUG("Dual stream: Successfully decoded and sent skipped packet sequence=%u (old_expected=%u)\n",
sequence, old_expected);
return 0;
} else {
}
} else if (sequence > g_ogg_expected_sequence) {
// 当前包仍然是未来的包，缓存起来
- printf("[LN_UDP] Dual stream: Current packet sequence=%u still ahead of expected=%u after skip, caching\n",
+ LN_MQTT_DEBUG("Dual stream: Current packet sequence=%u still ahead of expected=%u after skip, caching\n",
sequence, g_ogg_expected_sequence);
ln_udp_ogg_cache_packet(sequence, data, data_size);
free((void *)data);
return 0;
} else {
// 当前包已经是过去的包（在刷新缓存时已处理），丢弃
- printf("[LN_UDP] Dual stream: Current packet sequence=%u is now old (expected=%u), dropping\n",
+ LN_MQTT_DEBUG("Dual stream: Current packet sequence=%u is now old (expected=%u), dropping\n",
sequence, g_ogg_expected_sequence);
free((void *)data);
return 0;
}
} else {
// 是过去的包（重复或乱序），丢弃
- printf("[LN_UDP] Dual stream: Received old/duplicate packet sequence=%u (expected=%u), dropping\n",
+ LN_MQTT_DEBUG("Dual stream: Received old/duplicate packet sequence=%u (expected=%u), dropping\n",
sequence, g_ogg_expected_sequence);
free((void *)data);
return 0;
uint32_t last_recreate_tick = 0;
uint32_t recreate_interval_ticks = 0;
- printf("[LN_UDP] Receive thread started\n");
+ LN_MQTT_INFO("Receive thread started\n");
// 获取服务器地址信息
ln_mqtt_udp_info_t udp_info;
if (ln_mqtt_api_get_udp_info(&udp_info) != 0 || !udp_info.valid) {
- printf("[LN_UDP] UDP info not available in receive thread\n");
+ LN_MQTT_WARN("UDP info not available in receive thread\n");
g_udp_thread_running = false;
return;
}
}
while (g_udp_thread_running && g_udp_socket >= 0) {
- printf("g_udp_thread_running %d g_udp_socket %d\r\n",g_udp_thread_running,g_udp_socket);
+ LN_MQTT_DEBUG("g_udp_thread_running %d g_udp_socket %d\r\n", g_udp_thread_running, g_udp_socket);
// 固定时间间隔到达则重新创建 socket
if (UDP_RECV_RECREATE_INTERVAL_SEC > 0 && recreate_interval_ticks > 0) {
uint32_t now = osKernelGetTickCount();
if ((now - last_recreate_tick) >= recreate_interval_ticks) {
- printf("[LN_UDP] Recreate interval reached (%u s), recreating socket\n", (unsigned)UDP_RECV_RECREATE_INTERVAL_SEC);
+ LN_MQTT_INFO("Recreate interval reached (%u s), recreating socket\n", (unsigned)UDP_RECV_RECREATE_INTERVAL_SEC);
lwip_close(g_udp_socket);
g_udp_socket = ln_udp_create_socket_fd_only();
if (g_udp_socket < 0) {
- printf("[LN_UDP] Failed to recreate socket: %s\n", strerror(errno));
+ LN_MQTT_ERROR("Failed to recreate socket: %s\n", strerror(errno));
break;
}
/* 重新获取 UDP 地址信息（服务端地址/端口可能变化） */
if (ln_mqtt_api_get_udp_info(&udp_info) != 0 || !udp_info.valid) {
- printf("[LN_UDP] UDP info not available after recreate, keep last address\n");
+ LN_MQTT_WARN("UDP info not available after recreate, keep last address\n");
} else {
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin_family = AF_INET;
(struct sockaddr *)&server_addr, &addr_len);
if (recv_len > 0) {
- printf("[LN_UDP] Received %d bytes\r\n",
+ LN_MQTT_DEBUG("Received %d bytes\r\n",
(int)recv_len
);
ln_udp_process_received_data(recv_buffer, (uint16_t)recv_len);
} else if (recv_len == 0) {
- printf("[LN_UDP] Connection closed by peer\n");
+ LN_MQTT_INFO("Connection closed by peer\n");
break;
} else {
if (errno != EAGAIN && errno != EWOULDBLOCK) {
- printf("[LN_UDP] Recvfrom error: %s\n", strerror(errno));
+ LN_MQTT_ERROR("Recvfrom error: %s\n", strerror(errno));
}
}
} else if (select_ret < 0) {
- printf("select_ret %d\r\n",select_ret);
+ LN_MQTT_DEBUG("select_ret %d\r\n", select_ret);
if (errno != EINTR) {
- printf("[LN_UDP] Select error: %s\n", strerror(errno));
+ LN_MQTT_ERROR("Select error: %s\n", strerror(errno));
break;
}
}
// select_ret == 0 表示超时，继续循环
}
- printf("[LN_UDP] Receive thread exited\n");
+ LN_MQTT_INFO("Receive thread exited\n");
g_udp_thread_running = false;
}
// 获取UDP信息
ln_mqtt_udp_info_t udp_info;
if (ln_mqtt_api_get_udp_info(&udp_info) != 0) {
- printf("[LN_UDP] UDP info not available, cannot create socket\n");
+ LN_MQTT_WARN("UDP info not available, cannot create socket\n");
return -1;
}
if (!udp_info.valid) {
- printf("[LN_UDP] UDP info invalid, cannot create socket\n");
+ LN_MQTT_WARN("UDP info invalid, cannot create socket\n");
return -1;
}
- printf("[LN_UDP] Creating UDP socket for server: %s:%d\n", udp_info.server, udp_info.port);
+ LN_MQTT_INFO("Creating UDP socket for server: %s:%d\n", udp_info.server, udp_info.port);
// 如果socket已存在，先关闭
if (g_udp_socket >= 0) {
- printf("[LN_UDP] Closing existing UDP socket\n");
+ LN_MQTT_DEBUG("Closing existing UDP socket\n");
ln_udp_close_socket();
}
// 创建UDP套接字（复用仅创建 fd 的逻辑）
g_udp_socket = ln_udp_create_socket_fd_only();
if (g_udp_socket < 0) {
- printf("[LN_UDP] Failed to create UDP socket: %s\n", strerror(errno));
+ LN_MQTT_ERROR("Failed to create UDP socket: %s\n", strerror(errno));
return -1;
}
- printf("[LN_UDP] UDP socket created successfully, fd=%d\n", g_udp_socket);
+ LN_MQTT_INFO("UDP socket created successfully, fd=%d\n", g_udp_socket);
// 创建接收线程
if (!g_udp_thread_running) {
g_udp_thread_running = true;
errcode_t ret = uapi_create_osThread_custom_with_args(&recv_task);
if (ret != ERRCODE_SUCC) {
- printf("[LN_UDP] ERROR: Failed to create receive thread: %d\n", ret);
+ LN_MQTT_ERROR("Failed to create receive thread: %d\n", ret);
g_udp_thread_running = false;
lwip_close(g_udp_socket);
g_udp_socket = -1;
return -1;
}
- printf("[LN_UDP] Receive thread created successfully\n");
+ LN_MQTT_INFO("Receive thread created successfully\n");
}
return 0;
// 停止接收线程
if (g_udp_thread_running) {
- printf("[LN_UDP] Stopping receive thread\n");
+ LN_MQTT_INFO("Stopping receive thread\n");
g_udp_thread_running = false;
// 等待线程退出（最多等待2秒）
}
if (g_udp_thread_handle != 0) {
- printf("[LN_UDP] WARNING: Receive thread did not exit in time\n");
+ LN_MQTT_WARN("Receive thread did not exit in time\n");
}
g_udp_thread_handle = 0;
// 关闭套接字
if (g_udp_socket >= 0) {
- printf("[LN_UDP] Closing UDP socket, fd=%d\n", g_udp_socket);
+ LN_MQTT_DEBUG("Closing UDP socket, fd=%d\n", g_udp_socket);
lwip_close(g_udp_socket);
g_udp_socket = -1;
}
size_t hex_len = strlen(hex_str);
if (hex_len % 2 != 0 || hex_len / 2 > output_size) {
- printf("[LN_UDP] Invalid hex string length: %zu\n", hex_len);
+ LN_MQTT_WARN("Invalid hex string length: %zu\n", hex_len);
return -1;
}
char *endptr;
unsigned long val = strtoul(hex_byte, &endptr, 16);
if (*endptr != '\0' || val > 255) {
- printf("[LN_UDP] Invalid hex character at position %zu\n", i);
+ LN_MQTT_WARN("Invalid hex character at position %zu\n", i);
return -1;
}
output[i / 2] = (uint8_t)val;
const uint8_t *audio_data, uint16_t audio_len, uint8_t *encrypted_data)
{
if (!key_hex || !base_nonce_hex || !audio_data || !encrypted_data || audio_len == 0) {
- printf("[LN_UDP] Invalid parameters for encryption\n");
+ LN_MQTT_WARN("Invalid parameters for encryption\n");
return -1;
}
// 转换密钥（32字符十六进制 = 16字节）
uint8_t key[16];
if (hex_string_to_bytes(key_hex, key, sizeof(key)) != 16) {
- printf("[LN_UDP] Failed to convert key from hex\n");
+ LN_MQTT_ERROR("Failed to convert key from hex\n");
return -1;
}
// 转换基础nonce（32字符十六进制 = 16字节）
uint8_t base_nonce[16];
if (hex_string_to_bytes(base_nonce_hex, base_nonce, sizeof(base_nonce)) != 16) {
- printf("[LN_UDP] Failed to convert base nonce from hex\n");
+ LN_MQTT_ERROR("Failed to convert base nonce from hex\n");
return -1;
}
// 设置AES-128密钥（128位 = 16字节）
if (mbedtls_aes_setkey_enc(&aes_ctx, key, 128) != 0) {
- printf("[LN_UDP] Failed to set AES key\n");
+ LN_MQTT_ERROR("Failed to set AES key\n");
mbedtls_aes_free(&aes_ctx);
return -1;
}
size_t nc_off = 0; // nonce counter offset（CTR模式内部使用）
uint8_t stream_block[16] = {0}; // stream block（CTR模式内部使用）
- printf("nonce_counter: ");
+ LN_MQTT_DEBUG("nonce_counter: ");
for (int i = 0; i < 16; i++) {
- printf("%02x ", nonce_counter[i]);
+ LN_MQTT_DEBUG("%02x ", nonce_counter[i]);
}
- printf("\n");
+ LN_MQTT_DEBUG("\n");
if (mbedtls_aes_crypt_ctr(&aes_ctx, audio_len, &nc_off, nonce_counter, stream_block,
audio_data, encrypted_data) != 0) {
- printf("[LN_UDP] Failed to encrypt audio data with AES-CTR\n");
+ LN_MQTT_ERROR("Failed to encrypt audio data with AES-CTR\n");
mbedtls_aes_free(&aes_ctx);
return -1;
}
uint8_t *buffer, uint16_t buffer_size, uint16_t *out_len)
{
if (!audio_data || audio_len == 0 || !buffer || !out_len) {
- printf("[LN_UDP] Invalid parameters for pack audio data\n");
+ LN_MQTT_WARN("Invalid parameters for pack audio data\n");
return -1;
}
// 计算所需缓冲区大小
uint16_t total_len = UDP_PACKET_HEADER_SIZE + audio_len;
if (buffer_size < total_len) {
- printf("[LN_UDP] Buffer too small: need %d, have %d\n", total_len, buffer_size);
+ LN_MQTT_WARN("Buffer too small: need %d, have %d\n", total_len, buffer_size);
return -1;
}
// 1. 获取UDP信息（用于加密）
ln_mqtt_udp_info_t udp_info;
if (ln_mqtt_api_get_udp_info(&udp_info) != 0 || !udp_info.valid) {
- printf("[LN_UDP] UDP info not available for encryption\n");
+ LN_MQTT_WARN("UDP info not available for encryption\n");
return -1;
}
// 01 00 00 00 1d 38 db 20 69 70 a0 da 00000000
((uint32_t)nonce_bytes[5] << 16) |
((uint32_t)nonce_bytes[6] << 8) |
((uint32_t)nonce_bytes[7]);
- printf("[LN_UDP] SSRC initialized from nonce bytes[4-7]: 0x%02X%02X%02X%02X -> 0x%08X\n",
+ LN_MQTT_DEBUG("SSRC initialized from nonce bytes[4-7]: 0x%02X%02X%02X%02X -> 0x%08X\n",
nonce_bytes[4], nonce_bytes[5], nonce_bytes[6], nonce_bytes[7], g_udp_ssrc);
} else {
- printf("[LN_UDP] Failed to convert nonce to bytes, using default SSRC\n");
+ LN_MQTT_WARN("Failed to convert nonce to bytes, using default SSRC\n");
g_udp_ssrc = 0x12345678;
}
}
uint8_t *encrypted_payload = buffer + UDP_PACKET_HEADER_SIZE;
if (ln_udp_encrypt_audio(udp_info.key, udp_info.nonce, audio_len, timestamp, sequence,
audio_data, audio_len, encrypted_payload) != 0) {
- printf("[LN_UDP] Failed to encrypt audio data\n");
+ LN_MQTT_ERROR("Failed to encrypt audio data\n");
return -1;
}
*out_len = total_len;
- printf( "buffer: ");
+ LN_MQTT_DEBUG("buffer: ");
for (int i = 0; i < 16; i++) {
- printf("%02x ", buffer[i]);
+ LN_MQTT_DEBUG("%02x ", buffer[i]);
}
- printf("\n");
+ LN_MQTT_DEBUG("\n");
- printf("[LN_UDP] Audio data packed: type=%d, flags=%d, ssrc=0x%08X, timestamp=%u, sequence=%u, payload_len=%d, total_len=%d\n",
+ LN_MQTT_DEBUG("Audio data packed: type=%d, flags=%d, ssrc=0x%08X, timestamp=%u, sequence=%u, payload_len=%d, total_len=%d\n",
type, flags, g_udp_ssrc, timestamp, sequence, audio_len, total_len);
return 0;
if (osal_msg_queue_create("ln_udp_audio_send_queue", AUDIO_SEND_QUEUE_SIZE, &g_audio_send_queue,
0, sizeof(audio_send_msg_t)) != ERRCODE_SUCC) {
- printf("[LN_UDP] Failed to create audio send queue\n");
+ LN_MQTT_ERROR("Failed to create audio send queue\n");
g_audio_send_queue = 0xFFFFFFFF;
} else {
- printf("[LN_UDP] Audio send queue created successfully\n");
+ LN_MQTT_INFO("Audio send queue created successfully\n");
}
}
uint16_t out_len = 0;
if (ln_udp_pack_audio_data(audio_data, (uint16_t)audio_size, send_buf,
(uint16_t)sizeof(send_buf), &out_len) != 0) {
- printf("[LN_UDP] Failed to pack audio frame\n");
+ LN_MQTT_ERROR("Failed to pack audio frame\n");
return -1;
}
// 获取UDP信息（用于发送）
ln_mqtt_udp_info_t udp_info;
if (ln_mqtt_api_get_udp_info(&udp_info) != 0 || !udp_info.valid) {
- printf("[LN_UDP] UDP info not available, drop audio frame\n");
+ LN_MQTT_WARN("UDP info not available, drop audio frame\n");
return -1;
}
ssize_t sent = lwip_sendto(sock, send_buf, out_len, 0,
(struct sockaddr *)&server_addr, sizeof(server_addr));
if (sent < 0) {
- printf("[LN_UDP] UDP sendto failed: %s\n", strerror(errno));
+ LN_MQTT_ERROR("UDP sendto failed: %s\n", strerror(errno));
return -1;
}
audio_send_msg_t msg;
uint32_t msgsize = sizeof(audio_send_msg_t);
- printf("[LN_UDP] Audio send thread started\n");
+ LN_MQTT_INFO("Audio send thread started\n");
while (g_audio_send_thread_running) {
// 从队列读取音频数据（阻塞等待）
int32_t ret = osal_msg_queue_read_copy(g_audio_send_queue, (void *)&msg, &msgsize,
OSAL_MSGQ_WAIT_FOREVER);
if (ret != OSAL_SUCCESS) {
- printf("[LN_UDP] Failed to read from audio send queue: %d\n", ret);
+ LN_MQTT_ERROR("Failed to read from audio send queue: %d\n", ret);
continue;
}
// 检查数据大小和数据指针
if (msg.size == 0 || msg.size > AUDIO_SEND_MAX_DATA_SIZE || msg.data == NULL) {
- printf("[LN_UDP] Invalid audio data: size=%u, data=%p\n", msg.size, msg.data);
+ LN_MQTT_WARN("Invalid audio data: size=%u, data=%p\n", msg.size, msg.data);
// 释放内存（如果存在）
if (msg.data != NULL) {
free(msg.data);
// 确保 UDP socket 已创建
if (!ln_udp_is_socket_created()) {
- printf("[LN_UDP] UDP socket not ready, drop audio frame\n");
+ LN_MQTT_WARN("UDP socket not ready, drop audio frame\n");
free(msg.data);
continue;
}
int sock = ln_udp_get_socket();
if (sock < 0) {
- printf("[LN_UDP] UDP socket invalid, drop audio frame\n");
+ LN_MQTT_WARN("UDP socket invalid, drop audio frame\n");
free(msg.data);
continue;
}
if (msg.encoding == AUDIO_SEND_ENCODING_PCM) {
/* PCM：追加到缓存，按 60ms 切割编码，余量保留 */
if (g_pcm_send_cache == NULL) {
- printf("[LN_UDP] PCM cache not allocated, drop %u bytes\n", msg.size);
+ LN_MQTT_WARN("PCM cache not allocated, drop %u bytes\n", msg.size);
free(msg.data);
continue;
}
memmove(g_pcm_send_cache, g_pcm_send_cache + AUDIO_SEND_PCM_FRAME_BYTES, g_pcm_send_cache_size);
}
if (g_pcm_send_cache_size + msg.size > g_pcm_send_cache_capacity) {
- printf("[LN_UDP] PCM cache full, drop %u bytes (cache=%u, cap=%u)\n", msg.size, g_pcm_send_cache_size, g_pcm_send_cache_capacity);
+ LN_MQTT_WARN("PCM cache full, drop %u bytes (cache=%u, cap=%u)\n", msg.size, g_pcm_send_cache_size, g_pcm_send_cache_capacity);
free(msg.data);
continue;
}
while (g_pcm_send_cache_size >= AUDIO_SEND_PCM_FRAME_BYTES) {
int encoded_len = 0;
- printf("[LN_UDP] PCM send cache size: %d\n", g_pcm_send_cache_size);
+ LN_MQTT_DEBUG("PCM send cache size: %d\n", g_pcm_send_cache_size);
for (int i = 0; i < AUDIO_SEND_PCM_FRAME_BYTES; i++) {
- printf("%02x ", g_pcm_send_cache[i]);
+ LN_MQTT_DEBUG("%02x ", g_pcm_send_cache[i]);
}
- printf("\n");
+ LN_MQTT_DEBUG("\n");
if (opus_pcm_to_frame_encode_packet(
(const short *)g_pcm_send_cache, AUDIO_SEND_PCM_FRAME_SAMPLES,
AUDIO_SEND_PCM_SAMPLE_RATE, AUDIO_SEND_PCM_CHANNELS,
AUDIO_SEND_PCM_BITRATE, AUDIO_SEND_PCM_APPLICATION,
opus_buf, (int)sizeof(opus_buf), &encoded_len) != 0) {
- printf("[LN_UDP] PCM to Opus encode failed, drop 60ms frame\n");
+ LN_MQTT_WARN("PCM to Opus encode failed, drop 60ms frame\n");
break;
}
- printf("[LN_UDP] Opus encoded len: %d\n", encoded_len);
- printf("[LN_UDP] Opus encoded data: ");
+ LN_MQTT_DEBUG("Opus encoded len: %d\n", encoded_len);
+ LN_MQTT_DEBUG("Opus encoded data: ");
for (int i = 0; i < encoded_len; i++) {
- printf("%02x ", opus_buf[i]);
+ LN_MQTT_DEBUG("%02x ", opus_buf[i]);
}
- printf("\n");
+ LN_MQTT_DEBUG("\n");
if (ln_udp_send_audio_frame(sock, opus_buf, (uint32_t)encoded_len) != 0) {
break;
}
msg.data = NULL;
}
- printf("[LN_UDP] Audio send thread exited\n");
+ LN_MQTT_INFO("Audio send thread exited\n");
g_audio_send_thread_running = false;
}
if (g_pcm_send_cache == NULL) {
g_pcm_send_cache = (uint8_t *)malloc(AUDIO_SEND_PCM_CACHE_ALLOC_SIZE);
if (g_pcm_send_cache == NULL) {
- printf("[LN_UDP] Failed to allocate PCM send cache (%u bytes)\n", (unsigned)AUDIO_SEND_PCM_CACHE_ALLOC_SIZE);
+ LN_MQTT_ERROR("Failed to allocate PCM send cache (%u bytes)\n", (unsigned)AUDIO_SEND_PCM_CACHE_ALLOC_SIZE);
return -1;
}
g_pcm_send_cache_capacity = AUDIO_SEND_PCM_CACHE_ALLOC_SIZE;
g_pcm_send_cache_size = 0;
- printf("[LN_UDP] PCM send cache allocated: %u bytes\n", g_pcm_send_cache_capacity);
+ LN_MQTT_DEBUG("PCM send cache allocated: %u bytes\n", g_pcm_send_cache_capacity);
}
// 创建消息队列
create_audio_send_queue();
if (g_audio_send_queue == 0xFFFFFFFF) {
- printf("[LN_UDP] Failed to create audio send queue\n");
+ LN_MQTT_ERROR("Failed to create audio send queue\n");
if (g_pcm_send_cache != NULL) {
free(g_pcm_send_cache);
g_pcm_send_cache = NULL;
g_audio_send_thread_running = true;
errcode_t ret = uapi_create_osThread_custom_with_args(&send_task);
if (ret != ERRCODE_SUCC) {
- printf("[LN_UDP] ERROR: Failed to create audio send thread: %d\n", ret);
+ LN_MQTT_ERROR("Failed to create audio send thread: %d\n", ret);
g_audio_send_thread_running = false;
return -1;
}
- printf("[LN_UDP] Audio send thread created successfully\n");
+ LN_MQTT_INFO("Audio send thread created successfully\n");
}
return 0;
}
// 停止发送线程
if (g_audio_send_thread_running) {
- printf("[LN_UDP] Stopping audio send thread\n");
+ LN_MQTT_INFO("Stopping audio send thread\n");
g_audio_send_thread_running = false;
// 发送一个空消息唤醒线程（如果队列为空）
}
if (g_audio_send_thread_handle != 0) {
- printf("[LN_UDP] WARNING: Audio send thread did not exit in time\n");
+ LN_MQTT_WARN("Audio send thread did not exit in time\n");
}
g_audio_send_thread_handle = 0;
if (g_audio_send_queue != 0xFFFFFFFF) {
osal_msg_queue_delete(g_audio_send_queue);
g_audio_send_queue = 0xFFFFFFFF;
- printf("[LN_UDP] Audio send queue deleted\n");
+ LN_MQTT_DEBUG("Audio send queue deleted\n");
}
}
int ln_udp_audio_send_enqueue(const uint8_t *data, uint32_t size, uint8_t encoding)
{
if (!data || size == 0 || size > AUDIO_SEND_MAX_DATA_SIZE) {
- printf("[LN_UDP] Invalid parameters for audio send enqueue\n");
+ LN_MQTT_WARN("Invalid parameters for audio send enqueue\n");
return -1;
}
if (g_audio_send_queue == 0xFFFFFFFF) {
- printf("[LN_UDP] Audio send queue not initialized\n");
+ LN_MQTT_WARN("Audio send queue not initialized\n");
return -1;
}
// 动态分配内存并复制数据
uint8_t *data_copy = (uint8_t *)malloc(size);
if (data_copy == NULL) {
- printf("[LN_UDP] Failed to allocate memory for audio data\n");
+ LN_MQTT_ERROR("Failed to allocate memory for audio data\n");
return -1;
}
memcpy(data_copy, data, size);
// 写入队列（非阻塞，如果队列满则丢弃并释放内存）
int32_t ret = osal_msg_queue_write_copy(g_audio_send_queue, (void *)&msg, sizeof(audio_send_msg_t), 0);
if (ret != OSAL_SUCCESS) {
- printf("[LN_UDP] Failed to enqueue audio data: %d (queue may be full)\n", ret);
+ LN_MQTT_WARN("Failed to enqueue audio data: %d (queue may be full)\n", ret);
free(data_copy); // 队列满时释放内存
return -1;
}
#define LN_MQTT_SEND_TOPIC "device-server-enhanced"
+/* LN_MQTT 日志等级变量（默认 INFO） */
+ln_mqtt_log_level_t g_ln_mqtt_log_level = LN_MQTT_LOG_INFO;
+
+void ln_mqtt_set_log_level(uint8_t level)
+{
+ if (level <= LN_MQTT_LOG_DEBUG) {
+ g_ln_mqtt_log_level = (ln_mqtt_log_level_t)level;
+ }
+}
+
/* 测试性录音数据保存到文件：1=启用，0=禁用。启用后每次开始录音创建新文件，停止时关闭。 */
#ifndef LN_MQTT_RECORD_SAVE_TO_FILE_TEST
#define LN_MQTT_RECORD_SAVE_TO_FILE_TEST 1
uint32_t elapsed_ms = current_tick - g_mqtt_vad_cooldown_start_tick;
if (elapsed_ms >= g_mqtt_vad_cooldown_duration_ms) {
g_mqtt_vad_cooldown_active = false;
- printf("[LN_MQTT_API] VAD cooldown period ended\n");
+ LN_MQTT_DEBUG("VAD cooldown period ended\n");
return false;
}
return true;
{
g_mqtt_vad_cooldown_start_tick = osKernelGetTickCount();
g_mqtt_vad_cooldown_active = true;
- printf("[LN_MQTT_API] VAD cooldown started, duration: %u ms\n", g_mqtt_vad_cooldown_duration_ms);
+ LN_MQTT_DEBUG("VAD cooldown started, duration: %u ms\n", g_mqtt_vad_cooldown_duration_ms);
}
/**
*/
static void vad_status_callback_ln_mqtt(int status)
{
- printf("[LN_MQTT_API] VAD status callback: %d\n", status);
+ LN_MQTT_DEBUG("VAD status callback: %d\n", status);
if (!g_mqtt_vad_server_enabled) {
return;
}
if (status == 1) {
if (ln_mqtt_is_vad_cooldown_active()) {
- printf("[LN_MQTT_API] VAD cooldown active, ignoring start request\n");
+ LN_MQTT_DEBUG("VAD cooldown active, ignoring start request\n");
return;
}
(void)ln_mqtt_api_send_listen_state(true);
{
#if USE_DUAL_STREAM_INTERFACE
if (g_mqtt_audio_initialized) {
- printf("[LN_MQTT_API] Audio already initialized, skipping duplicate initialization\n");
+ LN_MQTT_DEBUG("Audio already initialized, skipping duplicate initialization\n");
return;
}
- printf("[LN_MQTT_API] Initializing audio with old_Start_AIVoice dual stream interface\n");
+ LN_MQTT_INFO("Initializing audio with old_Start_AIVoice dual stream interface\n");
if (AI_IsVoiceServiceRunning()) {
- printf("[LN_MQTT_API] AI voice service already running, stopping it first\n");
+ LN_MQTT_INFO("AI voice service already running, stopping it first\n");
StopAIVoice();
}
);
if (start_ret != 0) {
- printf("[LN_MQTT_API] WARNING: old_Start_AIVoice failed: %d\n", (int)start_ret);
+ LN_MQTT_WARN("old_Start_AIVoice failed: %d\n", (int)start_ret);
return;
}
g_mqtt_audio_initialized = true;
- printf("[LN_MQTT_API] old_Start_AIVoice initialized successfully (SBC, 16kHz, mono)\n");
+ LN_MQTT_INFO("old_Start_AIVoice initialized successfully (SBC, 16kHz, mono)\n");
#if defined(ENABLE_VAD_SERVER) && ENABLE_VAD_SERVER
/* 初始化 VAD 服务器（参考 ln_api_websocket.c ln_ws_audio_init） */
g_mqtt_vad_server_enabled = true;
if (!g_mqtt_vad_server_initialized) {
- printf("[LN_MQTT_API] Initializing VAD server...\n");
+ LN_MQTT_INFO("Initializing VAD server...\n");
errcode_t ret = vad_server_init(vad_status_callback_ln_mqtt);
if (ret == ERRCODE_SUCC) {
g_mqtt_vad_server_initialized = true;
- printf("[LN_MQTT_API] VAD server initialized successfully\n");
+ LN_MQTT_INFO("VAD server initialized successfully\n");
if (g_mqtt_message_callback != NULL) {
g_mqtt_message_callback(NULL, WS_CMD_VAD_INITIALIZED);
}
} else {
- printf("[LN_MQTT_API] Failed to initialize VAD server: %d\n", (int)ret);
+ LN_MQTT_ERROR("Failed to initialize VAD server: %d\n", (int)ret);
}
}
#endif /* ENABLE_VAD_SERVER */
#if defined(ENABLE_VAD_SERVER) && ENABLE_VAD_SERVER
if (g_mqtt_vad_server_initialized) {
- printf("[LN_MQTT_API] Deinitializing VAD server...\n");
+ LN_MQTT_INFO("Deinitializing VAD server...\n");
errcode_t ret = vad_server_deinit();
if (ret == ERRCODE_SUCC) {
g_mqtt_vad_server_initialized = false;
- printf("[LN_MQTT_API] VAD server deinitialized successfully\n");
+ LN_MQTT_INFO("VAD server deinitialized successfully\n");
} else {
- printf("[LN_MQTT_API] Failed to deinitialize VAD server: %d\n", (int)ret);
+ LN_MQTT_ERROR("Failed to deinitialize VAD server: %d\n", (int)ret);
}
}
g_mqtt_vad_server_enabled = false;
g_recording_upload_started = false;
if (AI_IsVoiceServiceRunning()) {
(void)StopAIVoice();
- printf("[LN_MQTT_API] AI voice service stopped\n");
+ LN_MQTT_INFO("AI voice service stopped\n");
}
g_mqtt_audio_initialized = false;
- printf("[LN_MQTT_API] Audio deinitialized\n");
+ LN_MQTT_INFO("Audio deinitialized\n");
#ifdef SUPPORT_CAT1_SERVICE
cat1_api_keep_wakeup(0);
}
g_record_test_file = fopen(filename, "wb");
if (g_record_test_file) {
- printf("[LN_MQTT_API] Test save file opened: %s\n", filename);
+ LN_MQTT_DEBUG("Test save file opened: %s\n", filename);
} else {
- printf("[LN_MQTT_API] Failed to open test save file: %s\n", filename);
+ LN_MQTT_ERROR("Failed to open test save file: %s\n", filename);
}
}
if (g_record_test_file) {
fclose(g_record_test_file);
g_record_test_file = NULL;
- printf("[LN_MQTT_API] Test save file closed\n");
+ LN_MQTT_DEBUG("Test save file closed\n");
}
}
#endif /* LN_MQTT_RECORD_SAVE_TO_FILE_TEST */
return;
}
if (size > LN_MQTT_RECORD_MAX_FRAME) {
- printf("[LN_MQTT_API] Record frame too large: %u\n", (unsigned)size);
+ LN_MQTT_WARN("Record frame too large: %u\n", (unsigned)size);
return;
}
{
uint32_t len=1024*3;
AI_SecondStreamInObtainBuffer(pcm_data, &len);
- printf("vad_server_send_audio size %d\r\n",len);
+ LN_MQTT_DEBUG("vad_server_send_audio size %d\r\n", len);
(void)vad_server_send_audio(VAD_AUDIO_FORMAT_PCM, pcm_data, len, false);
free(pcm_data);
}
- printf("vad_server_send_audio size %d\r\n",size);
+ LN_MQTT_DEBUG("vad_server_send_audio size %d\r\n", size);
(void)vad_server_send_audio(VAD_AUDIO_FORMAT_PCM, data, size, false);
}
}
#endif /* USE_DUAL_STREAM_INTERFACE */
- printf("ln_mqtt_record_data_cb size %d\r\n",size);
+ LN_MQTT_DEBUG("ln_mqtt_record_data_cb size %d\r\n", size);
#if LN_MQTT_RECORD_SAVE_TO_FILE_TEST
/* 测试性保存到文件：首次写入时打开，之后追加 */
if (g_record_test_file != NULL && size > 0) {
size_t n = fwrite(data, 1, (size_t)size, g_record_test_file);
if (n != (size_t)size) {
- printf("[LN_MQTT_API] Test file write incomplete: %zu/%u\n", n, (unsigned)size);
+ LN_MQTT_WARN("Test file write incomplete: %zu/%u\n", n, (unsigned)size);
}
}
#endif /* LN_MQTT_RECORD_SAVE_TO_FILE_TEST */
uint32_t initial_size = LN_MQTT_RECORD_MAX_FRAME * LN_MQTT_RECORD_BATCH_SIZE;
g_record_cache.buffer = (uint8_t *)malloc(initial_size);
if (g_record_cache.buffer == NULL) {
- printf("[LN_MQTT_API] Failed to allocate cache buffer, drop frame\n");
+ LN_MQTT_ERROR("Failed to allocate cache buffer, drop frame\n");
return;
}
g_record_cache.buffer_size = initial_size;
g_record_cache.current_size = 0;
g_record_cache.packet_count = 0;
- printf("[LN_MQTT_API] Cache buffer allocated: %u bytes\n", initial_size);
+ LN_MQTT_DEBUG("Cache buffer allocated: %u bytes\n", initial_size);
}
// 检查缓存是否足够大，如果不够则扩容
if (g_record_cache.current_size + size > g_record_cache.buffer_size) {
- printf("[LN_MQTT_API] Cache overflow, force flush: current=%u, new=%u, max=%u\n",
+ LN_MQTT_DEBUG("Cache overflow, force flush: current=%u, new=%u, max=%u\n",
g_record_cache.current_size, size, g_record_cache.buffer_size);
// 如果缓存已满，强制刷新当前缓存
if (g_record_cache.current_size > 0) {
if (ln_udp_audio_send_enqueue(g_record_cache.buffer, g_record_cache.current_size, AUDIO_SEND_ENCODING_OPUS) != 0) {
- printf("[LN_MQTT_API] Failed to enqueue cached audio data\n");
+ LN_MQTT_ERROR("Failed to enqueue cached audio data\n");
}
g_record_cache.current_size = 0;
g_record_cache.packet_count = 0;
if (g_record_cache.packet_count >= LN_MQTT_RECORD_BATCH_SIZE) {
if (ln_udp_audio_send_enqueue(g_record_cache.buffer, g_record_cache.current_size, AUDIO_SEND_ENCODING_OPUS) != 0)
{
- printf("[LN_MQTT_API] Failed to enqueue batched audio data, drop frame\n");
+ LN_MQTT_ERROR("Failed to enqueue batched audio data, drop frame\n");
} else {
- printf("[LN_MQTT_API] Enqueued %u packets, total size: %u bytes\n",
+ LN_MQTT_DEBUG("Enqueued %u packets, total size: %u bytes\n",
g_record_cache.packet_count, g_record_cache.current_size);
}
// 清空缓存
}
#else
if (ln_udp_audio_send_enqueue(data, size, AUDIO_SEND_ENCODING_OPUS) != 0) {
- printf("[LN_MQTT_API] Failed to enqueue audio data, drop frame\n");
+ LN_MQTT_ERROR("Failed to enqueue audio data, drop frame\n");
} else {
- printf("[LN_MQTT_API] Enqueued %u bytes of audio data\n", size);
+ LN_MQTT_DEBUG("Enqueued %u bytes of audio data\n", size);
}
#endif
#if USE_DUAL_STREAM_INTERFACE
// 确保字符串以null结尾
char *json_str = (char *)malloc(len + 1);
if (!json_str) {
- printf("[LN_MQTT_API] Failed to allocate memory for JSON string\n");
+ LN_MQTT_ERROR("Failed to allocate memory for JSON string\n");
return -1;
}
memcpy(json_str, data, len);
if (!root) {
const char *error_ptr = cJSON_GetErrorPtr();
if (error_ptr != NULL) {
- printf("[LN_MQTT_API] JSON parse error: %s\n", error_ptr);
+ LN_MQTT_ERROR("JSON parse error: %s\n", error_ptr);
}
free(json_str);
return -1;
// 获取type字段
cJSON *type_item = cJSON_GetObjectItemCaseSensitive(root, "type");
if (!cJSON_IsString(type_item)) {
- printf("[LN_MQTT_API] No 'type' field or invalid type field in message\n");
+ LN_MQTT_WARN("No 'type' field or invalid type field in message\n");
cJSON_Delete(root);
free(json_str);
return -1;
}
const char *type_value = type_item->valuestring;
- printf("[LN_MQTT_API] Message type detected: %s\n", type_value);
+ LN_MQTT_DEBUG("Message type detected: %s\n", type_value);
- printf("[LN_MQTT_API] Message: %s\n", json_str);
+ LN_MQTT_DEBUG("Message: %s\n", json_str);
// 根据type值调用相应的处理函数
int ret = -1;
ln_udp_create_socket();
}
} else {
- printf("[LN_MQTT_API] Unknown message type: %s, skipping\n", type_value);
+ LN_MQTT_DEBUG("Unknown message type: %s, skipping\n", type_value);
}
cJSON_Delete(root);
static int ln_mqtt_handle_hello_message(const char *data)
{
if (!data) {
- printf("[LN_MQTT_API] Invalid data for parsing hello message\n");
+ LN_MQTT_WARN("Invalid data for parsing hello message\n");
return -1;
}
if (!root) {
const char *error_ptr = cJSON_GetErrorPtr();
if (error_ptr != NULL) {
- printf("[LN_MQTT_API] JSON parse error: %s\n", error_ptr);
+ LN_MQTT_ERROR("JSON parse error: %s\n", error_ptr);
}
return -1;
}
- printf("[LN_MQTT_API] Parsing hello message...\n");
+ LN_MQTT_DEBUG("Parsing hello message...\n");
// 提取并保存 session_id（供后续 listen 消息使用）
cJSON *session_id_item = cJSON_GetObjectItemCaseSensitive(root, "session_id");
strncpy(g_ln_mqtt_session_id, session_id_item->valuestring, sizeof(g_ln_mqtt_session_id) - 1);
g_ln_mqtt_session_id[sizeof(g_ln_mqtt_session_id) - 1] = '\0';
g_ln_mqtt_session_id_valid = true;
- printf("[LN_MQTT_API] session_id saved: %s\n", g_ln_mqtt_session_id);
+ LN_MQTT_DEBUG("session_id saved: %s\n", g_ln_mqtt_session_id);
} else {
// 不直接失败：UDP 信息可能仍然有效
g_ln_mqtt_session_id[0] = '\0';
g_ln_mqtt_session_id_valid = false;
- printf("[LN_MQTT_API] WARNING: session_id missing or invalid in hello message\n");
+ LN_MQTT_WARN("session_id missing or invalid in hello message\n");
}
// 解析UDP信息
if (cJSON_IsString(server_item)) {
strncpy(g_udp_info.server, server_item->valuestring, sizeof(g_udp_info.server) - 1);
g_udp_info.server[sizeof(g_udp_info.server) - 1] = '\0';
- printf("[LN_MQTT_API] UDP server: %s\n", g_udp_info.server);
+ LN_MQTT_DEBUG("UDP server: %s\n", g_udp_info.server);
}
// 解析port
cJSON *port_item = cJSON_GetObjectItemCaseSensitive(udp_item, "port");
if (cJSON_IsNumber(port_item)) {
g_udp_info.port = (uint16_t)port_item->valueint;
- printf("[LN_MQTT_API] UDP port: %d\n", g_udp_info.port);
+ LN_MQTT_DEBUG("UDP port: %d\n", g_udp_info.port);
}
// 解析encryption
if (cJSON_IsString(encryption_item)) {
strncpy(g_udp_info.encryption, encryption_item->valuestring, sizeof(g_udp_info.encryption) - 1);
g_udp_info.encryption[sizeof(g_udp_info.encryption) - 1] = '\0';
- printf("[LN_MQTT_API] UDP encryption: %s\n", g_udp_info.encryption);
+ LN_MQTT_DEBUG("UDP encryption: %s\n", g_udp_info.encryption);
}
// 解析key
if (cJSON_IsString(key_item)) {
strncpy(g_udp_info.key, key_item->valuestring, sizeof(g_udp_info.key) - 1);
g_udp_info.key[sizeof(g_udp_info.key) - 1] = '\0';
- printf("[LN_MQTT_API] UDP key: %s\n", g_udp_info.key);
+ LN_MQTT_DEBUG("UDP key: %s\n", g_udp_info.key);
}
// 解析nonce
if (cJSON_IsString(nonce_item)) {
strncpy(g_udp_info.nonce, nonce_item->valuestring, sizeof(g_udp_info.nonce) - 1);
g_udp_info.nonce[sizeof(g_udp_info.nonce) - 1] = '\0';
- printf("[LN_MQTT_API] UDP nonce: %s\n", g_udp_info.nonce);
+ LN_MQTT_DEBUG("UDP nonce: %s\n", g_udp_info.nonce);
}
// 标记信息有效
if (g_udp_info.server[0] != '\0' && g_udp_info.port > 0) {
g_udp_info.valid = true;
- printf("[LN_MQTT_API] UDP info saved successfully\n");
+ LN_MQTT_INFO("UDP info saved successfully\n");
} else {
- printf("[LN_MQTT_API] WARNING: UDP info incomplete (server or port missing)\n");
+ LN_MQTT_WARN("UDP info incomplete (server or port missing)\n");
}
} else {
- printf("[LN_MQTT_API] No UDP information in hello message\n");
+ LN_MQTT_DEBUG("No UDP information in hello message\n");
}
if (g_mqtt_message_callback != NULL) {
{
char client_id[256] = {0};
if (uapi_mqtt_get_client_id(client_id, sizeof(client_id)) != 0) {
- printf("[LN_MQTT_API] Warning: client_id not available for auto-subscribe\n");
+ LN_MQTT_WARN("client_id not available for auto-subscribe\n");
return -1;
}
char p2p_topic[256] = {0};
int ret = snprintf(p2p_topic, sizeof(p2p_topic), "devices/p2p/%s", client_id);
if (ret <= 0 || ret >= (int)sizeof(p2p_topic)) {
- printf("[LN_MQTT_API] Failed to construct p2p topic (buffer too small)\n");
+ LN_MQTT_ERROR("Failed to construct p2p topic (buffer too small)\n");
return -1;
}
- printf("[LN_MQTT_API] Auto-subscribing to topic: %s\n", p2p_topic);
+ LN_MQTT_INFO("Auto-subscribing to topic: %s\n", p2p_topic);
int subscribe_ret = uapi_mqtt_subscribe(p2p_topic, 1);
if (subscribe_ret == 0) {
- printf("[LN_MQTT_API] Auto-subscribe request sent successfully\n");
+ LN_MQTT_INFO("Auto-subscribe request sent successfully\n");
return 0;
} else {
- printf("[LN_MQTT_API] Auto-subscribe request failed: %d\n", subscribe_ret);
+ LN_MQTT_ERROR("Auto-subscribe request failed: %d\n", subscribe_ret);
return -1;
}
}
{
(void)arg;
- printf("[LN_MQTT_API] Connection status changed: %d\n", status);
+ LN_MQTT_INFO("Connection status changed: %d\n", status);
// 连接成功时（status == 0 对应 MQTT_CONNECT_ACCEPTED），自动订阅和发送通知
if (status == 0) {
{
(void)arg;
- printf("[LN_MQTT_API] Message received - Topic: %s, Length: %d\n", topic ? topic : "NULL", len);
+ LN_MQTT_DEBUG("Message received - Topic: %s, Length: %d\n", topic ? topic : "NULL", len);
// 统一解析消息，根据type字段分发处理
if (data && len > 0) {
MQTT_ERROR("Failed to load credentials\n");
if(ln_ota_send_device_info_json(NULL, cred) != 0) {
- printf("[LN_MQTT_API] Failed to send device info\n");
+ LN_MQTT_ERROR("Failed to send device info\n");
return -1;
}
else
{
- printf("[LN_MQTT_API] Device info sent successfully\n");
+ LN_MQTT_INFO("Device info sent successfully\n");
}
}
- printf("[LN_MQTT_API] Credentials callback\n");
- printf("[LN_MQTT_API] Credentials: %s\n", cred->endpoint);
- printf("[LN_MQTT_API] Credentials: %s\n", cred->client_id);
- printf("[LN_MQTT_API] Credentials: %s\n", cred->username);
- printf("[LN_MQTT_API] Credentials: %s\n", cred->password);
- printf("[LN_MQTT_API] Credentials: %s\n", cred->publish_topic);
- printf("[LN_MQTT_API] Credentials: %s\n", cred->subscribe_topic);
+ LN_MQTT_DEBUG("Credentials callback\n");
+ LN_MQTT_DEBUG("Credentials: %s\n", cred->endpoint);
+ LN_MQTT_DEBUG("Credentials: %s\n", cred->client_id);
+ LN_MQTT_DEBUG("Credentials: %s\n", cred->username);
+ LN_MQTT_DEBUG("Credentials: %s\n", cred->password);
+ LN_MQTT_DEBUG("Credentials: %s\n", cred->publish_topic);
+ LN_MQTT_DEBUG("Credentials: %s\n", cred->subscribe_topic);
return 0;
}
(void)arg;
if (result == 0) {
- printf("[LN_MQTT_API] Subscribe successful - Topic: %s, QoS: %d\n", topic ? topic : "NULL", qos);
+ LN_MQTT_INFO("Subscribe successful - Topic: %s, QoS: %d\n", topic ? topic : "NULL", qos);
// ln_mqtt_api_send_connection_notification();
ln_mqtt_api_send_hello();
} else {
- printf("[LN_MQTT_API] Subscribe failed - Topic: %s, QoS: %d, Result: %d\n", topic ? topic : "NULL", qos, result);
+ LN_MQTT_ERROR("Subscribe failed - Topic: %s, QoS: %d, Result: %d\n", topic ? topic : "NULL", qos, result);
}
}
g_mqtt_message_callback = callback;
if (callback != NULL) {
- printf("[LN_MQTT_API] Message callback registered\n");
+ LN_MQTT_DEBUG("Message callback registered\n");
}
- printf("[LN_MQTT_API] Starting MQTT service\n");
+ LN_MQTT_INFO("Starting MQTT service\n");
// 构建回调函数结构体，使用内部回调
mqtt_call_backs_t callbacks = {0};
// 初始化音频发送队列和线程
if (ln_udp_audio_send_init() != 0) {
- printf("[LN_MQTT_API] WARNING: Failed to init audio send queue/thread\n");
+ LN_MQTT_WARN("Failed to init audio send queue/thread\n");
// 不影响服务启动，继续执行
}
// ln_mqtt_audio_init();
g_ln_mqtt_service_started = true;
- printf("[LN_MQTT_API] MQTT service started successfully\n");
+ LN_MQTT_INFO("MQTT service started successfully\n");
return 0;
}
return;
}
- printf("[LN_MQTT_API] Stopping MQTT service\n");
+ LN_MQTT_INFO("Stopping MQTT service\n");
// 停止音频发送线程
ln_udp_audio_send_deinit();
if (g_record_cache.buffer != NULL) {
// 如果有剩余数据，先刷新
if (g_record_cache.current_size > 0) {
- printf("[LN_MQTT_API] Flushing remaining cached audio data before service stop\n");
+ LN_MQTT_DEBUG("Flushing remaining cached audio data before service stop\n");
if (ln_udp_audio_send_enqueue(g_record_cache.buffer, g_record_cache.current_size, AUDIO_SEND_ENCODING_OPUS) != 0) {
- printf("[LN_MQTT_API] Failed to enqueue remaining cached audio data\n");
+ LN_MQTT_ERROR("Failed to enqueue remaining cached audio data\n");
}
}
free(g_record_cache.buffer);
g_record_cache.buffer_size = 0;
g_record_cache.current_size = 0;
g_record_cache.packet_count = 0;
- printf("[LN_MQTT_API] Cache buffer freed\n");
+ LN_MQTT_DEBUG("Cache buffer freed\n");
}
// 音频辅助反初始化（双流模式下停止 AI 语音服务）
g_ln_mqtt_service_started = false;
- printf("[LN_MQTT_API] MQTT service stopped\n");
+ LN_MQTT_INFO("MQTT service stopped\n");
}
return -1;
}
- printf("[LN_MQTT_API] Disconnecting MQTT\n");
+ LN_MQTT_INFO("Disconnecting MQTT\n");
int ret = uapi_mqtt_disconnect();
if (ret != 0) {
int ln_mqtt_api_send_connection_notification(void)
{
if (!uapi_mqtt_is_connected()) {
- printf("[LN_MQTT_API] Client not connected, cannot send connection notification\n");
+ LN_MQTT_WARN("Client not connected, cannot send connection notification\n");
return -1;
}
char client_id[256] = {0};
if (uapi_mqtt_get_client_id(client_id, sizeof(client_id)) != 0) {
- printf("[LN_MQTT_API] client_id not available, cannot send connection notification\n");
+ LN_MQTT_WARN("client_id not available, cannot send connection notification\n");
return -1;
}
// 构建JSON数据
cJSON *root = cJSON_CreateObject();
if (!root) {
- printf("[LN_MQTT_API] Failed to create JSON object\n");
+ LN_MQTT_ERROR("Failed to create JSON object\n");
return -1;
}
cJSON *data = cJSON_CreateObject();
if (!data) {
- printf("[LN_MQTT_API] Failed to create data object\n");
+ LN_MQTT_ERROR("Failed to create data object\n");
cJSON_Delete(root);
return -1;
}
char *json_str = cJSON_Print(root);
if (!json_str) {
- printf("[LN_MQTT_API] Failed to create JSON string\n");
+ LN_MQTT_ERROR("Failed to create JSON string\n");
cJSON_Delete(root);
return -1;
}
use_topic = LN_MQTT_SEND_TOPIC; // 使用默认主题
}
- printf("[LN_MQTT_API] Publishing connection notification to topic: %s\n", use_topic);
- printf("[LN_MQTT_API] Message: %s\n", json_str);
+ LN_MQTT_DEBUG("Publishing connection notification to topic: %s\n", use_topic);
+ LN_MQTT_DEBUG("Message: %s\n", json_str);
uint16_t msg_len = (uint16_t)strlen(json_str);
int ret = uapi_mqtt_main_send(use_topic, json_str, msg_len, 1, 0);
cJSON_Delete(root);
if (ret == 0) {
- printf("[LN_MQTT_API] Connection notification queued for sending successfully\n");
+ LN_MQTT_INFO("Connection notification queued for sending successfully\n");
return 0;
} else {
- printf("[LN_MQTT_API] Failed to queue connection notification: %d\n", ret);
+ LN_MQTT_ERROR("Failed to queue connection notification: %d\n", ret);
return -1;
}
}
int ln_mqtt_api_send_hello(void)
{
if (!uapi_mqtt_is_connected()) {
- printf("[LN_MQTT_API] Client not connected, cannot send hello message\n");
+ LN_MQTT_WARN("Client not connected, cannot send hello message\n");
return -1;
}
// 构建JSON数据
cJSON *root = cJSON_CreateObject();
if (!root) {
- printf("[LN_MQTT_API] Failed to create JSON object\n");
+ LN_MQTT_ERROR("Failed to create JSON object\n");
return -1;
}
// 添加 features 对象
cJSON *features = cJSON_CreateObject();
if (!features) {
- printf("[LN_MQTT_API] Failed to create features object\n");
+ LN_MQTT_ERROR("Failed to create features object\n");
cJSON_Delete(root);
return -1;
}
// 添加 audio_params 对象
cJSON *audio_params = cJSON_CreateObject();
if (!audio_params) {
- printf("[LN_MQTT_API] Failed to create audio_params object\n");
+ LN_MQTT_ERROR("Failed to create audio_params object\n");
cJSON_Delete(root);
return -1;
}
char *json_str = cJSON_Print(root);
if (!json_str) {
- printf("[LN_MQTT_API] Failed to create JSON string\n");
+ LN_MQTT_ERROR("Failed to create JSON string\n");
cJSON_Delete(root);
return -1;
}
use_topic = LN_MQTT_SEND_TOPIC; // 使用默认主题
}
- printf("[LN_MQTT_API] Publishing hello message to topic: %s\n", use_topic);
- printf("[LN_MQTT_API] Message: %s\n", json_str);
+ LN_MQTT_DEBUG("Publishing hello message to topic: %s\n", use_topic);
+ LN_MQTT_DEBUG("Message: %s\n", json_str);
uint16_t msg_len = (uint16_t)strlen(json_str);
int ret = uapi_mqtt_main_send(use_topic, json_str, msg_len, 1, 0);
cJSON_Delete(root);
if (ret == 0) {
- printf("[LN_MQTT_API] Hello message queued for sending successfully\n");
+ LN_MQTT_INFO("Hello message queued for sending successfully\n");
return 0;
} else {
- printf("[LN_MQTT_API] Failed to queue hello message: %d\n", ret);
+ LN_MQTT_ERROR("Failed to queue hello message: %d\n", ret);
return -1;
}
}
int ln_mqtt_api_send_listen_state(bool start)
{
if (!uapi_mqtt_is_connected()) {
- printf("[LN_MQTT_API] Client not connected, cannot send listen message\n");
+ LN_MQTT_WARN("Client not connected, cannot send listen message\n");
return -1;
}
if (!g_ln_mqtt_session_id_valid || g_ln_mqtt_session_id[0] == '\0') {
- printf("[LN_MQTT_API] session_id not ready (missing hello?), cannot send listen message\n");
+ LN_MQTT_WARN("session_id not ready (missing hello?), cannot send listen message\n");
return -1;
}
// 构建JSON数据
cJSON *root = cJSON_CreateObject();
if (!root) {
- printf("[LN_MQTT_API] Failed to create JSON object\n");
+ LN_MQTT_ERROR("Failed to create JSON object\n");
return -1;
}
char *json_str = cJSON_Print(root);
if (!json_str) {
- printf("[LN_MQTT_API] Failed to create JSON string\n");
+ LN_MQTT_ERROR("Failed to create JSON string\n");
cJSON_Delete(root);
return -1;
}
use_topic = LN_MQTT_SEND_TOPIC; // 使用默认主题
}
- printf("[LN_MQTT_API] Publishing listen message to topic: %s\n", use_topic);
- printf("[LN_MQTT_API] Message: %s\n", json_str);
+ LN_MQTT_DEBUG("Publishing listen message to topic: %s\n", use_topic);
+ LN_MQTT_DEBUG("Message: %s\n", json_str);
uint16_t msg_len = (uint16_t)strlen(json_str);
int ret = uapi_mqtt_main_send(use_topic, json_str, msg_len, 1, 0);
cJSON_Delete(root);
if (ret != 0) {
- printf("[LN_MQTT_API] Failed to queue listen message: %d\n", ret);
+ LN_MQTT_ERROR("Failed to queue listen message: %d\n", ret);
return -1;
}
- printf("[LN_MQTT_API] Listen message queued for sending successfully\n");
+ LN_MQTT_INFO("Listen message queued for sending successfully\n");
// 发送完成后控制录音：start->开始录音，stop->停止录音
if (start) {
#if USE_DUAL_STREAM_INTERFACE
// 使用 old_Start_AIVoice 双流接口（音频已在服务初始化时启动）
- printf("[LN_MQTT_API] Starting dual stream recording (audio already initialized in service)\n");
+ LN_MQTT_INFO("Starting dual stream recording (audio already initialized in service)\n");
// 检查 AI 语音服务是否运行（应该在服务初始化时已启动）
if (!AI_IsVoiceServiceRunning()) {
- printf("[LN_MQTT_API] WARNING: AI voice service not running, audio should be initialized in service start\n");
+ LN_MQTT_WARN("AI voice service not running, audio should be initialized in service start\n");
return -1;
}
if (g_mqtt_message_callback != NULL) {
g_mqtt_message_callback(NULL, WS_CMD_AUDIO_RECORDING_START);
}
- printf("[LN_MQTT_API] Dual stream recording started, upload enabled\n");
+ LN_MQTT_INFO("Dual stream recording started, upload enabled\n");
#else
// 使用原有 MQTT_StartRecord 接口
MqttRecordAudioParams audioParams = {
int32_t rec_ret = MQTT_StartRecord(ln_mqtt_record_data_cb, NULL, &audioParams);
if (rec_ret != 0) {
- printf("[LN_MQTT_API] WARNING: MQTT_StartRecord failed: %d\n", (int)rec_ret);
+ LN_MQTT_WARN("MQTT_StartRecord failed: %d\n", (int)rec_ret);
} else {
if (g_mqtt_message_callback != NULL) {
g_mqtt_message_callback(NULL, WS_CMD_AUDIO_RECORDING_START);
}
- printf("[LN_MQTT_API] MQTT_StartRecord started with SBC format (16kHz, mono)\n");
+ LN_MQTT_INFO("MQTT_StartRecord started with SBC format (16kHz, mono)\n");
}
#endif /* USE_DUAL_STREAM_INTERFACE */
} else {
// 停止录音前，先刷新缓存中剩余的数据
if (g_record_cache.buffer != NULL && g_record_cache.current_size > 0) {
- printf("[LN_MQTT_API] Flushing remaining cached audio data: %u bytes, %u packets\n",
+ LN_MQTT_DEBUG("Flushing remaining cached audio data: %u bytes, %u packets\n",
g_record_cache.current_size, g_record_cache.packet_count);
if (ln_udp_audio_send_enqueue(g_record_cache.buffer, g_record_cache.current_size, AUDIO_SEND_ENCODING_OPUS) != 0) {
- printf("[LN_MQTT_API] Failed to enqueue remaining cached audio data\n");
+ LN_MQTT_ERROR("Failed to enqueue remaining cached audio data\n");
}
g_record_cache.current_size = 0;
g_record_cache.packet_count = 0;
free(g_record_cache.buffer);
g_record_cache.buffer = NULL;
g_record_cache.buffer_size = 0;
- printf("[LN_MQTT_API] Cache buffer freed\n");
+ LN_MQTT_DEBUG("Cache buffer freed\n");
}
#if LN_MQTT_RECORD_SAVE_TO_FILE_TEST
if (g_mqtt_message_callback != NULL) {
g_mqtt_message_callback(NULL, WS_CMD_AUDIO_RECORDING_END);
}
- printf("[LN_MQTT_API] Dual stream recording stopped, upload disabled (AI voice service still running)\n");
+ LN_MQTT_INFO("Dual stream recording stopped, upload disabled (AI voice service still running)\n");
#else
if (g_mqtt_message_callback != NULL) {
g_mqtt_message_callback(NULL, WS_CMD_AUDIO_RECORDING_END);
}
if (!g_udp_info.valid) {
- printf("[LN_MQTT_API] UDP info not available or invalid\n");
+ LN_MQTT_WARN("UDP info not available or invalid\n");
return -1;
}
projects / mirrors / FD230.git / commitdiff