FFmpeg: libavformat/dashdec.c Source File

FFmpeg

[フレーム]

libavformat

dashdec.c

Go to the documentation of this file.

1 /*

2 * Dynamic Adaptive Streaming over HTTP demux

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 <libxml/parser.h>

23 #include "libavutil/intreadwrite.h"

24 #include "libavutil/opt.h"

25 #include "libavutil/time.h"

26 #include "libavutil/parseutils.h"

27 #include "internal.h"

28 #include "avio_internal.h"

29 #include "dash.h"

31 #define INITIAL_BUFFER_SIZE 32768

33 struct fragment {

34 int64_t url_offset;

35 int64_t size;

36 char *url;

37 };

39 /*

40 * reference to : ISO_IEC_23009-1-DASH-2012

41 * Section: 5.3.9.6.2

42 * Table: Table 17 — Semantics of SegmentTimeline element

43 * */

44 struct timeline {

45 /* starttime: Element or Attribute Name

46 * specifies the MPD start time, in @timescale units,

47 * the first Segment in the series starts relative to the beginning of the Period.

48 * The value of this attribute must be equal to or greater than the sum of the previous S

49 * element earliest presentation time and the sum of the contiguous Segment durations.

50 * If the value of the attribute is greater than what is expressed by the previous S element,

51 * it expresses discontinuities in the timeline.

52 * If not present then the value shall be assumed to be zero for the first S element

53 * and for the subsequent S elements, the value shall be assumed to be the sum of

54 * the previous S element's earliest presentation time and contiguous duration

55 * (i.e. previous S@starttime + @duration * (@repeat + 1)).

56 * */

57 int64_t starttime;

58 /* repeat: Element or Attribute Name

59 * specifies the repeat count of the number of following contiguous Segments with

60 * the same duration expressed by the value of @duration. This value is zero-based

61 * (e.g. a value of three means four Segments in the contiguous series).

62 * */

63 int64_t repeat;

64 /* duration: Element or Attribute Name

65 * specifies the Segment duration, in units of the value of the @timescale.

66 * */

67 int64_t duration;

68 };

70 /*

71 * Each playlist has its own demuxer. If it is currently active,

72 * it has an opened AVIOContext too, and potentially an AVPacket

73 * containing the next packet from this stream.

74 */

75 struct representation {

76 char *url_template;

77 AVIOContext pb;

78 AVIOContext *input;

79 AVFormatContext *parent;

80 AVFormatContext *ctx;

81 AVPacket pkt;

82 int rep_idx;

83 int rep_count;

84 int stream_index;

86 enum AVMediaType type;

87 char id[20];

88 int bandwidth;

89 AVRational framerate;

90 AVStream *assoc_stream; /* demuxer stream associated with this representation */

92 int n_fragments;

93 struct fragment **fragments; /* VOD list of fragment for profile */

95 int n_timelines;

96 struct timeline **timelines;

98 int64_t first_seq_no;

99 int64_t last_seq_no;

100 int64_t start_number; /* used in case when we have dynamic list of segment to know which segments are new one*/

101

102 int64_t fragment_duration;

103 int64_t fragment_timescale;

104

105 int64_t presentation_timeoffset;

106

107 int64_t cur_seq_no;

108 int64_t cur_seg_offset;

109 int64_t cur_seg_size;

110 struct fragment *cur_seg;

111

112 /* Currently active Media Initialization Section */

113 struct fragment *init_section;

114 uint8_t *init_sec_buf;

115 uint32_t init_sec_buf_size;

116 uint32_t init_sec_data_len;

117 uint32_t init_sec_buf_read_offset;

118 int64_t cur_timestamp;

119 int is_restart_needed;

120 };

121

122 typedef struct DASHContext {

123 const AVClass *class;

124 char *base_url;

125

126 int n_videos;

127 struct representation **videos;

128 int n_audios;

129 struct representation **audios;

130

131 /* MediaPresentationDescription Attribute */

132 uint64_t media_presentation_duration;

133 uint64_t suggested_presentation_delay;

134 uint64_t availability_start_time;

135 uint64_t publish_time;

136 uint64_t minimum_update_period;

137 uint64_t time_shift_buffer_depth;

138 uint64_t min_buffer_time;

139

140 /* Period Attribute */

141 uint64_t period_duration;

142 uint64_t period_start;

143

144 int is_live;

145 AVIOInterruptCB *interrupt_callback;

146 char *user_agent; ///< holds HTTP user agent set as an AVOption to the HTTP protocol context

147 char *cookies; ///< holds HTTP cookie values set in either the initial response or as an AVOption to the HTTP protocol context

148 char *headers; ///< holds HTTP headers set as an AVOption to the HTTP protocol context

149 char *allowed_extensions;

150 AVDictionary *avio_opts;

151 int max_url_size;

152 } DASHContext;

153

154 static int ishttp(char *url)

155 {

156 const char *proto_name = avio_find_protocol_name(url);

157 return av_strstart(proto_name, "http", NULL);

158 }

159

160 static int aligned(int val)

161 {

162 return ((val + 0x3F) >> 6) << 6;

163 }

164

165 static uint64_t get_current_time_in_sec(void)

166 {

167 return av_gettime() / 1000000;

168 }

169

170 static uint64_t get_utc_date_time_insec(AVFormatContext *s, const char *datetime)

171 {

172 struct tm timeinfo;

173 int year = 0;

174 int month = 0;

175 int day = 0;

176 int hour = 0;

177 int minute = 0;

178 int ret = 0;

179 float second = 0.0;

180

181 /* ISO-8601 date parser */

182 if (!datetime)

183 return 0;

184

185 ret = sscanf(datetime, "%d-%d-%dT%d:%d:%fZ", &year, &month, &day, &hour, &minute, &second);

186 /* year, month, day, hour, minute, second 6 arguments */

187 if (ret != 6) {

188 av_log(s, AV_LOG_WARNING, "get_utc_date_time_insec get a wrong time format\n");

189 }

190 timeinfo.tm_year = year - 1900;

191 timeinfo.tm_mon = month - 1;

192 timeinfo.tm_mday = day;

193 timeinfo.tm_hour = hour;

194 timeinfo.tm_min = minute;

195 timeinfo.tm_sec = (int)second;

196

197 return av_timegm(&timeinfo);

198 }

199

200 static uint32_t get_duration_insec(AVFormatContext *s, const char *duration)

201 {

202 /* ISO-8601 duration parser */

203 uint32_t days = 0;

204 uint32_t hours = 0;

205 uint32_t mins = 0;

206 uint32_t secs = 0;

207 int size = 0;

208 float value = 0;

209 char type = '0円';

210 const char *ptr = duration;

211

212 while (*ptr) {

213 if (*ptr == 'P' || *ptr == 'T') {

214 ptr++;

215 continue;

216 }

217

218 if (sscanf(ptr, "%f%c%n", &value, &type, &size) != 2) {

219 av_log(s, AV_LOG_WARNING, "get_duration_insec get a wrong time format\n");

220 return 0; /* parser error */

221 }

222 switch (type) {

223 case 'D':

224 days = (uint32_t)value;

225 break;

226 case 'H':

227 hours = (uint32_t)value;

228 break;

229 case 'M':

230 mins = (uint32_t)value;

231 break;

232 case 'S':

233 secs = (uint32_t)value;

234 break;

235 default:

236 // handle invalid type

237 break;

238 }

239 ptr += size;

240 }

241 return ((days * 24 + hours) * 60 + mins) * 60 + secs;

242 }

243

244 static int64_t get_segment_start_time_based_on_timeline(struct representation *pls, int64_t cur_seq_no)

245 {

246 int64_t start_time = 0;

247 int64_t i = 0;

248 int64_t j = 0;

249 int64_t num = 0;

250

251 if (pls->n_timelines) {

252 for (i = 0; i < pls->n_timelines; i++) {

253 if (pls->timelines[i]->starttime > 0) {

254 start_time = pls->timelines[i]->starttime;

255 }

256 if (num == cur_seq_no)

257 goto finish;

258

259 start_time += pls->timelines[i]->duration;

260 for (j = 0; j < pls->timelines[i]->repeat; j++) {

261 num++;

262 if (num == cur_seq_no)

263 goto finish;

264 start_time += pls->timelines[i]->duration;

265 }

266 num++;

267 }

268 }

269 finish:

270 return start_time;

271 }

272

273 static int64_t calc_next_seg_no_from_timelines(struct representation *pls, int64_t cur_time)

274 {

275 int64_t i = 0;

276 int64_t j = 0;

277 int64_t num = 0;

278 int64_t start_time = 0;

279

280 for (i = 0; i < pls->n_timelines; i++) {

281 if (pls->timelines[i]->starttime > 0) {

282 start_time = pls->timelines[i]->starttime;

283 }

284 if (start_time > cur_time)

285 goto finish;

286

287 start_time += pls->timelines[i]->duration;

288 for (j = 0; j < pls->timelines[i]->repeat; j++) {

289 num++;

290 if (start_time > cur_time)

291 goto finish;

292 start_time += pls->timelines[i]->duration;

293 }

294 num++;

295 }

296

297 return -1;

298

299 finish:

300 return num;

301 }

302

303 static void free_fragment(struct fragment **seg)

304 {

305 if (!(*seg)) {

306 return;

307 }

308 av_freep(&(*seg)->url);

309 av_freep(seg);

310 }

311

312 static void free_fragment_list(struct representation *pls)

313 {

314 int i;

315

316 for (i = 0; i < pls->n_fragments; i++) {

317 free_fragment(&pls->fragments[i]);

318 }

319 av_freep(&pls->fragments);

320 pls->n_fragments = 0;

321 }

322

323 static void free_timelines_list(struct representation *pls)

324 {

325 int i;

326

327 for (i = 0; i < pls->n_timelines; i++) {

328 av_freep(&pls->timelines[i]);

329 }

330 av_freep(&pls->timelines);

331 pls->n_timelines = 0;

332 }

333

334 static void free_representation(struct representation *pls)

335 {

336 free_fragment_list(pls);

337 free_timelines_list(pls);

338 free_fragment(&pls->cur_seg);

339 free_fragment(&pls->init_section);

340 av_freep(&pls->init_sec_buf);

341 av_freep(&pls->pb.buffer);

342 if (pls->input)

343 ff_format_io_close(pls->parent, &pls->input);

344 if (pls->ctx) {

345 pls->ctx->pb = NULL;

346 avformat_close_input(&pls->ctx);

347 }

348

349 av_freep(&pls->url_template);

350 av_freep(&pls);

351 }

352

353 static void free_video_list(DASHContext *c)

354 {

355 int i;

356 for (i = 0; i < c->n_videos; i++) {

357 struct representation *pls = c->videos[i];

358 free_representation(pls);

359 }

360 av_freep(&c->videos);

361 c->n_videos = 0;

362 }

363

364 static void free_audio_list(DASHContext *c)

365 {

366 int i;

367 for (i = 0; i < c->n_audios; i++) {

368 struct representation *pls = c->audios[i];

369 free_representation(pls);

370 }

371 av_freep(&c->audios);

372 c->n_audios = 0;

373 }

374

375 static void set_httpheader_options(DASHContext *c, AVDictionary **opts)

376 {

377 // broker prior HTTP options that should be consistent across requests

378 av_dict_set(opts, "user-agent", c->user_agent, 0);

379 av_dict_set(opts, "cookies", c->cookies, 0);

380 av_dict_set(opts, "headers", c->headers, 0);

381 if (c->is_live) {

382 av_dict_set(opts, "seekable", "0", 0);

383 }

384 }

385 static void update_options(char **dest, const char *name, void *src)

386 {

387 av_freep(dest);

388 av_opt_get(src, name, AV_OPT_SEARCH_CHILDREN, (uint8_t**)dest);

389 if (*dest)

390 av_freep(dest);

391 }

392

393 static int open_url(AVFormatContext *s, AVIOContext **pb, const char *url,

394 AVDictionary *opts, AVDictionary *opts2, int *is_http)

395 {

396 DASHContext *c = s->priv_data;

397 AVDictionary *tmp = NULL;

398 const char *proto_name = NULL;

399 int ret;

400

401 av_dict_copy(&tmp, opts, 0);

402 av_dict_copy(&tmp, opts2, 0);

403

404 if (av_strstart(url, "crypto", NULL)) {

405 if (url[6] == '+' || url[6] == ':')

406 proto_name = avio_find_protocol_name(url + 7);

407 }

408

409 if (!proto_name)

410 proto_name = avio_find_protocol_name(url);

411

412 if (!proto_name)

413 return AVERROR_INVALIDDATA;

414

415 // only http(s) & file are allowed

416 if (av_strstart(proto_name, "file", NULL)) {

417 if (strcmp(c->allowed_extensions, "ALL") && !av_match_ext(url, c->allowed_extensions)) {

418 av_log(s, AV_LOG_ERROR,

419 "Filename extension of \'%s\' is not a common multimedia extension, blocked for security reasons.\n"

420 "If you wish to override this adjust allowed_extensions, you can set it to \'ALL\' to allow all\n",

421 url);

422 return AVERROR_INVALIDDATA;

423 }

424 } else if (av_strstart(proto_name, "http", NULL)) {

425 ;

426 } else

427 return AVERROR_INVALIDDATA;

428

429 if (!strncmp(proto_name, url, strlen(proto_name)) && url[strlen(proto_name)] == ':')

430 ;

431 else if (av_strstart(url, "crypto", NULL) && !strncmp(proto_name, url + 7, strlen(proto_name)) && url[7 + strlen(proto_name)] == ':')

432 ;

433 else if (strcmp(proto_name, "file") || !strncmp(url, "file,", 5))

434 return AVERROR_INVALIDDATA;

435

436 av_freep(pb);

437 ret = avio_open2(pb, url, AVIO_FLAG_READ, c->interrupt_callback, &tmp);

438 if (ret >= 0) {

439 // update cookies on http response with setcookies.

440 char *new_cookies = NULL;

441

442 if (!(s->flags & AVFMT_FLAG_CUSTOM_IO))

443 av_opt_get(*pb, "cookies", AV_OPT_SEARCH_CHILDREN, (uint8_t**)&new_cookies);

444

445 if (new_cookies) {

446 av_free(c->cookies);

447 c->cookies = new_cookies;

448 }

449

450 av_dict_set(&opts, "cookies", c->cookies, 0);

451 }

452

453 av_dict_free(&tmp);

454

455 if (is_http)

456 *is_http = av_strstart(proto_name, "http", NULL);

457

458 return ret;

459 }

460

461 static char *get_content_url(xmlNodePtr *baseurl_nodes,

462 int n_baseurl_nodes,

463 int max_url_size,

464 char *rep_id_val,

465 char *rep_bandwidth_val,

466 char *val)

467 {

468 int i;

469 char *text;

470 char *url = NULL;

471 char *tmp_str = av_mallocz(max_url_size);

472 char *tmp_str_2 = av_mallocz(max_url_size);

473

474 if (!tmp_str || !tmp_str_2) {

475 return NULL;

476 }

477

478 for (i = 0; i < n_baseurl_nodes; ++i) {

479 if (baseurl_nodes[i] &&

480 baseurl_nodes[i]->children &&

481 baseurl_nodes[i]->children->type == XML_TEXT_NODE) {

482 text = xmlNodeGetContent(baseurl_nodes[i]->children);

483 if (text) {

484 memset(tmp_str, 0, max_url_size);

485 memset(tmp_str_2, 0, max_url_size);

486 ff_make_absolute_url(tmp_str_2, max_url_size, tmp_str, text);

487 av_strlcpy(tmp_str, tmp_str_2, max_url_size);

488 xmlFree(text);

489 }

490 }

491 }

492

493 if (val)

494 av_strlcat(tmp_str, (const char*)val, max_url_size);

495

496 if (rep_id_val) {

497 url = av_strireplace(tmp_str, "$RepresentationID$", (const char*)rep_id_val);

498 if (!url) {

499 goto end;

500 }

501 av_strlcpy(tmp_str, url, max_url_size);

502 }

503 if (rep_bandwidth_val && tmp_str[0] != '0円') {

504 // free any previously assigned url before reassigning

505 av_free(url);

506 url = av_strireplace(tmp_str, "$Bandwidth$", (const char*)rep_bandwidth_val);

507 if (!url) {

508 goto end;

509 }

510 }

511 end:

512 av_free(tmp_str);

513 av_free(tmp_str_2);

514 return url;

515 }

516

517 static char *get_val_from_nodes_tab(xmlNodePtr *nodes, const int n_nodes, const char *attrname)

518 {

519 int i;

520 char *val;

521

522 for (i = 0; i < n_nodes; ++i) {

523 if (nodes[i]) {

524 val = xmlGetProp(nodes[i], attrname);

525 if (val)

526 return val;

527 }

528 }

529

530 return NULL;

531 }

532

533 static xmlNodePtr find_child_node_by_name(xmlNodePtr rootnode, const char *nodename)

534 {

535 xmlNodePtr node = rootnode;

536 if (!node) {

537 return NULL;

538 }

539

540 node = xmlFirstElementChild(node);

541 while (node) {

542 if (!av_strcasecmp(node->name, nodename)) {

543 return node;

544 }

545 node = xmlNextElementSibling(node);

546 }

547 return NULL;

548 }

549

550 static enum AVMediaType get_content_type(xmlNodePtr node)

551 {

552 enum AVMediaType type = AVMEDIA_TYPE_UNKNOWN;

553 int i = 0;

554 const char *attr;

555 char *val = NULL;

556

557 if (node) {

558 for (i = 0; i < 2; i++) {

559 attr = i ? "mimeType" : "contentType";

560 val = xmlGetProp(node, attr);

561 if (val) {

562 if (av_stristr((const char *)val, "video")) {

563 type = AVMEDIA_TYPE_VIDEO;

564 } else if (av_stristr((const char *)val, "audio")) {

565 type = AVMEDIA_TYPE_AUDIO;

566 }

567 xmlFree(val);

568 }

569 }

570 }

571 return type;

572 }

573

574 static struct fragment * get_Fragment(char *range)

575 {

576 struct fragment * seg = av_mallocz(sizeof(struct fragment));

577

578 if (!seg)

579 return NULL;

580

581 seg->size = -1;

582 if (range) {

583 char *str_end_offset;

584 char *str_offset = av_strtok(range, "-", &str_end_offset);

585 seg->url_offset = strtoll(str_offset, NULL, 10);

586 seg->size = strtoll(str_end_offset, NULL, 10) - seg->url_offset;

587 }

588

589 return seg;

590 }

591

592 static int parse_manifest_segmenturlnode(AVFormatContext *s, struct representation *rep,

593 xmlNodePtr fragmenturl_node,

594 xmlNodePtr *baseurl_nodes,

595 char *rep_id_val,

596 char *rep_bandwidth_val)

597 {

598 DASHContext *c = s->priv_data;

599 char *initialization_val = NULL;

600 char *media_val = NULL;

601 char *range_val = NULL;

602 int max_url_size = c ? c->max_url_size: MAX_URL_SIZE;

603

604 if (!av_strcasecmp(fragmenturl_node->name, (const char *)"Initialization")) {

605 initialization_val = xmlGetProp(fragmenturl_node, "sourceURL");

606 range_val = xmlGetProp(fragmenturl_node, "range");

607 if (initialization_val || range_val) {

608 rep->init_section = get_Fragment(range_val);

609 if (!rep->init_section) {

610 xmlFree(initialization_val);

611 xmlFree(range_val);

612 return AVERROR(ENOMEM);

613 }

614 rep->init_section->url = get_content_url(baseurl_nodes, 4,

615 max_url_size,

616 rep_id_val,

617 rep_bandwidth_val,

618 initialization_val);

619

620 if (!rep->init_section->url) {

621 av_free(rep->init_section);

622 xmlFree(initialization_val);

623 xmlFree(range_val);

624 return AVERROR(ENOMEM);

625 }

626 xmlFree(initialization_val);

627 xmlFree(range_val);

628 }

629 } else if (!av_strcasecmp(fragmenturl_node->name, (const char *)"SegmentURL")) {

630 media_val = xmlGetProp(fragmenturl_node, "media");

631 range_val = xmlGetProp(fragmenturl_node, "mediaRange");

632 if (media_val || range_val) {

633 struct fragment *seg = get_Fragment(range_val);

634 if (!seg) {

635 xmlFree(media_val);

636 xmlFree(range_val);

637 return AVERROR(ENOMEM);

638 }

639 seg->url = get_content_url(baseurl_nodes, 4,

640 max_url_size,

641 rep_id_val,

642 rep_bandwidth_val,

643 media_val);

644 if (!seg->url) {

645 av_free(seg);

646 xmlFree(media_val);

647 xmlFree(range_val);

648 return AVERROR(ENOMEM);

649 }

650 dynarray_add(&rep->fragments, &rep->n_fragments, seg);

651 xmlFree(media_val);

652 xmlFree(range_val);

653 }

654 }

655

656 return 0;

657 }

658

659 static int parse_manifest_segmenttimeline(AVFormatContext *s, struct representation *rep,

660 xmlNodePtr fragment_timeline_node)

661 {

662 xmlAttrPtr attr = NULL;

663 char *val = NULL;

664

665 if (!av_strcasecmp(fragment_timeline_node->name, (const char *)"S")) {

666 struct timeline *tml = av_mallocz(sizeof(struct timeline));

667 if (!tml) {

668 return AVERROR(ENOMEM);

669 }

670 attr = fragment_timeline_node->properties;

671 while (attr) {

672 val = xmlGetProp(fragment_timeline_node, attr->name);

673

674 if (!val) {

675 av_log(s, AV_LOG_WARNING, "parse_manifest_segmenttimeline attr->name = %s val is NULL\n", attr->name);

676 continue;

677 }

678

679 if (!av_strcasecmp(attr->name, (const char *)"t")) {

680 tml->starttime = (int64_t)strtoll(val, NULL, 10);

681 } else if (!av_strcasecmp(attr->name, (const char *)"r")) {

682 tml->repeat =(int64_t) strtoll(val, NULL, 10);

683 } else if (!av_strcasecmp(attr->name, (const char *)"d")) {

684 tml->duration = (int64_t)strtoll(val, NULL, 10);

685 }

686 attr = attr->next;

687 xmlFree(val);

688 }

689 dynarray_add(&rep->timelines, &rep->n_timelines, tml);

690 }

691

692 return 0;

693 }

694

695 static int resolve_content_path(AVFormatContext *s, const char *url, int *max_url_size, xmlNodePtr *baseurl_nodes, int n_baseurl_nodes) {

696

697 char *tmp_str = NULL;

698 char *path = NULL;

699 char *mpdName = NULL;

700 xmlNodePtr node = NULL;

701 char *baseurl = NULL;

702 char *root_url = NULL;

703 char *text = NULL;

704

705 int isRootHttp = 0;

706 char token ='/';

707 int start = 0;

708 int rootId = 0;

709 int updated = 0;

710 int size = 0;

711 int i;

712 int tmp_max_url_size = strlen(url);

713

714 for (i = n_baseurl_nodes-1; i >= 0 ; i--) {

715 text = xmlNodeGetContent(baseurl_nodes[i]);

716 if (!text)

717 continue;

718 tmp_max_url_size += strlen(text);

719 if (ishttp(text)) {

720 xmlFree(text);

721 break;

722 }

723 xmlFree(text);

724 }

725

726 tmp_max_url_size = aligned(tmp_max_url_size);

727 text = av_mallocz(tmp_max_url_size);

728 if (!text) {

729 updated = AVERROR(ENOMEM);

730 goto end;

731 }

732 av_strlcpy(text, url, strlen(url)+1);

733 while (mpdName = av_strtok(text, "/", &text)) {

734 size = strlen(mpdName);

735 }

736

737 path = av_mallocz(tmp_max_url_size);

738 tmp_str = av_mallocz(tmp_max_url_size);

739 if (!tmp_str || !path) {

740 updated = AVERROR(ENOMEM);

741 goto end;

742 }

743

744 av_strlcpy (path, url, strlen(url) - size + 1);

745 for (rootId = n_baseurl_nodes - 1; rootId > 0; rootId --) {

746 if (!(node = baseurl_nodes[rootId])) {

747 continue;

748 }

749 if (ishttp(xmlNodeGetContent(node))) {

750 break;

751 }

752 }

753

754 node = baseurl_nodes[rootId];

755 baseurl = xmlNodeGetContent(node);

756 root_url = (av_strcasecmp(baseurl, "")) ? baseurl : path;

757 if (node) {

758 xmlNodeSetContent(node, root_url);

759 updated = 1;

760 }

761

762 size = strlen(root_url);

763 isRootHttp = ishttp(root_url);

764

765 if (root_url[size - 1] != token) {

766 av_strlcat(root_url, "/", size + 2);

767 size += 2;

768 }

769

770 for (i = 0; i < n_baseurl_nodes; ++i) {

771 if (i == rootId) {

772 continue;

773 }

774 text = xmlNodeGetContent(baseurl_nodes[i]);

775 if (text) {

776 memset(tmp_str, 0, strlen(tmp_str));

777 if (!ishttp(text) && isRootHttp) {

778 av_strlcpy(tmp_str, root_url, size + 1);

779 }

780 start = (text[0] == token);

781 av_strlcat(tmp_str, text + start, tmp_max_url_size);

782 xmlNodeSetContent(baseurl_nodes[i], tmp_str);

783 updated = 1;

784 xmlFree(text);

785 }

786 }

787

788 end:

789 if (tmp_max_url_size > *max_url_size) {

790 *max_url_size = tmp_max_url_size;

791 }

792 av_free(path);

793 av_free(tmp_str);

794 return updated;

795

796 }

797

798 static int parse_manifest_representation(AVFormatContext *s, const char *url,

799 xmlNodePtr node,

800 xmlNodePtr adaptionset_node,

801 xmlNodePtr mpd_baseurl_node,

802 xmlNodePtr period_baseurl_node,

803 xmlNodePtr period_segmenttemplate_node,

804 xmlNodePtr period_segmentlist_node,

805 xmlNodePtr fragment_template_node,

806 xmlNodePtr content_component_node,

807 xmlNodePtr adaptionset_baseurl_node,

808 xmlNodePtr adaptionset_segmentlist_node,

809 xmlNodePtr adaptionset_supplementalproperty_node)

810 {

811 int32_t ret = 0;

812 int32_t audio_rep_idx = 0;

813 int32_t video_rep_idx = 0;

814 DASHContext *c = s->priv_data;

815 struct representation *rep = NULL;

816 struct fragment *seg = NULL;

817 xmlNodePtr representation_segmenttemplate_node = NULL;

818 xmlNodePtr representation_baseurl_node = NULL;

819 xmlNodePtr representation_segmentlist_node = NULL;

820 xmlNodePtr segmentlists_tab[2];

821 xmlNodePtr fragment_timeline_node = NULL;

822 xmlNodePtr fragment_templates_tab[5];

823 char *duration_val = NULL;

824 char *presentation_timeoffset_val = NULL;

825 char *startnumber_val = NULL;

826 char *timescale_val = NULL;

827 char *initialization_val = NULL;

828 char *media_val = NULL;

829 char *val = NULL;

830 xmlNodePtr baseurl_nodes[4];

831 xmlNodePtr representation_node = node;

832 char *rep_id_val = xmlGetProp(representation_node, "id");

833 char *rep_bandwidth_val = xmlGetProp(representation_node, "bandwidth");

834 char *rep_framerate_val = xmlGetProp(representation_node, "frameRate");

835 enum AVMediaType type = AVMEDIA_TYPE_UNKNOWN;

836

837 // try get information from representation

838 if (type == AVMEDIA_TYPE_UNKNOWN)

839 type = get_content_type(representation_node);

840 // try get information from contentComponen

841 if (type == AVMEDIA_TYPE_UNKNOWN)

842 type = get_content_type(content_component_node);

843 // try get information from adaption set

844 if (type == AVMEDIA_TYPE_UNKNOWN)

845 type = get_content_type(adaptionset_node);

846 if (type == AVMEDIA_TYPE_UNKNOWN) {

847 av_log(s, AV_LOG_VERBOSE, "Parsing '%s' - skipp not supported representation type\n", url);

848 } else if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO) {

849 // convert selected representation to our internal struct

850 rep = av_mallocz(sizeof(struct representation));

851 if (!rep) {

852 ret = AVERROR(ENOMEM);

853 goto end;

854 }

855 representation_segmenttemplate_node = find_child_node_by_name(representation_node, "SegmentTemplate");

856 representation_baseurl_node = find_child_node_by_name(representation_node, "BaseURL");

857 representation_segmentlist_node = find_child_node_by_name(representation_node, "SegmentList");

858

859 baseurl_nodes[0] = mpd_baseurl_node;

860 baseurl_nodes[1] = period_baseurl_node;

861 baseurl_nodes[2] = adaptionset_baseurl_node;

862 baseurl_nodes[3] = representation_baseurl_node;

863

864 ret = resolve_content_path(s, url, &c->max_url_size, baseurl_nodes, 4);

865 c->max_url_size = aligned(c->max_url_size + strlen(rep_id_val) + strlen(rep_bandwidth_val));

866 if (ret == AVERROR(ENOMEM) || ret == 0) {

867 goto end;

868 }

869 if (representation_segmenttemplate_node || fragment_template_node || period_segmenttemplate_node) {

870 fragment_timeline_node = NULL;

871 fragment_templates_tab[0] = representation_segmenttemplate_node;

872 fragment_templates_tab[1] = adaptionset_segmentlist_node;

873 fragment_templates_tab[2] = fragment_template_node;

874 fragment_templates_tab[3] = period_segmenttemplate_node;

875 fragment_templates_tab[4] = period_segmentlist_node;

876

877 presentation_timeoffset_val = get_val_from_nodes_tab(fragment_templates_tab, 4, "presentationTimeOffset");

878 duration_val = get_val_from_nodes_tab(fragment_templates_tab, 4, "duration");

879 startnumber_val = get_val_from_nodes_tab(fragment_templates_tab, 4, "startNumber");

880 timescale_val = get_val_from_nodes_tab(fragment_templates_tab, 4, "timescale");

881 initialization_val = get_val_from_nodes_tab(fragment_templates_tab, 4, "initialization");

882 media_val = get_val_from_nodes_tab(fragment_templates_tab, 4, "media");

883

884 if (initialization_val) {

885 rep->init_section = av_mallocz(sizeof(struct fragment));

886 if (!rep->init_section) {

887 av_free(rep);

888 ret = AVERROR(ENOMEM);

889 goto end;

890 }

891 c->max_url_size = aligned(c->max_url_size + strlen(initialization_val));

892 rep->init_section->url = get_content_url(baseurl_nodes, 4, c->max_url_size, rep_id_val, rep_bandwidth_val, initialization_val);

893 if (!rep->init_section->url) {

894 av_free(rep->init_section);

895 av_free(rep);

896 ret = AVERROR(ENOMEM);

897 goto end;

898 }

899 rep->init_section->size = -1;

900 xmlFree(initialization_val);

901 }

902

903 if (media_val) {

904 c->max_url_size = aligned(c->max_url_size + strlen(media_val));

905 rep->url_template = get_content_url(baseurl_nodes, 4, c->max_url_size, rep_id_val, rep_bandwidth_val, media_val);

906 xmlFree(media_val);

907 }

908

909 if (presentation_timeoffset_val) {

910 rep->presentation_timeoffset = (int64_t) strtoll(presentation_timeoffset_val, NULL, 10);

911 xmlFree(presentation_timeoffset_val);

912 }

913 if (duration_val) {

914 rep->fragment_duration = (int64_t) strtoll(duration_val, NULL, 10);

915 xmlFree(duration_val);

916 }

917 if (timescale_val) {

918 rep->fragment_timescale = (int64_t) strtoll(timescale_val, NULL, 10);

919 xmlFree(timescale_val);

920 }

921 if (startnumber_val) {

922 rep->first_seq_no = (int64_t) strtoll(startnumber_val, NULL, 10);

923 xmlFree(startnumber_val);

924 }

925 if (adaptionset_supplementalproperty_node) {

926 if (!av_strcasecmp(xmlGetProp(adaptionset_supplementalproperty_node,"schemeIdUri"), "http://dashif.org/guidelines/last-segment-number")) {

927 val = xmlGetProp(adaptionset_supplementalproperty_node,"value");

928 if (!val) {

929 av_log(s, AV_LOG_ERROR, "Missing value attribute in adaptionset_supplementalproperty_node\n");

930 } else {

931 rep->last_seq_no =(int64_t) strtoll(val, NULL, 10) - 1;

932 xmlFree(val);

933 }

934 }

935 }

936

937 fragment_timeline_node = find_child_node_by_name(representation_segmenttemplate_node, "SegmentTimeline");

938

939 if (!fragment_timeline_node)

940 fragment_timeline_node = find_child_node_by_name(fragment_template_node, "SegmentTimeline");

941 if (!fragment_timeline_node)

942 fragment_timeline_node = find_child_node_by_name(adaptionset_segmentlist_node, "SegmentTimeline");

943 if (!fragment_timeline_node)

944 fragment_timeline_node = find_child_node_by_name(period_segmentlist_node, "SegmentTimeline");

945 if (fragment_timeline_node) {

946 fragment_timeline_node = xmlFirstElementChild(fragment_timeline_node);

947 while (fragment_timeline_node) {

948 ret = parse_manifest_segmenttimeline(s, rep, fragment_timeline_node);

949 if (ret < 0) {

950 return ret;

951 }

952 fragment_timeline_node = xmlNextElementSibling(fragment_timeline_node);

953 }

954 }

955 } else if (representation_baseurl_node && !representation_segmentlist_node) {

956 seg = av_mallocz(sizeof(struct fragment));

957 if (!seg) {

958 ret = AVERROR(ENOMEM);

959 goto end;

960 }

961 seg->url = get_content_url(baseurl_nodes, 4, c->max_url_size, rep_id_val, rep_bandwidth_val, NULL);

962 if (!seg->url) {

963 av_free(seg);

964 ret = AVERROR(ENOMEM);

965 goto end;

966 }

967 seg->size = -1;

968 dynarray_add(&rep->fragments, &rep->n_fragments, seg);

969 } else if (representation_segmentlist_node) {

970 // TODO: https://www.brendanlong.com/the-structure-of-an-mpeg-dash-mpd.html

971 // http://www-itec.uni-klu.ac.at/dash/ddash/mpdGenerator.php?fragmentlength=15&type=full

972 xmlNodePtr fragmenturl_node = NULL;

973 segmentlists_tab[0] = representation_segmentlist_node;

974 segmentlists_tab[1] = adaptionset_segmentlist_node;

975

976 duration_val = get_val_from_nodes_tab(segmentlists_tab, 2, "duration");

977 timescale_val = get_val_from_nodes_tab(segmentlists_tab, 2, "timescale");

978 if (duration_val) {

979 rep->fragment_duration = (int64_t) strtoll(duration_val, NULL, 10);

980 xmlFree(duration_val);

981 }

982 if (timescale_val) {

983 rep->fragment_timescale = (int64_t) strtoll(timescale_val, NULL, 10);

984 xmlFree(timescale_val);

985 }

986 fragmenturl_node = xmlFirstElementChild(representation_segmentlist_node);

987 while (fragmenturl_node) {

988 ret = parse_manifest_segmenturlnode(s, rep, fragmenturl_node,

989 baseurl_nodes,

990 rep_id_val,

991 rep_bandwidth_val);

992 if (ret < 0) {

993 return ret;

994 }

995 fragmenturl_node = xmlNextElementSibling(fragmenturl_node);

996 }

997

998 fragment_timeline_node = find_child_node_by_name(representation_segmenttemplate_node, "SegmentTimeline");

999

1000 if (!fragment_timeline_node)

1001 fragment_timeline_node = find_child_node_by_name(fragment_template_node, "SegmentTimeline");

1002 if (!fragment_timeline_node)

1003 fragment_timeline_node = find_child_node_by_name(adaptionset_segmentlist_node, "SegmentTimeline");

1004 if (!fragment_timeline_node)

1005 fragment_timeline_node = find_child_node_by_name(period_segmentlist_node, "SegmentTimeline");

1006 if (fragment_timeline_node) {

1007 fragment_timeline_node = xmlFirstElementChild(fragment_timeline_node);

1008 while (fragment_timeline_node) {

1009 ret = parse_manifest_segmenttimeline(s, rep, fragment_timeline_node);

1010 if (ret < 0) {

1011 return ret;

1012 }

1013 fragment_timeline_node = xmlNextElementSibling(fragment_timeline_node);

1014 }

1015 }

1016 } else {

1017 free_representation(rep);

1018 rep = NULL;

1019 av_log(s, AV_LOG_ERROR, "Unknown format of Representation node id[%s] \n", (const char *)rep_id_val);

1020 }

1021

1022 if (rep) {

1023 if (rep->fragment_duration > 0 && !rep->fragment_timescale)

1024 rep->fragment_timescale = 1;

1025 rep->bandwidth = rep_bandwidth_val ? atoi(rep_bandwidth_val) : 0;

1026 strncpy(rep->id, rep_id_val ? rep_id_val : "", sizeof(rep->id));

1027 rep->framerate = av_make_q(0, 0);

1028 if (type == AVMEDIA_TYPE_VIDEO && rep_framerate_val) {

1029 ret = av_parse_video_rate(&rep->framerate, rep_framerate_val);

1030 if (ret < 0)

1031 av_log(s, AV_LOG_VERBOSE, "Ignoring invalid frame rate '%s'\n", rep_framerate_val);

1032 }

1033

1034 if (type == AVMEDIA_TYPE_VIDEO) {

1035 rep->rep_idx = video_rep_idx;

1036 dynarray_add(&c->videos, &c->n_videos, rep);

1037 } else {

1038 rep->rep_idx = audio_rep_idx;

1039 dynarray_add(&c->audios, &c->n_audios, rep);

1040 }

1041 }

1042 }

1043

1044 video_rep_idx += type == AVMEDIA_TYPE_VIDEO;

1045 audio_rep_idx += type == AVMEDIA_TYPE_AUDIO;

1046

1047 end:

1048 if (rep_id_val)

1049 xmlFree(rep_id_val);

1050 if (rep_bandwidth_val)

1051 xmlFree(rep_bandwidth_val);

1052 if (rep_framerate_val)

1053 xmlFree(rep_framerate_val);

1054

1055 return ret;

1056 }

1057

1058 static int parse_manifest_adaptationset(AVFormatContext *s, const char *url,

1059 xmlNodePtr adaptionset_node,

1060 xmlNodePtr mpd_baseurl_node,

1061 xmlNodePtr period_baseurl_node,

1062 xmlNodePtr period_segmenttemplate_node,

1063 xmlNodePtr period_segmentlist_node)

1064 {

1065 int ret = 0;

1066 xmlNodePtr fragment_template_node = NULL;

1067 xmlNodePtr content_component_node = NULL;

1068 xmlNodePtr adaptionset_baseurl_node = NULL;

1069 xmlNodePtr adaptionset_segmentlist_node = NULL;

1070 xmlNodePtr adaptionset_supplementalproperty_node = NULL;

1071 xmlNodePtr node = NULL;

1072

1073 node = xmlFirstElementChild(adaptionset_node);

1074 while (node) {

1075 if (!av_strcasecmp(node->name, (const char *)"SegmentTemplate")) {

1076 fragment_template_node = node;

1077 } else if (!av_strcasecmp(node->name, (const char *)"ContentComponent")) {

1078 content_component_node = node;

1079 } else if (!av_strcasecmp(node->name, (const char *)"BaseURL")) {

1080 adaptionset_baseurl_node = node;

1081 } else if (!av_strcasecmp(node->name, (const char *)"SegmentList")) {

1082 adaptionset_segmentlist_node = node;

1083 } else if (!av_strcasecmp(node->name, (const char *)"SupplementalProperty")) {

1084 adaptionset_supplementalproperty_node = node;

1085 } else if (!av_strcasecmp(node->name, (const char *)"Representation")) {

1086 ret = parse_manifest_representation(s, url, node,

1087 adaptionset_node,

1088 mpd_baseurl_node,

1089 period_baseurl_node,

1090 period_segmenttemplate_node,

1091 period_segmentlist_node,

1092 fragment_template_node,

1093 content_component_node,

1094 adaptionset_baseurl_node,

1095 adaptionset_segmentlist_node,

1096 adaptionset_supplementalproperty_node);

1097 if (ret < 0) {

1098 return ret;

1099 }

1100 }

1101 node = xmlNextElementSibling(node);

1102 }

1103 return 0;

1104 }

1105

1106 static int parse_manifest(AVFormatContext *s, const char *url, AVIOContext *in)

1107 {

1108 DASHContext *c = s->priv_data;

1109 int ret = 0;

1110 int close_in = 0;

1111 uint8_t *new_url = NULL;

1112 int64_t filesize = 0;

1113 char *buffer = NULL;

1114 AVDictionary *opts = NULL;

1115 xmlDoc *doc = NULL;

1116 xmlNodePtr root_element = NULL;

1117 xmlNodePtr node = NULL;

1118 xmlNodePtr period_node = NULL;

1119 xmlNodePtr mpd_baseurl_node = NULL;

1120 xmlNodePtr period_baseurl_node = NULL;

1121 xmlNodePtr period_segmenttemplate_node = NULL;

1122 xmlNodePtr period_segmentlist_node = NULL;

1123 xmlNodePtr adaptionset_node = NULL;

1124 xmlAttrPtr attr = NULL;

1125 char *val = NULL;

1126 uint32_t period_duration_sec = 0;

1127 uint32_t period_start_sec = 0;

1128

1129 if (!in) {

1130 close_in = 1;

1131

1132 set_httpheader_options(c, &opts);

1133 ret = avio_open2(&in, url, AVIO_FLAG_READ, c->interrupt_callback, &opts);

1134 av_dict_free(&opts);

1135 if (ret < 0)

1136 return ret;

1137 }

1138

1139 if (av_opt_get(in, "location", AV_OPT_SEARCH_CHILDREN, &new_url) >= 0) {

1140 c->base_url = av_strdup(new_url);

1141 } else {

1142 c->base_url = av_strdup(url);

1143 }

1144

1145 filesize = avio_size(in);

1146 if (filesize <= 0) {

1147 filesize = 8 * 1024;

1148 }

1149

1150 buffer = av_mallocz(filesize);

1151 if (!buffer) {

1152 av_free(c->base_url);

1153 return AVERROR(ENOMEM);

1154 }

1155

1156 filesize = avio_read(in, buffer, filesize);

1157 if (filesize <= 0) {

1158 av_log(s, AV_LOG_ERROR, "Unable to read to offset '%s'\n", url);

1159 ret = AVERROR_INVALIDDATA;

1160 } else {

1161 LIBXML_TEST_VERSION

1162

1163 doc = xmlReadMemory(buffer, filesize, c->base_url, NULL, 0);

1164 root_element = xmlDocGetRootElement(doc);

1165 node = root_element;

1166

1167 if (!node) {

1168 ret = AVERROR_INVALIDDATA;

1169 av_log(s, AV_LOG_ERROR, "Unable to parse '%s' - missing root node\n", url);

1170 goto cleanup;

1171 }

1172

1173 if (node->type != XML_ELEMENT_NODE ||

1174 av_strcasecmp(node->name, (const char *)"MPD")) {

1175 ret = AVERROR_INVALIDDATA;

1176 av_log(s, AV_LOG_ERROR, "Unable to parse '%s' - wrong root node name[%s] type[%d]\n", url, node->name, (int)node->type);

1177 goto cleanup;

1178 }

1179

1180 val = xmlGetProp(node, "type");

1181 if (!val) {

1182 av_log(s, AV_LOG_ERROR, "Unable to parse '%s' - missing type attrib\n", url);

1183 ret = AVERROR_INVALIDDATA;

1184 goto cleanup;

1185 }

1186 if (!av_strcasecmp(val, (const char *)"dynamic"))

1187 c->is_live = 1;

1188 xmlFree(val);

1189

1190 attr = node->properties;

1191 while (attr) {

1192 val = xmlGetProp(node, attr->name);

1193

1194 if (!av_strcasecmp(attr->name, (const char *)"availabilityStartTime")) {

1195 c->availability_start_time = get_utc_date_time_insec(s, (const char *)val);

1196 } else if (!av_strcasecmp(attr->name, (const char *)"publishTime")) {

1197 c->publish_time = get_utc_date_time_insec(s, (const char *)val);

1198 } else if (!av_strcasecmp(attr->name, (const char *)"minimumUpdatePeriod")) {

1199 c->minimum_update_period = get_duration_insec(s, (const char *)val);

1200 } else if (!av_strcasecmp(attr->name, (const char *)"timeShiftBufferDepth")) {

1201 c->time_shift_buffer_depth = get_duration_insec(s, (const char *)val);

1202 } else if (!av_strcasecmp(attr->name, (const char *)"minBufferTime")) {

1203 c->min_buffer_time = get_duration_insec(s, (const char *)val);

1204 } else if (!av_strcasecmp(attr->name, (const char *)"suggestedPresentationDelay")) {

1205 c->suggested_presentation_delay = get_duration_insec(s, (const char *)val);

1206 } else if (!av_strcasecmp(attr->name, (const char *)"mediaPresentationDuration")) {

1207 c->media_presentation_duration = get_duration_insec(s, (const char *)val);

1208 }

1209 attr = attr->next;

1210 xmlFree(val);

1211 }

1212

1213 mpd_baseurl_node = find_child_node_by_name(node, "BaseURL");

1214 if (!mpd_baseurl_node) {

1215 mpd_baseurl_node = xmlNewNode(NULL, "BaseURL");

1216 }

1217

1218 // at now we can handle only one period, with the longest duration

1219 node = xmlFirstElementChild(node);

1220 while (node) {

1221 if (!av_strcasecmp(node->name, (const char *)"Period")) {

1222 period_duration_sec = 0;

1223 period_start_sec = 0;

1224 attr = node->properties;

1225 while (attr) {

1226 val = xmlGetProp(node, attr->name);

1227 if (!av_strcasecmp(attr->name, (const char *)"duration")) {

1228 period_duration_sec = get_duration_insec(s, (const char *)val);

1229 } else if (!av_strcasecmp(attr->name, (const char *)"start")) {

1230 period_start_sec = get_duration_insec(s, (const char *)val);

1231 }

1232 attr = attr->next;

1233 xmlFree(val);

1234 }

1235 if ((period_duration_sec) >= (c->period_duration)) {

1236 period_node = node;

1237 c->period_duration = period_duration_sec;

1238 c->period_start = period_start_sec;

1239 if (c->period_start > 0)

1240 c->media_presentation_duration = c->period_duration;

1241 }

1242 }

1243 node = xmlNextElementSibling(node);

1244 }

1245 if (!period_node) {

1246 av_log(s, AV_LOG_ERROR, "Unable to parse '%s' - missing Period node\n", url);

1247 ret = AVERROR_INVALIDDATA;

1248 goto cleanup;

1249 }

1250

1251 adaptionset_node = xmlFirstElementChild(period_node);

1252 while (adaptionset_node) {

1253 if (!av_strcasecmp(adaptionset_node->name, (const char *)"BaseURL")) {

1254 period_baseurl_node = adaptionset_node;

1255 } else if (!av_strcasecmp(adaptionset_node->name, (const char *)"SegmentTemplate")) {

1256 period_segmenttemplate_node = adaptionset_node;

1257 } else if (!av_strcasecmp(adaptionset_node->name, (const char *)"SegmentList")) {

1258 period_segmentlist_node = adaptionset_node;

1259 } else if (!av_strcasecmp(adaptionset_node->name, (const char *)"AdaptationSet")) {

1260 parse_manifest_adaptationset(s, url, adaptionset_node, mpd_baseurl_node, period_baseurl_node, period_segmenttemplate_node, period_segmentlist_node);

1261 }

1262 adaptionset_node = xmlNextElementSibling(adaptionset_node);

1263 }

1264 cleanup:

1265 /*free the document */

1266 xmlFreeDoc(doc);

1267 xmlCleanupParser();

1268 }

1269

1270 av_free(new_url);

1271 av_free(buffer);

1272 if (close_in) {

1273 avio_close(in);

1274 }

1275 return ret;

1276 }

1277

1278 static int64_t calc_cur_seg_no(AVFormatContext *s, struct representation *pls)

1279 {

1280 DASHContext *c = s->priv_data;

1281 int64_t num = 0;

1282 int64_t start_time_offset = 0;

1283

1284 if (c->is_live) {

1285 if (pls->n_fragments) {

1286 num = pls->first_seq_no;

1287 } else if (pls->n_timelines) {

1288 start_time_offset = get_segment_start_time_based_on_timeline(pls, 0xFFFFFFFF) - 60 * pls->fragment_timescale; // 60 seconds before end

1289 num = calc_next_seg_no_from_timelines(pls, start_time_offset);

1290 if (num == -1)

1291 num = pls->first_seq_no;

1292 else

1293 num += pls->first_seq_no;

1294 } else if (pls->fragment_duration){

1295 if (pls->presentation_timeoffset) {

1296 num = pls->presentation_timeoffset * pls->fragment_timescale / pls->fragment_duration;

1297 } else if (c->publish_time > 0 && !c->availability_start_time) {

1298 num = pls->first_seq_no + (((c->publish_time - c->availability_start_time) - c->suggested_presentation_delay) * pls->fragment_timescale) / pls->fragment_duration;

1299 } else {

1300 num = pls->first_seq_no + (((get_current_time_in_sec() - c->availability_start_time) - c->suggested_presentation_delay) * pls->fragment_timescale) / pls->fragment_duration;

1301 }

1302 }

1303 } else {

1304 num = pls->first_seq_no;

1305 }

1306 return num;

1307 }

1308

1309 static int64_t calc_min_seg_no(AVFormatContext *s, struct representation *pls)

1310 {

1311 DASHContext *c = s->priv_data;

1312 int64_t num = 0;

1313

1314 if (c->is_live && pls->fragment_duration) {

1315 num = pls->first_seq_no + (((get_current_time_in_sec() - c->availability_start_time) - c->time_shift_buffer_depth) * pls->fragment_timescale) / pls->fragment_duration;

1316 } else {

1317 num = pls->first_seq_no;

1318 }

1319 return num;

1320 }

1321

1322 static int64_t calc_max_seg_no(struct representation *pls, DASHContext *c)

1323 {

1324 int64_t num = 0;

1325

1326 if (pls->n_fragments) {

1327 num = pls->first_seq_no + pls->n_fragments - 1;

1328 } else if (pls->n_timelines) {

1329 int i = 0;

1330 num = pls->first_seq_no + pls->n_timelines - 1;

1331 for (i = 0; i < pls->n_timelines; i++) {

1332 num += pls->timelines[i]->repeat;

1333 }

1334 } else if (c->is_live && pls->fragment_duration) {

1335 num = pls->first_seq_no + (((get_current_time_in_sec() - c->availability_start_time)) * pls->fragment_timescale) / pls->fragment_duration;

1336 } else if (pls->fragment_duration) {

1337 num = pls->first_seq_no + (c->media_presentation_duration * pls->fragment_timescale) / pls->fragment_duration;

1338 }

1339

1340 return num;

1341 }

1342

1343 static void move_timelines(struct representation *rep_src, struct representation *rep_dest, DASHContext *c)

1344 {

1345 if (rep_dest && rep_src ) {

1346 free_timelines_list(rep_dest);

1347 rep_dest->timelines = rep_src->timelines;

1348 rep_dest->n_timelines = rep_src->n_timelines;

1349 rep_dest->first_seq_no = rep_src->first_seq_no;

1350 rep_dest->last_seq_no = calc_max_seg_no(rep_dest, c);

1351 rep_src->timelines = NULL;

1352 rep_src->n_timelines = 0;

1353 rep_dest->cur_seq_no = rep_src->cur_seq_no;

1354 }

1355 }

1356

1357 static void move_segments(struct representation *rep_src, struct representation *rep_dest, DASHContext *c)

1358 {

1359 if (rep_dest && rep_src ) {

1360 free_fragment_list(rep_dest);

1361 if (rep_src->start_number > (rep_dest->start_number + rep_dest->n_fragments))

1362 rep_dest->cur_seq_no = 0;

1363 else

1364 rep_dest->cur_seq_no += rep_src->start_number - rep_dest->start_number;

1365 rep_dest->fragments = rep_src->fragments;

1366 rep_dest->n_fragments = rep_src->n_fragments;

1367 rep_dest->parent = rep_src->parent;

1368 rep_dest->last_seq_no = calc_max_seg_no(rep_dest, c);

1369 rep_src->fragments = NULL;

1370 rep_src->n_fragments = 0;

1371 }

1372 }

1373

1374

1375 static int refresh_manifest(AVFormatContext *s)

1376 {

1377

1378 int ret = 0, i;

1379 DASHContext *c = s->priv_data;

1380

1381 // save current context

1382 int n_videos = c->n_videos;

1383 struct representation **videos = c->videos;

1384 int n_audios = c->n_audios;

1385 struct representation **audios = c->audios;

1386 char *base_url = c->base_url;

1387

1388 c->base_url = NULL;

1389 c->n_videos = 0;

1390 c->videos = NULL;

1391 c->n_audios = 0;

1392 c->audios = NULL;

1393 ret = parse_manifest(s, s->filename, NULL);

1394 if (ret)

1395 goto finish;

1396

1397 if (c->n_videos != n_videos) {

1398 av_log(c, AV_LOG_ERROR,

1399 "new manifest has mismatched no. of video representations, %d -> %d\n",

1400 n_videos, c->n_videos);

1401 return AVERROR_INVALIDDATA;

1402 }

1403 if (c->n_audios != n_audios) {

1404 av_log(c, AV_LOG_ERROR,

1405 "new manifest has mismatched no. of audio representations, %d -> %d\n",

1406 n_audios, c->n_audios);

1407 return AVERROR_INVALIDDATA;

1408 }

1409

1410 for (i = 0; i < n_videos; i++) {

1411 struct representation *cur_video = videos[i];

1412 struct representation *ccur_video = c->videos[i];

1413 if (cur_video->timelines) {

1414 // calc current time

1415 int64_t currentTime = get_segment_start_time_based_on_timeline(cur_video, cur_video->cur_seq_no) / cur_video->fragment_timescale;

1416 // update segments

1417 ccur_video->cur_seq_no = calc_next_seg_no_from_timelines(ccur_video, currentTime * cur_video->fragment_timescale - 1);

1418 if (ccur_video->cur_seq_no >= 0) {

1419 move_timelines(ccur_video, cur_video, c);

1420 }

1421 }

1422 if (cur_video->fragments) {

1423 move_segments(ccur_video, cur_video, c);

1424 }

1425 }

1426 for (i = 0; i < n_audios; i++) {

1427 struct representation *cur_audio = audios[i];

1428 struct representation *ccur_audio = c->audios[i];

1429 if (cur_audio->timelines) {

1430 // calc current time

1431 int64_t currentTime = get_segment_start_time_based_on_timeline(cur_audio, cur_audio->cur_seq_no) / cur_audio->fragment_timescale;

1432 // update segments

1433 ccur_audio->cur_seq_no = calc_next_seg_no_from_timelines(ccur_audio, currentTime * cur_audio->fragment_timescale - 1);

1434 if (ccur_audio->cur_seq_no >= 0) {

1435 move_timelines(ccur_audio, cur_audio, c);

1436 }

1437 }

1438 if (cur_audio->fragments) {

1439 move_segments(ccur_audio, cur_audio, c);

1440 }

1441 }

1442

1443 finish:

1444 // restore context

1445 if (c->base_url)

1446 av_free(base_url);

1447 else

1448 c->base_url = base_url;

1449 if (c->audios)

1450 free_audio_list(c);

1451 if (c->videos)

1452 free_video_list(c);

1453 c->n_audios = n_audios;

1454 c->audios = audios;

1455 c->n_videos = n_videos;

1456 c->videos = videos;

1457 return ret;

1458 }

1459

1460 static struct fragment *get_current_fragment(struct representation *pls)

1461 {

1462 int64_t min_seq_no = 0;

1463 int64_t max_seq_no = 0;

1464 struct fragment *seg = NULL;

1465 struct fragment *seg_ptr = NULL;

1466 DASHContext *c = pls->parent->priv_data;

1467

1468 while (( !ff_check_interrupt(c->interrupt_callback)&& pls->n_fragments > 0)) {

1469 if (pls->cur_seq_no < pls->n_fragments) {

1470 seg_ptr = pls->fragments[pls->cur_seq_no];

1471 seg = av_mallocz(sizeof(struct fragment));

1472 if (!seg) {

1473 return NULL;

1474 }

1475 seg->url = av_strdup(seg_ptr->url);

1476 if (!seg->url) {

1477 av_free(seg);

1478 return NULL;

1479 }

1480 seg->size = seg_ptr->size;

1481 seg->url_offset = seg_ptr->url_offset;

1482 return seg;

1483 } else if (c->is_live) {

1484 refresh_manifest(pls->parent);

1485 } else {

1486 break;

1487 }

1488 }

1489 if (c->is_live) {

1490 min_seq_no = calc_min_seg_no(pls->parent, pls);

1491 max_seq_no = calc_max_seg_no(pls, c);

1492

1493 if (pls->timelines || pls->fragments) {

1494 refresh_manifest(pls->parent);

1495 }

1496 if (pls->cur_seq_no <= min_seq_no) {

1497 av_log(pls->parent, AV_LOG_VERBOSE, "old fragment: cur[%"PRId64"] min[%"PRId64"] max[%"PRId64"], playlist %d\n", (int64_t)pls->cur_seq_no, min_seq_no, max_seq_no, (int)pls->rep_idx);

1498 pls->cur_seq_no = calc_cur_seg_no(pls->parent, pls);

1499 } else if (pls->cur_seq_no > max_seq_no) {

1500 av_log(pls->parent, AV_LOG_VERBOSE, "new fragment: min[%"PRId64"] max[%"PRId64"], playlist %d\n", min_seq_no, max_seq_no, (int)pls->rep_idx);

1501 }

1502 seg = av_mallocz(sizeof(struct fragment));

1503 if (!seg) {

1504 return NULL;

1505 }

1506 } else if (pls->cur_seq_no <= pls->last_seq_no) {

1507 seg = av_mallocz(sizeof(struct fragment));

1508 if (!seg) {

1509 return NULL;

1510 }

1511 }

1512 if (seg) {

1513 char *tmpfilename= av_mallocz(c->max_url_size);

1514 if (!tmpfilename) {

1515 return NULL;

1516 }

1517 ff_dash_fill_tmpl_params(tmpfilename, c->max_url_size, pls->url_template, 0, pls->cur_seq_no, 0, get_segment_start_time_based_on_timeline(pls, pls->cur_seq_no));

1518 seg->url = av_strireplace(pls->url_template, pls->url_template, tmpfilename);

1519 if (!seg->url) {

1520 av_log(pls->parent, AV_LOG_WARNING, "Unable to resolve template url '%s', try to use origin template\n", pls->url_template);

1521 seg->url = av_strdup(pls->url_template);

1522 if (!seg->url) {

1523 av_log(pls->parent, AV_LOG_ERROR, "Cannot resolve template url '%s'\n", pls->url_template);

1524 av_free(tmpfilename);

1525 return NULL;

1526 }

1527 }

1528 av_free(tmpfilename);

1529 seg->size = -1;

1530 }

1531

1532 return seg;

1533 }

1534

1535 enum ReadFromURLMode {

1536 READ_NORMAL,

1537 READ_COMPLETE,

1538 };

1539

1540 static int read_from_url(struct representation *pls, struct fragment *seg,

1541 uint8_t *buf, int buf_size,

1542 enum ReadFromURLMode mode)

1543 {

1544 int ret;

1545

1546 /* limit read if the fragment was only a part of a file */

1547 if (seg->size >= 0)

1548 buf_size = FFMIN(buf_size, pls->cur_seg_size - pls->cur_seg_offset);

1549

1550 if (mode == READ_COMPLETE) {

1551 ret = avio_read(pls->input, buf, buf_size);

1552 if (ret < buf_size) {

1553 av_log(pls->parent, AV_LOG_WARNING, "Could not read complete fragment.\n");

1554 }

1555 } else {

1556 ret = avio_read(pls->input, buf, buf_size);

1557 }

1558 if (ret > 0)

1559 pls->cur_seg_offset += ret;

1560

1561 return ret;

1562 }

1563

1564 static int open_input(DASHContext *c, struct representation *pls, struct fragment *seg)

1565 {

1566 AVDictionary *opts = NULL;

1567 char *url = NULL;

1568 int ret = 0;

1569

1570 url = av_mallocz(c->max_url_size);

1571 if (!url) {

1572 goto cleanup;

1573 }

1574 set_httpheader_options(c, &opts);

1575 if (seg->size >= 0) {

1576 /* try to restrict the HTTP request to the part we want

1577 * (if this is in fact a HTTP request) */

1578 av_dict_set_int(&opts, "offset", seg->url_offset, 0);

1579 av_dict_set_int(&opts, "end_offset", seg->url_offset + seg->size, 0);

1580 }

1581

1582 ff_make_absolute_url(url, c->max_url_size, c->base_url, seg->url);

1583 av_log(pls->parent, AV_LOG_VERBOSE, "DASH request for url '%s', offset %"PRId64", playlist %d\n",

1584 url, seg->url_offset, pls->rep_idx);

1585 ret = open_url(pls->parent, &pls->input, url, c->avio_opts, opts, NULL);

1586 if (ret < 0) {

1587 goto cleanup;

1588 }

1589

1590 cleanup:

1591 av_free(url);

1592 av_dict_free(&opts);

1593 pls->cur_seg_offset = 0;

1594 pls->cur_seg_size = seg->size;

1595 return ret;

1596 }

1597

1598 static int update_init_section(struct representation *pls)

1599 {

1600 static const int max_init_section_size = 1024 * 1024;

1601 DASHContext *c = pls->parent->priv_data;

1602 int64_t sec_size;

1603 int64_t urlsize;

1604 int ret;

1605

1606 if (!pls->init_section || pls->init_sec_buf)

1607 return 0;

1608

1609 ret = open_input(c, pls, pls->init_section);

1610 if (ret < 0) {

1611 av_log(pls->parent, AV_LOG_WARNING,

1612 "Failed to open an initialization section in playlist %d\n",

1613 pls->rep_idx);

1614 return ret;

1615 }

1616

1617 if (pls->init_section->size >= 0)

1618 sec_size = pls->init_section->size;

1619 else if ((urlsize = avio_size(pls->input)) >= 0)

1620 sec_size = urlsize;

1621 else

1622 sec_size = max_init_section_size;

1623

1624 av_log(pls->parent, AV_LOG_DEBUG,

1625 "Downloading an initialization section of size %"PRId64"\n",

1626 sec_size);

1627

1628 sec_size = FFMIN(sec_size, max_init_section_size);

1629

1630 av_fast_malloc(&pls->init_sec_buf, &pls->init_sec_buf_size, sec_size);

1631

1632 ret = read_from_url(pls, pls->init_section, pls->init_sec_buf,

1633 pls->init_sec_buf_size, READ_COMPLETE);

1634 ff_format_io_close(pls->parent, &pls->input);

1635

1636 if (ret < 0)

1637 return ret;

1638

1639 pls->init_sec_data_len = ret;

1640 pls->init_sec_buf_read_offset = 0;

1641

1642 return 0;

1643 }

1644

1645 static int64_t seek_data(void *opaque, int64_t offset, int whence)

1646 {

1647 struct representation *v = opaque;

1648 if (v->n_fragments && !v->init_sec_data_len) {

1649 return avio_seek(v->input, offset, whence);

1650 }

1651

1652 return AVERROR(ENOSYS);

1653 }

1654

1655 static int read_data(void *opaque, uint8_t *buf, int buf_size)

1656 {

1657 int ret = 0;

1658 struct representation *v = opaque;

1659 DASHContext *c = v->parent->priv_data;

1660

1661 restart:

1662 if (!v->input) {

1663 free_fragment(&v->cur_seg);

1664 v->cur_seg = get_current_fragment(v);

1665 if (!v->cur_seg) {

1666 ret = AVERROR_EOF;

1667 goto end;

1668 }

1669

1670 /* load/update Media Initialization Section, if any */

1671 ret = update_init_section(v);

1672 if (ret)

1673 goto end;

1674

1675 ret = open_input(c, v, v->cur_seg);

1676 if (ret < 0) {

1677 if (ff_check_interrupt(c->interrupt_callback)) {

1678 goto end;

1679 ret = AVERROR_EXIT;

1680 }

1681 av_log(v->parent, AV_LOG_WARNING, "Failed to open fragment of playlist %d\n", v->rep_idx);

1682 v->cur_seq_no++;

1683 goto restart;

1684 }

1685 }

1686

1687 if (v->init_sec_buf_read_offset < v->init_sec_data_len) {

1688 /* Push init section out first before first actual fragment */

1689 int copy_size = FFMIN(v->init_sec_data_len - v->init_sec_buf_read_offset, buf_size);

1690 memcpy(buf, v->init_sec_buf, copy_size);

1691 v->init_sec_buf_read_offset += copy_size;

1692 ret = copy_size;

1693 goto end;

1694 }

1695

1696 /* check the v->cur_seg, if it is null, get current and double check if the new v->cur_seg*/

1697 if (!v->cur_seg) {

1698 v->cur_seg = get_current_fragment(v);

1699 }

1700 if (!v->cur_seg) {

1701 ret = AVERROR_EOF;

1702 goto end;

1703 }

1704 ret = read_from_url(v, v->cur_seg, buf, buf_size, READ_NORMAL);

1705 if (ret > 0)

1706 goto end;

1707

1708 if (c->is_live || v->cur_seq_no < v->last_seq_no) {

1709 if (!v->is_restart_needed)

1710 v->cur_seq_no++;

1711 v->is_restart_needed = 1;

1712 }

1713

1714 end:

1715 return ret;

1716 }

1717

1718 static int save_avio_options(AVFormatContext *s)

1719 {

1720 DASHContext *c = s->priv_data;

1721 const char *opts[] = { "headers", "user_agent", "user-agent", "cookies", NULL }, **opt = opts;

1722 uint8_t *buf = NULL;

1723 int ret = 0;

1724

1725 while (*opt) {

1726 if (av_opt_get(s->pb, *opt, AV_OPT_SEARCH_CHILDREN, &buf) >= 0) {

1727 if (buf[0] != '0円') {

1728 ret = av_dict_set(&c->avio_opts, *opt, buf, AV_DICT_DONT_STRDUP_VAL);

1729 if (ret < 0) {

1730 av_freep(&buf);

1731 return ret;

1732 }

1733 } else {

1734 av_freep(&buf);

1735 }

1736 }

1737 opt++;

1738 }

1739

1740 return ret;

1741 }

1742

1743 static int nested_io_open(AVFormatContext *s, AVIOContext **pb, const char *url,

1744 int flags, AVDictionary **opts)

1745 {

1746 av_log(s, AV_LOG_ERROR,

1747 "A DASH playlist item '%s' referred to an external file '%s'. "

1748 "Opening this file was forbidden for security reasons\n",

1749 s->filename, url);

1750 return AVERROR(EPERM);

1751 }

1752

1753 static void close_demux_for_component(struct representation *pls)

1754 {

1755 /* note: the internal buffer could have changed */

1756 av_freep(&pls->pb.buffer);

1757 memset(&pls->pb, 0x00, sizeof(AVIOContext));

1758 pls->ctx->pb = NULL;

1759 avformat_close_input(&pls->ctx);

1760 pls->ctx = NULL;

1761 }

1762

1763 static int reopen_demux_for_component(AVFormatContext *s, struct representation *pls)

1764 {

1765 DASHContext *c = s->priv_data;

1766 AVInputFormat *in_fmt = NULL;

1767 AVDictionary *in_fmt_opts = NULL;

1768 uint8_t *avio_ctx_buffer = NULL;

1769 int ret = 0, i;

1770

1771 if (pls->ctx) {

1772 close_demux_for_component(pls);

1773 }

1774 if (!(pls->ctx = avformat_alloc_context())) {

1775 ret = AVERROR(ENOMEM);

1776 goto fail;

1777 }

1778

1779 avio_ctx_buffer = av_malloc(INITIAL_BUFFER_SIZE);

1780 if (!avio_ctx_buffer ) {

1781 ret = AVERROR(ENOMEM);

1782 avformat_free_context(pls->ctx);

1783 pls->ctx = NULL;

1784 goto fail;

1785 }

1786 if (c->is_live) {

1787 ffio_init_context(&pls->pb, avio_ctx_buffer , INITIAL_BUFFER_SIZE, 0, pls, read_data, NULL, NULL);

1788 } else {

1789 ffio_init_context(&pls->pb, avio_ctx_buffer , INITIAL_BUFFER_SIZE, 0, pls, read_data, NULL, seek_data);

1790 }

1791 pls->pb.seekable = 0;

1792

1793 if ((ret = ff_copy_whiteblacklists(pls->ctx, s)) < 0)

1794 goto fail;

1795

1796 pls->ctx->flags = AVFMT_FLAG_CUSTOM_IO;

1797 pls->ctx->probesize = 1024 * 4;

1798 pls->ctx->max_analyze_duration = 4 * AV_TIME_BASE;

1799 ret = av_probe_input_buffer(&pls->pb, &in_fmt, "", NULL, 0, 0);

1800 if (ret < 0) {

1801 av_log(s, AV_LOG_ERROR, "Error when loading first fragment, playlist %d\n", (int)pls->rep_idx);

1802 avformat_free_context(pls->ctx);

1803 pls->ctx = NULL;

1804 goto fail;

1805 }

1806

1807 pls->ctx->pb = &pls->pb;

1808 pls->ctx->io_open = nested_io_open;

1809

1810 // provide additional information from mpd if available

1811 ret = avformat_open_input(&pls->ctx, "", in_fmt, &in_fmt_opts); //pls->init_section->url

1812 av_dict_free(&in_fmt_opts);

1813 if (ret < 0)

1814 goto fail;

1815 if (pls->n_fragments) {

1816 #if FF_API_R_FRAME_RATE

1817 if (pls->framerate.den) {

1818 for (i = 0; i < pls->ctx->nb_streams; i++)

1819 pls->ctx->streams[i]->r_frame_rate = pls->framerate;

1820 }

1821 #endif

1822

1823 ret = avformat_find_stream_info(pls->ctx, NULL);

1824 if (ret < 0)

1825 goto fail;

1826 }

1827

1828 fail:

1829 return ret;

1830 }

1831

1832 static int open_demux_for_component(AVFormatContext *s, struct representation *pls)

1833 {

1834 int ret = 0;

1835 int i;

1836

1837 pls->parent = s;

1838 pls->cur_seq_no = calc_cur_seg_no(s, pls);

1839

1840 if (!pls->last_seq_no) {

1841 pls->last_seq_no = calc_max_seg_no(pls, s->priv_data);

1842 }

1843

1844 ret = reopen_demux_for_component(s, pls);

1845 if (ret < 0) {

1846 goto fail;

1847 }

1848 for (i = 0; i < pls->ctx->nb_streams; i++) {

1849 AVStream *st = avformat_new_stream(s, NULL);

1850 AVStream *ist = pls->ctx->streams[i];

1851 if (!st) {

1852 ret = AVERROR(ENOMEM);

1853 goto fail;

1854 }

1855 st->id = i;

1856 avcodec_parameters_copy(st->codecpar, pls->ctx->streams[i]->codecpar);

1857 avpriv_set_pts_info(st, ist->pts_wrap_bits, ist->time_base.num, ist->time_base.den);

1858 }

1859

1860 return 0;

1861 fail:

1862 return ret;

1863 }

1864

1865 static int dash_read_header(AVFormatContext *s)

1866 {

1867 void *u = (s->flags & AVFMT_FLAG_CUSTOM_IO) ? NULL : s->pb;

1868 DASHContext *c = s->priv_data;

1869 int ret = 0;

1870 int stream_index = 0;

1871 int i;

1872

1873 c->interrupt_callback = &s->interrupt_callback;

1874 // if the URL context is good, read important options we must broker later

1875 if (u) {

1876 update_options(&c->user_agent, "user-agent", u);

1877 update_options(&c->cookies, "cookies", u);

1878 update_options(&c->headers, "headers", u);

1879 }

1880

1881 if ((ret = parse_manifest(s, s->filename, s->pb)) < 0)

1882 goto fail;

1883

1884 if ((ret = save_avio_options(s)) < 0)

1885 goto fail;

1886

1887 /* If this isn't a live stream, fill the total duration of the

1888 * stream. */

1889 if (!c->is_live) {

1890 s->duration = (int64_t) c->media_presentation_duration * AV_TIME_BASE;

1891 }

1892

1893 /* Open the demuxer for video and audio components if available */

1894 for (i = 0; i < c->n_videos; i++) {

1895 struct representation *cur_video = c->videos[i];

1896 ret = open_demux_for_component(s, cur_video);

1897 if (ret)

1898 goto fail;

1899 cur_video->stream_index = stream_index;

1900 ++stream_index;

1901 }

1902

1903 for (i = 0; i < c->n_audios; i++) {

1904 struct representation *cur_audio = c->audios[i];

1905 ret = open_demux_for_component(s, cur_audio);

1906 if (ret)

1907 goto fail;

1908 cur_audio->stream_index = stream_index;

1909 ++stream_index;

1910 }

1911

1912 if (!stream_index) {

1913 ret = AVERROR_INVALIDDATA;

1914 goto fail;

1915 }

1916

1917 /* Create a program */

1918 if (!ret) {

1919 AVProgram *program;

1920 program = av_new_program(s, 0);

1921 if (!program) {

1922 goto fail;

1923 }

1924

1925 for (i = 0; i < c->n_videos; i++) {

1926 struct representation *pls = c->videos[i];

1927

1928 av_program_add_stream_index(s, 0, pls->stream_index);

1929 pls->assoc_stream = s->streams[pls->stream_index];

1930 if (pls->bandwidth > 0)

1931 av_dict_set_int(&pls->assoc_stream->metadata, "variant_bitrate", pls->bandwidth, 0);

1932 if (pls->id[0])

1933 av_dict_set(&pls->assoc_stream->metadata, "id", pls->id, 0);

1934 }

1935 for (i = 0; i < c->n_audios; i++) {

1936 struct representation *pls = c->audios[i];

1937

1938 av_program_add_stream_index(s, 0, pls->stream_index);

1939 pls->assoc_stream = s->streams[pls->stream_index];

1940 if (pls->bandwidth > 0)

1941 av_dict_set_int(&pls->assoc_stream->metadata, "variant_bitrate", pls->bandwidth, 0);

1942 if (pls->id[0])

1943 av_dict_set(&pls->assoc_stream->metadata, "id", pls->id, 0);

1944 }

1945 }

1946

1947 return 0;

1948 fail:

1949 return ret;

1950 }

1951

1952 static void recheck_discard_flags(AVFormatContext *s, struct representation **p, int n)

1953 {

1954 int i, j;

1955

1956 for (i = 0; i < n; i++) {

1957 struct representation *pls = p[i];

1958

1959 int needed = !pls->assoc_stream || pls->assoc_stream->discard < AVDISCARD_ALL;

1960 if (needed && !pls->ctx) {

1961 pls->cur_seg_offset = 0;

1962 pls->init_sec_buf_read_offset = 0;

1963 /* Catch up */

1964 for (j = 0; j < n; j++) {

1965 pls->cur_seq_no = FFMAX(pls->cur_seq_no, p[j]->cur_seq_no);

1966 }

1967 reopen_demux_for_component(s, pls);

1968 av_log(s, AV_LOG_INFO, "Now receiving stream_index %d\n", pls->stream_index);

1969 } else if (!needed && pls->ctx) {

1970 close_demux_for_component(pls);

1971 if (pls->input)

1972 ff_format_io_close(pls->parent, &pls->input);

1973 av_log(s, AV_LOG_INFO, "No longer receiving stream_index %d\n", pls->stream_index);

1974 }

1975 }

1976 }

1977

1978 static int dash_read_packet(AVFormatContext *s, AVPacket *pkt)

1979 {

1980 DASHContext *c = s->priv_data;

1981 int ret = 0, i;

1982 int64_t mints = 0;

1983 struct representation *cur = NULL;

1984

1985 recheck_discard_flags(s, c->videos, c->n_videos);

1986 recheck_discard_flags(s, c->audios, c->n_audios);

1987

1988 for (i = 0; i < c->n_videos; i++) {

1989 struct representation *pls = c->videos[i];

1990 if (!pls->ctx)

1991 continue;

1992 if (!cur || pls->cur_timestamp < mints) {

1993 cur = pls;

1994 mints = pls->cur_timestamp;

1995 }

1996 }

1997 for (i = 0; i < c->n_audios; i++) {

1998 struct representation *pls = c->audios[i];

1999 if (!pls->ctx)

2000 continue;

2001 if (!cur || pls->cur_timestamp < mints) {

2002 cur = pls;

2003 mints = pls->cur_timestamp;

2004 }

2005 }

2006

2007 if (!cur) {

2008 return AVERROR_INVALIDDATA;

2009 }

2010 while (!ff_check_interrupt(c->interrupt_callback) && !ret) {

2011 ret = av_read_frame(cur->ctx, pkt);

2012 if (ret >= 0) {

2013 /* If we got a packet, return it */

2014 cur->cur_timestamp = av_rescale(pkt->pts, (int64_t)cur->ctx->streams[0]->time_base.num * 90000, cur->ctx->streams[0]->time_base.den);

2015 pkt->stream_index = cur->stream_index;

2016 return 0;

2017 }

2018 if (cur->is_restart_needed) {

2019 cur->cur_seg_offset = 0;

2020 cur->init_sec_buf_read_offset = 0;

2021 if (cur->input)

2022 ff_format_io_close(cur->parent, &cur->input);

2023 ret = reopen_demux_for_component(s, cur);

2024 cur->is_restart_needed = 0;

2025 }

2026 }

2027 return AVERROR_EOF;

2028 }

2029

2030 static int dash_close(AVFormatContext *s)

2031 {

2032 DASHContext *c = s->priv_data;

2033 free_audio_list(c);

2034 free_video_list(c);

2035

2036 av_freep(&c->cookies);

2037 av_freep(&c->user_agent);

2038 av_dict_free(&c->avio_opts);

2039 av_freep(&c->base_url);

2040 return 0;

2041 }

2042

2043 static int dash_seek(AVFormatContext *s, struct representation *pls, int64_t seek_pos_msec, int flags, int dry_run)

2044 {

2045 int ret = 0;

2046 int i = 0;

2047 int j = 0;

2048 int64_t duration = 0;

2049

2050 av_log(pls->parent, AV_LOG_VERBOSE, "DASH seek pos[%"PRId64"ms], playlist %d%s\n",

2051 seek_pos_msec, pls->rep_idx, dry_run ? " (dry)" : "");

2052

2053 // single fragment mode

2054 if (pls->n_fragments == 1) {

2055 pls->cur_timestamp = 0;

2056 pls->cur_seg_offset = 0;

2057 if (dry_run)

2058 return 0;

2059 ff_read_frame_flush(pls->ctx);

2060 return av_seek_frame(pls->ctx, -1, seek_pos_msec * 1000, flags);

2061 }

2062

2063 if (pls->input)

2064 ff_format_io_close(pls->parent, &pls->input);

2065

2066 // find the nearest fragment

2067 if (pls->n_timelines > 0 && pls->fragment_timescale > 0) {

2068 int64_t num = pls->first_seq_no;

2069 av_log(pls->parent, AV_LOG_VERBOSE, "dash_seek with SegmentTimeline start n_timelines[%d] "

2070 "last_seq_no[%"PRId64"], playlist %d.\n",

2071 (int)pls->n_timelines, (int64_t)pls->last_seq_no, (int)pls->rep_idx);

2072 for (i = 0; i < pls->n_timelines; i++) {

2073 if (pls->timelines[i]->starttime > 0) {

2074 duration = pls->timelines[i]->starttime;

2075 }

2076 duration += pls->timelines[i]->duration;

2077 if (seek_pos_msec < ((duration * 1000) / pls->fragment_timescale)) {

2078 goto set_seq_num;

2079 }

2080 for (j = 0; j < pls->timelines[i]->repeat; j++) {

2081 duration += pls->timelines[i]->duration;

2082 num++;

2083 if (seek_pos_msec < ((duration * 1000) / pls->fragment_timescale)) {

2084 goto set_seq_num;

2085 }

2086 }

2087 num++;

2088 }

2089

2090 set_seq_num:

2091 pls->cur_seq_no = num > pls->last_seq_no ? pls->last_seq_no : num;

2092 av_log(pls->parent, AV_LOG_VERBOSE, "dash_seek with SegmentTimeline end cur_seq_no[%"PRId64"], playlist %d.\n",

2093 (int64_t)pls->cur_seq_no, (int)pls->rep_idx);

2094 } else if (pls->fragment_duration > 0) {

2095 pls->cur_seq_no = pls->first_seq_no + ((seek_pos_msec * pls->fragment_timescale) / pls->fragment_duration) / 1000;

2096 } else {

2097 av_log(pls->parent, AV_LOG_ERROR, "dash_seek missing timeline or fragment_duration\n");

2098 pls->cur_seq_no = pls->first_seq_no;

2099 }

2100 pls->cur_timestamp = 0;

2101 pls->cur_seg_offset = 0;

2102 pls->init_sec_buf_read_offset = 0;

2103 ret = dry_run ? 0 : reopen_demux_for_component(s, pls);

2104

2105 return ret;

2106 }

2107

2108 static int dash_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)

2109 {

2110 int ret = 0, i;

2111 DASHContext *c = s->priv_data;

2112 int64_t seek_pos_msec = av_rescale_rnd(timestamp, 1000,

2113 s->streams[stream_index]->time_base.den,

2114 flags & AVSEEK_FLAG_BACKWARD ?

2115 AV_ROUND_DOWN : AV_ROUND_UP);

2116 if ((flags & AVSEEK_FLAG_BYTE) || c->is_live)

2117 return AVERROR(ENOSYS);

2118

2119 /* Seek in discarded streams with dry_run=1 to avoid reopening them */

2120 for (i = 0; i < c->n_videos; i++) {

2121 if (!ret)

2122 ret = dash_seek(s, c->videos[i], seek_pos_msec, flags, !c->videos[i]->ctx);

2123 }

2124 for (i = 0; i < c->n_audios; i++) {

2125 if (!ret)

2126 ret = dash_seek(s, c->audios[i], seek_pos_msec, flags, !c->audios[i]->ctx);

2127 }

2128

2129 return ret;

2130 }

2131

2132 static int dash_probe(AVProbeData *p)

2133 {

2134 if (!av_stristr(p->buf, "<MPD"))

2135 return 0;

2136

2137 if (av_stristr(p->buf, "dash:profile:isoff-on-demand:2011") ||

2138 av_stristr(p->buf, "dash:profile:isoff-live:2011") ||

2139 av_stristr(p->buf, "dash:profile:isoff-live:2012") ||

2140 av_stristr(p->buf, "dash:profile:isoff-main:2011")) {

2141 return AVPROBE_SCORE_MAX;

2142 }

2143 if (av_stristr(p->buf, "dash:profile")) {

2144 return AVPROBE_SCORE_MAX;

2145 }

2146

2147 return 0;

2148 }

2149

2150 #define OFFSET(x) offsetof(DASHContext, x)

2151 #define FLAGS AV_OPT_FLAG_DECODING_PARAM

2152 static const AVOption dash_options[] = {

2153 {"allowed_extensions", "List of file extensions that dash is allowed to access",

2154 OFFSET(allowed_extensions), AV_OPT_TYPE_STRING,

2155 {.str = "aac,m4a,m4s,m4v,mov,mp4"},

2156 INT_MIN, INT_MAX, FLAGS},

2157 {NULL}

2158 };

2159

2160 static const AVClass dash_class = {

2161 .class_name = "dash",

2162 .item_name = av_default_item_name,

2163 .option = dash_options,

2164 .version = LIBAVUTIL_VERSION_INT,

2165 };

2166

2167 AVInputFormat ff_dash_demuxer = {

2168 .name = "dash",

2169 .long_name = NULL_IF_CONFIG_SMALL("Dynamic Adaptive Streaming over HTTP"),

2170 .priv_class = &dash_class,

2171 .priv_data_size = sizeof(DASHContext),

2172 .read_probe = dash_probe,

2173 .read_header = dash_read_header,

2174 .read_packet = dash_read_packet,

2175 .read_close = dash_close,

2176 .read_seek = dash_read_seek,

2177 .flags = AVFMT_NO_BYTE_SEEK,

2178 };

av_timegm

time_t av_timegm(struct tm *tm)

Convert the decomposed UTC time in tm to a time_t value.

Definition: parseutils.c:568

representation::cur_seg_size

int64_t cur_seg_size

Definition: dashdec.c:109

FLAGS

#define FLAGS

Definition: dashdec.c:2151

AVSEEK_FLAG_BACKWARD

#define AVSEEK_FLAG_BACKWARD

Definition: avformat.h:2486

AVFormatContext::probesize

int64_t probesize

Maximum size of the data read from input for determining the input container format.

Definition: avformat.h:1506

representation::input

AVIOContext * input

Definition: dashdec.c:78

NULL

#define NULL

Definition: coverity.c:32

val

const char const char void * val

Definition: avisynth_c.h:771

ff_make_absolute_url

void ff_make_absolute_url(char *buf, int size, const char *base, const char *rel)

Convert a relative url into an absolute url, given a base url.

Definition: url.c:80

const char * s

Definition: avisynth_c.h:768

AVIOContext

Bytestream IO Context.

Definition: avio.h:161

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:59

avio_size

int64_t avio_size(AVIOContext *s)

Get the filesize.

Definition: aviobuf.c:336

fragment::url_offset

int64_t url_offset

Definition: dashdec.c:34

representation::n_fragments

int n_fragments

Definition: dashdec.c:92

DASHContext::allowed_extensions

char * allowed_extensions

Definition: dashdec.c:149

av_parse_video_rate

int av_parse_video_rate(AVRational *rate, const char *arg)

Parse str and store the detected values in *rate.

Definition: parseutils.c:179

AVFormatContext::interrupt_callback

AVIOInterruptCB interrupt_callback

Custom interrupt callbacks for the I/O layer.

Definition: avformat.h:1618

AVOption

AVOption.

Definition: opt.h:246

ReadFromURLMode

Definition: dashdec.c:1535

READ_COMPLETE

Definition: dashdec.c:1537

DASHContext::n_audios

int n_audios

Definition: dashdec.c:128

get_segment_start_time_based_on_timeline

static int64_t get_segment_start_time_based_on_timeline(struct representation *pls, int64_t cur_seq_no)

Definition: dashdec.c:244

representation::n_timelines

int n_timelines

Definition: dashdec.c:95

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:182

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

representation::pkt

AVPacket pkt

Definition: dashdec.c:81

read_data

static int read_data(void *opaque, uint8_t *buf, int buf_size)

Definition: dashdec.c:1655

avpriv_set_pts_info

void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)

Set the time base and wrapping info for a given stream.

Definition: utils.c:4820

ff_copy_whiteblacklists

int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src)

Copies the whilelists from one context to the other.

Definition: utils.c:164

av_stristr

char * av_stristr(const char *s1, const char *s2)

Locate the first case-independent occurrence in the string haystack of the string needle...

Definition: avstring.c:56

read_seek

static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)

Definition: libcdio.c:153

ishttp

static int ishttp(char *url)

Definition: dashdec.c:154

AVRational::num

int num

Numerator.

Definition: rational.h:59

avio_seek

int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)

fseek() equivalent for AVIOContext.

Definition: aviobuf.c:246

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:191

AVIO_FLAG_READ

#define AVIO_FLAG_READ

read-only

Definition: avio.h:654

fragment::size

int64_t size

Definition: dashdec.c:35

AVIOContext::buffer

unsigned char * buffer

Start of the buffer.

Definition: avio.h:226

time.h

get_current_fragment

static struct fragment * get_current_fragment(struct representation *pls)

Definition: dashdec.c:1460

av_dict_copy

int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)

Copy entries from one AVDictionary struct into another.

Definition: dict.c:217

dash_options

static const AVOption dash_options[]

Definition: dashdec.c:2152

fragment

Definition: dashdec.c:33

seek_data

static int64_t seek_data(void *opaque, int64_t offset, int whence)

Definition: dashdec.c:1645

av_mallocz

void * av_mallocz(size_t size)

Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...

Definition: mem.c:236

AVDISCARD_ALL

discard all

Definition: avcodec.h:794

AVInputFormat

Definition: avformat.h:642

pkt

static AVPacket pkt

Definition: demuxing_decoding.c:54

representation::cur_timestamp

int64_t cur_timestamp

Definition: dashdec.c:118

src

#define src

Definition: vp8dsp.c:254

DASHContext::n_videos

int n_videos

Definition: dashdec.c:126

DASHContext::headers

char * headers

holds HTTP headers set as an AVOption to the HTTP protocol context

Definition: dashdec.c:148

parse_manifest_segmenturlnode

static int parse_manifest_segmenturlnode(AVFormatContext *s, struct representation *rep, xmlNodePtr fragmenturl_node, xmlNodePtr *baseurl_nodes, char *rep_id_val, char *rep_bandwidth_val)

Definition: dashdec.c:592

DASHContext::min_buffer_time

uint64_t min_buffer_time

Definition: dashdec.c:138

free_fragment

static void free_fragment(struct fragment **seg)

Definition: dashdec.c:303

AVFormatContext

Format I/O context.

Definition: avformat.h:1342

MAX_URL_SIZE

#define MAX_URL_SIZE

Definition: internal.h:30

AVClass::class_name

const char * class_name

The name of the class; usually it is the same name as the context structure type to which the AVClass...

Definition: log.h:72

ff_read_frame_flush

void ff_read_frame_flush(AVFormatContext *s)

Flush the frame reader.

Definition: utils.c:1917

representation::init_section

struct fragment * init_section

Definition: dashdec.c:113

representation::init_sec_buf_read_offset

uint32_t init_sec_buf_read_offset

Definition: dashdec.c:117

representation::stream_index

int stream_index

Definition: dashdec.c:84

get_utc_date_time_insec

static uint64_t get_utc_date_time_insec(AVFormatContext *s, const char *datetime)

Definition: dashdec.c:170

start_time

static int64_t start_time

Definition: ffplay.c:327

DASHContext::suggested_presentation_delay

uint64_t suggested_presentation_delay

Definition: dashdec.c:133

uint8_t

Definition: audio_convert.c:194

AV_ROUND_UP

Round toward +infinity.

Definition: mathematics.h:83

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:31

DASHContext::media_presentation_duration

uint64_t media_presentation_duration

Definition: dashdec.c:132

opt.h

AVOptions.

set_httpheader_options

static void set_httpheader_options(DASHContext *c, AVDictionary **opts)

Definition: dashdec.c:375

end

static av_cold int end(AVCodecContext *avctx)

Definition: avrndec.c:90

representation::presentation_timeoffset

int64_t presentation_timeoffset

Definition: dashdec.c:105

AVStream::id

int id

Format-specific stream ID.

Definition: avformat.h:880

dash_close

static int dash_close(AVFormatContext *s)

Definition: dashdec.c:2030

ff_format_io_close

void ff_format_io_close(AVFormatContext *s, AVIOContext **pb)

Definition: utils.c:5608

DASHContext::period_duration

uint64_t period_duration

Definition: dashdec.c:141

avformat_new_stream

AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)

Add a new stream to a media file.

Definition: utils.c:4450

#define u(width, name, range_min, range_max)

Definition: cbs_h2645.c:344

AVFormatContext::streams

AVStream ** streams

A list of all streams in the file.

Definition: avformat.h:1410

duration

int64_t duration

Definition: movenc.c:63

representation::first_seq_no

int64_t first_seq_no

Definition: dashdec.c:98

avformat_alloc_context

AVFormatContext * avformat_alloc_context(void)

Allocate an AVFormatContext.

Definition: options.c:144

representation::pb

AVIOContext pb

Definition: dashdec.c:77

avio_internal.h

finish

static void finish(void)

Definition: movenc.c:345

AV_OPT_TYPE_STRING

Definition: opt.h:227

AVFormatContext::flags

int flags

Flags modifying the (de)muxer behaviour.

Definition: avformat.h:1473

av_new_program

AVProgram * av_new_program(AVFormatContext *s, int id)

Definition: utils.c:4549

representation::timelines

struct timeline ** timelines

Definition: dashdec.c:96

flags

static int flags

Definition: log.c:55

AVERROR_EOF

#define AVERROR_EOF

End of file.

Definition: error.h:55

read_close

static av_cold int read_close(AVFormatContext *ctx)

Definition: libcdio.c:145

AV_LOG_VERBOSE

#define AV_LOG_VERBOSE

Detailed information.

Definition: log.h:192

av_match_ext

int av_match_ext(const char *filename, const char *extensions)

Return a positive value if the given filename has one of the given extensions, 0 otherwise.

Definition: format.c:38

DASHContext::publish_time

uint64_t publish_time

Definition: dashdec.c:135

size

ptrdiff_t size

Definition: opengl_enc.c:101

recheck_discard_flags

static void recheck_discard_flags(AVFormatContext *s, struct representation **p, int n)

Definition: dashdec.c:1952

DASHContext::availability_start_time

uint64_t availability_start_time

Definition: dashdec.c:134

get_content_type

static enum AVMediaType get_content_type(xmlNodePtr node)

Definition: dashdec.c:550

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:28

avio_read

int avio_read(AVIOContext *s, unsigned char *buf, int size)

Read size bytes from AVIOContext into buf.

Definition: aviobuf.c:648

DASHContext::audios

struct representation ** audios

Definition: dashdec.c:129

INITIAL_BUFFER_SIZE

#define INITIAL_BUFFER_SIZE

Definition: dashdec.c:31

find_child_node_by_name

static xmlNodePtr find_child_node_by_name(xmlNodePtr rootnode, const char *nodename)

Definition: dashdec.c:533

aligned

static int aligned(int val)

Definition: dashdec.c:160

AVIOInterruptCB

Callback for checking whether to abort blocking functions.

Definition: avio.h:58

av_probe_input_buffer

int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt, const char *url, void *logctx, unsigned int offset, unsigned int max_probe_size)

Like av_probe_input_buffer2() but returns 0 on success.

Definition: format.c:320

AVDictionary

Definition: dict.c:30

avcodec_parameters_copy

int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)

Copy the contents of src to dst.

Definition: utils.c:2003

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:176

representation::init_sec_data_len

uint32_t init_sec_data_len

Definition: dashdec.c:116

dash.h

free_timelines_list

static void free_timelines_list(struct representation *pls)

Definition: dashdec.c:323

timeline::starttime

int64_t starttime

Definition: dashdec.c:57

move_segments

static void move_segments(struct representation *rep_src, struct representation *rep_dest, DASHContext *c)

Definition: dashdec.c:1357

calc_max_seg_no

static int64_t calc_max_seg_no(struct representation *pls, DASHContext *c)

Definition: dashdec.c:1322

AVERROR

#define AVERROR(e)

Definition: error.h:43

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...

Definition: internal.h:186

calc_cur_seg_no

static int64_t calc_cur_seg_no(AVFormatContext *s, struct representation *pls)

Definition: dashdec.c:1278

avio_close

int avio_close(AVIOContext *s)

Close the resource accessed by the AVIOContext s and free it.

Definition: aviobuf.c:1190

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:197

av_dict_free

void av_dict_free(AVDictionary **pm)

Free all the memory allocated for an AVDictionary struct and all keys and values. ...

Definition: dict.c:203

AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

dash_read_seek

static int dash_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)

Definition: dashdec.c:2108

av_strireplace

char * av_strireplace(const char *str, const char *from, const char *to)

Locale-independent strings replace.

Definition: avstring.c:234

internal.h

offset

static const uint8_t offset[127][2]

Definition: vf_spp.c:92

AVProgram

New fields can be added to the end with minor version bumps.

Definition: avformat.h:1260

FFMAX

#define FFMAX(a, b)

Definition: common.h:94

av_strlcpy

size_t av_strlcpy(char *dst, const char *src, size_t size)

Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.

Definition: avstring.c:83

fail

#define fail()

Definition: checkasm.h:116

read_from_url

static int read_from_url(struct representation *pls, struct fragment *seg, uint8_t *buf, int buf_size, enum ReadFromURLMode mode)

Definition: dashdec.c:1540

av_fast_malloc

void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)

Allocate a buffer, reusing the given one if large enough.

Definition: mem.c:488

AVProbeData::buf

unsigned char * buf

Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.

Definition: avformat.h:450

DASHContext::minimum_update_period

uint64_t minimum_update_period

Definition: dashdec.c:136

representation::fragments

struct fragment ** fragments

Definition: dashdec.c:93

free_representation

static void free_representation(struct representation *pls)

Definition: dashdec.c:334

DASHContext::interrupt_callback

AVIOInterruptCB * interrupt_callback

Definition: dashdec.c:145

AVFormatContext::nb_streams

unsigned int nb_streams

Number of elements in AVFormatContext.streams.

Definition: avformat.h:1398

free_audio_list

static void free_audio_list(DASHContext *c)

Definition: dashdec.c:364

opts

AVDictionary * opts

Definition: movenc.c:50

DASHContext::user_agent

char * user_agent

holds HTTP user agent set as an AVOption to the HTTP protocol context

Definition: dashdec.c:146

AVIOContext::seekable

int seekable

A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.

Definition: avio.h:260

dynarray_add

#define dynarray_add(tab, nb_ptr, elem)

Definition: internal.h:198

av_rescale

int64_t av_rescale(int64_t a, int64_t b, int64_t c)

Rescale a 64-bit integer with rounding to nearest.

Definition: mathematics.c:129

AV_TIME_BASE

#define AV_TIME_BASE

Internal time base represented as integer.

Definition: avutil.h:254

av_program_add_stream_index

void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)

FFMIN

#define FFMIN(a, b)

Definition: common.h:96

av_strcasecmp

int av_strcasecmp(const char *a, const char *b)

Locale-independent case-insensitive compare.

Definition: avstring.c:213

free_fragment_list

static void free_fragment_list(struct representation *pls)

Definition: dashdec.c:312

AV_OPT_SEARCH_CHILDREN

#define AV_OPT_SEARCH_CHILDREN

Search in possible children of the given object first.

Definition: opt.h:555

AV_DICT_DONT_STRDUP_VAL

#define AV_DICT_DONT_STRDUP_VAL

Take ownership of a value that's been allocated with av_malloc() or another memory allocation functio...

Definition: dict.h:76

read_probe

static int read_probe(AVProbeData *pd)

Definition: jvdec.c:55

intreadwrite.h

value

GLsizei GLboolean const GLfloat * value

Definition: opengl_enc.c:109

int32_t

Definition: audio_convert.c:194

move_timelines

static void move_timelines(struct representation *rep_src, struct representation *rep_dest, DASHContext *c)

Definition: dashdec.c:1343

get_duration_insec

static uint32_t get_duration_insec(AVFormatContext *s, const char *duration)

Definition: dashdec.c:200

DASHContext::is_live

int is_live

Definition: dashdec.c:144

representation::type

enum AVMediaType type

Definition: dashdec.c:86

OFFSET

#define OFFSET(x)

Definition: dashdec.c:2150

open_url

static int open_url(AVFormatContext *s, AVIOContext **pb, const char *url, AVDictionary *opts, AVDictionary *opts2, int *is_http)

Definition: dashdec.c:393

parse_manifest

static int parse_manifest(AVFormatContext *s, const char *url, AVIOContext *in)

Definition: dashdec.c:1106

int n

Definition: avisynth_c.h:684

READ_NORMAL

Definition: dashdec.c:1536

AVStream::metadata

AVDictionary * metadata

Definition: avformat.h:937

AVFMT_FLAG_CUSTOM_IO

#define AVFMT_FLAG_CUSTOM_IO

The caller has supplied a custom AVIOContext, don't avio_close() it.

Definition: avformat.h:1481

AVMEDIA_TYPE_UNKNOWN

Usually treated as AVMEDIA_TYPE_DATA.

Definition: avutil.h:200

save_avio_options

static int save_avio_options(AVFormatContext *s)

Definition: dashdec.c:1718

fragment::url

char * url

Definition: dashdec.c:36

AVERROR_EXIT

#define AVERROR_EXIT

Immediate exit was requested; the called function should not be restarted.

Definition: error.h:56

av_rescale_rnd

int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd)

Rescale a 64-bit integer with specified rounding.

Definition: mathematics.c:58

DASHContext::period_start

uint64_t period_start

Definition: dashdec.c:142

AVFormatContext::max_analyze_duration

int64_t max_analyze_duration

Maximum duration (in AV_TIME_BASE units) of the data read from input in avformat_find_stream_info().

Definition: avformat.h:1514

get_val_from_nodes_tab

static char * get_val_from_nodes_tab(xmlNodePtr *nodes, const int n_nodes, const char *attrname)

Definition: dashdec.c:517

nested_io_open

static int nested_io_open(AVFormatContext *s, AVIOContext **pb, const char *url, int flags, AVDictionary **opts)

Definition: dashdec.c:1743

read_header

static int read_header(FFV1Context *f)

Definition: ffv1dec.c:530

av_gettime

int64_t av_gettime(void)

Get the current time in microseconds.

Definition: time.c:39

dash_probe

static int dash_probe(AVProbeData *p)

Definition: dashdec.c:2132

AVStream

Stream structure.

Definition: avformat.h:873

ff_dash_fill_tmpl_params

void ff_dash_fill_tmpl_params(char *dst, size_t buffer_size, const char *template, int rep_id, int number, int bit_rate, int64_t time)

Definition: dash.c:96

read_packet

static int read_packet(void *opaque, uint8_t *buf, int buf_size)

Definition: avio_reading.c:42

representation::parent

AVFormatContext * parent

Definition: dashdec.c:79

AV_LOG_INFO

#define AV_LOG_INFO

Standard information.

Definition: log.h:187

av_strdup

char * av_strdup(const char *s)

Duplicate a string.

Definition: mem.c:251

ff_check_interrupt

int ff_check_interrupt(AVIOInterruptCB *cb)

Check if the user has requested to interrupt a blocking function associated with cb.

Definition: avio.c:664

AVFormatContext::pb

AVIOContext * pb

I/O context.

Definition: avformat.h:1384

representation::last_seq_no

int64_t last_seq_no

Definition: dashdec.c:99

av_make_q

static AVRational av_make_q(int num, int den)

Create an AVRational.

Definition: rational.h:71

representation::init_sec_buf_size

uint32_t init_sec_buf_size

Definition: dashdec.c:115

representation::cur_seq_no

int64_t cur_seq_no

Definition: dashdec.c:107

DASHContext::max_url_size

int max_url_size

Definition: dashdec.c:151

uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> in

Definition: audio_convert.c:194

dash_read_header

static int dash_read_header(AVFormatContext *s)

Definition: dashdec.c:1865

buf

void * buf

Definition: avisynth_c.h:690

type

GLint GLenum type

Definition: opengl_enc.c:105

DASHContext::time_shift_buffer_depth

uint64_t time_shift_buffer_depth

Definition: dashdec.c:137

av_dict_set

int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)

Set the given entry in *pm, overwriting an existing entry.

Definition: dict.c:70

DASHContext

Definition: dashdec.c:122

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:67

update_options

static void update_options(char **dest, const char *name, void *src)

Definition: dashdec.c:385

open_input

static int open_input(DASHContext *c, struct representation *pls, struct fragment *seg)

Definition: dashdec.c:1564

dash_read_packet

static int dash_read_packet(AVFormatContext *s, AVPacket *pkt)

Definition: dashdec.c:1978

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

resolve_content_path

static int resolve_content_path(AVFormatContext *s, const char *url, int *max_url_size, xmlNodePtr *baseurl_nodes, int n_baseurl_nodes)

Definition: dashdec.c:695

AVSEEK_FLAG_BYTE

#define AVSEEK_FLAG_BYTE

seeking based on position in bytes

Definition: avformat.h:2487

AVMediaType

Definition: avutil.h:199

get_Fragment

static struct fragment * get_Fragment(char *range)

Definition: dashdec.c:574

parse_manifest_segmenttimeline

static int parse_manifest_segmenttimeline(AVFormatContext *s, struct representation *rep, xmlNodePtr fragment_timeline_node)

Definition: dashdec.c:659

avio_open2

int avio_open2(AVIOContext **s, const char *url, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options)

Create and initialize a AVIOContext for accessing the resource indicated by url.

Definition: aviobuf.c:1178

representation::id

char id[20]

Definition: dashdec.c:87

DASHContext::avio_opts

AVDictionary * avio_opts

Definition: dashdec.c:150

avformat_free_context

void avformat_free_context(AVFormatContext *s)

Free an AVFormatContext and all its streams.

Definition: utils.c:4384

AVProbeData

This structure contains the data a format has to probe a file.

Definition: avformat.h:448

parseutils.h

misc parsing utilities

av_read_frame

int av_read_frame(AVFormatContext *s, AVPacket *pkt)

Return the next frame of a stream.

Definition: utils.c:1767

av_strlcat

size_t av_strlcat(char *dst, const char *src, size_t size)

Append the string src to the string dst, but to a total length of no more than size - 1 bytes...

Definition: avstring.c:93

AV_ROUND_DOWN

Round toward -infinity.

Definition: mathematics.h:82

avio_find_protocol_name

const char * avio_find_protocol_name(const char *url)

Return the name of the protocol that will handle the passed URL.

Definition: avio.c:473

ff_dash_demuxer

AVInputFormat ff_dash_demuxer

Definition: dashdec.c:2167

dash_seek

static int dash_seek(AVFormatContext *s, struct representation *pls, int64_t seek_pos_msec, int flags, int dry_run)

Definition: dashdec.c:2043

av_seek_frame

int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)

Seek to the keyframe at timestamp.

Definition: utils.c:2505

av_strtok

char * av_strtok(char *s, const char *delim, char **saveptr)

Split the string into several tokens which can be accessed by successive calls to av_strtok()...

Definition: avstring.c:184

update_init_section

static int update_init_section(struct representation *pls)

Definition: dashdec.c:1598

AVPROBE_SCORE_MAX

#define AVPROBE_SCORE_MAX

maximum score

Definition: avformat.h:460

DASHContext::cookies

char * cookies

holds HTTP cookie values set in either the initial response or as an AVOption to the HTTP protocol co...

Definition: dashdec.c:147

av_strstart

int av_strstart(const char *str, const char *pfx, const char **ptr)

Return non-zero if pfx is a prefix of str.

Definition: avstring.c:34

timeline

Definition: dashdec.c:44

int

Definition: ffmpeg_filter.c:190

timeline::duration

int64_t duration

Definition: dashdec.c:67

if(ret< 0)

Definition: vf_mcdeint.c:279

ffio_init_context

int ffio_init_context(AVIOContext *s, unsigned char *buffer, int buffer_size, int write_flag, void *opaque, int(*read_packet)(void *opaque, uint8_t *buf, int buf_size), int(*write_packet)(void *opaque, uint8_t *buf, int buf_size), int64_t(*seek)(void *opaque, int64_t offset, int whence))

Definition: aviobuf.c:81

avformat_find_stream_info

int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)

Read packets of a media file to get stream information.

Definition: utils.c:3559

dash_class

static const AVClass dash_class

Definition: dashdec.c:2160

static double c[64]

Definition: vsrc_mptestsrc.c:87

representation::fragment_duration

int64_t fragment_duration

Definition: dashdec.c:102

av_dict_set_int

int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags)

Convenience wrapper for av_dict_set that converts the value to a string and stores it...

Definition: dict.c:147

representation::cur_seg

struct fragment * cur_seg

Definition: dashdec.c:110

AVStream::pts_wrap_bits

int pts_wrap_bits

number of bits in pts (used for wrapping control)

Definition: avformat.h:1065

representation::bandwidth

int bandwidth

Definition: dashdec.c:88

AVRational::den

int den

Denominator.

Definition: rational.h:60

representation::ctx

AVFormatContext * ctx

Definition: dashdec.c:80

representation::rep_count

int rep_count

Definition: dashdec.c:83

avformat_close_input

void avformat_close_input(AVFormatContext **s)

Close an opened input AVFormatContext.

Definition: utils.c:4422

representation::fragment_timescale

int64_t fragment_timescale

Definition: dashdec.c:103

close_demux_for_component

static void close_demux_for_component(struct representation *pls)

Definition: dashdec.c:1753

representation::is_restart_needed

int is_restart_needed

Definition: dashdec.c:119

av_opt_get

int av_opt_get(void *obj, const char *name, int search_flags, uint8_t **out_val)

Definition: opt.c:751

av_free

#define av_free(p)

Definition: tableprint_vlc.h:34

AVFMT_NO_BYTE_SEEK

#define AVFMT_NO_BYTE_SEEK

Format does not allow seeking by bytes.

Definition: avformat.h:477

parse_manifest_adaptationset

static int parse_manifest_adaptationset(AVFormatContext *s, const char *url, xmlNodePtr adaptionset_node, xmlNodePtr mpd_baseurl_node, xmlNodePtr period_baseurl_node, xmlNodePtr period_segmenttemplate_node, xmlNodePtr period_segmentlist_node)

Definition: dashdec.c:1058

representation::init_sec_buf

uint8_t * init_sec_buf

Definition: dashdec.c:114

get_content_url

static char * get_content_url(xmlNodePtr *baseurl_nodes, int n_baseurl_nodes, int max_url_size, char *rep_id_val, char *rep_bandwidth_val, char *val)

Definition: dashdec.c:461

representation::framerate

AVRational framerate

Definition: dashdec.c:89

AVFormatContext::priv_data

void * priv_data

Format private data.

Definition: avformat.h:1370

representation::start_number

int64_t start_number

Definition: dashdec.c:100

get_current_time_in_sec

static uint64_t get_current_time_in_sec(void)

Definition: dashdec.c:165

avformat_open_input

int avformat_open_input(AVFormatContext **ps, const char *url, AVInputFormat *fmt, AVDictionary **options)

Open an input stream and read the header.

Definition: utils.c:537

parse_manifest_representation

static int parse_manifest_representation(AVFormatContext *s, const char *url, xmlNodePtr node, xmlNodePtr adaptionset_node, xmlNodePtr mpd_baseurl_node, xmlNodePtr period_baseurl_node, xmlNodePtr period_segmenttemplate_node, xmlNodePtr period_segmentlist_node, xmlNodePtr fragment_template_node, xmlNodePtr content_component_node, xmlNodePtr adaptionset_baseurl_node, xmlNodePtr adaptionset_segmentlist_node, xmlNodePtr adaptionset_supplementalproperty_node)

Definition: dashdec.c:798

calc_min_seg_no

static int64_t calc_min_seg_no(AVFormatContext *s, struct representation *pls)

Definition: dashdec.c:1309

representation::cur_seg_offset

int64_t cur_seg_offset

Definition: dashdec.c:108

DASHContext::videos

struct representation ** videos

Definition: dashdec.c:127

AVFormatContext::duration

int64_t duration