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.

2405 lines
86KB

  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. #define KEYSIZE 16
  56. #define LINE_BUFFER_SIZE 1024
  57. #define HLS_MICROSECOND_UNIT 1000000
  58. #define POSTFIX_PATTERN "_%d"
  59. typedef struct HLSSegment {
  60. char filename[1024];
  61. char sub_filename[1024];
  62. double duration; /* in seconds */
  63. int discont;
  64. int64_t pos;
  65. int64_t size;
  66. char key_uri[LINE_BUFFER_SIZE + 1];
  67. char iv_string[KEYSIZE*2 + 1];
  68. struct HLSSegment *next;
  69. } HLSSegment;
  70. typedef enum HLSFlags {
  71. // Generate a single media file and use byte ranges in the playlist.
  72. HLS_SINGLE_FILE = (1 << 0),
  73. HLS_DELETE_SEGMENTS = (1 << 1),
  74. HLS_ROUND_DURATIONS = (1 << 2),
  75. HLS_DISCONT_START = (1 << 3),
  76. HLS_OMIT_ENDLIST = (1 << 4),
  77. HLS_SPLIT_BY_TIME = (1 << 5),
  78. HLS_APPEND_LIST = (1 << 6),
  79. HLS_PROGRAM_DATE_TIME = (1 << 7),
  80. HLS_SECOND_LEVEL_SEGMENT_INDEX = (1 << 8), // include segment index in segment filenames when use_localtime e.g.: %%03d
  81. HLS_SECOND_LEVEL_SEGMENT_DURATION = (1 << 9), // include segment duration (microsec) in segment filenames when use_localtime e.g.: %%09t
  82. HLS_SECOND_LEVEL_SEGMENT_SIZE = (1 << 10), // include segment size (bytes) in segment filenames when use_localtime e.g.: %%014s
  83. HLS_TEMP_FILE = (1 << 11),
  84. HLS_PERIODIC_REKEY = (1 << 12),
  85. HLS_INDEPENDENT_SEGMENTS = (1 << 13),
  86. } HLSFlags;
  87. typedef enum {
  88. SEGMENT_TYPE_MPEGTS,
  89. SEGMENT_TYPE_FMP4,
  90. } SegmentType;
  91. typedef struct VariantStream {
  92. unsigned number;
  93. int64_t sequence;
  94. AVOutputFormat *oformat;
  95. AVOutputFormat *vtt_oformat;
  96. AVIOContext *out;
  97. int packets_written;
  98. int init_range_length;
  99. AVFormatContext *avf;
  100. AVFormatContext *vtt_avf;
  101. int has_video;
  102. int has_subtitle;
  103. int new_start;
  104. double dpp; // duration per packet
  105. int64_t start_pts;
  106. int64_t end_pts;
  107. double duration; // last segment duration computed so far, in seconds
  108. int64_t start_pos; // last segment starting position
  109. int64_t size; // last segment size
  110. int nb_entries;
  111. int discontinuity_set;
  112. int discontinuity;
  113. HLSSegment *segments;
  114. HLSSegment *last_segment;
  115. HLSSegment *old_segments;
  116. char *basename;
  117. char *vtt_basename;
  118. char *vtt_m3u8_name;
  119. char *m3u8_name;
  120. double initial_prog_date_time;
  121. char current_segment_final_filename_fmt[1024]; // when renaming segments
  122. char *fmp4_init_filename;
  123. char *base_output_dirname;
  124. int fmp4_init_mode;
  125. AVStream **streams;
  126. unsigned int nb_streams;
  127. int m3u8_created; /* status of media play-list creation */
  128. char *baseurl;
  129. } VariantStream;
  130. typedef struct HLSContext {
  131. const AVClass *class; // Class for private options.
  132. int64_t start_sequence;
  133. uint32_t start_sequence_source_type; // enum StartSequenceSourceType
  134. float time; // Set by a private option.
  135. float init_time; // Set by a private option.
  136. int max_nb_segments; // Set by a private option.
  137. #if FF_API_HLS_WRAP
  138. int wrap; // Set by a private option.
  139. #endif
  140. uint32_t flags; // enum HLSFlags
  141. uint32_t pl_type; // enum PlaylistType
  142. char *segment_filename;
  143. char *fmp4_init_filename;
  144. int segment_type;
  145. int use_localtime; ///< flag to expand filename with localtime
  146. int use_localtime_mkdir;///< flag to mkdir dirname in timebased filename
  147. int allowcache;
  148. int64_t recording_time;
  149. int64_t max_seg_size; // every segment file max size
  150. char *baseurl;
  151. char *format_options_str;
  152. char *vtt_format_options_str;
  153. char *subtitle_filename;
  154. AVDictionary *format_options;
  155. int encrypt;
  156. char *key;
  157. char *key_url;
  158. char *iv;
  159. char *key_basename;
  160. int encrypt_started;
  161. char *key_info_file;
  162. char key_file[LINE_BUFFER_SIZE + 1];
  163. char key_uri[LINE_BUFFER_SIZE + 1];
  164. char key_string[KEYSIZE*2 + 1];
  165. char iv_string[KEYSIZE*2 + 1];
  166. AVDictionary *vtt_format_options;
  167. char *method;
  168. char *user_agent;
  169. VariantStream *var_streams;
  170. unsigned int nb_varstreams;
  171. int master_m3u8_created; /* status of master play-list creation */
  172. char *master_m3u8_url; /* URL of the master m3u8 file */
  173. int version; /* HLS version */
  174. char *var_stream_map; /* user specified variant stream map string */
  175. char *master_pl_name;
  176. unsigned int master_publish_rate;
  177. int http_persistent;
  178. AVIOContext *m3u8_out;
  179. AVIOContext *sub_m3u8_out;
  180. } HLSContext;
  181. static int mkdir_p(const char *path) {
  182. int ret = 0;
  183. char *temp = av_strdup(path);
  184. char *pos = temp;
  185. char tmp_ch = '\0';
  186. if (!path || !temp) {
  187. return -1;
  188. }
  189. if (!strncmp(temp, "/", 1) || !strncmp(temp, "\\", 1)) {
  190. pos++;
  191. } else if (!strncmp(temp, "./", 2) || !strncmp(temp, ".\\", 2)) {
  192. pos += 2;
  193. }
  194. for ( ; *pos != '\0'; ++pos) {
  195. if (*pos == '/' || *pos == '\\') {
  196. tmp_ch = *pos;
  197. *pos = '\0';
  198. ret = mkdir(temp, 0755);
  199. *pos = tmp_ch;
  200. }
  201. }
  202. if ((*(pos - 1) != '/') || (*(pos - 1) != '\\')) {
  203. ret = mkdir(temp, 0755);
  204. }
  205. av_free(temp);
  206. return ret;
  207. }
  208. static int is_http_proto(char *filename) {
  209. const char *proto = avio_find_protocol_name(filename);
  210. return proto ? (!av_strcasecmp(proto, "http") || !av_strcasecmp(proto, "https")) : 0;
  211. }
  212. static int hlsenc_io_open(AVFormatContext *s, AVIOContext **pb, char *filename,
  213. AVDictionary **options) {
  214. HLSContext *hls = s->priv_data;
  215. int http_base_proto = filename ? is_http_proto(filename) : 0;
  216. int err = AVERROR_MUXER_NOT_FOUND;
  217. if (!*pb || !http_base_proto || !hls->http_persistent) {
  218. err = s->io_open(s, pb, filename, AVIO_FLAG_WRITE, options);
  219. #if CONFIG_HTTP_PROTOCOL
  220. } else {
  221. URLContext *http_url_context = ffio_geturlcontext(*pb);
  222. av_assert0(http_url_context);
  223. err = ff_http_do_new_request(http_url_context, filename);
  224. #endif
  225. }
  226. return err;
  227. }
  228. static void hlsenc_io_close(AVFormatContext *s, AVIOContext **pb, char *filename) {
  229. HLSContext *hls = s->priv_data;
  230. int http_base_proto = filename ? is_http_proto(filename) : 0;
  231. if (!http_base_proto || !hls->http_persistent || hls->key_info_file || hls->encrypt) {
  232. ff_format_io_close(s, pb);
  233. } else {
  234. avio_flush(*pb);
  235. }
  236. }
  237. static void set_http_options(AVFormatContext *s, AVDictionary **options, HLSContext *c)
  238. {
  239. int http_base_proto = is_http_proto(s->filename);
  240. if (c->method) {
  241. av_dict_set(options, "method", c->method, 0);
  242. } else if (http_base_proto) {
  243. av_log(c, AV_LOG_WARNING, "No HTTP method set, hls muxer defaulting to method PUT.\n");
  244. av_dict_set(options, "method", "PUT", 0);
  245. }
  246. if (c->user_agent)
  247. av_dict_set(options, "user_agent", c->user_agent, 0);
  248. if (c->http_persistent)
  249. av_dict_set_int(options, "multiple_requests", 1, 0);
  250. }
  251. static int replace_int_data_in_filename(char *buf, int buf_size, const char *filename, char placeholder, int64_t number)
  252. {
  253. const char *p;
  254. char *q, buf1[20], c;
  255. int nd, len, addchar_count;
  256. int found_count = 0;
  257. q = buf;
  258. p = filename;
  259. for (;;) {
  260. c = *p;
  261. if (c == '\0')
  262. break;
  263. if (c == '%' && *(p+1) == '%') // %%
  264. addchar_count = 2;
  265. else if (c == '%' && (av_isdigit(*(p+1)) || *(p+1) == placeholder)) {
  266. nd = 0;
  267. addchar_count = 1;
  268. while (av_isdigit(*(p + addchar_count))) {
  269. nd = nd * 10 + *(p + addchar_count) - '0';
  270. addchar_count++;
  271. }
  272. if (*(p + addchar_count) == placeholder) {
  273. len = snprintf(buf1, sizeof(buf1), "%0*"PRId64, (number < 0) ? nd : nd++, number);
  274. if (len < 1) // returned error or empty buf1
  275. goto fail;
  276. if ((q - buf + len) > buf_size - 1)
  277. goto fail;
  278. memcpy(q, buf1, len);
  279. q += len;
  280. p += (addchar_count + 1);
  281. addchar_count = 0;
  282. found_count++;
  283. }
  284. } else
  285. addchar_count = 1;
  286. while (addchar_count--)
  287. if ((q - buf) < buf_size - 1)
  288. *q++ = *p++;
  289. else
  290. goto fail;
  291. }
  292. *q = '\0';
  293. return found_count;
  294. fail:
  295. *q = '\0';
  296. return -1;
  297. }
  298. static void write_styp(AVIOContext *pb)
  299. {
  300. avio_wb32(pb, 24);
  301. ffio_wfourcc(pb, "styp");
  302. ffio_wfourcc(pb, "msdh");
  303. avio_wb32(pb, 0); /* minor */
  304. ffio_wfourcc(pb, "msdh");
  305. ffio_wfourcc(pb, "msix");
  306. }
  307. static int flush_dynbuf(VariantStream *vs, int *range_length)
  308. {
  309. AVFormatContext *ctx = vs->avf;
  310. uint8_t *buffer;
  311. if (!ctx->pb) {
  312. return AVERROR(EINVAL);
  313. }
  314. // flush
  315. av_write_frame(ctx, NULL);
  316. avio_flush(ctx->pb);
  317. // write out to file
  318. *range_length = avio_close_dyn_buf(ctx->pb, &buffer);
  319. ctx->pb = NULL;
  320. avio_write(vs->out, buffer, *range_length);
  321. av_free(buffer);
  322. // re-open buffer
  323. return avio_open_dyn_buf(&ctx->pb);
  324. }
  325. static int hls_delete_old_segments(AVFormatContext *s, HLSContext *hls,
  326. VariantStream *vs) {
  327. HLSSegment *segment, *previous_segment = NULL;
  328. float playlist_duration = 0.0f;
  329. int ret = 0, path_size, sub_path_size;
  330. char *dirname = NULL, *p, *sub_path;
  331. char *path = NULL;
  332. AVDictionary *options = NULL;
  333. AVIOContext *out = NULL;
  334. const char *proto = NULL;
  335. segment = vs->segments;
  336. while (segment) {
  337. playlist_duration += segment->duration;
  338. segment = segment->next;
  339. }
  340. segment = vs->old_segments;
  341. while (segment) {
  342. playlist_duration -= segment->duration;
  343. previous_segment = segment;
  344. segment = previous_segment->next;
  345. if (playlist_duration <= -previous_segment->duration) {
  346. previous_segment->next = NULL;
  347. break;
  348. }
  349. }
  350. if (segment && !hls->use_localtime_mkdir) {
  351. if (hls->segment_filename) {
  352. dirname = av_strdup(hls->segment_filename);
  353. } else {
  354. dirname = av_strdup(vs->avf->filename);
  355. }
  356. if (!dirname) {
  357. ret = AVERROR(ENOMEM);
  358. goto fail;
  359. }
  360. p = (char *)av_basename(dirname);
  361. *p = '\0';
  362. }
  363. while (segment) {
  364. av_log(hls, AV_LOG_DEBUG, "deleting old segment %s\n",
  365. segment->filename);
  366. path_size = (hls->use_localtime_mkdir ? 0 : strlen(dirname)) + strlen(segment->filename) + 1;
  367. path = av_malloc(path_size);
  368. if (!path) {
  369. ret = AVERROR(ENOMEM);
  370. goto fail;
  371. }
  372. if (hls->use_localtime_mkdir)
  373. av_strlcpy(path, segment->filename, path_size);
  374. else { // segment->filename contains basename only
  375. av_strlcpy(path, dirname, path_size);
  376. av_strlcat(path, segment->filename, path_size);
  377. }
  378. proto = avio_find_protocol_name(s->filename);
  379. if (hls->method || (proto && !av_strcasecmp(proto, "http"))) {
  380. av_dict_set(&options, "method", "DELETE", 0);
  381. if ((ret = vs->avf->io_open(vs->avf, &out, path, AVIO_FLAG_WRITE, &options)) < 0)
  382. goto fail;
  383. ff_format_io_close(vs->avf, &out);
  384. } else if (unlink(path) < 0) {
  385. av_log(hls, AV_LOG_ERROR, "failed to delete old segment %s: %s\n",
  386. path, strerror(errno));
  387. }
  388. if ((segment->sub_filename[0] != '\0')) {
  389. sub_path_size = strlen(segment->sub_filename) + 1 + (dirname ? strlen(dirname) : 0);
  390. sub_path = av_malloc(sub_path_size);
  391. if (!sub_path) {
  392. ret = AVERROR(ENOMEM);
  393. goto fail;
  394. }
  395. av_strlcpy(sub_path, dirname, sub_path_size);
  396. av_strlcat(sub_path, segment->sub_filename, sub_path_size);
  397. if (hls->method || (proto && !av_strcasecmp(proto, "http"))) {
  398. av_dict_set(&options, "method", "DELETE", 0);
  399. if ((ret = vs->avf->io_open(vs->avf, &out, sub_path, AVIO_FLAG_WRITE, &options)) < 0) {
  400. av_free(sub_path);
  401. goto fail;
  402. }
  403. ff_format_io_close(vs->avf, &out);
  404. } else if (unlink(sub_path) < 0) {
  405. av_log(hls, AV_LOG_ERROR, "failed to delete old segment %s: %s\n",
  406. sub_path, strerror(errno));
  407. }
  408. av_free(sub_path);
  409. }
  410. av_freep(&path);
  411. previous_segment = segment;
  412. segment = previous_segment->next;
  413. av_free(previous_segment);
  414. }
  415. fail:
  416. av_free(path);
  417. av_free(dirname);
  418. return ret;
  419. }
  420. static int randomize(uint8_t *buf, int len)
  421. {
  422. #if CONFIG_GCRYPT
  423. gcry_randomize(buf, len, GCRY_VERY_STRONG_RANDOM);
  424. return 0;
  425. #elif CONFIG_OPENSSL
  426. if (RAND_bytes(buf, len))
  427. return 0;
  428. #else
  429. return AVERROR(ENOSYS);
  430. #endif
  431. return AVERROR(EINVAL);
  432. }
  433. static int do_encrypt(AVFormatContext *s, VariantStream *vs)
  434. {
  435. HLSContext *hls = s->priv_data;
  436. int ret;
  437. int len;
  438. AVIOContext *pb;
  439. uint8_t key[KEYSIZE];
  440. len = strlen(s->filename) + 4 + 1;
  441. hls->key_basename = av_mallocz(len);
  442. if (!hls->key_basename)
  443. return AVERROR(ENOMEM);
  444. av_strlcpy(hls->key_basename, s->filename, len);
  445. av_strlcat(hls->key_basename, ".key", len);
  446. if (hls->key_url) {
  447. av_strlcpy(hls->key_file, hls->key_url, sizeof(hls->key_file));
  448. av_strlcpy(hls->key_uri, hls->key_url, sizeof(hls->key_uri));
  449. } else {
  450. av_strlcpy(hls->key_file, hls->key_basename, sizeof(hls->key_file));
  451. av_strlcpy(hls->key_uri, hls->key_basename, sizeof(hls->key_uri));
  452. }
  453. if (!*hls->iv_string) {
  454. uint8_t iv[16] = { 0 };
  455. char buf[33];
  456. if (!hls->iv) {
  457. AV_WB64(iv + 8, vs->sequence);
  458. } else {
  459. memcpy(iv, hls->iv, sizeof(iv));
  460. }
  461. ff_data_to_hex(buf, iv, sizeof(iv), 0);
  462. buf[32] = '\0';
  463. memcpy(hls->iv_string, buf, sizeof(hls->iv_string));
  464. }
  465. if (!*hls->key_uri) {
  466. av_log(hls, AV_LOG_ERROR, "no key URI specified in key info file\n");
  467. return AVERROR(EINVAL);
  468. }
  469. if (!*hls->key_file) {
  470. av_log(hls, AV_LOG_ERROR, "no key file specified in key info file\n");
  471. return AVERROR(EINVAL);
  472. }
  473. if (!*hls->key_string) {
  474. if (!hls->key) {
  475. if ((ret = randomize(key, sizeof(key))) < 0) {
  476. av_log(s, AV_LOG_ERROR, "Cannot generate a strong random key\n");
  477. return ret;
  478. }
  479. } else {
  480. memcpy(key, hls->key, sizeof(key));
  481. }
  482. ff_data_to_hex(hls->key_string, key, sizeof(key), 0);
  483. if ((ret = s->io_open(s, &pb, hls->key_file, AVIO_FLAG_WRITE, NULL)) < 0)
  484. return ret;
  485. avio_seek(pb, 0, SEEK_CUR);
  486. avio_write(pb, key, KEYSIZE);
  487. avio_close(pb);
  488. }
  489. return 0;
  490. }
  491. static int hls_encryption_start(AVFormatContext *s)
  492. {
  493. HLSContext *hls = s->priv_data;
  494. int ret;
  495. AVIOContext *pb;
  496. uint8_t key[KEYSIZE];
  497. if ((ret = s->io_open(s, &pb, hls->key_info_file, AVIO_FLAG_READ, NULL)) < 0) {
  498. av_log(hls, AV_LOG_ERROR,
  499. "error opening key info file %s\n", hls->key_info_file);
  500. return ret;
  501. }
  502. ff_get_line(pb, hls->key_uri, sizeof(hls->key_uri));
  503. hls->key_uri[strcspn(hls->key_uri, "\r\n")] = '\0';
  504. ff_get_line(pb, hls->key_file, sizeof(hls->key_file));
  505. hls->key_file[strcspn(hls->key_file, "\r\n")] = '\0';
  506. ff_get_line(pb, hls->iv_string, sizeof(hls->iv_string));
  507. hls->iv_string[strcspn(hls->iv_string, "\r\n")] = '\0';
  508. ff_format_io_close(s, &pb);
  509. if (!*hls->key_uri) {
  510. av_log(hls, AV_LOG_ERROR, "no key URI specified in key info file\n");
  511. return AVERROR(EINVAL);
  512. }
  513. if (!*hls->key_file) {
  514. av_log(hls, AV_LOG_ERROR, "no key file specified in key info file\n");
  515. return AVERROR(EINVAL);
  516. }
  517. if ((ret = s->io_open(s, &pb, hls->key_file, AVIO_FLAG_READ, NULL)) < 0) {
  518. av_log(hls, AV_LOG_ERROR, "error opening key file %s\n", hls->key_file);
  519. return ret;
  520. }
  521. ret = avio_read(pb, key, sizeof(key));
  522. ff_format_io_close(s, &pb);
  523. if (ret != sizeof(key)) {
  524. av_log(hls, AV_LOG_ERROR, "error reading key file %s\n", hls->key_file);
  525. if (ret >= 0 || ret == AVERROR_EOF)
  526. ret = AVERROR(EINVAL);
  527. return ret;
  528. }
  529. ff_data_to_hex(hls->key_string, key, sizeof(key), 0);
  530. return 0;
  531. }
  532. static int read_chomp_line(AVIOContext *s, char *buf, int maxlen)
  533. {
  534. int len = ff_get_line(s, buf, maxlen);
  535. while (len > 0 && av_isspace(buf[len - 1]))
  536. buf[--len] = '\0';
  537. return len;
  538. }
  539. static int hls_mux_init(AVFormatContext *s, VariantStream *vs)
  540. {
  541. AVDictionary *options = NULL;
  542. HLSContext *hls = s->priv_data;
  543. AVFormatContext *oc;
  544. AVFormatContext *vtt_oc = NULL;
  545. int byterange_mode = (hls->flags & HLS_SINGLE_FILE) || (hls->max_seg_size > 0);
  546. int i, ret;
  547. ret = avformat_alloc_output_context2(&vs->avf, vs->oformat, NULL, NULL);
  548. if (ret < 0)
  549. return ret;
  550. oc = vs->avf;
  551. oc->filename[0] = '\0';
  552. oc->oformat = vs->oformat;
  553. oc->interrupt_callback = s->interrupt_callback;
  554. oc->max_delay = s->max_delay;
  555. oc->opaque = s->opaque;
  556. oc->io_open = s->io_open;
  557. oc->io_close = s->io_close;
  558. av_dict_copy(&oc->metadata, s->metadata, 0);
  559. if(vs->vtt_oformat) {
  560. ret = avformat_alloc_output_context2(&vs->vtt_avf, vs->vtt_oformat, NULL, NULL);
  561. if (ret < 0)
  562. return ret;
  563. vtt_oc = vs->vtt_avf;
  564. vtt_oc->oformat = vs->vtt_oformat;
  565. av_dict_copy(&vtt_oc->metadata, s->metadata, 0);
  566. }
  567. for (i = 0; i < vs->nb_streams; i++) {
  568. AVStream *st;
  569. AVFormatContext *loc;
  570. if (vs->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
  571. loc = vtt_oc;
  572. else
  573. loc = oc;
  574. if (!(st = avformat_new_stream(loc, NULL)))
  575. return AVERROR(ENOMEM);
  576. avcodec_parameters_copy(st->codecpar, vs->streams[i]->codecpar);
  577. if (!oc->oformat->codec_tag ||
  578. av_codec_get_id (oc->oformat->codec_tag, vs->streams[i]->codecpar->codec_tag) == st->codecpar->codec_id ||
  579. av_codec_get_tag(oc->oformat->codec_tag, vs->streams[i]->codecpar->codec_id) <= 0) {
  580. st->codecpar->codec_tag = vs->streams[i]->codecpar->codec_tag;
  581. } else {
  582. st->codecpar->codec_tag = 0;
  583. }
  584. st->sample_aspect_ratio = vs->streams[i]->sample_aspect_ratio;
  585. st->time_base = vs->streams[i]->time_base;
  586. av_dict_copy(&st->metadata, vs->streams[i]->metadata, 0);
  587. }
  588. vs->packets_written = 1;
  589. vs->start_pos = 0;
  590. vs->new_start = 1;
  591. vs->fmp4_init_mode = 0;
  592. if (hls->segment_type == SEGMENT_TYPE_FMP4) {
  593. if (hls->max_seg_size > 0) {
  594. av_log(s, AV_LOG_WARNING, "Multi-file byterange mode is currently unsupported in the HLS muxer.\n");
  595. return AVERROR_PATCHWELCOME;
  596. }
  597. vs->packets_written = 0;
  598. vs->init_range_length = 0;
  599. vs->fmp4_init_mode = !byterange_mode;
  600. set_http_options(s, &options, hls);
  601. if ((ret = avio_open_dyn_buf(&oc->pb)) < 0)
  602. return ret;
  603. ret = hlsenc_io_open(s, &vs->out, vs->base_output_dirname, &options);
  604. av_dict_free(&options);
  605. if (ret < 0) {
  606. av_log(s, AV_LOG_ERROR, "Failed to open segment '%s'\n", vs->fmp4_init_filename);
  607. return ret;
  608. }
  609. if (hls->format_options_str) {
  610. ret = av_dict_parse_string(&hls->format_options, hls->format_options_str, "=", ":", 0);
  611. if (ret < 0) {
  612. av_log(s, AV_LOG_ERROR, "Could not parse format options list '%s'\n",
  613. hls->format_options_str);
  614. return ret;
  615. }
  616. }
  617. av_dict_copy(&options, hls->format_options, 0);
  618. av_dict_set(&options, "fflags", "-autobsf", 0);
  619. av_dict_set(&options, "movflags", "frag_custom+dash+delay_moov", 0);
  620. ret = avformat_init_output(oc, &options);
  621. if (ret < 0)
  622. return ret;
  623. if (av_dict_count(options)) {
  624. av_log(s, AV_LOG_ERROR, "Some of the provided format options in '%s' are not recognized\n", hls->format_options_str);
  625. av_dict_free(&options);
  626. return AVERROR(EINVAL);
  627. }
  628. avio_flush(oc->pb);
  629. av_dict_free(&options);
  630. }
  631. return 0;
  632. }
  633. static HLSSegment *find_segment_by_filename(HLSSegment *segment, const char *filename)
  634. {
  635. while (segment) {
  636. if (!av_strcasecmp(segment->filename,filename))
  637. return segment;
  638. segment = segment->next;
  639. }
  640. return (HLSSegment *) NULL;
  641. }
  642. static int sls_flags_filename_process(struct AVFormatContext *s, HLSContext *hls,
  643. VariantStream *vs, HLSSegment *en,
  644. double duration, int64_t pos, int64_t size)
  645. {
  646. if ((hls->flags & (HLS_SECOND_LEVEL_SEGMENT_SIZE | HLS_SECOND_LEVEL_SEGMENT_DURATION)) &&
  647. strlen(vs->current_segment_final_filename_fmt)) {
  648. av_strlcpy(vs->avf->filename, vs->current_segment_final_filename_fmt, sizeof(vs->avf->filename));
  649. if (hls->flags & HLS_SECOND_LEVEL_SEGMENT_SIZE) {
  650. char * filename = av_strdup(vs->avf->filename); // %%s will be %s after strftime
  651. if (!filename) {
  652. av_free(en);
  653. return AVERROR(ENOMEM);
  654. }
  655. if (replace_int_data_in_filename(vs->avf->filename, sizeof(vs->avf->filename),
  656. filename, 's', pos + size) < 1) {
  657. av_log(hls, AV_LOG_ERROR,
  658. "Invalid second level segment filename template '%s', "
  659. "you can try to remove second_level_segment_size flag\n",
  660. filename);
  661. av_free(filename);
  662. av_free(en);
  663. return AVERROR(EINVAL);
  664. }
  665. av_free(filename);
  666. }
  667. if (hls->flags & HLS_SECOND_LEVEL_SEGMENT_DURATION) {
  668. char * filename = av_strdup(vs->avf->filename); // %%t will be %t after strftime
  669. if (!filename) {
  670. av_free(en);
  671. return AVERROR(ENOMEM);
  672. }
  673. if (replace_int_data_in_filename(vs->avf->filename, sizeof(vs->avf->filename),
  674. filename, 't', (int64_t)round(duration * HLS_MICROSECOND_UNIT)) < 1) {
  675. av_log(hls, AV_LOG_ERROR,
  676. "Invalid second level segment filename template '%s', "
  677. "you can try to remove second_level_segment_time flag\n",
  678. filename);
  679. av_free(filename);
  680. av_free(en);
  681. return AVERROR(EINVAL);
  682. }
  683. av_free(filename);
  684. }
  685. }
  686. return 0;
  687. }
  688. static int sls_flag_check_duration_size_index(HLSContext *hls)
  689. {
  690. int ret = 0;
  691. if (hls->flags & HLS_SECOND_LEVEL_SEGMENT_DURATION) {
  692. av_log(hls, AV_LOG_ERROR,
  693. "second_level_segment_duration hls_flag requires use_localtime to be true\n");
  694. ret = AVERROR(EINVAL);
  695. }
  696. if (hls->flags & HLS_SECOND_LEVEL_SEGMENT_SIZE) {
  697. av_log(hls, AV_LOG_ERROR,
  698. "second_level_segment_size hls_flag requires use_localtime to be true\n");
  699. ret = AVERROR(EINVAL);
  700. }
  701. if (hls->flags & HLS_SECOND_LEVEL_SEGMENT_INDEX) {
  702. av_log(hls, AV_LOG_ERROR,
  703. "second_level_segment_index hls_flag requires use_localtime to be true\n");
  704. ret = AVERROR(EINVAL);
  705. }
  706. return ret;
  707. }
  708. static int sls_flag_check_duration_size(HLSContext *hls, VariantStream *vs)
  709. {
  710. const char *proto = avio_find_protocol_name(vs->basename);
  711. int segment_renaming_ok = proto && !strcmp(proto, "file");
  712. int ret = 0;
  713. if ((hls->flags & HLS_SECOND_LEVEL_SEGMENT_DURATION) && !segment_renaming_ok) {
  714. av_log(hls, AV_LOG_ERROR,
  715. "second_level_segment_duration hls_flag works only with file protocol segment names\n");
  716. ret = AVERROR(EINVAL);
  717. }
  718. if ((hls->flags & HLS_SECOND_LEVEL_SEGMENT_SIZE) && !segment_renaming_ok) {
  719. av_log(hls, AV_LOG_ERROR,
  720. "second_level_segment_size hls_flag works only with file protocol segment names\n");
  721. ret = AVERROR(EINVAL);
  722. }
  723. return ret;
  724. }
  725. static void sls_flag_file_rename(HLSContext *hls, VariantStream *vs, char *old_filename) {
  726. if ((hls->flags & (HLS_SECOND_LEVEL_SEGMENT_SIZE | HLS_SECOND_LEVEL_SEGMENT_DURATION)) &&
  727. strlen(vs->current_segment_final_filename_fmt)) {
  728. ff_rename(old_filename, vs->avf->filename, hls);
  729. }
  730. }
  731. static int sls_flag_use_localtime_filename(AVFormatContext *oc, HLSContext *c, VariantStream *vs)
  732. {
  733. if (c->flags & HLS_SECOND_LEVEL_SEGMENT_INDEX) {
  734. char * filename = av_strdup(oc->filename); // %%d will be %d after strftime
  735. if (!filename)
  736. return AVERROR(ENOMEM);
  737. if (replace_int_data_in_filename(oc->filename, sizeof(oc->filename),
  738. #if FF_API_HLS_WRAP
  739. filename, 'd', c->wrap ? vs->sequence % c->wrap : vs->sequence) < 1) {
  740. #else
  741. filename, 'd', vs->sequence) < 1) {
  742. #endif
  743. av_log(c, AV_LOG_ERROR, "Invalid second level segment filename template '%s', "
  744. "you can try to remove second_level_segment_index flag\n",
  745. filename);
  746. av_free(filename);
  747. return AVERROR(EINVAL);
  748. }
  749. av_free(filename);
  750. }
  751. if (c->flags & (HLS_SECOND_LEVEL_SEGMENT_SIZE | HLS_SECOND_LEVEL_SEGMENT_DURATION)) {
  752. av_strlcpy(vs->current_segment_final_filename_fmt, oc->filename,
  753. sizeof(vs->current_segment_final_filename_fmt));
  754. if (c->flags & HLS_SECOND_LEVEL_SEGMENT_SIZE) {
  755. char * filename = av_strdup(oc->filename); // %%s will be %s after strftime
  756. if (!filename)
  757. return AVERROR(ENOMEM);
  758. if (replace_int_data_in_filename(oc->filename, sizeof(oc->filename), filename, 's', 0) < 1) {
  759. av_log(c, AV_LOG_ERROR, "Invalid second level segment filename template '%s', "
  760. "you can try to remove second_level_segment_size flag\n",
  761. filename);
  762. av_free(filename);
  763. return AVERROR(EINVAL);
  764. }
  765. av_free(filename);
  766. }
  767. if (c->flags & HLS_SECOND_LEVEL_SEGMENT_DURATION) {
  768. char * filename = av_strdup(oc->filename); // %%t will be %t after strftime
  769. if (!filename)
  770. return AVERROR(ENOMEM);
  771. if (replace_int_data_in_filename(oc->filename, sizeof(oc->filename), filename, 't', 0) < 1) {
  772. av_log(c, AV_LOG_ERROR, "Invalid second level segment filename template '%s', "
  773. "you can try to remove second_level_segment_time flag\n",
  774. filename);
  775. av_free(filename);
  776. return AVERROR(EINVAL);
  777. }
  778. av_free(filename);
  779. }
  780. }
  781. return 0;
  782. }
  783. /* Create a new segment and append it to the segment list */
  784. static int hls_append_segment(struct AVFormatContext *s, HLSContext *hls,
  785. VariantStream *vs, double duration, int64_t pos,
  786. int64_t size)
  787. {
  788. HLSSegment *en = av_malloc(sizeof(*en));
  789. const char *filename;
  790. int byterange_mode = (hls->flags & HLS_SINGLE_FILE) || (hls->max_seg_size > 0);
  791. int ret;
  792. if (!en)
  793. return AVERROR(ENOMEM);
  794. ret = sls_flags_filename_process(s, hls, vs, en, duration, pos, size);
  795. if (ret < 0) {
  796. return ret;
  797. }
  798. filename = av_basename(vs->avf->filename);
  799. if (hls->use_localtime_mkdir) {
  800. filename = vs->avf->filename;
  801. }
  802. if ((find_segment_by_filename(vs->segments, filename) || find_segment_by_filename(vs->old_segments, filename))
  803. && !byterange_mode) {
  804. av_log(hls, AV_LOG_WARNING, "Duplicated segment filename detected: %s\n", filename);
  805. }
  806. av_strlcpy(en->filename, filename, sizeof(en->filename));
  807. if(vs->has_subtitle)
  808. av_strlcpy(en->sub_filename, av_basename(vs->vtt_avf->filename), sizeof(en->sub_filename));
  809. else
  810. en->sub_filename[0] = '\0';
  811. en->duration = duration;
  812. en->pos = pos;
  813. en->size = size;
  814. en->next = NULL;
  815. en->discont = 0;
  816. if (vs->discontinuity) {
  817. en->discont = 1;
  818. vs->discontinuity = 0;
  819. }
  820. if (hls->key_info_file || hls->encrypt) {
  821. av_strlcpy(en->key_uri, hls->key_uri, sizeof(en->key_uri));
  822. av_strlcpy(en->iv_string, hls->iv_string, sizeof(en->iv_string));
  823. }
  824. if (!vs->segments)
  825. vs->segments = en;
  826. else
  827. vs->last_segment->next = en;
  828. vs->last_segment = en;
  829. // EVENT or VOD playlists imply sliding window cannot be used
  830. if (hls->pl_type != PLAYLIST_TYPE_NONE)
  831. hls->max_nb_segments = 0;
  832. if (hls->max_nb_segments && vs->nb_entries >= hls->max_nb_segments) {
  833. en = vs->segments;
  834. vs->initial_prog_date_time += en->duration;
  835. vs->segments = en->next;
  836. if (en && hls->flags & HLS_DELETE_SEGMENTS &&
  837. #if FF_API_HLS_WRAP
  838. !(hls->flags & HLS_SINGLE_FILE || hls->wrap)) {
  839. #else
  840. !(hls->flags & HLS_SINGLE_FILE)) {
  841. #endif
  842. en->next = vs->old_segments;
  843. vs->old_segments = en;
  844. if ((ret = hls_delete_old_segments(s, hls, vs)) < 0)
  845. return ret;
  846. } else
  847. av_free(en);
  848. } else
  849. vs->nb_entries++;
  850. if (hls->max_seg_size > 0) {
  851. return 0;
  852. }
  853. vs->sequence++;
  854. return 0;
  855. }
  856. static int parse_playlist(AVFormatContext *s, const char *url, VariantStream *vs)
  857. {
  858. HLSContext *hls = s->priv_data;
  859. AVIOContext *in;
  860. int ret = 0, is_segment = 0;
  861. int64_t new_start_pos;
  862. char line[1024];
  863. const char *ptr;
  864. const char *end;
  865. if ((ret = ffio_open_whitelist(&in, url, AVIO_FLAG_READ,
  866. &s->interrupt_callback, NULL,
  867. s->protocol_whitelist, s->protocol_blacklist)) < 0)
  868. return ret;
  869. read_chomp_line(in, line, sizeof(line));
  870. if (strcmp(line, "#EXTM3U")) {
  871. ret = AVERROR_INVALIDDATA;
  872. goto fail;
  873. }
  874. vs->discontinuity = 0;
  875. while (!avio_feof(in)) {
  876. read_chomp_line(in, line, sizeof(line));
  877. if (av_strstart(line, "#EXT-X-MEDIA-SEQUENCE:", &ptr)) {
  878. int64_t tmp_sequence = strtoll(ptr, NULL, 10);
  879. if (tmp_sequence < vs->sequence)
  880. av_log(hls, AV_LOG_VERBOSE,
  881. "Found playlist sequence number was smaller """
  882. "than specified start sequence number: %"PRId64" < %"PRId64", "
  883. "omitting\n", tmp_sequence, hls->start_sequence);
  884. else {
  885. av_log(hls, AV_LOG_DEBUG, "Found playlist sequence number: %"PRId64"\n", tmp_sequence);
  886. vs->sequence = tmp_sequence;
  887. }
  888. } else if (av_strstart(line, "#EXT-X-DISCONTINUITY", &ptr)) {
  889. is_segment = 1;
  890. vs->discontinuity = 1;
  891. } else if (av_strstart(line, "#EXTINF:", &ptr)) {
  892. is_segment = 1;
  893. vs->duration = atof(ptr);
  894. } else if (av_stristart(line, "#EXT-X-KEY:", &ptr)) {
  895. ptr = av_stristr(line, "URI=\"");
  896. if (ptr) {
  897. ptr += strlen("URI=\"");
  898. end = av_stristr(ptr, ",");
  899. if (end) {
  900. av_strlcpy(hls->key_uri, ptr, end - ptr);
  901. } else {
  902. av_strlcpy(hls->key_uri, ptr, sizeof(hls->key_uri));
  903. }
  904. }
  905. ptr = av_stristr(line, "IV=0x");
  906. if (ptr) {
  907. ptr += strlen("IV=0x");
  908. end = av_stristr(ptr, ",");
  909. if (end) {
  910. av_strlcpy(hls->iv_string, ptr, end - ptr);
  911. } else {
  912. av_strlcpy(hls->iv_string, ptr, sizeof(hls->iv_string));
  913. }
  914. }
  915. } else if (av_strstart(line, "#", NULL)) {
  916. continue;
  917. } else if (line[0]) {
  918. if (is_segment) {
  919. is_segment = 0;
  920. new_start_pos = avio_tell(vs->avf->pb);
  921. vs->size = new_start_pos - vs->start_pos;
  922. av_strlcpy(vs->avf->filename, line, sizeof(line));
  923. ret = hls_append_segment(s, hls, vs, vs->duration, vs->start_pos, vs->size);
  924. if (ret < 0)
  925. goto fail;
  926. vs->start_pos = new_start_pos;
  927. }
  928. }
  929. }
  930. fail:
  931. avio_close(in);
  932. return ret;
  933. }
  934. static void hls_free_segments(HLSSegment *p)
  935. {
  936. HLSSegment *en;
  937. while(p) {
  938. en = p;
  939. p = p->next;
  940. av_free(en);
  941. }
  942. }
  943. static void hls_rename_temp_file(AVFormatContext *s, AVFormatContext *oc)
  944. {
  945. size_t len = strlen(oc->filename);
  946. char final_filename[sizeof(oc->filename)];
  947. av_strlcpy(final_filename, oc->filename, len);
  948. final_filename[len-4] = '\0';
  949. ff_rename(oc->filename, final_filename, s);
  950. oc->filename[len-4] = '\0';
  951. }
  952. static int get_relative_url(const char *master_url, const char *media_url,
  953. char *rel_url, int rel_url_buf_size)
  954. {
  955. char *p = NULL;
  956. int base_len = -1;
  957. p = strrchr(master_url, '/') ? strrchr(master_url, '/') :\
  958. strrchr(master_url, '\\');
  959. if (p) {
  960. base_len = FFABS(p - master_url);
  961. if (av_strncasecmp(master_url, media_url, base_len)) {
  962. av_log(NULL, AV_LOG_WARNING, "Unable to find relative url\n");
  963. return AVERROR(EINVAL);
  964. }
  965. }
  966. av_strlcpy(rel_url, &(media_url[base_len + 1]), rel_url_buf_size);
  967. return 0;
  968. }
  969. static int create_master_playlist(AVFormatContext *s,
  970. VariantStream * const input_vs)
  971. {
  972. HLSContext *hls = s->priv_data;
  973. VariantStream *vs;
  974. AVStream *vid_st, *aud_st;
  975. AVDictionary *options = NULL;
  976. unsigned int i, j;
  977. int m3u8_name_size, ret, bandwidth;
  978. char *m3u8_rel_name;
  979. input_vs->m3u8_created = 1;
  980. if (!hls->master_m3u8_created) {
  981. /* For the first time, wait until all the media playlists are created */
  982. for (i = 0; i < hls->nb_varstreams; i++)
  983. if (!hls->var_streams[i].m3u8_created)
  984. return 0;
  985. } else {
  986. /* Keep publishing the master playlist at the configured rate */
  987. if (&hls->var_streams[0] != input_vs || !hls->master_publish_rate ||
  988. input_vs->number % hls->master_publish_rate)
  989. return 0;
  990. }
  991. set_http_options(s, &options, hls);
  992. ret = hlsenc_io_open(s, &hls->m3u8_out, hls->master_m3u8_url, &options);
  993. av_dict_free(&options);
  994. if (ret < 0) {
  995. av_log(NULL, AV_LOG_ERROR, "Failed to open master play list file '%s'\n",
  996. hls->master_m3u8_url);
  997. goto fail;
  998. }
  999. ff_hls_write_playlist_version(hls->m3u8_out, hls->version);
  1000. /* For variant streams with video add #EXT-X-STREAM-INF tag with attributes*/
  1001. for (i = 0; i < hls->nb_varstreams; i++) {
  1002. vs = &(hls->var_streams[i]);
  1003. m3u8_name_size = strlen(vs->m3u8_name) + 1;
  1004. m3u8_rel_name = av_malloc(m3u8_name_size);
  1005. if (!m3u8_rel_name) {
  1006. ret = AVERROR(ENOMEM);
  1007. goto fail;
  1008. }
  1009. av_strlcpy(m3u8_rel_name, vs->m3u8_name, m3u8_name_size);
  1010. ret = get_relative_url(hls->master_m3u8_url, vs->m3u8_name,
  1011. m3u8_rel_name, m3u8_name_size);
  1012. if (ret < 0) {
  1013. av_log(NULL, AV_LOG_ERROR, "Unable to find relative URL\n");
  1014. goto fail;
  1015. }
  1016. vid_st = NULL;
  1017. aud_st = NULL;
  1018. for (j = 0; j < vs->nb_streams; j++) {
  1019. if (vs->streams[j]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
  1020. vid_st = vs->streams[j];
  1021. else if (vs->streams[j]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
  1022. aud_st = vs->streams[j];
  1023. }
  1024. if (!vid_st && !aud_st) {
  1025. av_log(NULL, AV_LOG_WARNING, "Media stream not found\n");
  1026. continue;
  1027. }
  1028. bandwidth = 0;
  1029. if (vid_st)
  1030. bandwidth += vid_st->codecpar->bit_rate;
  1031. if (aud_st)
  1032. bandwidth += aud_st->codecpar->bit_rate;
  1033. bandwidth += bandwidth / 10;
  1034. ff_hls_write_stream_info(vid_st, hls->m3u8_out, bandwidth, m3u8_rel_name);
  1035. av_freep(&m3u8_rel_name);
  1036. }
  1037. fail:
  1038. if(ret >=0)
  1039. hls->master_m3u8_created = 1;
  1040. av_freep(&m3u8_rel_name);
  1041. hlsenc_io_close(s, &hls->m3u8_out, hls->master_m3u8_url);
  1042. return ret;
  1043. }
  1044. static int hls_window(AVFormatContext *s, int last, VariantStream *vs)
  1045. {
  1046. HLSContext *hls = s->priv_data;
  1047. HLSSegment *en;
  1048. int target_duration = 0;
  1049. int ret = 0;
  1050. char temp_filename[1024];
  1051. int64_t sequence = FFMAX(hls->start_sequence, vs->sequence - vs->nb_entries);
  1052. const char *proto = avio_find_protocol_name(s->filename);
  1053. int use_rename = proto && !strcmp(proto, "file");
  1054. static unsigned warned_non_file;
  1055. char *key_uri = NULL;
  1056. char *iv_string = NULL;
  1057. AVDictionary *options = NULL;
  1058. double prog_date_time = vs->initial_prog_date_time;
  1059. double *prog_date_time_p = (hls->flags & HLS_PROGRAM_DATE_TIME) ? &prog_date_time : NULL;
  1060. int byterange_mode = (hls->flags & HLS_SINGLE_FILE) || (hls->max_seg_size > 0);
  1061. hls->version = 3;
  1062. if (byterange_mode) {
  1063. hls->version = 4;
  1064. sequence = 0;
  1065. }
  1066. if (hls->flags & HLS_INDEPENDENT_SEGMENTS) {
  1067. hls->version = 6;
  1068. }
  1069. if (hls->segment_type == SEGMENT_TYPE_FMP4) {
  1070. hls->version = 7;
  1071. }
  1072. if (!use_rename && !warned_non_file++)
  1073. av_log(s, AV_LOG_ERROR, "Cannot use rename on non file protocol, this may lead to races and temporary partial files\n");
  1074. set_http_options(s, &options, hls);
  1075. snprintf(temp_filename, sizeof(temp_filename), use_rename ? "%s.tmp" : "%s", vs->m3u8_name);
  1076. if ((ret = hlsenc_io_open(s, &hls->m3u8_out, temp_filename, &options)) < 0)
  1077. goto fail;
  1078. for (en = vs->segments; en; en = en->next) {
  1079. if (target_duration <= en->duration)
  1080. target_duration = hls_get_int_from_double(en->duration);
  1081. }
  1082. vs->discontinuity_set = 0;
  1083. ff_hls_write_playlist_header(hls->m3u8_out, hls->version, hls->allowcache,
  1084. target_duration, sequence, hls->pl_type);
  1085. if((hls->flags & HLS_DISCONT_START) && sequence==hls->start_sequence && vs->discontinuity_set==0 ){
  1086. avio_printf(hls->m3u8_out, "#EXT-X-DISCONTINUITY\n");
  1087. vs->discontinuity_set = 1;
  1088. }
  1089. if (vs->has_video && (hls->flags & HLS_INDEPENDENT_SEGMENTS)) {
  1090. avio_printf(hls->m3u8_out, "#EXT-X-INDEPENDENT-SEGMENTS\n");
  1091. }
  1092. for (en = vs->segments; en; en = en->next) {
  1093. if ((hls->encrypt || hls->key_info_file) && (!key_uri || strcmp(en->key_uri, key_uri) ||
  1094. av_strcasecmp(en->iv_string, iv_string))) {
  1095. avio_printf(hls->m3u8_out, "#EXT-X-KEY:METHOD=AES-128,URI=\"%s\"", en->key_uri);
  1096. if (*en->iv_string)
  1097. avio_printf(hls->m3u8_out, ",IV=0x%s", en->iv_string);
  1098. avio_printf(hls->m3u8_out, "\n");
  1099. key_uri = en->key_uri;
  1100. iv_string = en->iv_string;
  1101. }
  1102. if ((hls->segment_type == SEGMENT_TYPE_FMP4) && (en == vs->segments)) {
  1103. ff_hls_write_init_file(hls->m3u8_out, vs->fmp4_init_filename,
  1104. hls->flags & HLS_SINGLE_FILE, en->size, en->pos);
  1105. }
  1106. ret = ff_hls_write_file_entry(hls->m3u8_out, en->discont, byterange_mode,
  1107. en->duration, hls->flags & HLS_ROUND_DURATIONS,
  1108. en->size, en->pos, vs->baseurl,
  1109. en->filename, prog_date_time_p);
  1110. if (ret < 0) {
  1111. av_log(s, AV_LOG_WARNING, "ff_hls_write_file_entry get error\n");
  1112. }
  1113. }
  1114. if (last && (hls->flags & HLS_OMIT_ENDLIST)==0)
  1115. ff_hls_write_end_list(hls->m3u8_out);
  1116. if( vs->vtt_m3u8_name ) {
  1117. if ((ret = hlsenc_io_open(s, &hls->sub_m3u8_out, vs->vtt_m3u8_name, &options)) < 0)
  1118. goto fail;
  1119. ff_hls_write_playlist_header(hls->sub_m3u8_out, hls->version, hls->allowcache,
  1120. target_duration, sequence, PLAYLIST_TYPE_NONE);
  1121. for (en = vs->segments; en; en = en->next) {
  1122. ret = ff_hls_write_file_entry(hls->sub_m3u8_out, 0, byterange_mode,
  1123. en->duration, 0, en->size, en->pos,
  1124. vs->baseurl, en->sub_filename, NULL);
  1125. if (ret < 0) {
  1126. av_log(s, AV_LOG_WARNING, "ff_hls_write_file_entry get error\n");
  1127. }
  1128. }
  1129. if (last)
  1130. ff_hls_write_end_list(hls->sub_m3u8_out);
  1131. }
  1132. fail:
  1133. av_dict_free(&options);
  1134. hlsenc_io_close(s, &hls->m3u8_out, temp_filename);
  1135. hlsenc_io_close(s, &hls->sub_m3u8_out, vs->vtt_m3u8_name);
  1136. if (ret >= 0 && use_rename)
  1137. ff_rename(temp_filename, vs->m3u8_name, s);
  1138. if (ret >= 0 && hls->master_pl_name)
  1139. if (create_master_playlist(s, vs) < 0)
  1140. av_log(s, AV_LOG_WARNING, "Master playlist creation failed\n");
  1141. return ret;
  1142. }
  1143. static int hls_start(AVFormatContext *s, VariantStream *vs)
  1144. {
  1145. HLSContext *c = s->priv_data;
  1146. AVFormatContext *oc = vs->avf;
  1147. AVFormatContext *vtt_oc = vs->vtt_avf;
  1148. AVDictionary *options = NULL;
  1149. char *filename, iv_string[KEYSIZE*2 + 1];
  1150. int err = 0;
  1151. if (c->flags & HLS_SINGLE_FILE) {
  1152. av_strlcpy(oc->filename, vs->basename,
  1153. sizeof(oc->filename));
  1154. if (vs->vtt_basename)
  1155. av_strlcpy(vtt_oc->filename, vs->vtt_basename,
  1156. sizeof(vtt_oc->filename));
  1157. } else if (c->max_seg_size > 0) {
  1158. if (replace_int_data_in_filename(oc->filename, sizeof(oc->filename),
  1159. #if FF_API_HLS_WRAP
  1160. vs->basename, 'd', c->wrap ? vs->sequence % c->wrap : vs->sequence) < 1) {
  1161. #else
  1162. vs->basename, 'd', vs->sequence) < 1) {
  1163. #endif
  1164. av_log(oc, AV_LOG_ERROR, "Invalid segment filename template '%s', you can try to use -use_localtime 1 with it\n", vs->basename);
  1165. return AVERROR(EINVAL);
  1166. }
  1167. } else {
  1168. if (c->use_localtime) {
  1169. time_t now0;
  1170. struct tm *tm, tmpbuf;
  1171. time(&now0);
  1172. tm = localtime_r(&now0, &tmpbuf);
  1173. if (!strftime(oc->filename, sizeof(oc->filename), vs->basename, tm)) {
  1174. av_log(oc, AV_LOG_ERROR, "Could not get segment filename with use_localtime\n");
  1175. return AVERROR(EINVAL);
  1176. }
  1177. err = sls_flag_use_localtime_filename(oc, c, vs);
  1178. if (err < 0) {
  1179. return AVERROR(ENOMEM);
  1180. }
  1181. if (c->use_localtime_mkdir) {
  1182. const char *dir;
  1183. char *fn_copy = av_strdup(oc->filename);
  1184. if (!fn_copy) {
  1185. return AVERROR(ENOMEM);
  1186. }
  1187. dir = av_dirname(fn_copy);
  1188. if (mkdir_p(dir) == -1 && errno != EEXIST) {
  1189. av_log(oc, AV_LOG_ERROR, "Could not create directory %s with use_localtime_mkdir\n", dir);
  1190. av_free(fn_copy);
  1191. return AVERROR(errno);
  1192. }
  1193. av_free(fn_copy);
  1194. }
  1195. } else if (replace_int_data_in_filename(oc->filename, sizeof(oc->filename),
  1196. #if FF_API_HLS_WRAP
  1197. vs->basename, 'd', c->wrap ? vs->sequence % c->wrap : vs->sequence) < 1) {
  1198. #else
  1199. vs->basename, 'd', vs->sequence) < 1) {
  1200. #endif
  1201. av_log(oc, AV_LOG_ERROR, "Invalid segment filename template '%s' you can try to use -use_localtime 1 with it\n", vs->basename);
  1202. return AVERROR(EINVAL);
  1203. }
  1204. if( vs->vtt_basename) {
  1205. if (replace_int_data_in_filename(vtt_oc->filename, sizeof(vtt_oc->filename),
  1206. #if FF_API_HLS_WRAP
  1207. vs->vtt_basename, 'd', c->wrap ? vs->sequence % c->wrap : vs->sequence) < 1) {
  1208. #else
  1209. vs->vtt_basename, 'd', vs->sequence) < 1) {
  1210. #endif
  1211. av_log(vtt_oc, AV_LOG_ERROR, "Invalid segment filename template '%s'\n", vs->vtt_basename);
  1212. return AVERROR(EINVAL);
  1213. }
  1214. }
  1215. }
  1216. vs->number++;
  1217. set_http_options(s, &options, c);
  1218. if (c->flags & HLS_TEMP_FILE) {
  1219. av_strlcat(oc->filename, ".tmp", sizeof(oc->filename));
  1220. }
  1221. if (c->key_info_file || c->encrypt) {
  1222. if (c->key_info_file && c->encrypt) {
  1223. av_log(s, AV_LOG_WARNING, "Cannot use both -hls_key_info_file and -hls_enc,"
  1224. " will use -hls_key_info_file priority\n");
  1225. }
  1226. if (!c->encrypt_started || (c->flags & HLS_PERIODIC_REKEY)) {
  1227. if (c->key_info_file) {
  1228. if ((err = hls_encryption_start(s)) < 0)
  1229. goto fail;
  1230. } else {
  1231. if ((err = do_encrypt(s, vs)) < 0)
  1232. goto fail;
  1233. }
  1234. c->encrypt_started = 1;
  1235. }
  1236. if ((err = av_dict_set(&options, "encryption_key", c->key_string, 0))
  1237. < 0)
  1238. goto fail;
  1239. err = av_strlcpy(iv_string, c->iv_string, sizeof(iv_string));
  1240. if (!err)
  1241. snprintf(iv_string, sizeof(iv_string), "%032"PRIx64, vs->sequence);
  1242. if ((err = av_dict_set(&options, "encryption_iv", iv_string, 0)) < 0)
  1243. goto fail;
  1244. filename = av_asprintf("crypto:%s", oc->filename);
  1245. if (!filename) {
  1246. err = AVERROR(ENOMEM);
  1247. goto fail;
  1248. }
  1249. err = hlsenc_io_open(s, &oc->pb, filename, &options);
  1250. av_free(filename);
  1251. av_dict_free(&options);
  1252. if (err < 0)
  1253. return err;
  1254. } else if (c->segment_type != SEGMENT_TYPE_FMP4) {
  1255. if ((err = hlsenc_io_open(s, &oc->pb, oc->filename, &options)) < 0)
  1256. goto fail;
  1257. }
  1258. if (vs->vtt_basename) {
  1259. set_http_options(s, &options, c);
  1260. if ((err = hlsenc_io_open(s, &vtt_oc->pb, vtt_oc->filename, &options)) < 0)
  1261. goto fail;
  1262. }
  1263. av_dict_free(&options);
  1264. if (c->segment_type != SEGMENT_TYPE_FMP4) {
  1265. /* We only require one PAT/PMT per segment. */
  1266. if (oc->oformat->priv_class && oc->priv_data) {
  1267. char period[21];
  1268. snprintf(period, sizeof(period), "%d", (INT_MAX / 2) - 1);
  1269. av_opt_set(oc->priv_data, "mpegts_flags", "resend_headers", 0);
  1270. av_opt_set(oc->priv_data, "sdt_period", period, 0);
  1271. av_opt_set(oc->priv_data, "pat_period", period, 0);
  1272. }
  1273. }
  1274. if (vs->vtt_basename) {
  1275. err = avformat_write_header(vtt_oc,NULL);
  1276. if (err < 0)
  1277. return err;
  1278. }
  1279. return 0;
  1280. fail:
  1281. av_dict_free(&options);
  1282. return err;
  1283. }
  1284. static const char * get_default_pattern_localtime_fmt(AVFormatContext *s)
  1285. {
  1286. char b[21];
  1287. time_t t = time(NULL);
  1288. struct tm *p, tmbuf;
  1289. HLSContext *hls = s->priv_data;
  1290. p = localtime_r(&t, &tmbuf);
  1291. // no %s support when strftime returned error or left format string unchanged
  1292. // also no %s support on MSVC, which invokes the invalid parameter handler on unsupported format strings, instead of returning an error
  1293. if (hls->segment_type == SEGMENT_TYPE_FMP4) {
  1294. return (HAVE_LIBC_MSVCRT || !strftime(b, sizeof(b), "%s", p) || !strcmp(b, "%s")) ? "-%Y%m%d%H%M%S.m4s" : "-%s.m4s";
  1295. }
  1296. return (HAVE_LIBC_MSVCRT || !strftime(b, sizeof(b), "%s", p) || !strcmp(b, "%s")) ? "-%Y%m%d%H%M%S.ts" : "-%s.ts";
  1297. }
  1298. static int format_name(char *name, int name_buf_len, int i)
  1299. {
  1300. char *p;
  1301. char extension[10] = {'\0'};
  1302. p = strrchr(name, '.');
  1303. if (p) {
  1304. av_strlcpy(extension, p, sizeof(extension));
  1305. *p = '\0';
  1306. }
  1307. snprintf(name + strlen(name), name_buf_len - strlen(name), POSTFIX_PATTERN, i);
  1308. if (strlen(extension))
  1309. av_strlcat(name, extension, name_buf_len);
  1310. return 0;
  1311. }
  1312. static int get_nth_codec_stream_index(AVFormatContext *s,
  1313. enum AVMediaType codec_type,
  1314. int stream_id)
  1315. {
  1316. unsigned int stream_index, cnt;
  1317. if (stream_id < 0 || stream_id > s->nb_streams - 1)
  1318. return -1;
  1319. cnt = 0;
  1320. for (stream_index = 0; stream_index < s->nb_streams; stream_index++) {
  1321. if (s->streams[stream_index]->codecpar->codec_type != codec_type)
  1322. continue;
  1323. if (cnt == stream_id)
  1324. return stream_index;
  1325. cnt++;
  1326. }
  1327. return -1;
  1328. }
  1329. static int parse_variant_stream_mapstring(AVFormatContext *s)
  1330. {
  1331. HLSContext *hls = s->priv_data;
  1332. VariantStream *vs;
  1333. int stream_index;
  1334. enum AVMediaType codec_type;
  1335. int nb_varstreams, nb_streams;
  1336. char *p, *q, *saveptr1, *saveptr2, *varstr, *keyval;
  1337. const char *val;
  1338. /**
  1339. * Expected format for var_stream_map string is as below:
  1340. * "a:0,v:0 a:1,v:1"
  1341. * This string specifies how to group the audio, video and subtitle streams
  1342. * into different variant streams. The variant stream groups are separated
  1343. * by space.
  1344. *
  1345. * a:, v:, s: are keys to specify audio, video and subtitle streams
  1346. * respectively. Allowed values are 0 to 9 digits (limited just based on
  1347. * practical usage)
  1348. *
  1349. */
  1350. p = av_strdup(hls->var_stream_map);
  1351. q = p;
  1352. while(av_strtok(q, " \t", &saveptr1)) {
  1353. q = NULL;
  1354. hls->nb_varstreams++;
  1355. }
  1356. av_freep(&p);
  1357. hls->var_streams = av_mallocz(sizeof(*hls->var_streams) * hls->nb_varstreams);
  1358. if (!hls->var_streams)
  1359. return AVERROR(ENOMEM);
  1360. p = hls->var_stream_map;
  1361. nb_varstreams = 0;
  1362. while (varstr = av_strtok(p, " \t", &saveptr1)) {
  1363. p = NULL;
  1364. if (nb_varstreams < hls->nb_varstreams)
  1365. vs = &(hls->var_streams[nb_varstreams++]);
  1366. else
  1367. return AVERROR(EINVAL);
  1368. q = varstr;
  1369. while (q < varstr + strlen(varstr)) {
  1370. if (!av_strncasecmp(q, "a:", 2) || !av_strncasecmp(q, "v:", 2) ||
  1371. !av_strncasecmp(q, "s:", 2))
  1372. vs->nb_streams++;
  1373. q++;
  1374. }
  1375. vs->streams = av_mallocz(sizeof(AVStream *) * vs->nb_streams);
  1376. if (!vs->streams)
  1377. return AVERROR(ENOMEM);
  1378. nb_streams = 0;
  1379. while (keyval = av_strtok(varstr, ",", &saveptr2)) {
  1380. varstr = NULL;
  1381. if (av_strstart(keyval, "v:", &val)) {
  1382. codec_type = AVMEDIA_TYPE_VIDEO;
  1383. } else if (av_strstart(keyval, "a:", &val)) {
  1384. codec_type = AVMEDIA_TYPE_AUDIO;
  1385. } else if (av_strstart(keyval, "s:", &val)) {
  1386. codec_type = AVMEDIA_TYPE_SUBTITLE;
  1387. } else {
  1388. av_log(s, AV_LOG_ERROR, "Invalid keyval %s\n", keyval);
  1389. return AVERROR(EINVAL);
  1390. }
  1391. stream_index = -1;
  1392. if (av_isdigit(*val))
  1393. stream_index = get_nth_codec_stream_index (s, codec_type,
  1394. atoi(val));
  1395. if (stream_index >= 0 && nb_streams < vs->nb_streams) {
  1396. vs->streams[nb_streams++] = s->streams[stream_index];
  1397. } else {
  1398. av_log(s, AV_LOG_ERROR, "Unable to map stream at %s\n", keyval);
  1399. return AVERROR(EINVAL);
  1400. }
  1401. }
  1402. }
  1403. av_log(s, AV_LOG_DEBUG, "Number of variant streams %d\n",
  1404. hls->nb_varstreams);
  1405. return 0;
  1406. }
  1407. static int update_variant_stream_info(AVFormatContext *s) {
  1408. HLSContext *hls = s->priv_data;
  1409. unsigned int i;
  1410. if (hls->var_stream_map) {
  1411. return parse_variant_stream_mapstring(s);
  1412. } else {
  1413. //By default, a single variant stream with all the codec streams is created
  1414. hls->nb_varstreams = 1;
  1415. hls->var_streams = av_mallocz(sizeof(*hls->var_streams) *
  1416. hls->nb_varstreams);
  1417. if (!hls->var_streams)
  1418. return AVERROR(ENOMEM);
  1419. hls->var_streams[0].nb_streams = s->nb_streams;
  1420. hls->var_streams[0].streams = av_mallocz(sizeof(AVStream *) *
  1421. hls->var_streams[0].nb_streams);
  1422. if (!hls->var_streams[0].streams)
  1423. return AVERROR(ENOMEM);
  1424. for (i = 0; i < s->nb_streams; i++)
  1425. hls->var_streams[0].streams[i] = s->streams[i];
  1426. }
  1427. return 0;
  1428. }
  1429. static int update_master_pl_info(AVFormatContext *s) {
  1430. HLSContext *hls = s->priv_data;
  1431. int m3u8_name_size, ret;
  1432. char *p;
  1433. m3u8_name_size = strlen(s->filename) + strlen(hls->master_pl_name) + 1;
  1434. hls->master_m3u8_url = av_malloc(m3u8_name_size);
  1435. if (!hls->master_m3u8_url) {
  1436. ret = AVERROR(ENOMEM);
  1437. return ret;
  1438. }
  1439. av_strlcpy(hls->master_m3u8_url, s->filename, m3u8_name_size);
  1440. p = strrchr(hls->master_m3u8_url, '/') ?
  1441. strrchr(hls->master_m3u8_url, '/') :
  1442. strrchr(hls->master_m3u8_url, '\\');
  1443. if (p) {
  1444. *(p + 1) = '\0';
  1445. av_strlcat(hls->master_m3u8_url, hls->master_pl_name, m3u8_name_size);
  1446. } else {
  1447. av_strlcpy(hls->master_m3u8_url, hls->master_pl_name, m3u8_name_size);
  1448. }
  1449. return 0;
  1450. }
  1451. static int hls_write_header(AVFormatContext *s)
  1452. {
  1453. HLSContext *hls = s->priv_data;
  1454. int ret, i, j;
  1455. AVDictionary *options = NULL;
  1456. VariantStream *vs = NULL;
  1457. for (i = 0; i < hls->nb_varstreams; i++) {
  1458. vs = &hls->var_streams[i];
  1459. av_dict_copy(&options, hls->format_options, 0);
  1460. ret = avformat_write_header(vs->avf, &options);
  1461. if (av_dict_count(options)) {
  1462. av_log(s, AV_LOG_ERROR, "Some of provided format options in '%s' are not recognized\n", hls->format_options_str);
  1463. ret = AVERROR(EINVAL);
  1464. av_dict_free(&options);
  1465. goto fail;
  1466. }
  1467. av_dict_free(&options);
  1468. //av_assert0(s->nb_streams == hls->avf->nb_streams);
  1469. for (j = 0; j < vs->nb_streams; j++) {
  1470. AVStream *inner_st;
  1471. AVStream *outer_st = vs->streams[j];
  1472. if (hls->max_seg_size > 0) {
  1473. if ((outer_st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) &&
  1474. (outer_st->codecpar->bit_rate > hls->max_seg_size)) {
  1475. av_log(s, AV_LOG_WARNING, "Your video bitrate is bigger than hls_segment_size, "
  1476. "(%"PRId64 " > %"PRId64 "), the result maybe not be what you want.",
  1477. outer_st->codecpar->bit_rate, hls->max_seg_size);
  1478. }
  1479. }
  1480. if (outer_st->codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE)
  1481. inner_st = vs->avf->streams[j];
  1482. else if (vs->vtt_avf)
  1483. inner_st = vs->vtt_avf->streams[0];
  1484. else {
  1485. /* We have a subtitle stream, when the user does not want one */
  1486. inner_st = NULL;
  1487. continue;
  1488. }
  1489. avpriv_set_pts_info(outer_st, inner_st->pts_wrap_bits, inner_st->time_base.num, inner_st->time_base.den);
  1490. }
  1491. }
  1492. fail:
  1493. return ret;
  1494. }
  1495. static int hls_write_packet(AVFormatContext *s, AVPacket *pkt)
  1496. {
  1497. HLSContext *hls = s->priv_data;
  1498. AVFormatContext *oc = NULL;
  1499. AVStream *st = s->streams[pkt->stream_index];
  1500. int64_t end_pts = 0;
  1501. int is_ref_pkt = 1;
  1502. int ret = 0, can_split = 1, i, j;
  1503. int stream_index = 0;
  1504. int range_length = 0;
  1505. uint8_t *buffer = NULL;
  1506. VariantStream *vs = NULL;
  1507. for (i = 0; i < hls->nb_varstreams; i++) {
  1508. vs = &hls->var_streams[i];
  1509. for (j = 0; j < vs->nb_streams; j++) {
  1510. if (vs->streams[j] == st) {
  1511. if( st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE ) {
  1512. oc = vs->vtt_avf;
  1513. stream_index = 0;
  1514. } else {
  1515. oc = vs->avf;
  1516. stream_index = j;
  1517. }
  1518. break;
  1519. }
  1520. }
  1521. if (oc)
  1522. break;
  1523. }
  1524. if (!oc) {
  1525. av_log(s, AV_LOG_ERROR, "Unable to find mapping variant stream\n");
  1526. return AVERROR(ENOMEM);
  1527. }
  1528. end_pts = hls->recording_time * vs->number;
  1529. if (vs->sequence - vs->nb_entries > hls->start_sequence && hls->init_time > 0) {
  1530. /* reset end_pts, hls->recording_time at end of the init hls list */
  1531. int init_list_dur = hls->init_time * vs->nb_entries * AV_TIME_BASE;
  1532. int after_init_list_dur = (vs->sequence - vs->nb_entries ) * hls->time * AV_TIME_BASE;
  1533. hls->recording_time = hls->time * AV_TIME_BASE;
  1534. end_pts = init_list_dur + after_init_list_dur ;
  1535. }
  1536. if (vs->start_pts == AV_NOPTS_VALUE) {
  1537. vs->start_pts = pkt->pts;
  1538. }
  1539. if (vs->has_video) {
  1540. can_split = st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
  1541. ((pkt->flags & AV_PKT_FLAG_KEY) || (hls->flags & HLS_SPLIT_BY_TIME));
  1542. is_ref_pkt = st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO;
  1543. }
  1544. if (pkt->pts == AV_NOPTS_VALUE)
  1545. is_ref_pkt = can_split = 0;
  1546. if (is_ref_pkt) {
  1547. if (vs->end_pts == AV_NOPTS_VALUE)
  1548. vs->end_pts = pkt->pts;
  1549. if (vs->new_start) {
  1550. vs->new_start = 0;
  1551. vs->duration = (double)(pkt->pts - vs->end_pts)
  1552. * st->time_base.num / st->time_base.den;
  1553. vs->dpp = (double)(pkt->duration) * st->time_base.num / st->time_base.den;
  1554. } else {
  1555. if (pkt->duration) {
  1556. vs->duration += (double)(pkt->duration) * st->time_base.num / st->time_base.den;
  1557. } else {
  1558. av_log(s, AV_LOG_WARNING, "pkt->duration = 0, maybe the hls segment duration will not precise\n");
  1559. vs->duration = (double)(pkt->pts - vs->end_pts) * st->time_base.num / st->time_base.den;
  1560. }
  1561. }
  1562. }
  1563. if (vs->packets_written && can_split && av_compare_ts(pkt->pts - vs->start_pts, st->time_base,
  1564. end_pts, AV_TIME_BASE_Q) >= 0) {
  1565. int64_t new_start_pos;
  1566. char *old_filename = av_strdup(vs->avf->filename);
  1567. int byterange_mode = (hls->flags & HLS_SINGLE_FILE) || (hls->max_seg_size > 0);
  1568. if (!old_filename) {
  1569. return AVERROR(ENOMEM);
  1570. }
  1571. av_write_frame(vs->avf, NULL); /* Flush any buffered data */
  1572. new_start_pos = avio_tell(vs->avf->pb);
  1573. vs->size = new_start_pos - vs->start_pos;
  1574. if (!byterange_mode) {
  1575. if (hls->segment_type == SEGMENT_TYPE_FMP4) {
  1576. if (!vs->init_range_length) {
  1577. avio_flush(oc->pb);
  1578. range_length = avio_close_dyn_buf(oc->pb, &buffer);
  1579. avio_write(vs->out, buffer, range_length);
  1580. vs->init_range_length = range_length;
  1581. avio_open_dyn_buf(&oc->pb);
  1582. vs->packets_written = 0;
  1583. ff_format_io_close(s, &vs->out);
  1584. hlsenc_io_close(s, &vs->out, vs->base_output_dirname);
  1585. }
  1586. } else {
  1587. hlsenc_io_close(s, &oc->pb, oc->filename);
  1588. }
  1589. if (vs->vtt_avf) {
  1590. hlsenc_io_close(s, &vs->vtt_avf->pb, vs->vtt_avf->filename);
  1591. }
  1592. }
  1593. if ((hls->flags & HLS_TEMP_FILE) && oc->filename[0]) {
  1594. if (!(hls->flags & HLS_SINGLE_FILE) || (hls->max_seg_size <= 0))
  1595. if ((vs->avf->oformat->priv_class && vs->avf->priv_data) && hls->segment_type != SEGMENT_TYPE_FMP4)
  1596. av_opt_set(vs->avf->priv_data, "mpegts_flags", "resend_headers", 0);
  1597. hls_rename_temp_file(s, oc);
  1598. }
  1599. if (vs->fmp4_init_mode) {
  1600. vs->number--;
  1601. }
  1602. if (hls->segment_type == SEGMENT_TYPE_FMP4) {
  1603. ret = hlsenc_io_open(s, &vs->out, vs->avf->filename, NULL);
  1604. if (ret < 0) {
  1605. av_log(NULL, AV_LOG_ERROR, "Failed to open file '%s'\n",
  1606. vs->avf->filename);
  1607. return ret;
  1608. }
  1609. write_styp(vs->out);
  1610. ret = flush_dynbuf(vs, &range_length);
  1611. if (ret < 0) {
  1612. return ret;
  1613. }
  1614. ff_format_io_close(s, &vs->out);
  1615. }
  1616. ret = hls_append_segment(s, hls, vs, vs->duration, vs->start_pos, vs->size);
  1617. vs->start_pos = new_start_pos;
  1618. if (ret < 0) {
  1619. av_free(old_filename);
  1620. return ret;
  1621. }
  1622. vs->end_pts = pkt->pts;
  1623. vs->duration = 0;
  1624. vs->fmp4_init_mode = 0;
  1625. if (hls->flags & HLS_SINGLE_FILE) {
  1626. vs->number++;
  1627. } else if (hls->max_seg_size > 0) {
  1628. if (vs->start_pos >= hls->max_seg_size) {
  1629. vs->sequence++;
  1630. sls_flag_file_rename(hls, vs, old_filename);
  1631. ret = hls_start(s, vs);
  1632. vs->start_pos = 0;
  1633. /* When split segment by byte, the duration is short than hls_time,
  1634. * so it is not enough one segment duration as hls_time, */
  1635. vs->number--;
  1636. }
  1637. vs->number++;
  1638. } else {
  1639. sls_flag_file_rename(hls, vs, old_filename);
  1640. ret = hls_start(s, vs);
  1641. }
  1642. av_free(old_filename);
  1643. if (ret < 0) {
  1644. return ret;
  1645. }
  1646. if (!vs->fmp4_init_mode || byterange_mode)
  1647. if ((ret = hls_window(s, 0, vs)) < 0) {
  1648. return ret;
  1649. }
  1650. }
  1651. vs->packets_written++;
  1652. ret = ff_write_chained(oc, stream_index, pkt, s, 0);
  1653. return ret;
  1654. }
  1655. static int hls_write_trailer(struct AVFormatContext *s)
  1656. {
  1657. HLSContext *hls = s->priv_data;
  1658. AVFormatContext *oc = NULL;
  1659. AVFormatContext *vtt_oc = NULL;
  1660. char *old_filename = NULL;
  1661. int i;
  1662. int ret = 0;
  1663. VariantStream *vs = NULL;
  1664. for (i = 0; i < hls->nb_varstreams; i++) {
  1665. vs = &hls->var_streams[i];
  1666. oc = vs->avf;
  1667. vtt_oc = vs->vtt_avf;
  1668. old_filename = av_strdup(vs->avf->filename);
  1669. if (!old_filename) {
  1670. return AVERROR(ENOMEM);
  1671. }
  1672. if ( hls->segment_type == SEGMENT_TYPE_FMP4) {
  1673. int range_length = 0;
  1674. ret = hlsenc_io_open(s, &vs->out, vs->avf->filename, NULL);
  1675. if (ret < 0) {
  1676. av_log(NULL, AV_LOG_ERROR, "Failed to open file '%s'\n", vs->avf->filename);
  1677. return AVERROR(ENOENT);
  1678. }
  1679. write_styp(vs->out);
  1680. ret = flush_dynbuf(vs, &range_length);
  1681. if (ret < 0) {
  1682. return ret;
  1683. }
  1684. ff_format_io_close(s, &vs->out);
  1685. }
  1686. av_write_trailer(oc);
  1687. if (oc->pb) {
  1688. vs->size = avio_tell(vs->avf->pb) - vs->start_pos;
  1689. if (hls->segment_type != SEGMENT_TYPE_FMP4)
  1690. ff_format_io_close(s, &oc->pb);
  1691. if ((hls->flags & HLS_TEMP_FILE) && oc->filename[0]) {
  1692. hls_rename_temp_file(s, oc);
  1693. }
  1694. /* after av_write_trailer, then duration + 1 duration per packet */
  1695. hls_append_segment(s, hls, vs, vs->duration + vs->dpp, vs->start_pos, vs->size);
  1696. }
  1697. sls_flag_file_rename(hls, vs, old_filename);
  1698. if (vtt_oc) {
  1699. if (vtt_oc->pb)
  1700. av_write_trailer(vtt_oc);
  1701. vs->size = avio_tell(vs->vtt_avf->pb) - vs->start_pos;
  1702. ff_format_io_close(s, &vtt_oc->pb);
  1703. }
  1704. av_freep(&vs->basename);
  1705. av_freep(&vs->base_output_dirname);
  1706. avformat_free_context(oc);
  1707. vs->avf = NULL;
  1708. hls_window(s, 1, vs);
  1709. av_freep(&vs->fmp4_init_filename);
  1710. if (vtt_oc) {
  1711. av_freep(&vs->vtt_basename);
  1712. av_freep(&vs->vtt_m3u8_name);
  1713. avformat_free_context(vtt_oc);
  1714. }
  1715. hls_free_segments(vs->segments);
  1716. hls_free_segments(vs->old_segments);
  1717. av_free(old_filename);
  1718. av_freep(&vs->m3u8_name);
  1719. av_freep(&vs->streams);
  1720. av_freep(&vs->baseurl);
  1721. }
  1722. av_freep(&hls->key_basename);
  1723. av_freep(&hls->var_streams);
  1724. av_freep(&hls->master_m3u8_url);
  1725. return 0;
  1726. }
  1727. static int hls_init(AVFormatContext *s)
  1728. {
  1729. int ret = 0;
  1730. int i = 0;
  1731. int j = 0;
  1732. HLSContext *hls = s->priv_data;
  1733. const char *pattern = "%d.ts";
  1734. VariantStream *vs = NULL;
  1735. int basename_size = 0;
  1736. const char *pattern_localtime_fmt = get_default_pattern_localtime_fmt(s);
  1737. const char *vtt_pattern = "%d.vtt";
  1738. char *p = NULL;
  1739. int vtt_basename_size = 0, m3u8_name_size = 0;
  1740. int fmp4_init_filename_len = strlen(hls->fmp4_init_filename) + 1;
  1741. ret = update_variant_stream_info(s);
  1742. if (ret < 0) {
  1743. av_log(s, AV_LOG_ERROR, "Variant stream info update failed with status %x\n",
  1744. ret);
  1745. goto fail;
  1746. }
  1747. //TODO: Updates needed to encryption functionality with periodic re-key when more than one variant streams are present
  1748. if (hls->nb_varstreams > 1 && hls->flags & HLS_PERIODIC_REKEY) {
  1749. ret = AVERROR(EINVAL);
  1750. av_log(s, AV_LOG_ERROR, "Periodic re-key not supported when more than one variant streams are present\n");
  1751. goto fail;
  1752. }
  1753. if (hls->master_pl_name) {
  1754. ret = update_master_pl_info(s);
  1755. if (ret < 0) {
  1756. av_log(s, AV_LOG_ERROR, "Master stream info update failed with status %x\n",
  1757. ret);
  1758. goto fail;
  1759. }
  1760. }
  1761. if (hls->segment_type == SEGMENT_TYPE_FMP4) {
  1762. pattern = "%d.m4s";
  1763. }
  1764. if ((hls->start_sequence_source_type == HLS_START_SEQUENCE_AS_SECONDS_SINCE_EPOCH) ||
  1765. (hls->start_sequence_source_type == HLS_START_SEQUENCE_AS_FORMATTED_DATETIME)) {
  1766. time_t t = time(NULL); // we will need it in either case
  1767. if (hls->start_sequence_source_type == HLS_START_SEQUENCE_AS_SECONDS_SINCE_EPOCH) {
  1768. hls->start_sequence = (int64_t)t;
  1769. } else if (hls->start_sequence_source_type == HLS_START_SEQUENCE_AS_FORMATTED_DATETIME) {
  1770. char b[15];
  1771. struct tm *p, tmbuf;
  1772. if (!(p = localtime_r(&t, &tmbuf)))
  1773. return AVERROR(ENOMEM);
  1774. if (!strftime(b, sizeof(b), "%Y%m%d%H%M%S", p))
  1775. return AVERROR(ENOMEM);
  1776. hls->start_sequence = strtoll(b, NULL, 10);
  1777. }
  1778. av_log(hls, AV_LOG_DEBUG, "start_number evaluated to %"PRId64"\n", hls->start_sequence);
  1779. }
  1780. hls->recording_time = (hls->init_time ? hls->init_time : hls->time) * AV_TIME_BASE;
  1781. for (i = 0; i < hls->nb_varstreams; i++) {
  1782. vs = &hls->var_streams[i];
  1783. vs->sequence = hls->start_sequence;
  1784. vs->start_pts = AV_NOPTS_VALUE;
  1785. vs->end_pts = AV_NOPTS_VALUE;
  1786. vs->current_segment_final_filename_fmt[0] = '\0';
  1787. if (hls->flags & HLS_SPLIT_BY_TIME && hls->flags & HLS_INDEPENDENT_SEGMENTS) {
  1788. // Independent segments cannot be guaranteed when splitting by time
  1789. hls->flags &= ~HLS_INDEPENDENT_SEGMENTS;
  1790. av_log(s, AV_LOG_WARNING,
  1791. "'split_by_time' and 'independent_segments' cannot be enabled together. "
  1792. "Disabling 'independent_segments' flag\n");
  1793. }
  1794. if (hls->flags & HLS_PROGRAM_DATE_TIME) {
  1795. time_t now0;
  1796. time(&now0);
  1797. vs->initial_prog_date_time = now0;
  1798. }
  1799. if (hls->format_options_str) {
  1800. ret = av_dict_parse_string(&hls->format_options, hls->format_options_str, "=", ":", 0);
  1801. if (ret < 0) {
  1802. av_log(s, AV_LOG_ERROR, "Could not parse format options list '%s'\n", hls->format_options_str);
  1803. goto fail;
  1804. }
  1805. }
  1806. for (j = 0; j < vs->nb_streams; j++) {
  1807. vs->has_video += vs->streams[j]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO;
  1808. vs->has_subtitle += vs->streams[j]->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE;
  1809. }
  1810. if (vs->has_video > 1)
  1811. av_log(s, AV_LOG_WARNING, "More than a single video stream present, expect issues decoding it.\n");
  1812. if (hls->segment_type == SEGMENT_TYPE_FMP4) {
  1813. vs->oformat = av_guess_format("mp4", NULL, NULL);
  1814. } else {
  1815. vs->oformat = av_guess_format("mpegts", NULL, NULL);
  1816. }
  1817. if (!vs->oformat) {
  1818. ret = AVERROR_MUXER_NOT_FOUND;
  1819. goto fail;
  1820. }
  1821. if (vs->has_subtitle) {
  1822. vs->vtt_oformat = av_guess_format("webvtt", NULL, NULL);
  1823. if (!vs->oformat) {
  1824. ret = AVERROR_MUXER_NOT_FOUND;
  1825. goto fail;
  1826. }
  1827. }
  1828. if (hls->segment_filename) {
  1829. basename_size = strlen(hls->segment_filename) + 1;
  1830. if (hls->nb_varstreams > 1) {
  1831. basename_size += strlen(POSTFIX_PATTERN);
  1832. }
  1833. vs->basename = av_malloc(basename_size);
  1834. if (!vs->basename) {
  1835. ret = AVERROR(ENOMEM);
  1836. goto fail;
  1837. }
  1838. av_strlcpy(vs->basename, hls->segment_filename, basename_size);
  1839. } else {
  1840. if (hls->flags & HLS_SINGLE_FILE) {
  1841. if (hls->segment_type == SEGMENT_TYPE_FMP4) {
  1842. pattern = ".m4s";
  1843. } else {
  1844. pattern = ".ts";
  1845. }
  1846. }
  1847. if (hls->use_localtime) {
  1848. basename_size = strlen(s->filename) + strlen(pattern_localtime_fmt) + 1;
  1849. } else {
  1850. basename_size = strlen(s->filename) + strlen(pattern) + 1;
  1851. }
  1852. if (hls->nb_varstreams > 1) {
  1853. basename_size += strlen(POSTFIX_PATTERN);
  1854. }
  1855. vs->basename = av_malloc(basename_size);
  1856. if (!vs->basename) {
  1857. ret = AVERROR(ENOMEM);
  1858. goto fail;
  1859. }
  1860. av_strlcpy(vs->basename, s->filename, basename_size);
  1861. p = strrchr(vs->basename, '.');
  1862. if (p)
  1863. *p = '\0';
  1864. if (hls->use_localtime) {
  1865. av_strlcat(vs->basename, pattern_localtime_fmt, basename_size);
  1866. } else {
  1867. av_strlcat(vs->basename, pattern, basename_size);
  1868. }
  1869. }
  1870. m3u8_name_size = strlen(s->filename) + 1;
  1871. if (hls->nb_varstreams > 1) {
  1872. m3u8_name_size += strlen(POSTFIX_PATTERN);
  1873. }
  1874. vs->m3u8_name = av_malloc(m3u8_name_size);
  1875. if (!vs->m3u8_name ) {
  1876. ret = AVERROR(ENOMEM);
  1877. goto fail;
  1878. }
  1879. av_strlcpy(vs->m3u8_name, s->filename, m3u8_name_size);
  1880. if (hls->nb_varstreams > 1) {
  1881. ret = format_name(vs->basename, basename_size, i);
  1882. if (ret < 0)
  1883. goto fail;
  1884. ret = format_name(vs->m3u8_name, m3u8_name_size, i);
  1885. if (ret < 0)
  1886. goto fail;
  1887. }
  1888. if (hls->segment_type == SEGMENT_TYPE_FMP4) {
  1889. if (hls->nb_varstreams > 1)
  1890. fmp4_init_filename_len += strlen(POSTFIX_PATTERN);
  1891. vs->fmp4_init_filename = av_malloc(fmp4_init_filename_len);
  1892. if (!vs->fmp4_init_filename ) {
  1893. ret = AVERROR(ENOMEM);
  1894. goto fail;
  1895. }
  1896. av_strlcpy(vs->fmp4_init_filename, hls->fmp4_init_filename,
  1897. fmp4_init_filename_len);
  1898. if (hls->nb_varstreams > 1) {
  1899. ret = format_name(vs->fmp4_init_filename, fmp4_init_filename_len, i);
  1900. if (ret < 0)
  1901. goto fail;
  1902. }
  1903. if (av_strcasecmp(hls->fmp4_init_filename, "init.mp4")) {
  1904. fmp4_init_filename_len = strlen(vs->fmp4_init_filename) + 1;
  1905. vs->base_output_dirname = av_malloc(fmp4_init_filename_len);
  1906. if (!vs->base_output_dirname) {
  1907. ret = AVERROR(ENOMEM);
  1908. goto fail;
  1909. }
  1910. av_strlcpy(vs->base_output_dirname, vs->fmp4_init_filename,
  1911. fmp4_init_filename_len);
  1912. } else {
  1913. fmp4_init_filename_len = strlen(vs->m3u8_name) +
  1914. strlen(vs->fmp4_init_filename) + 1;
  1915. vs->base_output_dirname = av_malloc(fmp4_init_filename_len);
  1916. if (!vs->base_output_dirname) {
  1917. ret = AVERROR(ENOMEM);
  1918. goto fail;
  1919. }
  1920. av_strlcpy(vs->base_output_dirname, vs->m3u8_name,
  1921. fmp4_init_filename_len);
  1922. p = strrchr(vs->base_output_dirname, '/');
  1923. if (p) {
  1924. *(p + 1) = '\0';
  1925. av_strlcat(vs->base_output_dirname, vs->fmp4_init_filename,
  1926. fmp4_init_filename_len);
  1927. } else {
  1928. av_strlcpy(vs->base_output_dirname, vs->fmp4_init_filename,
  1929. fmp4_init_filename_len);
  1930. }
  1931. }
  1932. }
  1933. if (!hls->use_localtime) {
  1934. ret = sls_flag_check_duration_size_index(hls);
  1935. if (ret < 0) {
  1936. goto fail;
  1937. }
  1938. } else {
  1939. ret = sls_flag_check_duration_size(hls, vs);
  1940. if (ret < 0) {
  1941. goto fail;
  1942. }
  1943. }
  1944. if (vs->has_subtitle) {
  1945. if (hls->flags & HLS_SINGLE_FILE)
  1946. vtt_pattern = ".vtt";
  1947. vtt_basename_size = strlen(s->filename) + strlen(vtt_pattern) + 1;
  1948. if (hls->nb_varstreams > 1) {
  1949. vtt_basename_size += strlen(POSTFIX_PATTERN);
  1950. }
  1951. vs->vtt_basename = av_malloc(vtt_basename_size);
  1952. if (!vs->vtt_basename) {
  1953. ret = AVERROR(ENOMEM);
  1954. goto fail;
  1955. }
  1956. vs->vtt_m3u8_name = av_malloc(vtt_basename_size);
  1957. if (!vs->vtt_m3u8_name ) {
  1958. ret = AVERROR(ENOMEM);
  1959. goto fail;
  1960. }
  1961. av_strlcpy(vs->vtt_basename, s->filename, vtt_basename_size);
  1962. p = strrchr(vs->vtt_basename, '.');
  1963. if (p)
  1964. *p = '\0';
  1965. if ( hls->subtitle_filename ) {
  1966. strcpy(vs->vtt_m3u8_name, hls->subtitle_filename);
  1967. } else {
  1968. strcpy(vs->vtt_m3u8_name, vs->vtt_basename);
  1969. av_strlcat(vs->vtt_m3u8_name, "_vtt.m3u8", vtt_basename_size);
  1970. }
  1971. av_strlcat(vs->vtt_basename, vtt_pattern, vtt_basename_size);
  1972. if (hls->nb_varstreams > 1) {
  1973. ret= format_name(vs->vtt_basename, vtt_basename_size, i);
  1974. if (ret < 0)
  1975. goto fail;
  1976. ret = format_name(vs->vtt_m3u8_name, vtt_basename_size, i);
  1977. if (ret < 0)
  1978. goto fail;
  1979. }
  1980. }
  1981. if (hls->baseurl) {
  1982. vs->baseurl = av_strdup(hls->baseurl);
  1983. if (!vs->baseurl) {
  1984. ret = AVERROR(ENOMEM);
  1985. goto fail;
  1986. }
  1987. }
  1988. if ((hls->flags & HLS_SINGLE_FILE) && (hls->segment_type == SEGMENT_TYPE_FMP4)) {
  1989. vs->fmp4_init_filename = av_strdup(vs->basename);
  1990. if (!vs->fmp4_init_filename) {
  1991. ret = AVERROR(ENOMEM);
  1992. goto fail;
  1993. }
  1994. }
  1995. if ((ret = hls_mux_init(s, vs)) < 0)
  1996. goto fail;
  1997. if (hls->flags & HLS_APPEND_LIST) {
  1998. parse_playlist(s, vs->m3u8_name, vs);
  1999. vs->discontinuity = 1;
  2000. if (hls->init_time > 0) {
  2001. av_log(s, AV_LOG_WARNING, "append_list mode does not support hls_init_time,"
  2002. " hls_init_time value will have no effect\n");
  2003. hls->init_time = 0;
  2004. hls->recording_time = hls->time * AV_TIME_BASE;
  2005. }
  2006. }
  2007. if ((ret = hls_start(s, vs)) < 0)
  2008. goto fail;
  2009. }
  2010. fail:
  2011. if (ret < 0) {
  2012. av_freep(&hls->key_basename);
  2013. for (i = 0; i < hls->nb_varstreams && hls->var_streams; i++) {
  2014. vs = &hls->var_streams[i];
  2015. av_freep(&vs->basename);
  2016. av_freep(&vs->vtt_basename);
  2017. av_freep(&vs->fmp4_init_filename);
  2018. av_freep(&vs->m3u8_name);
  2019. av_freep(&vs->vtt_m3u8_name);
  2020. av_freep(&vs->streams);
  2021. av_freep(&vs->baseurl);
  2022. if (vs->avf)
  2023. avformat_free_context(vs->avf);
  2024. if (vs->vtt_avf)
  2025. avformat_free_context(vs->vtt_avf);
  2026. }
  2027. av_freep(&hls->var_streams);
  2028. av_freep(&hls->master_m3u8_url);
  2029. }
  2030. return ret;
  2031. }
  2032. #define OFFSET(x) offsetof(HLSContext, x)
  2033. #define E AV_OPT_FLAG_ENCODING_PARAM
  2034. static const AVOption options[] = {
  2035. {"start_number", "set first number in the sequence", OFFSET(start_sequence),AV_OPT_TYPE_INT64, {.i64 = 0}, 0, INT64_MAX, E},
  2036. {"hls_time", "set segment length in seconds", OFFSET(time), AV_OPT_TYPE_FLOAT, {.dbl = 2}, 0, FLT_MAX, E},
  2037. {"hls_init_time", "set segment length in seconds at init list", OFFSET(init_time), AV_OPT_TYPE_FLOAT, {.dbl = 0}, 0, FLT_MAX, E},
  2038. {"hls_list_size", "set maximum number of playlist entries", OFFSET(max_nb_segments), AV_OPT_TYPE_INT, {.i64 = 5}, 0, INT_MAX, E},
  2039. {"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},
  2040. {"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},
  2041. #if FF_API_HLS_WRAP
  2042. {"hls_wrap", "set number after which the index wraps (will be deprecated)", OFFSET(wrap), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, E},
  2043. #endif
  2044. {"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},
  2045. {"hls_base_url", "url to prepend to each playlist entry", OFFSET(baseurl), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E},
  2046. {"hls_segment_filename", "filename template for segment files", OFFSET(segment_filename), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E},
  2047. {"hls_segment_size", "maximum size per segment file, (in bytes)", OFFSET(max_seg_size), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, E},
  2048. {"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},
  2049. {"hls_enc", "enable AES128 encryption support", OFFSET(encrypt), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, E},
  2050. {"hls_enc_key", "hex-coded 16 byte key to encrypt the segments", OFFSET(key), AV_OPT_TYPE_STRING, .flags = E},
  2051. {"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},
  2052. {"hls_enc_iv", "hex-coded 16 byte initialization vector", OFFSET(iv), AV_OPT_TYPE_STRING, .flags = E},
  2053. {"hls_subtitle_path", "set path of hls subtitles", OFFSET(subtitle_filename), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E},
  2054. {"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"},
  2055. {"mpegts", "make segment file to mpegts files in m3u8", 0, AV_OPT_TYPE_CONST, {.i64 = SEGMENT_TYPE_MPEGTS }, 0, UINT_MAX, E, "segment_type"},
  2056. {"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"},
  2057. {"hls_fmp4_init_filename", "set fragment mp4 file init filename", OFFSET(fmp4_init_filename), AV_OPT_TYPE_STRING, {.str = "init.mp4"}, 0, 0, E},
  2058. {"hls_flags", "set flags affecting HLS playlist and media file generation", OFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64 = 0 }, 0, UINT_MAX, E, "flags"},
  2059. {"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"},
  2060. {"temp_file", "write segment to temporary file and rename when complete", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_TEMP_FILE }, 0, UINT_MAX, E, "flags"},
  2061. {"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"},
  2062. {"round_durations", "round durations in m3u8 to whole numbers", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_ROUND_DURATIONS }, 0, UINT_MAX, E, "flags"},
  2063. {"discont_start", "start the playlist with a discontinuity tag", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_DISCONT_START }, 0, UINT_MAX, E, "flags"},
  2064. {"omit_endlist", "Do not append an endlist when ending stream", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_OMIT_ENDLIST }, 0, UINT_MAX, E, "flags"},
  2065. {"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"},
  2066. {"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"},
  2067. {"program_date_time", "add EXT-X-PROGRAM-DATE-TIME", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_PROGRAM_DATE_TIME }, 0, UINT_MAX, E, "flags"},
  2068. {"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"},
  2069. {"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"},
  2070. {"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"},
  2071. {"periodic_rekey", "reload keyinfo file periodically for re-keying", 0, AV_OPT_TYPE_CONST, {.i64 = HLS_PERIODIC_REKEY }, 0, UINT_MAX, E, "flags"},
  2072. {"independent_segments", "add EXT-X-INDEPENDENT-SEGMENTS, whenever applicable", 0, AV_OPT_TYPE_CONST, { .i64 = HLS_INDEPENDENT_SEGMENTS }, 0, UINT_MAX, E, "flags"},
  2073. {"use_localtime", "set filename expansion with strftime at segment creation", OFFSET(use_localtime), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
  2074. {"use_localtime_mkdir", "create last directory component in strftime-generated filename", OFFSET(use_localtime_mkdir), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
  2075. {"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" },
  2076. {"event", "EVENT playlist", 0, AV_OPT_TYPE_CONST, {.i64 = PLAYLIST_TYPE_EVENT }, INT_MIN, INT_MAX, E, "pl_type" },
  2077. {"vod", "VOD playlist", 0, AV_OPT_TYPE_CONST, {.i64 = PLAYLIST_TYPE_VOD }, INT_MIN, INT_MAX, E, "pl_type" },
  2078. {"method", "set the HTTP method(default: PUT)", OFFSET(method), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E},
  2079. {"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" },
  2080. {"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" },
  2081. {"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" },
  2082. {"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" },
  2083. {"http_user_agent", "override User-Agent field in HTTP header", OFFSET(user_agent), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E},
  2084. {"var_stream_map", "Variant stream map string", OFFSET(var_stream_map), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E},
  2085. {"master_pl_name", "Create HLS master playlist with this name", OFFSET(master_pl_name), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, E},
  2086. {"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},
  2087. {"http_persistent", "Use persistent HTTP connections", OFFSET(http_persistent), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, E },
  2088. { NULL },
  2089. };
  2090. static const AVClass hls_class = {
  2091. .class_name = "hls muxer",
  2092. .item_name = av_default_item_name,
  2093. .option = options,
  2094. .version = LIBAVUTIL_VERSION_INT,
  2095. };
  2096. AVOutputFormat ff_hls_muxer = {
  2097. .name = "hls",
  2098. .long_name = NULL_IF_CONFIG_SMALL("Apple HTTP Live Streaming"),
  2099. .extensions = "m3u8",
  2100. .priv_data_size = sizeof(HLSContext),
  2101. .audio_codec = AV_CODEC_ID_AAC,
  2102. .video_codec = AV_CODEC_ID_H264,
  2103. .subtitle_codec = AV_CODEC_ID_WEBVTT,
  2104. .flags = AVFMT_NOFILE | AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH,
  2105. .init = hls_init,
  2106. .write_header = hls_write_header,
  2107. .write_packet = hls_write_packet,
  2108. .write_trailer = hls_write_trailer,
  2109. .priv_class = &hls_class,
  2110. };