Ticket #11627: 0001-fix-allow-demuxing-mp4-to-iamf-without-specifying-gr.patch

libavcodec/packet.h

@@ -366 +366 @@
      * Extensible image file format metadata. The payload is a buffer containing
      * EXIF metadata, starting with either 49 49 2a 00, or 4d 4d 00 2a.
      */
-     AV_PKT_DATA_EXIF,
+    AV_PKT_DATA_EXIF,
+
+    /**
+     * IAMF Descriptors parameter associated with the audio frame. This metadata
+     * is in the form of the IAMFContext struct, only used when rewrap MP4 -> IAMF.
+     */
+    AV_PKT_DATA_IAMF_DESCRIPTORS,
 
     /**
      * The number of side data types.

libavformat/dump.c

@@ -532 +532 @@
         case AV_PKT_DATA_3D_REFERENCE_DISPLAYS:
             dump_tdrdi(ctx, sd, log_level);
             break;
+        case AV_PKT_DATA_IAMF_DESCRIPTORS:
+            av_log(ctx, log_level, "IAMF descriptors");
+            break;
         default:
             if (name)
                 av_log(ctx, log_level, "(%zu bytes)", sd->size);

libavformat/iamf_writer.c

@@ -105 +105 @@
     return 0;
 }
 
-static int fill_codec_config(IAMFContext *iamf, const AVStreamGroup *stg,
-                             IAMFCodecConfig *codec_config)
+int ff_iamf_fill_codec_config(IAMFContext *iamf, const AVStreamGroup *stg,
+                              IAMFCodecConfig *codec_config)
 {
     const AVStream *st = stg->streams[0];
     IAMFCodecConfig **tmp;
@@ -309 +309 @@
     if (!codec_config)
         return AVERROR(ENOMEM);
 
-    ret = fill_codec_config(iamf, stg, codec_config);
+    ret = ff_iamf_fill_codec_config(iamf, stg, codec_config);
     if (ret < 0) {
         av_free(codec_config);
         return ret;

libavformat/iamf_writer.h

@@ -32 +32 @@
 int ff_iamf_add_audio_element(IAMFContext *iamf, const AVStreamGroup *stg, void *log_ctx);
 int ff_iamf_add_mix_presentation(IAMFContext *iamf, const AVStreamGroup *stg, void *log_ctx);
 
+int ff_iamf_fill_codec_config(IAMFContext *iamf, const AVStreamGroup *stg,
+                              IAMFCodecConfig *codec_config);
+
 int ff_iamf_write_descriptors(const IAMFContext *iamf, AVIOContext *pb, void *log_ctx);
 
 int ff_iamf_write_parameter_blocks(const IAMFContext *iamf, AVIOContext *pb,

libavformat/iamfenc.c

@@ -21 +21 @@
 
 #include <stdint.h>
 
+#include "libavutil/intreadwrite.h"
+#include "libavutil/mem.h"
 #include "avformat.h"
+#include "avio_internal.h"
 #include "iamf.h"
+#include "iamf_parse.h"
 #include "iamf_writer.h"
 #include "internal.h"
 #include "mux.h"
@@ -40 +44 @@
 {
     IAMFMuxContext *const c = s->priv_data;
     IAMFContext *const iamf = &c->iamf;
+    FFIOContext b;
     int nb_audio_elements = 0, nb_mix_presentations = 0;
     int ret;
 
@@ -68 +73 @@
     }
 
     if (s->nb_stream_groups <= 1) {
-        av_log(s, AV_LOG_ERROR, "There must be at least two stream groups\n");
-        return AVERROR(EINVAL);
+        av_log(s, AV_LOG_WARNING,
+               "Less than two stream groups provided; falling back to copying IAMF descriptors.\n");
+
+        /* Find the descriptors, by default only stored on the first stream */
+        const AVPacketSideData *sd = 
+            av_packet_side_data_get(s->streams[0]->codecpar->coded_side_data,
+                                    s->streams[0]->codecpar->nb_coded_side_data,
+                                    AV_PKT_DATA_IAMF_DESCRIPTORS);
+        if (!sd) {
+            av_log(s, AV_LOG_ERROR,
+                "No IAMF extradata found on the first input stream; cannot rewrap.\n");
+            return AVERROR_INVALIDDATA;
+        }
+
+        av_log(s, AV_LOG_TRACE,
+            "Writing IAMF descriptors from extradata (size=%d)\n", sd->size);
+        
+        ffio_init_read_context(&b, sd->data, sd->size);
+        ret = ff_iamfdec_read_descriptors(iamf, &b.pub, sd->size, s);
+        if (ret < 0)
+            return ret;
+        
+        /* patch the iamf codec struct like the ff_iamf_add_audio_element does */
+
+        for (int i = 0; i < iamf->nb_codec_configs; i++) {
+            av_free(iamf->codec_configs[i]->extradata);
+            av_free(iamf->codec_configs[i]);
+        }
+        av_freep(&iamf->codec_configs);
+        iamf->nb_codec_configs = 0;
+
+        for (int i = 0; i < iamf->nb_audio_elements; i++) {
+            IAMFAudioElement *audio_element = iamf->audio_elements[i];
+
+            /* Create a synthetic stream group */
+            AVStreamGroup *stg = avformat_stream_group_create(
+                    s, AV_STREAM_GROUP_PARAMS_IAMF_AUDIO_ELEMENT, NULL);
+            if (!stg)
+                return AVERROR(ENOMEM);
+
+            int sid = audio_element->substreams[0].audio_substream_id;
+            for (int j = 0; j < s->nb_streams; j++) {
+                AVStream *st = s->streams[j];
+                if (st->id != sid) continue;
+                avformat_stream_group_add_stream(stg, st);
+                break;
+            }
+
+            IAMFCodecConfig *cc = av_mallocz(sizeof(*cc));
+            if (!cc)
+                return AVERROR(ENOMEM);
+
+            ret = ff_iamf_fill_codec_config(iamf, stg, cc);
+            if (ret < 0)
+                return ret;
+        }
+
+        return 0;
     }
 
     for (int i = 0; i < s->nb_stream_groups; i++) {

libavformat/mov.c

@@ -980 +980 @@
                 if (audio_element->layers[0].substream_count != 1)
                     disposition &= ~AV_DISPOSITION_DEFAULT;
                 stream = st;
+
+                // save a copy of the descriptors on the side data for later use when encoding raw IAMF
+                if (!av_packet_side_data_new(&substream->codecpar->coded_side_data,
+                                             &substream->codecpar->nb_coded_side_data,
+                                             AV_PKT_DATA_IAMF_DESCRIPTORS,
+                                             descriptors_size, 0)) {
+                    ret = AVERROR(ENOMEM);
+                    goto fail;
+                }
+                memcpy(substream->codecpar->coded_side_data->data,
+                       st->codecpar->extradata, descriptors_size);
             } else
                 stream = avformat_new_stream(c->fc, NULL);
             if (!stream) {