]> git.sesse.net Git - ffmpeg/blobdiff - libavformat/hashenc.c
avformat/avio: Add Metacube support
[ffmpeg] / libavformat / hashenc.c
index a9be6d0c81df6950e34fd2c12fb0bd55ba9ccb5f..a1e98eda894ee8dd85c9a01201d7ab790fe2432c 100644 (file)
@@ -31,6 +31,7 @@ struct HashContext {
     const AVClass *avclass;
     struct AVHashContext **hashes;
     char *hash_name;
+    int per_stream;
     int format_version;
 };
 
@@ -41,8 +42,8 @@ struct HashContext {
 #define FORMAT_VERSION_OPT \
     { "format_version", "file format version", OFFSET(format_version), AV_OPT_TYPE_INT, {.i64 = 2}, 1, 2, ENC }
 
-#if CONFIG_HASH_MUXER
-static const AVOption hash_options[] = {
+#if CONFIG_HASH_MUXER || CONFIG_STREAMHASH_MUXER
+static const AVOption hash_streamhash_options[] = {
     HASH_OPT("sha256"),
     { NULL },
 };
@@ -76,7 +77,8 @@ static int hash_init(struct AVFormatContext *s)
 {
     int res;
     struct HashContext *c = s->priv_data;
-    c->hashes = av_mallocz_array(1, sizeof(c->hashes));
+    c->per_stream = 0;
+    c->hashes = av_mallocz_array(1, sizeof(*c->hashes));
     if (!c->hashes)
         return AVERROR(ENOMEM);
     res = av_hash_alloc(&c->hashes[0], c->hash_name);
@@ -85,46 +87,91 @@ static int hash_init(struct AVFormatContext *s)
     av_hash_init(c->hashes[0]);
     return 0;
 }
+#endif
+
+#if CONFIG_STREAMHASH_MUXER
+static int streamhash_init(struct AVFormatContext *s)
+{
+    int res, i;
+    struct HashContext *c = s->priv_data;
+    c->per_stream = 1;
+    c->hashes = av_mallocz_array(s->nb_streams, sizeof(*c->hashes));
+    if (!c->hashes)
+        return AVERROR(ENOMEM);
+    for (i = 0; i < s->nb_streams; i++) {
+        res = av_hash_alloc(&c->hashes[i], c->hash_name);
+        if (res < 0) {
+            return res;
+        }
+        av_hash_init(c->hashes[i]);
+    }
+    return 0;
+}
+#endif
+
+#if CONFIG_HASH_MUXER || CONFIG_MD5_MUXER || CONFIG_STREAMHASH_MUXER
+static char get_media_type_char(enum AVMediaType type)
+{
+    switch (type) {
+    case AVMEDIA_TYPE_VIDEO:      return 'v';
+    case AVMEDIA_TYPE_AUDIO:      return 'a';
+    case AVMEDIA_TYPE_DATA:       return 'd';
+    case AVMEDIA_TYPE_SUBTITLE:   return 's';
+    case AVMEDIA_TYPE_ATTACHMENT: return 't';
+    default:                      return '?';
+    }
+}
 
 static int hash_write_packet(struct AVFormatContext *s, AVPacket *pkt)
 {
     struct HashContext *c = s->priv_data;
-    av_hash_update(c->hashes[0], pkt->data, pkt->size);
+    av_hash_update(c->hashes[c->per_stream ? pkt->stream_index : 0], pkt->data, pkt->size);
     return 0;
 }
 
 static int hash_write_trailer(struct AVFormatContext *s)
 {
     struct HashContext *c = s->priv_data;
-    char buf[AV_HASH_MAX_SIZE*2+128];
-    snprintf(buf, sizeof(buf) - 200, "%s=", av_hash_get_name(c->hashes[0]));
-
-    av_hash_final_hex(c->hashes[0], buf + strlen(buf), sizeof(buf) - strlen(buf));
-    av_strlcatf(buf, sizeof(buf), "\n");
-    avio_write(s->pb, buf, strlen(buf));
-    avio_flush(s->pb);
+    int num_hashes = c->per_stream ? s->nb_streams : 1;
+    for (int i = 0; i < num_hashes; i++) {
+        char buf[AV_HASH_MAX_SIZE*2+128];
+        if (c->per_stream) {
+            AVStream *st = s->streams[i];
+            snprintf(buf, sizeof(buf) - 200, "%d,%c,%s=", i, get_media_type_char(st->codecpar->codec_type),
+                     av_hash_get_name(c->hashes[i]));
+        } else {
+            snprintf(buf, sizeof(buf) - 200, "%s=", av_hash_get_name(c->hashes[i]));
+        }
+        av_hash_final_hex(c->hashes[i], buf + strlen(buf), sizeof(buf) - strlen(buf));
+        av_strlcatf(buf, sizeof(buf), "\n");
+        avio_write(s->pb, buf, strlen(buf));
+    }
 
     return 0;
 }
+#endif
 
 static void hash_free(struct AVFormatContext *s)
 {
     struct HashContext *c = s->priv_data;
-    if (c->hashes)
-        av_hash_freep(&c->hashes[0]);
+    if (c->hashes) {
+        int num_hashes = c->per_stream ? s->nb_streams : 1;
+        for (int i = 0; i < num_hashes; i++) {
+            av_hash_freep(&c->hashes[i]);
+        }
+    }
     av_freep(&c->hashes);
 }
-#endif
 
 #if CONFIG_HASH_MUXER
 static const AVClass hashenc_class = {
     .class_name = "hash muxer",
     .item_name  = av_default_item_name,
-    .option     = hash_options,
+    .option     = hash_streamhash_options,
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVOutputFormat ff_hash_muxer = {
+const AVOutputFormat ff_hash_muxer = {
     .name              = "hash",
     .long_name         = NULL_IF_CONFIG_SMALL("Hash testing"),
     .priv_data_size    = sizeof(struct HashContext),
@@ -148,7 +195,7 @@ static const AVClass md5enc_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVOutputFormat ff_md5_muxer = {
+const AVOutputFormat ff_md5_muxer = {
     .name              = "md5",
     .long_name         = NULL_IF_CONFIG_SMALL("MD5 testing"),
     .priv_data_size    = sizeof(struct HashContext),
@@ -164,6 +211,30 @@ AVOutputFormat ff_md5_muxer = {
 };
 #endif
 
+#if CONFIG_STREAMHASH_MUXER
+static const AVClass streamhashenc_class = {
+    .class_name = "stream hash muxer",
+    .item_name  = av_default_item_name,
+    .option     = hash_streamhash_options,
+    .version    = LIBAVUTIL_VERSION_INT,
+};
+
+const AVOutputFormat ff_streamhash_muxer = {
+    .name              = "streamhash",
+    .long_name         = NULL_IF_CONFIG_SMALL("Per-stream hash testing"),
+    .priv_data_size    = sizeof(struct HashContext),
+    .audio_codec       = AV_CODEC_ID_PCM_S16LE,
+    .video_codec       = AV_CODEC_ID_RAWVIDEO,
+    .init              = streamhash_init,
+    .write_packet      = hash_write_packet,
+    .write_trailer     = hash_write_trailer,
+    .deinit            = hash_free,
+    .flags             = AVFMT_VARIABLE_FPS | AVFMT_TS_NONSTRICT |
+                         AVFMT_TS_NEGATIVE,
+    .priv_class        = &streamhashenc_class,
+};
+#endif
+
 #if CONFIG_FRAMEHASH_MUXER || CONFIG_FRAMEMD5_MUXER
 static void framehash_print_extradata(struct AVFormatContext *s)
 {
@@ -190,7 +261,8 @@ static int framehash_init(struct AVFormatContext *s)
 {
     int res;
     struct HashContext *c = s->priv_data;
-    c->hashes = av_mallocz_array(1, sizeof(c->hashes));
+    c->per_stream = 0;
+    c->hashes = av_mallocz_array(1, sizeof(*c->hashes));
     if (!c->hashes)
         return AVERROR(ENOMEM);
     res = av_hash_alloc(&c->hashes[0], c->hash_name);
@@ -226,18 +298,19 @@ static int framehash_write_packet(struct AVFormatContext *s, AVPacket *pkt)
     avio_write(s->pb, buf, strlen(buf));
 
     if (c->format_version > 1 && pkt->side_data_elems) {
-        int i, j;
+        int i;
         avio_printf(s->pb, ", S=%d", pkt->side_data_elems);
         for (i = 0; i < pkt->side_data_elems; i++) {
             av_hash_init(c->hashes[0]);
             if (HAVE_BIGENDIAN && pkt->side_data[i].type == AV_PKT_DATA_PALETTE) {
-                for (j = 0; j < pkt->side_data[i].size; j += sizeof(uint32_t)) {
+                for (size_t j = 0; j < pkt->side_data[i].size; j += sizeof(uint32_t)) {
                     uint32_t data = AV_RL32(pkt->side_data[i].data + j);
                     av_hash_update(c->hashes[0], (uint8_t *)&data, sizeof(uint32_t));
                 }
             } else
                 av_hash_update(c->hashes[0], pkt->side_data[i].data, pkt->side_data[i].size);
-            snprintf(buf, sizeof(buf) - (AV_HASH_MAX_SIZE * 2 + 1), ", %8d, ", pkt->side_data[i].size);
+            snprintf(buf, sizeof(buf) - (AV_HASH_MAX_SIZE * 2 + 1),
+                     ", %8"SIZE_SPECIFIER", ", pkt->side_data[i].size);
             len = strlen(buf);
             av_hash_final_hex(c->hashes[0], buf + len, sizeof(buf) - len);
             avio_write(s->pb, buf, strlen(buf));
@@ -245,17 +318,8 @@ static int framehash_write_packet(struct AVFormatContext *s, AVPacket *pkt)
     }
 
     avio_printf(s->pb, "\n");
-    avio_flush(s->pb);
     return 0;
 }
-
-static void framehash_free(struct AVFormatContext *s)
-{
-    struct HashContext *c = s->priv_data;
-    if (c->hashes)
-        av_hash_freep(&c->hashes[0]);
-    av_freep(&c->hashes);
-}
 #endif
 
 #if CONFIG_FRAMEHASH_MUXER
@@ -266,7 +330,7 @@ static const AVClass framehash_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVOutputFormat ff_framehash_muxer = {
+const AVOutputFormat ff_framehash_muxer = {
     .name              = "framehash",
     .long_name         = NULL_IF_CONFIG_SMALL("Per-frame hash testing"),
     .priv_data_size    = sizeof(struct HashContext),
@@ -275,7 +339,7 @@ AVOutputFormat ff_framehash_muxer = {
     .init              = framehash_init,
     .write_header      = framehash_write_header,
     .write_packet      = framehash_write_packet,
-    .deinit            = framehash_free,
+    .deinit            = hash_free,
     .flags             = AVFMT_VARIABLE_FPS | AVFMT_TS_NONSTRICT |
                          AVFMT_TS_NEGATIVE,
     .priv_class        = &framehash_class,
@@ -290,7 +354,7 @@ static const AVClass framemd5_class = {
     .version    = LIBAVUTIL_VERSION_INT,
 };
 
-AVOutputFormat ff_framemd5_muxer = {
+const AVOutputFormat ff_framemd5_muxer = {
     .name              = "framemd5",
     .long_name         = NULL_IF_CONFIG_SMALL("Per-frame MD5 testing"),
     .priv_data_size    = sizeof(struct HashContext),
@@ -299,7 +363,7 @@ AVOutputFormat ff_framemd5_muxer = {
     .init              = framehash_init,
     .write_header      = framehash_write_header,
     .write_packet      = framehash_write_packet,
-    .deinit            = framehash_free,
+    .deinit            = hash_free,
     .flags             = AVFMT_VARIABLE_FPS | AVFMT_TS_NONSTRICT |
                          AVFMT_TS_NEGATIVE,
     .priv_class        = &framemd5_class,