Merge branch 'feature/hls_support_multiple_key' into 'master'

feat(http_stream): Add multiple key support for HLS

See merge request adf/esp-adf-internal!1432

Author: jason-mao

components/audio_stream/http_stream.c

@@ -69,7 +69,6 @@ typedef struct {
     uint8_t          key_cache[HLS_KEY_CACHE_SIZE];
     uint8_t          key_size;
     hls_stream_key_t key;
-    uint64_t         sequence_no;
     esp_aes_context  aes_ctx;
     bool             aes_used;
 } http_stream_hls_key_t;
@@ -96,14 +95,17 @@ typedef struct http_stream {
     bool                            gzip_encoding;     /* Content is encoded */
     gzip_miniz_handle_t             gzip;              /* GZIP instance */
     http_stream_hls_key_t           *hls_key;
+    uint64_t                         hls_sequence_no;
     hls_handle_t                    *hls_media;
+    int                              url_index;
     int                             request_range_size;
     int64_t                         request_range_end;
     bool                            is_last_range;
     const char                      *user_agent;
 } http_stream_t;
 
 static esp_err_t http_stream_auto_connect_next_track(audio_element_handle_t el);
+static int _update_hls_info(http_stream_t *http);
 
 // `errno` is not thread safe in multiple HTTP-clients,
 // so it is necessary to save the errno number of HTTP clients to avoid reading and writing exceptions of HTTP-clients caused by errno exceptions
@@ -272,14 +274,13 @@ static esp_err_t _prepare_crypt(http_stream_t *http)
     if (ret < 0) {
         return ESP_FAIL;
     }
-    ret = hls_playlist_get_key(http->hls_media, http->hls_key->sequence_no, &http->hls_key->key);
+    ret = hls_playlist_get_key(http->hls_media, http->hls_sequence_no, &http->hls_key->key);
     if (ret != 0) {
         return ESP_FAIL;
     }
     esp_aes_init(&hls_key->aes_ctx);
     esp_aes_setkey(&hls_key->aes_ctx, (unsigned char*)hls_key->key.key, 128);
     hls_key->aes_used = true;
-    http->hls_key->sequence_no++;
     return ESP_OK;
 }
 
@@ -387,6 +388,15 @@ static esp_err_t _resolve_playlist(audio_element_handle_t self, const char *uri)
         }
     } while (0);
     if (hls) {
+        http->hls_sequence_no = hls_playlist_get_sequence_no(hls);
+        for (int i = 0; i < http->url_index; i++) {
+            char *next_url = http_playlist_get_next_track(http->playlist);
+            if (next_url == NULL) {
+                ESP_LOGE(TAG, "Url index %d over limited %d", http->url_index, i);
+                return ESP_FAIL;
+            }
+        }
+        http->hls_sequence_no += http->url_index;
         if (hls_playlist_is_encrypt(hls) == false) {
             _free_hls_key(http);
             hls_playlist_close(hls);
@@ -398,27 +408,9 @@ static esp_err_t _resolve_playlist(audio_element_handle_t self, const char *uri)
                 ESP_LOGE(TAG, "Hls do not have key url");
                 return ESP_FAIL;
             }
-            if (http->hls_key == NULL) {
-                http->hls_key = (http_stream_hls_key_t *) calloc(1, sizeof(http_stream_hls_key_t));
-                if (http->hls_key == NULL) {
-                    ESP_LOGE(TAG, "No memory for hls key");
-                    return ESP_FAIL;
-                }
-            }
-            if (http->hls_key->key_url && strcmp(http->hls_key->key_url, key_url) == 0) {
-                http->hls_key->key_loaded = true;
-            } else {
-                if (http->hls_key->key_url) {
-                    audio_free(http->hls_key->key_url);
-                }
-                http->hls_key->key_loaded = false;
-                http->hls_key->key_url = audio_strdup(key_url);
-                if (http->hls_key->key_url == NULL) {
-                    ESP_LOGE(TAG, "No memory for hls key url");
-                    return ESP_FAIL;
-                } 
+            if (_update_hls_info(http) != ESP_OK) {
+                return ESP_FAIL;
             }
-            http->hls_key->sequence_no = hls_playlist_get_sequence_no(hls);
         }
     }
     return http->is_valid_playlist ? ESP_OK : ESP_FAIL;
@@ -570,7 +562,7 @@ static esp_err_t _http_open(audio_element_handle_t self)
         ESP_LOGE(TAG, "Error open connection, uri = NULL");
         return ESP_FAIL;
     }
-    
+
     ESP_LOGD(TAG, "URI=%s", uri);
     // if not initialize http client, initial it
     if (http->client == NULL) {
@@ -600,7 +592,7 @@ static esp_err_t _http_open(audio_element_handle_t self)
         return ESP_FAIL;
     }
 
-    if (_is_playlist(&info, uri) == true) {
+    if (_is_playlist(&info, uri) == true && http->is_playlist_resolved == false) {
         /**
          * `goto _stream_open_begin` blocks on http_open until it gets valid URL.
          * Ensure that the stop command is processed
@@ -704,6 +696,43 @@ static bool _check_range_done(audio_element_handle_t self)
     return last_range;
 }
 
+static int _update_hls_info(http_stream_t *http)
+{
+    char *key_url = hls_playlist_get_key_uri_by_seq(http->hls_media, http->hls_sequence_no);
+    if (key_url && http->hls_key == NULL) {
+        http->hls_key = audio_calloc(1, sizeof(http_stream_hls_key_t));
+        if (http->hls_key == NULL) {
+            ESP_LOGE(TAG, "No mem for HLS key");
+            return ESP_FAIL;
+        }
+    }
+    if (http->hls_key) {
+        if (key_url == NULL) {
+            ESP_LOGE(TAG, "Hls do not have key url");
+            return ESP_FAIL;
+        }
+        // Same key no need reload
+        if (http->hls_key->key_url && strcmp(http->hls_key->key_url, key_url) == 0) {
+            http->hls_key->key_loaded = true;
+            audio_free(key_url);
+        } else {
+            if (http->hls_key->key_url) {
+                audio_free(http->hls_key->key_url);
+            }
+            http->hls_key->key_loaded = false;
+            http->hls_key->key_url = key_url;
+        }
+    }
+    return ESP_OK;
+}
+
+static int _update_next_hls_info(http_stream_t *http)
+{
+    // Check HLS key need update or not
+    http->hls_sequence_no++;
+    return _update_hls_info(http);
+}
+
 static int _http_read(audio_element_handle_t self, char *buffer, int len, TickType_t ticks_to_wait, void *context)
 {
     http_stream_t *http = (http_stream_t *)audio_element_getdata(self);
@@ -719,6 +748,9 @@ static int _http_read(audio_element_handle_t self, char *buffer, int len, TickTy
             rlen = _http_read_data(http, buffer, len);
         }
     }
+    if (rlen <= 0) {
+        _update_next_hls_info(http);
+    }
     if (rlen <= 0 && http->auto_connect_next_track) {
         if (http_stream_auto_connect_next_track(self) == ESP_OK) {
             rlen = _http_read_data(http, buffer, len);
@@ -727,7 +759,7 @@ static int _http_read(audio_element_handle_t self, char *buffer, int len, TickTy
     if (rlen <= 0) {
         http->_errno = esp_http_client_get_errno(http->client);
         ESP_LOGW(TAG, "No more data,errno:%d, total_bytes:%llu, rlen = %d", http->_errno, info.byte_pos, rlen);
-        if (http->_errno != 0) {  // Error occuered, reset connection
+        if (http->_errno != 0) {  // Error occurs, reset connection
             ESP_LOGW(TAG, "Got %d errno(%s)", http->_errno, strerror(http->_errno));
             return http->_errno;
         }
@@ -745,8 +777,8 @@ static int _http_read(audio_element_handle_t self, char *buffer, int len, TickTy
         return ESP_OK;
     } else {
         if (http->hls_key) {
-            int ret = esp_aes_crypt_cbc(&http->hls_key->aes_ctx, ESP_AES_DECRYPT, 
-                 rlen, (unsigned char*)http->hls_key->key.iv, 
+            int ret = esp_aes_crypt_cbc(&http->hls_key->aes_ctx, ESP_AES_DECRYPT,
+                 rlen, (unsigned char*)http->hls_key->key.iv,
                  (unsigned char*)buffer, (unsigned char*)buffer);
             if (rlen % 16 != 0) {
                 ESP_LOGE(TAG, "Data length %d not aligned", rlen);
@@ -873,6 +905,7 @@ audio_element_handle_t http_stream_init(http_stream_cfg_t *config)
     http->user_data = config->user_data;
     http->cert_pem = config->cert_pem;
     http->user_agent = config->user_agent;
+    http->url_index = config->url_index;
 
     if (config->crt_bundle_attach) {
 #if  (ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 3, 0))
@@ -971,6 +1004,19 @@ esp_err_t http_stream_auto_connect_next_track(audio_element_handle_t el)
     return ESP_FAIL;
 }
 
+esp_err_t http_stream_get_url_index(audio_element_handle_t el, int *url_idx)
+{
+    http_stream_t *http = (http_stream_t *)audio_element_getdata(el);
+    if (http->playlist == NULL || http->hls_media == NULL || http->playlist->is_incomplete) {
+        ESP_LOGI(TAG, "Only support for VOD HLS stream");
+        return ESP_ERR_NOT_SUPPORTED;
+    }
+    uint64_t start_seq = hls_playlist_get_sequence_no(http->hls_media);
+    *(url_idx) = (int)(http->hls_sequence_no - start_seq);
+    ESP_LOGI(TAG, "Current url index %d\n", *(url_idx));
+    return ESP_OK;
+}
+
 esp_err_t http_stream_fetch_again(audio_element_handle_t el)
 {
     http_stream_t *http = (http_stream_t *)audio_element_getdata(el);

components/audio_stream/include/http_stream.h

@@ -90,11 +90,12 @@ typedef struct {
                                                              bundle for server verification, must be enabled in menuconfig */
     int                         request_size;           /*!< Request data size each time from `http_client`
                                                              Defaults use DEFAULT_ELEMENT_BUFFER_LENGTH if set to 0
-                                                             Need care this setting if audio frame size is small and want low latency playback */                                                         
+                                                             Need care this setting if audio frame size is small and want low latency playback */
     int                         request_range_size;     /*!< Range size setting for header `Range: bytes=start-end`
                                                              Request full range of resource if set to 0
                                                              Range size bigger than request size is recommended */
     const char                  *user_agent;            /*!< The User Agent string to send with HTTP requests */
+    int                         url_index;              /*!< The url index to be played in playlist */
 } http_stream_cfg_t;
 
 #define HTTP_STREAM_TASK_STACK          (6 * 1024)
@@ -158,6 +159,19 @@ esp_err_t http_stream_restart(audio_element_handle_t el);
  */
 esp_err_t http_stream_fetch_again(audio_element_handle_t el);
 
+/**
+ * @brief       Get url index in current playlist
+ *
+ *
+ * @param       el       The http_stream element handle
+ * @param       url_idx  Url index in playlist
+ *
+ * @return
+ *     - ESP_OK on success
+ *     - ESP_ERR_NOT_SUPPORTED if playlist not existed
+ */
+esp_err_t http_stream_get_url_index(audio_element_handle_t el, int *url_idx);
+
 /**
  * @brief       Set SSL server certification
  * @note        EM format as string, if the client requires to verify server

components/audio_stream/lib/hls/hls_playlist.c

@@ -260,6 +260,48 @@ static void hls_hex_to_bin(uint8_t* v, char* s, int n)
     }
 }
 
+static int hls_append_key(hls_media_playlist_t* media, hls_tag_info_t* tag_info)
+{
+    if ((media->key_num % 5) == 0) {
+        int key_arr_size = sizeof(hls_key_t) *  (media->key_num + 5);
+        hls_key_t* new_key = audio_realloc(media->key, key_arr_size);
+        if (new_key == NULL) {
+            return -1;
+        }
+        memset(&new_key[media->key_num], 0, sizeof(hls_key_t) * 5);
+        media->key = new_key;
+    }
+    hls_key_t *key_info = &media->key[media->key_num];
+    for (int i = 0; i < tag_info->attr_num; i++) {
+        switch (tag_info->k[i]) {
+            case HLS_ATTR_METHOD:
+                key_info->method = (hls_encrypt_method_t)tag_info->v[i].v;
+                break;
+            case HLS_ATTR_IV: {
+                char* v = tag_info->v[i].s;
+                // Skip leading 0x
+                if (strncasecmp(v, "0x", 2) == 0) {
+                    v += 2;
+                }
+                hls_hex_to_bin(key_info->iv, v, strlen(v));
+                break;
+            }
+            case HLS_ATTR_URI:
+                key_info->uri = strdup(tag_info->v[i].s);
+                break;
+            default:
+                break;
+        }
+    }
+    key_info->range[0] = media->url_num;
+    key_info->range[1] = 0xFFFF;
+    if (media->key_num > 0) {
+        key_info[-1].range[1] = media->url_num ? media->url_num - 1 : 0;
+    }
+    media->key_num++;
+    return 0;
+}
+
 static int hls_media_tag_cb(hls_tag_info_t* tag_info, void* ctx)
 {
     hls_t* hls = (hls_t*)ctx;
@@ -293,36 +335,9 @@ static int hls_media_tag_cb(hls_tag_info_t* tag_info, void* ctx)
             break;
         case HLS_TAG_KEY:
             if (tag_info->attr_num) {
-                // Only support one key currently
-                media->key_num = 1;
-                if (media->key == NULL) {
-                    media->key = (hls_key_t*) audio_calloc(1, sizeof(hls_key_t));
-                }
-                if (media->key == NULL) {
+                if (hls_append_key(media, tag_info) != 0) {
                     ESP_LOGE(TAG, "No memory for key");
-                    break;
-                }
-                for (int i = 0; i < tag_info->attr_num; i++) {
-                    switch (tag_info->k[i]) {
-                        case HLS_ATTR_METHOD:
-                            media->key[0].method = (hls_encrypt_method_t)tag_info->v[i].v;
-                            break;
-                        case HLS_ATTR_IV: {
-                            char* v = tag_info->v[i].s;
-                            // Skip leading 0x
-                            if (strncasecmp(v, "0x", 2) == 0) {
-                                v += 2;
-                            }
-                            hls_hex_to_bin(media->key[0].iv, v, strlen(v));
-                            break;
-                        }
-                        case HLS_ATTR_URI:
-                            HLS_FREE(media->key[0].uri);
-                            media->key[0].uri = join_url(media->uri, tag_info->v[i].s);
-                            break;
-                        default:
-                            break;
-                    }
+                    return -1;
                 }
             }
             break;
@@ -333,6 +348,8 @@ static int hls_media_tag_cb(hls_tag_info_t* tag_info, void* ctx)
                     case HLS_ATTR_URI: {
                         char* url = join_url(media->uri, tag_info->v[i].s);
                         if (url) {
+                            // Inc url number
+                            media->url_num++;
                             hls->cfg.cb(url, hls->cfg.ctx);
                             audio_free(url);
                         }
@@ -429,10 +446,12 @@ static int hls_close_media_playlist(hls_t* hls, hls_media_playlist_t* media)
     }
     media->key_num = 0;
     HLS_FREE(media->key);
-    // release url
-    for (i = 0; i < media->url_num; i++) {
-        hls_url_t* url = &media->url_items[i];
-        HLS_FREE(url->uri);
+    // Release url
+    if (media->url_items) {
+        for (i = 0; i < media->url_num; i++) {
+            hls_url_t* url = &media->url_items[i];
+            HLS_FREE(url->uri);
+        }
     }
     HLS_FREE(media->url_items);
     HLS_FREE(media->uri);
@@ -585,7 +604,7 @@ const char* hls_playlist_get_key_uri(hls_handle_t h)
     }
     hls_media_playlist_t* media = hls->media_playlist;
     if (media->key_num && media->key[0].uri) {
-        return media->key[0].uri;
+        return join_url(media->uri, media->key[0].uri);
     }
     return NULL;
 }
@@ -600,6 +619,26 @@ uint64_t hls_playlist_get_sequence_no(hls_handle_t h)
     return media->media_sequence;
 }
 
+char *hls_playlist_get_key_uri_by_seq(hls_handle_t h, uint64_t sequence_no)
+{
+    hls_t* hls = (hls_t*)h;
+    if (hls == NULL || hls->media_playlist == NULL) {
+        return NULL;
+    }
+    hls_media_playlist_t* media = hls->media_playlist;
+    if (media->key_num == 0) {
+        return NULL;
+    }
+    uint16_t start_idx = sequence_no - media->media_sequence;
+    for (int i = 0; i < media->key_num; i++) {
+        if (start_idx > media->key[i].range[1]) {
+            continue;
+        }
+        return join_url(media->uri, media->key[i].uri);
+    }
+    return NULL;
+}
+
 int hls_playlist_get_key(hls_handle_t h, uint64_t sequence_no, hls_stream_key_t* key)
 {
     hls_t* hls = (hls_t*)h;