BPI/BPI-CM9-Linux
6
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
3428a94f6b57d8d41235a742c5b29defce11fc93
BPI-CM9-Linux/aml-comp/multimedia/ffmpeg_ctc/libavformat/hls.c
T

4837 lines
176 KiB
C
Raw Blame History

/*
* Apple HTTP Live Streaming demuxer
* Copyright (c) 2010 Martin Storsjo
* Copyright (c) 2013 Anssi Hannula
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
/**
* @file
* Apple HTTP Live Streaming demuxer
* http://tools.ietf.org/html/draft-pantos-http-live-streaming
*/
#include "aml/hls/ffhls.h"
#include "avformat.h"
#include "aviolpbuf.h"
#include "ffhls.h"
#include "libavformat/avformat.h"
#include "libavformat/avio_internal.h"
#include "libavutil/base64.h"
#include <sys/time.h>
#include "get_config.h"
#include "libavformat/aml/tcpproto/dns_cache.h"
#include "libavformat/mpegts.h"
#include "libavutil/encryption_info.h"
#include <amconfigutils.h>
static int reopen_pls(AVFormatContext *s, struct playlist *pls);
static void free_segment_list(struct playlist *pls)
{
int i;
for (i = 0; i < pls->n_segments; i++) {
av_freep(&pls->segments[i]->key);
av_freep(&pls->segments[i]->url);
av_freep(&pls->segments[i]);
}
av_freep(&pls->segments);
pls->n_segments = 0;
}
static void free_init_section_list(struct playlist *pls)
{
int i;
for (i = 0; i < pls->n_init_sections; i++) {
av_freep(&pls->init_sections[i]->url);
av_freep(&pls->init_sections[i]);
}
av_freep(&pls->init_sections);
pls->n_init_sections = 0;
}
static void free_playlist_list(HLSContext *c)
{
int i;
for (i = 0; i < c->n_playlists_all; i++) {
struct playlist *pls = c->playlists_all[i];
free_segment_list(pls);
free_init_section_list(pls);
av_freep(&pls->main_streams);
av_freep(&pls->renditions);
av_freep(&pls->id3_buf);
av_dict_free(&pls->id3_initial);
ff_id3v2_free_extra_meta(&pls->id3_deferred_extra);
av_freep(&pls->init_sec_buf);
av_packet_unref(&pls->pkt);
av_freep(&pls->pb.buffer);
if (pls->redirect_url)
av_freep(&pls->redirect_url);
if (pls->timeshif_url)
av_freep(&pls->timeshif_url);
if (pls->input)
ff_format_io_close(c->ctx, &pls->input);
pls->input_read_done = 0;
if (pls->input_next)
ff_format_io_close(c->ctx, &pls->input_next);
if (pls->playlist_pb)
ff_format_io_close(c->ctx, &pls->playlist_pb);
pls->input_next_requested = 0;
if (pls->ctx) {
pls->ctx->pb = NULL;
avformat_close_input(&pls->ctx);
}
av_free(pls);
}
av_freep(&c->playlists);
av_freep(&c->playlists_all);
av_freep(&c->cookies);
av_freep(&c->user_agent);
av_freep(&c->headers);
av_freep(&c->http_proxy);
c->n_playlists = 0;
c->n_playlists_all = 0;
}
static void free_variant_list(HLSContext *c)
{
int i;
for (i = 0; i < c->n_variants; i++) {
struct variant_t *var = c->variants[i];
av_freep(&var->playlists);
av_free(var);
}
#ifdef HLS_I_FRAME_MODE
for (i = 0; i < c->n_i_frame_variants; i++) {
struct variant_t *var = c->i_frame_variants[i];
av_freep(&var->playlists);
av_free(var);
}
av_freep(&c->i_frame_variants);
c->n_i_frame_variants = 0;
#endif
av_freep(&c->variants);
c->n_variants = 0;
}
static void free_rendition_list(HLSContext *c)
{
int i;
for (i = 0; i < c->n_renditions; i++)
av_freep(&c->renditions[i]);
av_freep(&c->renditions);
c->n_renditions = 0;
}
/*
* Used to reset a statically allocated AVPacket to a clean slate,
* containing no data.
*/
static void reset_packet(AVPacket *pkt)
{
av_init_packet(pkt);
pkt->data = NULL;
}
static struct playlist *new_playlist(HLSContext *c, const char *url,
const char *base)
{
struct playlist *pls = av_mallocz(sizeof(struct playlist));
if (!pls)
return NULL;
reset_packet(&pls->pkt);
ff_make_absolute_url(pls->url, sizeof(pls->url), base, url);
pls->seek_timestamp = AV_NOPTS_VALUE;
pls->is_id3_timestamped = -1;
pls->id3_mpegts_timestamp = AV_NOPTS_VALUE;
dynarray_add(&c->playlists, &c->n_playlists, pls);
return pls;
}
struct variant_info {
char bandwidth[20];
/* variant group ids: */
char audio[MAX_FIELD_LEN];
char video[MAX_FIELD_LEN];
char subtitles[MAX_FIELD_LEN];
char codecs[MAX_FIELD_LEN];
char resolution[MAX_FIELD_LEN];
};
static struct variant_t *new_variant(HLSContext *c, struct variant_info *info,
const char *url, const char *base)
{
struct variant_t *var;
struct playlist *pls;
pls = new_playlist(c, url, base);
if (!pls)
return NULL;
var = av_mallocz(sizeof(struct variant_t));
if (!var)
return NULL;
if (info) {
var->bandwidth = atoi(info->bandwidth);
strcpy(var->audio_group, info->audio);
strcpy(var->video_group, info->video);
strcpy(var->subtitles_group, info->subtitles);
strcpy(var->codecs, info->codecs);
strcpy(var->resolution, info->resolution);
}
dynarray_add(&c->variants, &c->n_variants, var);
dynarray_add(&var->playlists, &var->n_playlists, pls);
return var;
}
static void handle_variant_args(struct variant_info *info, const char *key,
int key_len, char **dest, int *dest_len)
{
if (!strncmp(key, "BANDWIDTH=", key_len)) {
*dest = info->bandwidth;
*dest_len = sizeof(info->bandwidth);
} else if (!strncmp(key, "AUDIO=", key_len)) {
*dest = info->audio;
*dest_len = sizeof(info->audio);
} else if (!strncmp(key, "VIDEO=", key_len)) {
*dest = info->video;
*dest_len = sizeof(info->video);
} else if (!strncmp(key, "SUBTITLES=", key_len)) {
*dest = info->subtitles;
*dest_len = sizeof(info->subtitles);
} else if (!strncmp(key, "CODECS=", key_len)) {
*dest = info->codecs;
*dest_len = sizeof(info->codecs);
} else if (!strncmp(key, "RESOLUTION=", key_len)) {
*dest = info->resolution;
*dest_len = sizeof(info->resolution);
}
}
typedef struct {
enum AVMediaType type;
const char *desc;
} Codec_Desc;
static Codec_Desc codec_desc[] = {
{AVMEDIA_TYPE_VIDEO, "avc1"},
{AVMEDIA_TYPE_VIDEO, "avc2"},
{AVMEDIA_TYPE_VIDEO, "avc3"},
{AVMEDIA_TYPE_VIDEO, "avc4"},
{AVMEDIA_TYPE_AUDIO, "mp4a.40.2"},
{AVMEDIA_TYPE_AUDIO, "mp4a.40.33"},
{AVMEDIA_TYPE_AUDIO, "mp4a.40.34"},
{AVMEDIA_TYPE_AUDIO, "ac-3"},
{AVMEDIA_TYPE_AUDIO, "ec-3"},
{AVMEDIA_TYPE_SUBTITLE, "sbtt"},
{AVMEDIA_TYPE_SUBTITLE, "stpp"},
{AVMEDIA_TYPE_SUBTITLE, "encu"},
};
static int isCodecContainVideo(const char *codecs)
{
char *p = (char *)codecs;
char *q;
char *codec;
int len;
int found = 0;
int containVideo = 0;
while (p) {
q = strchr(p, ',');
if (q) {
len = q - p;
} else {
len = strlen(p);
}
codec = av_mallocz(len + 1);
if (!codec)
return 0;
strncpy(codec, p, len);
for (int i = 0; i < FF_ARRAY_ELEMS(codec_desc); i++) {
if (!strncmp(codec, codec_desc[i].desc, 4)) {
switch (codec_desc[i].type) {
case AVMEDIA_TYPE_VIDEO:
containVideo = 1;
found = 1;
break;
default:
break;
}
break;
}
}
av_free(codec);
if (found)
break;
p = q ? q + 1 : NULL;
}
return containVideo;
}
static void handle_key_args(struct hls_key_info *info, const char *key,
int key_len, char **dest, int *dest_len)
{
if (!strncmp(key, "METHOD=", key_len)) {
*dest = info->method;
*dest_len = sizeof(info->method);
} else if (!strncmp(key, "URI=", key_len)) {
*dest = info->uri;
*dest_len = sizeof(info->uri);
} else if (!strncmp(key, "IV=", key_len)) {
*dest = info->iv;
*dest_len = sizeof(info->iv);
} else if (!strncmp(key, "KEYID=", key_len)) {
*dest = info->keyid;
*dest_len = sizeof(info->keyid);
}
}
struct init_section_info {
char uri[MAX_URL_SIZE];
char byterange[32];
};
static struct segment *new_init_section(struct playlist *pls,
struct init_section_info *info,
const char *url_base)
{
struct segment *sec;
char *ptr;
char tmp_str[MAX_URL_SIZE];
if (!info->uri[0])
return NULL;
sec = av_mallocz(sizeof(*sec));
if (!sec)
return NULL;
ff_make_absolute_url(tmp_str, sizeof(tmp_str), url_base, info->uri);
sec->url = av_strdup(tmp_str);
if (!sec->url) {
av_free(sec);
return NULL;
}
if (info->byterange[0]) {
sec->size = strtoll(info->byterange, NULL, 10);
ptr = strchr(info->byterange, '@');
if (ptr)
sec->url_offset = strtoll(ptr+1, NULL, 10);
} else {
/* the entire file is the init section */
sec->size = -1;
}
dynarray_add(&pls->init_sections, &pls->n_init_sections, sec);
return sec;
}
static void handle_init_section_args(struct init_section_info *info, const char *key,
int key_len, char **dest, int *dest_len)
{
if (!strncmp(key, "URI=", key_len)) {
*dest = info->uri;
*dest_len = sizeof(info->uri);
} else if (!strncmp(key, "BYTERANGE=", key_len)) {
*dest = info->byterange;
*dest_len = sizeof(info->byterange);
}
}
struct rendition_info {
char type[16];
char uri[MAX_URL_SIZE];
char group_id[MAX_FIELD_LEN];
char language[MAX_FIELD_LEN];
char assoc_language[MAX_FIELD_LEN];
char name[MAX_FIELD_LEN];
char defaultr[4];
char forced[4];
char characteristics[MAX_CHARACTERISTICS_LEN];
};
static struct rendition *new_rendition(HLSContext *c, struct rendition_info *info,
const char *url_base)
{
struct rendition *rend;
enum AVMediaType type = AVMEDIA_TYPE_UNKNOWN;
char *characteristic;
char *chr_ptr;
char *saveptr;
if (!strcmp(info->type, "AUDIO"))
type = AVMEDIA_TYPE_AUDIO;
else if (!strcmp(info->type, "VIDEO"))
type = AVMEDIA_TYPE_VIDEO;
else if (!strcmp(info->type, "SUBTITLES"))
type = AVMEDIA_TYPE_SUBTITLE;
else if (!strcmp(info->type, "CLOSED-CAPTIONS"))
/* CLOSED-CAPTIONS is ignored since we do not support CEA-608 CC in
* AVC SEI RBSP anyway */
return NULL;
if (type == AVMEDIA_TYPE_UNKNOWN)
return NULL;
/* URI is mandatory for subtitles as per spec */
if (type == AVMEDIA_TYPE_SUBTITLE && !info->uri[0])
return NULL;
/* TODO: handle subtitles (each segment has to parsed separately) */
// if (c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL)
// if (type == AVMEDIA_TYPE_SUBTITLE)
// return NULL;
rend = av_mallocz(sizeof(struct rendition));
if (!rend)
return NULL;
dynarray_add(&c->renditions, &c->n_renditions, rend);
rend->type = type;
strcpy(rend->group_id, info->group_id);
strcpy(rend->language, info->language);
strcpy(rend->name, info->name);
/* add the playlist if this is an external rendition */
if (info->uri[0]) {
rend->playlist = new_playlist(c, info->uri, url_base);
if (rend->playlist)
dynarray_add(&rend->playlist->renditions,
&rend->playlist->n_renditions, rend);
}
if (info->assoc_language[0]) {
int langlen = strlen(rend->language);
if (langlen < sizeof(rend->language) - 3) {
rend->language[langlen] = ',';
strncpy(rend->language + langlen + 1, info->assoc_language,
sizeof(rend->language) - langlen - 2);
}
}
if (!strcmp(info->defaultr, "YES"))
rend->disposition |= AV_DISPOSITION_DEFAULT;
if (!strcmp(info->forced, "YES"))
rend->disposition |= AV_DISPOSITION_FORCED;
chr_ptr = info->characteristics;
while ((characteristic = av_strtok(chr_ptr, ",", &saveptr))) {
if (!strcmp(characteristic, "public.accessibility.describes-music-and-sound"))
rend->disposition |= AV_DISPOSITION_HEARING_IMPAIRED;
else if (!strcmp(characteristic, "public.accessibility.describes-video"))
rend->disposition |= AV_DISPOSITION_VISUAL_IMPAIRED;
chr_ptr = NULL;
}
return rend;
}
static void handle_rendition_args(struct rendition_info *info, const char *key,
int key_len, char **dest, int *dest_len)
{
if (!strncmp(key, "TYPE=", key_len)) {
*dest = info->type;
*dest_len = sizeof(info->type);
} else if (!strncmp(key, "URI=", key_len)) {
*dest = info->uri;
*dest_len = sizeof(info->uri);
} else if (!strncmp(key, "GROUP-ID=", key_len)) {
*dest = info->group_id;
*dest_len = sizeof(info->group_id);
} else if (!strncmp(key, "LANGUAGE=", key_len)) {
*dest = info->language;
*dest_len = sizeof(info->language);
} else if (!strncmp(key, "ASSOC-LANGUAGE=", key_len)) {
*dest = info->assoc_language;
*dest_len = sizeof(info->assoc_language);
} else if (!strncmp(key, "NAME=", key_len)) {
*dest = info->name;
*dest_len = sizeof(info->name);
} else if (!strncmp(key, "DEFAULT=", key_len)) {
*dest = info->defaultr;
*dest_len = sizeof(info->defaultr);
} else if (!strncmp(key, "FORCED=", key_len)) {
*dest = info->forced;
*dest_len = sizeof(info->forced);
} else if (!strncmp(key, "CHARACTERISTICS=", key_len)) {
*dest = info->characteristics;
*dest_len = sizeof(info->characteristics);
}
/*
* ignored:
* - AUTOSELECT: client may autoselect based on e.g. system language
* - INSTREAM-ID: EIA-608 closed caption number ("CC1".."CC4")
*/
}
/* used by parse_playlist to allocate a new variant+playlist when the
* playlist is detected to be a Media Playlist (not Master Playlist)
* and we have no parent Master Playlist (parsing of which would have
* allocated the variant and playlist already)
* *pls == NULL => Master Playlist or parentless Media Playlist
* *pls != NULL => parented Media Playlist, playlist+variant allocated */
static int ensure_playlist(HLSContext *c, struct playlist **pls, const char *url)
{
if (*pls)
return 0;
if (!new_variant(c, NULL, url, NULL))
return AVERROR(ENOMEM);
*pls = c->playlists[c->n_playlists - 1];
return 0;
}
static void update_options(char **dest, const char *name, void *src)
{
av_freep(dest);
av_opt_get(src, name, AV_OPT_SEARCH_CHILDREN, (uint8_t**)dest);
if (*dest && !strlen(*dest))
av_freep(dest);
}
static int open_url_keepalive(AVFormatContext *s, AVIOContext **pb,
const char *url)
{
//add for amlogic, not support keepalive for not suitable with our framework
// #if !CONFIG_HTTP_PROTOCOL
return AVERROR_PROTOCOL_NOT_FOUND;
// #else
// int ret;
// URLContext *uc = ffio_geturlcontext(*pb);
// av_assert0(uc);
// (*pb)->eof_reached = 0;
// ret = aml_http_do_new_request(uc, url);
// if (ret < 0) {
// ff_format_io_close(s, pb);
// }
// return ret;
// #endif
}
static int open_url(AVFormatContext *s, AVIOContext **pb, const char *url,
AVDictionary *opts, AVDictionary *opts2, int *is_http_out)
{
HLSContext *c = s->priv_data;
AVDictionary *tmp = NULL;
const char *proto_name = NULL;
int ret;
int is_http = 0;
av_dict_copy(&tmp, opts, 0);
av_dict_copy(&tmp, opts2, 0);
if (av_strstart(url, "crypto", NULL)) {
if (url[6] == '+' || url[6] == ':')
proto_name = avio_find_protocol_name(url + 7);
}
if (!proto_name)
proto_name = avio_find_protocol_name(url);
if (!proto_name)
return AVERROR_INVALIDDATA;
// only http(s) & file are allowed
if (av_strstart(proto_name, "file", NULL)) {
if (strcmp(c->allowed_extensions, "ALL") && !av_match_ext(url, c->allowed_extensions)) {
av_log(NULL, AV_LOG_ERROR,"Filename extension of \'%s\' is not a common multimedia extension, blocked for security reasons.\n"
"If you wish to override this adjust allowed_extensions, you can set it to \'ALL\' to allow all\n",
url);
return AVERROR_INVALIDDATA;
}
} else if (av_strstart(proto_name, "http", NULL)) {
is_http = 1;
} else
return AVERROR_INVALIDDATA;
if (!strncmp(proto_name, url, strlen(proto_name)) && url[strlen(proto_name)] == ':')
;
else if (av_strstart(url, "crypto", NULL) && !strncmp(proto_name, url + 7, strlen(proto_name)) && url[7 + strlen(proto_name)] == ':')
;
else if (strcmp(proto_name, "file") || !strncmp(url, "file,", 5))
return AVERROR_INVALIDDATA;
if (is_http && c->http_persistent && *pb) {
ret = open_url_keepalive(c->ctx, pb, url);
if (ret == AVERROR_EXIT) {
return ret;
} else if (ret < 0) {
if (ret != AVERROR_EOF)
av_log(NULL, AV_LOG_WARNING,"keepalive request failed for '%s', retrying with new connection: %s\n",
url, av_err2str(ret));
//ret = s->io_open(s, pb, url, AVIO_FLAG_READ, &tmp);
ret = amlio_open_whitelist(pb, url, AVIO_FLAG_READ, &s->interrupt_callback, &tmp,
s->protocol_whitelist, s->protocol_blacklist);
}
} else {
//ret = s->io_open(s, pb, url, AVIO_FLAG_READ, &tmp);
ret = amlio_open_whitelist(pb, url, AVIO_FLAG_READ , &s->interrupt_callback, &tmp,
s->protocol_whitelist, s->protocol_blacklist);
}
if (ret >= 0) {
// update cookies on http response with setcookies.
char *new_cookies = NULL;
if (!(s->flags & AVFMT_FLAG_CUSTOM_IO))
av_opt_get(*pb, "cookies", AV_OPT_SEARCH_CHILDREN, (uint8_t**)&new_cookies);
if (new_cookies) {
av_free(c->cookies);
c->cookies = new_cookies;
}
av_dict_set(&opts, "cookies", c->cookies, 0);
if (c->http_thread_enable)
{
//will use the buf in http proto
//to avoid copy ts data one more time
//so close the buf in this AVIOContext
(*pb)->direct = 1;
}
}
av_dict_free(&tmp);
if (is_http_out)
*is_http_out = is_http;
return ret;
}
static void get_m3u8_opts(HLSContext *c, AVDictionary **_opts)
{
int ret = 0;
/* Some HLS servers don't like being sent the range header */
// ret = av_dict_set(_opts, "seekable", "0", 0);
// broker prior HTTP options that should be consistent across requests
ret = av_dict_set(_opts, "user_agent", c->user_agent, 0);
ret = av_dict_set(_opts, "cookies", c->cookies, 0);
ret = av_dict_set(_opts, "headers", c->headers, 0);
ret = av_dict_set(_opts, "http_proxy", c->http_proxy, 0);
//opt for m3u8 http
ret = av_dict_set_int(_opts, "seekable", c->seekable, 0);
ret = av_dict_set_int(_opts, "http_reconnect", 0, 0);
ret = av_dict_set_int(_opts, "http_reconnect_at_eof", c->http_reconnect_at_eof, 0);
ret = av_dict_set_int(_opts, "http_reconnect_streamed", c->http_reconnect_streamed, 0);
ret = av_dict_set_int(_opts, "http_reconnect_delay_max", c->http_reconnect_delay_max, 0);
ret = av_dict_set_int(_opts, "http_thread_enable", c->http_thread_enable, 0);
ret = av_dict_set_int(_opts, "http_thread_bufsize", c->http_thread_bufsize, 0);
ret = av_dict_set_int(_opts, "tcp_rw_timeout", c->tcp_rw_timeout, 0);
ret = av_dict_set_int(_opts, "tcp_connect_timeout", c->tcp_connect_timeout, 0);
ret = av_dict_set_int(_opts, "addrinfo_one_by_one", c->addrinfo_one_by_one, 0);
ret = av_dict_set_int(_opts, "dns_seq_mode", c->dns_seq_mode, 0);
ret = av_dict_set_int(_opts, "addrinfo_timeout", c->addrinfo_timeout, 0);
ret = av_dict_set_int(_opts, "dns_cache_timeout", c->dns_cache_timeout, 0);
if (c->http_persistent)
ret = av_dict_set(_opts, "multiple_requests", "1", 0);
}
int parse_playlist_start_seq(AVIOContext *in)
{
int ret = -1;
const char *ptr;
if (in == NULL)
{
av_log(NULL, AV_LOG_ERROR,"in == NULL");
return -1;
}
char line[MAX_URL_SIZE];
ff_get_chomp_line(in, line, sizeof(line));
if (strcmp(line, "#EXTM3U")) {
ret = AVERROR_INVALIDDATA;
goto fail;
}
while (!avio_feof(in)) {
ff_get_chomp_line(in, line, sizeof(line));
if (av_strstart(line, "#EXT-X-MEDIA-SEQUENCE:", &ptr)) {
ret = atoi(ptr);
break;
}
}
fail:
avio_seek(in, 0, SEEK_SET);
return ret;
}
static int64_t parse_date_time_us(const char *timestamp)
{
struct tm tm = {0};
char timestamp_strp[50];
char timestamp_ms[4];
memset(timestamp_strp, 0, sizeof(timestamp_strp));
memset(timestamp_ms, 0, sizeof(timestamp_ms));
char* ms_str = strstr(timestamp, ".");
if (ms_str) {
memcpy(timestamp_strp, timestamp, ms_str - timestamp);
memcpy(timestamp_strp + (ms_str - timestamp), ms_str + 4, strlen(ms_str + 4));
memcpy(timestamp_ms, ms_str + 1, 3);
} else {
memcpy(timestamp_strp, timestamp, strlen(timestamp));
}
strptime(timestamp_strp, "%Y-%m-%dT%H:%M:%S%z", &tm);
char *tz = getenv("TZ");
int64_t unixTimestamp = mktime(&tm);
int ms = atoi(timestamp_ms);
int64_t us = (unixTimestamp - timezone) * 1000000 + ms * 1000;
av_log(NULL, AV_LOG_WARNING, "timestamp_strp:%s, timestamp_ms:%s, us:%lld, unixTimestamp:%lld, timezone:%ld, tz:%s\n", timestamp_strp, timestamp_ms, us, unixTimestamp, timezone, tz ? tz : "tz=NULL");
return us;
}
static int parse_playlist(HLSContext *c, const char *url,
struct playlist *pls, AVIOContext *in)
{
int ret = 0, is_segment = 0, is_variant = 0;
int64_t duration = 0;
int64_t seg_time_us = -1;
enum KeyType key_type = KEY_NONE;
uint8_t iv[16] = "";
int has_iv = 0;
char key[MAX_URL_SIZE] = "";
char line[MAX_URL_SIZE];
const char *ptr;
int close_in = 0;
int64_t seg_offset = 0;
int64_t seg_size = -1;
uint8_t *new_url = NULL;
struct variant_info variant_info;
#ifdef HLS_I_FRAME_MODE
struct i_frame_variant_info i_frame_variant_info;
#endif
char tmp_str[MAX_URL_SIZE];
struct segment *cur_init_section = NULL;
char* url_origin = url;
int is_http = av_strstart(url, "http", NULL);
if (is_http && !in && c->http_persistent && c->playlist_pb && !c->hls_thread_enable) {
in = c->playlist_pb;
ret = open_url_keepalive(c->ctx, &c->playlist_pb, url);
if (ret == AVERROR_EXIT) {
return ret;
} else if (ret < 0) {
if (ret != AVERROR_EOF)
av_log(NULL, AV_LOG_WARNING,"keepalive request failed for '%s', retrying with new connection: %s\n",
url, av_err2str(ret));
in = NULL;
}
}
if (!in) {
AVDictionary *opts = NULL;
get_m3u8_opts(c, &opts);
//ret = c->ctx->io_open(c->ctx, &in, url, AVIO_FLAG_READ, &opts);
ret = amlio_open_whitelist(&in, url, AVIO_FLAG_READ, &c->ctx->interrupt_callback, &opts,
c->ctx->protocol_whitelist, c->ctx->protocol_blacklist);
av_dict_free(&opts);
if (ret < 0)
{
if (check_net_phy_conn_status() == 0)
{
av_log(NULL, AV_LOG_WARNING,"hls net down");
set_dns_net_down();
return AVERROR(ETIMEDOUT);
}
if (pls && pls->redirect_url)
av_freep(&pls->redirect_url);
return ret;
}
if (is_http && c->http_persistent)
c->playlist_pb = in;
else
close_in = 1;
}
if (av_opt_get(in, "location", AV_OPT_SEARCH_CHILDREN, &new_url) >= 0 && new_url)
{
//sometimes new_url="", but don't know why yet. add a protection
if (strcmp(new_url, "")) {
url = new_url;
if (pls)
{
if (pls->redirect_url)
av_freep(&pls->redirect_url);
pls->redirect_url = av_strdup(new_url);
}
}
av_log(NULL, AV_LOG_INFO,"location get new_url:%s, url:%s, redirect_url:%s\n",trimLeadingCharacter(new_url), trimLeadingCharacter(url), (pls ? trimLeadingCharacter(pls->redirect_url) : NULL));
}else{
av_log(NULL, AV_LOG_INFO,"location get new_url failed!\n");
}
if (c->print_m3u8)
{
while (!avio_feof(in)) {
ff_get_chomp_line(in, line, sizeof(line));
av_log(NULL, AV_LOG_VERBOSE,"m3u8 line:%s", line);
}
avio_seek(in, 0, SEEK_SET);
}
ff_get_chomp_line(in, line, sizeof(line));
if (strcmp(line, "#EXTM3U")) {
ret = AVERROR_INVALIDDATA;
goto fail;
}
if (pls) {
free_segment_list(pls);
pls->finished = 0;
pls->type = PLS_TYPE_UNSPECIFIED;
}
while (!avio_feof(in)) {
if ((ret = ff_get_chomp_line(in, line, sizeof(line))) < 0) {
av_log(NULL, AV_LOG_ERROR, "ff_get_chomp_line return error:%d", ret);
break;
}
if (av_strstart(line, "#EXT-X-STREAM-INF:", &ptr)) {
is_variant = 1;
memset(&variant_info, 0, sizeof(variant_info));
ff_parse_key_value(ptr, (ff_parse_key_val_cb) handle_variant_args,
&variant_info);
}
#ifdef HLS_I_FRAME_MODE
else if (av_strstart(line, "#EXT-X-I-FRAME-STREAM-INF:", &ptr)) {
av_log(NULL, AV_LOG_VERBOSE,"enter #EXT-X-I-FRAME-STREAM-IN------------>");
memset(&variant_info, 0, sizeof(variant_info));
ff_parse_key_value(ptr, (ff_parse_key_val_cb) handle_i_frame_variant_args,
&i_frame_variant_info);
if (!new_i_frame_variant(c, &i_frame_variant_info, url)) {
// av_log(NULL, AV_LOG_VERBOSE,"new_i_frame_variant11------------>line:%s, url:%s",line, url);
ret = AVERROR(ENOMEM);
goto fail;
}else{
//av_log(NULL, AV_LOG_VERBOSE,"new_i_frame_variant22------------>line:%s, url:%s",line, url);
}
}
#endif
else if (av_strstart(line, "#EXT-X-KEY:", &ptr)) {
struct hls_key_info info = {{0}};
ff_parse_key_value(ptr, (ff_parse_key_val_cb) handle_key_args,
&info);
key_type = KEY_NONE;
has_iv = 0;
if (!strcmp(info.method, "AES-128"))
key_type = KEY_AES_128;
if (!strcmp(info.method, "SAMPLE-AES-CTR"))
key_type = KEY_SAMPLE_AES_CTR;
else if (!strcmp(info.method, "SAMPLE-AES"))
key_type = KEY_SAMPLE_AES;
if (!strncmp(info.iv, "0x", 2) || !strncmp(info.iv, "0X", 2)) {
ff_hex_to_data(iv, info.iv + 2);
has_iv = 1;
}
av_strlcpy(key, info.uri, sizeof(key));
// todo, how to report to AmIptvMedia?
// base64 to binary
const char *base64Prefix = "data:text/plain;base64,";
if ((key_type == KEY_SAMPLE_AES || key_type == KEY_SAMPLE_AES_CTR)
&& info.uri && strlen(info.uri) > strlen(base64Prefix)
&& !strncmp(info.uri, base64Prefix, strlen(base64Prefix))) {
char *base64Str = info.uri + strlen(base64Prefix);
size_t size = AV_BASE64_DECODE_SIZE(strlen(base64Str));
uint8_t *pssh = av_malloc(size);
int pssh_size = av_base64_decode(pssh, base64Str, size);
av_log(0, AV_LOG_ERROR, "notify base64Str:%s pssh: %s", base64Str, (char*)pssh);
c->hls_notify_direct((void *)c->session, ffObFFMPEG_PSSH_UPDATE, (int64_t)(intptr_t)pssh, pssh_size, 0);
av_free(pssh);
}
} else if (av_strstart(line, "#EXT-X-MEDIA:", &ptr)) {
struct rendition_info info = {{0}};
ff_parse_key_value(ptr, (ff_parse_key_val_cb) handle_rendition_args,
&info);
new_rendition(c, &info, url_origin);
} else if (av_strstart(line, "#EXT-X-TARGETDURATION:", &ptr)) {
ret = ensure_playlist(c, &pls, url_origin);
if (ret < 0)
goto fail;
pls->target_duration = strtoll(ptr, NULL, 10) * AV_TIME_BASE;
} else if (av_strstart(line, "#EXT-X-MEDIA-SEQUENCE:", &ptr)) {
ret = ensure_playlist(c, &pls, url_origin);
if (ret < 0)
goto fail;
pls->start_seq_no = atoi(ptr);
} else if (av_strstart(line, "#EXT-X-PROGRAM-DATE-TIME:", &ptr)) {
seg_time_us = parse_date_time_us(ptr);
av_log(0, AV_LOG_VERBOSE, "Program date time: %lld\n", seg_time_us);
} else if (av_strstart(line, "#EXT-X-PLAYLIST-TYPE:", &ptr)) {
ret = ensure_playlist(c, &pls, url_origin);
if (ret < 0)
goto fail;
if (!strcmp(ptr, "EVENT"))
pls->type = PLS_TYPE_EVENT;
else if (!strcmp(ptr, "VOD"))
pls->type = PLS_TYPE_VOD;
} else if (av_strstart(line, "#EXT-X-MAP:", &ptr)) {
struct init_section_info info = {{0}};
ret = ensure_playlist(c, &pls, url_origin);
if (ret < 0)
goto fail;
ff_parse_key_value(ptr, (ff_parse_key_val_cb) handle_init_section_args,
&info);
cur_init_section = new_init_section(pls, &info, url);
} else if (av_strstart(line, "#EXT-X-ENDLIST", &ptr)) {
if (pls)
pls->finished = 1;
} else if (av_strstart(line, "#EXTINF:", &ptr)) {
is_segment = 1;
duration = atof(ptr) * AV_TIME_BASE;
} else if (av_strstart(line, "#EXT-X-BYTERANGE:", &ptr)) {
seg_size = strtoll(ptr, NULL, 10);
ptr = strchr(ptr, '@');
if (ptr)
seg_offset = strtoll(ptr+1, NULL, 10);
} else if (av_strstart(line, "#EXT-X-DISCONTINUITY", &ptr)) {
av_log(NULL, AV_LOG_WARNING, "#EXT-X-DISCONTINUITY found!");
} else if (av_strstart(line, "#", NULL)) {
continue;
} else if (line[0]) {
if (is_variant) {
if (!new_variant(c, &variant_info, line, url_origin)) {
ret = AVERROR(ENOMEM);
goto fail;
}
is_variant = 0;
}
if (is_segment) {
struct segment *seg;
if (!pls) {
if (!new_variant(c, 0, url_origin, NULL)) {
ret = AVERROR(ENOMEM);
goto fail;
}
pls = c->playlists[c->n_playlists - 1];
}
seg = av_malloc(sizeof(struct segment));
if (!seg) {
ret = AVERROR(ENOMEM);
goto fail;
}
seg->fetch_starttime = 0;
seg->last_readtime = 0;
seg->duration = duration;
seg->timestamp_us_in_url = seg->timestamp_us_in_url_next = seg_time_us;
seg_time_us += duration;
seg->key_type = key_type;
c->ctx_key_type = key_type;
if (has_iv) {
memcpy(seg->iv, iv, sizeof(iv));
} else {
int seq = pls->start_seq_no + pls->n_segments;
memset(seg->iv, 0, sizeof(seg->iv));
AV_WB32(seg->iv + 12, seq);
}
if (key_type != KEY_NONE) {
ff_make_absolute_url(tmp_str, sizeof(tmp_str), url, key);
seg->key = av_strdup(tmp_str);
if (!seg->key) {
av_free(seg);
ret = AVERROR(ENOMEM);
goto fail;
}
} else {
seg->key = NULL;
}
ff_make_absolute_url(tmp_str, sizeof(tmp_str), url, line);
seg->url = av_strdup(tmp_str);
if (c->print_m3u8)
{
av_log(NULL, AV_LOG_VERBOSE,"seg url:%s", trimLeadingCharacter(seg->url));
av_log(NULL, AV_LOG_VERBOSE,"url url:%s", trimLeadingCharacter(url));
av_log(NULL, AV_LOG_VERBOSE,"line:%s", line);
}
if (!seg->url) {
av_free(seg->key);
av_free(seg);
ret = AVERROR(ENOMEM);
goto fail;
}
dynarray_add(&pls->segments, &pls->n_segments, seg);
is_segment = 0;
seg->size = seg_size;
if (seg_size >= 0) {
seg->url_offset = seg_offset;
seg_offset += seg_size;
seg_size = -1;
} else {
seg->url_offset = 0;
seg_offset = 0;
}
seg->init_section = cur_init_section;
}
}
}
if (pls)
pls->last_load_time = av_gettime_relative();
fail:
av_free(new_url);
if (close_in)
ff_format_io_close(c->ctx, &in);
c->ctx->ctx_flags = c->ctx->ctx_flags & ~(unsigned)AVFMTCTX_UNSEEKABLE;
if (!c->n_variants || !c->variants[c->varrant_used]->n_playlists ||
!(c->variants[c->varrant_used]->playlists[0]->finished ||
c->variants[c->varrant_used]->playlists[0]->type == PLS_TYPE_EVENT))
c->ctx->ctx_flags |= AVFMTCTX_UNSEEKABLE;
return ret;
}
static struct segment *current_segment(struct playlist *pls)
{
return pls->segments[pls->cur_seq_no - pls->start_seq_no];
}
static struct segment *next_segment(struct playlist *pls)
{
int n = pls->cur_seq_no - pls->start_seq_no + 1;
if (n >= pls->n_segments)
return NULL;
return pls->segments[n];
}
enum ReadFromURLMode {
READ_NORMAL,
READ_COMPLETE,
};
static int read_from_url(struct playlist *pls, struct segment *seg,
uint8_t *buf, int buf_size,
enum ReadFromURLMode mode)
{
int ret;
/* limit read if the segment was only a part of a file */
if (seg->size >= 0)
buf_size = FFMIN(buf_size, seg->size - pls->cur_seg_offset);
if (buf_size <= 0)
{
return AVERROR_EOF;
}
if (mode == READ_COMPLETE) {
ret = avio_read(pls->input, buf, buf_size);
if (ret != buf_size)
av_log(NULL, AV_LOG_ERROR,"Could not read complete segment.\n");
} else
ret = avio_read(pls->input, buf, buf_size);
if (ret > 0)
pls->cur_seg_offset += ret;
return ret;
}
/* Parse the raw ID3 data and pass contents to caller */
static void parse_id3(AVFormatContext *s, AVIOContext *pb,
AVDictionary **metadata, int64_t *dts,
ID3v2ExtraMetaAPIC **apic, ID3v2ExtraMeta **extra_meta)
{
static const char id3_priv_owner_ts[] = "com.apple.streaming.transportStreamTimestamp";
ID3v2ExtraMeta *meta;
ff_id3v2_read_dict(pb, metadata, ID3v2_DEFAULT_MAGIC, extra_meta);
for (meta = *extra_meta; meta; meta = meta->next) {
if (!strcmp(meta->tag, "PRIV")) {
ID3v2ExtraMetaPRIV *priv = meta->data;
if (priv->datasize == 8 && !strcmp(priv->owner, id3_priv_owner_ts)) {
/* 33-bit MPEG timestamp */
int64_t ts = AV_RB64(priv->data);
av_log(NULL, AV_LOG_DEBUG,"HLS ID3 audio timestamp %"PRId64"\n", ts);
if ((ts & ~((1ULL << 33) - 1)) == 0)
*dts = ts;
else
av_log(NULL, AV_LOG_ERROR,"Invalid HLS ID3 audio timestamp %"PRId64"\n", ts);
}
} else if (!strcmp(meta->tag, "APIC") && apic)
*apic = meta->data;
}
}
/* Check if the ID3 metadata contents have changed */
static int id3_has_changed_values(struct playlist *pls, AVDictionary *metadata,
ID3v2ExtraMetaAPIC *apic)
{
AVDictionaryEntry *entry = NULL;
AVDictionaryEntry *oldentry;
/* check that no keys have changed values */
while ((entry = av_dict_get(metadata, "", entry, AV_DICT_IGNORE_SUFFIX))) {
oldentry = av_dict_get(pls->id3_initial, entry->key, NULL, AV_DICT_MATCH_CASE);
if (!oldentry || strcmp(oldentry->value, entry->value) != 0)
return 1;
}
/* check if apic appeared */
if (apic && (pls->ctx->nb_streams != 2 || !pls->ctx->streams[1]->attached_pic.data))
return 1;
if (apic) {
int size = pls->ctx->streams[1]->attached_pic.size;
if (size != apic->buf->size - AV_INPUT_BUFFER_PADDING_SIZE)
return 1;
if (memcmp(apic->buf->data, pls->ctx->streams[1]->attached_pic.data, size) != 0)
return 1;
}
return 0;
}
/* Parse ID3 data and handle the found data */
static void handle_id3(AVIOContext *pb, struct playlist *pls)
{
AVDictionary *metadata = NULL;
ID3v2ExtraMetaAPIC *apic = NULL;
ID3v2ExtraMeta *extra_meta = NULL;
int64_t timestamp = AV_NOPTS_VALUE;
parse_id3(pls->ctx, pb, &metadata, &timestamp, &apic, &extra_meta);
if (timestamp != AV_NOPTS_VALUE) {
pls->id3_mpegts_timestamp = timestamp;
pls->id3_offset = 0;
}
if (!pls->id3_found) {
/* initial ID3 tags */
av_assert0(!pls->id3_deferred_extra);
pls->id3_found = 1;
/* get picture attachment and set text metadata */
if (pls->ctx->nb_streams)
ff_id3v2_parse_apic(pls->ctx, &extra_meta);
else
/* demuxer not yet opened, defer picture attachment */
pls->id3_deferred_extra = extra_meta;
ff_id3v2_parse_priv_dict(&metadata, &extra_meta);
av_dict_copy(&pls->ctx->metadata, metadata, 0);
pls->id3_initial = metadata;
} else {
if (!pls->id3_changed && id3_has_changed_values(pls, metadata, apic)) {
avpriv_report_missing_feature(pls->ctx, "Changing ID3 metadata in HLS audio elementary stream");
pls->id3_changed = 1;
}
av_dict_free(&metadata);
}
if (!pls->id3_deferred_extra)
ff_id3v2_free_extra_meta(&extra_meta);
}
static void intercept_id3(struct playlist *pls, uint8_t *buf,
int buf_size, int *len)
{
/* intercept id3 tags, we do not want to pass them to the raw
* demuxer on all segment switches */
int bytes;
int id3_buf_pos = 0;
int fill_buf = 0;
struct segment *seg = current_segment(pls);
/* gather all the id3 tags */
while (1) {
/* see if we can retrieve enough data for ID3 header */
if (*len < ID3v2_HEADER_SIZE && buf_size >= ID3v2_HEADER_SIZE) {
bytes = read_from_url(pls, seg, buf + *len, ID3v2_HEADER_SIZE - *len, READ_COMPLETE);
if (bytes > 0) {
if (bytes == ID3v2_HEADER_SIZE - *len)
/* no EOF yet, so fill the caller buffer again after
* we have stripped the ID3 tags */
fill_buf = 1;
*len += bytes;
} else if (*len <= 0) {
/* error/EOF */
*len = bytes;
fill_buf = 0;
}
}
if (*len < ID3v2_HEADER_SIZE)
break;
if (ff_id3v2_match(buf, ID3v2_DEFAULT_MAGIC)) {
int64_t maxsize = seg->size >= 0 ? seg->size : 1024*1024;
int taglen = ff_id3v2_tag_len(buf);
int tag_got_bytes = FFMIN(taglen, *len);
int remaining = taglen - tag_got_bytes;
if (taglen > maxsize) {
av_log(NULL, AV_LOG_ERROR,"Too large HLS ID3 tag (%d > %"PRId64" bytes)\n",
taglen, maxsize);
break;
}
/*
* Copy the id3 tag to our temporary id3 buffer.
* We could read a small id3 tag directly without memcpy, but
* we would still need to copy the large tags, and handling
* both of those cases together with the possibility for multiple
* tags would make the handling a bit complex.
*/
pls->id3_buf = av_fast_realloc(pls->id3_buf, &pls->id3_buf_size, id3_buf_pos + taglen);
if (!pls->id3_buf)
break;
memcpy(pls->id3_buf + id3_buf_pos, buf, tag_got_bytes);
id3_buf_pos += tag_got_bytes;
/* strip the intercepted bytes */
*len -= tag_got_bytes;
memmove(buf, buf + tag_got_bytes, *len);
av_log(NULL, AV_LOG_DEBUG,"Stripped %d HLS ID3 bytes\n", tag_got_bytes);
if (remaining > 0) {
/* read the rest of the tag in */
if (read_from_url(pls, seg, pls->id3_buf + id3_buf_pos, remaining, READ_COMPLETE) != remaining)
break;
id3_buf_pos += remaining;
av_log(NULL, AV_LOG_DEBUG,"Stripped additional %d HLS ID3 bytes\n", remaining);
}
} else {
/* no more ID3 tags */
break;
}
}
/* re-fill buffer for the caller unless EOF */
if (*len >= 0 && (fill_buf || *len == 0)) {
bytes = read_from_url(pls, seg, buf + *len, buf_size - *len, READ_NORMAL);
/* ignore error if we already had some data */
if (bytes >= 0)
*len += bytes;
else if (*len == 0)
*len = bytes;
}
if (pls->id3_buf) {
/* Now parse all the ID3 tags */
AVIOContext id3ioctx;
ffio_init_context(&id3ioctx, pls->id3_buf, id3_buf_pos, 0, NULL, NULL, NULL, NULL);
handle_id3(&id3ioctx, pls);
}
if (pls->is_id3_timestamped == -1)
pls->is_id3_timestamped = (pls->id3_mpegts_timestamp != AV_NOPTS_VALUE);
}
static int open_input(HLSContext *c, struct playlist *pls, struct segment *seg, AVIOContext **in)
{
AVDictionary *opts = NULL;
int ret;
int is_http = 0;
// broker prior HTTP options that should be consistent across requests
av_dict_set(&opts, "user_agent", c->user_agent, 0);
av_dict_set(&opts, "referer", c->referer, 0);
av_dict_set(&opts, "cookies", c->cookies, 0);
av_dict_set(&opts, "headers", c->headers, 0);
av_dict_set(&opts, "http_proxy", c->http_proxy, 0);
if (c->http_persistent)
av_dict_set(&opts, "multiple_requests", "1", 0);
if (seg->size >= 0) {
/* try to restrict the HTTP request to the part we want
* (if this is in fact a HTTP request) */
av_dict_set_int(&opts, "offset", seg->url_offset, 0);
av_dict_set_int(&opts, "end_offset", seg->url_offset + seg->size, 0);
}
if (c->retry_segment_cnt < 0) {
if (pls->finished) {
c->http_always_reconnect = 1;
} else {
c->http_always_reconnect = 0;
}
}
av_dict_set_int(&c->avio_opts, "http_always_reconnect", c->http_always_reconnect, 0);
av_log(NULL, AV_LOG_DEBUG,"HLS request for url '%s', offset %" PRId64 ", playlist %d\n",
trimLeadingCharacter(seg->url), seg->url_offset, pls->index);
if (seg->key_type == KEY_NONE) {
ret = open_url(pls->parent, in, seg->url, c->avio_opts, opts, &is_http);
} else if (seg->key_type == KEY_AES_128) {
AVDictionary *opts2 = NULL;
char iv[33], key[33], url[MAX_URL_SIZE];
if (strcmp(seg->key, pls->key_url)) {
AVIOContext *pb = NULL;
if (open_url(pls->parent, &pb, seg->key, c->avio_opts, opts, NULL) == 0) {
ret = avio_read(pb, pls->key, sizeof(pls->key));
if (ret != sizeof(pls->key)) {
av_log(NULL, AV_LOG_ERROR,"Unable to read key file %s\n",
seg->key);
}
ff_format_io_close(pls->parent, &pb);
} else {
av_log(NULL, AV_LOG_ERROR,"Unable to open key file %s\n",
seg->key);
}
av_strlcpy(pls->key_url, seg->key, sizeof(pls->key_url));
}
ff_data_to_hex(iv, seg->iv, sizeof(seg->iv), 0);
ff_data_to_hex(key, pls->key, sizeof(pls->key), 0);
iv[32] = key[32] = '\0';
if (strstr(seg->url, "://"))
snprintf(url, sizeof(url), "crypto+%s", seg->url);
else
snprintf(url, sizeof(url), "crypto:%s", seg->url);
av_dict_copy(&opts2, c->avio_opts, 0);
av_dict_set(&opts2, "key", key, 0);
av_dict_set(&opts2, "iv", iv, 0);
ret = open_url(pls->parent, in, url, opts2, opts, &is_http);
av_dict_free(&opts2);
if (ret < 0) {
goto cleanup;
}
ret = 0;
} else if (seg->key_type == KEY_SAMPLE_AES || seg->key_type == KEY_SAMPLE_AES_CTR) {
// av_log(NULL, AV_LOG_ERROR,"SAMPLE-AES encryption is not supported yet\n");
ret = open_url(pls->parent, in, seg->url, c->avio_opts, opts, &is_http);
// ret = AVERROR_PATCHWELCOME;
}
else
ret = AVERROR(ENOSYS);
/* Seek to the requested position. If this was a HTTP request, the offset
* should already be where want it to, but this allows e.g. local testing
* without a HTTP server.
*
* This is not done for HTTP at all as avio_seek() does internal bookkeeping
* of file offset which is out-of-sync with the actual offset when "offset"
* AVOption is used with http protocol, causing the seek to not be a no-op
* as would be expected. Wrong offset received from the server will not be
* noticed without the call, though.
*/
if (ret == 0 && !is_http && seg->key_type == KEY_NONE && seg->url_offset) {
int64_t seekret = avio_seek(*in, seg->url_offset, SEEK_SET);
if (seekret < 0) {
av_log(NULL, AV_LOG_ERROR, "Unable to seek to offset %"PRId64" of HLS segment '%s'\n", seg->url_offset, seg->url);
ret = seekret;
ff_format_io_close(pls->parent, in);
}
}
cleanup:
av_dict_free(&opts);
pls->cur_seg_offset = 0;
return ret;
}
static int hls_check_requested(struct playlist *pls)
{
if (!pls)
return 0;
if (pls->reopen_playlist_requested
|| pls->switch_variant_requested != -1) {
return AVERROR_EOF;
}
return 0;
}
static int update_init_section(struct playlist *pls, struct segment *seg)
{
static const int max_init_section_size = 1024*1024;
HLSContext *c = pls->parent->priv_data;
int64_t sec_size;
int64_t urlsize;
int ret;
if ((seg->init_section == pls->cur_init_section
|| (seg->init_section && pls->cur_init_section && !strcmp(seg->init_section->url, pls->cur_init_section->url)))
&& pls->init_section_update_status == INIT_SEC_UPDATE_NONE)
return 0;
if (pls->cur_init_section) {
switch (pls->init_section_update_status) {
case INIT_SEC_UPDATE_NONE:
pls->init_section_update_status = INIT_SEC_UPDATE_WAITING_REOPEN;
case INIT_SEC_UPDATE_WAITING_REOPEN:
av_log(0, AV_LOG_INFO, "wait for reopen pls->ctx,pls->cur_init_section:%s\n",trimLeadingCharacter(pls->cur_init_section->url));
return AVERROR_EOF;
case INIT_SEC_UPDATE_REOPEN_DONE:
default:
av_log(0, AV_LOG_INFO, "update init section\n");
pls->init_section_update_status = INIT_SEC_UPDATE_NONE;
}
}
pls->cur_init_section = NULL;
if (!seg->init_section)
return 0;
ret = open_input(c, pls, seg->init_section, &pls->input);
if (ret < 0) {
av_log(NULL, AV_LOG_WARNING,"Failed to open an initialization section in playlist %d, ret:%d\n",
pls->index, ret);
c->read_data_error = ret;
return ret;
}
if (seg->init_section->size >= 0)
sec_size = seg->init_section->size;
else if ((urlsize = avio_size(pls->input)) >= 0)
sec_size = urlsize;
else
sec_size = max_init_section_size;
av_log(NULL, AV_LOG_INFO,"Downloading an initialization section of size %"PRId64"\n",
sec_size);
sec_size = FFMIN(sec_size, max_init_section_size);
av_fast_malloc(&pls->init_sec_buf, &pls->init_sec_buf_size, sec_size);
ret = read_from_url(pls, seg->init_section, pls->init_sec_buf,
pls->init_sec_buf_size, READ_COMPLETE);
ff_format_io_close(pls->parent, &pls->input);
if (ret < 0) {
av_log(0, AV_LOG_ERROR, "read_from_url ret:%d\n", ret);
c->read_data_error = ret;
return ret;
}
pls->cur_init_section = seg->init_section;
pls->init_sec_data_len = ret;
pls->init_sec_buf_read_offset = 0;
/* spec says audio elementary streams do not have media initialization
* sections, so there should be no ID3 timestamps */
pls->is_id3_timestamped = 0;
return 0;
}
static int64_t default_reload_interval(struct playlist *pls)
{
return pls->n_segments > 0 ?
pls->segments[pls->n_segments - 1]->duration :
pls->target_duration;
}
static int playlist_needed(struct playlist *pls)
{
AVFormatContext *s = pls->parent;
int i, j;
int stream_needed = 0;
int first_st;
/* If there is no context or streams yet, the playlist is needed */
if (!pls->ctx || !pls->n_main_streams)
return 1;
/* check if any of the streams in the playlist are needed */
for (i = 0; i < pls->n_main_streams; i++) {
if (pls->main_streams[i]->discard < AVDISCARD_ALL) {
stream_needed = 1;
break;
}
}
/* If all streams in the playlist were discarded, the playlist is not
* needed (regardless of whether whole programs are discarded or not). */
if (!stream_needed)
return 0;
/* Otherwise, check if all the programs (variants) this playlist is in are
* discarded. Since all streams in the playlist are part of the same programs
* we can just check the programs of the first stream. */
first_st = pls->main_streams[0]->index;
for (i = 0; i < s->nb_programs; i++) {
AVProgram *program = s->programs[i];
if (program->discard < AVDISCARD_ALL) {
for (j = 0; j < program->nb_stream_indexes; j++) {
if (program->stream_index[j] == first_st) {
/* playlist is in an undiscarded program */
return 1;
}
}
}
}
/* some streams were not discarded but all the programs were */
return 0;
}
#define kNeedReopenPlaylistCount (99)
static int read_data(void *opaque, uint8_t *buf, int buf_size)
{
struct playlist *v = opaque;
HLSContext *c = v->parent->priv_data;
int ret;
int just_opened = 0;
int reload_count = 0;
struct segment *seg;
/*seg is not open ,record the time for timeout*/
if (v->input == NULL)
v->fetch_start = av_gettime_relative();
/*Now ensure that the read_data is successful, and if it fails, it will exit the playback*/
if (c->read_data_error) {
char errbuf[50]={0};
av_strerror(c->read_data_error, errbuf, sizeof(errbuf));
av_log(NULL, AV_LOG_INFO,"error!!! read_data_error:%d,EOF:%d, %s", c->read_data_error, AVERROR_EOF,errbuf);
return c->read_data_error;
}
/* read_date must bee nonbock , so sleep in player thread,
switch bandwidth and read frame or read data use the same lock,
so read data should quickly as soon as possible*/
if (c->expire_time > av_gettime_relative()) {
av_log(NULL, AV_LOG_VERBOSE,"error--------------------->55555timeout\n");
return AVERROR(ETIMEDOUT);
}
restart:
if (!v->needed)
return AVERROR_EOF;
if (!v->input || (c->http_persistent && v->input_read_done)) {
int64_t reload_interval;
/* Check that the playlist is still needed before opening a new
* segment. */
v->needed = playlist_needed(v);
if (!v->needed) {
av_log(NULL, AV_LOG_INFO,"No longer receiving playlist %d\n",
v->index);
return AVERROR_EOF;
}
/* If this is a live stream and the reload interval has elapsed since
* the last playlist reload, reload the playlists now. */
reload_interval = default_reload_interval(v);
reload:
reload_count++;
if (reload_count > c->max_reload)
return AVERROR_EOF;
if (c->hls_thread_enable)
{
if (v->finished)
{
}
if (v->playlist_pb && !v->finished)
{
if (c->hlsLiveMode == HLS_MODE_LIVE_SHIFT && v->timeshif_url)
{
memcpy(v->url, v->timeshif_url, sizeof(v->url) - 1);
}
ret = parse_playlist(c, v->url, v, v->playlist_pb);
if (ret < 0) {
if (ret != AVERROR_EXIT)
{
av_log(NULL, AV_LOG_WARNING,"Failed to reload playlist_pb %d\n",
v->index);
}
}
ff_format_io_close(c->ctx, &v->playlist_pb);
v->playlist_pb = NULL;
if (ret < 0) {
return ret;
}
reload_interval = v->target_duration / 2;
} else {
if (!v->finished && v->playlist_pb == NULL &&
(av_gettime_relative() - v->last_load_time >= reload_interval) &&
c->net_down_wait_parse_playlist) {
return AVERROR(EAGAIN); /* wait network up and flush playlist ok */
}
//return AVERROR(ETIMEDOUT);
}
}
else if (!v->finished &&
av_gettime_relative() - v->last_load_time >= reload_interval) {
if ((ret = parse_playlist(c, v->url, v, NULL)) < 0) {
if (ret != AVERROR_EXIT)
av_log(NULL, AV_LOG_WARNING,"Failed to reload playlist %d\n",
v->index);
return ret;
}
/* If we need to reload the playlist again below (if
* there's still no more segments), switch to a reload
* interval of half the target duration. */
reload_interval = v->target_duration / 2;
}
if (v->cur_seq_no < v->start_seq_no) {
av_log(NULL, AV_LOG_WARNING,"skipping %d segments ahead, expired from playlists\n",
v->start_seq_no - v->cur_seq_no);
v->cur_seq_no = v->start_seq_no;
}
if (v->cur_seq_no >= v->start_seq_no + v->n_segments) {
av_log(NULL, AV_LOG_VERBOSE, "reach the latest segment start:%d cur:%d, n_segments:%d, finish:%d, buffer:%d\n",
v->start_seq_no, v->cur_seq_no, v->n_segments, v->finished, v->pb.buf_end - v->pb.buf_ptr);
if (v->finished)
{
hls_bw_eof(c->hlsBandWidth);
return AVERROR_EOF;
}
if (c->hls_thread_enable) {
if (v->cur_seq_no > v->start_seq_no + v->n_segments +1) {
av_log(NULL, AV_LOG_WARNING,"cur_seq_no:%d >= start_seq_no:%d + segments:%d\n",
v->cur_seq_no, v->start_seq_no, v->n_segments +1);
v->cur_seq_no = v->start_seq_no;
} else {
//TODO
//sleep not good
//use sleep with interrupt or del it
//av_usleep(20*1000);
}
// return AVERROR(EAGAIN);
if (v->pb.buf_end - v->pb.buf_ptr > 0)
return AVERROR(EAGAIN);
while (1) {
if (ff_check_interrupt(c->interrupt_callback))
return AVERROR_EXIT;
c->m3u8UpdateFunc(c->parserHandle, 0);
if (v->playlist_pb) {
goto reload;
} else if (c->read_data_error) {
char errbuf[50]={0};
av_strerror(c->read_data_error, errbuf, sizeof(errbuf));
av_log(NULL, AV_LOG_INFO,"error!!! read_data_error:%d,EOF:%d, %s", c->read_data_error, AVERROR_EOF,errbuf);
return c->read_data_error;
} else {
av_usleep(1000 * 20);
}
}
}
while (av_gettime_relative() - v->last_load_time < reload_interval) {
if (ff_check_interrupt(c->interrupt_callback))
return AVERROR_EXIT;
//this sleep unreachable
//call_AMLSleep_msleep((void *)c->AMLSleep, 100);
c->expire_time = av_gettime_relative() + 100*1000;
}
/* Enough time has elapsed since the last reload */
goto reload;
}
v->input_read_done = 0;
seg = current_segment(v);
/* load/update Media Initialization Section, if any */
ret = update_init_section(v, seg);
if (ret) {
char errbuf[50]={0};
av_strerror(ret, errbuf, sizeof(errbuf));
av_log(NULL, AV_LOG_VERBOSE,"update_init_section, ret:%d, %s, playlist:%p, cur_seq_no:%d, start_seq_no:%d, n_segments:%d, url:%s\n", ret, errbuf, v, v->cur_seq_no, v->start_seq_no, v->n_segments, trimLeadingCharacter(seg->url));
return ret;
}
/* 1.check reopen playlist, if any
2.check switch variant, if any
*/
ret = hls_check_requested(v);
if (ret) {
av_log(NULL, AV_LOG_INFO,"[HlsAdaptive] psl:%p, pls->reopen_playlist_requested:%d, switch_variant_requested:%d", v, v->reopen_playlist_requested, v->switch_variant_requested);
return ret;
}
#ifdef HLS_I_FRAME_MODE
if (c->http_multiple == 1 && v->input_next_requested && !c->i_frame_mode)
#else
if (c->http_multiple == 1 && v->input_next_requested)
#endif
{
FFSWAP(AVIOContext *, v->input, v->input_next);
v->input_next_requested = 0;
ret = 0;
av_log(NULL, AV_LOG_INFO,"index:%d, replace input ts, pls:%p, cur_seq_no:%d, start_seq_no:%d, cur-start diff:%d, n_segments:%d, duration:%lld, url:%s", v->index, v, v->cur_seq_no, v->start_seq_no, v->cur_seq_no-v->start_seq_no, v->n_segments, seg->duration, trimLeadingCharacter(seg->url));
} else {
av_log(NULL, AV_LOG_INFO,"index:%d, open input ts, pls:%p, cur_seq_no:%d, start_seq_no:%d, cur-start diff:%d, n_segments:%d, duration:%lld, url:%s", v->index, v, v->cur_seq_no, v->start_seq_no, v->cur_seq_no - v->start_seq_no, v->n_segments, seg->duration, trimLeadingCharacter(seg->url));
ret = open_input(c, v, seg, &v->input);
}
if (ret < 0) {
if (ff_check_interrupt(c->interrupt_callback))
return AVERROR_EXIT;
char errbuf[50]={0};
int ret1 = 0;
if (check_net_phy_conn_status() == 0)
{
av_log(NULL, AV_LOG_WARNING,"hls net down");
set_dns_net_down();
c->net_down_wait_parse_playlist = 1;
return AVERROR_NET_NEED_RECONNECT;
}
//refresh m3u8
if (ret == AVERROR_HTTP_FORBIDDEN ||
ret == AVERROR_HTTP_NOT_FOUND ||
ret == AVERROR_HTTP_OTHER_4XX ||
ret == AVERROR_HTTP_SERVER_ERROR) {
av_strerror(ret, errbuf, sizeof(errbuf));
av_log(NULL, AV_LOG_WARNING,"Failed err:%s, need to refresh pls %d of playlist %d, ,url:%s\n",
errbuf,
v->cur_seq_no,
v->index,
v->url);
if (c->retry_segment_cnt < 0 && v->finished) {
v->cur_seq_no++;
c->cur_seq_no = v->cur_seq_no;
v->open_retrytime = 0;
return AVERROR(EAGAIN);
} else {
if (v->redirect_url)
av_freep(&v->redirect_url);
if ((ret1 = parse_playlist(c, v->url, v, NULL)) < 0) {
av_strerror(ret1, errbuf, sizeof(errbuf));
av_log(NULL, AV_LOG_WARNING,"Failed to refresh pls %d of playlist %d, errbuf:%s,url:%s\n",
v->cur_seq_no,
v->index,
errbuf,
v->url);
}
}
}
if (c->retry_segment_cnt < 0) { /* -1 is reopen this segment forever */
return AVERROR_NET_NEED_RECONNECT;
}
c->expire_time = av_gettime_relative() + 100*1000;
if (ret < 0) {
//av_log(NULL, AV_LOG_VERBOSE,"open input ts again failed, ret:%d, add one seq then reload", ret);
//v->cur_seq_no += 1;
av_strerror(ret, errbuf, sizeof(errbuf));
{
if (c->http_persistent &&
seg->key_type == KEY_NONE && av_strstart(seg->url, "http", NULL)) {
v->input_read_done = 1;
} else {
ff_format_io_close(v->parent, &v->input);
}
v->open_retrytime++;
av_log(NULL, AV_LOG_VERBOSE,"open segment error:%s:retry:%d,cur_seq_no%d of playlist %d, start_seq_no:%d, n_segments:%d",errbuf, v->open_retrytime,v->cur_seq_no,v->index, v->start_seq_no, v->n_segments);
}
if (v->open_retrytime >= c->retry_segment_cnt + 1) { /* retry_segment_cnt, 0:is not retry, open next seg */
v->cur_seq_no++;
c->cur_seq_no = v->cur_seq_no;
v->open_retrytime = 0;
av_log(NULL, AV_LOG_VERBOSE,"open segment timeout, skip next,cur_seq_no%d, start_seq_no:%d, n_segments:%d", v->cur_seq_no, v->start_seq_no, v->n_segments);
}
return AVERROR(ETIMEDOUT);
}
}else {
/* open sucess retry time clear*/
c->net_down_wait_parse_playlist = 0;
v->open_retrytime = 0;
}
just_opened = 1;
}
if (c->http_multiple == -1) {
uint8_t *http_version_opt = NULL;
int r = av_opt_get(v->input, "http_version", AV_OPT_SEARCH_CHILDREN, &http_version_opt);
if (r >= 0) {
c->http_multiple = strncmp((const char *)http_version_opt, "1.1", 3) == 0;
av_freep(&http_version_opt);
}
}
#ifdef HLS_I_FRAME_MODE
if (!c->i_frame_mode) {
#endif
seg = next_segment(v);
if (c->http_multiple == 1 && !v->input_next_requested &&
seg && av_strstart(seg->url, "http", NULL)) {
av_log(NULL, AV_LOG_INFO, "index:%d, open input_next, pls:%p, cur_seq_no:%d, start_seq_no:%d, n_segments:%d, url:%s.", v->index, v, v->cur_seq_no, v->start_seq_no, v->n_segments, seg->url + 1);
ret = open_input(c, v, seg, &v->input_next);
if (ret < 0) {
if (ff_check_interrupt(c->interrupt_callback)) {
return AVERROR_EXIT;
}
av_log(NULL, AV_LOG_WARNING,"Failed to open segment %d of playlist %d\n",
v->cur_seq_no + 1,
v->index);
} else {
v->input_next_requested = 1;
}
}
#ifdef HLS_I_FRAME_MODE
}
#endif
if (v->init_sec_buf_read_offset < v->init_sec_data_len) {
/* Push init section out first before first actual segment */
int copy_size = FFMIN(v->init_sec_data_len - v->init_sec_buf_read_offset, buf_size);
memcpy(buf, v->init_sec_buf, copy_size);
v->init_sec_buf_read_offset += copy_size;
return copy_size;
}
//BW
#ifdef HLS_I_FRAME_MODE
if (c->n_variants > 1 && (c->quality == 2 || c->quality == 3) && !c->i_frame_mode)
#else
if (c->n_variants > 1 && (c->quality == 2 || c->quality == 3))
#endif
{
// if (!hls_bw_ready_read(c->ctx, v))
{
//playable_msec has enough,
//so sleep here
if (ff_check_interrupt(c->interrupt_callback))
return AVERROR_EXIT;
//TODO
//sleep not good
//use sleep with interrupt
//av_usleep(20*1000);
// return AVERROR(ETIMEDOUT);
}
}
seg = current_segment(v);
ret = read_from_url(v, seg, buf, buf_size, READ_NORMAL);
if (ret > 0) {
if ((just_opened || v->parse_preloaded_segment_id3_requested) && v->is_id3_timestamped != 0) {
/* Intercept ID3 tags here, elementary audio streams are required
* to convey timestamps using them in the beginning of each segment. */
intercept_id3(v, buf, buf_size, &ret);
if (v->parse_preloaded_segment_id3_requested) {
v->parse_preloaded_segment_id3_requested = 0;
av_log(NULL, AV_LOG_VERBOSE,"intercept_id3 done, parse_preloaded_segment_id3_requested:%d", v->parse_preloaded_segment_id3_requested);
}
}
v->lastread_time = av_gettime_relative();
return ret;
}
char errbuf[50]={0};
av_strerror(ret, errbuf, sizeof(errbuf));
av_log(NULL, AV_LOG_VERBOSE,"read_from_url, ret:%d,EOF:%d, %s, playlist:%p", ret, AVERROR_EOF,errbuf, v);
int64_t average_speed = -1, last_speed = -1;
hls_get_ts_speed(v->input, &average_speed, &last_speed);
//BW
int ret_bw = -1;
int64_t time = av_gettime_relative();
int islive = (v->finished ==1) ? 0:1;
if (ret == AVERROR_EOF)
{
if (c->http_persistent &&
seg->key_type == KEY_NONE && av_strstart(seg->url, "http", NULL)) {
v->input_read_done = 1;
} else {
ff_format_io_close(v->parent, &v->input);
}
#ifdef HLS_I_FRAME_MODE
judge_next_segment(v);
#else
v->cur_seq_no++;
#endif
c->cur_seq_no = v->cur_seq_no;
#ifdef HLS_I_FRAME_MODE
if (c->n_variants > 1 && (c->quality == 2 || c->quality == 3)&& !c->i_frame_mode)
#else
if (c->n_variants > 1 && (c->quality == 2 || c->quality == 3))
#endif
{
//make sure v is the main media
struct variant_t *variant = c->variants[c->varrant_used];
if (variant->playlists[0] == v)
{
if (v->cur_seq_no >= v->start_seq_no + v->n_segments) {
if (v->finished) {
hls_bw_eof(c->hlsBandWidth);
}
}
ret_bw = hls_bw_finish_one_ts(c->ctx, average_speed, last_speed);
}
}
{
if (v->reopen_playlist_enable) {
++v->each_segment_read_done;
if (v->each_segment_read_done > kNeedReopenPlaylistCount)
v->reopen_playlist_requested = 1;
if (v->each_segment_read_done % 10 == 0)
av_log(NULL, AV_LOG_INFO,"playlist:%p, enable:%d, each_segment_read_done:%d, reopen_playlist_requested:%d", v, v->reopen_playlist_enable, v->each_segment_read_done, v->reopen_playlist_requested);
} else {
v->each_segment_read_done = 0;
}
if (ret_bw >= 0) {
//disable switch_variant
v->switch_variant_requested = ret_bw;
av_log(NULL, AV_LOG_INFO,"%s %d, set switch variant requested=%d", __FUNCTION__, __LINE__, v->switch_variant_requested);
}
}
av_log(NULL, AV_LOG_VERBOSE,"eof, skip next,cur_seq_no:%d, start_seq_no:%d, n_segments:%d, ret_bw:%d, playlist:%p, switch_variant_requested:%d", v->cur_seq_no, v->start_seq_no, v->n_segments, ret_bw, v, v->switch_variant_requested);
}
else if (ret == AVERROR(EAGAIN))
{
if (c->retry_segment_cnt < 0 && islive == 0) { /* -1 is reopen this segment forever */
return AVERROR_NET_NEED_RECONNECT;
}
if ((time -v->lastread_time )/1000000 > 5)
{
if (c->http_persistent &&
seg->key_type == KEY_NONE && av_strstart(seg->url, "http", NULL)) {
v->input_read_done = 1;
} else {
ff_format_io_close(v->parent, &v->input);
v->read_retrytime++;
}
}
av_log(NULL, AV_LOG_ERROR,"EAGAIN, skip next,cur_seq_no:%d, start_seq_no:%d, n_segments:%d", v->cur_seq_no, v->start_seq_no, v->n_segments);
//call_AMLSleep_msleep((void *)c->AMLSleep, 100);
c->expire_time = time + 100*1000;
c->read_data_error = ret;
}
else
{
if (c->retry_segment_cnt < 0 && islive == 0) { /* -1 is reopen this segment forever */
return AVERROR_NET_NEED_RECONNECT;
}
if (c->http_persistent &&
seg->key_type == KEY_NONE && av_strstart(seg->url, "http", NULL)) {
v->input_read_done = 1;
} else {
ff_format_io_close(v->parent, &v->input);
}
v->read_retrytime++;
c->expire_time = time + 100*1000;
c->read_data_error = ret;
av_log(NULL, AV_LOG_ERROR,"read error:%d, cur_seq_no%d, start_seq_no:%d, n_segments:%d, url:%s", ret, v->cur_seq_no, v->start_seq_no, v->n_segments, trimLeadingCharacter(seg->url));
}
if (v->read_retrytime >= c->retry_segment_cnt + 1 && c->retry_segment_cnt >= 0) {
v->cur_seq_no++;
c->cur_seq_no = v->cur_seq_no;
v->read_retrytime = 0;
av_log(NULL, AV_LOG_VERBOSE,"retry timeout, skip next,cur_seq_no:%d, start_seq_no:%d, n_segments:%d", v->cur_seq_no, v->start_seq_no, v->n_segments);
if (c->hls_notify != NULL)
c->hls_notify((void *)c->session, ffObLOOP_ERROR, NET_ERROR_GET_DATA_TIMEOUT,0,0);
#ifdef HLS_I_FRAME_MODE
if (c->n_variants > 1 && (c->quality == 2 || c->quality == 3)&& !c->i_frame_mode)
#else
if (c->n_variants > 1 && (c->quality == 2 || c->quality == 3))
#endif
{
//make sure v is the main media
struct variant_t *variant = c->variants[c->varrant_used];
if (variant->playlists[0] == v)
{
if (v->cur_seq_no >= v->start_seq_no + v->n_segments) {
if (v->finished) {
hls_bw_eof(c->hlsBandWidth);
}
}
ret_bw = hls_bw_finish_one_ts(c->ctx, average_speed, last_speed);
}
}
}
if (c->expire_time > time)
{
return AVERROR(ETIMEDOUT);
}
goto restart;
}
static void add_renditions_to_variant(HLSContext *c, struct variant_t *var,
enum AVMediaType type, const char *group_id)
{
int i;
for (i = 0; i < c->n_renditions; i++) {
struct rendition *rend = c->renditions[i];
if (rend->type == type && !strcmp(rend->group_id, group_id)) {
if (rend->playlist)
/* rendition is an external playlist
* => add the playlist to the variant */
dynarray_add(&var->playlists, &var->n_playlists, rend->playlist);
else
/* rendition is part of the variant main Media Playlist
* => add the rendition to the main Media Playlist */
dynarray_add(&var->playlists[0]->renditions,
&var->playlists[0]->n_renditions,
rend);
}
}
}
static void add_metadata_from_renditions(AVFormatContext *s, struct playlist *pls,
enum AVMediaType type)
{
int rend_idx = 0;
int i;
for (i = 0; i < pls->n_main_streams; i++) {
AVStream *st = pls->main_streams[i];
if (st->codecpar->codec_type != type)
continue;
for (; rend_idx < pls->n_renditions; rend_idx++) {
struct rendition *rend = pls->renditions[rend_idx];
if (rend->type != type)
continue;
if (rend->language[0])
av_dict_set(&st->metadata, "language", rend->language, 0);
if (rend->name[0])
av_dict_set(&st->metadata, "comment", rend->name, 0);
st->disposition |= rend->disposition;
}
if (rend_idx >=pls->n_renditions)
break;
}
}
/* if timestamp was in valid range: returns 1 and sets seq_no
* if not: returns 0 and sets seq_no to closest segment */
static int find_timestamp_in_playlist(HLSContext *c, struct playlist *pls,
int64_t timestamp, int *seq_no)
{
int i;
int64_t pos = c->first_timestamp == AV_NOPTS_VALUE ?
0 : c->first_timestamp;
if (timestamp < pos) {
*seq_no = pls->start_seq_no;
return 0;
}
for (i = 0; i < pls->n_segments; i++) {
int64_t diff = pos + pls->segments[i]->duration - timestamp;
if (diff > 0) {
*seq_no = pls->start_seq_no + i;
return 1;
}
pos += pls->segments[i]->duration;
}
*seq_no = pls->start_seq_no + pls->n_segments - 1;
return 0;
}
static int select_cur_seq_no(HLSContext *c, struct playlist *pls)
{
int seq_no;
if (!c->hls_thread_enable)
if (!pls->finished && !c->first_packet &&
av_gettime_relative() - pls->last_load_time >= default_reload_interval(pls))
/* reload the playlist since it was suspended */
parse_playlist(c, pls->url, pls, NULL);
/* If playback is already in progress (we are just selecting a new
* playlist) and this is a complete file, find the matching segment
* by counting durations. */
if (pls->finished && c->cur_timestamp != AV_NOPTS_VALUE) {
find_timestamp_in_playlist(c, pls, c->cur_timestamp, &seq_no);
return seq_no;
}
if (!pls->finished) {
if (!c->first_packet && /* we are doing a segment selection during playback */
c->cur_seq_no >= pls->start_seq_no &&
c->cur_seq_no < pls->start_seq_no + pls->n_segments)
/* While spec 3.4.3 says that we cannot assume anything about the
* content at the same sequence number on different playlists,
* in practice this seems to work and doing it otherwise would
* require us to download a segment to inspect its timestamps. */
return c->cur_seq_no;
if (c->hlsLiveMode == HLS_MODE_LIVE)
{
/* If this is a live stream, start live_start_index segments from the
* start or end */
if (c->live_start_index < 0)
{
av_log(NULL, AV_LOG_INFO,"start no:%d, select_cur_seq_no: %d\n",pls->start_seq_no, pls->start_seq_no + FFMAX(pls->n_segments + c->live_start_index, 0));
return pls->start_seq_no + FFMAX(pls->n_segments + c->live_start_index, 0);
}
else
{
av_log(NULL, AV_LOG_INFO,"start no:%d, select_cur_seq_no: %d\n",pls->start_seq_no, pls->start_seq_no + FFMIN(c->live_start_index, pls->n_segments - 1));
return pls->start_seq_no + FFMIN(c->live_start_index, pls->n_segments - 1);
}
}
}
/* Otherwise just start on the first segment. */
av_log(NULL, AV_LOG_INFO,"select_cur_seq_no: %d\n",pls->start_seq_no);
return pls->start_seq_no;
}
static int save_avio_options(AVFormatContext *s)
{
HLSContext *c = s->priv_data;
static const char * const opts[] = {
"headers", "http_proxy", "user_agent", "user-agent", "cookies", "referer", NULL };
const char * const * opt = opts;
uint8_t *buf;
int ret = 0;
while (*opt) {
if (av_opt_get(s->pb, *opt, AV_OPT_SEARCH_CHILDREN | AV_OPT_ALLOW_NULL, &buf) >= 0) {
ret = av_dict_set(&c->avio_opts, *opt, buf,
AV_DICT_DONT_STRDUP_VAL);
if (ret < 0)
return ret;
}
opt++;
}
//for ts opt
av_dict_set_int(&c->avio_opts, "seekable", c->seekable, 0);
av_dict_set_int(&c->avio_opts, "http_reconnect", c->http_reconnect, 0);
av_dict_set_int(&c->avio_opts, "http_reconnect_at_eof", c->http_reconnect_at_eof, 0);
av_dict_set_int(&c->avio_opts, "http_reconnect_streamed", c->http_reconnect_streamed, 0);
av_dict_set_int(&c->avio_opts, "http_reconnect_delay_max", c->http_reconnect_delay_max, 1);
av_dict_set_int(&c->avio_opts, "http_always_reconnect", c->http_always_reconnect, 0);
av_dict_set_int(&c->avio_opts, "http_thread_enable", c->http_thread_enable, 0);
av_dict_set_int(&c->avio_opts, "http_thread_bufsize", c->http_thread_bufsize, 0);
av_dict_set_int(&c->avio_opts, "tcp_rw_timeout", c->tcp_rw_timeout, 0);
av_dict_set_int(&c->avio_opts, "tcp_connect_timeout", c->tcp_connect_timeout, 0);
av_dict_set_int(&c->avio_opts, "addrinfo_one_by_one", c->addrinfo_one_by_one, 0);
av_dict_set_int(&c->avio_opts, "dns_seq_mode", c->dns_seq_mode, 0);
av_dict_set_int(&c->avio_opts, "addrinfo_timeout", c->addrinfo_timeout, 0);
av_dict_set_int(&c->avio_opts, "dns_cache_timeout", c->dns_cache_timeout, 0);
return ret;
}
static int nested_io_open(AVFormatContext *s, AVIOContext **pb, const char *url,
int flags, AVDictionary **opts)
{
av_log(NULL, AV_LOG_ERROR,"A HLS playlist item '%s' referred to an external file '%s'. "
"Opening this file was forbidden for security reasons\n",
s->url, url);
return AVERROR(EPERM);
}
static void add_stream_to_programs(AVFormatContext *s, struct playlist *pls, AVStream *stream)
{
HLSContext *c = s->priv_data;
int i, j;
int bandwidth = -1;
struct variant_t *v = NULL;
#ifdef HLS_I_FRAME_MODE
for (i = 0; i < c->n_variants+c->n_i_frame_variants; i++) {
if (i < c->n_variants) {
v = c->variants[i];
}else{
v = c->i_frame_variants[i - c->n_variants];
}
for (j = 0; j < v->n_playlists; j++) {
if (v->playlists[j] != pls)
continue;
av_program_add_stream_index(s, i, stream->index);
if (bandwidth < 0)
bandwidth = v->bandwidth;
else if (bandwidth != v->bandwidth)
bandwidth = -1; /* stream in multiple variants with different bandwidths */
}
}
#else
for (i = 0; i < c->n_variants; i++) {
v = c->variants[i];
for (j = 0; j < v->n_playlists; j++) {
if (v->playlists[j] != pls)
continue;
av_program_add_stream_index(s, i, stream->index);
if (bandwidth < 0)
bandwidth = v->bandwidth;
else if (bandwidth != v->bandwidth)
bandwidth = -1; /* stream in multiple variants with different bandwidths */
}
}
#endif
if (bandwidth >= 0)
av_dict_set_int(&stream->metadata, "variant_bitrate", bandwidth, 0);
}
static int set_stream_info_from_input_stream(AVStream *st, struct playlist *pls, AVStream *ist)
{
int err;
err = avcodec_parameters_copy(st->codecpar, ist->codecpar);
if (err < 0)
return err;
if (pls->is_id3_timestamped) /* custom timestamps via id3 */
avpriv_set_pts_info(st, 33, 1, MPEG_TIME_BASE);
else
avpriv_set_pts_info(st, ist->pts_wrap_bits, ist->time_base.num, ist->time_base.den);
st->internal->need_context_update = 1;
st->id = ist->id;
{
// copy content protection info from ist to st
int origin_side_data_size = 0;
uint8_t* origin_side_data = av_stream_get_side_data(ist, AV_PKT_DATA_ENCRYPTION_INIT_INFO, &origin_side_data_size);
if (origin_side_data) {
AVEncryptionInitInfo* new_encryption_init_info = av_encryption_init_info_get_side_data(origin_side_data, origin_side_data_size);
// check if the side data is already added, if so, append the new one to the end
int old_side_data_size = 0;
uint8_t* old_side_data = av_stream_get_side_data(st, AV_PKT_DATA_ENCRYPTION_INIT_INFO, &old_side_data_size);
AVEncryptionInitInfo *old_init_info = NULL;
if (old_side_data) {
const int append_side_data = 0;// may useful in future
if (append_side_data) {
old_init_info = av_encryption_init_info_get_side_data(old_side_data, old_side_data_size);
if (old_init_info) {
for (AVEncryptionInitInfo *cur = old_init_info;; cur = cur->next) {
if (!cur->next) {
cur->next = new_encryption_init_info;
break;
}
}
new_encryption_init_info = old_init_info;
}
}
}
size_t new_side_data_size = 0;
uint8_t* new_side_data = av_encryption_init_info_add_side_data(new_encryption_init_info, &new_side_data_size);
av_stream_add_side_data(st, AV_PKT_DATA_ENCRYPTION_INIT_INFO, new_side_data, new_side_data_size);
av_encryption_init_info_free(new_encryption_init_info);
}
}
return 0;
}
/* add new subdemuxer streams to our context, if any */
static int update_streams_from_subdemuxer(AVFormatContext *s, struct playlist *pls)
{
int err;
while (pls->n_main_streams < pls->ctx->nb_streams) {
int ist_idx = pls->n_main_streams;
AVStream *st = avformat_new_stream(s, NULL);
AVStream *ist = pls->ctx->streams[ist_idx];
if (!st)
return AVERROR(ENOMEM);
st->id = pls->index;
dynarray_add(&pls->main_streams, &pls->n_main_streams, st);
add_stream_to_programs(s, pls, st);
err = set_stream_info_from_input_stream(st, pls, ist);
if (err < 0)
return err;
}
return 0;
}
static void update_noheader_flag(AVFormatContext *s)
{
HLSContext *c = s->priv_data;
int flag_needed = 0;
int i;
for (i = 0; i < c->n_playlists; i++) {
struct playlist *pls = c->playlists[i];
if (pls->has_noheader_flag) {
flag_needed = 1;
break;
}
}
if (flag_needed)
s->ctx_flags |= AVFMTCTX_NOHEADER;
else
s->ctx_flags &= ~AVFMTCTX_NOHEADER;
}
static int hls_close(AVFormatContext *s)
{
HLSContext *c = s->priv_data;
av_log(NULL, AV_LOG_INFO,"hls_close: %d\n",__LINE__);
free_playlist_list(c);
free_variant_list(c);
free_rendition_list(c);
av_dict_free(&c->avio_opts);
ff_format_io_close(c->ctx, &c->playlist_pb);
hls_bw_del(s);
// call_AMLSleep_Destroy((void *)c->AMLSleep);
return 0;
}
int hls_switch_variant(AVFormatContext *s, int varrant_used)
{
HLSContext *c = s->priv_data;
int ret = -1;
struct variant_t *variant = NULL;
if (c->n_variants <= 1 || c->n_variants < varrant_used)
{
av_log(NULL, AV_LOG_ERROR,"hls_switch_variant err, n_variants:%d, set value:%d",
c->n_variants, varrant_used);
return -1;
}
int i;
varrant_used = varrant_used < c->lowest_valid_variant ? c->lowest_valid_variant : varrant_used;
int varrant_used_last = c->varrant_used;
if (varrant_used_last == varrant_used) {
av_log(NULL, AV_LOG_ERROR,"hls_switch_variant same variant, do nothing, varrant_used_last:%d, varrant_used:%d",
varrant_used_last, varrant_used);
return -1;
}
int cur_seq_no = c->variants[varrant_used_last]->playlists[0]->cur_seq_no;
c->varrant_used = varrant_used;
variant = c->variants[c->varrant_used];
// {
// int playlists_num = c->n_playlists;
// av_log(NULL, AV_LOG_ERROR,"LNTES----------->enter hls_switch_variant varrant_used_last:%d, playlists_num:%d\n",varrant_used_last,playlists_num);
// for (int i = 0; i < playlists_num; i++)
// {
// reset_playlist(c, c->playlists[i]);
// }
// }
//close main input
{
/* Reset reading */
struct playlist *pls = c->variants[varrant_used_last]->playlists[0];
if (pls->input)
ff_format_io_close(pls->parent, &pls->input);
pls->input_read_done = 0;
pls ->open_retrytime = 0;
pls->read_retrytime = 0;
if (pls->input_next)
ff_format_io_close(pls->parent, &pls->input_next);
if (pls->playlist_pb)
ff_format_io_close(c->ctx, &pls->playlist_pb);
pls->input_next_requested = 0;
av_packet_unref(&pls->pkt);
reset_packet(&pls->pkt);
pls->pb.eof_reached = 0;
/* Clear any buffered data */
pls->pb.buf_end = pls->pb.buf_ptr = pls->pb.buffer;
/* Reset the pos, to let the mpegts demuxer know we've seeked. */
pls->pb.pos = 0;
/* Flush the packet queue of the subdemuxer. */
ff_read_frame_flush(pls->ctx);
pls->seek_flags = 0;
pls->needed = 0;
}
//clear playlists
for (i = 0; i < c->n_playlists_all; i++)
{
c->playlists[i] = NULL;
}
//set new value
c->n_playlists = variant->n_playlists;
for (i = 0; i < variant->n_playlists; i++)
{
c->playlists[i] = variant->playlists[i];
}
//parse_playlist
//for (i = 0; i < c->n_playlists; i++)
{
//struct playlist *pls = c->playlists[i];
struct playlist *pls = variant->playlists[0];
if ((ret = parse_playlist(c, pls->url, pls, NULL)) < 0)
goto fail;
}
/* Select the starting segments */
//for (i = 0; i < c->n_playlists; i++)
{
//struct playlist *pls = c->playlists[i];
struct playlist *pls = variant->playlists[0];
pls->cur_seq_no = cur_seq_no;
pls->needed = 1;
av_log(NULL, AV_LOG_INFO,"hls_switch_variant c->n_playlists:%d, pls->cur_seq_no:%d, pls:%p, pls->input:%p", c->n_playlists, pls->cur_seq_no, pls, pls->input);
}
/* Open the demuxer for each playlist */
for (i = 0; i < c->n_playlists; i++) {
struct playlist *pls = c->playlists[i];
AVInputFormat *in_fmt = NULL;
av_log(NULL, AV_LOG_VERBOSE,"hls_switch_variant enter, pls:%p, i:%d, url:%s", pls, i, trimLeadingCharacter(pls->url));
if (pls->ctx)
{
if (i == 0) {
ret = reopen_pls(s, pls);
if (ret < 0) {
c->read_data_error = AVERROR(EIO); //set err, pls restart
return ret;
}
av_log(NULL, AV_LOG_INFO,"hls_switch_variant reopen_pls, pls:%p, i:%d, url:%s", pls, i, trimLeadingCharacter(pls->url));
} else {
av_log(NULL, AV_LOG_INFO,"hls_switch_variant continue, pls:%p, ctx:%p i:%d, url:%s", pls, pls->ctx, i, trimLeadingCharacter(pls->url));
}
continue;
}
av_log(NULL, AV_LOG_VERBOSE,"hls_switch_variant start, pls:%p, ctx:%p, input:%p, i:%d, url:%s", pls, pls->ctx, pls->input, i, trimLeadingCharacter(pls->url));
if (!(pls->ctx = avformat_alloc_context())) {
ret = AVERROR(ENOMEM);
goto fail;
}
if (pls->n_segments == 0)
continue;
pls->index = i;
pls->needed = 1;
pls->parent = s;
pls->ctx->interrupt_callback = s->interrupt_callback;
pls->switch_variant_requested = -1;
pls->read_buffer = av_malloc(INITIAL_BUFFER_SIZE);
if (!pls->read_buffer) {
ret = AVERROR(ENOMEM);
avformat_free_context(pls->ctx);
pls->ctx = NULL;
goto fail;
}
ffio_init_context(&pls->pb, pls->read_buffer, INITIAL_BUFFER_SIZE, 0, pls,
read_data, NULL, NULL);
//pls->pb.seekable = 0;
ret = av_probe_input_buffer(&pls->pb, &in_fmt, pls->segments[0]->url,
NULL, 0, 0);
if (ret < 0) {
/* Free the ctx - it isn't initialized properly at this point,
* so avformat_close_input shouldn't be called. If
* avformat_open_input fails below, it frees and zeros the
* context, so it doesn't need any special treatment like this. */
av_log(NULL, AV_LOG_ERROR,"Error when loading first segment '%s'\n", trimLeadingCharacter(pls->segments[0]->url));
avformat_free_context(pls->ctx);
pls->ctx = NULL;
goto fail;
}
pls->ctx->pb = &pls->pb;
pls->ctx->io_open = nested_io_open;
pls->ctx->flags |= s->flags & ~AVFMT_FLAG_CUSTOM_IO;
if ((ret = ff_copy_whiteblacklists(pls->ctx, s)) < 0)
goto fail;
AVDictionary* opts = NULL;
av_dict_set_int(&opts, "hls_live_mode", !pls->finished, 0);
av_dict_set_int(&opts, "sidx_reference_count", 0, 0);
ret = avformat_open_input(&pls->ctx, pls->segments[0]->url, in_fmt, &opts);
av_dict_free(&opts);
if (ret < 0)
goto fail;
if (pls->id3_deferred_extra && pls->ctx->nb_streams == 1) {
ff_id3v2_parse_apic(pls->ctx, &pls->id3_deferred_extra);
avformat_queue_attached_pictures(pls->ctx);
ff_id3v2_parse_priv(pls->ctx, &pls->id3_deferred_extra);
ff_id3v2_free_extra_meta(&pls->id3_deferred_extra);
pls->id3_deferred_extra = NULL;
}
if (pls->is_id3_timestamped == -1)
av_log(NULL, AV_LOG_WARNING, "No expected HTTP requests have been made\n");
/*
* For ID3 timestamped raw audio streams we need to detect the packet
* durations to calculate timestamps in fill_timing_for_id3_timestamped_stream(),
* but for other streams we can rely on our user calling avformat_find_stream_info()
* on us if they want to.
*/
if (pls->is_id3_timestamped) {
ret = avformat_find_stream_info(pls->ctx, NULL);
if (ret < 0)
goto fail;
}
pls->has_noheader_flag = !!(pls->ctx->ctx_flags & AVFMTCTX_NOHEADER);
/* Create new AVStreams for each stream in this playlist */
ret = update_streams_from_subdemuxer(s, pls);
if (ret < 0)
goto fail;
/*
* Copy any metadata from playlist to main streams, but do not set
* event flags.
*/
if (pls->n_main_streams)
av_dict_copy(&pls->main_streams[0]->metadata, pls->ctx->metadata, 0);
add_metadata_from_renditions(s, pls, AVMEDIA_TYPE_AUDIO);
add_metadata_from_renditions(s, pls, AVMEDIA_TYPE_VIDEO);
add_metadata_from_renditions(s, pls, AVMEDIA_TYPE_SUBTITLE);
av_log(NULL, AV_LOG_VERBOSE,"hls_switch_variant done, pls:%p, pls->ctx:%p, input:%p, i:%d, url:%s", pls, pls->ctx, pls->input, i, trimLeadingCharacter(pls->url));
}
update_noheader_flag(s);
return 0;
fail:
av_log(NULL, AV_LOG_ERROR,"hls_switch_variant err");
c->varrant_used = varrant_used_last;
variant = c->variants[c->varrant_used];
for (i = 0; i < c->n_playlists_all; i++)
{
c->playlists[i] = NULL;
}
c->n_playlists = variant->n_playlists;
for (i = 0; i < variant->n_playlists; i++)
{
c->playlists[i] = variant->playlists[i];
}
return -1;
}
static void mhls_notify(void *handle, int msg, int64_t ext1, int64_t ext2, int64_t ext3)
{
av_log(NULL, AV_LOG_INFO, "msg=%d, ext1=%lld, ext2=%lld, ext3=%lld\n", msg, ext1, ext2, ext3);
if (handle == NULL)
{
av_log(NULL, AV_LOG_ERROR, "handle is null, return\n");
return;
}
if (msg == ffObFFMPEG_PMT_CHANGE)
{
AVFormatContext *ctx = (AVFormatContext*)handle;
struct playlist *pls = (struct playlist *)ctx->parent;
AVFormatContext *user_ctx = pls->parent;
HLSContext *c = user_ctx->priv_data;
if (!c->hls_switch_pmt)
{
av_log(NULL, AV_LOG_ERROR, "mhls_notify, pmt change, but do not support, hls_switch_pmt=%d\n", c->hls_switch_pmt);
return;
}
int old_pls_n_main_streams = pls->n_main_streams, ret=0, need_notify=0;
update_streams_from_subdemuxer(user_ctx, pls);
if (old_pls_n_main_streams != pls->n_main_streams)
{
av_log(NULL, AV_LOG_ERROR, "num change, need notify\n");
c->index_defaule_max = user_ctx->nb_streams - 1;
need_notify = 1;
}
for (int i = 0; i < pls->n_main_streams && i < pls->ctx->nb_streams; i++)
{
AVStream *ist = pls->ctx->streams[i];
AVStream *st = pls->main_streams[i];
if (ist->codecpar->codec_id != st->codecpar->codec_id)
{
av_log(NULL, AV_LOG_ERROR, "ctx_pid=%d codec_id=%d, pls_pid=%d, codec_id=%d", ist->id, ist->codecpar->codec_id, st->id, st->codecpar->codec_id);
ret = set_stream_info_from_input_stream(st, pls, ist);
if (ret < 0)
{
av_log(NULL, AV_LOG_ERROR, "update info error");
return;
}
else
{
av_log(NULL, AV_LOG_ERROR, "fmt change, need notify\n");
need_notify = 1;
}
}
}
av_log(NULL, AV_LOG_ERROR, "hls, old vpid=%d, apid=%d, spid=%d\n", user_ctx->streams[c->index_defaule_video]->id, user_ctx->streams[c->index_defaule_audio]->id,
user_ctx->streams[c->index_defaule_sub]->id);
if ((c->index_defaule_video != 0 && ext1 != user_ctx->streams[c->index_defaule_video]->id) ||
(c->index_defaule_audio != 0 && ext2 != user_ctx->streams[c->index_defaule_audio]->id) ||
(c->index_defaule_sub != 0 && ext3 != user_ctx->streams[c->index_defaule_sub]->id))
{
need_notify = 1;
for (int i = 0; i < user_ctx->nb_streams; i++)
{
if (user_ctx->streams[i]->id == ext1)
c->index_defaule_audio = user_ctx->streams[i]->index;
if (user_ctx->streams[i]->id == ext2)
c->index_defaule_video = user_ctx->streams[i]->index;
if (user_ctx->streams[i]->id == ext3)
c->index_defaule_sub = user_ctx->streams[i]->index;
}
av_log(NULL, AV_LOG_ERROR, "pid change, need notify\n");
av_log(NULL, AV_LOG_ERROR, "hls, new vpid=%d, apid=%d, spid=%d\n", user_ctx->streams[c->index_defaule_video]->id, user_ctx->streams[c->index_defaule_audio]->id,
user_ctx->streams[c->index_defaule_sub]->id);
}
if (c->hls_notify && c->session && need_notify && (ext1 != 0 || ext2 != 0 || ext3 != 0))
{
ctx->switching_param = (!ffchange_none);
av_log(NULL, AV_LOG_INFO, "call hls_notify, pmt change, set hls_switching_param=%d, notify %d, vpid=%d, apid=%d, spid=%d\n",
ctx->switching_param, ffObFFMPEG_PMT_CHANGE, ext1, ext2, ext3);
c->hls_notify(c->session, ffObFFMPEG_PMT_CHANGE, ext1, ext2, ext3);
}
else
av_log(NULL, AV_LOG_INFO, "m_vpid=%d, m_apid=%d, m_spid=%d, need_notify=%d, c->hls_notify is %s\n", ext1, ext2, ext3, need_notify, c->hls_notify==NULL?"null":"not null");
}
else
av_log(NULL, AV_LOG_ERROR, "do not support this msg=%d\n", msg);
return;
}
static int reopen_pls(AVFormatContext *s, struct playlist *pls)
{
av_log(NULL, AV_LOG_INFO, "reopen_pls enter, pls:%p", pls);
int ret = 0;
AVInputFormat *in_fmt = NULL;
HLSContext *c = s->priv_data;
av_freep(&pls->pb.buffer);
avformat_close_input(&pls->ctx);
if (!(pls->ctx = avformat_alloc_context())) {
ret = AVERROR(ENOMEM);
return ret;
}
pls->init_section_update_status = INIT_SEC_UPDATE_REOPEN_DONE;
pls->ctx->interrupt_callback = s->interrupt_callback;
pls->switch_variant_requested = -1;
pls->read_buffer = av_malloc(INITIAL_BUFFER_SIZE);
if (!pls->read_buffer) {
av_log(NULL, AV_LOG_ERROR, "reopen_pls read_buffer malloc failed, ret:%d\n", ret);
return AVERROR(ENOMEM);
}
ffio_init_context(&pls->pb, pls->read_buffer, INITIAL_BUFFER_SIZE, 0, pls,
read_data, NULL, NULL);
ret = av_probe_input_buffer(&pls->pb, &in_fmt, NULL,
NULL, 0, 0);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR,"Error when av_probe_input_buffer, ret:%d\n", ret);
return ret;
}
pls->ctx->pb = &pls->pb;
pls->ctx->io_open = nested_io_open;
pls->ctx->flags |= s->flags & ~AVFMT_FLAG_CUSTOM_IO;
if (c->hls_switch_pmt)
pls->ctx->parent = (void*)pls;
else
pls->ctx->parent = NULL;
if ((ret = ff_copy_whiteblacklists(pls->ctx, s)) < 0) {
av_log(NULL, AV_LOG_ERROR,"Error when copy whiteblacklists, ret:%d\n", ret);
return ret;
}
AVDictionary* opts = NULL;
av_dict_set_int(&opts, "hls_live_mode", !pls->finished, 0);
av_dict_set_int(&opts, "sidx_reference_count", 0, 0);
ret = avformat_open_input(&pls->ctx, NULL, in_fmt, &opts);
av_dict_free(&opts);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR,"Error when avformat_open_input, ret:%d\n", ret);
return ret;
}
for (int i = 0; i < pls->ctx->nb_streams && i < pls->n_main_streams; i++) {
AVStream *st = pls->main_streams[i];
AVStream *ist = pls->ctx->streams[i];
ret = set_stream_info_from_input_stream(st, pls, ist);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR,"Error when set_stream_info_from_input_stream, ret:%d\n", ret);
return ret;
}
}
pls->init_section_update_notify = 1;
av_log(NULL, AV_LOG_ERROR, "reopen_pls leave");
return ret;
}
static int hls_read_header(AVFormatContext *s)
{
void *u = (s->flags & AVFMT_FLAG_CUSTOM_IO) ? NULL : s->pb;
HLSContext *c = s->priv_data;
int ret = 0, i;
int highest_cur_seq_no = 0;
c->ctx = s;
c->interrupt_callback = &s->interrupt_callback;
c->strict_std_compliance = s->strict_std_compliance;
c->net_down_wait_parse_playlist = 0;
c->first_packet = 1;
c->i_frame_mode = 0;
c->first_timestamp = AV_NOPTS_VALUE;
c->cur_timestamp = AV_NOPTS_VALUE;
//add for amlogic, will change implament in the feauture, delete now
// c->AMLSleep = (void *)call_AMLSleep_Create();
c->expire_time = av_gettime_relative();
int64_t begin_time = c->expire_time;
c->read_data_error = 0;
c->hls_optimize_segment_timestamp_enable = am_getconfig_int_def("ffmpegctc.hls.OptSegTimestamp.enable", 1);
c->index_defaule_audio = 0;
c->index_defaule_sub = 0;
c->index_defaule_video = 0;
av_log(s, AV_LOG_INFO, "retry_segment_cnt:%d, OptSegTimestamp:%d", c->retry_segment_cnt, c->hls_optimize_segment_timestamp_enable);
if (u) {
// get the previous user agent & set back to null if string size is zero
update_options(&c->user_agent, "user_agent", u);
// get the previous cookies & set back to null if string size is zero
update_options(&c->cookies, "cookies", u);
// get the previous headers & set back to null if string size is zero
update_options(&c->headers, "headers", u);
// get the previous http proxt & set back to null if string size is zero
update_options(&c->http_proxy, "http_proxy", u);
}
if ((ret = parse_playlist(c, s->url, NULL, s->pb)) < 0)
goto fail;
if ((ret = save_avio_options(s)) < 0)
goto fail;
/* Some HLS servers don't like being sent the range header */
//av_dict_set(&c->avio_opts, "seekable", "0", 0);
if (c->n_variants == 0) {
av_log(NULL, AV_LOG_WARNING, "Empty playlist\n");
ret = AVERROR_EOF;
goto fail;
}
//reorder variants
//0 is lowest,
if (c->n_variants > 1)
{
for (i = 0; i < c->n_variants - 1; i++) {
int j = 0;
for (j = 0; j < c->n_variants - 1 - i; j++) {
if (c->variants[j]->bandwidth > c->variants[j+1]->bandwidth)
{
struct variant_t *v = c->variants[j+1];
c->variants[j+1] = c->variants[j];
c->variants[j] = v;
}
}
}
}
int lowest_valid_variant = -1;
/* Associate renditions with variants */
for (i = 0; i < c->n_variants; i++) {
struct variant_t *var = c->variants[i];
if (var->audio_group[0])
add_renditions_to_variant(c, var, AVMEDIA_TYPE_AUDIO, var->audio_group);
if (var->video_group[0])
add_renditions_to_variant(c, var, AVMEDIA_TYPE_VIDEO, var->video_group);
if (var->subtitles_group[0])
add_renditions_to_variant(c, var, AVMEDIA_TYPE_SUBTITLE, var->subtitles_group);
if (isCodecContainVideo(var->codecs)) {
var->containVideo = 1;
if (lowest_valid_variant == -1) {
lowest_valid_variant = i;
}
}
av_log(NULL, AV_LOG_INFO, "after parse playlist index=%d, bandwidth=%dbps(need >= %dKBps), num playlist=%d, containvideo=%d, resolution=%s\n",
i , var->bandwidth, var->bandwidth/1000/8 + 1, var->n_playlists, var->containVideo, var->resolution);
}
if (lowest_valid_variant != -1) {
c->lowest_valid_variant = lowest_valid_variant;
}
if (c->n_variants >= 1)
{
if (c->quality == 0) {
c->varrant_used = c->n_variants - 1;
} else if (c->quality == 1) {
c->varrant_used = 0;
} else if (c->quality == 2) {
c->varrant_used = c->n_variants -1;
} else if (c->quality == 3) {
c->varrant_used = 0;
}
c->varrant_used = c->varrant_used < c->lowest_valid_variant ? c->lowest_valid_variant : c->varrant_used;
struct variant_t *variant = c->variants[c->varrant_used];
int n_playlists = c->n_playlists;
c->playlists_all = av_mallocz(sizeof(struct playlist *) * n_playlists);
c->n_playlists_all = n_playlists;
for (i = 0; i < n_playlists; i++)
{
c->playlists_all[i] = c->playlists[i];
c->playlists[i] = NULL;
}
c->n_playlists = variant->n_playlists;
for (i = 0; i < variant->n_playlists; i++)
{
c->playlists[i] = variant->playlists[i];
}
}
/* If the playlist only contained playlists (Master Playlist),
* parse each individual playlist. */
if (c->n_playlists > 1 || c->playlists[0]->n_segments == 0) {
/*
* create pls->pb for each playlist
*/
int close_in = 0;
if (c->n_playlists > 1 || c->playlists[0]->n_segments == 0) {
for (i = 0; i < c->n_playlists; i++) {
struct playlist *pls = c->playlists[i];
int is_http = av_strstart(pls->url, "http", NULL);
AVDictionary *opts = NULL;
get_m3u8_opts(c, &opts);
//ret = c->ctx->io_open(c->ctx, &in, url, AVIO_FLAG_READ, &opts);
ret = amlio_open_whitelist(&pls->playlist_pb, pls->url, AVIO_FLAG_READ, &c->ctx->interrupt_callback, &opts,
c->ctx->protocol_whitelist, c->ctx->protocol_blacklist);
av_dict_free(&opts);
if (ret < 0)
{
if (check_net_phy_conn_status() == 0)
{
av_log(NULL, AV_LOG_WARNING,"hls net down");
set_dns_net_down();
ret = AVERROR(ETIMEDOUT);
goto fail;
}
if (pls && pls->redirect_url)
av_freep(&pls->redirect_url);
goto fail;
}
if (is_http && c->http_persistent)
c->playlist_pb = pls->playlist_pb;
else
close_in = 1;
}
}
for (i = 0; i < c->n_playlists; i++) {
struct playlist *pls = c->playlists[i];
if ((ret = parse_playlist(c, pls->url, pls, pls->playlist_pb)) < 0)
goto fail;
if (close_in)
ff_format_io_close(c->ctx, &pls->playlist_pb);
}
}
hls_bw_init(s);
if (c->variants[c->varrant_used]->playlists[0]->n_segments == 0) {
av_log(NULL, AV_LOG_WARNING, "Empty playlist\n");
ret = AVERROR_EOF;
goto fail;
}
/* If this isn't a live stream, calculate the total duration of the
* stream. */
if (c->variants[c->varrant_used]->playlists[0]->finished) {
int64_t duration = 0;
for (i = 0; i < c->variants[c->varrant_used]->playlists[0]->n_segments; i++)
duration += c->variants[c->varrant_used]->playlists[0]->segments[i]->duration;
s->duration = duration;
c->hlsLiveMode = HLS_MODE_VOD;
av_log(NULL, AV_LOG_INFO, "set livemode %d\n",c->hlsLiveMode);
}else{
switch (c->customer_hls_mode)
{
case 1:
c->hlsLiveMode = HLS_MODE_LIVE;
break;
case 2:
c->hlsLiveMode = HLS_MODE_LIVE_SHIFT;
break;
default:
c->hlsLiveMode = HLS_MODE_LIVE;
break;
}
av_log(NULL, AV_LOG_INFO, "set livemode %d, c->live_start_index:%d\n",c->hlsLiveMode, c->live_start_index);
}
#ifdef HLS_I_FRAME_MODE
/* Create a program for each variant */
for (i = 0; i < c->n_variants + c->n_i_frame_variants; i++) {
struct variant_t *v = i < c->n_variants ? c->variants[i] : c->i_frame_variants[i - c->n_variants];
AVProgram *program;
program = av_new_program(s, i);
if (!program)
goto fail;
av_dict_set_int(&program->metadata, "variant_bitrate", v->bandwidth, 0);
}
#else
/* Create a program for each variant */
for (i = 0; i < c->n_variants; i++) {
struct variant_t *v = c->variants[i];
AVProgram *program;
program = av_new_program(s, i);
if (!program)
goto fail;
av_dict_set_int(&program->metadata, "variant_bitrate", v->bandwidth, 0);
}
#endif
/* Select the starting segments */
for (i = 0; i < c->n_playlists; i++) {
struct playlist *pls = c->playlists[i];
if (pls->n_segments == 0)
continue;
pls->cur_seq_no = select_cur_seq_no(c, pls);
highest_cur_seq_no = FFMAX(highest_cur_seq_no, pls->cur_seq_no);
}
av_log(NULL, AV_LOG_INFO, "highest_cur_seq_no:%d", highest_cur_seq_no);
for (i = 0; i < c->n_playlists; i++) {
struct playlist *pls = c->playlists[i];
/*
* If this is a live stream and this playlist looks like it is one segment
* behind, try to sync it up so that every substream starts at the same
* time position (so e.g. avformat_find_stream_info() will see packets from
* all active streams within the first few seconds). This is not very generic,
* though, as the sequence numbers are technically independent.
*/
if (!pls->finished && pls->cur_seq_no == highest_cur_seq_no - 1 &&
highest_cur_seq_no < pls->start_seq_no + pls->n_segments) {
pls->cur_seq_no = highest_cur_seq_no;
}
av_log(NULL, AV_LOG_INFO, "recheck, pls:%d, cur_seq_no:%d", i, pls->cur_seq_no);
}
// pre open url before before really read packet one by one;
if (!c->read_packet_readed) {
/*
* "read_packet_readed=true" means that in hls_read_header, the link to the cur segment has been created in advance.
* Doing this is not very good and may cause problems for ID3 timestamped raw audio streams.
*/
c->read_packet_readed = 1;
av_log(NULL, AV_LOG_INFO, "enter read_packet_readed.\n");
for (i = 0; i < c->n_playlists; i++) {
struct playlist *pls = c->playlists[i];
struct segment *seg = current_segment(pls);
int ret_ = 0;
if (seg && av_strstart(seg->url, "http", NULL)) {
pls->parent = s;
pls->parse_preloaded_segment_id3_requested = 1;
ret_ = update_init_section(pls, seg);
av_log(NULL, AV_LOG_INFO,"index:%d, open input ts, cur_seq_no:%d, start_seq_no:%d, cur-start diff:%d, n_segments:%d, duration:%lld, url:%s", i, pls->cur_seq_no, pls->start_seq_no, pls->cur_seq_no - pls->start_seq_no, pls->n_segments, seg->duration, trimLeadingCharacter(seg->url));
ret_ = open_input(c, pls, seg, &pls->input);
if (ret_ < 0) {
if (ff_check_interrupt(c->interrupt_callback)) {
return AVERROR_EXIT;
}
av_log(NULL, AV_LOG_WARNING,"Failed to open segment %d of playlist %d\n",
pls->cur_seq_no,
pls->index);
}
}
}
}
/* Open the demuxer for each playlist */
for (i = 0; i < c->n_playlists; i++) {
struct playlist *pls = c->playlists[i];
AVInputFormat *in_fmt = NULL;
av_log(NULL, AV_LOG_INFO, "Open the demuxer pls:%p, i:%d", pls, i);
if (!(pls->ctx = avformat_alloc_context())) {
ret = AVERROR(ENOMEM);
goto fail;
}
if (pls->n_segments == 0)
continue;
pls->index = i;
pls->needed = 1;
pls->parent = s;
pls->ctx->interrupt_callback = s->interrupt_callback;
pls->fetch_start =0;
pls->open_retrytime =0;
pls->read_retrytime =0;
pls->each_segment_read_done = 0;
pls->reopen_playlist_requested = 0;
pls->reopen_playlist_enable = 0;
pls->switch_variant_requested = -1;
/*
* If this is a live stream and this playlist looks like it is one segment
* behind, try to sync it up so that every substream starts at the same
* time position (so e.g. avformat_find_stream_info() will see packets from
* all active streams within the first few seconds). This is not very generic,
* though, as the sequence numbers are technically independent.
*/
if (!pls->finished && pls->cur_seq_no == highest_cur_seq_no - 1 &&
highest_cur_seq_no < pls->start_seq_no + pls->n_segments) {
pls->cur_seq_no = highest_cur_seq_no;
}
pls->read_buffer = av_malloc(INITIAL_BUFFER_SIZE);
if (!pls->read_buffer) {
ret = AVERROR(ENOMEM);
avformat_free_context(pls->ctx);
pls->ctx = NULL;
goto fail;
}
ffio_init_context(&pls->pb, pls->read_buffer, INITIAL_BUFFER_SIZE, 0, pls,
read_data, NULL, NULL);
//pls->pb.seekable = 0;
ret = av_probe_input_buffer(&pls->pb, &in_fmt, pls->segments[0]->url,
NULL, 0, 0);
if (ret < 0) {
/* Free the ctx - it isn't initialized properly at this point,
* so avformat_close_input shouldn't be called. If
* avformat_open_input fails below, it frees and zeros the
* context, so it doesn't need any special treatment like this. */
av_log(NULL, AV_LOG_ERROR,"Error when loading first segment '%s'\n", pls->segments[0]->url);
avformat_free_context(pls->ctx);
pls->ctx = NULL;
goto fail;
}
pls->ctx->pb = &pls->pb;
pls->ctx->io_open = nested_io_open;
pls->ctx->flags |= s->flags & ~AVFMT_FLAG_CUSTOM_IO;
if (c->hls_switch_pmt)
pls->ctx->parent = (void*)pls;
else
pls->ctx->parent = NULL;
if ((ret = ff_copy_whiteblacklists(pls->ctx, s)) < 0)
goto fail;
AVDictionary* opts = NULL;
av_dict_set_int(&opts, "hls_live_mode", !pls->finished, 0);
av_dict_set_int(&opts, "sidx_reference_count", 0, 0);
ret = avformat_open_input(&pls->ctx, pls->segments[0]->url, in_fmt, &opts);
av_dict_free(&opts);
if (ret < 0)
goto fail;
if (pls->ctx->iformat && pls->ctx->iformat->name)
{
av_log(NULL, AV_LOG_INFO,"pls->ctx->iformat->name:%s", pls->ctx->iformat->name);
if (!strcmp(pls->ctx->iformat->name, "mpegts")) {
struct MpegTSContext *context = (struct MpegTSContext *)pls->ctx->priv_data;
if (context)
{
context->mpegts_notify = c->hls_notify;
context->session = c->session;
if (c->hls_switch_pmt)
context->parent_notify = (ffmpegts_notify_t)mhls_notify;
}
} else if (!strcmp(pls->ctx->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")) {
//mp4
pls->reopen_playlist_enable = 1;
av_log(NULL, AV_LOG_INFO, "reopen_playlist_enable:%d, pls:%p, %s", pls->reopen_playlist_enable, pls, trimLeadingCharacter(pls->segments[0]->url));
}
}
if (pls->id3_deferred_extra && pls->ctx->nb_streams == 1) {
ff_id3v2_parse_apic(pls->ctx, &pls->id3_deferred_extra);
avformat_queue_attached_pictures(pls->ctx);
ff_id3v2_parse_priv(pls->ctx, &pls->id3_deferred_extra);
ff_id3v2_free_extra_meta(&pls->id3_deferred_extra);
pls->id3_deferred_extra = NULL;
}
if (pls->is_id3_timestamped == -1)
av_log(NULL, AV_LOG_WARNING, "No expected HTTP requests have been made\n");
/*
* For ID3 timestamped raw audio streams we need to detect the packet
* durations to calculate timestamps in fill_timing_for_id3_timestamped_stream(),
* but for other streams we can rely on our user calling avformat_find_stream_info()
* on us if they want to.
*/
if (pls->is_id3_timestamped) {
ret = avformat_find_stream_info(pls->ctx, NULL);
if (ret < 0)
goto fail;
}
pls->has_noheader_flag = !!(pls->ctx->ctx_flags & AVFMTCTX_NOHEADER);
/* Create new AVStreams for each stream in this playlist */
ret = update_streams_from_subdemuxer(s, pls);
if (ret < 0)
goto fail;
/*
* Copy any metadata from playlist to main streams, but do not set
* event flags.
*/
if (pls->n_main_streams)
av_dict_copy(&pls->main_streams[0]->metadata, pls->ctx->metadata, 0);
add_metadata_from_renditions(s, pls, AVMEDIA_TYPE_AUDIO);
add_metadata_from_renditions(s, pls, AVMEDIA_TYPE_VIDEO);
add_metadata_from_renditions(s, pls, AVMEDIA_TYPE_SUBTITLE);
}
update_noheader_flag(s);
//for index change when switch BW
c->index_defaule_max = s->nb_streams - 1;
int nb_streams = s->nb_streams;
for (i = 0; i < nb_streams; i++)
{
enum AVMediaType codec_type = s->streams[i]->codecpar->codec_type;
if (codec_type == AVMEDIA_TYPE_AUDIO) {
c->index_defaule_audio = i;
} else if (codec_type == AVMEDIA_TYPE_SUBTITLE) {
c->index_defaule_sub = i;
} else if (codec_type == AVMEDIA_TYPE_VIDEO) {
c->index_defaule_video = i;
}
}
int64_t cost_time = av_gettime_relative() - begin_time;
av_log(s, AV_LOG_INFO, "hls_read_header done, cost time: %.2f ms", cost_time/1e3);
return 0;
fail:
//hls_close(s);
return ret;
}
static int recheck_discard_flags(AVFormatContext *s, int first)
{
HLSContext *c = s->priv_data;
int i, changed = 0;
int cur_needed;
/* Check if any new streams are needed */
for (i = 0; i < c->n_playlists; i++) {
struct playlist *pls = c->playlists[i];
cur_needed = playlist_needed(c->playlists[i]);
if (cur_needed && !pls->needed) {
pls->needed = 1;
changed = 1;
pls->cur_seq_no = select_cur_seq_no(c, pls);
pls->pb.eof_reached = 0;
if (c->cur_timestamp != AV_NOPTS_VALUE) {
/* catch up */
pls->seek_timestamp = c->cur_timestamp;
pls->seek_flags = AVSEEK_FLAG_ANY;
pls->seek_stream_index = -1;
}
av_log(NULL, AV_LOG_INFO,"Now receiving playlist %d, segment %d\n", i, pls->cur_seq_no);
} else if (first && !cur_needed && pls->needed) {
if (pls->input)
ff_format_io_close(pls->parent, &pls->input);
pls->input_read_done = 0;
if (pls->input_next)
ff_format_io_close(pls->parent, &pls->input_next);
if (pls->playlist_pb)
ff_format_io_close(c->ctx, &pls->playlist_pb);
pls->input_next_requested = 0;
pls->needed = 0;
changed = 1;
av_log(NULL, AV_LOG_INFO,"No longer receiving playlist %d\n", i);
}
}
return changed;
}
static void fill_timing_for_id3_timestamped_stream(struct playlist *pls)
{
if (pls->id3_offset >= 0) {
pls->pkt.dts = pls->id3_mpegts_timestamp +
av_rescale_q(pls->id3_offset,
pls->ctx->streams[pls->pkt.stream_index]->time_base,
MPEG_TIME_BASE_Q);
if (pls->pkt.duration)
pls->id3_offset += pls->pkt.duration;
else
pls->id3_offset = -1;
} else {
/* there have been packets with unknown duration
* since the last id3 tag, should not normally happen */
pls->pkt.dts = AV_NOPTS_VALUE;
}
if (pls->pkt.duration)
pls->pkt.duration = av_rescale_q(pls->pkt.duration,
pls->ctx->streams[pls->pkt.stream_index]->time_base,
MPEG_TIME_BASE_Q);
pls->pkt.pts = AV_NOPTS_VALUE;
}
static AVRational get_timebase(struct playlist *pls)
{
if (pls->is_id3_timestamped)
return MPEG_TIME_BASE_Q;
return pls->ctx->streams[pls->pkt.stream_index]->time_base;
}
static int64_t compare_ts_with_wrapdetect(int64_t ts_a, struct playlist *pls_a,
int64_t ts_b, struct playlist *pls_b)
{
int64_t scaled_ts_a = av_rescale_q(ts_a, get_timebase(pls_a), MPEG_TIME_BASE_Q);
int64_t scaled_ts_b = av_rescale_q(ts_b, get_timebase(pls_b), MPEG_TIME_BASE_Q);
return av_compare_mod(scaled_ts_a, scaled_ts_b, 1LL << 33);
}
static int hls_read_packet(AVFormatContext *s, AVPacket *pkt)
{
HLSContext *c = s->priv_data;
int ret = AVERROR_EOF, i, minplaylist = -1, isEof = 0;
int switch_varrant = -1;
if (c->hls_switch_pmt && (s->switching_param & ffchange_end))
{
for (int i = 0; i < c->n_playlists; i++)
{
if (c->playlists[i]->ctx->switching_param != ffchange_none)
{
c->playlists[i]->ctx->switching_param = ffchange_none;
av_log(NULL, AV_LOG_INFO, "ctx=%p, set switching_param=%d", c->playlists[i]->ctx, c->playlists[i]->ctx->switching_param);
}
}
s->switching_param = ffchange_none;
}
recheck_discard_flags(s, c->first_packet);
c->first_packet = 0;
/* get the smallest seq*/
int min_seq = -1;
for (i = 0; i < c->n_playlists; i++) {
struct playlist *pls = c->playlists[i];
if (pls->needed && pls->cur_seq_no >= 0) {
min_seq = min_seq < 0 ? pls->cur_seq_no : FFMIN(min_seq, pls->cur_seq_no);
}
}
for (i = 0; i < c->n_playlists; i++) {
struct playlist *pls = c->playlists[i];
if (pls->finished && pls->needed && pls->n_segments > 0 && pls->cur_seq_no >= pls->n_segments - 1) {
isEof = 1; /* when cur_seq_no is last seq no and open fail, consider stream is eof */
}
/* Make sure we've got one buffered packet from each open playlist
* stream */
av_log(NULL, AV_LOG_DEBUG, "min_seq:%d, pls->cur_seq_no:%d, pls:%p, i:%d", min_seq, pls->cur_seq_no, pls, i);
if (pls->needed && !pls->pkt.data && min_seq == pls->cur_seq_no) {
while (1) {
int64_t ts_diff;
AVRational tb;
if (c->enableRawData) {
av_init_packet(&pls->pkt);
int size_packet = 188 * 100;
uint8_t* buf = malloc(size_packet);
ret = avio_read(&pls->pb, buf, size_packet);
if (ret > 0) {
av_new_packet(&pls->pkt, ret);
memcpy(pls->pkt.data, buf, ret);
ret = 0;
}
free(buf);
} else {
ret = av_read_frame(pls->ctx, &pls->pkt);
if (ret < 0) {
if (pls->init_section_update_status == INIT_SEC_UPDATE_WAITING_REOPEN || pls->reopen_playlist_requested) {
av_log(NULL, AV_LOG_INFO, "pls->init_section_update_status:%d,pls->reopen_playlist_requested:%d", pls->init_section_update_status,pls->reopen_playlist_requested);
//always update, clear first
pls->reopen_playlist_requested = 0;
pls->each_segment_read_done = 0;
if (pls->switch_variant_requested != -1) {
pls->switch_variant_requested = -1;
av_log(NULL, AV_LOG_INFO, "enter update_status or reopen_playlist_requested, force switch_variant_requested=-1");
}
//reopen_pls
ret = reopen_pls(s, pls);
if (ret < 0)
return ret;
ret = av_read_frame(pls->ctx, &pls->pkt);
} else if (pls->switch_variant_requested != -1) {
//always update, clear first
switch_varrant = pls->switch_variant_requested;
pls->switch_variant_requested = -1;
//only video playlist will enter switch_variant_requested, so clearing the reopen parameter is possible
pls->reopen_playlist_requested = 0;
pls->each_segment_read_done = 0;
//hls_bw_switch_varrant
#ifdef HLS_I_FRAME_MODE
if (c->n_variants > 1 && (c->quality == 2 || c->quality == 3)&& !c->i_frame_mode)
#else
if (c->n_variants > 1 && (c->quality == 2 || c->quality == 3))
#endif
{
//make sure v is the main media
if (i == 0) {
ret = hls_bw_switch_varrant(s, switch_varrant);
if (ret < 0)
return ret;
//update new pls
pls = c->playlists[0];
}
}
ret = av_read_frame(pls->ctx, &pls->pkt);
}
}
av_log(0, AV_LOG_DEBUG, "pls->pkt.pts:%lld, ret:%d, c->first_timestamp:%lld, pls->init_section_update_status:%d, pls->reopen_playlist_requested:%d,"
"pls->index:%d, pls->pkt.stream_index:%d, codec_type:%d, ctx_codec_type:%d\n",
pls->pkt.pts, ret, c->first_timestamp, pls->init_section_update_status, pls->reopen_playlist_requested,
pls->index, pls->pkt.stream_index, pls->main_streams[pls->pkt.stream_index]->codecpar->codec_type, pls->ctx->streams[pls->pkt.stream_index]->codecpar->codec_type);
if (c->first_timestamp >= 0 && ret >= 0 && pls->main_streams[pls->pkt.stream_index]->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
int64_t p = av_rescale_q(pls->pkt.pts, get_timebase(pls), AV_TIME_BASE_Q);
struct segment *seg = current_segment(pls);
if (seg) {
pls->use_segment_timestamp = 1;
//update use_segment_timestamp_increment_step
int64_t step_us = 500 * 1000;//500ms
int64_t out_val = 0;
if (pls->input) {
if (av_opt_get_int(pls->ctx, "sidx_reference_count", AV_OPT_SEARCH_CHILDREN, &out_val) == 0 && out_val > 0) {
step_us = seg->duration / out_val;
}
}
pls->use_segment_timestamp_increment_step = step_us;
}
av_log(0, AV_LOG_DEBUG, "first_timestamp=%lld, pls->index:%d, cur_seg timestamp_us_in_url:%lld, diff:%lld(s),"
"use_segment_timestamp:%d, step:%d, pls:%p, pls->url:%s, pkt.duration:%lld, seg->duration:%lld\n",
c->first_timestamp, pls->index, seg->timestamp_us_in_url, (FFABS(p - seg->timestamp_us_in_url)/AV_TIME_BASE),
pls->use_segment_timestamp, pls->use_segment_timestamp_increment_step, pls, trimLeadingCharacter(pls->url), pls->pkt.duration, seg->duration);
}
if (pls->use_segment_timestamp && ret >= 0) {
struct segment *seg = current_segment(pls);
if (seg->timestamp_us_in_url > 0 && seg->timestamp_us_in_url_next > 0) {
int64_t old_timestamp = pls->pkt.pts;
int64_t timestamp_in_url = av_rescale_q(seg->timestamp_us_in_url_next, AV_TIME_BASE_Q, get_timebase(pls));
int64_t sub_diff = av_rescale(timestamp_in_url-old_timestamp, get_timebase(pls).num, get_timebase(pls).den);
pls->pkt.pts = timestamp_in_url;
pls->pkt.dts = timestamp_in_url;
if (c->hls_optimize_segment_timestamp_enable) {
if (pls->pkt.duration > 0) {
seg->timestamp_us_in_url_next += av_rescale_q(pls->pkt.duration, get_timebase(pls), AV_TIME_BASE_Q);
} else {
seg->timestamp_us_in_url_next += pls->use_segment_timestamp_increment_step;
}
seg->timestamp_us_in_url_next = seg->timestamp_us_in_url_next > seg->timestamp_us_in_url + seg->duration ? seg->timestamp_us_in_url + seg->duration : seg->timestamp_us_in_url_next;
}
av_log(0, AV_LOG_DEBUG, "reconstructed_pts=%lld, old_timestamp:%lld, sub_diff:%lld(s), next_pts:%lld, pls->pkt.duration:%lld, timestamp_us_in_url:%lld, timebase[%d,%d] pls:%p, url:%s\n",
timestamp_in_url, old_timestamp, sub_diff, seg->timestamp_us_in_url_next, av_rescale_q(pls->pkt.duration, get_timebase(pls), AV_TIME_BASE_Q),
seg->timestamp_us_in_url, get_timebase(pls).num, get_timebase(pls).den, pls, trimLeadingCharacter(pls->url));
}
}
}
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "av_read_frame ret:%d, cur_seq_no:%d, start_seq:%d, n_segments:%d, pls:%p, ctx:%p, url:%s", ret, pls->cur_seq_no, pls->start_seq_no, pls->n_segments, pls, pls->ctx, trimLeadingCharacter(pls->url));
if (!avio_feof(&pls->pb) && ret != AVERROR_EOF) {
return ret;
}
reset_packet(&pls->pkt);
break;
} else {
/* stream_index check prevents matching picture attachments etc. */
if (pls->is_id3_timestamped && pls->pkt.stream_index == 0) {
/* audio elementary streams are id3 timestamped */
fill_timing_for_id3_timestamped_stream(pls);
}
if (c->first_timestamp == AV_NOPTS_VALUE &&
pls->pkt.dts != AV_NOPTS_VALUE)
c->first_timestamp = av_rescale_q(pls->pkt.dts,
get_timebase(pls), AV_TIME_BASE_Q);
}
if (pls->seek_timestamp == AV_NOPTS_VALUE)
break;
if (pls->seek_stream_index < 0 ||
pls->seek_stream_index == pls->pkt.stream_index) {
if (pls->pkt.dts == AV_NOPTS_VALUE) {
pls->seek_timestamp = AV_NOPTS_VALUE;
break;
}
tb = get_timebase(pls);
ts_diff = av_rescale_rnd(pls->pkt.dts, AV_TIME_BASE,
tb.den, AV_ROUND_DOWN) -
pls->seek_timestamp;
if (ts_diff >= 0 && (pls->seek_flags & AVSEEK_FLAG_ANY ||
pls->pkt.flags & AV_PKT_FLAG_KEY)) {
pls->seek_timestamp = AV_NOPTS_VALUE;
break;
}
}
av_packet_unref(&pls->pkt);
reset_packet(&pls->pkt);
}
}
/* Check if this stream has the packet with the lowest dts */
if (pls->pkt.data) {
struct playlist *minpls = (minplaylist < 0 ? NULL : c->playlists[minplaylist]);
if (minplaylist < 0) {
minplaylist = i;
} else {
int64_t dts = pls->pkt.dts;
int64_t mindts = minpls->pkt.dts;
if (dts == AV_NOPTS_VALUE ||
(mindts != AV_NOPTS_VALUE && compare_ts_with_wrapdetect(dts, pls, mindts, minpls) < 0))
minplaylist = i;
}
}
}
/* If we got a packet, return it */
if (minplaylist >= 0) {
struct playlist *pls = c->playlists[minplaylist];
AVStream *ist;
AVStream *st;
ret = update_streams_from_subdemuxer(s, pls);
if (ret < 0) {
av_packet_unref(&pls->pkt);
reset_packet(&pls->pkt);
return ret;
}
// If sub-demuxer reports updated metadata, copy it to the first stream
// and set its AVSTREAM_EVENT_FLAG_METADATA_UPDATED flag.
if (pls->ctx->event_flags & AVFMT_EVENT_FLAG_METADATA_UPDATED) {
if (pls->n_main_streams) {
st = pls->main_streams[0];
av_dict_copy(&st->metadata, pls->ctx->metadata, 0);
st->event_flags |= AVSTREAM_EVENT_FLAG_METADATA_UPDATED;
}
pls->ctx->event_flags &= ~AVFMT_EVENT_FLAG_METADATA_UPDATED;
}
/* check if noheader flag has been cleared by the subdemuxer */
if (pls->has_noheader_flag && !(pls->ctx->ctx_flags & AVFMTCTX_NOHEADER)) {
pls->has_noheader_flag = 0;
update_noheader_flag(s);
}
if (pls->pkt.stream_index >= pls->n_main_streams) {
av_log(NULL, AV_LOG_ERROR,"stream index inconsistency: index %d, %d main streams, %d subdemuxer streams\n",
pls->pkt.stream_index, pls->n_main_streams, pls->ctx->nb_streams);
av_packet_unref(&pls->pkt);
reset_packet(&pls->pkt);
return AVERROR_BUG;
}
ist = pls->ctx->streams[pls->pkt.stream_index];
st = pls->main_streams[pls->pkt.stream_index];
*pkt = pls->pkt;
pkt->stream_index = st->index;
if (pls->init_section_update_notify == 1) {
pls->init_section_update_notify = 0;
c->update_pssh = 1;
} else {
c->update_pssh = 0;
}
if (pkt->stream_index > c->index_defaule_max) {
if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
pkt->stream_index = c->index_defaule_video;
} if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
pkt->stream_index = c->index_defaule_audio;
} else if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
pkt->stream_index = c->index_defaule_sub;
}
}
reset_packet(&c->playlists[minplaylist]->pkt);
if (pkt->dts != AV_NOPTS_VALUE)
c->cur_timestamp = av_rescale_q(pkt->dts,
ist->time_base,
AV_TIME_BASE_Q);
/* There may be more situations where this would be useful, but this at least
* handles newly probed codecs properly (i.e. request_probe by mpegts). */
if (ist->codecpar->codec_id != st->codecpar->codec_id) {
ret = set_stream_info_from_input_stream(st, pls, ist);
if (ret < 0) {
av_packet_unref(pkt);
return ret;
}
}
return 0;
} else {
av_log(NULL, AV_LOG_INFO, "minplaylist:%d, ret:%d, isEof:%d", minplaylist, ret, isEof);
}
if (isEof == 0) { /* if not read the last seg, do not return EOF */
return ret;
}
return AVERROR_EOF;
}
//copy form hls_read_packet
static int hls_read_one(AVFormatContext *s, HLSContext *c, struct playlist * pls)
{
int ret = 0;
/* Make sure we've got one buffered packet from each open playlist
* stream */
if (pls->needed && !pls->pkt.data) {
while (1) {
int64_t ts_diff;
AVRational tb;
ret = av_read_frame(pls->ctx, &pls->pkt);
if (ret < 0 && pls->init_section_update_status == INIT_SEC_UPDATE_WAITING_REOPEN) {
ret = reopen_pls(s, pls);
if (ret < 0)
return ret;
ret = av_read_frame(pls->ctx, &pls->pkt);
}
if (ret < 0) {
if (!avio_feof(&pls->pb) && ret != AVERROR_EOF)
return ret;
reset_packet(&pls->pkt);
break;
} else {
/* stream_index check prevents matching picture attachments etc. */
if (pls->is_id3_timestamped && pls->pkt.stream_index == 0) {
/* audio elementary streams are id3 timestamped */
fill_timing_for_id3_timestamped_stream(pls);
}
if (c->first_timestamp == AV_NOPTS_VALUE &&
pls->pkt.dts != AV_NOPTS_VALUE)
c->first_timestamp = av_rescale_q(pls->pkt.dts,
get_timebase(pls), AV_TIME_BASE_Q);
}
if (pls->seek_timestamp == AV_NOPTS_VALUE)
break;
if (pls->seek_stream_index < 0 ||
pls->seek_stream_index == pls->pkt.stream_index) {
if (pls->pkt.dts == AV_NOPTS_VALUE) {
pls->seek_timestamp = AV_NOPTS_VALUE;
break;
}
tb = get_timebase(pls);
ts_diff = av_rescale_rnd(pls->pkt.dts, AV_TIME_BASE,
tb.den, AV_ROUND_DOWN) -
pls->seek_timestamp;
if (ts_diff >= 0 && (pls->seek_flags & AVSEEK_FLAG_ANY ||
pls->pkt.flags & AV_PKT_FLAG_KEY)) {
pls->seek_timestamp = AV_NOPTS_VALUE;
break;
}
}
av_packet_unref(&pls->pkt);
reset_packet(&pls->pkt);
}
}
return ret;
}
static int hls_read_seek(AVFormatContext *s, int stream_index,
int64_t timestamp, int flags)
{
HLSContext *c = s->priv_data;
struct playlist *seek_pls = NULL;
int i, seq_no;
int j;
int stream_subdemuxer_index = 0;
int64_t first_timestamp, seek_timestamp, duration;
if ((flags & AVSEEK_FLAG_BYTE) || (c->ctx->ctx_flags & AVFMTCTX_UNSEEKABLE))
return AVERROR(ENOSYS);
first_timestamp = c->first_timestamp == AV_NOPTS_VALUE ?
0 : c->first_timestamp;
seek_timestamp = av_rescale_rnd(timestamp, AV_TIME_BASE,
s->streams[stream_index]->time_base.den,
flags & AVSEEK_FLAG_BACKWARD ?
AV_ROUND_DOWN : AV_ROUND_UP);
duration = s->duration == AV_NOPTS_VALUE ?
0 : s->duration;
if (0 < duration && duration < seek_timestamp - first_timestamp)
return AVERROR(EIO);
if (c->n_variants > 0)
{
//if had switch BW,
//the index may be changed
//find the new index
int in_same_variants = 0;
for (i = 0; i < c->n_playlists; i++) {
struct playlist *pls = c->playlists[i];
for (j = 0; j < pls->n_main_streams; j++) {
if (pls->main_streams[j]->index == stream_index)
{
in_same_variants = 1;
break;
}
}
}
if (!in_same_variants)
{
//index had change
AVStream *st = s->streams[stream_index];
enum AVMediaType avMediaType = st->codecpar->codec_type;
for (i = 0; i < c->n_playlists; i++) {
struct playlist *pls = c->playlists[i];
for (j = 0; j < pls->n_main_streams; j++) {
if (pls->main_streams[j]->codecpar->codec_type == avMediaType)
{
stream_index = pls->main_streams[j]->index;
break;
}
}
}
}
}
/* find the playlist with the specified stream */
for (i = 0; i < c->n_playlists; i++) {
struct playlist *pls = c->playlists[i];
for (j = 0; j < pls->n_main_streams; j++) {
if (pls->main_streams[j] == s->streams[stream_index]) {
seek_pls = pls;
stream_subdemuxer_index = j;
break;
}
}
}
/* check if the timestamp is valid for the playlist with the
* specified stream index */
if (!seek_pls)
return AVERROR(EIO);
/* because seq_no is change, so donot care ret */
find_timestamp_in_playlist(c, seek_pls, seek_timestamp, &seq_no);
av_log(NULL, AV_LOG_INFO,"seek, new seq:%d, old seq:%d, n_segments:%d, seek_timestamp:%" PRId64 ", fastseek:%d\n",
seq_no, seek_pls->cur_seq_no, seek_pls->n_segments, seek_timestamp, c->vod_fastseek);
if (seq_no == seek_pls->n_segments - 1 && !c->vod_fastseek)
{
//when seek to end,
//play some pic
//fastseek play from first pkt, so not need this
int64_t old_seek_timestamp = seek_timestamp;
seek_timestamp -= seek_pls->segments[seek_pls->n_segments - 1]->duration;
av_log(NULL, AV_LOG_INFO,"new time:%" PRId64 ", old time:%" PRId64 "\n", seek_timestamp, old_seek_timestamp);
}
/* set segment now so we do not need to search again below */
seek_pls->cur_seq_no = seq_no;
seek_pls->seek_stream_index = stream_subdemuxer_index;
for (i = 0; i < c->n_playlists; i++) {
/* Reset reading */
struct playlist *pls = c->playlists[i];
if (pls->input)
ff_format_io_close(pls->parent, &pls->input);
pls->input_read_done = 0;
pls->fetch_start =0;
pls->open_retrytime = 0;
pls->read_retrytime = 0;
if (pls->input_next)
ff_format_io_close(pls->parent, &pls->input_next);
if (pls->playlist_pb)
ff_format_io_close(c->ctx, &pls->playlist_pb);
pls->input_next_requested = 0;
av_packet_unref(&pls->pkt);
reset_packet(&pls->pkt);
pls->pb.eof_reached = 0;
/* Clear any buffered data */
pls->pb.buf_end = pls->pb.buf_ptr = pls->pb.buffer;
/* Reset the pos, to let the mpegts demuxer know we've seeked. */
pls->pb.pos = 0;
/* Flush the packet queue of the subdemuxer. */
ff_read_frame_flush(pls->ctx);
pls->seek_timestamp = seek_timestamp;
pls->seek_flags = flags;
if (pls != seek_pls) {
/* set closest segment seq_no for playlists not handled above */
find_timestamp_in_playlist(c, pls, seek_timestamp, &pls->cur_seq_no);
/* seek the playlist to the given position without taking
* keyframes into account since this playlist does not have the
* specified stream where we should look for the keyframes */
pls->seek_stream_index = -1;
pls->seek_flags |= AVSEEK_FLAG_ANY;
}
reopen_pls(s, pls);
}
c->cur_timestamp = seek_timestamp;
if (c->vod_fastseek)
{
int ret;
//read from first pkt
seek_pls->seek_timestamp = 0;
ret = hls_read_one(s, c, seek_pls);
if (ret >= 0)
{
seek_timestamp = av_rescale_rnd(seek_pls->pkt.dts, AV_TIME_BASE,
seek_pls->main_streams[stream_subdemuxer_index]->time_base.den,
flags & AVSEEK_FLAG_BACKWARD ?
AV_ROUND_DOWN : AV_ROUND_UP);
c->cur_timestamp = seek_timestamp;
for (i = 0; i < c->n_playlists; i++) {
struct playlist *pls = c->playlists[i];
if (pls == seek_pls)
continue;
pls->seek_timestamp = 0;
pls->seek_flags = flags;
find_timestamp_in_playlist(c, pls, seek_timestamp, &pls->cur_seq_no);
pls->seek_stream_index = -1;
pls->seek_flags |= AVSEEK_FLAG_ANY;
}
}
}
av_log(NULL, AV_LOG_INFO,"seek end");
return 0;
}
int hls_read_shift(AVFormatContext *s, char *shift_url, int varrant_used)
{
HLSContext *c = s->priv_data;
int i;
for (i = 0; i < c->n_playlists; i++) {
/* Reset reading */
struct playlist *pls = c->playlists[i];
if (pls->input)
ff_format_io_close(pls->parent, &pls->input);
pls->input_read_done = 0;
pls->fetch_start =0;
pls->open_retrytime =0;
pls->read_retrytime = 0;
if (pls->input_next)
ff_format_io_close(pls->parent, &pls->input_next);
if (pls->playlist_pb)
ff_format_io_close(c->ctx, &pls->playlist_pb);
pls->input_next_requested = 0;
av_packet_unref(&pls->pkt);
reset_packet(&pls->pkt);
pls->pb.eof_reached = 0;
/* Clear any buffered data */
pls->pb.buf_end = pls->pb.buf_ptr = pls->pb.buffer;
/* Reset the pos, to let the mpegts demuxer know we've seeked. */
pls->pb.pos = 0;
/* Flush the packet queue of the subdemuxer. */
ff_read_frame_flush(pls->ctx);
pls->seek_flags = 0;
}
struct variant_t *variant = c->variants[varrant_used];
int ret = -1;
for (i = 0; i < variant->n_playlists; i++)
{
struct playlist *seek_pls = variant->playlists[i];
if (seek_pls && seek_pls->timeshif_url)
{
av_freep(&seek_pls->timeshif_url);
}
ret = parse_playlist(c, shift_url, seek_pls, NULL);
if (ret >= 0)
{
seek_pls->cur_seq_no = seek_pls->start_seq_no;
memset(seek_pls->url, 0, MAX_URL_SIZE);
strcpy(seek_pls->url, shift_url);
} else {
av_log(NULL, AV_LOG_ERROR,"hls_read_shift err :%d", ret);
break;
}
}
return ret;
}
static int hls_probe(AVProbeData *p)
{
/* Require #EXTM3U at the start, and either one of the ones below
* somewhere for a proper match. */
if (strncmp(p->buf, "#EXTM3U", 7))
return 0;
if (strstr(p->buf, "#EXT-X-STREAM-INF:") ||
strstr(p->buf, "#EXT-X-TARGETDURATION:") ||
strstr(p->buf, "#EXT-X-MEDIA-SEQUENCE:"))
return AVPROBE_SCORE_MAX;
return 0;
}
int64_t time_to_refresh(int64_t reload_interval, int64_t target_duration,
int64_t last_load_time, int64_t last_live_change_time, HLS_LIVE_refresh_STATE *live_change_state)
{
int64_t now_time = av_gettime_relative();
{
//++ is not allow for enum, so just use number
int64_t diff_load_time = now_time - last_load_time;
switch (*live_change_state) {
case HLS_LIVE_refreshed:
//the m3u8 had change when state = 0,
//MIN(target_duration, reload_interval, 9s)
break;
//the follow is no change
//so need wait 1,1,1,2,5,10,10......
case HLS_LIVE_norefresh_1s_1:
case HLS_LIVE_norefresh_1s_2:
case HLS_LIVE_norefresh_1s_3:
if (diff_load_time > 1 * 1000 * 1000ll)
{
av_log(NULL, AV_LOG_INFO,"state:%d, diff_load_time:%" PRId64 " > 1s",
*live_change_state, diff_load_time);
(*live_change_state)++;
return diff_load_time;
}
else
return 0;
case HLS_LIVE_norefresh_2s:
if (diff_load_time > 2 * 1000 * 1000ll)
{
av_log(NULL, AV_LOG_INFO,"state:%d, diff_load_time:%" PRId64 " > 2s",
*live_change_state, diff_load_time);
(*live_change_state)++;
return diff_load_time;
}
else
return 0;
case HLS_LIVE_norefresh_5s:
if (diff_load_time > 5 * 1000 * 1000ll)
{
av_log(NULL, AV_LOG_INFO,"state:%d, diff_load_time:%" PRId64 " > 5s",
*live_change_state, diff_load_time);
(*live_change_state)++;
return diff_load_time;
}
else
return 0;
case HLS_LIVE_norefresh_10s:
default:
{
if (diff_load_time > 10 * 1000 * 1000ll)
{
av_log(NULL, AV_LOG_INFO,"state:%d, diff_load_time:%" PRId64 " > 10s",
*live_change_state, diff_load_time);
return diff_load_time;
}
else
return 0;
}
}
}
//only live_change_state == 0 can reach here
//for m3u8 change case
//MIN(target_duration, reload_interval, 9s)
int64_t diff_time = now_time - last_load_time;
if (diff_time >= reload_interval || diff_time >= 9 * 1000000ll || diff_time >= target_duration)
{
av_log(NULL, AV_LOG_INFO,"no change state:%d, diff_time:%" PRId64 "",
*live_change_state, diff_time);
return diff_time;
} else {
return 0;
}
}
int64_t time_to_shift(HLSContext *c, int varrant_used)
{
struct variant_t *variant = c->variants[varrant_used];
struct playlist *pls = variant->playlists[0];
int n_back = 0;
int seg_time = 0;
//the read_data fun not yet read and close the playlist_pb
//so wait
int n = variant->n_playlists;
int i = 0;
for (i = 0; i < n; i++)
{
if (variant->playlists[i]->playlist_pb)
return 0;
}
//20s before play all seg is the n_back
int n_segments = pls->n_segments;
for (; n_segments > 0; n_segments--)
{
seg_time += pls->segments[n_segments - 1]->duration;
if (seg_time >= 20)
{
break;
}
n_back++;
}
if (pls->cur_seq_no >= pls->start_seq_no + pls->n_segments - n_back)
{
//time to shift when open the cur_seq_no
return (int64_t)pls->cur_seq_no;
}
return 0;
}
void free_avio_list(AVFormatContext *s, AVIOContext ***avio, int *n_avio, int need_close)
{
int i;
if (s == NULL || avio == NULL || *avio == NULL || **avio == NULL
|| n_avio == NULL || *n_avio == 0)
return;
for (i = 0; i < *n_avio; i++) {
struct AVIOContext *var = (*avio)[i];
if (var)
{
if (need_close)
ff_format_io_close(s, &var);
}
}
av_freep(avio);
*n_avio = 0;
}
int open_varant(AVFormatContext *s, const char *shift_url, int varrant_used, struct rendition *r, int n_renditions,
AVIOContext ***playlist_pb, int *n_pls)
{
int ret = -1;
int need_close = 0;
if (r == NULL || n_renditions == 0)
{
HLSContext *c = (HLSContext *)s->priv_data;
AVDictionary *opts = NULL;
//get_m3u8_opts(c, &opts);
if (c->read_data_error) {
//not open_varant
return AVERROR_EXIT;
}
av_dict_set_int(&opts, "http_wait_eof", 1, 0);
//open all media
struct variant_t *v = c->variants[varrant_used];
int n = v->n_playlists;
int i = 0;
av_log(NULL, AV_LOG_VERBOSE, "[%d]in open_varant n:%d", __LINE__, n);
for (i = 0; i < n; i++)
{
AVIOContext *in;
const char *url;
if (shift_url)
{
url = shift_url;
} else {
if (v->playlists[i]->redirect_url)
url = v->playlists[i]->redirect_url;
else
url = v->playlists[i]->url;
}
av_log(NULL, AV_LOG_VERBOSE, "[%d]start open_varant url:%s", __LINE__, trimLeadingCharacter(url));
get_m3u8_opts(c, &opts);
ret = amlio_open_whitelist(&in, url, AVIO_FLAG_READ, &s->interrupt_callback, &opts,
s->protocol_whitelist, s->protocol_blacklist);
if (ret >= 0)
{
//will use the buf in http proto
//to avoid copy m3u8 data one more time
//so close the buf in this AVIOContext
in->direct = 1;
if (shift_url)
{
if (v->playlists[i]->timeshif_url)
{
av_freep(&v->playlists[i]->timeshif_url);
}
v->playlists[i]->timeshif_url = av_strdup(shift_url);
}
dynarray_add(playlist_pb, n_pls, in);
} else {
if (check_net_phy_conn_status() == 0)
{
av_log(NULL, AV_LOG_WARNING,"hls net down");
set_dns_net_down();
} else {
av_freep(&v->playlists[i]->redirect_url);
}
need_close = 1;
break;
}
}
av_log(NULL, AV_LOG_VERBOSE, "[%d]out open_varant", __LINE__);
av_dict_free(&opts);
} else {
//TODO:
//open media from rendition
}
//if one err, should close other success
if (need_close)
{
free_avio_list(s, playlist_pb, n_pls, 1);
}
return ret;
}
static int64_t get_cur_us(void)
{
struct timeval tv;
gettimeofday(&tv, NULL);
int64_t time = (int64_t)tv.tv_sec * 1000 * 1000 + tv.tv_usec;
return time;
}
#define TIMESHIFT_URL_STARTTIME "%Y%m%dT%H%M%S.00Z"
#define TIMESHIFT_URL_TAG "&starttime=%s" //new standard no need token
static char *get_formatted_time(int64_t timeUs)
{
struct tm *tm_now;
int64_t lst = timeUs;
lst = lst / 1000000;
char strTime[100];
time_t timer = lst;
tm_now = localtime(&timer);
strftime(strTime, sizeof(strTime), TIMESHIFT_URL_STARTTIME, tm_now);
int slen = strlen(strTime) + 1;
char *p = (char *)av_mallocz(slen);
*(p + slen - 1) = '\0';
strcpy(p, strTime);
return p;
}
int make_timeshift_url(char *url, char *shift_url, int64_t us, int varrant_used)
{
char tmp_url[MAX_URL_SIZE];
snprintf(tmp_url, MAX_URL_SIZE, "%s", url);
char *tmp = get_formatted_time(us);
char *start = strstr(tmp_url, "&starttime=");
if (NULL == start)
{
snprintf(tmp_url + strlen(tmp_url), MAX_URL_SIZE - strlen(tmp_url), TIMESHIFT_URL_TAG, tmp);
av_log(NULL, AV_LOG_INFO,"no starttime, tmp_url:%s", tmp_url);
}
else
{
strncpy(start + 11, tmp, strlen(tmp));
}
av_freep(&tmp);
tmp = strstr(tmp_url, "livemode=1");
if (NULL != tmp)
{
*(tmp + 9) = '2';
}
av_log(NULL, AV_LOG_INFO,"last, tmp_url:%s", tmp_url);
strncpy(shift_url, tmp_url, MAX_URL_SIZE);
//av_freep(&tmp_url);
return 0;
}
#ifdef HLS_I_FRAME_MODE
static int frames_in_ff_fb(int scale) {
int factor = (scale >= 0 ? scale:-scale);
int ret = 1;
switch (factor) {
case I_FRAME_FF_FB_STEP_2X:
ret = 1;
break;
case I_FRAME_FF_FB_STEP_4X:
ret = 2;
break;
case I_FRAME_FF_FB_STEP_8X:
ret = 4;
break;
case I_FRAME_FF_FB_STEP_16X:
ret = 6;
break;
case I_FRAME_FF_FB_STEP_32X:
ret = 8;
break;
case I_FRAME_FF_FB_STEP_64X:
ret = 10;
break;
default:
ret = 1;
break;
}
return ret;
}
static int i_frame_find_drop_interval(struct playlist *pls, int scale, int I_total_number)
{
AVFormatContext* s = pls->parent;
int drop_interval = 0;
int need_number = 0;
int total_in_speed = 0;
int drop_number = 0;
av_log(NULL, AV_LOG_INFO,"scale:%d,I_total_number:%d\n",scale, I_total_number);
need_number = frames_in_ff_fb(scale);
// if (s->duration != 0) {
// total_in_speed = scale * I_total_number/(s->duration/1000000);
// av_log(NULL, AV_LOG_INFO,"total_in_speed:%d,scale:%d,I_total_number:%d,durationUs:%lld\n",
// total_in_speed, scale, I_total_number, s->duration);
// }
// drop_number = total_in_speed - need_number;
// if (drop_number > 0) {
// if (total_in_speed % drop_number == 0)
// drop_interval = total_in_speed/drop_number;
// else
// drop_interval = (total_in_speed + drop_number)/drop_number;
// av_log(NULL, AV_LOG_INFO,"drop_interval= %d,drop_number:%d\n",
// drop_interval,drop_number);
// }
return need_number;
}
static void judge_next_segment(struct playlist *pls)
{
AVFormatContext* s = pls->parent;
HLSContext * c = pls->parent->priv_data;
int scale = c->i_frame_ff_fb_scale;
if (c->i_frame_mode) {
int symbol = (scale >= 0 ? 1 : -1);
int I_total_number = pls->n_segments;
av_log(NULL, AV_LOG_INFO,"old cur seq no is %d\n",pls->cur_seq_no);
pls->cur_seq_no += (symbol * i_frame_find_drop_interval(pls, scale, I_total_number));
av_log(NULL, AV_LOG_INFO,"new cur seq no is %d\n",pls->cur_seq_no);
}else{
pls->cur_seq_no++;
}
}
static struct variant_t *new_i_frame_variant(HLSContext *c, struct i_frame_variant_info *info, const char *base)
{
struct variant_t *var;
struct playlist *pls;
pls = new_playlist(c, info->uri, base);
if (!pls)
return NULL;
var = av_mallocz(sizeof(struct variant_t));
if (!var)
return NULL;
if (info) {
var->bandwidth = atoi(info->bandwidth);
strcpy(var->audio_group, info->audio);
strcpy(var->video_group, info->video);
strcpy(var->subtitles_group, info->subtitles);
}
dynarray_add(&c->i_frame_variants, &c->n_i_frame_variants, var);
dynarray_add(&var->playlists, &var->n_playlists, pls);
return var;
}
static void handle_i_frame_variant_args(struct i_frame_variant_info *info, const char *key,
int key_len, char **dest, int *dest_len)
{
if (!strncmp(key, "BANDWIDTH=", key_len)) {
*dest = info->bandwidth;
*dest_len = sizeof(info->bandwidth);
} else if (!strncmp(key, "AUDIO=", key_len)) {
*dest = info->audio;
*dest_len = sizeof(info->audio);
} else if (!strncmp(key, "VIDEO=", key_len)) {
*dest = info->video;
*dest_len = sizeof(info->video);
} else if (!strncmp(key, "SUBTITLES=", key_len)) {
*dest = info->subtitles;
*dest_len = sizeof(info->subtitles);
}
else if (!strncmp(key, "PROGRAM-ID=", key_len)) {
*dest = info->program_id;
*dest_len = sizeof(info->program_id);
}
else if (!strncmp(key, "URI=", key_len)) {
*dest = info->uri;
*dest_len = sizeof(info->uri);
}
}
int hls_switch_I_frame_back_to_normal_variant(AVFormatContext *s, int varrant_used)
{
HLSContext *c = s->priv_data;
int ret = -1;
struct variant_t *variant = NULL;
struct playlist *pls = NULL;
av_log(NULL, AV_LOG_INFO,"LNTES----------->enter hls_switch_I_frame_back_to_normal_variant\n");
if (c->i_frame_mode == 0 || c->n_variants <= 0 || c->n_variants < varrant_used)
{
av_log(NULL, AV_LOG_ERROR,"hls_switch_variant err, i_frame_mode:%d, n_variants:%d, set value:%d\n",
c->i_frame_mode, c->n_variants, varrant_used);
return -1;
}
int i;
int varrant_used_last = c->varrant_used;
int cur_seq_no = c->i_frame_variants[varrant_used_last]->playlists[0]->cur_seq_no;
c->varrant_used = varrant_used;
variant = c->variants[c->varrant_used];
//close main input
{
int playlists_num = c->n_playlists;
av_log(NULL, AV_LOG_ERROR,"LNTES----------->enter hls_switch_to_i_frame_variant varrant_used_last:%d, playlists_num:%d\n",varrant_used_last,playlists_num);
for (int i = 0; i < playlists_num; i++) {
reset_playlist(c, c->playlists[i]);
}
}
av_log(NULL, AV_LOG_INFO,"LNTES----------->enter close varrant_used_last[%d] end\n",varrant_used_last);
//clear playlists
for (i = 0; i < c->n_playlists_all; i++)
{
c->playlists[i] = NULL;
}
//set new value
c->n_playlists = variant->n_playlists;
for (i = 0; i < variant->n_playlists; i++)
{
c->playlists[i] = variant->playlists[i];
}
//parse_playlist
for (i = 0; i < c->n_playlists; i++)
{
struct playlist *pls = c->playlists[i];
av_log(NULL, AV_LOG_INFO,"LNTES----------->enter parse_playlist %s begin\n",pls->url);
if ((ret = parse_playlist(c, pls->url, pls, NULL)) < 0)
goto fail;
av_log(NULL, AV_LOG_INFO,"LNTES----------->enter parse_playlist %s end\n",pls->url);
}
/* Select the starting segments */
for (i = 0; i < c->n_playlists; i++)
{
struct playlist *pls = c->playlists[i];
find_timestamp_in_playlist(c, pls, c->cur_timestamp, &pls->cur_seq_no);
av_log(NULL, AV_LOG_INFO,"LNTES----------->pls->cur_seq_no %d",pls->cur_seq_no);
pls->needed = 1;
}
/* Open the demuxer for each playlist */
for (i = 0; i < c->n_playlists; i++) {
struct playlist *pls = c->playlists[i];
AVInputFormat *in_fmt = NULL;
if (pls->ctx)
{
continue;
}
if (!(pls->ctx = avformat_alloc_context())) {
ret = AVERROR(ENOMEM);
goto fail;
}
if (pls->n_segments == 0)
continue;
pls->index = i;
pls->needed = 1;
pls->parent = s;
pls->ctx->interrupt_callback = s->interrupt_callback;
pls->switch_variant_requested = -1;
pls->read_buffer = av_malloc(INITIAL_BUFFER_SIZE);
if (!pls->read_buffer) {
ret = AVERROR(ENOMEM);
avformat_free_context(pls->ctx);
pls->ctx = NULL;
goto fail;
}
ffio_init_context(&pls->pb, pls->read_buffer, INITIAL_BUFFER_SIZE, 0, pls,
read_data, NULL, NULL);
//pls->pb.seekable = 0;
ret = av_probe_input_buffer(&pls->pb, &in_fmt, pls->segments[0]->url,
NULL, 0, 0);
if (ret < 0) {
/* Free the ctx - it isn't initialized properly at this point,
* so avformat_close_input shouldn't be called. If
* avformat_open_input fails below, it frees and zeros the
* context, so it doesn't need any special treatment like this. */
av_log(NULL, AV_LOG_ERROR,"Error when loading first segment '%s'\n", pls->segments[0]->url);
avformat_free_context(pls->ctx);
pls->ctx = NULL;
goto fail;
}
pls->ctx->pb = &pls->pb;
pls->ctx->io_open = nested_io_open;
pls->ctx->flags |= s->flags & ~AVFMT_FLAG_CUSTOM_IO;
if ((ret = ff_copy_whiteblacklists(pls->ctx, s)) < 0)
goto fail;
AVDictionary* opts = NULL;
av_dict_set_int(&opts, "hls_live_mode", !pls->finished, 0);
av_dict_set_int(&opts, "sidx_reference_count", 0, 0);
ret = avformat_open_input(&pls->ctx, pls->segments[0]->url, in_fmt, &opts);
av_dict_free(&opts);
if (ret < 0)
goto fail;
if (pls->id3_deferred_extra && pls->ctx->nb_streams == 1) {
ff_id3v2_parse_apic(pls->ctx, &pls->id3_deferred_extra);
avformat_queue_attached_pictures(pls->ctx);
ff_id3v2_parse_priv(pls->ctx, &pls->id3_deferred_extra);
ff_id3v2_free_extra_meta(&pls->id3_deferred_extra);
pls->id3_deferred_extra = NULL;
}
if (pls->is_id3_timestamped == -1)
av_log(NULL, AV_LOG_WARNING, "No expected HTTP requests have been made\n");
/*
* For ID3 timestamped raw audio streams we need to detect the packet
* durations to calculate timestamps in fill_timing_for_id3_timestamped_stream(),
* but for other streams we can rely on our user calling avformat_find_stream_info()
* on us if they want to.
*/
if (pls->is_id3_timestamped) {
ret = avformat_find_stream_info(pls->ctx, NULL);
if (ret < 0)
goto fail;
}
pls->has_noheader_flag = !!(pls->ctx->ctx_flags & AVFMTCTX_NOHEADER);
/* Create new AVStreams for each stream in this playlist */
av_log(NULL, AV_LOG_INFO,"-------->update_streams_from_subdemuxer\n");
ret = update_streams_from_subdemuxer(s, pls);
if (ret < 0)
goto fail;
/*
* Copy any metadata from playlist to main streams, but do not set
* event flags.
*/
if (pls->n_main_streams)
av_dict_copy(&pls->main_streams[0]->metadata, pls->ctx->metadata, 0);
add_metadata_from_renditions(s, pls, AVMEDIA_TYPE_AUDIO);
add_metadata_from_renditions(s, pls, AVMEDIA_TYPE_VIDEO);
add_metadata_from_renditions(s, pls, AVMEDIA_TYPE_SUBTITLE);
}
update_noheader_flag(s);
return 0;
fail:
av_log(NULL, AV_LOG_ERROR,"hls_switch_I_frame_back_to_normal_variant err,ret:%d\n",ret);
c->varrant_used = varrant_used_last;
variant = c->variants[c->varrant_used];
for (i = 0; i < c->n_playlists_all; i++)
{
c->playlists[i] = NULL;
}
c->n_playlists = variant->n_playlists;
for (i = 0; i < variant->n_playlists; i++)
{
c->playlists[i] = variant->playlists[i];
}
return ret;
}
static int reset_playlist(HLSContext *c, struct playlist *pls)
{
if (NULL == pls || NULL == c || NULL == c->ctx) {
av_log(NULL, AV_LOG_ERROR,"bad param, pls is NULL\n");
return AVERROR(EINVAL);
}
/* Reset reading */
if (pls->input)
ff_format_io_close(pls->parent, &pls->input);
pls->input_read_done = 0;
pls ->open_retrytime = 0;
pls->read_retrytime = 0;
if (pls->input_next)
ff_format_io_close(pls->parent, &pls->input_next);
if (pls->playlist_pb)
ff_format_io_close(c->ctx, &pls->playlist_pb);
pls->input_next_requested = 0;
av_packet_unref(&pls->pkt);
reset_packet(&pls->pkt);
pls->pb.eof_reached = 0;
/* Clear any buffered data */
pls->pb.buf_end = pls->pb.buf_ptr = pls->pb.buffer;
/* Reset the pos, to let the mpegts demuxer know we've seeked. */
pls->pb.pos = 0;
/* Flush the packet queue of the subdemuxer. */
ff_read_frame_flush(pls->ctx);
pls->seek_flags = 0;
pls->needed = 0;
return 0;
}
int hls_switch_to_i_frame_variant(AVFormatContext *s, int varrant_used)
{
HLSContext *c = s->priv_data;
int ret = -1;
struct variant_t *variant = NULL;
if (c->n_i_frame_variants < 1 || varrant_used > c->n_i_frame_variants - 1)
{
av_log(NULL, AV_LOG_ERROR,"hls_switch_variant err, n_i_frame_variants:%d, set value:%d",
c->n_i_frame_variants, varrant_used);
return -1;
}
int i;
int varrant_used_last = c->varrant_used;
int cur_seq_no = c->variants[varrant_used_last]->playlists[0]->cur_seq_no;
c->varrant_used = varrant_used;
variant = c->i_frame_variants[varrant_used];
//close main input
{
int playlists_num = c->n_playlists;
av_log(NULL, AV_LOG_ERROR,"LNTES----------->enter hls_switch_to_i_frame_variant varrant_used_last:%d, playlists_num:%d\n",varrant_used_last,playlists_num);
for (int i = 0; i < playlists_num; i++)
{
reset_playlist(c, c->playlists[i]);
}
}
//clear playlists
for (i = 0; i < c->n_playlists_all; i++)
{
c->playlists[i] = NULL;
}
//set new value
c->n_playlists = variant->n_playlists;
for (i = 0; i < variant->n_playlists; i++)
{
c->playlists[i] = variant->playlists[i];
}
//parse_playlist
for (i = 0; i < c->n_playlists; i++)
{
struct playlist *pls = c->playlists[i];
// struct playlist *pls = variant->playlists[0];
if ((ret = parse_playlist(c, pls->url, pls, NULL)) < 0)
goto fail;
}
/* Select the starting segments */
for (i = 0; i < c->n_playlists; i++)
{
struct playlist *pls = c->playlists[i];
// struct playlist *pls = variant->playlists[0];
// pls->cur_seq_no = cur_seq_no;
find_timestamp_in_playlist(c, pls, c->cur_timestamp, &pls->cur_seq_no);
av_log(NULL, AV_LOG_INFO,"LNTEST----------->pls->cur_seq_no %d",pls->cur_seq_no);
if (pls->cur_seq_no < pls->start_seq_no + pls->n_segments - 1) {
pls->cur_seq_no += 1;
}
pls->needed = 1;
}
/* Open the demuxer for each playlist */
for (i = 0; i < c->n_playlists; i++) {
struct playlist *pls = c->playlists[i];
AVInputFormat *in_fmt = NULL;
av_log(NULL, AV_LOG_INFO,"LNTES----------->222222222i = 0; i < c->n_playlists; i++\n");
if (pls->ctx)
{
av_log(NULL, AV_LOG_INFO,"LNTES----------->1111111111i = 0; i < c->n_playlists; i++\n");
continue;
}
if (!(pls->ctx = avformat_alloc_context())) {
ret = AVERROR(ENOMEM);
goto fail;
}
if (pls->n_segments == 0)
continue;
pls->index = i;
pls->needed = 1;
pls->parent = s;
pls->ctx->interrupt_callback = s->interrupt_callback;
pls->switch_variant_requested = -1;
pls->read_buffer = av_malloc(INITIAL_BUFFER_SIZE);
if (!pls->read_buffer) {
ret = AVERROR(ENOMEM);
avformat_free_context(pls->ctx);
pls->ctx = NULL;
goto fail;
}
ffio_init_context(&pls->pb, pls->read_buffer, INITIAL_BUFFER_SIZE, 0, pls,
read_data, NULL, NULL);
//pls->pb.seekable = 0;
av_log(NULL, AV_LOG_INFO,"LNTES----------->1111111111pls->segments[0]->url:%s\n",pls->segments[0]->url);
ret = av_probe_input_buffer(&pls->pb, &in_fmt, pls->segments[0]->url,
NULL, 0, 0);
if (ret < 0) {
/* Free the ctx - it isn't initialized properly at this point,
* so avformat_close_input shouldn't be called. If
* avformat_open_input fails below, it frees and zeros the
* context, so it doesn't need any special treatment like this. */
av_log(NULL, AV_LOG_ERROR,"Error when loading first segment '%s', ret:%d\n", pls->segments[0]->url,ret);
avformat_free_context(pls->ctx);
pls->ctx = NULL;
goto fail;
}
pls->ctx->pb = &pls->pb;
pls->ctx->io_open = nested_io_open;
pls->ctx->flags |= s->flags & ~AVFMT_FLAG_CUSTOM_IO;
if ((ret = ff_copy_whiteblacklists(pls->ctx, s)) < 0)
goto fail;
AVDictionary* opts = NULL;
av_dict_set_int(&opts, "hls_live_mode", !pls->finished, 0);
av_dict_set_int(&opts, "sidx_reference_count", 0, 0);
ret = avformat_open_input(&pls->ctx, pls->segments[0]->url, in_fmt, &opts);
av_dict_free(&opts);
if (ret < 0)
goto fail;
if (pls->id3_deferred_extra && pls->ctx->nb_streams == 1) {
ff_id3v2_parse_apic(pls->ctx, &pls->id3_deferred_extra);
avformat_queue_attached_pictures(pls->ctx);
ff_id3v2_parse_priv(pls->ctx, &pls->id3_deferred_extra);
ff_id3v2_free_extra_meta(&pls->id3_deferred_extra);
pls->id3_deferred_extra = NULL;
}
if (pls->is_id3_timestamped == -1)
av_log(NULL, AV_LOG_WARNING, "No expected HTTP requests have been made\n");
/*
* For ID3 timestamped raw audio streams we need to detect the packet
* durations to calculate timestamps in fill_timing_for_id3_timestamped_stream(),
* but for other streams we can rely on our user calling avformat_find_stream_info()
* on us if they want to.
*/
if (pls->is_id3_timestamped) {
ret = avformat_find_stream_info(pls->ctx, NULL);
if (ret < 0)
goto fail;
}
pls->has_noheader_flag = !!(pls->ctx->ctx_flags & AVFMTCTX_NOHEADER);
/* Create new AVStreams for each stream in this playlist */
av_log(NULL, AV_LOG_INFO,"-------->update_streams_from_subdemuxer\n");
ret = update_streams_from_subdemuxer(s, pls);
if (ret < 0)
goto fail;
/*
* Copy any metadata from playlist to main streams, but do not set
* event flags.
*/
if (pls->n_main_streams)
av_dict_copy(&pls->main_streams[0]->metadata, pls->ctx->metadata, 0);
add_metadata_from_renditions(s, pls, AVMEDIA_TYPE_AUDIO);
add_metadata_from_renditions(s, pls, AVMEDIA_TYPE_VIDEO);
add_metadata_from_renditions(s, pls, AVMEDIA_TYPE_SUBTITLE);
}
update_noheader_flag(s);
return 0;
fail:
av_log(NULL, AV_LOG_ERROR,"hls_switch_to_i_frame_variant err");
c->varrant_used = varrant_used_last;
variant = c->variants[c->varrant_used];
for (i = 0; i < c->n_playlists_all; i++)
{
c->playlists[i] = NULL;
}
c->n_playlists = variant->n_playlists;
for (i = 0; i < variant->n_playlists; i++)
{
c->playlists[i] = variant->playlists[i];
}
return ret;
}
static int judge_scale(int scale)
{
int ret = scale;
int symbol = (scale >= 0 ? 1 : -1);
scale *=symbol;
if (scale > I_FRAME_FF_FB_STEP_4X && scale < I_FRAME_FF_FB_STEP_8X) {
ret = I_FRAME_FF_FB_STEP_4X * symbol;
} else if (scale > I_FRAME_FF_FB_STEP_8X && scale < I_FRAME_FF_FB_STEP_16X) {
ret = I_FRAME_FF_FB_STEP_8X * symbol;
} else if (scale > I_FRAME_FF_FB_STEP_16X && scale < I_FRAME_FF_FB_STEP_32X) {
ret = I_FRAME_FF_FB_STEP_16X * symbol;
} else if (scale > I_FRAME_FF_FB_STEP_32X && scale < I_FRAME_FF_FB_STEP_64X) {
ret = I_FRAME_FF_FB_STEP_32X * symbol;
} else if (scale > I_FRAME_FF_FB_STEP_64X) {
ret = I_FRAME_FF_FB_STEP_64X * symbol;
}
return ret;
}
static int hls_read_fast(struct AVFormatContext *s, int scale)
{
int ret = -1;
do {
if (NULL == s) {
ret = AVERROR_INVALIDDATA;
break;
}
HLSContext *c = s->priv_data;
av_log(NULL, AV_LOG_INFO,"LNTEST------------>ENTER hls_read_fast, c->i_frame_mode:%d, scale:%d\n",c->i_frame_mode, scale);
if (scale > I_FRAME_FF_FB_STEP_64X || scale < -I_FRAME_FF_FB_STEP_64X) {
av_log(NULL, AV_LOG_ERROR,"bad param, scale %d is invalid!\n",scale);
ret = AVERROR_INVALIDDATA;
break;
}
scale = judge_scale(scale);
if (c->i_frame_mode) {
if (scale == 0) {
ret = hls_switch_I_frame_back_to_normal_variant(s, 0);
if (ret >= 0) {
c->i_frame_mode = 0;
c->i_frame_ff_fb_scale = 0;
}
av_log(NULL, AV_LOG_INFO,"LNTEST------------>ENTER c->i_frame_mode && scale == 0\n");
}else{
c->i_frame_ff_fb_scale = scale;
av_log(NULL, AV_LOG_INFO,"LNTEST------------>ENTER scale: %d\n",scale);
ret = 0;
}
}else{
int best_index = find_best_i_frame_variant(c, c->playlists[0]->url, (const struct variant_t * const *)c->i_frame_variants, c->n_i_frame_variants);
if (best_index >= 0) {
ret = hls_switch_to_i_frame_variant(s, best_index);
if (ret >= 0) {
c->i_frame_ff_fb_scale = scale;
c->i_frame_mode = 1;
}
break;
}else{
for (int i = 0; i <= c->n_i_frame_variants - 1; i++)
{
av_log(NULL, AV_LOG_INFO,"LNTEST-------->used is %d, change to %d \n",c->varrant_used,i);
ret = hls_switch_to_i_frame_variant(s, i);
if (ret >= 0) {
c->i_frame_ff_fb_scale = scale;
c->i_frame_mode = 1;
}
break;
}
}
}
}while(0);
return ret;
}
/*
* return: >=0 success; <0: failed;
*/
static int find_best_i_frame_variant(const HLSContext *c, const char* playing_url, const struct variant_t ** variants, int n_variants){
char* last_pos = NULL;
unsigned int base_url_len = 0;
int ret = -1;
do {
if (n_variants <= 0
|| variants == NULL
|| playing_url == NULL) {
break;
}
if (n_variants == 1) {
ret = 0;
break;
}
last_pos = strrchr(playing_url, '/');
if (NULL == last_pos) {
av_log(NULL, AV_LOG_ERROR,"can not find / in %s\n", playing_url);
break;
}
base_url_len = last_pos - playing_url;
if (base_url_len <= 0) {
av_log(NULL, AV_LOG_ERROR,"base_url_len <= 0, playing_url is %s\n", playing_url);
break;
}
for (int i = 0; i < n_variants; i++) {
struct variant_t *variant = variants[i];
struct playlist *pls = variant->playlists[0];
char* url = pls->url;
if (NULL == url)
{
av_log(NULL, AV_LOG_ERROR,"the index of %d in i_frame_variants playlists[0]->url is NULL\n");
continue;
}
if (strncmp(url, playing_url, base_url_len) == 0)
{
ret = i;
break;
}else{
av_log(NULL, AV_LOG_INFO,"playing_url:%s, url:%s\n", playing_url, url);
}
}
}while(0);
return ret;
}
#endif
AVInputFormat ff_hls_demuxer = {
.name = "hls",
.long_name = NULL_IF_CONFIG_SMALL("Apple HTTP Live Streaming"),
.priv_class = &hls_class,
.priv_data_size = sizeof(HLSContext),
.flags = AVFMT_NOGENSEARCH | AVFMT_TS_DISCONT,
.read_probe = hls_probe,
.read_header = hls_read_header,
.read_packet = hls_read_packet,
.read_close = hls_close,
.read_seek = hls_read_seek,
};
AmlInputFormat aml_hls_demuxer = {
//.name = "hls,applehttp",
//.long_name = NULL_IF_CONFIG_SMALL("Apple HTTP Live Streaming"),
//.priv_class = &hls_class,
//.priv_data_size = sizeof(HLSContext),
.flags = AVFMT_NOGENSEARCH,
.read_probe = hls_probe,
.read_header = hls_read_header,
.read_packet = hls_read_packet,
.read_close = hls_close,
.read_seek = hls_read_seek,
#ifdef HLS_I_FRAME_MODE
.read_fast = hls_read_fast,
#else
.read_fast = NULL,
#endif
};
Reference in New Issue View Git Blame Copy Permalink