avformat/nut: add support for per frame side & meta data with version 4

Signed-off-by: Michael Niedermayer <michaelni@gmx.at>

3 files changed, 268 insertions, 6 deletions

diff --git a/libavformat/nut.h b/libavformat/nut.h
index 18b688ae60..29f28e6ab9 100644
--- a/libavformat/nut.h
+++ b/libavformat/nut.h
@@ -46,6 +46,7 @@ typedef enum{
     FLAG_SIZE_MSB   =  32, ///<if set, data_size_msb is at frame header, otherwise data_size_msb is 0
     FLAG_CHECKSUM   =  64, ///<if set, the frame header contains a checksum
     FLAG_RESERVED   = 128, ///<if set, reserved_count is coded in the frame header
+    FLAG_SM_DATA    = 256, ///<if set, side / meta data is stored in the frame header.
     FLAG_HEADER_IDX =1024, ///<If set, header_idx is coded in the frame header.
     FLAG_MATCH_TIME =2048, ///<If set, match_time_delta is coded in the frame header
     FLAG_CODED      =4096, ///<if set, coded_flags are stored in the frame header
diff --git a/libavformat/nutdec.c b/libavformat/nutdec.c
index ba9ff0294b..6eb9ba6970 100644
--- a/libavformat/nutdec.c
+++ b/libavformat/nutdec.c
@@ -24,8 +24,10 @@
 #include "libavutil/avassert.h"
 #include "libavutil/bswap.h"
 #include "libavutil/dict.h"
+#include "libavutil/intreadwrite.h"
 #include "libavutil/mathematics.h"
 #include "libavutil/tree.h"
+#include "libavcodec/bytestream.h"
 #include "avio_internal.h"
 #include "nut.h"
 #include "riff.h"
@@ -227,7 +229,7 @@ static int decode_main_header(NUTContext *nut)
     end += avio_tell(bc);
 
     tmp = ffio_read_varlen(bc);
-    if (tmp < 2 && tmp > NUT_VERSION) {
+    if (tmp < 2 && tmp > 4) {
         av_log(s, AV_LOG_ERROR, "Version %"PRId64" not supported.\n",
                tmp);
         return AVERROR(ENOSYS);
@@ -776,6 +778,116 @@ static int nut_read_header(AVFormatContext *s)
     return 0;
 }
 
+static int read_sm_data(AVFormatContext *s, AVIOContext *bc, AVPacket *pkt, int is_meta, int64_t maxpos)
+{
+    int count = ffio_read_varlen(bc);
+    int skip_start = 0;
+    int skip_end = 0;
+    int channels = 0;
+    int64_t channel_layout = 0;
+    int sample_rate = 0;
+    int width = 0;
+    int height = 0;
+    int i;
+
+    for (i=0; i<count; i++) {
+        uint8_t name[256], str_value[256], type_str[256];
+        int value, type;
+        if (avio_tell(bc) >= maxpos)
+            return AVERROR_INVALIDDATA;
+        get_str(bc, name, sizeof(name));
+        type = value = get_s(bc);
+
+        if (value == -1) {
+            get_str(bc, str_value, sizeof(str_value));
+            av_log(s, AV_LOG_WARNING, "Unknown string %s / %s\n", name, str_value);
+        } else if (value == -2) {
+            uint8_t *dst = NULL;
+            int64_t v64, value_len;
+
+            get_str(bc, type_str, sizeof(type_str));
+            value_len = ffio_read_varlen(bc);
+            if (avio_tell(bc) + value_len >= maxpos)
+                return AVERROR_INVALIDDATA;
+            if (!strcmp(name, "Palette")) {
+                dst = av_packet_new_side_data(pkt, AV_PKT_DATA_PALETTE, value_len);
+            } else if (!strcmp(name, "Extradata")) {
+                dst = av_packet_new_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA, value_len);
+            } else if (sscanf(name, "CodecSpecificSide%"SCNd64"", &v64) == 1) {
+                dst = av_packet_new_side_data(pkt, AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL, value_len + 8);
+                if(!dst)
+                    return AVERROR(ENOMEM);
+                AV_WB64(dst, v64);
+                dst += 8;
+            } else if (!strcmp(name, "ChannelLayout") && value_len == 8) {
+                channel_layout = avio_rl64(bc);
+                continue;
+            } else {
+                av_log(s, AV_LOG_WARNING, "Unknown data %s / %s\n", name, type_str);
+                avio_skip(bc, value_len);
+                continue;
+            }
+            if(!dst)
+                return AVERROR(ENOMEM);
+            avio_read(bc, dst, value_len);
+        } else if (value == -3) {
+            value = get_s(bc);
+        } else if (value == -4) {
+            value = ffio_read_varlen(bc);
+        } else if (value < -4) {
+            get_s(bc);
+        } else {
+            if (!strcmp(name, "SkipStart")) {
+                skip_start = value;
+            } else if (!strcmp(name, "SkipEnd")) {
+                skip_end = value;
+            } else if (!strcmp(name, "Channels")) {
+                channels = value;
+            } else if (!strcmp(name, "SampleRate")) {
+                sample_rate = value;
+            } else if (!strcmp(name, "Width")) {
+                width = value;
+            } else if (!strcmp(name, "Height")) {
+                height = value;
+            } else {
+                av_log(s, AV_LOG_WARNING, "Unknown integer %s\n", name);
+            }
+        }
+    }
+
+    if (channels || channel_layout || sample_rate || width || height) {
+        uint8_t *dst = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, 28);
+        if (!dst)
+            return AVERROR(ENOMEM);
+        bytestream_put_le32(&dst,
+                            AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT*(!!channels) +
+                            AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT*(!!channel_layout) +
+                            AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE*(!!sample_rate) +
+                            AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS*(!!(width|height))
+                           );
+        if (channels)
+            bytestream_put_le32(&dst, channels);
+        if (channel_layout)
+            bytestream_put_le64(&dst, channel_layout);
+        if (sample_rate)
+            bytestream_put_le32(&dst, sample_rate);
+        if (width || height){
+            bytestream_put_le32(&dst, width);
+            bytestream_put_le32(&dst, height);
+        }
+    }
+
+    if (skip_start || skip_end) {
+        uint8_t *dst = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
+        if (!dst)
+            return AVERROR(ENOMEM);
+        AV_WL32(dst, skip_start);
+        AV_WL32(dst+4, skip_end);
+    }
+
+    return 0;
+}
+
 static int decode_frame_header(NUTContext *nut, int64_t *pts, int *stream_id,
                                uint8_t *header_idx, int frame_code)
 {
@@ -883,6 +995,17 @@ static int decode_frame(NUTContext *nut, AVPacket *pkt, int frame_code)
         return AVERROR(ENOMEM);
     memcpy(pkt->data, nut->header[header_idx], nut->header_len[header_idx]);
     pkt->pos = avio_tell(bc); // FIXME
+    if (stc->last_flags & FLAG_SM_DATA) {
+        int sm_size;
+        if (read_sm_data(s, bc, pkt, 0, pkt->pos + size) < 0)
+            return AVERROR_INVALIDDATA;
+        if (read_sm_data(s, bc, pkt, 1, pkt->pos + size) < 0)
+            return AVERROR_INVALIDDATA;
+        sm_size = avio_tell(bc) - pkt->pos;
+        size      -= sm_size;
+        pkt->size -= sm_size;
+    }
+
     avio_read(bc, pkt->data + nut->header_len[header_idx], size);
 
     pkt->stream_index = stream_id;
diff --git a/libavformat/nutenc.c b/libavformat/nutenc.c
index 107e57b445..1c7b78c6cc 100644
--- a/libavformat/nutenc.c
+++ b/libavformat/nutenc.c
@@ -26,6 +26,7 @@
 #include "libavutil/tree.h"
 #include "libavutil/dict.h"
 #include "libavutil/avassert.h"
+#include "libavcodec/bytestream.h"
 #include "libavcodec/mpegaudiodata.h"
 #include "nut.h"
 #include "internal.h"
@@ -778,6 +779,8 @@ static int get_needed_flags(NUTContext *nut, StreamContext *nus, FrameCode *fc,
         flags |= FLAG_SIZE_MSB;
     if (pkt->pts - nus->last_pts != fc->pts_delta)
         flags |= FLAG_CODED_PTS;
+    if (pkt->side_data_elems && nut->version > 3)
+        flags |= FLAG_SM_DATA;
     if (pkt->size > 2 * nut->max_distance)
         flags |= FLAG_CHECKSUM;
     if (FFABS(pkt->pts - nus->last_pts) > nus->max_pts_distance)
@@ -810,11 +813,128 @@ static int find_best_header_idx(NUTContext *nut, AVPacket *pkt)
     return best_i;
 }
 
+static int write_sm_data(AVFormatContext *s, AVIOContext *bc, AVPacket *pkt, int is_meta)
+{
+    AVStream *st = s->streams[pkt->stream_index];
+    int ret, i, dyn_size;
+    unsigned flags;
+    AVIOContext *dyn_bc;
+    int sm_data_count = 0;
+    uint8_t tmp[256];
+    uint8_t *dyn_buf;
+
+    ret = avio_open_dyn_buf(&dyn_bc);
+    if (ret < 0)
+        return ret;
+
+    for (i = 0; i<pkt->side_data_elems; i++) {
+        const uint8_t *data = pkt->side_data[i].data;
+        int size = pkt->side_data[i].size;
+        const uint8_t *data_end = data + size;
+
+        if (is_meta) {
+            if (   pkt->side_data[i].type == AV_PKT_DATA_METADATA_UPDATE
+                || pkt->side_data[i].type == AV_PKT_DATA_STRINGS_METADATA) {
+                if (!size || data[size-1])
+                    return AVERROR(EINVAL);
+                while (data < data_end) {
+                    const uint8_t *key = data;
+                    const uint8_t *val = data + strlen(key) + 1;
+
+                    if(val >= data_end)
+                        return AVERROR(EINVAL);
+                    put_str(dyn_bc, key);
+                    put_s(dyn_bc, -1);
+                    put_str(dyn_bc, val);
+                    data = val + strlen(val) + 1;
+                    sm_data_count++;
+                }
+            }
+        } else {
+            switch (pkt->side_data[i].type) {
+            case AV_PKT_DATA_PALETTE:
+            case AV_PKT_DATA_NEW_EXTRADATA:
+            case AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL:
+            default:
+                if (pkt->side_data[i].type == AV_PKT_DATA_PALETTE) {
+                    put_str(dyn_bc, "Palette");
+                } else if(pkt->side_data[i].type == AV_PKT_DATA_NEW_EXTRADATA) {
+                    put_str(dyn_bc, "Extradata");
+                } else if(pkt->side_data[i].type == AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL) {
+                    snprintf(tmp, sizeof(tmp), "CodecSpecificSide%"PRId64"", AV_RB64(data));
+                    put_str(dyn_bc, tmp);
+                } else {
+                    snprintf(tmp, sizeof(tmp), "UserData%s-SD-%d",
+                            (st->codec->flags & CODEC_FLAG_BITEXACT) ? "Lavf" : LIBAVFORMAT_IDENT,
+                            pkt->side_data[i].type);
+                    put_str(dyn_bc, tmp);
+                }
+                put_s(dyn_bc, -2);
+                put_str(dyn_bc, "bin");
+                ff_put_v(dyn_bc, pkt->side_data[i].size);
+                avio_write(dyn_bc, data, pkt->side_data[i].size);
+                sm_data_count++;
+                break;
+            case AV_PKT_DATA_PARAM_CHANGE:
+                flags = bytestream_get_le32(&data);
+                if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT) {
+                    put_str(dyn_bc, "Channels");
+                    put_s(dyn_bc, bytestream_get_le32(&data));
+                    sm_data_count++;
+                }
+                if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT) {
+                    put_str(dyn_bc, "ChannelLayout");
+                    put_s(dyn_bc, -2);
+                    put_str(dyn_bc, "u64");
+                    ff_put_v(bc, 8);
+                    avio_write(dyn_bc, data, 8); data+=8;
+                    sm_data_count++;
+                }
+                if (flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE) {
+                    put_str(dyn_bc, "SampleRate");
+                    put_s(dyn_bc, bytestream_get_le32(&data));
+                    sm_data_count++;
+                }
+                if (flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS) {
+                    put_str(dyn_bc, "Width");
+                    put_s(dyn_bc, bytestream_get_le32(&data));
+                    put_str(dyn_bc, "Height");
+                    put_s(dyn_bc, bytestream_get_le32(&data));
+                    sm_data_count+=2;
+                }
+            case AV_PKT_DATA_SKIP_SAMPLES:
+                if (AV_RL32(data)) {
+                    put_str(dyn_bc, "SkipStart");
+                    put_s(dyn_bc, (unsigned)AV_RL32(data));
+                    sm_data_count++;
+                }
+                if (AV_RL32(data+4)) {
+                    put_str(dyn_bc, "SkipEnd");
+                    put_s(dyn_bc, (unsigned)AV_RL32(data+4));
+                    sm_data_count++;
+                }
+                break;
+            case AV_PKT_DATA_METADATA_UPDATE:
+            case AV_PKT_DATA_STRINGS_METADATA:
+                // belongs into meta, not side data
+                break;
+            }
+        }
+    }
+
+    ff_put_v(bc, sm_data_count);
+    dyn_size = avio_close_dyn_buf(dyn_bc, &dyn_buf);
+    avio_write(bc, dyn_buf, dyn_size);
+    av_freep(&dyn_buf);
+
+    return 0;
+}
+
 static int nut_write_packet(AVFormatContext *s, AVPacket *pkt)
 {
     NUTContext *nut    = s->priv_data;
     StreamContext *nus = &nut->stream[pkt->stream_index];
-    AVIOContext *bc    = s->pb, *dyn_bc;
+    AVIOContext *bc    = s->pb, *dyn_bc, *sm_bc = NULL;
     FrameCode *fc;
     int64_t coded_pts;
     int best_length, frame_code, flags, needed_flags, i, header_idx;
@@ -822,6 +942,9 @@ static int nut_write_packet(AVFormatContext *s, AVPacket *pkt)
     int key_frame = !!(pkt->flags & AV_PKT_FLAG_KEY);
     int store_sp  = 0;
     int ret;
+    int sm_size = 0;
+    int data_size = pkt->size;
+    uint8_t *sm_buf;
 
     if (pkt->pts < 0) {
         av_log(s, AV_LOG_ERROR,
@@ -830,13 +953,23 @@ static int nut_write_packet(AVFormatContext *s, AVPacket *pkt)
         return AVERROR(EINVAL);
     }
 
+    if (pkt->side_data_elems && nut->version > 3) {
+        ret = avio_open_dyn_buf(&sm_bc);
+        if (ret < 0)
+            return ret;
+        write_sm_data(s, sm_bc, pkt, 0);
+        write_sm_data(s, sm_bc, pkt, 1);
+        sm_size = avio_close_dyn_buf(sm_bc, &sm_buf);
+        data_size += sm_size;
+    }
+
     if (1LL << (20 + 3 * nut->header_count) <= avio_tell(bc))
         write_headers(s, bc);
 
     if (key_frame && !(nus->last_flags & FLAG_KEY))
         store_sp = 1;
 
-    if (pkt->size + 30 /*FIXME check*/ + avio_tell(bc) >= nut->last_syncpoint_pos + nut->max_distance)
+    if (data_size + 30 /*FIXME check*/ + avio_tell(bc) >= nut->last_syncpoint_pos + nut->max_distance)
         store_sp = 1;
 
 //FIXME: Ensure store_sp is 1 in the first place.
@@ -916,10 +1049,10 @@ static int nut_write_packet(AVFormatContext *s, AVPacket *pkt)
         if (flags & FLAG_STREAM_ID)
             length += ff_get_v_length(pkt->stream_index);
 
-        if (pkt->size % fc->size_mul != fc->size_lsb)
+        if (data_size % fc->size_mul != fc->size_lsb)
             continue;
         if (flags & FLAG_SIZE_MSB)
-            length += ff_get_v_length(pkt->size / fc->size_mul);
+            length += ff_get_v_length(data_size / fc->size_mul);
 
         if (flags & FLAG_CHECKSUM)
             length += 4;
@@ -961,13 +1094,18 @@ static int nut_write_packet(AVFormatContext *s, AVPacket *pkt)
     }
     if (flags & FLAG_STREAM_ID)  ff_put_v(bc, pkt->stream_index);
     if (flags & FLAG_CODED_PTS)  ff_put_v(bc, coded_pts);
-    if (flags & FLAG_SIZE_MSB )  ff_put_v(bc, pkt->size / fc->size_mul);
+    if (flags & FLAG_SIZE_MSB )  ff_put_v(bc, data_size / fc->size_mul);
     if (flags & FLAG_HEADER_IDX) ff_put_v(bc, header_idx = best_header_idx);
 
     if (flags & FLAG_CHECKSUM)   avio_wl32(bc, ffio_get_checksum(bc));
     else                         ffio_get_checksum(bc);
 
+    if (flags & FLAG_SM_DATA) {
+        avio_write(bc, sm_buf, sm_size);
+        av_freep(&sm_buf);
+    }
     avio_write(bc, pkt->data + nut->header_len[header_idx], pkt->size - nut->header_len[header_idx]);
+
     nus->last_flags = flags;
     nus->last_pts   = pkt->pts;