You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

3072 lines
111KB

  1. /*
  2. * Apple HTTP Live Streaming segmenter
  3. * Copyright (c) 2012, Luca Barbato
  4. * Copyright (c) 2017 Akamai Technologies, Inc.
  5. *
  6. * This file is part of FFmpeg.
  7. *
  8. * FFmpeg is free software; you can redistribute it and/or
  9. * modify it under the terms of the GNU Lesser General Public
  10. * License as published by the Free Software Foundation; either
  11. * version 2.1 of the License, or (at your option) any later version.
  12. *
  13. * FFmpeg is distributed in the hope that it will be useful,
  14. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16. * Lesser General Public License for more details.
  17. *
  18. * You should have received a copy of the GNU Lesser General Public
  19. * License along with FFmpeg; if not, write to the Free Software
  20. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21. */
  22. #include "config.h"
  23. #include <float.h>
  24. #include <stdint.h>
  25. #if HAVE_UNISTD_H
  26. #include <unistd.h>
  27. #endif
  28. #if CONFIG_GCRYPT
  29. #include <gcrypt.h>
  30. #elif CONFIG_OPENSSL
  31. #include <openssl/rand.h>
  32. #endif
  33. #include "libavutil/avassert.h"
  34. #include "libavutil/mathematics.h"
  35. #include "libavutil/parseutils.h"
  36. #include "libavutil/avstring.h"
  37. #include "libavutil/intreadwrite.h"
  38. #include "libavutil/random_seed.h"
  39. #include "libavutil/opt.h"
  40. #include "libavutil/log.h"
  41. #include "libavutil/time_internal.h"
  42. #include "avformat.h"
  43. #include "avio_internal.h"
  44. #if CONFIG_HTTP_PROTOCOL
  45. #include "http.h"
  46. #endif
  47. #include "hlsplaylist.h"
  48. #include "internal.h"
  49. #include "os_support.h"
  50. typedef enum {
  51. HLS_START_SEQUENCE_AS_START_NUMBER = 0,
  52. HLS_START_SEQUENCE_AS_SECONDS_SINCE_EPOCH = 1,
  53. HLS_START_SEQUENCE_AS_FORMATTED_DATETIME = 2, // YYYYMMDDhhmmss
  54. } StartSequenceSourceType;
  55. typedef enum {
  56. CODEC_ATTRIBUTE_WRITTEN = 0,
  57. CODEC_ATTRIBUTE_WILL_NOT_BE_WRITTEN,
  58. } CodecAttributeStatus;
  59. #define KEYSIZE 16
  60. #define LINE_BUFFER_SIZE MAX_URL_SIZE
  61. #define HLS_MICROSECOND_UNIT 1000000
  62. #define POSTFIX_PATTERN "_%d"
  63. typedef struct HLSSegment {
  64. char filename[MAX_URL_SIZE];
  65. char sub_filename[MAX_URL_SIZE];
  66. double duration; /* in seconds */
  67. int discont;
  68. int64_t pos;
  69. int64_t size;
  70. int64_t keyframe_pos;
  71. int64_t keyframe_size;
  72. unsigned var_stream_idx;
  73. char key_uri[LINE_BUFFER_SIZE + 1];
  74. char iv_string[KEYSIZE*2 + 1];
  75. struct HLSSegment *next;
  76. } HLSSegment;
  77. typedef enum HLSFlags {
  78. // Generate a single media file and use byte ranges in the playlist.
  79. HLS_SINGLE_FILE = (1 << 0),
  80. HLS_DELETE_SEGMENTS = (1 << 1),
  81. HLS_ROUND_DURATIONS = (1 << 2),
  82. HLS_DISCONT_START = (1 << 3),
  83. HLS_OMIT_ENDLIST = (1 << 4),
  84. HLS_SPLIT_BY_TIME = (1 << 5),
  85. HLS_APPEND_LIST = (1 << 6),
  86. HLS_PROGRAM_DATE_TIME = (1 << 7),
  87. HLS_SECOND_LEVEL_SEGMENT_INDEX = (1 << 8), // include segment index in segment filenames when use_localtime e.g.: %%03d
  88. HLS_SECOND_LEVEL_SEGMENT_DURATION = (1 << 9), // include segment duration (microsec) in segment filenames when use_localtime e.g.: %%09t
  89. HLS_SECOND_LEVEL_SEGMENT_SIZE = (1 << 10), // include segment size (bytes) in segment filenames when use_localtime e.g.: %%014s
  90. HLS_TEMP_FILE = (1 << 11),
  91. HLS_PERIODIC_REKEY = (1 << 12),
  92. HLS_INDEPENDENT_SEGMENTS = (1 << 13),
  93. HLS_I_FRAMES_ONLY = (1 << 14),
  94. } HLSFlags;
  95. typedef enum {
  96. SEGMENT_TYPE_MPEGTS,
  97. SEGMENT_TYPE_FMP4,
  98. } SegmentType;
  99. typedef struct VariantStream {
  100. unsigned var_stream_idx;
  101. unsigned number;
  102. int64_t sequence;
  103. ff_const59 AVOutputFormat *oformat;
  104. ff_const59 AVOutputFormat *vtt_oformat;
  105. AVIOContext *out;
  106. int packets_written;
  107. int init_range_length;
  108. uint8_t *temp_buffer;
  109. AVFormatContext *avf;
  110. AVFormatContext *vtt_avf;
  111. int has_video;
  112. int has_subtitle;
  113. int new_start;
  114. double dpp; // duration per packet
  115. int64_t start_pts;
  116. int64_t end_pts;
  117. int64_t video_lastpos;
  118. int64_t video_keyframe_pos;
  119. int64_t video_keyframe_size;
  120. double duration; // last segment duration computed so far, in seconds
  121. int64_t start_pos; // last segment starting position
  122. int64_t size; // last segment size
  123. int nb_entries;
  124. int discontinuity_set;
  125. int discontinuity;
  126. int reference_stream_index;
  127. HLSSegment *segments;
  128. HLSSegment *last_segment;
  129. HLSSegment *old_segments;
  130. char *basename;
  131. char *vtt_basename;
  132. char *vtt_m3u8_name;
  133. char *m3u8_name;
  134. double initial_prog_date_time;
  135. char current_segment_final_filename_fmt[MAX_URL_SIZE]; // when renaming segments
  136. char *fmp4_init_filename;
  137. char *base_output_dirname;
  138. AVStream **streams;
  139. char codec_attr[128];
  140. CodecAttributeStatus attr_status;
  141. unsigned int nb_streams;
  142. int m3u8_created; /* status of media play-list creation */
  143. int is_default; /* default status of audio group */
  144. char *language; /* audio lauguage name */
  145. char *agroup; /* audio group name */
  146. char *ccgroup; /* closed caption group name */
  147. char *baseurl;
  148. char *varname; // variant name
  149. } VariantStream;
  150. typedef struct ClosedCaptionsStream {
  151. char *ccgroup; /* closed caption group name */
  152. char *instreamid; /* closed captions INSTREAM-ID */
  153. char *language; /* closed captions langauge */
  154. } ClosedCaptionsStream;
  155. typedef struct HLSContext {
  156. const AVClass *class; // Class for private options.
  157. int64_t start_sequence;
  158. uint32_t start_sequence_source_type; // enum StartSequenceSourceType
  159. float time; // Set by a private option.
  160. float init_time; // Set by a private option.
  161. int max_nb_segments; // Set by a private option.
  162. int hls_delete_threshold; // Set by a private option.
  163. #if FF_API_HLS_WRAP
  164. int wrap; // Set by a private option.
  165. #endif
  166. uint32_t flags; // enum HLSFlags
  167. uint32_t pl_type; // enum PlaylistType
  168. char *segment_filename;
  169. char *fmp4_init_filename;
  170. int segment_type;
  171. int use_localtime; ///< flag to expand filename with localtime
  172. int use_localtime_mkdir;///< flag to mkdir dirname in timebased filename
  173. int allowcache;
  174. int64_t recording_time;
  175. int64_t max_seg_size; // every segment file max size
  176. char *baseurl;
  177. char *format_options_str;
  178. char *vtt_format_options_str;
  179. char *subtitle_filename;
  180. AVDictionary *format_options;
  181. int encrypt;
  182. char *key;
  183. char *key_url;
  184. char *iv;
  185. char *key_basename;
  186. int encrypt_started;
  187. char *key_info_file;
  188. char key_file[LINE_BUFFER_SIZE + 1];
  189. char key_uri[LINE_BUFFER_SIZE + 1];
  190. char key_string[KEYSIZE*2 + 1];
  191. char iv_string[KEYSIZE*2 + 1];
  192. AVDictionary *vtt_format_options;
  193. char *method;
  194. char *user_agent;
  195. VariantStream *var_streams;
  196. unsigned int nb_varstreams;
  197. ClosedCaptionsStream *cc_streams;
  198. unsigned int nb_ccstreams;
  199. int master_m3u8_created; /* status of master play-list creation */
  200. char *master_m3u8_url; /* URL of the master m3u8 file */
  201. int version; /* HLS version */
  202. char *var_stream_map; /* user specified variant stream map string */
  203. char *cc_stream_map; /* user specified closed caption streams map string */
  204. char *master_pl_name;
  205. unsigned int master_publish_rate;
  206. int http_persistent;
  207. AVIOContext *m3u8_out;
  208. AVIOContext *sub_m3u8_out;
  209. int64_t timeout;
  210. int ignore_io_errors;
  211. char *headers;
  212. int has_default_key; /* has DEFAULT field of var_stream_map */
  213. int has_video_m3u8; /* has video stream m3u8 list */
  214. } HLSContext;
  215. static int hlsenc_io_open(AVFormatContext *s, AVIOContext **pb, char *filename,
  216. AVDictionary **options)
  217. {
  218. HLSContext *hls = s->priv_data;
  219. int http_base_proto = filename ? ff_is_http_proto(filename) : 0;
  220. int err = AVERROR_MUXER_NOT_FOUND;
  221. if (!*pb || !http_base_proto || !hls->http_persistent) {
  222. err = s->io_open(s, pb, filename, AVIO_FLAG_WRITE, options);
  223. #if CONFIG_HTTP_PROTOCOL
  224. } else {
  225. URLContext *http_url_context = ffio_geturlcontext(*pb);
  226. av_assert0(http_url_context);
  227. err = ff_http_do_new_request(http_url_context, filename);
  228. if (err < 0)
  229. ff_format_io_close(s, pb);
  230. #endif
  231. }
  232. return err;
  233. }
  234. static int hlsenc_io_close(AVFormatContext *s, AVIOContext **pb, char *filename)
  235. {
  236. HLSContext *hls = s->priv_data;
  237. int http_base_proto = filename ? ff_is_http_proto(filename) : 0;
  238. int ret = 0;
  239. if (!*pb)
  240. return ret;
  241. if (!http_base_proto || !hls->http_persistent || hls->key_info_file || hls->encrypt) {
  242. ff_format_io_close(s, pb);
  243. #if CONFIG_HTTP_PROTOCOL
  244. } else {
  245. URLContext *http_url_context = ffio_geturlcontext(*pb);
  246. av_assert0(http_url_context);
  247. avio_flush(*pb);
  248. ffurl_shutdown(http_url_context, AVIO_FLAG_WRITE);
  249. ret = ff_http_get_shutdown_status(http_url_context);
  250. #endif
  251. }
  252. return ret;
  253. }
  254. static void set_http_options(AVFormatContext *s, AVDictionary **options, HLSContext *c)
  255. {
  256. int http_base_proto = ff_is_http_proto(s->url);
  257. if (c->method) {
  258. av_dict_set(options, "method", c->method, 0);
  259. } else if (http_base_proto) {
  260. av_dict_set(options, "method", "PUT", 0);
  261. }
  262. if (c->user_agent)
  263. av_dict_set(options, "user_agent", c->user_agent, 0);
  264. if (c->http_persistent)
  265. av_dict_set_int(options, "multiple_requests", 1, 0);
  266. if (c->timeout >= 0)
  267. av_dict_set_int(options, "timeout", c->timeout, 0);
  268. if (c->headers)
  269. av_dict_set(options, "headers", c->headers, 0);
  270. }
  271. static void write_codec_attr(AVStream *st, VariantStream *vs)
  272. {
  273. int codec_strlen = strlen(vs->codec_attr);
  274. char attr[32];
  275. if (st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
  276. return;
  277. if (vs->attr_status == CODEC_ATTRIBUTE_WILL_NOT_BE_WRITTEN)
  278. return;
  279. if (st->codecpar->codec_id == AV_CODEC_ID_H264) {
  280. uint8_t *data = st->codecpar->extradata;
  281. if (data && (data[0] | data[1] | data[2]) == 0 && data[3] == 1 && (data[4] & 0x1F) == 7) {
  282. snprintf(attr, sizeof(attr),
  283. "avc1.%02x%02x%02x", data[5], data[6], data[7]);
  284. } else {
  285. goto fail;
  286. }
  287. } else if (st->codecpar->codec_id == AV_CODEC_ID_MP2) {
  288. snprintf(attr, sizeof(attr), "mp4a.40.33");
  289. } else if (st->codecpar->codec_id == AV_CODEC_ID_MP3) {
  290. snprintf(attr, sizeof(attr), "mp4a.40.34");
  291. } else if (st->codecpar->codec_id == AV_CODEC_ID_AAC) {
  292. /* TODO : For HE-AAC, HE-AACv2, the last digit needs to be set to 5 and 29 respectively */
  293. snprintf(attr, sizeof(attr), "mp4a.40.2");
  294. } else if (st->codecpar->codec_id == AV_CODEC_ID_AC3) {
  295. snprintf(attr, sizeof(attr), "ac-3");
  296. } else if (st->codecpar->codec_id == AV_CODEC_ID_EAC3) {
  297. snprintf(attr, sizeof(attr), "ec-3");
  298. } else {
  299. goto fail;
  300. }
  301. // Don't write the same attribute multiple times
  302. if (!av_stristr(vs->codec_attr, attr)) {
  303. snprintf(vs->codec_attr + codec_strlen,
  304. sizeof(vs->codec_attr) - codec_strlen,
  305. "%s%s", codec_strlen ? "," : "", attr);
  306. }
  307. return;
  308. fail:
  309. vs->codec_attr[0] = '\0';
  310. vs->attr_status = CODEC_ATTRIBUTE_WILL_NOT_BE_WRITTEN;
  311. return;
  312. }
  313. static int replace_str_data_in_filename(char **s, const char *filename, char placeholder, const char *datastring)
  314. {
  315. const char *p;
  316. char *new_filename;
  317. char c;
  318. int addchar_count;
  319. int found_count = 0;
  320. AVBPrint buf;
  321. av_bprint_init(&buf, 0, AV_BPRINT_SIZE_UNLIMITED);
  322. p = filename;
  323. for (;;) {
  324. c = *p;
  325. if (c == '\0')
  326. break;
  327. if (c == '%' && *(p+1) == '%') // %%
  328. addchar_count = 2;
  329. else if (c == '%' && *(p+1) == placeholder) {
  330. av_bprintf(&buf, "%s", datastring);
  331. p += 2;
  332. addchar_count = 0;
  333. found_count ++;
  334. } else
  335. addchar_count = 1;
  336. if (addchar_count > 0) {
  337. av_bprint_append_data(&buf, p, addchar_count);
  338. p += addchar_count;
  339. }
  340. }
  341. if (!av_bprint_is_complete(&buf)) {
  342. av_bprint_finalize(&buf, NULL);
  343. return -1;
  344. }
  345. if (av_bprint_finalize(&buf, &new_filename) < 0 || !new_filename)
  346. return -1;
  347. *s = new_filename;
  348. return found_count;
  349. }
  350. static int replace_int_data_in_filename(char **s, const char *filename, char placeholder, int64_t number)
  351. {
  352. const char *p;
  353. char *new_filename;
  354. char c;
  355. int nd, addchar_count;
  356. int found_count = 0;
  357. AVBPrint buf;
  358. av_bprint_init(&buf, 0, AV_BPRINT_SIZE_UNLIMITED);
  359. p = filename;
  360. for (;;) {
  361. c = *p;
  362. if (c == '\0')
  363. break;
  364. if (c == '%' && *(p+1) == '%') // %%
  365. addchar_count = 2;
  366. else if (c == '%' && (av_isdigit(*(p+1)) || *(p+1) == placeholder)) {
  367. nd = 0;
  368. addchar_count = 1;
  369. while (av_isdigit(*(p + addchar_count))) {
  370. nd = nd * 10 + *(p + addchar_count) - '0';
  371. addchar_count++;
  372. }
  373. if (*(p + addchar_count) == placeholder) {
  374. av_bprintf(&buf, "%0*"PRId64, (number < 0) ? nd : nd++, number);
  375. p += (addchar_count + 1);
  376. addchar_count = 0;
  377. found_count++;
  378. }
  379. } else
  380. addchar_count = 1;
  381. av_bprint_append_data(&buf, p, addchar_count);
  382. p += addchar_count;
  383. }
  384. if (!av_bprint_is_complete(&buf)) {
  385. av_bprint_finalize(&buf, NULL);
  386. return -1;
  387. }
  388. if (av_bprint_finalize(&buf, &new_filename) < 0 || !new_filename)
  389. return -1;
  390. *s = new_filename;
  391. return found_count;
  392. }
  393. static void write_styp(AVIOContext *pb)
  394. {
  395. avio_wb32(pb, 24);
  396. ffio_wfourcc(pb, "styp");
  397. ffio_wfourcc(pb, "msdh");
  398. avio_wb32(pb, 0); /* minor */
  399. ffio_wfourcc(pb, "msdh");
  400. ffio_wfourcc(pb, "msix");
  401. }
  402. static int flush_dynbuf(VariantStream *vs, int *range_length)
  403. {
  404. AVFormatContext *ctx = vs->avf;
  405. if (!ctx->pb) {
  406. return AVERROR(EINVAL);
  407. }
  408. // flush
  409. av_write_frame(ctx, NULL);
  410. avio_flush(ctx->pb);
  411. // write out to file
  412. *range_length = avio_close_dyn_buf(ctx->pb, &vs->temp_buffer);
  413. ctx->pb = NULL;
  414. avio_write(vs->out, vs->temp_buffer, *range_length);
  415. avio_flush(vs->out);
  416. // re-open buffer
  417. return avio_open_dyn_buf(&ctx->pb);
  418. }
  419. static void reflush_dynbuf(VariantStream *vs, int *range_length)
  420. {
  421. // re-open buffer
  422. avio_write(vs->out, vs->temp_buffer, *range_length);;
  423. }
  424. static int hls_delete_old_segments(AVFormatContext *s, HLSContext *hls,
  425. VariantStream *vs)
  426. {
  427. HLSSegment *segment, *previous_segment = NULL;
  428. float playlist_duration = 0.0f;
  429. int ret = 0, path_size, sub_path_size;
  430. int segment_cnt = 0;
  431. char *dirname = NULL, *sub_path;
  432. char *path = NULL;
  433. char *vtt_dirname = NULL;
  434. AVDictionary *options = NULL;
  435. AVIOContext *out = NULL;
  436. const char *proto = NULL;
  437. segment = vs->segments;
  438. while (segment) {
  439. playlist_duration += segment->duration;
  440. segment = segment->next;
  441. }
  442. segment = vs->old_segments;
  443. segment_cnt = 0;
  444. while (segment) {
  445. playlist_duration -= segment->duration;
  446. previous_segment = segment;
  447. segment = previous_segment->next;
  448. segment_cnt++;
  449. if (playlist_duration <= -previous_segment->duration) {
  450. previous_segment->next = NULL;
  451. break;
  452. }
  453. if (segment_cnt >= hls->hls_delete_threshold) {
  454. previous_segment->next = NULL;
  455. break;
  456. }
  457. }
  458. if (segment && !hls->use_localtime_mkdir) {
  459. char *dirname_r = hls->segment_filename ? av_strdup(hls->segment_filename): av_strdup(vs->avf->url);
  460. dirname = (char*)av_dirname(dirname_r);
  461. }
  462. /* if %v is present in the file's directory
  463. * all segment belongs to the same variant, so do it only once before the loop*/
  464. if (dirname && av_stristr(dirname, "%v")) {
  465. char * r_dirname = dirname;
  466. if (!vs->varname) {
  467. if (replace_int_data_in_filename(&r_dirname, dirname, 'v', segment->var_stream_idx) < 1) {
  468. ret = AVERROR(EINVAL);
  469. goto fail;
  470. }
  471. } else {
  472. if (replace_str_data_in_filename(&r_dirname, dirname, 'v', vs->varname) < 1) {
  473. ret = AVERROR(EINVAL);
  474. goto fail;
  475. }
  476. }
  477. av_freep(&dirname);
  478. dirname = r_dirname;
  479. }
  480. while (segment) {
  481. av_log(hls, AV_LOG_DEBUG, "deleting old segment %s\n",
  482. segment->filename);
  483. path_size = (hls->use_localtime_mkdir ? 0 : strlen(dirname)) + strlen(segment->filename) + 1;
  484. path = av_malloc(path_size);
  485. if (!path) {
  486. ret = AVERROR(ENOMEM);
  487. goto fail;
  488. }
  489. if (hls->use_localtime_mkdir)
  490. av_strlcpy(path, segment->filename, path_size);
  491. else { // segment->filename contains basename only
  492. av_strlcpy(path, dirname, path_size);
  493. av_strlcat(path, segment->filename, path_size);
  494. }
  495. proto = avio_find_protocol_name(s->url);
  496. if (hls->method || (proto && !av_strcasecmp(proto, "http"))) {
  497. av_dict_set(&options, "method", "DELETE", 0);
  498. if ((ret = vs->avf->io_open(vs->avf, &out, path, AVIO_FLAG_WRITE, &options)) < 0) {
  499. if (hls->ignore_io_errors)
  500. ret = 0;
  501. goto fail;
  502. }
  503. ff_format_io_close(vs->avf, &out);
  504. } else if (unlink(path) < 0) {
  505. av_log(hls, AV_LOG_ERROR, "failed to delete old segment %s: %s\n",
  506. path, strerror(errno));
  507. }
  508. if ((segment->sub_filename[0] != '\0')) {
  509. char *vtt_dirname_r = av_strdup(vs->vtt_avf->url);
  510. vtt_dirname = (char*)av_dirname(vtt_dirname_r);
  511. sub_path_size = strlen(segment->sub_filename) + 1 + strlen(vtt_dirname);
  512. sub_path = av_malloc(sub_path_size);
  513. if (!sub_path) {
  514. ret = AVERROR(ENOMEM);
  515. goto fail;
  516. }
  517. av_strlcpy(sub_path, vtt_dirname, sub_path_size);
  518. av_strlcat(sub_path, segment->sub_filename, sub_path_size);
  519. if (hls->method || (proto && !av_strcasecmp(proto, "http"))) {
  520. av_dict_set(&options, "method", "DELETE", 0);
  521. if ((ret = vs->vtt_avf->io_open(vs->vtt_avf, &out, sub_path, AVIO_FLAG_WRITE, &options)) < 0) {
  522. if (hls->ignore_io_errors)
  523. ret = 0;
  524. av_free(sub_path);
  525. goto fail;
  526. }
  527. ff_format_io_close(vs->vtt_avf, &out);
  528. } else if (unlink(sub_path) < 0) {
  529. av_log(hls, AV_LOG_ERROR, "failed to delete old segment %s: %s\n",
  530. sub_path, strerror(errno));
  531. }
  532. av_free(sub_path);
  533. }
  534. av_freep(&path);
  535. previous_segment = segment;
  536. segment = previous_segment->next;
  537. av_free(previous_segment);
  538. }
  539. fail:
  540. av_free(path);
  541. av_free(dirname);
  542. av_free(vtt_dirname);
  543. return ret;
  544. }
  545. static int randomize(uint8_t *buf, int len)
  546. {
  547. #if CONFIG_GCRYPT
  548. gcry_randomize(buf, len, GCRY_VERY_STRONG_RANDOM);
  549. return 0;
  550. #elif CONFIG_OPENSSL
  551. if (RAND_bytes(buf, len))
  552. return 0;
  553. #else
  554. return AVERROR(ENOSYS);
  555. #endif
  556. return AVERROR(EINVAL);
  557. }
  558. static int do_encrypt(AVFormatContext *s, VariantStream *vs)
  559. {
  560. HLSContext *hls = s->priv_data;
  561. int ret;
  562. int len;
  563. AVIOContext *pb;
  564. uint8_t key[KEYSIZE];
  565. len = strlen(s->url) + 4 + 1;
  566. hls->key_basename = av_mallocz(len);
  567. if (!hls->key_basename)
  568. return AVERROR(ENOMEM);
  569. av_strlcpy(hls->key_basename, s->url, len);
  570. av_strlcat(hls->key_basename, ".key", len);
  571. if (hls->key_url) {
  572. av_strlcpy(hls->key_file, hls->key_url, sizeof(hls->key_file));
  573. av_strlcpy(hls->key_uri, hls->key_url, sizeof(hls->key_uri));
  574. } else {
  575. av_strlcpy(hls->key_file, hls->key_basename, sizeof(hls->key_file));
  576. av_strlcpy(hls->key_uri, hls->key_basename, sizeof(hls->key_uri));
  577. }
  578. if (!*hls->iv_string) {
  579. uint8_t iv[16] = { 0 };
  580. char buf[33];
  581. if (!hls->iv) {
  582. AV_WB64(iv + 8, vs->sequence);
  583. } else {
  584. memcpy(iv, hls->iv, sizeof(iv));
  585. }
  586. ff_data_to_hex(buf, iv, sizeof(iv), 0);
  587. buf[32] = '\0';
  588. memcpy(hls->iv_string, buf, sizeof(hls->iv_string));
  589. }
  590. if (!*hls->key_uri) {
  591. av_log(hls, AV_LOG_ERROR, "no key URI specified in key info file\n");
  592. return AVERROR(EINVAL);
  593. }
  594. if (!*hls->key_file) {
  595. av_log(hls, AV_LOG_ERROR, "no key file specified in key info file\n");
  596. return AVERROR(EINVAL);
  597. }
  598. if (!*hls->key_string) {
  599. if (!hls->key) {
  600. if ((ret = randomize(key, sizeof(key))) < 0) {
  601. av_log(s, AV_LOG_ERROR, "Cannot generate a strong random key\n");
  602. return ret;
  603. }
  604. } else {
  605. memcpy(key, hls->key, sizeof(key));
  606. }
  607. ff_data_to_hex(hls->key_string, key, sizeof(key), 0);
  608. if ((ret = s->io_open(s, &pb, hls->key_file, AVIO_FLAG_WRITE, NULL)) < 0)
  609. return ret;
  610. avio_seek(pb, 0, SEEK_CUR);
  611. avio_write(pb, key, KEYSIZE);
  612. avio_close(pb);
  613. }
  614. return 0;
  615. }
  616. static int hls_encryption_start(AVFormatContext *s)
  617. {
  618. HLSContext *hls = s->priv_data;
  619. int ret;
  620. AVIOContext *pb;
  621. uint8_t key[KEYSIZE];
  622. if ((ret = s->io_open(s, &pb, hls->key_info_file, AVIO_FLAG_READ, NULL)) < 0) {
  623. av_log(hls, AV_LOG_ERROR,
  624. "error opening key info file %s\n", hls->key_info_file);
  625. return ret;
  626. }
  627. ff_get_line(pb, hls->key_uri, sizeof(hls->key_uri));
  628. hls->key_uri[strcspn(hls->key_uri, "\r\n")] = '\0';
  629. ff_get_line(pb, hls->key_file, sizeof(hls->key_file));
  630. hls->key_file[strcspn(hls->key_file, "\r\n")] = '\0';
  631. ff_get_line(pb, hls->iv_string, sizeof(hls->iv_string));
  632. hls->iv_string[strcspn(hls->iv_string, "\r\n")] = '\0';
  633. ff_format_io_close(s, &pb);
  634. if (!*hls->key_uri) {
  635. av_log(hls, AV_LOG_ERROR, "no key URI specified in key info file\n");
  636. return AVERROR(EINVAL);
  637. }
  638. if (!*hls->key_file) {
  639. av_log(hls, AV_LOG_ERROR, "no key file specified in key info file\n");
  640. return AVERROR(EINVAL);
  641. }
  642. if ((ret = s->io_open(s, &pb, hls->key_file, AVIO_FLAG_READ, NULL)) < 0) {
  643. av_log(hls, AV_LOG_ERROR, "error opening key file %s\n", hls->key_file);
  644. return ret;
  645. }
  646. ret = avio_read(pb, key, sizeof(key));
  647. ff_format_io_close(s, &pb);
  648. if (ret != sizeof(key)) {
  649. av_log(hls, AV_LOG_ERROR, "error reading key file %s\n", hls->key_file);
  650. if (ret >= 0 || ret == AVERROR_EOF)
  651. ret = AVERROR(EINVAL);
  652. return ret;
  653. }
  654. ff_data_to_hex(hls->key_string, key, sizeof(key), 0);
  655. return 0;
  656. }
  657. static int hls_mux_init(AVFormatContext *s, VariantStream *vs)
  658. {
  659. AVDictionary *options = NULL;
  660. HLSContext *hls = s->priv_data;
  661. AVFormatContext *oc;
  662. AVFormatContext *vtt_oc = NULL;
  663. int byterange_mode = (hls->flags & HLS_SINGLE_FILE) || (hls->max_seg_size > 0);
  664. int i, ret;
  665. ret = avformat_alloc_output_context2(&vs->avf, vs->oformat, NULL, NULL);
  666. if (ret < 0)
  667. return ret;
  668. oc = vs->avf;
  669. oc->url = av_strdup("");
  670. if (!oc->url)
  671. return AVERROR(ENOMEM);
  672. oc->oformat = vs->oformat;
  673. oc->interrupt_callback = s->interrupt_callback;
  674. oc->max_delay = s->max_delay;
  675. oc->opaque = s->opaque;
  676. oc->io_open = s->io_open;
  677. oc->io_close = s->io_close;
  678. av_dict_copy(&oc->metadata, s->metadata, 0);
  679. if (vs->vtt_oformat) {
  680. ret = avformat_alloc_output_context2(&vs->vtt_avf, vs->vtt_oformat, NULL, NULL);
  681. if (ret < 0)
  682. return ret;
  683. vtt_oc = vs->vtt_avf;
  684. vtt_oc->oformat = vs->vtt_oformat;
  685. av_dict_copy(&vtt_oc->metadata, s->metadata, 0);
  686. }
  687. for (i = 0; i < vs->nb_streams; i++) {
  688. AVStream *st;
  689. AVFormatContext *loc;
  690. if (vs->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
  691. loc = vtt_oc;
  692. else
  693. loc = oc;
  694. if (!(st = avformat_new_stream(loc, NULL)))
  695. return AVERROR(ENOMEM);
  696. avcodec_parameters_copy(st->codecpar, vs->streams[i]->codecpar);
  697. if (!oc->oformat->codec_tag ||
  698. av_codec_get_id (oc->oformat->codec_tag, vs->streams[i]->codecpar->codec_tag) == st->codecpar->codec_id ||
  699. av_codec_get_tag(oc->oformat->codec_tag, vs->streams[i]->codecpar->codec_id) <= 0) {
  700. st->codecpar->codec_tag = vs->streams[i]->codecpar->codec_tag;
  701. } else {
  702. st->codecpar->codec_tag = 0;
  703. }
  704. st->sample_aspect_ratio = vs->streams[i]->sample_aspect_ratio;
  705. st->time_base = vs->streams[i]->time_base;
  706. av_dict_copy(&st->metadata, vs->streams[i]->metadata, 0);
  707. }
  708. vs->packets_written = 1;
  709. vs->start_pos = 0;
  710. vs->new_start = 1;
  711. if (hls->segment_type == SEGMENT_TYPE_FMP4 && hls->max_seg_size > 0) {
  712. if (hls->http_persistent > 0) {
  713. //TODO: Support fragment fmp4 for http persistent in HLS muxer.
  714. av_log(s, AV_LOG_WARNING, "http persistent mode is currently unsupported for fragment mp4 in the HLS muxer.\n");
  715. }
  716. if (hls->max_seg_size > 0) {
  717. av_log(s, AV_LOG_WARNING, "Multi-file byterange mode is currently unsupported in the HLS muxer.\n");
  718. return AVERROR_PATCHWELCOME;
  719. }
  720. }
  721. vs->packets_written = 0;
  722. vs->init_range_length = 0;
  723. set_http_options(s, &options, hls);
  724. if ((ret = avio_open_dyn_buf(&oc->pb)) < 0)
  725. return ret;
  726. if (hls->segment_type == SEGMENT_TYPE_FMP4) {
  727. if (byterange_mode) {
  728. ret = hlsenc_io_open(s, &vs->out, vs->basename, &options);
  729. } else {
  730. ret = hlsenc_io_open(s, &vs->out, vs->base_output_dirname, &options);
  731. }
  732. }
  733. av_dict_free(&options);
  734. if (ret < 0) {
  735. av_log(s, AV_LOG_ERROR, "Failed to open segment '%s'\n", vs->fmp4_init_filename);
  736. return ret;
  737. }
  738. if (hls->format_options_str) {
  739. ret = av_dict_parse_string(&hls->format_options, hls->format_options_str, "=", ":", 0);
  740. if (ret < 0) {
  741. av_log(s, AV_LOG_ERROR, "Could not parse format options list '%s'\n",
  742. hls->format_options_str);
  743. return ret;
  744. }
  745. }
  746. av_dict_copy(&options, hls->format_options, 0);
  747. if (hls->segment_type == SEGMENT_TYPE_FMP4) {
  748. av_dict_set(&options, "fflags", "-autobsf", 0);
  749. av_dict_set(&options, "movflags", "+frag_custom+dash+delay_moov", AV_DICT_APPEND);
  750. ret = avformat_init_output(oc, &options);
  751. if (ret < 0)
  752. return ret;
  753. if (av_dict_count(options)) {
  754. av_log(s, AV_LOG_ERROR, "Some of the provided format options in '%s' are not recognized\n", hls->format_options_str);
  755. av_dict_free(&options);
  756. return AVERROR(EINVAL);
  757. }
  758. }
  759. avio_flush(oc->pb);
  760. av_dict_free(&options);
  761. return 0;
  762. }
  763. static HLSSegment *find_segment_by_filename(HLSSegment *segment, const char *filename)
  764. {
  765. while (segment) {
  766. if (!av_strcasecmp(segment->filename,filename))
  767. return segment;
  768. segment = segment->next;
  769. }
  770. return (HLSSegment *) NULL;
  771. }
  772. static int sls_flags_filename_process(struct AVFormatContext *s, HLSContext *hls,
  773. VariantStream *vs, HLSSegment *en,
  774. double duration, int64_t pos, int64_t size)
  775. {
  776. if ((hls->flags & (HLS_SECOND_LEVEL_SEGMENT_SIZE | HLS_SECOND_LEVEL_SEGMENT_DURATION)) &&
  777. strlen(vs->current_segment_final_filename_fmt)) {
  778. char * new_url = av_strdup(vs->current_segment_final_filename_fmt);
  779. if (!new_url) {
  780. av_free(en);
  781. return AVERROR(ENOMEM);
  782. }
  783. ff_format_set_url(vs->avf, new_url);
  784. if (hls->flags & HLS_SECOND_LEVEL_SEGMENT_SIZE) {
  785. char *filename = NULL;
  786. if (replace_int_data_in_filename(&filename, vs->avf->url, 's', pos + size) < 1) {
  787. av_log(hls, AV_LOG_ERROR,
  788. "Invalid second level segment filename template '%s', "
  789. "you can try to remove second_level_segment_size flag\n",
  790. vs->avf->url);
  791. av_free(filename);
  792. av_free(en);
  793. return AVERROR(EINVAL);
  794. }
  795. ff_format_set_url(vs->avf, filename);
  796. }
  797. if (hls->flags & HLS_SECOND_LEVEL_SEGMENT_DURATION) {
  798. char *filename = NULL;
  799. if (replace_int_data_in_filename(&filename, vs->avf->url,
  800. 't', (int64_t)round(duration * HLS_MICROSECOND_UNIT)) < 1) {
  801. av_log(hls, AV_LOG_ERROR,
  802. "Invalid second level segment filename template '%s', "
  803. "you can try to remove second_level_segment_time flag\n",
  804. vs->avf->url);
  805. av_free(filename);
  806. av_free(en);
  807. return AVERROR(EINVAL);
  808. }
  809. ff_format_set_url(vs->avf, filename);
  810. }
  811. }
  812. return 0;
  813. }
  814. static int sls_flag_check_duration_size_index(HLSContext *hls)
  815. {
  816. int ret = 0;
  817. if (hls->flags & HLS_SECOND_LEVEL_SEGMENT_DURATION) {
  818. av_log(hls, AV_LOG_ERROR,
  819. "second_level_segment_duration hls_flag requires strftime to be true\n");
  820. ret = AVERROR(EINVAL);
  821. }
  822. if (hls->flags & HLS_SECOND_LEVEL_SEGMENT_SIZE) {
  823. av_log(hls, AV_LOG_ERROR,
  824. "second_level_segment_size hls_flag requires strfime to be true\n");
  825. ret = AVERROR(EINVAL);
  826. }
  827. if (hls->flags & HLS_SECOND_LEVEL_SEGMENT_INDEX) {
  828. av_log(hls, AV_LOG_ERROR,
  829. "second_level_segment_index hls_flag requires strftime to be true\n");
  830. ret = AVERROR(EINVAL);
  831. }
  832. return ret;
  833. }
  834. static int sls_flag_check_duration_size(HLSContext *hls, VariantStream *vs)
  835. {
  836. const char *proto = avio_find_protocol_name(vs->basename);
  837. int segment_renaming_ok = proto && !strcmp(proto, "file");
  838. int ret = 0;
  839. if ((hls->flags & HLS_SECOND_LEVEL_SEGMENT_DURATION) && !segment_renaming_ok) {
  840. av_log(hls, AV_LOG_ERROR,
  841. "second_level_segment_duration hls_flag works only with file protocol segment names\n");
  842. ret = AVERROR(EINVAL);
  843. }
  844. if ((hls->flags & HLS_SECOND_LEVEL_SEGMENT_SIZE) && !segment_renaming_ok) {
  845. av_log(hls, AV_LOG_ERROR,
  846. "second_level_segment_size hls_flag works only with file protocol segment names\n");
  847. ret = AVERROR(EINVAL);
  848. }
  849. return ret;
  850. }
  851. static void sls_flag_file_rename(HLSContext *hls, VariantStream *vs, char *old_filename) {
  852. if ((hls->flags & (HLS_SECOND_LEVEL_SEGMENT_SIZE | HLS_SECOND_LEVEL_SEGMENT_DURATION)) &&
  853. strlen(vs->current_segment_final_filename_fmt)) {
  854. ff_rename(old_filename, vs->avf->url, hls);
  855. }
  856. }
  857. static int sls_flag_use_localtime_filename(AVFormatContext *oc, HLSContext *c, VariantStream *vs)
  858. {
  859. if (c->flags & HLS_SECOND_LEVEL_SEGMENT_INDEX) {
  860. char *filename = NULL;
  861. if (replace_int_data_in_filename(&filename,
  862. #if FF_API_HLS_WRAP
  863. oc->url, 'd', c->wrap ? vs->sequence % c->wrap : vs->sequence) < 1) {
  864. #else
  865. oc->url, 'd', vs->sequence) < 1) {
  866. #endif
  867. av_log(c, AV_LOG_ERROR, "Invalid second level segment filename template '%s', "
  868. "you can try to remove second_level_segment_index flag\n",
  869. oc->url);
  870. av_free(filename);
  871. return AVERROR(EINVAL);
  872. }
  873. ff_format_set_url(oc, filename);
  874. }
  875. if (c->flags & (HLS_SECOND_LEVEL_SEGMENT_SIZE | HLS_SECOND_LEVEL_SEGMENT_DURATION)) {
  876. av_strlcpy(vs->current_segment_final_filename_fmt, oc->url,
  877. sizeof(vs->current_segment_final_filename_fmt));
  878. if (c->flags & HLS_SECOND_LEVEL_SEGMENT_SIZE) {
  879. char *filename = NULL;
  880. if (replace_int_data_in_filename(&filename, oc->url, 's', 0) < 1) {
  881. av_log(c, AV_LOG_ERROR, "Invalid second level segment filename template '%s', "
  882. "you can try to remove second_level_segment_size flag\n",
  883. oc->url);
  884. av_free(filename);
  885. return AVERROR(EINVAL);
  886. }
  887. ff_format_set_url(oc, filename);
  888. }
  889. if (c->flags & HLS_SECOND_LEVEL_SEGMENT_DURATION) {
  890. char *filename = NULL;
  891. if (replace_int_data_in_filename(&filename, oc->url, 't', 0) < 1) {
  892. av_log(c, AV_LOG_ERROR, "Invalid second level segment filename template '%s', "
  893. "you can try to remove second_level_segment_time flag\n",
  894. oc->url);
  895. av_free(filename);
  896. return AVERROR(EINVAL);
  897. }
  898. ff_format_set_url(oc, filename);
  899. }
  900. }
  901. return 0;
  902. }
  903. /* Create a new segment and append it to the segment list */
  904. static int hls_append_segment(struct AVFormatContext *s, HLSContext *hls,
  905. VariantStream *vs, double duration, int64_t pos,
  906. int64_t size)
  907. {
  908. HLSSegment *en = av_malloc(sizeof(*en));
  909. const char *filename;
  910. int byterange_mode = (hls->flags & HLS_SINGLE_FILE) || (hls->max_seg_size > 0);
  911. int ret;
  912. if (!en)
  913. return AVERROR(ENOMEM);
  914. en->var_stream_idx = vs->var_stream_idx;
  915. ret = sls_flags_filename_process(s, hls, vs, en, duration, pos, size);
  916. if (ret < 0) {
  917. return ret;
  918. }
  919. filename = av_basename(vs->avf->url);
  920. if (hls->use_localtime_mkdir) {
  921. filename = vs->avf->url;
  922. }
  923. if ((find_segment_by_filename(vs->segments, filename) || find_segment_by_filename(vs->old_segments, filename))
  924. && !byterange_mode) {
  925. av_log(hls, AV_LOG_WARNING, "Duplicated segment filename detected: %s\n", filename);
  926. }
  927. av_strlcpy(en->filename, filename, sizeof(en->filename));
  928. if (vs->has_subtitle)
  929. av_strlcpy(en->sub_filename, av_basename(vs->vtt_avf->url), sizeof(en->sub_filename));
  930. else
  931. en->sub_filename[0] = '\0';
  932. en->duration = duration;
  933. en->pos = pos;
  934. en->size = size;
  935. en->keyframe_pos = vs->video_keyframe_pos;
  936. en->keyframe_size = vs->video_keyframe_size;
  937. en->next = NULL;
  938. en->discont = 0;
  939. if (vs->discontinuity) {
  940. en->discont = 1;
  941. vs->discontinuity = 0;
  942. }
  943. if (hls->key_info_file || hls->encrypt) {
  944. av_strlcpy(en->key_uri, hls->key_uri, sizeof(en->key_uri));
  945. av_strlcpy(en->iv_string, hls->iv_string, sizeof(en->iv_string));
  946. }
  947. if (!vs->segments)
  948. vs->segments = en;
  949. else
  950. vs->last_segment->next = en;
  951. vs->last_segment = en;
  952. // EVENT or VOD playlists imply sliding window cannot be used
  953. if (hls->pl_type != PLAYLIST_TYPE_NONE)
  954. hls->max_nb_segments = 0;
  955. if (hls->max_nb_segments && vs->nb_entries >= hls->max_nb_segments) {
  956. en = vs->segments;
  957. vs->initial_prog_date_time += en->duration;
  958. vs->segments = en->next;
  959. if (en && hls->flags & HLS_DELETE_SEGMENTS &&
  960. #if FF_API_HLS_WRAP
  961. !(hls->flags & HLS_SINGLE_FILE || hls->wrap)) {
  962. #else
  963. !(hls->flags & HLS_SINGLE_FILE)) {
  964. #endif
  965. en->next = vs->old_segments;
  966. vs->old_segments = en;
  967. if ((ret = hls_delete_old_segments(s, hls, vs)) < 0)
  968. return ret;
  969. } else
  970. av_free(en);
  971. } else
  972. vs->nb_entries++;
  973. if (hls->max_seg_size > 0) {
  974. return 0;
  975. }
  976. vs->sequence++;
  977. return 0;
  978. }
  979. static int parse_playlist(AVFormatContext *s, const char *url, VariantStream *vs)
  980. {
  981. HLSContext *hls = s->priv_data;
  982. AVIOContext *in;
  983. int ret = 0, is_segment = 0;
  984. int64_t new_start_pos;
  985. char line[MAX_URL_SIZE];
  986. const char *ptr;
  987. const char *end;
  988. if ((ret = ffio_open_whitelist(&in, url, AVIO_FLAG_READ,
  989. &s->interrupt_callback, NULL,
  990. s->protocol_whitelist, s->protocol_blacklist)) < 0)
  991. return ret;
  992. ff_get_chomp_line(in, line, sizeof(line));
  993. if (strcmp(line, "#EXTM3U")) {
  994. ret = AVERROR_INVALIDDATA;
  995. goto fail;
  996. }
  997. vs->discontinuity = 0;
  998. while (!avio_feof(in)) {
  999. ff_get_chomp_line(in, line, sizeof(line));
  1000. if (av_strstart(line, "#EXT-X-MEDIA-SEQUENCE:", &ptr)) {
  1001. int64_t tmp_sequence = strtoll(ptr, NULL, 10);
  1002. if (tmp_sequence < vs->sequence)
  1003. av_log(hls, AV_LOG_VERBOSE,
  1004. "Found playlist sequence number was smaller """
  1005. "than specified start sequence number: %"PRId64" < %"PRId64", "
  1006. "omitting\n", tmp_sequence, hls->start_sequence);
  1007. else {
  1008. av_log(hls, AV_LOG_DEBUG, "Found playlist sequence number: %"PRId64"\n", tmp_sequence);
  1009. vs->sequence = tmp_sequence;
  1010. }
  1011. } else if (av_strstart(line, "#EXT-X-DISCONTINUITY", &ptr)) {
  1012. is_segment = 1;
  1013. vs->discontinuity = 1;
  1014. } else if (av_strstart(line, "#EXTINF:", &ptr)) {
  1015. is_segment = 1;
  1016. vs->duration = atof(ptr);
  1017. } else if (av_stristart(line, "#EXT-X-KEY:", &ptr)) {
  1018. ptr = av_stristr(line, "URI=\"");
  1019. if (ptr) {
  1020. ptr += strlen("URI=\"");
  1021. end = av_stristr(ptr, ",");
  1022. if (end) {
  1023. av_strlcpy(hls->key_uri, ptr, end - ptr);
  1024. } else {
  1025. av_strlcpy(hls->key_uri, ptr, sizeof(hls->key_uri));
  1026. }
  1027. }
  1028. ptr = av_stristr(line, "IV=0x");
  1029. if (ptr) {
  1030. ptr += strlen("IV=0x");
  1031. end = av_stristr(ptr, ",");
  1032. if (end) {
  1033. av_strlcpy(hls->iv_string, ptr, end - ptr);
  1034. } else {
  1035. av_strlcpy(hls->iv_string, ptr, sizeof(hls->iv_string));
  1036. }
  1037. }
  1038. } else if (av_strstart(line, "#", NULL)) {
  1039. continue;
  1040. } else if (line[0]) {
  1041. if (is_segment) {
  1042. char *new_file = av_strdup(line);
  1043. if (!new_file) {
  1044. ret = AVERROR(ENOMEM);
  1045. goto fail;
  1046. }
  1047. ff_format_set_url(vs->avf, new_file);
  1048. is_segment = 0;
  1049. new_start_pos = avio_tell(vs->avf->pb);
  1050. vs->size = new_start_pos - vs->start_pos;
  1051. ret = hls_append_segment(s, hls, vs, vs->duration, vs->start_pos, vs->size);
  1052. if (ret < 0)
  1053. goto fail;
  1054. vs->start_pos = new_start_pos;
  1055. }
  1056. }
  1057. }
  1058. fail:
  1059. avio_close(in);
  1060. return ret;
  1061. }
  1062. static void hls_free_segments(HLSSegment *p)
  1063. {
  1064. HLSSegment *en;
  1065. while (p) {
  1066. en = p;
  1067. p = p->next;
  1068. av_free(en);
  1069. }
  1070. }
  1071. static int hls_rename_temp_file(AVFormatContext *s, AVFormatContext *oc)
  1072. {
  1073. size_t len = strlen(oc->url);
  1074. char *final_filename = av_strdup(oc->url);
  1075. int ret;
  1076. if (!final_filename)
  1077. return AVERROR(ENOMEM);
  1078. final_filename[len-4] = '\0';
  1079. ret = ff_rename(oc->url, final_filename, s);
  1080. oc->url[len-4] = '\0';
  1081. av_freep(&final_filename);
  1082. return ret;
  1083. }
  1084. static const char* get_relative_url(const char *master_url, const char *media_url)
  1085. {
  1086. const char *p = strrchr(master_url, '/');
  1087. size_t base_len = 0;
  1088. if (!p) p = strrchr(master_url, '\\');
  1089. if (p) {
  1090. base_len = p + 1 - master_url;
  1091. if (av_strncasecmp(master_url, media_url, base_len)) {
  1092. av_log(NULL, AV_LOG_WARNING, "Unable to find relative url\n");
  1093. return NULL;
  1094. }
  1095. }
  1096. return media_url + base_len;
  1097. }
  1098. static int64_t get_stream_bit_rate(AVStream *stream)
  1099. {
  1100. AVCPBProperties *props = (AVCPBProperties*)av_stream_get_side_data(
  1101. stream,
  1102. AV_PKT_DATA_CPB_PROPERTIES,
  1103. NULL
  1104. );
  1105. if (stream->codecpar->bit_rate)
  1106. return stream->codecpar->bit_rate;
  1107. else if (props)
  1108. return props->max_bitrate;
  1109. return 0;
  1110. }
  1111. static int create_master_playlist(AVFormatContext *s,
  1112. VariantStream * const input_vs)
  1113. {
  1114. HLSContext *hls = s->priv_data;
  1115. VariantStream *vs, *temp_vs;
  1116. AVStream *vid_st, *aud_st;
  1117. AVDictionary *options = NULL;
  1118. unsigned int i, j;
  1119. int ret, bandwidth;
  1120. const char *m3u8_rel_name = NULL;
  1121. char *ccgroup;
  1122. ClosedCaptionsStream *ccs;
  1123. const char *proto = avio_find_protocol_name(hls->master_m3u8_url);
  1124. int is_file_proto = proto && !strcmp(proto, "file");
  1125. int use_temp_file = is_file_proto && ((hls->flags & HLS_TEMP_FILE) || hls->master_publish_rate);
  1126. char temp_filename[MAX_URL_SIZE];
  1127. input_vs->m3u8_created = 1;
  1128. if (!hls->master_m3u8_created) {
  1129. /* For the first time, wait until all the media playlists are created */
  1130. for (i = 0; i < hls->nb_varstreams; i++)
  1131. if (!hls->var_streams[i].m3u8_created)
  1132. return 0;
  1133. } else {
  1134. /* Keep publishing the master playlist at the configured rate */
  1135. if (&hls->var_streams[0] != input_vs || !hls->master_publish_rate ||
  1136. input_vs->number % hls->master_publish_rate)
  1137. return 0;
  1138. }
  1139. set_http_options(s, &options, hls);
  1140. snprintf(temp_filename, sizeof(temp_filename), use_temp_file ? "%s.tmp" : "%s", hls->master_m3u8_url);
  1141. ret = hlsenc_io_open(s, &hls->m3u8_out, temp_filename, &options);
  1142. av_dict_free(&options);
  1143. if (ret < 0) {
  1144. av_log(s, AV_LOG_ERROR, "Failed to open master play list file '%s'\n",
  1145. temp_filename);
  1146. goto fail;
  1147. }
  1148. ff_hls_write_playlist_version(hls->m3u8_out, hls->version);
  1149. for (i = 0; i < hls->nb_ccstreams; i++) {
  1150. ccs = &(hls->cc_streams[i]);
  1151. avio_printf(hls->m3u8_out, "#EXT-X-MEDIA:TYPE=CLOSED-CAPTIONS");
  1152. avio_printf(hls->m3u8_out, ",GROUP-ID=\"%s\"", ccs->ccgroup);
  1153. avio_printf(hls->m3u8_out, ",NAME=\"%s\"", ccs->instreamid);
  1154. if (ccs->language)
  1155. avio_printf(hls->m3u8_out, ",LANGUAGE=\"%s\"", ccs->language);
  1156. avio_printf(hls->m3u8_out, ",INSTREAM-ID=\"%s\"\n", ccs->instreamid);
  1157. }
  1158. /* For audio only variant streams add #EXT-X-MEDIA tag with attributes*/
  1159. for (i = 0; i < hls->nb_varstreams; i++) {
  1160. vs = &(hls->var_streams[i]);
  1161. if (vs->has_video || vs->has_subtitle || !vs->agroup)
  1162. continue;
  1163. m3u8_rel_name = get_relative_url(hls->master_m3u8_url, vs->m3u8_name);
  1164. if (!m3u8_rel_name) {
  1165. av_log(s, AV_LOG_ERROR, "Unable to find relative URL\n");
  1166. goto fail;
  1167. }
  1168. ff_hls_write_audio_rendition(hls->m3u8_out, vs->agroup, m3u8_rel_name, vs->language, i, hls->has_default_key ? vs->is_default : 1);
  1169. }
  1170. /* For variant streams with video add #EXT-X-STREAM-INF tag with attributes*/
  1171. for (i = 0; i < hls->nb_varstreams; i++) {
  1172. vs = &(hls->var_streams[i]);
  1173. m3u8_rel_name = get_relative_url(hls->master_m3u8_url, vs->m3u8_name);
  1174. if (!m3u8_rel_name) {
  1175. av_log(s, AV_LOG_ERROR, "Unable to find relative URL\n");
  1176. goto fail;
  1177. }
  1178. vid_st = NULL;
  1179. aud_st = NULL;
  1180. for (j = 0; j < vs->nb_streams; j++) {
  1181. if (vs->streams[j]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
  1182. vid_st = vs->streams[j];
  1183. else if (vs->streams[j]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
  1184. aud_st = vs->streams[j];
  1185. }
  1186. if (!vid_st && !aud_st) {
  1187. av_log(s, AV_LOG_WARNING, "Media stream not found\n");
  1188. continue;
  1189. }
  1190. /**
  1191. * Traverse through the list of audio only rendition streams and find
  1192. * the rendition which has highest bitrate in the same audio group
  1193. */
  1194. if (vs->agroup) {
  1195. for (j = 0; j < hls->nb_varstreams; j++) {
  1196. temp_vs = &(hls->var_streams[j]);
  1197. if (!temp_vs->has_video && !temp_vs->has_subtitle &&
  1198. temp_vs->agroup &&
  1199. !av_strcasecmp(temp_vs->agroup, vs->agroup)) {
  1200. if (!aud_st)
  1201. aud_st = temp_vs->streams[0];
  1202. if (temp_vs->streams[0]->codecpar->bit_rate >
  1203. aud_st->codecpar->bit_rate)
  1204. aud_st = temp_vs->streams[0];
  1205. }
  1206. }
  1207. }
  1208. bandwidth = 0;
  1209. if (vid_st)
  1210. bandwidth += get_stream_bit_rate(vid_st);
  1211. if (aud_st)
  1212. bandwidth += get_stream_bit_rate(aud_st);
  1213. bandwidth += bandwidth / 10;
  1214. ccgroup = NULL;
  1215. if (vid_st && vs->ccgroup) {
  1216. /* check if this group name is available in the cc map string */
  1217. for (j = 0; j < hls->nb_ccstreams; j++) {
  1218. ccs = &(hls->cc_streams[j]);
  1219. if (!av_strcasecmp(ccs->ccgroup, vs->ccgroup)) {
  1220. ccgroup = vs->ccgroup;
  1221. break;
  1222. }
  1223. }
  1224. if (j == hls->nb_ccstreams)
  1225. av_log(s, AV_LOG_WARNING, "mapping ccgroup %s not found\n",
  1226. vs->ccgroup);
  1227. }
  1228. if (!hls->has_default_key || !hls->has_video_m3u8) {
  1229. ff_hls_write_stream_info(vid_st, hls->m3u8_out, bandwidth, m3u8_rel_name,
  1230. aud_st ? vs->agroup : NULL, vs->codec_attr, ccgroup);
  1231. } else {
  1232. if (vid_st) {
  1233. ff_hls_write_stream_info(vid_st, hls->m3u8_out, bandwidth, m3u8_rel_name,
  1234. aud_st ? vs->agroup : NULL, vs->codec_attr, ccgroup);
  1235. }
  1236. }
  1237. }
  1238. fail:
  1239. if (ret >=0)
  1240. hls->master_m3u8_created = 1;
  1241. hlsenc_io_close(s, &hls->m3u8_out, temp_filename);
  1242. if (use_temp_file)
  1243. ff_rename(temp_filename, hls->master_m3u8_url, s);
  1244. return ret;
  1245. }
  1246. static int hls_window(AVFormatContext *s, int last, VariantStream *vs)
  1247. {
  1248. HLSContext *hls = s->priv_data;
  1249. HLSSegment *en;
  1250. int target_duration = 0;
  1251. int ret = 0;
  1252. char temp_filename[MAX_URL_SIZE];
  1253. char temp_vtt_filename[MAX_URL_SIZE];
  1254. int64_t sequence = FFMAX(hls->start_sequence, vs->sequence - vs->nb_entries);
  1255. const char *proto = avio_find_protocol_name(vs->m3u8_name);
  1256. int is_file_proto = proto && !strcmp(proto, "file");
  1257. int use_temp_file = is_file_proto && ((hls->flags & HLS_TEMP_FILE) || !(hls->pl_type == PLAYLIST_TYPE_VOD));
  1258. static unsigned warned_non_file;
  1259. char *key_uri = NULL;
  1260. char *iv_string = NULL;
  1261. AVDictionary *options = NULL;
  1262. double prog_date_time = vs->initial_prog_date_time;
  1263. double *prog_date_time_p = (hls->flags & HLS_PROGRAM_DATE_TIME) ? &prog_date_time : NULL;
  1264. int byterange_mode = (hls->flags & HLS_SINGLE_FILE) || (hls->max_seg_size > 0);
  1265. hls->version = 3;
  1266. if (byterange_mode) {
  1267. hls->version = 4;
  1268. sequence = 0;
  1269. }
  1270. if (hls->flags & HLS_INDEPENDENT_SEGMENTS) {
  1271. hls->version = 6;
  1272. }
  1273. if (hls->segment_type == SEGMENT_TYPE_FMP4) {
  1274. hls->version = 7;
  1275. }
  1276. if (!is_file_proto && (hls->flags & HLS_TEMP_FILE) && !warned_non_file++)
  1277. av_log(s, AV_LOG_ERROR, "Cannot use rename on non file protocol, this may lead to races and temporary partial files\n");
  1278. set_http_options(s, &options, hls);
  1279. snprintf(temp_filename, sizeof(temp_filename), use_temp_file ? "%s.tmp" : "%s", vs->m3u8_name);
  1280. if ((ret = hlsenc_io_open(s, byterange_mode ? &hls->m3u8_out : &vs->out, temp_filename, &options)) < 0) {
  1281. if (hls->ignore_io_errors)
  1282. ret = 0;
  1283. goto fail;
  1284. }
  1285. for (en = vs->segments; en; en = en->next) {
  1286. if (target_duration <= en->duration)
  1287. target_duration = lrint(en->duration);
  1288. }
  1289. vs->discontinuity_set = 0;
  1290. ff_hls_write_playlist_header(byterange_mode ? hls->m3u8_out : vs->out, hls->version, hls->allowcache,
  1291. target_duration, sequence, hls->pl_type, hls->flags & HLS_I_FRAMES_ONLY);
  1292. if ((hls->flags & HLS_DISCONT_START) && sequence==hls->start_sequence && vs->discontinuity_set==0 ) {
  1293. avio_printf(byterange_mode ? hls->m3u8_out : vs->out, "#EXT-X-DISCONTINUITY\n");
  1294. vs->discontinuity_set = 1;
  1295. }
  1296. if (vs->has_video && (hls->flags & HLS_INDEPENDENT_SEGMENTS)) {
  1297. avio_printf(byterange_mode ? hls->m3u8_out : vs->out, "#EXT-X-INDEPENDENT-SEGMENTS\n");
  1298. }
  1299. for (en = vs->segments; en; en = en->next) {
  1300. if ((hls->encrypt || hls->key_info_file) && (!key_uri || strcmp(en->key_uri, key_uri) ||
  1301. av_strcasecmp(en->iv_string, iv_string))) {
  1302. avio_printf(byterange_mode ? hls->m3u8_out : vs->out, "#EXT-X-KEY:METHOD=AES-128,URI=\"%s\"", en->key_uri);
  1303. if (*en->iv_string)
  1304. avio_printf(byterange_mode ? hls->m3u8_out : vs->out, ",IV=0x%s", en->iv_string);
  1305. avio_printf(byterange_mode ? hls->m3u8_out : vs->out, "\n");
  1306. key_uri = en->key_uri;
  1307. iv_string = en->iv_string;
  1308. }
  1309. if ((hls->segment_type == SEGMENT_TYPE_FMP4) && (en == vs->segments)) {
  1310. ff_hls_write_init_file(byterange_mode ? hls->m3u8_out : vs->out, (hls->flags & HLS_SINGLE_FILE) ? en->filename : vs->fmp4_init_filename,
  1311. hls->flags & HLS_SINGLE_FILE, vs->init_range_length, 0);
  1312. }
  1313. ret = ff_hls_write_file_entry(byterange_mode ? hls->m3u8_out : vs->out, en->discont, byterange_mode,
  1314. en->duration, hls->flags & HLS_ROUND_DURATIONS,
  1315. en->size, en->pos, vs->baseurl,
  1316. en->filename, prog_date_time_p, en->keyframe_size, en->keyframe_pos, hls->flags & HLS_I_FRAMES_ONLY);
  1317. if (ret < 0) {
  1318. av_log(s, AV_LOG_WARNING, "ff_hls_write_file_entry get error\n");
  1319. }
  1320. }
  1321. if (last && (hls->flags & HLS_OMIT_ENDLIST)==0)
  1322. ff_hls_write_end_list(byterange_mode ? hls->m3u8_out : vs->out);
  1323. if (vs->vtt_m3u8_name) {
  1324. snprintf(temp_vtt_filename, sizeof(temp_vtt_filename), use_temp_file ? "%s.tmp" : "%s", vs->vtt_m3u8_name);
  1325. if ((ret = hlsenc_io_open(s, &hls->sub_m3u8_out, temp_vtt_filename, &options)) < 0) {
  1326. if (hls->ignore_io_errors)
  1327. ret = 0;
  1328. goto fail;
  1329. }
  1330. ff_hls_write_playlist_header(hls->sub_m3u8_out, hls->version, hls->allowcache,
  1331. target_duration, sequence, PLAYLIST_TYPE_NONE, 0);
  1332. for (en = vs->segments; en; en = en->next) {
  1333. ret = ff_hls_write_file_entry(hls->sub_m3u8_out, 0, byterange_mode,
  1334. en->duration, 0, en->size, en->pos,
  1335. vs->baseurl, en->sub_filename, NULL, 0, 0, 0);
  1336. if (ret < 0) {
  1337. av_log(s, AV_LOG_WARNING, "ff_hls_write_file_entry get error\n");
  1338. }
  1339. }
  1340. if (last)
  1341. ff_hls_write_end_list(hls->sub_m3u8_out);
  1342. }
  1343. fail:
  1344. av_dict_free(&options);
  1345. ret = hlsenc_io_close(s, byterange_mode ? &hls->m3u8_out : &vs->out, temp_filename);
  1346. if (ret < 0) {
  1347. return ret;
  1348. }
  1349. hlsenc_io_close(s, &hls->sub_m3u8_out, vs->vtt_m3u8_name);
  1350. if (use_temp_file) {
  1351. ff_rename(temp_filename, vs->m3u8_name, s);
  1352. if (vs->vtt_m3u8_name)
  1353. ff_rename(temp_vtt_filename, vs->vtt_m3u8_name, s);
  1354. }
  1355. if (ret >= 0 && hls->master_pl_name)
  1356. if (create_master_playlist(s, vs) < 0)
  1357. av_log(s, AV_LOG_WARNING, "Master playlist creation failed\n");
  1358. return ret;
  1359. }
  1360. static int hls_start(AVFormatContext *s, VariantStream *vs)
  1361. {
  1362. HLSContext *c = s->priv_data;
  1363. AVFormatContext *oc = vs->avf;
  1364. AVFormatContext *vtt_oc = vs->vtt_avf;
  1365. AVDictionary *options = NULL;
  1366. const char *proto = NULL;
  1367. int use_temp_file = 0;
  1368. char iv_string[KEYSIZE*2 + 1];
  1369. int err = 0;
  1370. if (c->flags & HLS_SINGLE_FILE) {
  1371. char *new_name = av_strdup(vs->basename);
  1372. if (!new_name)
  1373. return AVERROR(ENOMEM);
  1374. ff_format_set_url(oc, new_name);
  1375. if (vs->vtt_basename) {
  1376. new_name = av_strdup(vs->vtt_basename);
  1377. if (!new_name)
  1378. return AVERROR(ENOMEM);
  1379. ff_format_set_url(vtt_oc, new_name);
  1380. }
  1381. } else if (c->max_seg_size > 0) {
  1382. char *filename = NULL;
  1383. if (replace_int_data_in_filename(&filename,
  1384. #if FF_API_HLS_WRAP
  1385. vs->basename, 'd', c->wrap ? vs->sequence % c->wrap : vs->sequence) < 1) {
  1386. #else
  1387. vs->basename, 'd', vs->sequence) < 1) {
  1388. #endif
  1389. av_free(filename);
  1390. av_log(oc, AV_LOG_ERROR, "Invalid segment filename template '%s', you can try to use -strftime 1 with it\n", vs->basename);
  1391. return AVERROR(EINVAL);
  1392. }
  1393. ff_format_set_url(oc, filename);
  1394. } else {
  1395. if (c->use_localtime) {
  1396. time_t now0;
  1397. struct tm *tm, tmpbuf;
  1398. int bufsize = strlen(vs->basename) + MAX_URL_SIZE;
  1399. char *buf = av_mallocz(bufsize);
  1400. if (!buf)
  1401. return AVERROR(ENOMEM);
  1402. time(&now0);
  1403. tm = localtime_r(&now0, &tmpbuf);
  1404. ff_format_set_url(oc, buf);
  1405. if (!strftime(oc->url, bufsize, vs->basename, tm)) {
  1406. av_log(oc, AV_LOG_ERROR, "Could not get segment filename with strftime\n");
  1407. return AVERROR(EINVAL);
  1408. }
  1409. err = sls_flag_use_localtime_filename(oc, c, vs);
  1410. if (err < 0) {
  1411. return AVERROR(ENOMEM);
  1412. }
  1413. if (c->use_localtime_mkdir) {
  1414. const char *dir;
  1415. char *fn_copy = av_strdup(oc->url);
  1416. dir = av_dirname(fn_copy);
  1417. if (ff_mkdir_p(dir) == -1 && errno != EEXIST) {
  1418. av_log(oc, AV_LOG_ERROR, "Could not create directory %s with use_localtime_mkdir\n", dir);
  1419. av_freep(&fn_copy);
  1420. return AVERROR(errno);
  1421. }
  1422. av_freep(&fn_copy);
  1423. }
  1424. } else {
  1425. char *filename = NULL;
  1426. if (replace_int_data_in_filename(&filename,
  1427. #if FF_API_HLS_WRAP
  1428. vs->basename, 'd', c->wrap ? vs->sequence % c->wrap : vs->sequence) < 1) {
  1429. #else
  1430. vs->basename, 'd', vs->sequence) < 1) {
  1431. #endif
  1432. av_free(filename);
  1433. av_log(oc, AV_LOG_ERROR, "Invalid segment filename template '%s' you can try to use -strftime 1 with it\n", vs->basename);
  1434. return AVERROR(EINVAL);
  1435. }
  1436. ff_format_set_url(oc, filename);
  1437. }
  1438. if ( vs->vtt_basename) {
  1439. char *filename = NULL;
  1440. if (replace_int_data_in_filename(&filename,
  1441. #if FF_API_HLS_WRAP
  1442. vs->vtt_basename, 'd', c->wrap ? vs->sequence % c->wrap : vs->sequence) < 1) {
  1443. #else
  1444. vs->vtt_basename, 'd', vs->sequence) < 1) {
  1445. #endif
  1446. av_free(filename);
  1447. av_log(vtt_oc, AV_LOG_ERROR, "Invalid segment filename template '%s'\n", vs->vtt_basename);
  1448. return AVERROR(EINVAL);
  1449. }
  1450. ff_format_set_url(vtt_oc, filename);
  1451. }
  1452. }
  1453. vs->number++;
  1454. set_http_options(s, &options, c);
  1455. proto = avio_find_protocol_name(oc->url);
  1456. use_temp_file = proto && !strcmp(proto, "file") && (c->flags & HLS_TEMP_FILE);
  1457. if (use_temp_file) {
  1458. char *new_name = av_asprintf("%s.tmp", oc->url);
  1459. if (!new_name)
  1460. return AVERROR(ENOMEM);
  1461. ff_format_set_url(oc, new_name);
  1462. }
  1463. if (c->key_info_file || c->encrypt) {
  1464. if (c->segment_type == SEGMENT_TYPE_FMP4) {
  1465. av_log(s, AV_LOG_ERROR, "Encrypted fmp4 not yet supported\n");
  1466. return AVERROR_PATCHWELCOME;
  1467. }
  1468. if (c->key_info_file && c->encrypt) {
  1469. av_log(s, AV_LOG_WARNING, "Cannot use both -hls_key_info_file and -hls_enc,"
  1470. " ignoring -hls_enc\n");
  1471. }
  1472. if (!c->encrypt_started || (c->flags & HLS_PERIODIC_REKEY)) {
  1473. if (c->key_info_file) {
  1474. if ((err = hls_encryption_start(s)) < 0)
  1475. goto fail;
  1476. } else {
  1477. if ((err = do_encrypt(s, vs)) < 0)
  1478. goto fail;
  1479. }
  1480. c->encrypt_started = 1;
  1481. }
  1482. err = av_strlcpy(iv_string, c->iv_string, sizeof(iv_string));
  1483. if (!err) {
  1484. snprintf(iv_string, sizeof(iv_string), "%032"PRIx64, vs->sequence);
  1485. memset(c->iv_string, 0, sizeof(c->iv_string));
  1486. memcpy(c->iv_string, iv_string, sizeof(iv_string));
  1487. }
  1488. }
  1489. if (c->segment_type != SEGMENT_TYPE_FMP4) {
  1490. /* We only require one PAT/PMT per segment. */
  1491. if (oc->oformat->priv_class && oc->priv_data) {
  1492. char period[21];
  1493. snprintf(period, sizeof(period), "%d", (INT_MAX / 2) - 1);
  1494. av_opt_set(oc->priv_data, "mpegts_flags", "resend_headers", 0);
  1495. av_opt_set(oc->priv_data, "sdt_period", period, 0);
  1496. av_opt_set(oc->priv_data, "pat_period", period, 0);
  1497. }
  1498. if (c->flags & HLS_SINGLE_FILE) {
  1499. if ((err = hlsenc_io_open(s, &vs->out, oc->url, &options)) < 0) {
  1500. if (c->ignore_io_errors)
  1501. err = 0;
  1502. goto fail;
  1503. }
  1504. }
  1505. }
  1506. if (vs->vtt_basename) {
  1507. set_http_options(s, &options, c);
  1508. if ((err = hlsenc_io_open(s, &vtt_oc->pb, vtt_oc->url, &options)) < 0) {
  1509. if (c->ignore_io_errors)
  1510. err = 0;
  1511. goto fail;
  1512. }
  1513. }
  1514. av_dict_free(&options);
  1515. if (vs->vtt_basename) {
  1516. err = avformat_write_header(vtt_oc,NULL);
  1517. if (err < 0)
  1518. return err;
  1519. }
  1520. return 0;
  1521. fail:
  1522. av_dict_free(&options);
  1523. return err;
  1524. }
  1525. static const char * get_default_pattern_localtime_fmt(AVFormatContext *s)
  1526. {
  1527. char b[21];
  1528. time_t t = time(NULL);
  1529. struct tm *p, tmbuf;
  1530. HLSContext *hls = s->priv_data;
  1531. p = localtime_r(&t, &tmbuf);
  1532. // no %s support when strftime returned error or left format string unchanged
  1533. // also no %s support on MSVC, which invokes the invalid parameter handler on unsupported format strings, instead of returning an error
  1534. if (hls->segment_type == SEGMENT_TYPE_FMP4) {
  1535. return (HAVE_LIBC_MSVCRT || !strftime(b, sizeof(b), "%s", p) || !strcmp(b, "%s")) ? "-%Y%m%d%H%M%S.m4s" : "-%s.m4s";
  1536. }
  1537. return (HAVE_LIBC_MSVCRT || !strftime(b, sizeof(b), "%s", p) || !strcmp(b, "%s")) ? "-%Y%m%d%H%M%S.ts" : "-%s.ts";
  1538. }
  1539. static int append_postfix(char *name, int name_buf_len, int i)
  1540. {
  1541. char *p;
  1542. char extension[10] = {'\0'};
  1543. p = strrchr(name, '.');
  1544. if (p) {
  1545. av_strlcpy(extension, p, sizeof(extension));
  1546. *p = '\0';
  1547. }
  1548. snprintf(name + strlen(name), name_buf_len - strlen(name), POSTFIX_PATTERN, i);
  1549. if (strlen(extension))
  1550. av_strlcat(name, extension, name_buf_len);
  1551. return 0;
  1552. }
  1553. static int validate_name(int nb_vs, const char *fn)
  1554. {
  1555. const char *filename, *subdir_name;
  1556. char *fn_dup = NULL;
  1557. int ret = 0;
  1558. if (!fn) {
  1559. ret = AVERROR(EINVAL);
  1560. goto fail;
  1561. }
  1562. fn_dup = av_strdup(fn);
  1563. filename = av_basename(fn);
  1564. subdir_name = av_dirname(fn_dup);
  1565. if (nb_vs > 1 && !av_stristr(filename, "%v") && !av_stristr(subdir_name, "%v")) {
  1566. av_log(NULL, AV_LOG_ERROR, "More than 1 variant streams are present, %%v is expected "
  1567. "either in the filename or in the sub-directory name of file %s\n", fn);
  1568. ret = AVERROR(EINVAL);
  1569. goto fail;
  1570. }
  1571. if (av_stristr(filename, "%v") && av_stristr(subdir_name, "%v")) {
  1572. av_log(NULL, AV_LOG_ERROR, "%%v is expected either in the filename or "
  1573. "in the sub-directory name of file %s, but only in one of them\n", fn);
  1574. ret = AVERROR(EINVAL);
  1575. goto fail;
  1576. }
  1577. fail:
  1578. av_freep(&fn_dup);
  1579. return ret;
  1580. }
  1581. static int format_name(const char *buf, char **s, int index, const char *varname)
  1582. {
  1583. const char *proto, *dir;
  1584. char *orig_buf_dup = NULL, *mod_buf_dup = NULL;
  1585. int ret = 0;
  1586. orig_buf_dup = av_strdup(buf);
  1587. if (!orig_buf_dup) {
  1588. ret = AVERROR(ENOMEM);
  1589. goto fail;
  1590. }
  1591. if (!av_stristr(buf, "%v")) {
  1592. *s = orig_buf_dup;
  1593. return ret;
  1594. }
  1595. if (!varname) {
  1596. if (replace_int_data_in_filename(s, orig_buf_dup, 'v', index) < 1) {
  1597. ret = AVERROR(EINVAL);
  1598. goto fail;
  1599. }
  1600. } else {
  1601. if (replace_str_data_in_filename(s, orig_buf_dup, 'v', varname) < 1) {
  1602. ret = AVERROR(EINVAL);
  1603. goto fail;
  1604. }
  1605. }
  1606. proto = avio_find_protocol_name(orig_buf_dup);
  1607. dir = av_dirname(orig_buf_dup);
  1608. /* if %v is present in the file's directory, create sub-directory */
  1609. if (av_stristr(dir, "%v") && proto && !strcmp(proto, "file")) {
  1610. mod_buf_dup = av_strdup(*s);
  1611. dir = av_dirname(mod_buf_dup);
  1612. if (ff_mkdir_p(dir) == -1 && errno != EEXIST) {
  1613. ret = AVERROR(errno);
  1614. goto fail;
  1615. }
  1616. }
  1617. fail:
  1618. av_freep(&orig_buf_dup);
  1619. av_freep(&mod_buf_dup);
  1620. return ret;
  1621. }
  1622. static int get_nth_codec_stream_index(AVFormatContext *s,
  1623. enum AVMediaType codec_type,
  1624. int stream_id)
  1625. {
  1626. unsigned int stream_index, cnt;
  1627. if (stream_id < 0 || stream_id > s->nb_streams - 1)
  1628. return -1;
  1629. cnt = 0;
  1630. for (stream_index = 0; stream_index < s->nb_streams; stream_index++) {
  1631. if (s->streams[stream_index]->codecpar->codec_type != codec_type)
  1632. continue;
  1633. if (cnt == stream_id)
  1634. return stream_index;
  1635. cnt++;
  1636. }
  1637. return -1;
  1638. }
  1639. static int parse_variant_stream_mapstring(AVFormatContext *s)
  1640. {
  1641. HLSContext *hls = s->priv_data;
  1642. VariantStream *vs;
  1643. int stream_index, i, j;
  1644. enum AVMediaType codec_type;
  1645. int nb_varstreams, nb_streams;
  1646. char *p, *q, *saveptr1, *saveptr2, *varstr, *keyval;
  1647. const char *val;
  1648. /**
  1649. * Expected format for var_stream_map string is as below:
  1650. * "a:0,v:0 a:1,v:1"
  1651. * "a:0,agroup:a0,default:1,language:ENG a:1,agroup:a1,default:0 v:0,agroup:a0 v:1,agroup:a1"
  1652. * This string specifies how to group the audio, video and subtitle streams
  1653. * into different variant streams. The variant stream groups are separated
  1654. * by space.
  1655. *
  1656. * a:, v:, s: are keys to specify audio, video and subtitle streams
  1657. * respectively. Allowed values are 0 to 9 digits (limited just based on
  1658. * practical usage)
  1659. *
  1660. * agroup: is key to specify audio group. A string can be given as value.
  1661. */
  1662. p = av_strdup(hls->var_stream_map);
  1663. q = p;
  1664. while (av_strtok(q, " \t", &saveptr1)) {
  1665. q = NULL;
  1666. hls->nb_varstreams++;
  1667. }
  1668. av_freep(&p);
  1669. hls->var_streams = av_mallocz(sizeof(*hls->var_streams) * hls->nb_varstreams);
  1670. if (!hls->var_streams)
  1671. return AVERROR(ENOMEM);
  1672. p = hls->var_stream_map;
  1673. nb_varstreams = 0;
  1674. while (varstr = av_strtok(p, " \t", &saveptr1)) {
  1675. p = NULL;
  1676. if (nb_varstreams < hls->nb_varstreams) {
  1677. vs = &(hls->var_streams[nb_varstreams]);
  1678. vs->var_stream_idx = nb_varstreams;
  1679. vs->is_default = 0;
  1680. nb_varstreams++;
  1681. } else
  1682. return AVERROR(EINVAL);
  1683. q = varstr;
  1684. while (q < varstr + strlen(varstr)) {
  1685. if (!av_strncasecmp(q, "a:", 2) || !av_strncasecmp(q, "v:", 2) ||
  1686. !av_strncasecmp(q, "s:", 2))
  1687. vs->nb_streams++;
  1688. q++;
  1689. }
  1690. vs->streams = av_mallocz(sizeof(AVStream *) * vs->nb_streams);
  1691. if (!vs->streams)
  1692. return AVERROR(ENOMEM);
  1693. nb_streams = 0;
  1694. while (keyval = av_strtok(varstr, ",", &saveptr2)) {
  1695. varstr = NULL;
  1696. if (av_strstart(keyval, "language:", &val)) {
  1697. vs->language = av_strdup(val);
  1698. if (!vs->language)
  1699. return AVERROR(ENOMEM);
  1700. continue;
  1701. } else if (av_strstart(keyval, "default:", &val)) {
  1702. vs->is_default = (!av_strncasecmp(val, "YES", strlen("YES")) ||
  1703. (!av_strncasecmp(val, "1", strlen("1"))));
  1704. hls->has_default_key = 1;
  1705. continue;
  1706. } else if (av_strstart(keyval, "name:", &val)) {
  1707. vs->varname = av_strdup(val);
  1708. if (!vs->varname)
  1709. return AVERROR(ENOMEM);
  1710. continue;
  1711. } else if (av_strstart(keyval, "agroup:", &val)) {
  1712. vs->agroup = av_strdup(val);
  1713. if (!vs->agroup)
  1714. return AVERROR(ENOMEM);
  1715. continue;
  1716. } else if (av_strstart(keyval, "ccgroup:", &val)) {
  1717. vs->ccgroup = av_strdup(val);
  1718. if (!vs->ccgroup)
  1719. return AVERROR(ENOMEM);
  1720. continue;
  1721. } else if (av_strstart(keyval, "v:", &val)) {
  1722. codec_type = AVMEDIA_TYPE_VIDEO;
  1723. hls->has_video_m3u8 = 1;
  1724. } else if (av_strstart(keyval, "a:", &val)) {
  1725. codec_type = AVMEDIA_TYPE_AUDIO;
  1726. } else if (av_strstart(keyval, "s:", &val)) {
  1727. codec_type = AVMEDIA_TYPE_SUBTITLE;
  1728. } else {
  1729. av_log(s, AV_LOG_ERROR, "Invalid keyval %s\n", keyval);
  1730. return AVERROR(EINVAL);
  1731. }
  1732. stream_index = -1;
  1733. if (av_isdigit(*val))
  1734. stream_index = get_nth_codec_stream_index (s, codec_type,
  1735. atoi(val));
  1736. if (stream_index >= 0 && nb_streams < vs->nb_streams) {
  1737. for (i = 0; nb_streams > 0 && i < nb_streams; i++) {
  1738. if (vs->streams[i] == s->streams[stream_index]) {
  1739. av_log(s, AV_LOG_ERROR, "Same elementary stream found more than once inside "
  1740. "variant definition #%d\n", nb_varstreams - 1);
  1741. return AVERROR(EINVAL);
  1742. }
  1743. }
  1744. for (j = 0; nb_varstreams > 1 && j < nb_varstreams - 1; j++) {
  1745. for (i = 0; i < hls->var_streams[j].nb_streams; i++) {
  1746. if (hls->var_streams[j].streams[i] == s->streams[stream_index]) {
  1747. av_log(s, AV_LOG_ERROR, "Same elementary stream found more than once "
  1748. "in two different variant definitions #%d and #%d\n",
  1749. j, nb_varstreams - 1);
  1750. return AVERROR(EINVAL);
  1751. }
  1752. }
  1753. }
  1754. vs->streams[nb_streams++] = s->streams[stream_index];
  1755. } else {
  1756. av_log(s, AV_LOG_ERROR, "Unable to map stream at %s\n", keyval);
  1757. return AVERROR(EINVAL);
  1758. }
  1759. }
  1760. }
  1761. av_log(s, AV_LOG_DEBUG, "Number of variant streams %d\n",
  1762. hls->nb_varstreams);
  1763. return 0;
  1764. }
  1765. static int parse_cc_stream_mapstring(AVFormatContext *s)
  1766. {
  1767. HLSContext *hls = s->priv_data;
  1768. int nb_ccstreams;
  1769. char *p, *q, *ccstr, *keyval;
  1770. char *saveptr1 = NULL, *saveptr2 = NULL;
  1771. const char *val;
  1772. ClosedCaptionsStream *ccs;
  1773. p = av_strdup(hls->cc_stream_map);
  1774. q = p;
  1775. while (av_strtok(q, " \t", &saveptr1)) {
  1776. q = NULL;
  1777. hls->nb_ccstreams++;
  1778. }
  1779. av_freep(&p);
  1780. hls->cc_streams = av_mallocz(sizeof(*hls->cc_streams) * hls->nb_ccstreams);
  1781. if (!hls->cc_streams)
  1782. return AVERROR(ENOMEM);
  1783. p = hls->cc_stream_map;
  1784. nb_ccstreams = 0;
  1785. while (ccstr = av_strtok(p, " \t", &saveptr1)) {
  1786. p = NULL;
  1787. if (nb_ccstreams < hls->nb_ccstreams)
  1788. ccs = &(hls->cc_streams[nb_ccstreams++]);
  1789. else
  1790. return AVERROR(EINVAL);
  1791. while (keyval = av_strtok(ccstr, ",", &saveptr2)) {
  1792. ccstr = NULL;
  1793. if (av_strstart(keyval, "ccgroup:", &val)) {
  1794. ccs->ccgroup = av_strdup(val);
  1795. if (!ccs->ccgroup)
  1796. return AVERROR(ENOMEM);
  1797. } else if (av_strstart(keyval, "instreamid:", &val)) {
  1798. ccs->instreamid = av_strdup(val);
  1799. if (!ccs->instreamid)
  1800. return AVERROR(ENOMEM);
  1801. } else if (av_strstart(keyval, "language:", &val)) {
  1802. ccs->language = av_strdup(val);
  1803. if (!ccs->language)
  1804. return AVERROR(ENOMEM);
  1805. } else {
  1806. av_log(s, AV_LOG_ERROR, "Invalid keyval %s\n", keyval);
  1807. return AVERROR(EINVAL);
  1808. }
  1809. }
  1810. if (!ccs->ccgroup || !ccs->instreamid) {
  1811. av_log(s, AV_LOG_ERROR, "Insufficient parameters in cc stream map string\n");
  1812. return AVERROR(EINVAL);
  1813. }
  1814. if (av_strstart(ccs->instreamid, "CC", &val)) {
  1815. if (atoi(val) < 1 || atoi(val) > 4) {
  1816. av_log(s, AV_LOG_ERROR, "Invalid instream ID CC index %d in %s, range 1-4\n",
  1817. atoi(val), ccs->instreamid);
  1818. return AVERROR(EINVAL);
  1819. }
  1820. } else if (av_strstart(ccs->instreamid, "SERVICE", &val)) {
  1821. if (atoi(val) < 1 || atoi(val) > 63) {
  1822. av_log(s, AV_LOG_ERROR, "Invalid instream ID SERVICE index %d in %s, range 1-63 \n",
  1823. atoi(val), ccs->instreamid);
  1824. return AVERROR(EINVAL);
  1825. }
  1826. } else {
  1827. av_log(s, AV_LOG_ERROR, "Invalid instream ID %s, supported are CCn or SERIVICEn\n",
  1828. ccs->instreamid);
  1829. return AVERROR(EINVAL);
  1830. }
  1831. }
  1832. return 0;
  1833. }
  1834. static int update_variant_stream_info(AVFormatContext *s)
  1835. {
  1836. HLSContext *hls = s->priv_data;
  1837. unsigned int i;
  1838. int ret = 0;
  1839. if (hls->cc_stream_map) {
  1840. ret = parse_cc_stream_mapstring(s);
  1841. if (ret < 0)
  1842. return ret;
  1843. }
  1844. if (hls->var_stream_map) {
  1845. return parse_variant_stream_mapstring(s);
  1846. } else {
  1847. //By default, a single variant stream with all the codec streams is created
  1848. hls->nb_varstreams = 1;
  1849. hls->var_streams = av_mallocz(sizeof(*hls->var_streams) *
  1850. hls->nb_varstreams);
  1851. if (!hls->var_streams)
  1852. return AVERROR(ENOMEM);
  1853. hls->var_streams[0].var_stream_idx = 0;
  1854. hls->var_streams[0].nb_streams = s->nb_streams;
  1855. hls->var_streams[0].streams = av_mallocz(sizeof(AVStream *) *
  1856. hls->var_streams[0].nb_streams);
  1857. if (!hls->var_streams[0].streams) {
  1858. av_free(hls->var_streams);
  1859. return AVERROR(ENOMEM);
  1860. }
  1861. //by default, the first available ccgroup is mapped to the variant stream
  1862. if (hls->nb_ccstreams) {
  1863. hls->var_streams[0].ccgroup = av_strdup(hls->cc_streams[0].ccgroup);
  1864. if (!hls->var_streams[0].ccgroup) {
  1865. av_free(hls->var_streams);
  1866. return AVERROR(ENOMEM);
  1867. }
  1868. }
  1869. for (i = 0; i < s->nb_streams; i++)
  1870. hls->var_streams[0].streams[i] = s->streams[i];
  1871. }
  1872. return 0;
  1873. }
  1874. static int update_master_pl_info(AVFormatContext *s)
  1875. {
  1876. HLSContext *hls = s->priv_data;
  1877. const char *dir;
  1878. char *fn1= NULL, *fn2 = NULL;
  1879. int ret = 0;
  1880. fn1 = av_strdup(s->url);
  1881. dir = av_dirname(fn1);
  1882. /**
  1883. * if output file's directory has %v, variants are created in sub-directories
  1884. * then master is created at the sub-directories level
  1885. */
  1886. if (dir && av_stristr(av_basename(dir), "%v")) {
  1887. fn2 = av_strdup(dir);
  1888. dir = av_dirname(fn2);
  1889. }
  1890. if (dir && strcmp(dir, "."))
  1891. hls->master_m3u8_url = av_append_path_component(dir, hls->master_pl_name);
  1892. else
  1893. hls->master_m3u8_url = av_strdup(hls->master_pl_name);
  1894. if (!hls->master_m3u8_url) {
  1895. ret = AVERROR(ENOMEM);
  1896. goto fail;
  1897. }
  1898. fail:
  1899. av_freep(&fn1);
  1900. av_freep(&fn2);
  1901. return ret;
  1902. }
  1903. static int hls_write_header(AVFormatContext *s)
  1904. {
  1905. HLSContext *hls = s->priv_data;
  1906. int ret, i, j;
  1907. VariantStream *vs = NULL;
  1908. for (i = 0; i < hls->nb_varstreams; i++) {
  1909. vs = &hls->var_streams[i];
  1910. ret = avformat_write_header(vs->avf, NULL);
  1911. if (ret < 0)
  1912. return ret;
  1913. //av_assert0(s->nb_streams == hls->avf->nb_streams);
  1914. for (j = 0; j < vs->nb_streams; j++) {
  1915. AVStream *inner_st;
  1916. AVStream *outer_st = vs->streams[j];
  1917. if (hls->max_seg_size > 0) {
  1918. if ((outer_st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) &&
  1919. (outer_st->codecpar->bit_rate > hls->max_seg_size)) {
  1920. av_log(s, AV_LOG_WARNING, "Your video bitrate is bigger than hls_segment_size, "
  1921. "(%"PRId64 " > %"PRId64 "), the result maybe not be what you want.",
  1922. outer_st->codecpar->bit_rate, hls->max_seg_size);
  1923. }
  1924. }
  1925. if (outer_st->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE)
  1926. inner_st = vs->avf->streams[j];
  1927. else if (vs->vtt_avf)
  1928. inner_st = vs->vtt_avf->streams[0];
  1929. else {
  1930. /* We have a subtitle stream, when the user does not want one */
  1931. inner_st = NULL;
  1932. continue;
  1933. }
  1934. avpriv_set_pts_info(outer_st, inner_st->pts_wrap_bits, inner_st->time_base.num, inner_st->time_base.den);
  1935. write_codec_attr(outer_st, vs);
  1936. }
  1937. /* Update the Codec Attr string for the mapped audio groups */
  1938. if (vs->has_video && vs->agroup) {
  1939. for (j = 0; j < hls->nb_varstreams; j++) {
  1940. VariantStream *vs_agroup = &(hls->var_streams[j]);
  1941. if (!vs_agroup->has_video && !vs_agroup->has_subtitle &&
  1942. vs_agroup->agroup &&
  1943. !av_strcasecmp(vs_agroup->agroup, vs->agroup)) {
  1944. write_codec_attr(vs_agroup->streams[0], vs);
  1945. }
  1946. }
  1947. }
  1948. }
  1949. return ret;
  1950. }
  1951. static int hls_write_packet(AVFormatContext *s, AVPacket *pkt)
  1952. {
  1953. HLSContext *hls = s->priv_data;
  1954. AVFormatContext *oc = NULL;
  1955. AVStream *st = s->streams[pkt->stream_index];
  1956. int64_t end_pts = 0;
  1957. int is_ref_pkt = 1;
  1958. int ret = 0, can_split = 1, i, j;
  1959. int stream_index = 0;
  1960. int range_length = 0;
  1961. const char *proto = NULL;
  1962. int use_temp_file = 0;
  1963. uint8_t *buffer = NULL;
  1964. VariantStream *vs = NULL;
  1965. AVDictionary *options = NULL;
  1966. char *old_filename = NULL;
  1967. for (i = 0; i < hls->nb_varstreams; i++) {
  1968. vs = &hls->var_streams[i];
  1969. for (j = 0; j < vs->nb_streams; j++) {
  1970. if (vs->streams[j] == st) {
  1971. if ( st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE ) {
  1972. oc = vs->vtt_avf;
  1973. stream_index = 0;
  1974. } else {
  1975. oc = vs->avf;
  1976. stream_index = j;
  1977. }
  1978. break;
  1979. }
  1980. }
  1981. if (oc)
  1982. break;
  1983. }
  1984. if (!oc) {
  1985. av_log(s, AV_LOG_ERROR, "Unable to find mapping variant stream\n");
  1986. return AVERROR(ENOMEM);
  1987. }
  1988. end_pts = hls->recording_time * vs->number;
  1989. if (vs->sequence - vs->nb_entries > hls->start_sequence && hls->init_time > 0) {
  1990. /* reset end_pts, hls->recording_time at end of the init hls list */
  1991. int64_t init_list_dur = hls->init_time * vs->nb_entries * AV_TIME_BASE;
  1992. int64_t after_init_list_dur = (vs->sequence - hls->start_sequence - vs->nb_entries ) * (hls->time * AV_TIME_BASE);
  1993. hls->recording_time = hls->time * AV_TIME_BASE;
  1994. end_pts = init_list_dur + after_init_list_dur ;
  1995. }
  1996. if (vs->start_pts == AV_NOPTS_VALUE) {
  1997. vs->start_pts = pkt->pts;
  1998. }
  1999. if (vs->has_video) {
  2000. can_split = st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
  2001. ((pkt->flags & AV_PKT_FLAG_KEY) || (hls->flags & HLS_SPLIT_BY_TIME));
  2002. is_ref_pkt = (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) && (pkt->stream_index == vs->reference_stream_index);
  2003. }
  2004. if (pkt->pts == AV_NOPTS_VALUE)
  2005. is_ref_pkt = can_split = 0;
  2006. if (is_ref_pkt) {
  2007. if (vs->end_pts == AV_NOPTS_VALUE)
  2008. vs->end_pts = pkt->pts;
  2009. if (vs->new_start) {
  2010. vs->new_start = 0;
  2011. vs->duration = (double)(pkt->pts - vs->end_pts)
  2012. * st->time_base.num / st->time_base.den;
  2013. vs->dpp = (double)(pkt->duration) * st->time_base.num / st->time_base.den;
  2014. } else {
  2015. if (pkt->duration) {
  2016. vs->duration += (double)(pkt->duration) * st->time_base.num / st->time_base.den;
  2017. } else {
  2018. av_log(s, AV_LOG_WARNING, "pkt->duration = 0, maybe the hls segment duration will not precise\n");
  2019. vs->duration = (double)(pkt->pts - vs->end_pts) * st->time_base.num / st->time_base.den;
  2020. }
  2021. }
  2022. }
  2023. if (vs->packets_written && can_split && av_compare_ts(pkt->pts - vs->start_pts, st->time_base,
  2024. end_pts, AV_TIME_BASE_Q) >= 0) {
  2025. int64_t new_start_pos;
  2026. int byterange_mode = (hls->flags & HLS_SINGLE_FILE) || (hls->max_seg_size > 0);
  2027. av_write_frame(oc, NULL); /* Flush any buffered data */
  2028. new_start_pos = avio_tell(oc->pb);
  2029. vs->size = new_start_pos - vs->start_pos;
  2030. avio_flush(oc->pb);
  2031. if (hls->segment_type == SEGMENT_TYPE_FMP4) {
  2032. if (!vs->init_range_length) {
  2033. range_length = avio_close_dyn_buf(oc->pb, &buffer);
  2034. avio_write(vs->out, buffer, range_length);
  2035. av_free(buffer);
  2036. vs->init_range_length = range_length;
  2037. avio_open_dyn_buf(&oc->pb);
  2038. vs->packets_written = 0;
  2039. vs->start_pos = range_length;
  2040. if (!byterange_mode) {
  2041. hlsenc_io_close(s, &vs->out, vs->base_output_dirname);
  2042. }
  2043. }
  2044. }
  2045. if (!byterange_mode) {
  2046. if (vs->vtt_avf) {
  2047. hlsenc_io_close(s, &vs->vtt_avf->pb, vs->vtt_avf->url);
  2048. }
  2049. }
  2050. if (oc->url[0]) {
  2051. proto = avio_find_protocol_name(oc->url);
  2052. use_temp_file = proto && !strcmp(proto, "file") && (hls->flags & HLS_TEMP_FILE);
  2053. }
  2054. // look to rename the asset name
  2055. if (use_temp_file) {
  2056. av_dict_set(&options, "mpegts_flags", "resend_headers", 0);
  2057. }
  2058. if (hls->flags & HLS_SINGLE_FILE) {
  2059. ret = flush_dynbuf(vs, &range_length);
  2060. av_freep(&vs->temp_buffer);
  2061. if (ret < 0) {
  2062. return ret;
  2063. }
  2064. vs->size = range_length;
  2065. } else {
  2066. set_http_options(s, &options, hls);
  2067. if ((hls->max_seg_size > 0 && (vs->size >= hls->max_seg_size)) || !byterange_mode) {
  2068. char *filename = NULL;
  2069. if (hls->key_info_file || hls->encrypt) {
  2070. av_dict_set(&options, "encryption_key", hls->key_string, 0);
  2071. av_dict_set(&options, "encryption_iv", hls->iv_string, 0);
  2072. filename = av_asprintf("crypto:%s", oc->url);
  2073. } else {
  2074. filename = av_asprintf("%s", oc->url);
  2075. }
  2076. if (!filename) {
  2077. return AVERROR(ENOMEM);
  2078. }
  2079. ret = hlsenc_io_open(s, &vs->out, filename, &options);
  2080. if (ret < 0) {
  2081. av_log(s, hls->ignore_io_errors ? AV_LOG_WARNING : AV_LOG_ERROR,
  2082. "Failed to open file '%s'\n", filename);
  2083. return hls->ignore_io_errors ? 0 : ret;
  2084. }
  2085. if (hls->segment_type == SEGMENT_TYPE_FMP4) {
  2086. write_styp(vs->out);
  2087. }
  2088. ret = flush_dynbuf(vs, &range_length);
  2089. if (ret < 0) {
  2090. return ret;
  2091. }
  2092. ret = hlsenc_io_close(s, &vs->out, filename);
  2093. if (ret < 0) {
  2094. av_log(s, AV_LOG_WARNING, "upload segment failed,"
  2095. " will retry with a new http session.\n");
  2096. ff_format_io_close(s, &vs->out);
  2097. ret = hlsenc_io_open(s, &vs->out, filename, &options);
  2098. reflush_dynbuf(vs, &range_length);
  2099. ret = hlsenc_io_close(s, &vs->out, filename);
  2100. }
  2101. av_free(vs->temp_buffer);
  2102. av_free(filename);
  2103. }
  2104. }
  2105. if (use_temp_file && !(hls->flags & HLS_SINGLE_FILE)) {
  2106. hls_rename_temp_file(s, oc);
  2107. }
  2108. old_filename = av_strdup(oc->url);
  2109. if (!old_filename) {
  2110. return AVERROR(ENOMEM);
  2111. }
  2112. if (vs->start_pos || hls->segment_type != SEGMENT_TYPE_FMP4) {
  2113. ret = hls_append_segment(s, hls, vs, vs->duration, vs->start_pos, vs->size);
  2114. vs->end_pts = pkt->pts;
  2115. vs->duration = 0;
  2116. if (ret < 0) {
  2117. av_free(old_filename);
  2118. return ret;
  2119. }
  2120. }
  2121. // if we're building a VOD playlist, skip writing the manifest multiple times, and just wait until the end
  2122. if (hls->pl_type != PLAYLIST_TYPE_VOD) {
  2123. if ((ret = hls_window(s, 0, vs)) < 0) {
  2124. av_log(s, AV_LOG_WARNING, "upload playlist failed, will retry with a new http session.\n");
  2125. ff_format_io_close(s, &vs->out);
  2126. vs->out = NULL;
  2127. if ((ret = hls_window(s, 0, vs)) < 0) {
  2128. av_free(old_filename);
  2129. return ret;
  2130. }
  2131. }
  2132. }
  2133. if (hls->flags & HLS_SINGLE_FILE) {
  2134. vs->number++;
  2135. vs->start_pos += vs->size;
  2136. } else if (hls->max_seg_size > 0) {
  2137. vs->start_pos = new_start_pos;
  2138. if (vs->size >= hls->max_seg_size) {
  2139. vs->sequence++;
  2140. sls_flag_file_rename(hls, vs, old_filename);
  2141. ret = hls_start(s, vs);
  2142. vs->start_pos = 0;
  2143. /* When split segment by byte, the duration is short than hls_time,
  2144. * so it is not enough one segment duration as hls_time, */
  2145. vs->number--;
  2146. }
  2147. vs->number++;
  2148. } else {
  2149. vs->start_pos = new_start_pos;
  2150. sls_flag_file_rename(hls, vs, old_filename);
  2151. ret = hls_start(s, vs);
  2152. }
  2153. av_free(old_filename);
  2154. if (ret < 0) {
  2155. return ret;
  2156. }
  2157. }
  2158. vs->packets_written++;
  2159. if (oc->pb) {
  2160. ret = ff_write_chained(oc, stream_index, pkt, s, 0);
  2161. vs->video_keyframe_size += pkt->size;
  2162. if ((st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) && (pkt->flags & AV_PKT_FLAG_KEY)) {
  2163. vs->video_keyframe_size = avio_tell(oc->pb);
  2164. } else {
  2165. vs->video_keyframe_pos = avio_tell(vs->out);
  2166. }
  2167. if (hls->ignore_io_errors)
  2168. ret = 0;
  2169. }
  2170. return ret;
  2171. }
  2172. static void hls_free_variant_streams(struct HLSContext *hls)
  2173. {
  2174. int i = 0;
  2175. AVFormatContext *vtt_oc = NULL;
  2176. VariantStream *vs = NULL;
  2177. for (i = 0; i < hls->nb_varstreams; i++) {
  2178. vs = &hls->var_streams[i];
  2179. vtt_oc = vs->vtt_avf;
  2180. av_freep(&vs->basename);
  2181. av_freep(&vs->base_output_dirname);
  2182. av_freep(&vs->fmp4_init_filename);
  2183. if (vtt_oc) {
  2184. av_freep(&vs->vtt_basename);
  2185. av_freep(&vs->vtt_m3u8_name);
  2186. }
  2187. hls_free_segments(vs->segments);
  2188. hls_free_segments(vs->old_segments);
  2189. av_freep(&vs->m3u8_name);
  2190. av_freep(&vs->streams);
  2191. av_freep(&vs->agroup);
  2192. av_freep(&vs->language);
  2193. av_freep(&vs->ccgroup);
  2194. av_freep(&vs->baseurl);
  2195. av_freep(&vs->varname);
  2196. }
  2197. }
  2198. static int hls_write_trailer(struct AVFormatContext *s)
  2199. {
  2200. HLSContext *hls = s->priv_data;
  2201. AVFormatContext *oc = NULL;
  2202. AVFormatContext *vtt_oc = NULL;
  2203. char *old_filename = NULL;
  2204. const char *proto = NULL;
  2205. int use_temp_file = 0;
  2206. int i;
  2207. int ret = 0;
  2208. VariantStream *vs = NULL;
  2209. AVDictionary *options = NULL;
  2210. int range_length, byterange_mode;
  2211. for (i = 0; i < hls->nb_varstreams; i++) {
  2212. char *filename = NULL;
  2213. vs = &hls->var_streams[i];
  2214. oc = vs->avf;
  2215. vtt_oc = vs->vtt_avf;
  2216. old_filename = av_strdup(oc->url);
  2217. use_temp_file = 0;
  2218. if (!old_filename) {
  2219. return AVERROR(ENOMEM);
  2220. }
  2221. if (hls->key_info_file || hls->encrypt) {
  2222. av_dict_set(&options, "encryption_key", hls->key_string, 0);
  2223. av_dict_set(&options, "encryption_iv", hls->iv_string, 0);
  2224. filename = av_asprintf("crypto:%s", oc->url);
  2225. } else {
  2226. filename = av_asprintf("%s", oc->url);
  2227. }
  2228. if (!filename) {
  2229. av_free(old_filename);
  2230. return AVERROR(ENOMEM);
  2231. }
  2232. if ( hls->segment_type == SEGMENT_TYPE_FMP4) {
  2233. int range_length = 0;
  2234. if (!vs->init_range_length) {
  2235. uint8_t *buffer = NULL;
  2236. av_write_frame(oc, NULL); /* Flush any buffered data */
  2237. avio_flush(oc->pb);
  2238. range_length = avio_close_dyn_buf(oc->pb, &buffer);
  2239. avio_write(vs->out, buffer, range_length);
  2240. av_free(buffer);
  2241. vs->init_range_length = range_length;
  2242. avio_open_dyn_buf(&oc->pb);
  2243. vs->packets_written = 0;
  2244. vs->start_pos = range_length;
  2245. byterange_mode = (hls->flags & HLS_SINGLE_FILE) || (hls->max_seg_size > 0);
  2246. if (!byterange_mode) {
  2247. ff_format_io_close(s, &vs->out);
  2248. hlsenc_io_close(s, &vs->out, vs->base_output_dirname);
  2249. }
  2250. }
  2251. }
  2252. if (!(hls->flags & HLS_SINGLE_FILE)) {
  2253. set_http_options(s, &options, hls);
  2254. ret = hlsenc_io_open(s, &vs->out, filename, &options);
  2255. if (ret < 0) {
  2256. av_log(s, AV_LOG_ERROR, "Failed to open file '%s'\n", oc->url);
  2257. goto failed;
  2258. }
  2259. if (hls->segment_type == SEGMENT_TYPE_FMP4)
  2260. write_styp(vs->out);
  2261. }
  2262. ret = flush_dynbuf(vs, &range_length);
  2263. if (ret < 0)
  2264. goto failed;
  2265. vs->size = range_length;
  2266. hlsenc_io_close(s, &vs->out, filename);
  2267. ret = hlsenc_io_close(s, &vs->out, filename);
  2268. if (ret < 0) {
  2269. av_log(s, AV_LOG_WARNING, "upload segment failed, will retry with a new http session.\n");
  2270. ff_format_io_close(s, &vs->out);
  2271. ret = hlsenc_io_open(s, &vs->out, filename, &options);
  2272. if (ret < 0) {
  2273. av_log(s, AV_LOG_ERROR, "Failed to open file '%s'\n", oc->url);
  2274. goto failed;
  2275. }
  2276. reflush_dynbuf(vs, &range_length);
  2277. ret = hlsenc_io_close(s, &vs->out, filename);
  2278. if (ret < 0)
  2279. av_log(s, AV_LOG_WARNING, "Failed to upload file '%s' at the end.\n", oc->url);
  2280. }
  2281. av_free(vs->temp_buffer);
  2282. failed:
  2283. av_free(filename);
  2284. av_write_trailer(oc);
  2285. if (oc->url[0]) {
  2286. proto = avio_find_protocol_name(oc->url);
  2287. use_temp_file = proto && !strcmp(proto, "file") && (hls->flags & HLS_TEMP_FILE);
  2288. }
  2289. // rename that segment from .tmp to the real one
  2290. if (use_temp_file && !(hls->flags & HLS_SINGLE_FILE)) {
  2291. hls_rename_temp_file(s, oc);
  2292. av_free(old_filename);
  2293. old_filename = av_strdup(oc->url);
  2294. if (!old_filename) {
  2295. return AVERROR(ENOMEM);
  2296. }
  2297. }
  2298. /* after av_write_trailer, then duration + 1 duration per packet */
  2299. hls_append_segment(s, hls, vs, vs->duration + vs->dpp, vs->start_pos, vs->size);
  2300. sls_flag_file_rename(hls, vs, old_filename);
  2301. if (vtt_oc) {
  2302. if (vtt_oc->pb)
  2303. av_write_trailer(vtt_oc);
  2304. vs->size = avio_tell(vs->vtt_avf->pb) - vs->start_pos;
  2305. ff_format_io_close(s, &vtt_oc->pb);
  2306. avformat_free_context(vtt_oc);
  2307. }
  2308. ret = hls_window(s, 1, vs);
  2309. if (ret < 0) {
  2310. av_log(s, AV_LOG_WARNING, "upload playlist failed, will retry with a new http session.\n");
  2311. ff_format_io_close(s, &vs->out);
  2312. hls_window(s, 1, vs);
  2313. }
  2314. ffio_free_dyn_buf(&oc->pb);
  2315. avformat_free_context(oc);
  2316. vs->avf = NULL;
  2317. av_free(old_filename);
  2318. }
  2319. hls_free_variant_streams(hls);
  2320. for (i = 0; i < hls->nb_ccstreams; i++) {
  2321. ClosedCaptionsStream *ccs = &hls->cc_streams[i];
  2322. av_freep(&ccs->ccgroup);
  2323. av_freep(&ccs->instreamid);
  2324. av_freep(&ccs->language);
  2325. }
  2326. ff_format_io_close(s, &hls->m3u8_out);
  2327. ff_format_io_close(s, &hls->sub_m3u8_out);
  2328. av_freep(&hls->key_basename);
  2329. av_freep(&hls->var_streams);
  2330. av_freep(&hls->cc_streams);
  2331. av_freep(&hls->master_m3u8_url);
  2332. return 0;
  2333. }
  2334. static int hls_init(AVFormatContext *s)
  2335. {
  2336. int ret = 0;
  2337. int i = 0;
  2338. int j = 0;
  2339. HLSContext *hls = s->priv_data;
  2340. const char *pattern = "%d.ts";
  2341. VariantStream *vs = NULL;
  2342. int basename_size = 0;
  2343. const char *pattern_localtime_fmt = get_default_pattern_localtime_fmt(s);
  2344. const char *vtt_pattern = "%d.vtt";
  2345. char *p = NULL;
  2346. int vtt_basename_size = 0;
  2347. int http_base_proto = ff_is_http_proto(s->url);
  2348. int fmp4_init_filename_len = strlen(hls->fmp4_init_filename) + 1;
  2349. hls->has_default_key = 0;
  2350. hls->has_video_m3u8 = 0;
  2351. ret = update_variant_stream_info(s);
  2352. if (ret < 0) {
  2353. av_log(s, AV_LOG_ERROR, "Variant stream info update failed with status %x\n",
  2354. ret);
  2355. goto fail;
  2356. }
  2357. //TODO: Updates needed to encryption functionality with periodic re-key when more than one variant streams are present
  2358. if (hls->nb_varstreams > 1 && hls->flags & HLS_PERIODIC_REKEY) {
  2359. ret = AVERROR(EINVAL);
  2360. av_log(s, AV_LOG_ERROR, "Periodic re-key not supported when more than one variant streams are present\n");
  2361. goto fail;
  2362. }
  2363. if (!hls->method && http_base_proto) {
  2364. av_log(hls, AV_LOG_WARNING, "No HTTP method set, hls muxer defaulting to method PUT.\n");
  2365. }
  2366. ret = validate_name(hls->nb_varstreams, s->url);
  2367. if (ret < 0)
  2368. goto fail;
  2369. if (hls->segment_filename) {
  2370. ret = validate_name(hls->nb_varstreams, hls->segment_filename);
  2371. if (ret < 0)
  2372. goto fail;
  2373. }
  2374. if (av_strcasecmp(hls->fmp4_init_filename, "init.mp4")) {
  2375. ret = validate_name(hls->nb_varstreams, hls->fmp4_init_filename);
  2376. if (ret < 0)
  2377. goto fail;
  2378. }
  2379. if (hls->subtitle_filename) {
  2380. ret = validate_name(hls->nb_varstreams, hls->subtitle_filename);
  2381. if (ret < 0)
  2382. goto fail;
  2383. }
  2384. if (hls->master_pl_name) {
  2385. ret = update_master_pl_info(s);
  2386. if (ret < 0) {
  2387. av_log(s, AV_LOG_ERROR, "Master stream info update failed with status %x\n",
  2388. ret);
  2389. goto fail;
  2390. }
  2391. }
  2392. if (hls->segment_type == SEGMENT_TYPE_FMP4) {
  2393. pattern = "%d.m4s";
  2394. }
  2395. if ((hls->start_sequence_source_type == HLS_START_SEQUENCE_AS_SECONDS_SINCE_EPOCH) ||
  2396. (hls->start_sequence_source_type == HLS_START_SEQUENCE_AS_FORMATTED_DATETIME)) {
  2397. time_t t = time(NULL); // we will need it in either case
  2398. if (hls->start_sequence_source_type == HLS_START_SEQUENCE_AS_SECONDS_SINCE_EPOCH) {
  2399. hls->start_sequence = (int64_t)t;
  2400. } else if (hls->start_sequence_source_type == HLS_START_SEQUENCE_AS_FORMATTED_DATETIME) {
  2401. char b[15];
  2402. struct tm *p, tmbuf;
  2403. if (!(p = localtime_r(&t, &tmbuf)))
  2404. return AVERROR(ENOMEM);
  2405. if (!strftime(b, sizeof(b), "%Y%m%d%H%M%S", p))
  2406. return AVERROR(ENOMEM);
  2407. hls->start_sequence = strtoll(b, NULL, 10);
  2408. }
  2409. av_log(hls, AV_LOG_DEBUG, "start_number evaluated to %"PRId64"\n", hls->start_sequence);
  2410. }
  2411. hls->recording_time = (hls->init_time ? hls->init_time : hls->time) * AV_TIME_BASE;
  2412. for (i = 0; i < hls->nb_varstreams; i++) {
  2413. vs = &hls->var_streams[i];
  2414. ret = format_name(s->url, &vs->m3u8_name, i, vs->varname);
  2415. if (ret < 0)
  2416. goto fail;
  2417. vs->sequence = hls->start_sequence;
  2418. vs->start_pts = AV_NOPTS_VALUE;
  2419. vs->end_pts = AV_NOPTS_VALUE;
  2420. vs->current_segment_final_filename_fmt[0] = '\0';
  2421. if (hls->flags & HLS_SPLIT_BY_TIME && hls->flags & HLS_INDEPENDENT_SEGMENTS) {
  2422. // Independent segments cannot be guaranteed when splitting by time
  2423. hls->flags &= ~HLS_INDEPENDENT_SEGMENTS;
  2424. av_log(s, AV_LOG_WARNING,
  2425. "'split_by_time' and 'independent_segments' cannot be enabled together. "
  2426. "Disabling 'independent_segments' flag\n");
  2427. }
  2428. if (hls->flags & HLS_PROGRAM_DATE_TIME) {
  2429. time_t now0;
  2430. time(&now0);
  2431. vs->initial_prog_date_time = now0;
  2432. }
  2433. if (hls->format_options_str) {
  2434. ret = av_dict_parse_string(&hls->format_options, hls->format_options_str, "=", ":", 0);
  2435. if (ret < 0) {
  2436. av_log(s, AV_LOG_ERROR, "Could not parse format options list '%s'\n", hls->format_options_str);
  2437. goto fail;
  2438. }
  2439. }
  2440. for (j = 0; j < vs->nb_streams; j++) {
  2441. vs->has_video += vs->streams[j]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO;
  2442. /* Get one video stream to reference for split segments
  2443. * so use the first video stream index. */
  2444. if ((vs->has_video == 1) && (vs->streams[j]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)) {
  2445. vs->reference_stream_index = vs->streams[j]->index;
  2446. }
  2447. vs->has_subtitle += vs->streams[j]->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE;
  2448. }
  2449. if (vs->has_video > 1)
  2450. av_log(s, AV_LOG_WARNING, "More than a single video stream present, expect issues decoding it.\n");
  2451. if (hls->segment_type == SEGMENT_TYPE_FMP4) {
  2452. vs->oformat = av_guess_format("mp4", NULL, NULL);
  2453. } else {
  2454. vs->oformat = av_guess_format("mpegts", NULL, NULL);
  2455. }
  2456. if (!vs->oformat) {
  2457. ret = AVERROR_MUXER_NOT_FOUND;
  2458. goto fail;
  2459. }
  2460. if (vs->has_subtitle) {
  2461. vs->vtt_oformat = av_guess_format("webvtt", NULL, NULL);
  2462. if (!vs->oformat) {
  2463. ret = AVERROR_MUXER_NOT_FOUND;
  2464. goto fail;
  2465. }
  2466. }
  2467. if (hls->segment_filename) {
  2468. ret = format_name(hls->segment_filename, &vs->basename, i, vs->varname);
  2469. if (ret < 0)
  2470. goto fail;
  2471. } else {
  2472. if (hls->flags & HLS_SINGLE_FILE) {
  2473. if (hls->segment_type == SEGMENT_TYPE_FMP4) {
  2474. pattern = ".m4s";
  2475. } else {
  2476. pattern = ".ts";
  2477. }
  2478. }
  2479. if (hls->use_localtime) {
  2480. basename_size = strlen(vs->m3u8_name) + strlen(pattern_localtime_fmt) + 1;
  2481. } else {
  2482. basename_size = strlen(vs->m3u8_name) + strlen(pattern) + 1;
  2483. }
  2484. vs->basename = av_malloc(basename_size);
  2485. if (!vs->basename) {
  2486. ret = AVERROR(ENOMEM);
  2487. goto fail;
  2488. }
  2489. av_strlcpy(vs->basename, vs->m3u8_name, basename_size);
  2490. p = strrchr(vs->basename, '.');
  2491. if (p)
  2492. *p = '\0';
  2493. if (hls->use_localtime) {
  2494. av_strlcat(vs->basename, pattern_localtime_fmt, basename_size);
  2495. } else {
  2496. av_strlcat(vs->basename, pattern, basename_size);
  2497. }
  2498. }
  2499. if (hls->segment_type == SEGMENT_TYPE_FMP4) {
  2500. if (hls->nb_varstreams > 1)
  2501. fmp4_init_filename_len += strlen(POSTFIX_PATTERN);
  2502. if (hls->flags & HLS_SINGLE_FILE) {
  2503. vs->fmp4_init_filename = av_strdup(vs->basename);
  2504. if (!vs->fmp4_init_filename) {
  2505. ret = AVERROR(ENOMEM);
  2506. goto fail;
  2507. }
  2508. } else {
  2509. vs->fmp4_init_filename = av_malloc(fmp4_init_filename_len);
  2510. if (!vs->fmp4_init_filename ) {
  2511. ret = AVERROR(ENOMEM);
  2512. goto fail;
  2513. }
  2514. av_strlcpy(vs->fmp4_init_filename, hls->fmp4_init_filename,
  2515. fmp4_init_filename_len);
  2516. if (hls->nb_varstreams > 1) {
  2517. if (av_stristr(vs->fmp4_init_filename, "%v")) {
  2518. av_freep(&vs->fmp4_init_filename);
  2519. format_name(hls->fmp4_init_filename, &vs->fmp4_init_filename, i, vs->varname);
  2520. } else {
  2521. ret = append_postfix(vs->fmp4_init_filename, fmp4_init_filename_len, i);
  2522. }
  2523. if (ret < 0)
  2524. goto fail;
  2525. }
  2526. fmp4_init_filename_len = strlen(vs->m3u8_name) +
  2527. strlen(vs->fmp4_init_filename) + 1;
  2528. vs->base_output_dirname = av_malloc(fmp4_init_filename_len);
  2529. if (!vs->base_output_dirname) {
  2530. ret = AVERROR(ENOMEM);
  2531. goto fail;
  2532. }
  2533. av_strlcpy(vs->base_output_dirname, vs->m3u8_name,
  2534. fmp4_init_filename_len);
  2535. p = strrchr(vs->base_output_dirname, '/');
  2536. if (p) {
  2537. *(p + 1) = '\0';
  2538. av_strlcat(vs->base_output_dirname, vs->fmp4_init_filename,
  2539. fmp4_init_filename_len);
  2540. } else {
  2541. av_strlcpy(vs->base_output_dirname, vs->fmp4_init_filename,
  2542. fmp4_init_filename_len);
  2543. }
  2544. }
  2545. }
  2546. ret = hls->use_localtime ? sls_flag_check_duration_size(hls, vs) : sls_flag_check_duration_size_index(hls);
  2547. if (ret < 0)
  2548. goto fail;
  2549. if (vs->has_subtitle) {
  2550. if (hls->flags & HLS_SINGLE_FILE)
  2551. vtt_pattern = ".vtt";
  2552. vtt_basename_size = strlen(vs->m3u8_name) + strlen(vtt_pattern) + 1;
  2553. vs->vtt_basename = av_malloc(vtt_basename_size);
  2554. if (!vs->vtt_basename) {
  2555. ret = AVERROR(ENOMEM);
  2556. goto fail;
  2557. }
  2558. vs->vtt_m3u8_name = av_malloc(vtt_basename_size);
  2559. if (!vs->vtt_m3u8_name ) {
  2560. ret = AVERROR(ENOMEM);
  2561. goto fail;
  2562. }
  2563. av_strlcpy(vs->vtt_basename, vs->m3u8_name, vtt_basename_size);
  2564. p = strrchr(vs->vtt_basename, '.');
  2565. if (p)
  2566. *p = '\0';
  2567. if ( hls->subtitle_filename ) {
  2568. av_freep(&vs->vtt_m3u8_name);
  2569. ret = format_name(hls->subtitle_filename, &vs->vtt_m3u8_name, i, vs->varname);
  2570. if (ret < 0)
  2571. goto fail;
  2572. } else {
  2573. strcpy(vs->vtt_m3u8_name, vs->vtt_basename);
  2574. av_strlcat(vs->vtt_m3u8_name, "_vtt.m3u8", vtt_basename_size);
  2575. }
  2576. av_strlcat(vs->vtt_basename, vtt_pattern, vtt_basename_size);
  2577. }
  2578. if (hls->baseurl) {
  2579. vs->baseurl = av_strdup(hls->baseurl);
  2580. if (!vs->baseurl) {
  2581. ret = AVERROR(ENOMEM);
  2582. goto fail;
  2583. }
  2584. }
  2585. if ((ret = hls_mux_init(s, vs)) < 0)
  2586. goto fail;
  2587. if (hls->flags & HLS_APPEND_LIST) {
  2588. parse_playlist(s, vs->m3u8_name, vs);
  2589. vs->discontinuity = 1;
  2590. if (hls->init_time > 0) {
  2591. av_log(s, AV_LOG_WARNING, "append_list mode does not support hls_init_time,"
  2592. " hls_init_time value will have no effect\n");
  2593. hls->init_time = 0;
  2594. hls->recording_time = hls->time * AV_TIME_BASE;
  2595. }
  2596. }
  2597. if ((ret = hls_start(s, vs)) < 0)
  2598. goto fail;
  2599. }
  2600. fail:
  2601. if (ret < 0) {
  2602. av_freep(&hls->key_basename);
  2603. for (i = 0; i < hls->nb_varstreams && hls->var_streams; i++) {
  2604. vs = &hls->var_streams[i];
  2605. av_freep(&vs->basename);
  2606. av_freep(&vs->vtt_basename);
  2607. av_freep(&vs->fmp4_init_filename);
  2608. av_freep(&vs->m3u8_name);
  2609. av_freep(&vs->vtt_m3u8_name);
  2610. av_freep(&vs->streams);
  2611. av_freep(&vs->language);
  2612. av_freep(&vs->agroup);
  2613. av_freep(&vs->ccgroup);
  2614. av_freep(&vs->baseurl);
  2615. av_freep(&vs->varname);
  2616. if (vs->avf)
  2617. avformat_free_context(vs->avf);
  2618. if (vs->vtt_avf)
  2619. avformat_free_context(vs->vtt_avf);
  2620. }
  2621. for (i = 0; i < hls->nb_ccstreams; i++) {
  2622. ClosedCaptionsStream *ccs = &hls->cc_streams[i];
  2623. av_freep(&ccs->ccgroup);
  2624. av_freep(&ccs->instreamid);
  2625. av_freep(&ccs->language);
  2626. }
  2627. av_freep(&hls->var_streams);
  2628. av_freep(&hls->cc_streams);
  2629. av_freep(&hls->master_m3u8_url);
  2630. }
  2631. return ret;
  2632. }
  2633. #define OFFSET(x) offsetof(HLSContext, x)
  2634. #define E AV_OPT_FLAG_ENCODING_PARAM
  2635. static const AVOption options[] = {
  2636. {"start_number", "set first number in the sequence", OFFSET(start_sequence),AV_OPT_TYPE_INT64, {.i64 = 0}, 0, INT64_MAX, E},
  2637. {"hls_time", "set segment length in seconds", OFFSET(time), AV_OPT_TYPE_FLOAT, {.dbl = 2}, 0, FLT_MAX, E},
  2638. {"hls_init_time", "set segment length in seconds at init list", OFFSET(init_time), AV_OPT_TYPE_FLOAT, {.dbl = 0}, 0, FLT_MAX, E},
  2639. {"hls_list_size", "set maximum number of playlist entries", OFFSET(max_nb_segments), AV_OPT_TYPE_INT, {.i64 = 5}, 0, INT_MAX, E},
  2640. {"hls_delete_threshold", "set number of unreferenced segments to keep before deleting", OFFSET(hls_delete_threshold), AV_OPT_TYPE_INT, {.i64 = 1}, 1, INT_MAX, E},
  2641. {"hls_ts_options","set hls mpegts list of options for the container format used for hls", OFFSET(format_options_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E},
  2642. {"hls_vtt_options","set hls vtt list of options for the container format used for hls", OFFSET(vtt_format_options_str), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E},
  2643. #if FF_API_HLS_WRAP
  2644. {"hls_wrap", "set number after which the index wraps (will be deprecated)", OFFSET(wrap), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, E},
  2645. #endif
  2646. {"hls_allow_cache", "explicitly set whether the client MAY (1) or MUST NOT (0) cache media segments", OFFSET(allowcache), AV_OPT_TYPE_INT, {.i64 = -1}, INT_MIN, INT_MAX, E},
  2647. {"hls_base_url", "url to prepend to each playlist entry", OFFSET(baseurl), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E},
  2648. {"hls_segment_filename", "filename template for segment files", OFFSET(segment_filename), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E},
  2649. {"hls_segment_size", "maximum size per segment file, (in bytes)", OFFSET(max_seg_size), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, E},
  2650. {"hls_key_info_file", "file with key URI and key file path", OFFSET(key_info_file), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E},
  2651. {"hls_enc", "enable AES128 encryption support", OFFSET(encrypt), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, E},
  2652. {"hls_enc_key", "hex-coded 16 byte key to encrypt the segments", OFFSET(key), AV_OPT_TYPE_STRING, .flags = E},
  2653. {"hls_enc_key_url", "url to access the key to decrypt the segments", OFFSET(key_url), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E},
  2654. {"hls_enc_iv", "hex-coded 16 byte initialization vector", OFFSET(iv), AV_OPT_TYPE_STRING, .flags = E},
  2655. {"hls_subtitle_path", "set path of hls subtitles", OFFSET(subtitle_filename), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E},
  2656. {"hls_segment_type", "set hls segment files type", OFFSET(segment_type), AV_OPT_TYPE_INT, {.i64 = SEGMENT_TYPE_MPEGTS }, 0, SEGMENT_TYPE_FMP4, E, "segment_type"},
  2657. {"mpegts", "make segment file to mpegts files in m3u8", 0, AV_OPT_TYPE_CONST, {.i64 = SEGMENT_TYPE_MPEGTS }, 0, UINT_MAX, E, "segment_type"},
  2658. {"fmp4", "make segment file to fragment mp4 files in m3u8", 0, AV_OPT_TYPE_CONST, {.i64 = SEGMENT_TYPE_FMP4 }, 0, UINT_MAX, E, "segment_type"},
  2659. {"hls_fmp4_init_filename", "set fragment mp4 file init filename", OFFSET(fmp4_init_filename), AV_OPT_TYPE_STRING, {.str = "init.mp4"}, 0, 0, E},
  2660. {"hls_flags", "set flags affecting HLS playlist and media file generation", OFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64 = 0 }, 0, UINT_MAX, E, "flags"},
  2661. {"single_file", "generate a single media file indexed with byte ranges", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_SINGLE_FILE }, 0, UINT_MAX, E, "flags"},
  2662. {"temp_file", "write segment and playlist to temporary file and rename when complete", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_TEMP_FILE }, 0, UINT_MAX, E, "flags"},
  2663. {"delete_segments", "delete segment files that are no longer part of the playlist", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_DELETE_SEGMENTS }, 0, UINT_MAX, E, "flags"},
  2664. {"round_durations", "round durations in m3u8 to whole numbers", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_ROUND_DURATIONS }, 0, UINT_MAX, E, "flags"},
  2665. {"discont_start", "start the playlist with a discontinuity tag", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_DISCONT_START }, 0, UINT_MAX, E, "flags"},
  2666. {"omit_endlist", "Do not append an endlist when ending stream", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_OMIT_ENDLIST }, 0, UINT_MAX, E, "flags"},
  2667. {"split_by_time", "split the hls segment by time which user set by hls_time", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_SPLIT_BY_TIME }, 0, UINT_MAX, E, "flags"},
  2668. {"append_list", "append the new segments into old hls segment list", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_APPEND_LIST }, 0, UINT_MAX, E, "flags"},
  2669. {"program_date_time", "add EXT-X-PROGRAM-DATE-TIME", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_PROGRAM_DATE_TIME }, 0, UINT_MAX, E, "flags"},
  2670. {"second_level_segment_index", "include segment index in segment filenames when use_localtime", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_SECOND_LEVEL_SEGMENT_INDEX }, 0, UINT_MAX, E, "flags"},
  2671. {"second_level_segment_duration", "include segment duration in segment filenames when use_localtime", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_SECOND_LEVEL_SEGMENT_DURATION }, 0, UINT_MAX, E, "flags"},
  2672. {"second_level_segment_size", "include segment size in segment filenames when use_localtime", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_SECOND_LEVEL_SEGMENT_SIZE }, 0, UINT_MAX, E, "flags"},
  2673. {"periodic_rekey", "reload keyinfo file periodically for re-keying", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_PERIODIC_REKEY }, 0, UINT_MAX, E, "flags"},
  2674. {"independent_segments", "add EXT-X-INDEPENDENT-SEGMENTS, whenever applicable", 0, AV_OPT_TYPE_CONST, { .i64 = HLS_INDEPENDENT_SEGMENTS }, 0, UINT_MAX, E, "flags"},
  2675. {"iframes_only", "add EXT-X-I-FRAMES-ONLY, whenever applicable", 0, AV_OPT_TYPE_CONST, { .i64 = HLS_I_FRAMES_ONLY }, 0, UINT_MAX, E, "flags"},
  2676. #if FF_API_HLS_USE_LOCALTIME
  2677. {"use_localtime", "set filename expansion with strftime at segment creation(will be deprecated )", OFFSET(use_localtime), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
  2678. #endif
  2679. {"strftime", "set filename expansion with strftime at segment creation", OFFSET(use_localtime), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
  2680. #if FF_API_HLS_USE_LOCALTIME
  2681. {"use_localtime_mkdir", "create last directory component in strftime-generated filename(will be deprecated)", OFFSET(use_localtime_mkdir), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
  2682. #endif
  2683. {"strftime_mkdir", "create last directory component in strftime-generated filename", OFFSET(use_localtime_mkdir), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
  2684. {"hls_playlist_type", "set the HLS playlist type", OFFSET(pl_type), AV_OPT_TYPE_INT, {.i64 = PLAYLIST_TYPE_NONE }, 0, PLAYLIST_TYPE_NB-1, E, "pl_type" },
  2685. {"event", "EVENT playlist", 0, AV_OPT_TYPE_CONST, {.i64 = PLAYLIST_TYPE_EVENT }, INT_MIN, INT_MAX, E, "pl_type" },
  2686. {"vod", "VOD playlist", 0, AV_OPT_TYPE_CONST, {.i64 = PLAYLIST_TYPE_VOD }, INT_MIN, INT_MAX, E, "pl_type" },
  2687. {"method", "set the HTTP method(default: PUT)", OFFSET(method), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E},
  2688. {"hls_start_number_source", "set source of first number in sequence", OFFSET(start_sequence_source_type), AV_OPT_TYPE_INT, {.i64 = HLS_START_SEQUENCE_AS_START_NUMBER }, 0, HLS_START_SEQUENCE_AS_FORMATTED_DATETIME, E, "start_sequence_source_type" },
  2689. {"generic", "start_number value (default)", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_START_SEQUENCE_AS_START_NUMBER }, INT_MIN, INT_MAX, E, "start_sequence_source_type" },
  2690. {"epoch", "seconds since epoch", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_START_SEQUENCE_AS_SECONDS_SINCE_EPOCH }, INT_MIN, INT_MAX, E, "start_sequence_source_type" },
  2691. {"datetime", "current datetime as YYYYMMDDhhmmss", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_START_SEQUENCE_AS_FORMATTED_DATETIME }, INT_MIN, INT_MAX, E, "start_sequence_source_type" },
  2692. {"http_user_agent", "override User-Agent field in HTTP header", OFFSET(user_agent), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E},
  2693. {"var_stream_map", "Variant stream map string", OFFSET(var_stream_map), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E},
  2694. {"cc_stream_map", "Closed captions stream map string", OFFSET(cc_stream_map), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E},
  2695. {"master_pl_name", "Create HLS master playlist with this name", OFFSET(master_pl_name), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E},
  2696. {"master_pl_publish_rate", "Publish master play list every after this many segment intervals", OFFSET(master_publish_rate), AV_OPT_TYPE_INT, {.i64 = 0}, 0, UINT_MAX, E},
  2697. {"http_persistent", "Use persistent HTTP connections", OFFSET(http_persistent), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
  2698. {"timeout", "set timeout for socket I/O operations", OFFSET(timeout), AV_OPT_TYPE_DURATION, { .i64 = -1 }, -1, INT_MAX, .flags = E },
  2699. {"ignore_io_errors", "Ignore IO errors for stable long-duration runs with network output", OFFSET(ignore_io_errors), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, E },
  2700. {"headers", "set custom HTTP headers, can override built in default headers", OFFSET(headers), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, E },
  2701. { NULL },
  2702. };
  2703. static const AVClass hls_class = {
  2704. .class_name = "hls muxer",
  2705. .item_name = av_default_item_name,
  2706. .option = options,
  2707. .version = LIBAVUTIL_VERSION_INT,
  2708. };
  2709. AVOutputFormat ff_hls_muxer = {
  2710. .name = "hls",
  2711. .long_name = NULL_IF_CONFIG_SMALL("Apple HTTP Live Streaming"),
  2712. .extensions = "m3u8",
  2713. .priv_data_size = sizeof(HLSContext),
  2714. .audio_codec = AV_CODEC_ID_AAC,
  2715. .video_codec = AV_CODEC_ID_H264,
  2716. .subtitle_codec = AV_CODEC_ID_WEBVTT,
  2717. .flags = AVFMT_NOFILE | AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH | AVFMT_NODIMENSIONS,
  2718. .init = hls_init,
  2719. .write_header = hls_write_header,
  2720. .write_packet = hls_write_packet,
  2721. .write_trailer = hls_write_trailer,
  2722. .priv_class = &hls_class,
  2723. };