FFmpeg: libavformat/webmdashenc.c Source File

FFmpeg

[フレーム]

libavformat

webmdashenc.c

Go to the documentation of this file.

1 /*

2 * WebM DASH Manifest XML muxer

4 *

5 * This file is part of FFmpeg.

6 *

7 * FFmpeg is free software; you can redistribute it and/or

8 * modify it under the terms of the GNU Lesser General Public

9 * License as published by the Free Software Foundation; either

10 * version 2.1 of the License, or (at your option) any later version.

11 *

12 * FFmpeg is distributed in the hope that it will be useful,

13 * but WITHOUT ANY WARRANTY; without even the implied warranty of

14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

15 * Lesser General Public License for more details.

16 *

17 * You should have received a copy of the GNU Lesser General Public

18 * License along with FFmpeg; if not, write to the Free Software

19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

20 */

22 /*

23 * WebM DASH Specification:

24 * https://sites.google.com/a/webmproject.org/wiki/adaptive-streaming/webm-dash-specification

25 * ISO DASH Specification:

26 * http://standards.iso.org/ittf/PubliclyAvailableStandards/c065274_ISO_IEC_23009-1_2014.zip

27 */

29 #include <float.h>

30 #include <stdint.h>

31 #include <string.h>

33 #include "avformat.h"

34 #include "matroska.h"

35 #include "mux.h"

37 #include "libavutil/avstring.h"

38 #include "libavutil/dict.h"

39 #include "libavutil/opt.h"

40 #include "libavutil/time_internal.h"

42 #include "libavcodec/codec_desc.h"

44 typedef struct AdaptationSet {

45 char id[10];

46 int *streams;

47 int nb_streams;

48 } AdaptationSet;

50 typedef struct WebMDashMuxContext {

51 const AVClass *class;

52 char *adaptation_sets;

53 AdaptationSet *as;

54 int nb_as;

55 int representation_id;

56 int is_live;

57 int chunk_start_index;

58 int chunk_duration;

59 char *utc_timing_url;

60 double time_shift_buffer_depth;

61 int minimum_update_period;

62 } WebMDashMuxContext;

64 static const char *get_codec_name(int codec_id)

65 {

66 return avcodec_descriptor_get(codec_id)->name;

67 }

69 static double get_duration(AVFormatContext *s)

70 {

71 int i = 0;

72 double max = 0.0;

73 for (i = 0; i < s->nb_streams; i++) {

74 AVDictionaryEntry *duration = av_dict_get(s->streams[i]->metadata,

75 DURATION, NULL, 0);

76 if (!duration || atof(duration->value) < 0) continue;

77 if (atof(duration->value) > max) max = atof(duration->value);

78 }

79 return max / 1000;

80 }

82 static int write_header(AVFormatContext *s)

83 {

84 WebMDashMuxContext *w = s->priv_data;

85 AVIOContext *pb = s->pb;

86 double min_buffer_time = 1.0;

87 avio_printf(pb, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");

88 avio_printf(pb, "<MPD\n");

89 avio_printf(pb, " xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n");

90 avio_printf(pb, " xmlns=\"urn:mpeg:DASH:schema:MPD:2011\"\n");

91 avio_printf(pb, " xsi:schemaLocation=\"urn:mpeg:DASH:schema:MPD:2011\"\n");

92 avio_printf(pb, " type=\"%s\"\n", w->is_live ? "dynamic" : "static");

93 if (!w->is_live) {

94 avio_printf(pb, " mediaPresentationDuration=\"PT%gS\"\n",

95 get_duration(s));

96 }

97 avio_printf(pb, " minBufferTime=\"PT%gS\"\n", min_buffer_time);

98 avio_printf(pb, " profiles=\"%s\"%s",

99 w->is_live ? "urn:mpeg:dash:profile:isoff-live:2011" : "urn:mpeg:dash:profile:webm-on-demand:2012",

100 w->is_live ? "\n" : ">\n");

101 if (w->is_live) {

102 time_t local_time = time(NULL);

103 struct tm gmt_buffer;

104 struct tm *gmt = gmtime_r(&local_time, &gmt_buffer);

105 char gmt_iso[21];

106 if (!strftime(gmt_iso, 21, "%Y-%m-%dT%H:%M:%SZ", gmt)) {

107 return AVERROR_UNKNOWN;

108 }

109 if (s->flags & AVFMT_FLAG_BITEXACT) {

110 av_strlcpy(gmt_iso, "", 1);

111 }

112 avio_printf(pb, " availabilityStartTime=\"%s\"\n", gmt_iso);

113 avio_printf(pb, " timeShiftBufferDepth=\"PT%gS\"\n", w->time_shift_buffer_depth);

114 avio_printf(pb, " minimumUpdatePeriod=\"PT%dS\"", w->minimum_update_period);

115 avio_printf(pb, ">\n");

116 if (w->utc_timing_url) {

117 avio_printf(pb, "<UTCTiming\n");

118 avio_printf(pb, " schemeIdUri=\"urn:mpeg:dash:utc:http-iso:2014\"\n");

119 avio_printf(pb, " value=\"%s\"/>\n", w->utc_timing_url);

120 }

121 }

122 return 0;

123 }

124

125 static void write_footer(AVFormatContext *s)

126 {

127 avio_printf(s->pb, "</MPD>\n");

128 }

129

130 static int subsegment_alignment(AVFormatContext *s, const AdaptationSet *as)

131 {

132 int i;

133 AVDictionaryEntry *gold = av_dict_get(s->streams[as->streams[0]]->metadata,

134 CUE_TIMESTAMPS, NULL, 0);

135 if (!gold) return 0;

136 for (i = 1; i < as->nb_streams; i++) {

137 AVDictionaryEntry *ts = av_dict_get(s->streams[as->streams[i]]->metadata,

138 CUE_TIMESTAMPS, NULL, 0);

139 if (!ts || !av_strstart(ts->value, gold->value, NULL)) return 0;

140 }

141 return 1;

142 }

143

144 static int bitstream_switching(AVFormatContext *s, const AdaptationSet *as)

145 {

146 int i;

147 const AVStream *gold_st = s->streams[as->streams[0]];

148 AVDictionaryEntry *gold_track_num = av_dict_get(gold_st->metadata,

149 TRACK_NUMBER, NULL, 0);

150 AVCodecParameters *gold_par = gold_st->codecpar;

151 if (!gold_track_num) return 0;

152 for (i = 1; i < as->nb_streams; i++) {

153 const AVStream *st = s->streams[as->streams[i]];

154 AVDictionaryEntry *track_num = av_dict_get(st->metadata,

155 TRACK_NUMBER, NULL, 0);

156 AVCodecParameters *par = st->codecpar;

157 if (!track_num ||

158 !av_strstart(track_num->value, gold_track_num->value, NULL) ||

159 gold_par->codec_id != par->codec_id ||

160 gold_par->extradata_size != par->extradata_size ||

161 (par->extradata_size > 0 &&

162 memcmp(gold_par->extradata, par->extradata, par->extradata_size))) {

163 return 0;

164 }

165 }

166 return 1;

167 }

168

169 /*

170 * Writes a Representation within an Adaptation Set. Returns 0 on success and

171 * < 0 on failure.

172 */

173 static int write_representation(AVFormatContext *s, AVStream *st, char *id,

174 int output_width, int output_height,

175 int output_sample_rate)

176 {

177 WebMDashMuxContext *w = s->priv_data;

178 AVIOContext *pb = s->pb;

179 const AVCodecParameters *par = st->codecpar;

180 AVDictionaryEntry *bandwidth = av_dict_get(st->metadata, BANDWIDTH, NULL, 0);

181 const char *bandwidth_str;

182 avio_printf(pb, "<Representation id=\"%s\"", id);

183 if (bandwidth) {

184 bandwidth_str = bandwidth->value;

185 } else if (w->is_live) {

186 // if bandwidth for live was not provided, use a default

187 bandwidth_str = (par->codec_type == AVMEDIA_TYPE_AUDIO) ? "128000" : "1000000";

188 } else {

189 return AVERROR(EINVAL);

190 }

191 avio_printf(pb, " bandwidth=\"%s\"", bandwidth_str);

192 if (par->codec_type == AVMEDIA_TYPE_VIDEO && output_width)

193 avio_printf(pb, " width=\"%d\"", par->width);

194 if (par->codec_type == AVMEDIA_TYPE_VIDEO && output_height)

195 avio_printf(pb, " height=\"%d\"", par->height);

196 if (par->codec_type == AVMEDIA_TYPE_AUDIO && output_sample_rate)

197 avio_printf(pb, " audioSamplingRate=\"%d\"", par->sample_rate);

198 if (w->is_live) {

199 // For live streams, Codec and Mime Type always go in the Representation tag.

200 avio_printf(pb, " codecs=\"%s\"", get_codec_name(par->codec_id));

201 avio_printf(pb, " mimeType=\"%s/webm\"",

202 par->codec_type == AVMEDIA_TYPE_VIDEO ? "video" : "audio");

203 // For live streams, subsegments always start with key frames. So this

204 // is always 1.

205 avio_printf(pb, " startsWithSAP=\"1\"");

206 avio_printf(pb, ">");

207 } else {

208 AVDictionaryEntry *irange = av_dict_get(st->metadata, INITIALIZATION_RANGE, NULL, 0);

209 AVDictionaryEntry *cues_start = av_dict_get(st->metadata, CUES_START, NULL, 0);

210 AVDictionaryEntry *cues_end = av_dict_get(st->metadata, CUES_END, NULL, 0);

211 AVDictionaryEntry *filename = av_dict_get(st->metadata, FILENAME, NULL, 0);

212 if (!irange || !cues_start || !cues_end || !filename)

213 return AVERROR(EINVAL);

214

215 avio_printf(pb, ">\n");

216 avio_printf(pb, "<BaseURL>%s</BaseURL>\n", filename->value);

217 avio_printf(pb, "<SegmentBase\n");

218 avio_printf(pb, " indexRange=\"%s-%s\">\n", cues_start->value, cues_end->value);

219 avio_printf(pb, "<Initialization\n");

220 avio_printf(pb, " range=\"0-%s\" />\n", irange->value);

221 avio_printf(pb, "</SegmentBase>\n");

222 }

223 avio_printf(pb, "</Representation>\n");

224 return 0;

225 }

226

227 /*

228 * Checks if width of all streams are the same. Returns 1 if true, 0 otherwise.

229 */

230 static int check_matching_width(AVFormatContext *s, const AdaptationSet *as)

231 {

232 int first_width, i;

233 if (as->nb_streams < 2) return 1;

234 first_width = s->streams[as->streams[0]]->codecpar->width;

235 for (i = 1; i < as->nb_streams; i++)

236 if (first_width != s->streams[as->streams[i]]->codecpar->width)

237 return 0;

238 return 1;

239 }

240

241 /*

242 * Checks if height of all streams are the same. Returns 1 if true, 0 otherwise.

243 */

244 static int check_matching_height(AVFormatContext *s, const AdaptationSet *as)

245 {

246 int first_height, i;

247 if (as->nb_streams < 2) return 1;

248 first_height = s->streams[as->streams[0]]->codecpar->height;

249 for (i = 1; i < as->nb_streams; i++)

250 if (first_height != s->streams[as->streams[i]]->codecpar->height)

251 return 0;

252 return 1;

253 }

254

255 /*

256 * Checks if sample rate of all streams are the same. Returns 1 if true, 0 otherwise.

257 */

258 static int check_matching_sample_rate(AVFormatContext *s, const AdaptationSet *as)

259 {

260 int first_sample_rate, i;

261 if (as->nb_streams < 2) return 1;

262 first_sample_rate = s->streams[as->streams[0]]->codecpar->sample_rate;

263 for (i = 1; i < as->nb_streams; i++)

264 if (first_sample_rate != s->streams[as->streams[i]]->codecpar->sample_rate)

265 return 0;

266 return 1;

267 }

268

269 static void free_adaptation_sets(AVFormatContext *s)

270 {

271 WebMDashMuxContext *w = s->priv_data;

272 int i;

273 for (i = 0; i < w->nb_as; i++) {

274 av_freep(&w->as[i].streams);

275 }

276 av_freep(&w->as);

277 w->nb_as = 0;

278 }

279

280 /*

281 * Parses a live header filename and returns the position of the '_' and '.'

282 * delimiting <file_description> and <representation_id>.

283 *

284 * Name of the header file should conform to the following pattern:

285 * <file_description>_<representation_id>.hdr where <file_description> can be

286 * anything. The chunks should be named according to the following pattern:

287 * <file_description>_<representation_id>_<chunk_number>.chk

288 */

289 static int split_filename(char *filename, char **underscore_pos,

290 char **period_pos)

291 {

292 *underscore_pos = strrchr(filename, '_');

293 if (!*underscore_pos)

294 return AVERROR(EINVAL);

295 *period_pos = strchr(*underscore_pos, '.');

296 if (!*period_pos)

297 return AVERROR(EINVAL);

298 return 0;

299 }

300

301 /*

302 * Writes an Adaptation Set. Returns 0 on success and < 0 on failure.

303 */

304 static int write_adaptation_set(AVFormatContext *s, int as_index)

305 {

306 WebMDashMuxContext *w = s->priv_data;

307 AdaptationSet *as = &w->as[as_index];

308 const AVStream *st = s->streams[as->streams[0]];

309 AVCodecParameters *par = st->codecpar;

310 AVDictionaryEntry *lang;

311 AVIOContext *pb = s->pb;

312 int i;

313 static const char boolean[2][6] = { "false", "true" };

314 int subsegmentStartsWithSAP = 1;

315

316 // Width, Height and Sample Rate will go in the AdaptationSet tag if they

317 // are the same for all contained Representations. otherwise, they will go

318 // on their respective Representation tag. For live streams, they always go

319 // in the Representation tag.

320 int width_in_as = 1, height_in_as = 1, sample_rate_in_as = 1;

321 if (par->codec_type == AVMEDIA_TYPE_VIDEO) {

322 width_in_as = !w->is_live && check_matching_width (s, as);

323 height_in_as = !w->is_live && check_matching_height(s, as);

324 } else {

325 sample_rate_in_as = !w->is_live && check_matching_sample_rate(s, as);

326 }

327

328 avio_printf(pb, "<AdaptationSet id=\"%s\"", as->id);

329 avio_printf(pb, " mimeType=\"%s/webm\"",

330 par->codec_type == AVMEDIA_TYPE_VIDEO ? "video" : "audio");

331 avio_printf(pb, " codecs=\"%s\"", get_codec_name(par->codec_id));

332

333 lang = av_dict_get(st->metadata, "language", NULL, 0);

334 if (lang)

335 avio_printf(pb, " lang=\"%s\"", lang->value);

336

337 if (par->codec_type == AVMEDIA_TYPE_VIDEO && width_in_as)

338 avio_printf(pb, " width=\"%d\"", par->width);

339 if (par->codec_type == AVMEDIA_TYPE_VIDEO && height_in_as)

340 avio_printf(pb, " height=\"%d\"", par->height);

341 if (par->codec_type == AVMEDIA_TYPE_AUDIO && sample_rate_in_as)

342 avio_printf(pb, " audioSamplingRate=\"%d\"", par->sample_rate);

343

344 avio_printf(pb, " bitstreamSwitching=\"%s\"",

345 boolean[bitstream_switching(s, as)]);

346 avio_printf(pb, " subsegmentAlignment=\"%s\"",

347 boolean[w->is_live || subsegment_alignment(s, as)]);

348

349 for (i = 0; i < as->nb_streams; i++) {

350 AVDictionaryEntry *kf = av_dict_get(s->streams[as->streams[i]]->metadata,

351 CLUSTER_KEYFRAME, NULL, 0);

352 if (!w->is_live && (!kf || !strncmp(kf->value, "0", 1))) subsegmentStartsWithSAP = 0;

353 }

354 avio_printf(pb, " subsegmentStartsWithSAP=\"%d\"", subsegmentStartsWithSAP);

355 avio_printf(pb, ">\n");

356

357 if (w->is_live) {

358 AVDictionaryEntry *filename =

359 av_dict_get(st->metadata, FILENAME, NULL, 0);

360 char *underscore_pos, *period_pos;

361 int ret;

362 if (!filename)

363 return AVERROR(EINVAL);

364 ret = split_filename(filename->value, &underscore_pos, &period_pos);

365 if (ret) return ret;

366 *underscore_pos = '0円';

367 avio_printf(pb, "<ContentComponent id=\"1\" type=\"%s\"/>\n",

368 par->codec_type == AVMEDIA_TYPE_VIDEO ? "video" : "audio");

369 avio_printf(pb, "<SegmentTemplate");

370 avio_printf(pb, " timescale=\"1000\"");

371 avio_printf(pb, " duration=\"%d\"", w->chunk_duration);

372 avio_printf(pb, " media=\"%s_$RepresentationID$_$Number$.chk\"",

373 filename->value);

374 avio_printf(pb, " startNumber=\"%d\"", w->chunk_start_index);

375 avio_printf(pb, " initialization=\"%s_$RepresentationID$.hdr\"",

376 filename->value);

377 avio_printf(pb, "/>\n");

378 *underscore_pos = '_';

379 }

380

381 for (i = 0; i < as->nb_streams; i++) {

382 char buf[25], *representation_id = buf, *underscore_pos, *period_pos;

383 AVStream *st = s->streams[as->streams[i]];

384 int ret;

385 if (w->is_live) {

386 AVDictionaryEntry *filename =

387 av_dict_get(st->metadata, FILENAME, NULL, 0);

388 if (!filename)

389 return AVERROR(EINVAL);

390 ret = split_filename(filename->value, &underscore_pos, &period_pos);

391 if (ret < 0)

392 return ret;

393 representation_id = underscore_pos + 1;

394 *period_pos = '0円';

395 } else {

396 snprintf(buf, sizeof(buf), "%d", w->representation_id++);

397 }

398 ret = write_representation(s, st, representation_id, !width_in_as,

399 !height_in_as, !sample_rate_in_as);

400 if (ret) return ret;

401 if (w->is_live)

402 *period_pos = '.';

403 }

404 avio_printf(s->pb, "</AdaptationSet>\n");

405 return 0;

406 }

407

408 static int parse_adaptation_sets(AVFormatContext *s)

409 {

410 WebMDashMuxContext *w = s->priv_data;

411 char *p = w->adaptation_sets;

412 char *q;

413 enum { new_set, parsed_id, parsing_streams } state;

414 if (!w->adaptation_sets) {

415 av_log(s, AV_LOG_ERROR, "The 'adaptation_sets' option must be set.\n");

416 return AVERROR(EINVAL);

417 }

418 // syntax id=0,streams=0,1,2 id=1,streams=3,4 and so on

419 state = new_set;

420 while (1) {

421 if (*p == '0円') {

422 if (state == new_set)

423 break;

424 else

425 return AVERROR(EINVAL);

426 } else if (state == new_set && *p == ' ') {

427 p++;

428 continue;

429 } else if (state == new_set && !strncmp(p, "id=", 3)) {

430 void *mem = av_realloc(w->as, sizeof(*w->as) * (w->nb_as + 1));

431 const char *comma;

432 if (mem == NULL)

433 return AVERROR(ENOMEM);

434 w->as = mem;

435 ++w->nb_as;

436 w->as[w->nb_as - 1].nb_streams = 0;

437 w->as[w->nb_as - 1].streams = NULL;

438 p += 3; // consume "id="

439 q = w->as[w->nb_as - 1].id;

440 comma = strchr(p, ',');

441 if (!comma || comma - p >= sizeof(w->as[w->nb_as - 1].id)) {

442 av_log(s, AV_LOG_ERROR, "'id' in 'adaptation_sets' is malformed.\n");

443 return AVERROR(EINVAL);

444 }

445 while (*p != ',') *q++ = *p++;

446 *q = 0;

447 p++;

448 state = parsed_id;

449 } else if (state == parsed_id && !strncmp(p, "streams=", 8)) {

450 p += 8; // consume "streams="

451 state = parsing_streams;

452 } else if (state == parsing_streams) {

453 struct AdaptationSet *as = &w->as[w->nb_as - 1];

454 int64_t num;

455 int ret = av_reallocp_array(&as->streams, ++as->nb_streams,

456 sizeof(*as->streams));

457 if (ret < 0)

458 return ret;

459 num = strtoll(p, &q, 10);

460 if (!av_isdigit(*p) || (*q != ' ' && *q != '0円' && *q != ',') ||

461 num < 0 || num >= s->nb_streams) {

462 av_log(s, AV_LOG_ERROR, "Invalid value for 'streams' in adapation_sets.\n");

463 return AVERROR(EINVAL);

464 }

465 as->streams[as->nb_streams - 1] = num;

466 if (*q == '0円') break;

467 if (*q == ' ') state = new_set;

468 p = ++q;

469 } else {

470 return -1;

471 }

472 }

473 return 0;

474 }

475

476 static int webm_dash_manifest_write_header(AVFormatContext *s)

477 {

478 int i;

479 double start = 0.0;

480 int ret;

481 WebMDashMuxContext *w = s->priv_data;

482

483 for (unsigned i = 0; i < s->nb_streams; i++) {

484 enum AVCodecID codec_id = s->streams[i]->codecpar->codec_id;

485 if (codec_id != AV_CODEC_ID_VP8 && codec_id != AV_CODEC_ID_VP9 &&

486 codec_id != AV_CODEC_ID_AV1 && codec_id != AV_CODEC_ID_VORBIS &&

487 codec_id != AV_CODEC_ID_OPUS)

488 return AVERROR(EINVAL);

489 }

490

491 ret = parse_adaptation_sets(s);

492 if (ret < 0) {

493 goto fail;

494 }

495 ret = write_header(s);

496 if (ret < 0) {

497 goto fail;

498 }

499 avio_printf(s->pb, "<Period id=\"0\"");

500 avio_printf(s->pb, " start=\"PT%gS\"", start);

501 if (!w->is_live) {

502 avio_printf(s->pb, " duration=\"PT%gS\"", get_duration(s));

503 }

504 avio_printf(s->pb, " >\n");

505

506 for (i = 0; i < w->nb_as; i++) {

507 ret = write_adaptation_set(s, i);

508 if (ret < 0) {

509 goto fail;

510 }

511 }

512

513 avio_printf(s->pb, "</Period>\n");

514 write_footer(s);

515 fail:

516 free_adaptation_sets(s);

517 return ret < 0 ? ret : 0;

518 }

519

520 static int webm_dash_manifest_write_packet(AVFormatContext *s, AVPacket *pkt)

521 {

522 return AVERROR_EOF;

523 }

524

525 #define OFFSET(x) offsetof(WebMDashMuxContext, x)

526 static const AVOption options[] = {

527 { "adaptation_sets", "Adaptation sets. Syntax: id=0,streams=0,1,2 id=1,streams=3,4 and so on", OFFSET(adaptation_sets), AV_OPT_TYPE_STRING, { 0 }, 0, 0, AV_OPT_FLAG_ENCODING_PARAM },

528 { "live", "create a live stream manifest", OFFSET(is_live), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM },

529 { "chunk_start_index", "start index of the chunk", OFFSET(chunk_start_index), AV_OPT_TYPE_INT, {.i64 = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },

530 { "chunk_duration_ms", "duration of each chunk (in milliseconds)", OFFSET(chunk_duration), AV_OPT_TYPE_INT, {.i64 = 1000}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },

531 { "utc_timing_url", "URL of the page that will return the UTC timestamp in ISO format", OFFSET(utc_timing_url), AV_OPT_TYPE_STRING, { 0 }, 0, 0, AV_OPT_FLAG_ENCODING_PARAM },

532 { "time_shift_buffer_depth", "Smallest time (in seconds) shifting buffer for which any Representation is guaranteed to be available.", OFFSET(time_shift_buffer_depth), AV_OPT_TYPE_DOUBLE, { .dbl = 60.0 }, 1.0, DBL_MAX, AV_OPT_FLAG_ENCODING_PARAM },

533 { "minimum_update_period", "Minimum Update Period (in seconds) of the manifest.", OFFSET(minimum_update_period), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM },

534 { NULL },

535 };

536

537 static const AVClass webm_dash_class = {

538 .class_name = "WebM DASH Manifest muxer",

539 .item_name = av_default_item_name,

540 .option = options,

541 .version = LIBAVUTIL_VERSION_INT,

542 };

543

544 const FFOutputFormat ff_webm_dash_manifest_muxer = {

545 .p.name = "webm_dash_manifest",

546 .p.long_name = NULL_IF_CONFIG_SMALL("WebM DASH Manifest"),

547 .p.mime_type = "application/xml",

548 .p.extensions = "xml",

549 .priv_data_size = sizeof(WebMDashMuxContext),

550 .write_header = webm_dash_manifest_write_header,

551 .write_packet = webm_dash_manifest_write_packet,

552 .p.priv_class = &webm_dash_class,

553 };

AVCodecParameters::extradata

uint8_t * extradata

Extra binary data needed for initializing the decoder, codec-dependent.

Definition: codec_par.h:76

AVOutputFormat::name

const char * name

Definition: avformat.h:508

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

opt.h

check_matching_width

static int check_matching_width(AVFormatContext *s, const AdaptationSet *as)

Definition: webmdashenc.c:230

AVCodecParameters::codec_type

enum AVMediaType codec_type

General type of the encoded data.

Definition: codec_par.h:58

AVCodecParameters

This struct describes the properties of an encoded stream.

Definition: codec_par.h:54

bitstream_switching

static int bitstream_switching(AVFormatContext *s, const AdaptationSet *as)

Definition: webmdashenc.c:144

check_matching_sample_rate

static int check_matching_sample_rate(AVFormatContext *s, const AdaptationSet *as)

Definition: webmdashenc.c:258

AVERROR_EOF

#define AVERROR_EOF

End of file.

Definition: error.h:57

free_adaptation_sets

static void free_adaptation_sets(AVFormatContext *s)

Definition: webmdashenc.c:269

AVCodecDescriptor::name

const char * name

Name of the codec described by this descriptor.

Definition: codec_desc.h:46

CUES_START

#define CUES_START

Definition: matroska.h:383

AdaptationSet::id

int id

Definition: dashenc.c:88

uint8_t w

Definition: llviddspenc.c:38

AVOption

AVOption.

Definition: opt.h:251

write_footer

static void write_footer(AVFormatContext *s)

Definition: webmdashenc.c:125

matroska.h

split_filename

static int split_filename(char *filename, char **underscore_pos, char **period_pos)

Definition: webmdashenc.c:289

float.h

max

#define max(a, b)

Definition: cuda_runtime.h:33

AVERROR_UNKNOWN

#define AVERROR_UNKNOWN

Unknown error, typically from an external library.

Definition: error.h:73

FFOutputFormat::p

AVOutputFormat p

The public AVOutputFormat.

Definition: mux.h:34

AdaptationSet::nb_streams

int nb_streams

Definition: dashenc.c:99

fail

#define fail()

Definition: checkasm.h:134

gmtime_r

#define gmtime_r

Definition: time_internal.h:34

write_representation

static int write_representation(AVFormatContext *s, AVStream *st, char *id, int output_width, int output_height, int output_sample_rate)

Definition: webmdashenc.c:173

AdaptationSet::streams

int * streams

Definition: webmdashenc.c:46

pkt

AVPacket * pkt

Definition: movenc.c:59

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

duration

int64_t duration

Definition: movenc.c:64

av_dict_get

AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)

Get a dictionary entry with matching key.

Definition: dict.c:60

webm_dash_manifest_write_packet

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

Definition: webmdashenc.c:520

#define s(width, name)

Definition: cbs_vp9.c:256

AV_OPT_FLAG_ENCODING_PARAM

#define AV_OPT_FLAG_ENCODING_PARAM

a generic parameter which can be set by the user for muxing or encoding

Definition: opt.h:281

AV_OPT_TYPE_DOUBLE

@ AV_OPT_TYPE_DOUBLE

Definition: opt.h:227

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

AV_CODEC_ID_VP9

@ AV_CODEC_ID_VP9

Definition: codec_id.h:220

AVCodecParameters::width

int width

Video only.

Definition: codec_par.h:128

TRACK_NUMBER

#define TRACK_NUMBER

Definition: matroska.h:390

WebMDashMuxContext::representation_id

int representation_id

Definition: webmdashenc.c:55

get_duration

static double get_duration(AVFormatContext *s)

Definition: webmdashenc.c:69

CLUSTER_KEYFRAME

#define CLUSTER_KEYFRAME

Definition: matroska.h:388

ff_webm_dash_manifest_muxer

const FFOutputFormat ff_webm_dash_manifest_muxer

Definition: webmdashenc.c:544

codec_id

enum AVCodecID codec_id

Definition: vaapi_decode.c:388

write_header

static int write_header(AVFormatContext *s)

Definition: webmdashenc.c:82

get_codec_name

static const char * get_codec_name(int codec_id)

Definition: webmdashenc.c:64

time_internal.h

WebMDashMuxContext::is_live

int is_live

Definition: webmdashenc.c:56

AVFormatContext

Format I/O context.

Definition: avformat.h:1104

parse_adaptation_sets

static int parse_adaptation_sets(AVFormatContext *s)

Definition: webmdashenc.c:408

subsegment_alignment

static int subsegment_alignment(AVFormatContext *s, const AdaptationSet *as)

Definition: webmdashenc.c:130

AVStream::codecpar

AVCodecParameters * codecpar

Codec parameters associated with this stream.

Definition: avformat.h:861

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

WebMDashMuxContext::chunk_duration

int chunk_duration

Definition: webmdashenc.c:58

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:66

NULL

#define NULL

Definition: coverity.c:32

AV_CODEC_ID_AV1

@ AV_CODEC_ID_AV1

Definition: codec_id.h:283

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:237

WebMDashMuxContext::adaptation_sets

char * adaptation_sets

Definition: webmdashenc.c:52

AVStream::metadata

AVDictionary * metadata

Definition: avformat.h:918

FFOutputFormat

Definition: mux.h:30

WebMDashMuxContext

Definition: webmdashenc.c:50

CUES_END

#define CUES_END

Definition: matroska.h:384

AVCodecParameters::sample_rate

int sample_rate

Audio only.

Definition: codec_par.h:178

webm_dash_manifest_write_header

static int webm_dash_manifest_write_header(AVFormatContext *s)

Definition: webmdashenc.c:476

AVCodecID

Identify the syntax and semantics of the bitstream.

Definition: codec_id.h:49

AVCodecParameters::extradata_size

int extradata_size

Size of the extradata content in bytes.

Definition: codec_par.h:80

AVIOContext

Bytestream IO Context.

Definition: avio.h:166

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:115

WebMDashMuxContext::nb_as

int nb_as

Definition: webmdashenc.c:54

AV_CODEC_ID_OPUS

@ AV_CODEC_ID_OPUS

Definition: codec_id.h:498

INITIALIZATION_RANGE

#define INITIALIZATION_RANGE

Definition: matroska.h:382

av_isdigit

static av_const int av_isdigit(int c)

Locale-independent conversion of ASCII isdigit.

Definition: avstring.h:203

av_reallocp_array

int av_reallocp_array(void *ptr, size_t nmemb, size_t size)

Allocate, reallocate an array through a pointer to a pointer.

Definition: mem.c:223

OFFSET

#define OFFSET(x)

Definition: webmdashenc.c:525

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:37

check_matching_height

static int check_matching_height(AVFormatContext *s, const AdaptationSet *as)

Definition: webmdashenc.c:244

FILENAME

#define FILENAME

Definition: matroska.h:385

WebMDashMuxContext::chunk_start_index

int chunk_start_index

Definition: webmdashenc.c:57

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

Definition: cbs_h2645.c:269

BANDWIDTH

#define BANDWIDTH

Definition: matroska.h:386

AVCodecParameters::height

int height

Definition: codec_par.h:129

DURATION

#define DURATION

Definition: matroska.h:387

AdaptationSet

Definition: dashenc.c:87

CUE_TIMESTAMPS

#define CUE_TIMESTAMPS

Definition: matroska.h:389

write_packet

static int write_packet(Muxer *mux, OutputStream *ost, AVPacket *pkt)

Definition: ffmpeg_mux.c:61

write_adaptation_set

static int write_adaptation_set(AVFormatContext *s, int as_index)

Definition: webmdashenc.c:304

ret

Definition: filter_design.txt:187

AVFMT_FLAG_BITEXACT

#define AVFMT_FLAG_BITEXACT

When muxing, try to avoid writing any random/volatile data to the output.

Definition: avformat.h:1239

AVStream

Stream structure.

Definition: avformat.h:838

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:71

options

static const AVOption options[]

Definition: webmdashenc.c:526

WebMDashMuxContext::minimum_update_period

int minimum_update_period

Definition: webmdashenc.c:61

avformat.h

dict.h

avio_printf

int avio_printf(AVIOContext *s, const char *fmt,...) av_printf_format(2

Writes a formatted string to the context.

webm_dash_class

static const AVClass webm_dash_class

Definition: webmdashenc.c:537

AV_OPT_TYPE_INT

@ AV_OPT_TYPE_INT

Definition: opt.h:225

WebMDashMuxContext::time_shift_buffer_depth

double time_shift_buffer_depth

Definition: webmdashenc.c:60

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

AVDictionaryEntry

Definition: dict.h:89

AVCodecParameters::codec_id

enum AVCodecID codec_id

Specific type of the encoded data (the codec used).

Definition: codec_par.h:62

AVPacket

This structure stores compressed data.

Definition: packet.h:351

AV_OPT_TYPE_BOOL

@ AV_OPT_TYPE_BOOL

Definition: opt.h:244

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:34

AV_CODEC_ID_VP8

@ AV_CODEC_ID_VP8

Definition: codec_id.h:192

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:86

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:27

avcodec_descriptor_get

const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)

Definition: codec_desc.c:3664

AV_CODEC_ID_VORBIS

@ AV_CODEC_ID_VORBIS

Definition: codec_id.h:443

AVDictionaryEntry::value

char * value

Definition: dict.h:91

avstring.h

AV_OPT_TYPE_STRING

@ AV_OPT_TYPE_STRING

Definition: opt.h:229

state

static struct @345 state

WebMDashMuxContext::as

AdaptationSet * as

Definition: webmdashenc.c:53

codec_desc.h

WebMDashMuxContext::utc_timing_url

char * utc_timing_url

Definition: webmdashenc.c:59

snprintf

#define snprintf

Definition: snprintf.h:34

av_realloc

void * av_realloc(void *ptr, size_t size)

Allocate, reallocate, or free a block of memory.

Definition: mem.c:153

mux.h

Generated on Tue Feb 28 2023 21:34:11 for FFmpeg by doxygen 1.8.17