FFmpeg: libavformat/imfdec.c Source File

FFmpeg
imfdec.c
Go to the documentation of this file.
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with FFmpeg; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18 
19 /*
20  *
21  * Copyright (c) Sandflow Consulting LLC
22  *
23  * Redistribution and use in source and binary forms, with or without
24  * modification, are permitted provided that the following conditions are met:
25  *
26  * * Redistributions of source code must retain the above copyright notice, this
27  * list of conditions and the following disclaimer.
28  * * Redistributions in binary form must reproduce the above copyright notice,
29  * this list of conditions and the following disclaimer in the documentation
30  * and/or other materials provided with the distribution.
31  *
32  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
33  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
34  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
35  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
36  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
37  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
38  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
39  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
40  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
41  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
42  * POSSIBILITY OF SUCH DAMAGE.
43  */
44 
45 /**
46  * Demuxes an IMF Composition
47  *
48  * References
49  * OV 2067-0:2018 - SMPTE Overview Document - Interoperable Master Format
50  * ST 2067-2:2020 - SMPTE Standard - Interoperable Master Format — Core Constraints
51  * ST 2067-3:2020 - SMPTE Standard - Interoperable Master Format — Composition Playlist
52  * ST 2067-5:2020 - SMPTE Standard - Interoperable Master Format — Essence Component
53  * ST 2067-20:2016 - SMPTE Standard - Interoperable Master Format — Application #2
54  * ST 2067-21:2020 - SMPTE Standard - Interoperable Master Format — Application #2 Extended
55  * ST 2067-102:2017 - SMPTE Standard - Interoperable Master Format — Common Image Pixel Color Schemes
56  * ST 429-9:2007 - SMPTE Standard - D-Cinema Packaging — Asset Mapping and File Segmentation
57  *
58  * @author Marc-Antoine Arnaud
59  * @author Valentin Noel
60  * @author Nicholas Vanderzwet
61  * @file
62  * @ingroup lavu_imf
63  */
64 
65 #include "avio_internal.h"
66 #include "demux.h"
67 #include "imf.h"
68 #include "internal.h"
69 #include "libavcodec/packet.h"
70 #include "libavutil/avstring.h"
71 #include "libavutil/bprint.h"
72 #include "libavutil/intreadwrite.h"
73 #include "libavutil/opt.h"
74 #include "mxf.h"
75 #include <inttypes.h>
76 #include <libxml/parser.h>
77 
78  #define AVRATIONAL_FORMAT "%d/%d"
79  #define AVRATIONAL_ARG(rational) rational.num, rational.den
80 
81 /**
82  * IMF Asset locator
83  */
84  typedef struct IMFAssetLocator {
85   AVUUID uuid;
86   char *absolute_uri;
87 } IMFAssetLocator;
88 
89 /**
90  * IMF Asset locator map
91  * Results from the parsing of one or more ASSETMAP XML files
92  */
93  typedef struct IMFAssetLocatorMap {
94   uint32_t asset_count;
95   IMFAssetLocator *assets;
96 } IMFAssetLocatorMap;
97 
98  typedef struct IMFVirtualTrackResourcePlaybackCtx {
99   IMFAssetLocator *locator; /**< Location of the resource */
100   FFIMFTrackFileResource *resource; /**< Underlying IMF CPL resource */
101   AVFormatContext *ctx; /**< Context associated with the resource */
102   AVRational start_time; /**< inclusive start time of the resource on the CPL timeline (s) */
103   AVRational end_time; /**< exclusive end time of the resource on the CPL timeline (s) */
104   AVRational ts_offset; /**< start_time minus the entry point into the resource (s) */
105 } IMFVirtualTrackResourcePlaybackCtx;
106 
107  typedef struct IMFVirtualTrackPlaybackCtx {
108   int32_t index; /**< Track index in playlist */
109   AVRational current_timestamp; /**< Current temporal position */
110   AVRational duration; /**< Overall duration */
111   uint32_t resource_count; /**< Number of resources (<= INT32_MAX) */
112   unsigned int resources_alloc_sz; /**< Size of the buffer holding the resource */
113   IMFVirtualTrackResourcePlaybackCtx *resources; /**< Buffer holding the resources */
114   int32_t current_resource_index; /**< Index of the current resource in resources,
115  or < 0 if a current resource has yet to be selected */
116 } IMFVirtualTrackPlaybackCtx;
117 
118  typedef struct IMFContext {
119   const AVClass *class;
120   const char *base_url;
121   char *asset_map_paths;
122   AVIOInterruptCB *interrupt_callback;
123   AVDictionary *avio_opts;
124   FFIMFCPL *cpl;
125   IMFAssetLocatorMap asset_locator_map;
126   uint32_t track_count;
127   IMFVirtualTrackPlaybackCtx **tracks;
128 } IMFContext;
129 
130  static int imf_uri_is_url(const char *string)
131 {
132  return strstr(string, "://") != NULL;
133 }
134 
135  static int imf_uri_is_unix_abs_path(const char *string)
136 {
137  return string[0] == '/';
138 }
139 
140  static int imf_uri_is_dos_abs_path(const char *string)
141 {
142  /* Absolute path case: `C:\path\to\somwhere` */
143  if (string[1] == ':' && string[2] == '\\')
144  return 1;
145 
146  /* Absolute path case: `C:/path/to/somwhere` */
147  if (string[1] == ':' && string[2] == '/')
148  return 1;
149 
150  /* Network path case: `\\path\to\somwhere` */
151  if (string[0] == '\\' && string[1] == '\\')
152  return 1;
153 
154  return 0;
155 }
156 
157  static int imf_time_to_ts(int64_t *ts, AVRational t, AVRational time_base)
158 {
159  int dst_num;
160  int dst_den;
161  AVRational r;
162 
163  r = av_div_q(t, time_base);
164 
165  if ((av_reduce(&dst_num, &dst_den, r.num, r.den, INT64_MAX) != 1))
166  return 1;
167 
168  if (dst_den != 1)
169  return 1;
170 
171  *ts = dst_num;
172 
173  return 0;
174 }
175 
176 /**
177  * Parse a ASSETMAP XML file to extract the UUID-URI mapping of assets.
178  * @param s the current format context, if any (can be NULL).
179  * @param doc the XML document to be parsed.
180  * @param asset_map pointer on the IMFAssetLocatorMap to fill.
181  * @param base_url the url of the asset map XML file, if any (can be NULL).
182  * @return a negative value in case of error, 0 otherwise.
183  */
184  static int parse_imf_asset_map_from_xml_dom(AVFormatContext *s,
185  xmlDocPtr doc,
186  IMFAssetLocatorMap *asset_map,
187  const char *base_url)
188 {
189  xmlNodePtr asset_map_element = NULL;
190  xmlNodePtr node = NULL;
191  xmlNodePtr asset_element = NULL;
192  unsigned long elem_count;
193  char *uri;
194  int ret = 0;
195  IMFAssetLocator *asset = NULL;
196  void *tmp;
197 
198  asset_map_element = xmlDocGetRootElement(doc);
199 
200  if (!asset_map_element) {
201  av_log(s, AV_LOG_ERROR, "Unable to parse asset map XML - missing root node\n");
202  return AVERROR_INVALIDDATA;
203  }
204 
205  if (asset_map_element->type != XML_ELEMENT_NODE || av_strcasecmp(asset_map_element->name, "AssetMap")) {
206  av_log(s, AV_LOG_ERROR, "Unable to parse asset map XML - wrong root node name[%s] type[%d]\n",
207  asset_map_element->name, (int)asset_map_element->type);
208  return AVERROR_INVALIDDATA;
209  }
210 
211  /* parse asset locators */
212  if (!(node = ff_imf_xml_get_child_element_by_name(asset_map_element, "AssetList"))) {
213  av_log(s, AV_LOG_ERROR, "Unable to parse asset map XML - missing AssetList node\n");
214  return AVERROR_INVALIDDATA;
215  }
216  elem_count = xmlChildElementCount(node);
217  if (elem_count > UINT32_MAX
218  || asset_map->asset_count > UINT32_MAX - elem_count)
219  return AVERROR(ENOMEM);
220  tmp = av_realloc_array(asset_map->assets,
221  elem_count + asset_map->asset_count,
222  sizeof(IMFAssetLocator));
223  if (!tmp) {
224  av_log(s, AV_LOG_ERROR, "Cannot allocate IMF asset locators\n");
225  return AVERROR(ENOMEM);
226  }
227  asset_map->assets = tmp;
228 
229  asset_element = xmlFirstElementChild(node);
230  while (asset_element) {
231  if (av_strcasecmp(asset_element->name, "Asset") != 0)
232  continue;
233 
234  asset = &(asset_map->assets[asset_map->asset_count]);
235 
236  if (!(node = ff_imf_xml_get_child_element_by_name(asset_element, "Id"))) {
237  av_log(s, AV_LOG_ERROR, "Unable to parse asset map XML - missing Id node\n");
238  return AVERROR_INVALIDDATA;
239  }
240 
241  if (ff_imf_xml_read_uuid(node, asset->uuid)) {
242  av_log(s, AV_LOG_ERROR, "Could not parse UUID from asset in asset map.\n");
243  return AVERROR_INVALIDDATA;
244  }
245 
246  av_log(s, AV_LOG_DEBUG, "Found asset id: " AV_PRI_URN_UUID "\n", AV_UUID_ARG(asset->uuid));
247 
248  if (!(node = ff_imf_xml_get_child_element_by_name(asset_element, "ChunkList"))) {
249  av_log(s, AV_LOG_ERROR, "Unable to parse asset map XML - missing ChunkList node\n");
250  return AVERROR_INVALIDDATA;
251  }
252 
253  if (!(node = ff_imf_xml_get_child_element_by_name(node, "Chunk"))) {
254  av_log(s, AV_LOG_ERROR, "Unable to parse asset map XML - missing Chunk node\n");
255  return AVERROR_INVALIDDATA;
256  }
257 
258  uri = xmlNodeGetContent(ff_imf_xml_get_child_element_by_name(node, "Path"));
259  if (!imf_uri_is_url(uri) && !imf_uri_is_unix_abs_path(uri) && !imf_uri_is_dos_abs_path(uri))
260  asset->absolute_uri = av_append_path_component(base_url, uri);
261  else
262  asset->absolute_uri = av_strdup(uri);
263  xmlFree(uri);
264  if (!asset->absolute_uri)
265  return AVERROR(ENOMEM);
266 
267  av_log(s, AV_LOG_DEBUG, "Found asset absolute URI: %s\n", asset->absolute_uri);
268 
269  asset_map->asset_count++;
270  asset_element = xmlNextElementSibling(asset_element);
271  }
272 
273  return ret;
274 }
275 
276 /**
277  * Initializes an IMFAssetLocatorMap structure.
278  */
279  static void imf_asset_locator_map_init(IMFAssetLocatorMap *asset_map)
280 {
281  asset_map->assets = NULL;
282  asset_map->asset_count = 0;
283 }
284 
285 /**
286  * Free a IMFAssetLocatorMap pointer.
287  */
288  static void imf_asset_locator_map_deinit(IMFAssetLocatorMap *asset_map)
289 {
290  for (uint32_t i = 0; i < asset_map->asset_count; i++)
291  av_freep(&asset_map->assets[i].absolute_uri);
292 
293  av_freep(&asset_map->assets);
294 }
295 
296  static int parse_assetmap(AVFormatContext *s, const char *url)
297 {
298  IMFContext *c = s->priv_data;
299  AVIOContext *in = NULL;
300  struct AVBPrint buf;
301  AVDictionary *opts = NULL;
302  xmlDoc *doc = NULL;
303  const char *base_url;
304  char *tmp_str = NULL;
305  int ret;
306 
307  av_log(s, AV_LOG_DEBUG, "Asset Map URL: %s\n", url);
308 
309  av_dict_copy(&opts, c->avio_opts, 0);
310  ret = s->io_open(s, &in, url, AVIO_FLAG_READ, &opts);
311  av_dict_free(&opts);
312  if (ret < 0)
313  return ret;
314 
315  av_bprint_init(&buf, 0, INT_MAX); // xmlReadMemory uses integer length
316 
317  ret = avio_read_to_bprint(in, &buf, SIZE_MAX);
318  if (ret < 0 || !avio_feof(in)) {
319  av_log(s, AV_LOG_ERROR, "Unable to read to asset map '%s'\n", url);
320  if (ret == 0)
321  ret = AVERROR_INVALIDDATA;
322  goto clean_up;
323  }
324 
325  LIBXML_TEST_VERSION
326 
327  tmp_str = av_strdup(url);
328  if (!tmp_str) {
329  ret = AVERROR(ENOMEM);
330  goto clean_up;
331  }
332  base_url = av_dirname(tmp_str);
333 
334  doc = xmlReadMemory(buf.str, buf.len, url, NULL, 0);
335 
336  ret = parse_imf_asset_map_from_xml_dom(s, doc, &c->asset_locator_map, base_url);
337  if (!ret)
338  av_log(s, AV_LOG_DEBUG, "Found %d assets from %s\n",
339  c->asset_locator_map.asset_count, url);
340 
341  xmlFreeDoc(doc);
342 
343 clean_up:
344  if (tmp_str)
345  av_freep(&tmp_str);
346  ff_format_io_close(s, &in);
347  av_bprint_finalize(&buf, NULL);
348  return ret;
349 }
350 
351  static IMFAssetLocator *find_asset_map_locator(IMFAssetLocatorMap *asset_map, AVUUID uuid)
352 {
353  for (uint32_t i = 0; i < asset_map->asset_count; i++) {
354  if (memcmp(asset_map->assets[i].uuid, uuid, 16) == 0)
355  return &(asset_map->assets[i]);
356  }
357  return NULL;
358 }
359 
360  static int open_track_resource_context(AVFormatContext *s,
361  IMFVirtualTrackPlaybackCtx *track,
362  int32_t resource_index)
363 {
364  IMFContext *c = s->priv_data;
365  int ret = 0;
366  int64_t seek_offset = 0;
367  AVDictionary *opts = NULL;
368  AVStream *st;
369  IMFVirtualTrackResourcePlaybackCtx *track_resource = track->resources + resource_index;
370 
371  if (track_resource->ctx) {
372  av_log(s, AV_LOG_DEBUG, "Input context already opened for %s.\n",
373  track_resource->locator->absolute_uri);
374  return 0;
375  }
376 
377  track_resource->ctx = avformat_alloc_context();
378  if (!track_resource->ctx)
379  return AVERROR(ENOMEM);
380 
381  track_resource->ctx->io_open = s->io_open;
382 #if FF_API_AVFORMAT_IO_CLOSE
383 FF_DISABLE_DEPRECATION_WARNINGS
384  track_resource->ctx->io_close = s->io_close;
385 FF_ENABLE_DEPRECATION_WARNINGS
386 #endif
387  track_resource->ctx->io_close2 = s->io_close2;
388  track_resource->ctx->flags |= s->flags & ~AVFMT_FLAG_CUSTOM_IO;
389 
390  if ((ret = ff_copy_whiteblacklists(track_resource->ctx, s)) < 0)
391  goto cleanup;
392 
393  if ((ret = av_opt_set(track_resource->ctx, "format_whitelist", "mxf", 0)))
394  goto cleanup;
395 
396  if ((ret = av_dict_copy(&opts, c->avio_opts, 0)) < 0)
397  goto cleanup;
398 
399  ret = avformat_open_input(&track_resource->ctx,
400  track_resource->locator->absolute_uri,
401  NULL,
402  &opts);
403  if (ret < 0) {
404  av_log(s, AV_LOG_ERROR, "Could not open %s input context: %s\n",
405  track_resource->locator->absolute_uri, av_err2str(ret));
406  goto cleanup;
407  }
408  av_dict_free(&opts);
409 
410  /* make sure there is only one stream in the file */
411 
412  if (track_resource->ctx->nb_streams != 1) {
413  ret = AVERROR_INVALIDDATA;
414  goto cleanup;
415  }
416 
417  st = track_resource->ctx->streams[0];
418 
419  /* Determine the seek offset into the Track File, taking into account:
420  * - the current timestamp within the virtual track
421  * - the entry point of the resource
422  */
423  if (imf_time_to_ts(&seek_offset,
424  av_sub_q(track->current_timestamp, track_resource->ts_offset),
425  st->time_base))
426  av_log(s, AV_LOG_WARNING, "Incoherent stream timebase " AVRATIONAL_FORMAT
427  "and composition timeline position: " AVRATIONAL_FORMAT "\n",
428  AVRATIONAL_ARG(st->time_base), AVRATIONAL_ARG(track->current_timestamp));
429 
430  if (seek_offset) {
431  av_log(s, AV_LOG_DEBUG, "Seek at resource %s entry point: %" PRIi64 "\n",
432  track_resource->locator->absolute_uri, seek_offset);
433  ret = avformat_seek_file(track_resource->ctx, 0, seek_offset, seek_offset, seek_offset, 0);
434  if (ret < 0) {
435  av_log(s,
436  AV_LOG_ERROR,
437  "Could not seek at %" PRId64 "on %s: %s\n",
438  seek_offset,
439  track_resource->locator->absolute_uri,
440  av_err2str(ret));
441  avformat_close_input(&track_resource->ctx);
442  return ret;
443  }
444  }
445 
446  return 0;
447 
448 cleanup:
449  av_dict_free(&opts);
450  avformat_free_context(track_resource->ctx);
451  track_resource->ctx = NULL;
452  return ret;
453 }
454 
455  static int open_track_file_resource(AVFormatContext *s,
456  FFIMFTrackFileResource *track_file_resource,
457  IMFVirtualTrackPlaybackCtx *track)
458 {
459  IMFContext *c = s->priv_data;
460  IMFAssetLocator *asset_locator;
461  void *tmp;
462 
463  asset_locator = find_asset_map_locator(&c->asset_locator_map, track_file_resource->track_file_uuid);
464  if (!asset_locator) {
465  av_log(s, AV_LOG_ERROR, "Could not find asset locator for UUID: " AV_PRI_URN_UUID "\n",
466  AV_UUID_ARG(track_file_resource->track_file_uuid));
467  return AVERROR_INVALIDDATA;
468  }
469 
470  av_log(s,
471  AV_LOG_DEBUG,
472  "Found locator for " AV_PRI_URN_UUID ": %s\n",
473  AV_UUID_ARG(asset_locator->uuid),
474  asset_locator->absolute_uri);
475 
476  if (track->resource_count > INT32_MAX - track_file_resource->base.repeat_count
477  || (track->resource_count + track_file_resource->base.repeat_count)
478  > INT_MAX / sizeof(IMFVirtualTrackResourcePlaybackCtx))
479  return AVERROR(ENOMEM);
480  tmp = av_fast_realloc(track->resources,
481  &track->resources_alloc_sz,
482  (track->resource_count + track_file_resource->base.repeat_count)
483  * sizeof(IMFVirtualTrackResourcePlaybackCtx));
484  if (!tmp)
485  return AVERROR(ENOMEM);
486  track->resources = tmp;
487 
488  for (uint32_t i = 0; i < track_file_resource->base.repeat_count; i++) {
489  IMFVirtualTrackResourcePlaybackCtx vt_ctx;
490 
491  vt_ctx.locator = asset_locator;
492  vt_ctx.resource = track_file_resource;
493  vt_ctx.ctx = NULL;
494  vt_ctx.start_time = track->duration;
495  vt_ctx.ts_offset = av_sub_q(vt_ctx.start_time,
496  av_div_q(av_make_q((int)track_file_resource->base.entry_point, 1),
497  track_file_resource->base.edit_rate));
498  vt_ctx.end_time = av_add_q(track->duration,
499  av_make_q((int)track_file_resource->base.duration
500  * track_file_resource->base.edit_rate.den,
501  track_file_resource->base.edit_rate.num));
502  track->resources[track->resource_count++] = vt_ctx;
503  track->duration = vt_ctx.end_time;
504  }
505 
506  return 0;
507 }
508 
509  static void imf_virtual_track_playback_context_deinit(IMFVirtualTrackPlaybackCtx *track)
510 {
511  for (uint32_t i = 0; i < track->resource_count; i++)
512  avformat_close_input(&track->resources[i].ctx);
513 
514  av_freep(&track->resources);
515 }
516 
517  static int open_virtual_track(AVFormatContext *s,
518  FFIMFTrackFileVirtualTrack *virtual_track,
519  int32_t track_index)
520 {
521  IMFContext *c = s->priv_data;
522  IMFVirtualTrackPlaybackCtx *track = NULL;
523  void *tmp;
524  int ret = 0;
525 
526  if (!(track = av_mallocz(sizeof(IMFVirtualTrackPlaybackCtx))))
527  return AVERROR(ENOMEM);
528  track->current_resource_index = -1;
529  track->index = track_index;
530  track->duration = av_make_q(0, 1);
531 
532  for (uint32_t i = 0; i < virtual_track->resource_count; i++) {
533  av_log(s,
534  AV_LOG_DEBUG,
535  "Open stream from file " AV_PRI_URN_UUID ", stream %d\n",
536  AV_UUID_ARG(virtual_track->resources[i].track_file_uuid),
537  i);
538  if ((ret = open_track_file_resource(s, &virtual_track->resources[i], track)) != 0) {
539  av_log(s,
540  AV_LOG_ERROR,
541  "Could not open image track resource " AV_PRI_URN_UUID "\n",
542  AV_UUID_ARG(virtual_track->resources[i].track_file_uuid));
543  goto clean_up;
544  }
545  }
546 
547  track->current_timestamp = av_make_q(0, track->duration.den);
548 
549  if (c->track_count == UINT32_MAX) {
550  ret = AVERROR(ENOMEM);
551  goto clean_up;
552  }
553  tmp = av_realloc_array(c->tracks, c->track_count + 1, sizeof(IMFVirtualTrackPlaybackCtx *));
554  if (!tmp) {
555  ret = AVERROR(ENOMEM);
556  goto clean_up;
557  }
558  c->tracks = tmp;
559  c->tracks[c->track_count++] = track;
560 
561  return 0;
562 
563 clean_up:
564  imf_virtual_track_playback_context_deinit(track);
565  av_free(track);
566  return ret;
567 }
568 
569  static int set_context_streams_from_tracks(AVFormatContext *s)
570 {
571  IMFContext *c = s->priv_data;
572  int ret = 0;
573 
574  for (uint32_t i = 0; i < c->track_count; i++) {
575  AVStream *asset_stream;
576  AVStream *first_resource_stream;
577 
578  /* Open the first resource of the track to get stream information */
579  ret = open_track_resource_context(s, c->tracks[i], 0);
580  if (ret)
581  return ret;
582  first_resource_stream = c->tracks[i]->resources[0].ctx->streams[0];
583  av_log(s, AV_LOG_DEBUG, "Open the first resource of track %d\n", c->tracks[i]->index);
584 
585  asset_stream = ff_stream_clone(s, first_resource_stream);
586  if (!asset_stream) {
587  av_log(s, AV_LOG_ERROR, "Could not clone stream\n");
588  return AVERROR(ENOMEM);
589  }
590 
591  asset_stream->id = i;
592  asset_stream->nb_frames = 0;
593  avpriv_set_pts_info(asset_stream,
594  first_resource_stream->pts_wrap_bits,
595  first_resource_stream->time_base.num,
596  first_resource_stream->time_base.den);
597  asset_stream->duration = (int64_t)av_q2d(av_mul_q(c->tracks[i]->duration,
598  av_inv_q(asset_stream->time_base)));
599  }
600 
601  return 0;
602 }
603 
604  static int open_cpl_tracks(AVFormatContext *s)
605 {
606  IMFContext *c = s->priv_data;
607  int32_t track_index = 0;
608  int ret;
609 
610  if (c->cpl->main_image_2d_track) {
611  if ((ret = open_virtual_track(s, c->cpl->main_image_2d_track, track_index++)) != 0) {
612  av_log(s, AV_LOG_ERROR, "Could not open image track " AV_PRI_URN_UUID "\n",
613  AV_UUID_ARG(c->cpl->main_image_2d_track->base.id_uuid));
614  return ret;
615  }
616  }
617 
618  for (uint32_t i = 0; i < c->cpl->main_audio_track_count; i++) {
619  if ((ret = open_virtual_track(s, &c->cpl->main_audio_tracks[i], track_index++)) != 0) {
620  av_log(s, AV_LOG_ERROR, "Could not open audio track " AV_PRI_URN_UUID "\n",
621  AV_UUID_ARG(c->cpl->main_audio_tracks[i].base.id_uuid));
622  return ret;
623  }
624  }
625 
626  return set_context_streams_from_tracks(s);
627 }
628 
629  static int imf_read_header(AVFormatContext *s)
630 {
631  IMFContext *c = s->priv_data;
632  char *asset_map_path;
633  char *tmp_str;
634  AVDictionaryEntry* tcr;
635  char tc_buf[AV_TIMECODE_STR_SIZE];
636  int ret = 0;
637 
638  c->interrupt_callback = &s->interrupt_callback;
639  tmp_str = av_strdup(s->url);
640  if (!tmp_str)
641  return AVERROR(ENOMEM);
642  c->base_url = av_strdup(av_dirname(tmp_str));
643  av_freep(&tmp_str);
644  if (!c->base_url)
645  return AVERROR(ENOMEM);
646 
647  if ((ret = ffio_copy_url_options(s->pb, &c->avio_opts)) < 0)
648  return ret;
649 
650  av_log(s, AV_LOG_DEBUG, "start parsing IMF CPL: %s\n", s->url);
651 
652  if ((ret = ff_imf_parse_cpl(s->pb, &c->cpl)) < 0)
653  return ret;
654 
655  tcr = av_dict_get(s->metadata, "timecode", NULL, 0);
656  if (!tcr && c->cpl->tc) {
657  ret = av_dict_set(&s->metadata, "timecode",
658  av_timecode_make_string(c->cpl->tc, tc_buf, 0), 0);
659  if (ret)
660  return ret;
661  av_log(s, AV_LOG_INFO, "Setting timecode to IMF CPL timecode %s\n", tc_buf);
662  }
663 
664  av_log(s,
665  AV_LOG_DEBUG,
666  "parsed IMF CPL: " AV_PRI_URN_UUID "\n",
667  AV_UUID_ARG(c->cpl->id_uuid));
668 
669  if (!c->asset_map_paths) {
670  c->asset_map_paths = av_append_path_component(c->base_url, "ASSETMAP.xml");
671  if (!c->asset_map_paths) {
672  ret = AVERROR(ENOMEM);
673  return ret;
674  }
675  av_log(s, AV_LOG_DEBUG, "No asset maps provided, using the default ASSETMAP.xml\n");
676  }
677 
678  /* Parse each asset map XML file */
679  imf_asset_locator_map_init(&c->asset_locator_map);
680  asset_map_path = av_strtok(c->asset_map_paths, ",", &tmp_str);
681  while (asset_map_path != NULL) {
682  av_log(s, AV_LOG_DEBUG, "start parsing IMF Asset Map: %s\n", asset_map_path);
683 
684  if ((ret = parse_assetmap(s, asset_map_path)))
685  return ret;
686 
687  asset_map_path = av_strtok(NULL, ",", &tmp_str);
688  }
689 
690  av_log(s, AV_LOG_DEBUG, "parsed IMF Asset Maps\n");
691 
692  if ((ret = open_cpl_tracks(s)))
693  return ret;
694 
695  av_log(s, AV_LOG_DEBUG, "parsed IMF package\n");
696 
697  return 0;
698 }
699 
700  static IMFVirtualTrackPlaybackCtx *get_next_track_with_minimum_timestamp(AVFormatContext *s)
701 {
702  IMFContext *c = s->priv_data;
703  IMFVirtualTrackPlaybackCtx *track;
704  AVRational minimum_timestamp = av_make_q(INT32_MAX, 1);
705 
706  if (!c->track_count)
707  return NULL;
708 
709  for (uint32_t i = c->track_count; i > 0; i--) {
710  av_log(s, AV_LOG_TRACE, "Compare track %d timestamp " AVRATIONAL_FORMAT
711  " to minimum " AVRATIONAL_FORMAT
712  " (over duration: " AVRATIONAL_FORMAT ")\n", i,
713  AVRATIONAL_ARG(c->tracks[i - 1]->current_timestamp),
714  AVRATIONAL_ARG(minimum_timestamp),
715  AVRATIONAL_ARG(c->tracks[i - 1]->duration));
716 
717  if (av_cmp_q(c->tracks[i - 1]->current_timestamp, minimum_timestamp) <= 0) {
718  track = c->tracks[i - 1];
719  minimum_timestamp = track->current_timestamp;
720  }
721  }
722 
723  return track;
724 }
725 
726  static int get_resource_context_for_timestamp(AVFormatContext *s, IMFVirtualTrackPlaybackCtx *track, IMFVirtualTrackResourcePlaybackCtx **resource)
727 {
728  *resource = NULL;
729 
730  if (av_cmp_q(track->current_timestamp, track->duration) >= 0) {
731  av_log(s, AV_LOG_DEBUG, "Reached the end of the virtual track\n");
732  return AVERROR_EOF;
733  }
734 
735  av_log(s,
736  AV_LOG_TRACE,
737  "Looking for track %d resource for timestamp = %lf / %lf\n",
738  track->index,
739  av_q2d(track->current_timestamp),
740  av_q2d(track->duration));
741  for (uint32_t i = 0; i < track->resource_count; i++) {
742 
743  if (av_cmp_q(track->resources[i].end_time, track->current_timestamp) > 0) {
744  av_log(s, AV_LOG_DEBUG, "Found resource %d in track %d to read at timestamp %lf: "
745  "entry=%" PRIu32 ", duration=%" PRIu32 ", editrate=" AVRATIONAL_FORMAT "\n",
746  i, track->index, av_q2d(track->current_timestamp),
747  track->resources[i].resource->base.entry_point,
748  track->resources[i].resource->base.duration,
749  AVRATIONAL_ARG(track->resources[i].resource->base.edit_rate));
750 
751  if (track->current_resource_index != i) {
752  int ret;
753 
754  av_log(s, AV_LOG_TRACE, "Switch resource on track %d: re-open context\n",
755  track->index);
756 
757  ret = open_track_resource_context(s, track, i);
758  if (ret != 0)
759  return ret;
760  if (track->current_resource_index > 0)
761  avformat_close_input(&track->resources[track->current_resource_index].ctx);
762  track->current_resource_index = i;
763  }
764 
765  *resource = track->resources + track->current_resource_index;
766  return 0;
767  }
768  }
769 
770  av_log(s, AV_LOG_ERROR, "Could not find IMF track resource to read\n");
771  return AVERROR_STREAM_NOT_FOUND;
772 }
773 
774  static int imf_read_packet(AVFormatContext *s, AVPacket *pkt)
775 {
776  IMFVirtualTrackResourcePlaybackCtx *resource = NULL;
777  int ret = 0;
778  IMFVirtualTrackPlaybackCtx *track;
779  int64_t delta_ts;
780  AVStream *st;
781  AVRational next_timestamp;
782 
783  track = get_next_track_with_minimum_timestamp(s);
784 
785  if (!track) {
786  av_log(s, AV_LOG_ERROR, "No track found for playback\n");
787  return AVERROR_INVALIDDATA;
788  }
789 
790  av_log(s, AV_LOG_DEBUG, "Found track %d to read at timestamp %lf\n",
791  track->index, av_q2d(track->current_timestamp));
792 
793  ret = get_resource_context_for_timestamp(s, track, &resource);
794  if (ret)
795  return ret;
796 
797  ret = av_read_frame(resource->ctx, pkt);
798  if (ret)
799  return ret;
800 
801  av_log(s, AV_LOG_DEBUG, "Got packet: pts=%" PRId64 ", dts=%" PRId64
802  ", duration=%" PRId64 ", stream_index=%d, pos=%" PRId64
803  ", time_base=" AVRATIONAL_FORMAT "\n", pkt->pts, pkt->dts, pkt->duration,
804  pkt->stream_index, pkt->pos, AVRATIONAL_ARG(pkt->time_base));
805 
806  /* IMF resources contain only one stream */
807 
808  if (pkt->stream_index != 0)
809  return AVERROR_INVALIDDATA;
810  st = resource->ctx->streams[0];
811 
812  pkt->stream_index = track->index;
813 
814  /* adjust the packet PTS and DTS based on the temporal position of the resource within the timeline */
815 
816  ret = imf_time_to_ts(&delta_ts, resource->ts_offset, st->time_base);
817 
818  if (!ret) {
819  if (pkt->pts != AV_NOPTS_VALUE)
820  pkt->pts += delta_ts;
821  if (pkt->dts != AV_NOPTS_VALUE)
822  pkt->dts += delta_ts;
823  } else {
824  av_log(s, AV_LOG_WARNING, "Incoherent time stamp " AVRATIONAL_FORMAT
825  " for time base " AVRATIONAL_FORMAT,
826  AVRATIONAL_ARG(resource->ts_offset),
827  AVRATIONAL_ARG(pkt->time_base));
828  }
829 
830  /* advance the track timestamp by the packet duration */
831 
832  next_timestamp = av_add_q(track->current_timestamp,
833  av_mul_q(av_make_q((int)pkt->duration, 1), st->time_base));
834 
835  /* if necessary, clamp the next timestamp to the end of the current resource */
836 
837  if (av_cmp_q(next_timestamp, resource->end_time) > 0) {
838 
839  int64_t new_pkt_dur;
840 
841  /* shrink the packet duration */
842 
843  ret = imf_time_to_ts(&new_pkt_dur,
844  av_sub_q(resource->end_time, track->current_timestamp),
845  st->time_base);
846 
847  if (!ret)
848  pkt->duration = new_pkt_dur;
849  else
850  av_log(s, AV_LOG_WARNING, "Incoherent time base in packet duration calculation\n");
851 
852  /* shrink the packet itself for audio essence */
853 
854  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
855 
856  if (st->codecpar->codec_id == AV_CODEC_ID_PCM_S24LE) {
857  /* AV_CODEC_ID_PCM_S24LE is the only PCM format supported in IMF */
858  /* in this case, explicitly shrink the packet */
859 
860  int bytes_per_sample = av_get_exact_bits_per_sample(st->codecpar->codec_id) >> 3;
861  int64_t nbsamples = av_rescale_q(pkt->duration,
862  st->time_base,
863  av_make_q(1, st->codecpar->sample_rate));
864  av_shrink_packet(pkt, nbsamples * st->codecpar->ch_layout.nb_channels * bytes_per_sample);
865 
866  } else {
867  /* in all other cases, use side data to skip samples */
868  int64_t skip_samples;
869 
870  ret = imf_time_to_ts(&skip_samples,
871  av_sub_q(next_timestamp, resource->end_time),
872  av_make_q(1, st->codecpar->sample_rate));
873 
874  if (ret || skip_samples < 0 || skip_samples > UINT32_MAX) {
875  av_log(s, AV_LOG_WARNING, "Cannot skip audio samples\n");
876  } else {
877  uint8_t *side_data = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
878  if (!side_data)
879  return AVERROR(ENOMEM);
880 
881  AV_WL32(side_data + 4, skip_samples); /* skip from end of this packet */
882  side_data[6] = 1; /* reason for end is convergence */
883  }
884  }
885 
886  next_timestamp = resource->end_time;
887 
888  } else {
889  av_log(s, AV_LOG_WARNING, "Non-audio packet duration reduced\n");
890  }
891  }
892 
893  track->current_timestamp = next_timestamp;
894 
895  return 0;
896 }
897 
898  static int imf_close(AVFormatContext *s)
899 {
900  IMFContext *c = s->priv_data;
901 
902  av_log(s, AV_LOG_DEBUG, "Close IMF package\n");
903  av_dict_free(&c->avio_opts);
904  av_freep(&c->base_url);
905  imf_asset_locator_map_deinit(&c->asset_locator_map);
906  ff_imf_cpl_free(c->cpl);
907 
908  for (uint32_t i = 0; i < c->track_count; i++) {
909  imf_virtual_track_playback_context_deinit(c->tracks[i]);
910  av_freep(&c->tracks[i]);
911  }
912 
913  av_freep(&c->tracks);
914 
915  return 0;
916 }
917 
918  static int imf_probe(const AVProbeData *p)
919 {
920  if (!strstr(p->buf, "<CompositionPlaylist"))
921  return 0;
922 
923  /* check for a ContentTitle element without including ContentTitleText,
924  * which is used by the D-Cinema CPL.
925  */
926  if (!strstr(p->buf, "ContentTitle>"))
927  return 0;
928 
929  return AVPROBE_SCORE_MAX;
930 }
931 
932  static int coherent_ts(int64_t ts, AVRational in_tb, AVRational out_tb)
933 {
934  int dst_num;
935  int dst_den;
936  int ret;
937 
938  ret = av_reduce(&dst_num, &dst_den, ts * in_tb.num * out_tb.den,
939  in_tb.den * out_tb.num, INT64_MAX);
940  if (!ret || dst_den != 1)
941  return 0;
942 
943  return 1;
944 }
945 
946  static int imf_seek(AVFormatContext *s, int stream_index, int64_t min_ts,
947  int64_t ts, int64_t max_ts, int flags)
948 {
949  IMFContext *c = s->priv_data;
950  uint32_t i;
951 
952  if (flags & (AVSEEK_FLAG_BYTE | AVSEEK_FLAG_FRAME))
953  return AVERROR(ENOSYS);
954 
955  /* rescale timestamps to Composition edit units */
956  if (stream_index < 0)
957  ff_rescale_interval(AV_TIME_BASE_Q,
958  av_make_q(c->cpl->edit_rate.den, c->cpl->edit_rate.num),
959  &min_ts, &ts, &max_ts);
960  else
961  ff_rescale_interval(s->streams[stream_index]->time_base,
962  av_make_q(c->cpl->edit_rate.den, c->cpl->edit_rate.num),
963  &min_ts, &ts, &max_ts);
964 
965  /* requested timestamp bounds are too close */
966  if (max_ts < min_ts)
967  return -1;
968 
969  /* clamp requested timestamp to provided bounds */
970  ts = FFMAX(FFMIN(ts, max_ts), min_ts);
971 
972  av_log(s, AV_LOG_DEBUG, "Seeking to Composition Playlist edit unit %" PRIi64 "\n", ts);
973 
974  /* set the dts of each stream and temporal offset of each track */
975  for (i = 0; i < c->track_count; i++) {
976  AVStream *st = s->streams[i];
977  IMFVirtualTrackPlaybackCtx *t = c->tracks[i];
978  int64_t dts;
979 
980  if (!coherent_ts(ts, av_make_q(c->cpl->edit_rate.den, c->cpl->edit_rate.num),
981  st->time_base))
982  av_log(s, AV_LOG_WARNING, "Seek position is not coherent across tracks\n");
983 
984  dts = av_rescale(ts,
985  st->time_base.den * c->cpl->edit_rate.den,
986  st->time_base.num * c->cpl->edit_rate.num);
987 
988  av_log(s, AV_LOG_DEBUG, "Seeking to dts=%" PRId64 " on stream_index=%d\n",
989  dts, i);
990 
991  t->current_timestamp = av_mul_q(av_make_q(dts, 1), st->time_base);
992  if (t->current_resource_index >= 0) {
993  avformat_close_input(&t->resources[t->current_resource_index].ctx);
994  t->current_resource_index = -1;
995  }
996  }
997 
998  return 0;
999 }
1000 
1001  static const AVOption imf_options[] = {
1002  {
1003  .name = "assetmaps",
1004  .help = "Comma-separated paths to ASSETMAP files."
1005  "If not specified, the `ASSETMAP.xml` file in the same "
1006  "directory as the CPL is used.",
1007  .offset = offsetof(IMFContext, asset_map_paths),
1008  .type = AV_OPT_TYPE_STRING,
1009  .default_val = {.str = NULL},
1010  .flags = AV_OPT_FLAG_DECODING_PARAM,
1011  },
1012  {NULL},
1013 };
1014 
1015  static const AVClass imf_class = {
1016  .class_name = "imf",
1017  .item_name = av_default_item_name,
1018  .option = imf_options,
1019  .version = LIBAVUTIL_VERSION_INT,
1020 };
1021 
1022  const AVInputFormat ff_imf_demuxer = {
1023  .name = "imf",
1024  .long_name = NULL_IF_CONFIG_SMALL("IMF (Interoperable Master Format)"),
1025  .flags = AVFMT_EXPERIMENTAL | AVFMT_NO_BYTE_SEEK,
1026  .flags_internal = FF_FMT_INIT_CLEANUP,
1027  .priv_class = &imf_class,
1028  .priv_data_size = sizeof(IMFContext),
1029  .read_probe = imf_probe,
1030  .read_header = imf_read_header,
1031  .read_packet = imf_read_packet,
1032  .read_close = imf_close,
1033  .read_seek2 = imf_seek,
1034 };
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:82
FFIMFTrackFileVirtualTrack::resources
FFIMFTrackFileResource * resources
Resource elements of the Virtual Track.
Definition: imf.h:114
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AV_TIMECODE_STR_SIZE
#define AV_TIMECODE_STR_SIZE
Definition: timecode.h:33
IMFVirtualTrackResourcePlaybackCtx::ts_offset
AVRational ts_offset
start_time minus the entry point into the resource (s)
Definition: imfdec.c:104
AVFMT_NO_BYTE_SEEK
#define AVFMT_NO_BYTE_SEEK
Format does not allow seeking by bytes.
Definition: avformat.h:487
ffio_copy_url_options
int ffio_copy_url_options(AVIOContext *pb, AVDictionary **avio_opts)
Read url related dictionary options from the AVIOContext and write to the given dictionary.
Definition: aviobuf.c:1015
FF_FMT_INIT_CLEANUP
#define FF_FMT_INIT_CLEANUP
For an AVInputFormat with this flag set read_close() needs to be called by the caller upon read_heade...
Definition: internal.h:47
r
const char * r
Definition: vf_curves.c:126
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
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:58
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
set_context_streams_from_tracks
static int set_context_streams_from_tracks(AVFormatContext *s)
Definition: imfdec.c:569
AVUUID
uint8_t AVUUID[AV_UUID_LEN]
Definition: uuid.h:60
AVSEEK_FLAG_FRAME
#define AVSEEK_FLAG_FRAME
seeking based on frame number
Definition: avformat.h:2197
av_bprint_init
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
parse_assetmap
static int parse_assetmap(AVFormatContext *s, const char *url)
Definition: imfdec.c:296
AV_UUID_ARG
#define AV_UUID_ARG(x)
Definition: uuid.h:51
track_index
static int track_index(VividasDemuxContext *viv, AVFormatContext *s, uint8_t *buf, unsigned size)
Definition: vividas.c:435
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
IMFVirtualTrackResourcePlaybackCtx
Definition: imfdec.c:98
av_div_q
AVRational av_div_q(AVRational b, AVRational c)
Divide one rational by another.
Definition: rational.c:88
imf_close
static int imf_close(AVFormatContext *s)
Definition: imfdec.c:898
find_asset_map_locator
static IMFAssetLocator * find_asset_map_locator(IMFAssetLocatorMap *asset_map, AVUUID uuid)
Definition: imfdec.c:351
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
av_strcasecmp
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:208
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
cleanup
static av_cold void cleanup(FlashSV2Context *s)
Definition: flashsv2enc.c:130
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1172
FFIMFTrackFileVirtualTrack::resource_count
uint32_t resource_count
Number of Resource elements present in the Virtual Track.
Definition: imf.h:113
AVOption
AVOption.
Definition: opt.h:251
AVFMT_FLAG_CUSTOM_IO
#define AVFMT_FLAG_CUSTOM_IO
The caller has supplied a custom AVIOContext, don't avio_close() it.
Definition: avformat.h:1230
AVSEEK_FLAG_BYTE
#define AVSEEK_FLAG_BYTE
seeking based on position in bytes
Definition: avformat.h:2195
IMFVirtualTrackResourcePlaybackCtx::start_time
AVRational start_time
inclusive start time of the resource on the CPL timeline (s)
Definition: imfdec.c:102
IMFContext::asset_locator_map
IMFAssetLocatorMap asset_locator_map
Definition: imfdec.c:125
imf_probe
static int imf_probe(const AVProbeData *p)
Definition: imfdec.c:918
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:392
AVDictionary
Definition: dict.c:32
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
av_sub_q
AVRational av_sub_q(AVRational b, AVRational c)
Subtract one rational from another.
Definition: rational.c:101
av_read_frame
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
Definition: demux.c:1439
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:311
IMFContext::asset_map_paths
char * asset_map_paths
Definition: imfdec.c:121
IMFAssetLocatorMap::asset_count
uint32_t asset_count
Definition: imfdec.c:94
AVIOInterruptCB
Callback for checking whether to abort blocking functions.
Definition: avio.h:59
imf_uri_is_unix_abs_path
static int imf_uri_is_unix_abs_path(const char *string)
Definition: imfdec.c:135
av_append_path_component
char * av_append_path_component(const char *path, const char *component)
Append path component to the existing path.
Definition: avstring.c:297
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:463
avformat_close_input
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: demux.c:369
coherent_ts
static int coherent_ts(int64_t ts, AVRational in_tb, AVRational out_tb)
Definition: imfdec.c:932
AVRATIONAL_ARG
#define AVRATIONAL_ARG(rational)
Definition: imfdec.c:79
mxf.h
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: avformat.c:771
imf_uri_is_dos_abs_path
static int imf_uri_is_dos_abs_path(const char *string)
Definition: imfdec.c:140
IMFVirtualTrackPlaybackCtx::resource_count
uint32_t resource_count
Number of resources (<= INT32_MAX)
Definition: imfdec.c:111
av_shrink_packet
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: avpacket.c:112
ff_imf_cpl_free
void ff_imf_cpl_free(FFIMFCPL *cpl)
Deletes an FFIMFCPL data structure previously instantiated with ff_imf_cpl_alloc().
Definition: imf_cpl.c:851
av_timecode_make_string
char * av_timecode_make_string(const AVTimecode *tc, char *buf, int framenum)
Load timecode string in buf.
Definition: timecode.c:103
read_close
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:143
FFIMFBaseResource::duration
uint32_t duration
BaseResourceType/Duration.
Definition: imf.h:71
ff_imf_xml_get_child_element_by_name
xmlNodePtr ff_imf_xml_get_child_element_by_name(xmlNodePtr parent, const char *name_utf8)
Returns the first child element with the specified local name.
Definition: imf_cpl.c:59
av_opt_set
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:487
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:897
av_reduce
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
AVRational::num
int num
Numerator.
Definition: rational.h:59
av_dirname
const char * av_dirname(char *path)
Thread safe dirname.
Definition: avstring.c:276
IMFAssetLocator::uuid
AVUUID uuid
Definition: imfdec.c:85
open_track_file_resource
static int open_track_file_resource(AVFormatContext *s, FFIMFTrackFileResource *track_file_resource, IMFVirtualTrackPlaybackCtx *track)
Definition: imfdec.c:455
IMFContext::track_count
uint32_t track_count
Definition: imfdec.c:126
imf_seek
static int imf_seek(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
Definition: imfdec.c:946
AV_LOG_TRACE
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:206
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
AVInputFormat
Definition: avformat.h:546
FFIMFTrackFileVirtualTrack
IMF Composition Playlist Virtual Track that consists of Track File Resources.
Definition: imf.h:111
avformat_open_input
int avformat_open_input(AVFormatContext **ps, const char *url, const AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
Definition: demux.c:221
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_read_callback.c:41
IMFVirtualTrackPlaybackCtx::current_timestamp
AVRational current_timestamp
Current temporal position.
Definition: imfdec.c:109
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
av_fast_realloc
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given buffer if it is not large enough, otherwise do nothing.
Definition: mem.c:495
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:256
avio_read_to_bprint
int avio_read_to_bprint(AVIOContext *h, struct AVBPrint *pb, size_t max_size)
Read contents of h into print buffer, up to max_size bytes, or up to EOF.
Definition: aviobuf.c:1347
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:215
AVFormatContext::flags
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1222
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:551
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:453
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
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:179
imf_options
static const AVOption imf_options[]
Definition: imfdec.c:1001
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
IMFVirtualTrackResourcePlaybackCtx::locator
IMFAssetLocator * locator
Location of the resource.
Definition: imfdec.c:99
IMFAssetLocator
IMF Asset locator.
Definition: imfdec.c:84
IMFVirtualTrackPlaybackCtx
Definition: imfdec.c:107
get_next_track_with_minimum_timestamp
static IMFVirtualTrackPlaybackCtx * get_next_track_with_minimum_timestamp(AVFormatContext *s)
Definition: imfdec.c:700
IMFVirtualTrackResourcePlaybackCtx::resource
FFIMFTrackFileResource * resource
Underlying IMF CPL resource.
Definition: imfdec.c:100
AVFormatContext
Format I/O context.
Definition: avformat.h:1104
internal.h
IMFVirtualTrackResourcePlaybackCtx::ctx
AVFormatContext * ctx
Context associated with the resource.
Definition: imfdec.c:101
opts
AVDictionary * opts
Definition: movenc.c:50
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
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:545
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
AVStream::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avformat.h:877
NULL
#define NULL
Definition: coverity.c:32
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
ff_copy_whiteblacklists
int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src)
Copies the whilelists from one context to the other.
Definition: avformat.c:815
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:451
ff_rescale_interval
void ff_rescale_interval(AVRational tb_in, AVRational tb_out, int64_t *min_ts, int64_t *ts, int64_t *max_ts)
Rescales a timestamp and the endpoints of an interval to which the temstamp belongs,...
Definition: seek.c:758
imf_uri_is_url
static int imf_uri_is_url(const char *string)
Definition: imfdec.c:130
IMFContext::interrupt_callback
AVIOInterruptCB * interrupt_callback
Definition: imfdec.c:122
get_resource_context_for_timestamp
static int get_resource_context_for_timestamp(AVFormatContext *s, IMFVirtualTrackPlaybackCtx *track, IMFVirtualTrackResourcePlaybackCtx **resource)
Definition: imfdec.c:726
ff_imf_demuxer
const AVInputFormat ff_imf_demuxer
Definition: imfdec.c:1022
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:213
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
open_track_resource_context
static int open_track_resource_context(AVFormatContext *s, IMFVirtualTrackPlaybackCtx *track, int32_t resource_index)
Definition: imfdec.c:360
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:178
IMFAssetLocator::absolute_uri
char * absolute_uri
Definition: imfdec.c:86
AVStream::nb_frames
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:899
IMFVirtualTrackResourcePlaybackCtx::end_time
AVRational end_time
exclusive end time of the resource on the CPL timeline (s)
Definition: imfdec.c:103
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1160
imf_read_packet
static int imf_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: imfdec.c:774
av_get_exact_bits_per_sample
int av_get_exact_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:490
FFIMFBaseResource::edit_rate
AVRational edit_rate
BaseResourceType/EditRate.
Definition: imf.h:69
AVIOContext
Bytestream IO Context.
Definition: avio.h:166
AV_CODEC_ID_PCM_S24LE
@ AV_CODEC_ID_PCM_S24LE
Definition: codec_id.h:338
imf_asset_locator_map_deinit
static void imf_asset_locator_map_deinit(IMFAssetLocatorMap *asset_map)
Free a IMFAssetLocatorMap pointer.
Definition: imfdec.c:288
FFIMFTrackFileResource::track_file_uuid
AVUUID track_file_uuid
TrackFileResourceType/TrackFileId.
Definition: imf.h:80
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
avformat_alloc_context
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:166
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
IMFContext::cpl
FFIMFCPL * cpl
Definition: imfdec.c:124
av_err2str
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:121
imf_asset_locator_map_init
static void imf_asset_locator_map_init(IMFAssetLocatorMap *asset_map)
Initializes an IMFAssetLocatorMap structure.
Definition: imfdec.c:279
av_make_q
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
avformat_seek_file
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
Seek to timestamp ts.
Definition: seek.c:659
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
ff_format_io_close
int ff_format_io_close(AVFormatContext *s, AVIOContext **pb)
Definition: avformat.c:853
AVOption::name
const char * name
Definition: opt.h:252
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:373
AV_PRI_URN_UUID
#define AV_PRI_URN_UUID
Definition: uuid.h:43
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:223
open_cpl_tracks
static int open_cpl_tracks(AVFormatContext *s)
Definition: imfdec.c:604
AVRATIONAL_FORMAT
#define AVRATIONAL_FORMAT
Definition: imfdec.c:78
FFIMFBaseResource::repeat_count
uint32_t repeat_count
BaseResourceType/RepeatCount.
Definition: imf.h:72
IMFVirtualTrackPlaybackCtx::current_resource_index
int32_t current_resource_index
Index of the current resource in resources, or < 0 if a current resource has yet to be selected.
Definition: imfdec.c:114
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
ff_imf_parse_cpl
int ff_imf_parse_cpl(AVIOContext *in, FFIMFCPL **cpl)
Parse an IMF Composition Playlist document into the FFIMFCPL data structure.
Definition: imf_cpl.c:880
bprint.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:367
avio_internal.h
packet.h
FFIMFBaseResource::entry_point
uint32_t entry_point
BaseResourceType/EntryPoint.
Definition: imf.h:70
imf_read_header
static int imf_read_header(AVFormatContext *s)
Definition: imfdec.c:629
AV_OPT_FLAG_DECODING_PARAM
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:282
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
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:254
AVFMT_EXPERIMENTAL
#define AVFMT_EXPERIMENTAL
The muxer/demuxer is experimental and should be used with caution.
Definition: avformat.h:476
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
demux.h
AV_PKT_DATA_SKIP_SAMPLES
@ AV_PKT_DATA_SKIP_SAMPLES
Recommmends skipping the specified number of samples.
Definition: packet.h:157
imf_virtual_track_playback_context_deinit
static void imf_virtual_track_playback_context_deinit(IMFVirtualTrackPlaybackCtx *track)
Definition: imfdec.c:509
IMFVirtualTrackPlaybackCtx::index
int32_t index
Track index in playlist.
Definition: imfdec.c:108
parse_imf_asset_map_from_xml_dom
static int parse_imf_asset_map_from_xml_dom(AVFormatContext *s, xmlDocPtr doc, IMFAssetLocatorMap *asset_map, const char *base_url)
Parse a ASSETMAP XML file to extract the UUID-URI mapping of assets.
Definition: imfdec.c:184
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
imf_time_to_ts
static int imf_time_to_ts(int64_t *ts, AVRational t, AVRational time_base)
Definition: imfdec.c:157
av_cmp_q
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:850
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:838
IMFAssetLocatorMap
IMF Asset locator map Results from the parsing of one or more ASSETMAP XML files.
Definition: imfdec.c:93
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
IMFContext
Definition: imfdec.c:118
IMFVirtualTrackPlaybackCtx::duration
AVRational duration
Overall duration.
Definition: imfdec.c:110
IMFVirtualTrackPlaybackCtx::resources_alloc_sz
unsigned int resources_alloc_sz
Size of the buffer holding the resource.
Definition: imfdec.c:112
FFIMFTrackFileResource
IMF Composition Playlist Track File Resource.
Definition: imf.h:78
av_packet_new_side_data
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, size_t size)
Allocate new information of a packet.
Definition: avpacket.c:230
AVERROR_STREAM_NOT_FOUND
#define AVERROR_STREAM_NOT_FOUND
Stream not found.
Definition: error.h:67
AVRational::den
int den
Denominator.
Definition: rational.h:60
avformat_free_context
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: avformat.c:96
open_virtual_track
static int open_virtual_track(AVFormatContext *s, FFIMFTrackFileVirtualTrack *virtual_track, int32_t track_index)
Definition: imfdec.c:517
IMFContext::avio_opts
AVDictionary * avio_opts
Definition: imfdec.c:123
AVFormatContext::io_open
int(* io_open)(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags, AVDictionary **options)
A callback for opening new IO streams.
Definition: avformat.h:1661
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
AVPacket::stream_index
int stream_index
Definition: packet.h:376
imf_class
static const AVClass imf_class
Definition: imfdec.c:1015
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:81
AVIO_FLAG_READ
#define AVIO_FLAG_READ
read-only
Definition: avio.h:623
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:270
read_probe
static int read_probe(const AVProbeData *p)
Definition: cdg.c:29
IMFContext::tracks
IMFVirtualTrackPlaybackCtx ** tracks
Definition: imfdec.c:127
ff_imf_xml_read_uuid
int ff_imf_xml_read_uuid(xmlNodePtr element, AVUUID uuid)
Reads a UUID from an XML element.
Definition: imf_cpl.c:73
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVDictionaryEntry
Definition: dict.h:89
av_add_q
AVRational av_add_q(AVRational b, AVRational c)
Add two rationals.
Definition: rational.c:93
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:62
ff_stream_clone
AVStream * ff_stream_clone(AVFormatContext *dst_ctx, const AVStream *src)
Create a new stream and copy to it all parameters from a source stream, with the exception of the ind...
Definition: avformat.c:287
AVPacket
This structure stores compressed data.
Definition: packet.h:351
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
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:86
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:237
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:394
AVFormatContext::io_close2
int(* io_close2)(struct AVFormatContext *s, AVIOContext *pb)
A callback for closing the streams opened with AVFormatContext.io_open().
Definition: avformat.h:1713
int32_t
int32_t
Definition: audioconvert.c:56
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
IMFContext::base_url
const char * base_url
Definition: imfdec.c:120
FFIMFCPL
IMF Composition Playlist.
Definition: imf.h:130
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
imf.h
Public header file for the processing of Interoperable Master Format (IMF) packages.
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
IMFVirtualTrackPlaybackCtx::resources
IMFVirtualTrackResourcePlaybackCtx * resources
Buffer holding the resources.
Definition: imfdec.c:113
avstring.h
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:229
AVStream::pts_wrap_bits
int pts_wrap_bits
Number of bits in timestamps.
Definition: avformat.h:1005
FFIMFTrackFileResource::base
FFIMFBaseResource base
Definition: imf.h:79
AVPacket::time_base
AVRational time_base
Time base of the packet's timestamps.
Definition: packet.h:418
IMFAssetLocatorMap::assets
IMFAssetLocator * assets
Definition: imfdec.c:95
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:367
Generated on Tue Feb 28 2023 21:34:05 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /