[FFmpeg-devel] [PATCH v2 0/8] Dolby Vision extension block parsing

[FFmpeg-devel] [PATCH v2 0/8] Dolby Vision extension block parsing

[Niklas Haas]

Changes since v1:
- Rebased onto master
- Dropped av_dovi_metadata_alloc_ext(), instead statically allocate
  space for 32 extension blocks (AV_DOVI_MAX_EXT_BLOCKS)
- Removed misleading comment on nlq_pivots
- Fix memory leak on ff_dovi_ctx_flush()
- Switch to using ff_refstruct to properly manage ext_block lifetime
- Properly attach parsed extension blocks to the frame side data
- Avoid UB on get_cie_xy
- Validate num_ext_blocks
- Added commit fixing incorrect return code on invalid data
- Removed redundant extra init_get_bits8
- Reorderd fields to avoid unnecessary padding

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH v2 1/8] avutil/dovi_meta: add AVDOVIDataMapping.nlq_pivots

[Niklas Haas]

From: quietvoid <tcChlisop0@gmail.com>

The NLQ pivots are not documented but should be present in the header
for profile 7 RPU format. It has been verified using Dolby's
verification toolkit.

Signed-off-by: quietvoid <tcChlisop0@gmail.com>
Signed-off-by: Niklas Haas <git@haasn.dev>
---
 doc/APIchanges        | 3 +++
 libavcodec/dovi_rpu.c | 9 ++++++++-
 libavutil/dovi_meta.h | 1 +
 libavutil/version.h   | 2 +-
 4 files changed, 13 insertions(+), 2 deletions(-)

diff --git a/doc/APIchanges b/doc/APIchanges
index 77629072552..2f34018ea1b 100644
--- a/doc/APIchanges
+++ b/doc/APIchanges
@@ -2,6 +2,9 @@ The last version increases of all libraries were on 2024-03-07
 
 API changes, most recent first:
 
+2024-03-xx - xxxxxxxxxx - lavu 59.7.100 - dovi_meta.h
+  Add AVDOVIDataMapping.nlq_pivots.
+
 2024-03-xx - xxxxxxxxxx - lavu 59.6.100 - film_grain_params.h
   Add av_film_grain_params_select().
 
diff --git a/libavcodec/dovi_rpu.c b/libavcodec/dovi_rpu.c
index 31c64fb0602..c84a942f476 100644
--- a/libavcodec/dovi_rpu.c
+++ b/libavcodec/dovi_rpu.c
@@ -109,7 +109,7 @@ int ff_dovi_attach_side_data(DOVIContext *s, AVFrame *frame)
     /* Copy only the parts of these structs known to us at compiler-time. */
 #define COPY(t, a, b, last) memcpy(a, b, offsetof(t, last) + sizeof((b)->last))
     COPY(AVDOVIRpuDataHeader, av_dovi_get_header(dovi), &s->header, disable_residual_flag);
-    COPY(AVDOVIDataMapping, av_dovi_get_mapping(dovi), s->mapping, nlq[2].linear_deadzone_threshold);
+    COPY(AVDOVIDataMapping, av_dovi_get_mapping(dovi), s->mapping, nlq_pivots);
     COPY(AVDOVIColorMetadata, av_dovi_get_color(dovi), s->color, source_diagonal);
     return 0;
 }
@@ -346,7 +346,14 @@ int ff_dovi_rpu_parse(DOVIContext *s, const uint8_t *rpu, size_t rpu_size)
         }
 
         if (use_nlq) {
+            int nlq_pivot = 0;
             vdr->mapping.nlq_method_idc = get_bits(gb, 3);
+
+            for (int i = 0; i < 2; i++) {
+                nlq_pivot += get_bits(gb, hdr->bl_bit_depth);
+                vdr->mapping.nlq_pivots[i] = av_clip_uint16(nlq_pivot);
+            }
+
             /**
              * The patent mentions another legal value, NLQ_MU_LAW, but it's
              * not documented anywhere how to parse or apply that type of NLQ.
diff --git a/libavutil/dovi_meta.h b/libavutil/dovi_meta.h
index 3d11e02bffc..46b13b33995 100644
--- a/libavutil/dovi_meta.h
+++ b/libavutil/dovi_meta.h
@@ -147,6 +147,7 @@ typedef struct AVDOVIDataMapping {
     uint32_t num_x_partitions;
     uint32_t num_y_partitions;
     AVDOVINLQParams nlq[3]; /* per component */
+    uint16_t nlq_pivots[2];
 } AVDOVIDataMapping;
 
 /**
diff --git a/libavutil/version.h b/libavutil/version.h
index 445102073fc..80e6aacd0fa 100644
--- a/libavutil/version.h
+++ b/libavutil/version.h
@@ -79,7 +79,7 @@
  */
 
 #define LIBAVUTIL_VERSION_MAJOR  59
-#define LIBAVUTIL_VERSION_MINOR   6
+#define LIBAVUTIL_VERSION_MINOR   7
 #define LIBAVUTIL_VERSION_MICRO 100
 
 #define LIBAVUTIL_VERSION_INT   AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \
-- 
2.44.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH v2 2/8] avutil/dovi_meta: add dolby vision extension blocks

[Niklas Haas]

From: Niklas Haas <git@haasn.dev>

As well as accessors plus a function for allocating this struct with
extension blocks,

Definitions generously taken from quietvoid/dovi_tool, which is
assembled as a collection of various patent fragments, as well as output
by the official Dolby Vision bitstream verifier tool.
---
 doc/APIchanges        |   5 ++
 libavutil/dovi_meta.c |  22 ++++++-
 libavutil/dovi_meta.h | 146 ++++++++++++++++++++++++++++++++++++++++++
 libavutil/version.h   |   2 +-
 4 files changed, 171 insertions(+), 4 deletions(-)

diff --git a/doc/APIchanges b/doc/APIchanges
index 2f34018ea1b..fa406c445e7 100644
--- a/doc/APIchanges
+++ b/doc/APIchanges
@@ -2,6 +2,11 @@ The last version increases of all libraries were on 2024-03-07
 
 API changes, most recent first:
 
+2024-03-xx - xxxxxxxxxx - lavu 59.8.100 - dovi_meta.h
+  Add AVDOVIMetadata.ext_block_{offset,size}, AVDOVIMetadata.num_ext_blocks,
+  AVDOVIDmData and AVDOVIDmLevel{1..6,8..11,254..255}, av_dovi_get_ext()
+  and av_dovi_find_level().
+
 2024-03-xx - xxxxxxxxxx - lavu 59.7.100 - dovi_meta.h
   Add AVDOVIDataMapping.nlq_pivots.
 
diff --git a/libavutil/dovi_meta.c b/libavutil/dovi_meta.c
index 9c50da561ed..dfa4a438ed4 100644
--- a/libavutil/dovi_meta.c
+++ b/libavutil/dovi_meta.c
@@ -18,6 +18,8 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include <string.h>
+
 #include "dovi_meta.h"
 #include "mem.h"
 
@@ -39,6 +41,7 @@ typedef struct AVDOVIMetadataInternal {
     AVDOVIRpuDataHeader header;
     AVDOVIDataMapping mapping;
     AVDOVIColorMetadata color;
+    AVDOVIDmData ext_blocks[AV_DOVI_MAX_EXT_BLOCKS];
 } AVDOVIMetadataInternal;
 
 AVDOVIMetadata *av_dovi_metadata_alloc(size_t *size)
@@ -51,10 +54,23 @@ AVDOVIMetadata *av_dovi_metadata_alloc(size_t *size)
         *size = sizeof(*dovi);
 
     dovi->metadata = (struct AVDOVIMetadata) {
-        .header_offset  = offsetof(AVDOVIMetadataInternal, header),
-        .mapping_offset = offsetof(AVDOVIMetadataInternal, mapping),
-        .color_offset   = offsetof(AVDOVIMetadataInternal, color),
+        .header_offset      = offsetof(AVDOVIMetadataInternal, header),
+        .mapping_offset     = offsetof(AVDOVIMetadataInternal, mapping),
+        .color_offset       = offsetof(AVDOVIMetadataInternal, color),
+        .ext_block_offset   = offsetof(AVDOVIMetadataInternal, ext_blocks),
+        .ext_block_size     = sizeof(AVDOVIDmData),
     };
 
     return &dovi->metadata;
 }
+
+AVDOVIDmData *av_dovi_find_level(const AVDOVIMetadata *data, uint8_t level)
+{
+    for (int i = 0; i < data->num_ext_blocks; i++) {
+        AVDOVIDmData *ext = av_dovi_get_ext(data, i);
+        if (ext->level == level)
+            return ext;
+    }
+
+    return NULL;
+}
diff --git a/libavutil/dovi_meta.h b/libavutil/dovi_meta.h
index 46b13b33995..e10332f8d7e 100644
--- a/libavutil/dovi_meta.h
+++ b/libavutil/dovi_meta.h
@@ -29,7 +29,9 @@
 
 #include <stdint.h>
 #include <stddef.h>
+
 #include "rational.h"
+#include "csp.h"
 
 /*
  * DOVI configuration
@@ -187,6 +189,130 @@ typedef struct AVDOVIColorMetadata {
     uint16_t source_diagonal;
 } AVDOVIColorMetadata;
 
+typedef struct AVDOVIDmLevel1 {
+    /* Per-frame brightness metadata */
+    uint16_t min_pq;
+    uint16_t max_pq;
+    uint16_t avg_pq;
+} AVDOVIDmLevel1;
+
+typedef struct AVDOVIDmLevel2 {
+    /* Usually derived from level 8 (at different levels) */
+    uint16_t target_max_pq;
+    uint16_t trim_slope;
+    uint16_t trim_offset;
+    uint16_t trim_power;
+    uint16_t trim_chroma_weight;
+    uint16_t trim_saturation_gain;
+    int16_t ms_weight;
+} AVDOVIDmLevel2;
+
+typedef struct AVDOVIDmLevel3 {
+    uint16_t min_pq_offset;
+    uint16_t max_pq_offset;
+    uint16_t avg_pq_offset;
+} AVDOVIDmLevel3;
+
+typedef struct AVDOVIDmLevel4 {
+    uint16_t anchor_pq;
+    uint16_t anchor_power;
+} AVDOVIDmLevel4;
+
+typedef struct AVDOVIDmLevel5 {
+    /* Active area definition */
+    uint16_t left_offset;
+    uint16_t right_offset;
+    uint16_t top_offset;
+    uint16_t bottom_offset;
+} AVDOVIDmLevel5;
+
+typedef struct AVDOVIDmLevel6 {
+    /* Static HDR10 metadata */
+    uint16_t max_luminance;
+    uint16_t min_luminance;
+    uint16_t max_cll;
+    uint16_t max_fall;
+} AVDOVIDmLevel6;
+
+typedef struct AVDOVIDmLevel8 {
+    /* Extended version of level 2 */
+    uint8_t target_display_index;
+    uint16_t trim_slope;
+    uint16_t trim_offset;
+    uint16_t trim_power;
+    uint16_t trim_chroma_weight;
+    uint16_t trim_saturation_gain;
+    uint16_t ms_weight;
+    uint16_t target_mid_contrast;
+    uint16_t clip_trim;
+    uint8_t saturation_vector_field[6];
+    uint8_t hue_vector_field[6];
+} AVDOVIDmLevel8;
+
+typedef struct AVDOVIDmLevel9 {
+    /* Source display characteristics */
+    uint8_t source_primary_index;
+    AVColorPrimariesDesc source_display_primaries;
+} AVDOVIDmLevel9;
+
+typedef struct AVDOVIDmLevel10 {
+    /* Target display characteristics */
+    uint8_t target_display_index;
+    uint16_t target_max_pq;
+    uint16_t target_min_pq;
+    uint8_t target_primary_index;
+    AVColorPrimariesDesc target_display_primaries;
+} AVDOVIDmLevel10;
+
+typedef struct AVDOVIDmLevel11 {
+    uint8_t content_type;
+    uint8_t whitepoint;
+    uint8_t reference_mode_flag;
+    uint8_t sharpness;
+    uint8_t noise_reduction;
+    uint8_t mpeg_noise_reduction;
+    uint8_t frame_rate_conversion;
+    uint8_t brightness;
+    uint8_t color;
+} AVDOVIDmLevel11;
+
+typedef struct AVDOVIDmLevel254 {
+    /* DMv2 info block, always present in samples with DMv2 metadata */
+    uint8_t dm_mode;
+    uint8_t dm_version_index;
+} AVDOVIDmLevel254;
+
+typedef struct AVDOVIDmLevel255 {
+    /* Debug block, not really used in samples */
+    uint8_t dm_run_mode;
+    uint8_t dm_run_version;
+    uint8_t dm_debug[4];
+} AVDOVIDmLevel255;
+
+/**
+ * Dolby Vision metadata extension block.
+ *
+ * @note sizeof(AVDOVIDmData) is not part of the public API.
+ */
+typedef struct AVDOVIDmData {
+    uint8_t level; /* [1, 255] */
+    union {
+        AVDOVIDmLevel1 l1;
+        AVDOVIDmLevel2 l2; /* may appear multiple times */
+        AVDOVIDmLevel3 l3;
+        AVDOVIDmLevel4 l4;
+        AVDOVIDmLevel5 l5;
+        AVDOVIDmLevel6 l6;
+        /* level 7 is currently unused */
+        AVDOVIDmLevel8 l8; /* may appear multiple times */
+        AVDOVIDmLevel9 l9;
+        AVDOVIDmLevel10 l10; /* may appear multiple times */
+        AVDOVIDmLevel11 l11;
+        AVDOVIDmLevel254 l254;
+        AVDOVIDmLevel255 l255;
+    };
+} AVDOVIDmData;
+
 /**
  * Combined struct representing a combination of header, mapping and color
  * metadata, for attaching to frames as side data.
@@ -203,6 +329,13 @@ typedef struct AVDOVIMetadata {
     size_t header_offset;   /* AVDOVIRpuDataHeader */
     size_t mapping_offset;  /* AVDOVIDataMapping */
     size_t color_offset;    /* AVDOVIColorMetadata */
+
+    size_t ext_block_offset; /* offset to start of ext blocks array */
+    size_t ext_block_size; /* size per element */
+    int num_ext_blocks; /* number of extension blocks */
+
+    /* static limit on num_ext_blocks, derived from bitstream limitations */
+#define AV_DOVI_MAX_EXT_BLOCKS 32
 } AVDOVIMetadata;
 
 static av_always_inline AVDOVIRpuDataHeader *
@@ -223,6 +356,19 @@ av_dovi_get_color(const AVDOVIMetadata *data)
     return (AVDOVIColorMetadata *)((uint8_t *) data + data->color_offset);
 }
 
+static av_always_inline AVDOVIDmData *
+av_dovi_get_ext(const AVDOVIMetadata *data, int index)
+{
+    return (AVDOVIDmData *)((uint8_t *) data + data->ext_block_offset +
+                            data->ext_block_size * index);
+}
+
+/**
+ * Find an extension block with a given level, or NULL. In the case of
+ * multiple extension blocks, only the first is returned.
+ */
+AVDOVIDmData *av_dovi_find_level(const AVDOVIMetadata *data, uint8_t level);
+
 /**
  * Allocate an AVDOVIMetadata structure and initialize its
  * fields to default values.
diff --git a/libavutil/version.h b/libavutil/version.h
index 80e6aacd0fa..0a3f5dd0c92 100644
--- a/libavutil/version.h
+++ b/libavutil/version.h
@@ -79,7 +79,7 @@
  */
 
 #define LIBAVUTIL_VERSION_MAJOR  59
-#define LIBAVUTIL_VERSION_MINOR   7
+#define LIBAVUTIL_VERSION_MINOR   8
 #define LIBAVUTIL_VERSION_MICRO 100
 
 #define LIBAVUTIL_VERSION_INT   AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \
-- 
2.44.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH v2 3/8] avcodec/dovi_rpu: switch to AVERROR_INVALIDDATA

[Niklas Haas]

From: Niklas Haas <git@haasn.dev>

Instead of AVERROR(EINVAL)
---
 libavcodec/dovi_rpu.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libavcodec/dovi_rpu.c b/libavcodec/dovi_rpu.c
index c84a942f476..53f8c288db0 100644
--- a/libavcodec/dovi_rpu.c
+++ b/libavcodec/dovi_rpu.c
@@ -483,5 +483,5 @@ int ff_dovi_rpu_parse(DOVIContext *s, const uint8_t *rpu, size_t rpu_size)
 
 fail:
     ff_dovi_ctx_unref(s); /* don't leak potentially invalid state */
-    return AVERROR(EINVAL);
+    return AVERROR_INVALIDDATA;
 }
-- 
2.44.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH v2 4/8] avcodec/dovi_rpu: strip container in separate step

[Niklas Haas]

From: Niklas Haas <git@haasn.dev>

This ensures that `gb` in the following section is fully byte-aligned,
points at the start of the actual RPU, and ends on the CRC terminator.

This is important for both calculation of the CRC, as well as dovi
extension block parsing (which aligns to byte boundaries in various
places).
---
 libavcodec/dovi_rpu.c | 48 +++++++++++++++++++++++++++++++++++--------
 libavcodec/dovi_rpu.h |  2 ++
 2 files changed, 41 insertions(+), 9 deletions(-)

diff --git a/libavcodec/dovi_rpu.c b/libavcodec/dovi_rpu.c
index 53f8c288db0..d792a429217 100644
--- a/libavcodec/dovi_rpu.c
+++ b/libavcodec/dovi_rpu.c
@@ -23,6 +23,7 @@
 
 #include "libavutil/buffer.h"
 
+#include "avcodec.h"
 #include "dovi_rpu.h"
 #include "golomb.h"
 #include "get_bits.h"
@@ -45,6 +46,7 @@ void ff_dovi_ctx_unref(DOVIContext *s)
 {
     for (int i = 0; i < FF_ARRAY_ELEMS(s->vdr); i++)
         ff_refstruct_unref(&s->vdr[i]);
+    av_free(s->rpu_buf);
 
     *s = (DOVIContext) {
         .logctx = s->logctx,
@@ -59,6 +61,9 @@ void ff_dovi_ctx_flush(DOVIContext *s)
     *s = (DOVIContext) {
         .logctx = s->logctx,
         .dv_profile = s->dv_profile,
+        /* preserve temporary buffer */
+        .rpu_buf = s->rpu_buf,
+        .rpu_buf_sz = s->rpu_buf_sz,
     };
 }
 
@@ -202,17 +207,17 @@ int ff_dovi_rpu_parse(DOVIContext *s, const uint8_t *rpu, size_t rpu_size)
     DOVIVdr *vdr;
     int ret;
 
-    uint8_t nal_prefix;
     uint8_t rpu_type;
     uint8_t vdr_seq_info_present;
     uint8_t vdr_dm_metadata_present;
     uint8_t use_prev_vdr_rpu;
     uint8_t use_nlq;
     uint8_t profile;
-    if ((ret = init_get_bits8(gb, rpu, rpu_size)) < 0)
-        return ret;
 
-    /* Container header */
+    if (rpu_size < 5)
+        goto fail;
+
+    /* Container */
     if (s->dv_profile == 10 /* dav1.10 */) {
         /* DV inside AV1 re-uses an EMDF container skeleton, but with fixed
          * values - so we can effectively treat this as a magic byte sequence.
@@ -229,18 +234,43 @@ int ff_dovi_rpu_parse(DOVIContext *s, const uint8_t *rpu, size_t rpu_size)
          *   discard_unknown_payload : f(1) = 1
          */
         const unsigned header_magic = 0x01be6841u;
-        unsigned header, emdf_payload_size;
-        header = get_bits_long(gb, 27);
-        VALIDATE(header, header_magic, header_magic);
+        unsigned emdf_header, emdf_payload_size, emdf_protection;
+        if ((ret = init_get_bits8(gb, rpu, rpu_size)) < 0)
+            return ret;
+        emdf_header = get_bits_long(gb, 27);
+        VALIDATE(emdf_header, header_magic, header_magic);
         emdf_payload_size = get_variable_bits(gb, 8);
         VALIDATE(emdf_payload_size, 6, 512);
         if (emdf_payload_size * 8 > get_bits_left(gb))
             return AVERROR_INVALIDDATA;
+
+        /* The payload is not byte-aligned (off by *one* bit, curse Dolby),
+         * so copy into a fresh buffer to preserve byte alignment of the
+         * RPU struct */
+        av_fast_padded_malloc(&s->rpu_buf, &s->rpu_buf_sz, emdf_payload_size);
+        if (!s->rpu_buf)
+            return AVERROR(ENOMEM);
+        for (int i = 0; i < emdf_payload_size; i++)
+            s->rpu_buf[i] = get_bits(gb, 8);
+        rpu = s->rpu_buf;
+        rpu_size = emdf_payload_size;
+
+        /* Validate EMDF footer */
+        emdf_protection = get_bits(gb, 5 + 12);
+        VALIDATE(emdf_protection, 0x400, 0x400);
     } else {
-        nal_prefix = get_bits(gb, 8);
-        VALIDATE(nal_prefix, 25, 25);
+        /* NAL RBSP with prefix and trailing zeroes */
+        VALIDATE(rpu[0], 25, 25); /* NAL prefix */
+        rpu++;
+        rpu_size--;
+        /* Strip trailing padding bytes */
+        while (rpu_size && rpu[rpu_size - 1] == 0)
+            rpu_size--;
     }
 
+    if ((ret = init_get_bits8(gb, rpu, rpu_size)) < 0)
+        return ret;
+
     /* RPU header */
     rpu_type = get_bits(gb, 6);
     if (rpu_type != 2) {
diff --git a/libavcodec/dovi_rpu.h b/libavcodec/dovi_rpu.h
index 51c5fdbb879..755171c9237 100644
--- a/libavcodec/dovi_rpu.h
+++ b/libavcodec/dovi_rpu.h
@@ -48,6 +48,8 @@ typedef struct DOVIContext {
      * Private fields internal to dovi_rpu.c
      */
     struct DOVIVdr *vdr[DOVI_MAX_DM_ID+1]; ///< RefStruct references
+    uint8_t *rpu_buf; ///< temporary buffer
+    unsigned rpu_buf_sz;
     uint8_t dv_profile;
 
 } DOVIContext;
-- 
2.44.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH v2 5/8] avcodec/dovi_rpu: verify RPU data CRC32

[Niklas Haas]

From: Niklas Haas <git@haasn.dev>

The Dolby Vision RPU contains a CRC32 to validate the payload against.
The implementation is CRC32/MPEG-2.

The CRC is only verified with the AV_EF_CRCCHECK flag.

Co-authored-by: quietvoid <tcChlisop0@gmail.com>
---
 libavcodec/av1dec.c   |  3 ++-
 libavcodec/dovi_rpu.c | 18 ++++++++++++++++--
 libavcodec/dovi_rpu.h |  3 ++-
 libavcodec/hevcdec.c  |  3 ++-
 libavcodec/libdav1d.c |  3 ++-
 5 files changed, 24 insertions(+), 6 deletions(-)

diff --git a/libavcodec/av1dec.c b/libavcodec/av1dec.c
index 32a795e7580..e8753d302ae 100644
--- a/libavcodec/av1dec.c
+++ b/libavcodec/av1dec.c
@@ -1001,7 +1001,8 @@ static int export_itut_t35(AVCodecContext *avctx, AVFrame *frame,
             provider_oriented_code != 0x800)
             break;
 
-        ret = ff_dovi_rpu_parse(&s->dovi, gb.buffer, gb.buffer_end - gb.buffer);
+        ret = ff_dovi_rpu_parse(&s->dovi, gb.buffer, gb.buffer_end - gb.buffer,
+                                avctx->err_recognition);
         if (ret < 0) {
             av_log(avctx, AV_LOG_WARNING, "Error parsing DOVI OBU.\n");
             break; // ignore
diff --git a/libavcodec/dovi_rpu.c b/libavcodec/dovi_rpu.c
index d792a429217..d584d99590a 100644
--- a/libavcodec/dovi_rpu.c
+++ b/libavcodec/dovi_rpu.c
@@ -22,6 +22,7 @@
  */
 
 #include "libavutil/buffer.h"
+#include "libavutil/crc.h"
 
 #include "avcodec.h"
 #include "dovi_rpu.h"
@@ -200,7 +201,8 @@ static inline unsigned get_variable_bits(GetBitContext *gb, int n)
         }                                                                       \
     } while (0)
 
-int ff_dovi_rpu_parse(DOVIContext *s, const uint8_t *rpu, size_t rpu_size)
+int ff_dovi_rpu_parse(DOVIContext *s, const uint8_t *rpu, size_t rpu_size,
+                      int err_recognition)
 {
     AVDOVIRpuDataHeader *hdr = &s->header;
     GetBitContext *gb = &(GetBitContext){0};
@@ -268,6 +270,19 @@ int ff_dovi_rpu_parse(DOVIContext *s, const uint8_t *rpu, size_t rpu_size)
             rpu_size--;
     }
 
+    if (!rpu_size || rpu[rpu_size - 1] != 0x80)
+        goto fail;
+
+    if (err_recognition & AV_EF_CRCCHECK) {
+        uint32_t crc = av_bswap32(av_crc(av_crc_get_table(AV_CRC_32_IEEE),
+                                  -1, rpu, rpu_size - 1)); /* exclude 0x80 */
+        if (crc) {
+            av_log(s->logctx, AV_LOG_ERROR, "RPU CRC mismatch: %X\n", crc);
+            if (err_recognition & AV_EF_EXPLODE)
+                goto fail;
+        }
+    }
+
     if ((ret = init_get_bits8(gb, rpu, rpu_size)) < 0)
         return ret;
 
@@ -508,7 +523,6 @@ int ff_dovi_rpu_parse(DOVIContext *s, const uint8_t *rpu, size_t rpu_size)
         color->source_diagonal = get_bits(gb, 10);
     }
 
-    /* FIXME: verify CRC32, requires implementation of AV_CRC_32_MPEG_2 */
     return 0;
 
 fail:
diff --git a/libavcodec/dovi_rpu.h b/libavcodec/dovi_rpu.h
index 755171c9237..8dcc65bb40a 100644
--- a/libavcodec/dovi_rpu.h
+++ b/libavcodec/dovi_rpu.h
@@ -79,7 +79,8 @@ void ff_dovi_update_cfg(DOVIContext *s, const AVDOVIDecoderConfigurationRecord *
  *
  * Returns 0 or an error code.
  */
-int ff_dovi_rpu_parse(DOVIContext *s, const uint8_t *rpu, size_t rpu_size);
+int ff_dovi_rpu_parse(DOVIContext *s, const uint8_t *rpu, size_t rpu_size,
+                      int err_recognition);
 
 /**
  * Attach the decoded AVDOVIMetadata as side data to an AVFrame.
diff --git a/libavcodec/hevcdec.c b/libavcodec/hevcdec.c
index 575836e340c..3c8ec531a5d 100644
--- a/libavcodec/hevcdec.c
+++ b/libavcodec/hevcdec.c
@@ -3207,7 +3207,8 @@ static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
             return AVERROR(ENOMEM);
         memcpy(s->rpu_buf->data, nal->raw_data + 2, nal->raw_size - 2);
 
-        ret = ff_dovi_rpu_parse(&s->dovi_ctx, nal->data + 2, nal->size - 2);
+        ret = ff_dovi_rpu_parse(&s->dovi_ctx, nal->data + 2, nal->size - 2,
+                                s->avctx->err_recognition);
         if (ret < 0) {
             av_buffer_unref(&s->rpu_buf);
             av_log(s->avctx, AV_LOG_WARNING, "Error parsing DOVI NAL unit.\n");
diff --git a/libavcodec/libdav1d.c b/libavcodec/libdav1d.c
index ddcd0708b4f..f022a4ad05c 100644
--- a/libavcodec/libdav1d.c
+++ b/libavcodec/libdav1d.c
@@ -567,7 +567,8 @@ static int libdav1d_receive_frame(AVCodecContext *c, AVFrame *frame)
                 provider_oriented_code != 0x800)
                 break;
 
-            res = ff_dovi_rpu_parse(&dav1d->dovi, gb.buffer, gb.buffer_end - gb.buffer);
+            res = ff_dovi_rpu_parse(&dav1d->dovi, gb.buffer, gb.buffer_end - gb.buffer,
+                                    c->err_recognition);
             if (res < 0) {
                 av_log(c, AV_LOG_WARNING, "Error parsing DOVI OBU.\n");
                 break; // ignore
-- 
2.44.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH v2 6/8] avcodec/dovi_rpu: add ext_blocks array to DOVIContext

[Niklas Haas]

From: Niklas Haas <git@haasn.dev>

---
 libavcodec/dovi_rpu.c | 3 +++
 libavcodec/dovi_rpu.h | 6 ++++++
 2 files changed, 9 insertions(+)

diff --git a/libavcodec/dovi_rpu.c b/libavcodec/dovi_rpu.c
index d584d99590a..6097bd5422f 100644
--- a/libavcodec/dovi_rpu.c
+++ b/libavcodec/dovi_rpu.c
@@ -47,6 +47,7 @@ void ff_dovi_ctx_unref(DOVIContext *s)
 {
     for (int i = 0; i < FF_ARRAY_ELEMS(s->vdr); i++)
         ff_refstruct_unref(&s->vdr[i]);
+    ff_refstruct_unref(&s->ext_blocks);
     av_free(s->rpu_buf);
 
     *s = (DOVIContext) {
@@ -58,6 +59,7 @@ void ff_dovi_ctx_flush(DOVIContext *s)
 {
     for (int i = 0; i < FF_ARRAY_ELEMS(s->vdr); i++)
         ff_refstruct_unref(&s->vdr[i]);
+    ff_refstruct_unref(&s->ext_blocks);
 
     *s = (DOVIContext) {
         .logctx = s->logctx,
@@ -76,6 +78,7 @@ void ff_dovi_ctx_replace(DOVIContext *s, const DOVIContext *s0)
     s->dv_profile = s0->dv_profile;
     for (int i = 0; i <= DOVI_MAX_DM_ID; i++)
         ff_refstruct_replace(&s->vdr[i], s0->vdr[i]);
+    ff_refstruct_replace(&s->ext_blocks, s0->ext_blocks);
 }
 
 void ff_dovi_update_cfg(DOVIContext *s, const AVDOVIDecoderConfigurationRecord *cfg)
diff --git a/libavcodec/dovi_rpu.h b/libavcodec/dovi_rpu.h
index 8dcc65bb40a..9f26f332ceb 100644
--- a/libavcodec/dovi_rpu.h
+++ b/libavcodec/dovi_rpu.h
@@ -44,6 +44,12 @@ typedef struct DOVIContext {
     const AVDOVIDataMapping *mapping;
     const AVDOVIColorMetadata *color;
 
+    /**
+     * Currently active extension blocks, updates on every ff_dovi_rpu_parse()
+     */
+    AVDOVIDmData *ext_blocks;
+    int num_ext_blocks;
+
     /**
      * Private fields internal to dovi_rpu.c
      */
-- 
2.44.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH v2 7/8] avcodec/dovi_rpu: parse extension blocks

[Niklas Haas]

From: Niklas Haas <git@haasn.dev>

We split the inner loop between v1 and v2 extension blocks to print
a warning where an extension block was encountered in an unexpected
context.

Co-authored-by: quietvoid <tcChlisop0@gmail.com>
---
 libavcodec/dovi_rpu.c | 178 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 178 insertions(+)

diff --git a/libavcodec/dovi_rpu.c b/libavcodec/dovi_rpu.c
index 6097bd5422f..b3defd87bda 100644
--- a/libavcodec/dovi_rpu.c
+++ b/libavcodec/dovi_rpu.c
@@ -204,6 +204,170 @@ static inline unsigned get_variable_bits(GetBitContext *gb, int n)
         }                                                                       \
     } while (0)
 
+static void parse_ext_v1(DOVIContext *s, GetBitContext *gb, AVDOVIDmData *dm)
+{
+    switch (dm->level) {
+    case 1:
+        dm->l1.min_pq = get_bits(gb, 12);
+        dm->l1.max_pq = get_bits(gb, 12);
+        dm->l1.avg_pq = get_bits(gb, 12);
+        break;
+    case 2:
+        dm->l2.target_max_pq = get_bits(gb, 12);
+        dm->l2.trim_slope = get_bits(gb, 12);
+        dm->l2.trim_offset = get_bits(gb, 12);
+        dm->l2.trim_power = get_bits(gb, 12);
+        dm->l2.trim_chroma_weight = get_bits(gb, 12);
+        dm->l2.trim_saturation_gain = get_bits(gb, 12);
+        dm->l2.ms_weight = get_bits(gb, 13) - 8192;
+        break;
+    case 4:
+        dm->l4.anchor_pq = get_bits(gb, 12);
+        dm->l4.anchor_power = get_bits(gb, 12);
+        break;
+    case 5:
+        dm->l5.left_offset = get_bits(gb, 13);
+        dm->l5.right_offset = get_bits(gb, 13);
+        dm->l5.top_offset = get_bits(gb, 13);
+        dm->l5.bottom_offset = get_bits(gb, 13);
+        break;
+    case 6:
+        dm->l6.max_luminance = get_bits(gb, 16);
+        dm->l6.min_luminance = get_bits(gb, 16);
+        dm->l6.max_cll = get_bits(gb, 16);
+        dm->l6.max_fall = get_bits(gb, 16);
+        break;
+    case 255:
+        dm->l255.dm_run_mode = get_bits(gb, 8);
+        dm->l255.dm_run_version = get_bits(gb, 8);
+        for (int i = 0; i < 4; i++)
+            dm->l255.dm_debug[i] = get_bits(gb, 8);
+        break;
+    default:
+        av_log(s->logctx, AV_LOG_WARNING,
+               "Unknown Dolby Vision DM v1 level: %u\n", dm->level);
+    }
+}
+
+static inline AVCIExy get_cie_xy(GetBitContext *gb)
+{
+    AVCIExy xy;
+    const int denom = 32767;
+    xy.x = av_make_q(get_sbits(gb, 16), denom);
+    xy.y = av_make_q(get_sbits(gb, 16), denom);
+    return xy;
+}
+
+static void parse_ext_v2(DOVIContext *s, GetBitContext *gb, AVDOVIDmData *dm,
+                         int ext_block_length)
+{
+    switch (dm->level) {
+    case 3:
+        dm->l3.min_pq_offset = get_bits(gb, 12);
+        dm->l3.max_pq_offset = get_bits(gb, 12);
+        dm->l3.avg_pq_offset = get_bits(gb, 12);
+        break;
+    case 8:
+        dm->l8.target_display_index = get_bits(gb, 8);
+        dm->l8.trim_slope = get_bits(gb, 12);
+        dm->l8.trim_offset = get_bits(gb, 12);
+        dm->l8.trim_power = get_bits(gb, 12);
+        dm->l8.trim_chroma_weight = get_bits(gb, 12);
+        dm->l8.trim_saturation_gain = get_bits(gb, 12);
+        dm->l8.ms_weight = get_bits(gb, 12) - 8192;
+        if (ext_block_length < 12)
+            break;
+        dm->l8.target_mid_contrast = get_bits(gb, 12);
+        if (ext_block_length < 13)
+            break;
+        dm->l8.clip_trim = get_bits(gb, 12);
+        if (ext_block_length < 19)
+            break;
+        for (int i = 0; i < 6; i++)
+            dm->l8.saturation_vector_field[i] = get_bits(gb, 8);
+        if (ext_block_length < 25)
+            break;
+        for (int i = 0; i < 6; i++)
+            dm->l8.hue_vector_field[i] = get_bits(gb, 8);
+        break;
+    case 9:
+        dm->l9.source_primary_index = get_bits(gb, 8);
+        if (ext_block_length < 17)
+            break;
+        dm->l9.source_display_primaries.prim.r = get_cie_xy(gb);
+        dm->l9.source_display_primaries.prim.g = get_cie_xy(gb);
+        dm->l9.source_display_primaries.prim.b = get_cie_xy(gb);
+        dm->l9.source_display_primaries.wp = get_cie_xy(gb);
+        break;
+    case 10:
+        dm->l10.target_display_index = get_bits(gb, 8);
+        dm->l10.target_max_pq = get_bits(gb, 12);
+        dm->l10.target_min_pq = get_bits(gb, 12);
+        dm->l10.target_primary_index = get_bits(gb, 8);
+        if (ext_block_length < 21)
+            break;
+        dm->l10.target_display_primaries.prim.r = get_cie_xy(gb);
+        dm->l10.target_display_primaries.prim.g = get_cie_xy(gb);
+        dm->l10.target_display_primaries.prim.b = get_cie_xy(gb);
+        dm->l10.target_display_primaries.wp = get_cie_xy(gb);
+        break;
+    case 11:
+        dm->l11.content_type = get_bits(gb, 8);
+        dm->l11.whitepoint = get_bits(gb, 4);
+        dm->l11.reference_mode_flag = get_bits(gb, 1);
+        skip_bits(gb, 3); /* reserved */
+        dm->l11.sharpness = get_bits(gb, 2);
+        dm->l11.noise_reduction = get_bits(gb, 2);
+        dm->l11.mpeg_noise_reduction = get_bits(gb, 2);
+        dm->l11.frame_rate_conversion = get_bits(gb, 2);
+        dm->l11.brightness = get_bits(gb, 2);
+        dm->l11.color = get_bits(gb, 2);
+        break;
+    case 254:
+        dm->l254.dm_mode = get_bits(gb, 8);
+        dm->l254.dm_version_index = get_bits(gb, 8);
+        break;
+    default:
+        av_log(s->logctx, AV_LOG_WARNING,
+               "Unknown Dolby Vision DM v2 level: %u\n", dm->level);
+    }
+}
+
+static int parse_ext_blocks(DOVIContext *s, GetBitContext *gb, int ver)
+{
+    int num_ext_blocks, ext_block_length, start_pos, parsed_bits;
+
+    num_ext_blocks = get_ue_golomb_31(gb);
+    align_get_bits(gb);
+    if (s->num_ext_blocks + num_ext_blocks > AV_DOVI_MAX_EXT_BLOCKS)
+        return AVERROR_INVALIDDATA;
+
+    if (!s->ext_blocks) {
+        s->ext_blocks = ff_refstruct_allocz(sizeof(AVDOVIDmData) * AV_DOVI_MAX_EXT_BLOCKS);
+        if (!s->ext_blocks)
+            return AVERROR(ENOMEM);
+    }
+
+    while (num_ext_blocks--) {
+        AVDOVIDmData *dm = &s->ext_blocks[s->num_ext_blocks++];
+        ext_block_length = get_ue_golomb_31(gb);
+        dm->level = get_bits(gb, 8);
+        start_pos = get_bits_count(gb);
+
+        switch (ver) {
+        case 1: parse_ext_v1(s, gb, dm); break;
+        case 2: parse_ext_v2(s, gb, dm, ext_block_length); break;
+        }
+
+        parsed_bits = get_bits_count(gb) - start_pos;
+        if (parsed_bits > ext_block_length * 8)
+            return AVERROR_INVALIDDATA;
+        skip_bits(gb, ext_block_length * 8 - parsed_bits);
+    }
+
+    return 0;
+}
+
 int ff_dovi_rpu_parse(DOVIContext *s, const uint8_t *rpu, size_t rpu_size,
                       int err_recognition)
 {
@@ -526,6 +690,20 @@ int ff_dovi_rpu_parse(DOVIContext *s, const uint8_t *rpu, size_t rpu_size,
         color->source_diagonal = get_bits(gb, 10);
     }
 
+    /* Parse extension blocks */
+    s->num_ext_blocks = 0;
+    if ((ret = parse_ext_blocks(s, gb, 1)) < 0) {
+        ff_dovi_ctx_unref(s);
+        return ret;
+    }
+
+    if (get_bits_left(gb) > 48 /* padding + CRC32 + terminator */) {
+        if ((ret = parse_ext_blocks(s, gb, 2)) < 0) {
+            ff_dovi_ctx_unref(s);
+            return ret;
+        }
+    }
+
     return 0;
 
 fail:
-- 
2.44.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

[FFmpeg-devel] [PATCH v2 8/8] avcodec/dovi_rpu: attach ext blocks to frames

[Niklas Haas]

From: Niklas Haas <git@haasn.dev>

---
 libavcodec/dovi_rpu.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/libavcodec/dovi_rpu.c b/libavcodec/dovi_rpu.c
index b3defd87bda..2b4d2b470c2 100644
--- a/libavcodec/dovi_rpu.c
+++ b/libavcodec/dovi_rpu.c
@@ -94,7 +94,7 @@ int ff_dovi_attach_side_data(DOVIContext *s, AVFrame *frame)
     AVFrameSideData *sd;
     AVBufferRef *buf;
     AVDOVIMetadata *dovi;
-    size_t dovi_size;
+    size_t dovi_size, ext_sz;
 
     if (!s->mapping || !s->color)
         return 0; /* incomplete dovi metadata */
@@ -120,6 +120,9 @@ int ff_dovi_attach_side_data(DOVIContext *s, AVFrame *frame)
     COPY(AVDOVIRpuDataHeader, av_dovi_get_header(dovi), &s->header, disable_residual_flag);
     COPY(AVDOVIDataMapping, av_dovi_get_mapping(dovi), s->mapping, nlq_pivots);
     COPY(AVDOVIColorMetadata, av_dovi_get_color(dovi), s->color, source_diagonal);
+    ext_sz = FFMIN(sizeof(AVDOVIDmData), dovi->ext_block_size);
+    for (int i = 0; i < s->num_ext_blocks; i++)
+        memcpy(av_dovi_get_ext(dovi, i), &s->ext_blocks[i], ext_sz);
     return 0;
 }
 
-- 
2.44.0

_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

Re: [FFmpeg-devel] [PATCH v2 8/8] avcodec/dovi_rpu: attach ext blocks to frames

[Niklas Haas]

On Sat, 23 Mar 2024 20:19:57 +0100 Niklas Haas <ffmpeg@haasn.xyz> wrote:
> From: Niklas Haas <git@haasn.dev>
> 
> ---
>  libavcodec/dovi_rpu.c | 5 ++++-
>  1 file changed, 4 insertions(+), 1 deletion(-)
> 
> diff --git a/libavcodec/dovi_rpu.c b/libavcodec/dovi_rpu.c
> index b3defd87bda..2b4d2b470c2 100644
> --- a/libavcodec/dovi_rpu.c
> +++ b/libavcodec/dovi_rpu.c
> @@ -94,7 +94,7 @@ int ff_dovi_attach_side_data(DOVIContext *s, AVFrame *frame)
>      AVFrameSideData *sd;
>      AVBufferRef *buf;
>      AVDOVIMetadata *dovi;
> -    size_t dovi_size;
> +    size_t dovi_size, ext_sz;
>  
>      if (!s->mapping || !s->color)
>          return 0; /* incomplete dovi metadata */
> @@ -120,6 +120,9 @@ int ff_dovi_attach_side_data(DOVIContext *s, AVFrame *frame)
>      COPY(AVDOVIRpuDataHeader, av_dovi_get_header(dovi), &s->header, disable_residual_flag);
>      COPY(AVDOVIDataMapping, av_dovi_get_mapping(dovi), s->mapping, nlq_pivots);
>      COPY(AVDOVIColorMetadata, av_dovi_get_color(dovi), s->color, source_diagonal);
> +    ext_sz = FFMIN(sizeof(AVDOVIDmData), dovi->ext_block_size);
> +    for (int i = 0; i < s->num_ext_blocks; i++)
> +        memcpy(av_dovi_get_ext(dovi, i), &s->ext_blocks[i], ext_sz);

Forgot to set dovi->num_ext_blocks = s->num_ext_blocks, fixed.

>      return 0;
>  }
>  
> -- 
> 2.44.0
> 
_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".

Re: [FFmpeg-devel] [PATCH v2 0/8] Dolby Vision extension block parsing

[Niklas Haas]

On Sat, 23 Mar 2024 20:19:49 +0100 Niklas Haas <ffmpeg@haasn.xyz> wrote:
> Changes since v1:
> - Rebased onto master
> - Dropped av_dovi_metadata_alloc_ext(), instead statically allocate
>   space for 32 extension blocks (AV_DOVI_MAX_EXT_BLOCKS)
> - Removed misleading comment on nlq_pivots
> - Fix memory leak on ff_dovi_ctx_flush()
> - Switch to using ff_refstruct to properly manage ext_block lifetime
> - Properly attach parsed extension blocks to the frame side data
> - Avoid UB on get_cie_xy
> - Validate num_ext_blocks
> - Added commit fixing incorrect return code on invalid data
> - Removed redundant extra init_get_bits8
> - Reorderd fields to avoid unnecessary padding

Ping, any further comments / objections?

> 
> _______________________________________________
> ffmpeg-devel mailing list
> ffmpeg-devel@ffmpeg.org
> https://ffmpeg.org/mailman/listinfo/ffmpeg-devel
> 
> To unsubscribe, visit link above, or email
> ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".
_______________________________________________
ffmpeg-devel mailing list
ffmpeg-devel@ffmpeg.org
https://ffmpeg.org/mailman/listinfo/ffmpeg-devel

To unsubscribe, visit link above, or email
ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".