sigrid/ffmpeg

doc/APIchanges+5−0

 2011-05-XX - XXXXXX - lavfi 2.6.0 - avcodec.h
   Add avfilter_get_video_buffer_ref_from_frame() to libavfilter/avcodec.h.
+2011-06-xx - xxxxxxx - lavu 51.5.0 - AVMetadata
+  Move AVMetadata from lavf to lavu and rename it to
+  AVDictionary -- new installed header dict.h.
+  All av_metadata_* functions renamed to av_dict_*.
 2011-06-07 - a6703fa - lavu 51.4.0 - av_get_bytes_per_sample()
   Add av_get_bytes_per_sample() in libavutil/samplefmt.h.
   Deprecate av_get_bits_per_sample_fmt().

ffmpeg.c+15−14

 #include "libavutil/colorspace.h"
 #include "libavutil/fifo.h"
 #include "libavutil/intreadwrite.h"
+#include "libavutil/dict.h"
 #include "libavutil/pixdesc.h"
 #include "libavutil/avstring.h"
 #include "libavutil/libm.h"
 static int64_t recording_timestamp = 0;
 static int64_t input_ts_offset = 0;
 static int file_overwrite = 0;
-static AVMetadata *metadata;
+static AVDictionary *metadata;
 static int do_benchmark = 0;
 static int do_hex_dump = 0;
 static int do_pkt_dump = 0;
         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
         if (metadata_chapters_autocopy)
-            av_metadata_copy(&out_ch->metadata, in_ch->metadata, 0);
+            av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
         os->nb_chapters++;
         os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
         icodec = ist->st->codec;
         if (metadata_streams_autocopy)
-            av_metadata_copy(&ost->st->metadata, ist->st->metadata,
+            av_dict_copy(&ost->st->metadata, ist->st->metadata,
-                             AV_METADATA_DONT_OVERWRITE);
+                         AV_DICT_DONT_OVERWRITE);
         ost->st->disposition = ist->st->disposition;
         codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
     /* set meta data information from input file if required */
     for (i=0;i<nb_meta_data_maps;i++) {
         AVFormatContext *files[2];
-        AVMetadata      **meta[2];
+        AVDictionary    **meta[2];
         int j;
 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
             }
         }
-        av_metadata_copy(meta[0], *meta[1], AV_METADATA_DONT_OVERWRITE);
+        av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
     }
     /* copy global metadata by default */
     if (metadata_global_autocopy) {
         for (i = 0; i < nb_output_files; i++)
-            av_metadata_copy(&output_files[i]->metadata, input_files[0].ctx->metadata,
+            av_dict_copy(&output_files[i]->metadata, input_files[0].ctx->metadata,
-                             AV_METADATA_DONT_OVERWRITE);
+                         AV_DICT_DONT_OVERWRITE);
     }
     /* copy chapters according to chapter maps */
     }
     *mid++= 0;
-    av_metadata_set2(&metadata, arg, mid, 0);
+    av_dict_set(&metadata, arg, mid, 0);
     return 0;
 }
             parse_forced_key_frames(forced_key_frames, ost, video_enc);
     }
     if (video_language) {
-        av_metadata_set2(&st->metadata, "language", video_language, 0);
+        av_dict_set(&st->metadata, "language", video_language, 0);
         av_freep(&video_language);
     }
     }
     audio_enc->time_base= (AVRational){1, audio_sample_rate};
     if (audio_language) {
-        av_metadata_set2(&st->metadata, "language", audio_language, 0);
+        av_dict_set(&st->metadata, "language", audio_language, 0);
         av_freep(&audio_language);
     }
     }
     if (subtitle_language) {
-        av_metadata_set2(&st->metadata, "language", subtitle_language, 0);
+        av_dict_set(&st->metadata, "language", subtitle_language, 0);
         av_freep(&subtitle_language);
     }
         oc->timestamp = recording_timestamp;
-        av_metadata_copy(&oc->metadata, metadata, 0);
+        av_dict_copy(&oc->metadata, metadata, 0);
-        av_metadata_free(&metadata);
+        av_dict_free(&metadata);
     }
     output_files[nb_output_files++] = oc;

ffprobe.c+5−4

 #include "libavcodec/avcodec.h"
 #include "libavutil/opt.h"
 #include "libavutil/pixdesc.h"
+#include "libavutil/dict.h"
 #include "libavdevice/avdevice.h"
 #include "cmdutils.h"
     AVCodecContext *dec_ctx;
     AVCodec *dec;
     char val_str[128];
-    AVMetadataTag *tag = NULL;
+    AVDictionaryEntry *tag = NULL;
     AVRational display_aspect_ratio;
     printf("[STREAM]\n");
     if (stream->nb_frames)
         printf("nb_frames=%"PRId64"\n",    stream->nb_frames);
-    while ((tag = av_metadata_get(stream->metadata, "", tag, AV_METADATA_IGNORE_SUFFIX)))
+    while ((tag = av_dict_get(stream->metadata, "", tag, AV_DICT_IGNORE_SUFFIX)))
         printf("TAG:%s=%s\n", tag->key, tag->value);
     printf("[/STREAM]\n");
 static void show_format(AVFormatContext *fmt_ctx)
 {
-    AVMetadataTag *tag = NULL;
+    AVDictionaryEntry *tag = NULL;
     char val_str[128];
     printf("[FORMAT]\n");
     printf("bit_rate=%s\n",         value_string(val_str, sizeof(val_str), fmt_ctx->bit_rate,
                                                  unit_bit_per_second_str));
-    while ((tag = av_metadata_get(fmt_ctx->metadata, "", tag, AV_METADATA_IGNORE_SUFFIX)))
+    while ((tag = av_dict_get(fmt_ctx->metadata, "", tag, AV_DICT_IGNORE_SUFFIX)))
         printf("TAG:%s=%s\n", tag->key, tag->value);
     printf("[/FORMAT]\n");

ffserver.c+10−9

 #include "libavformat/avio_internal.h"
 #include "libavutil/avstring.h"
 #include "libavutil/lfg.h"
+#include "libavutil/dict.h"
 #include "libavutil/random_seed.h"
 #include "libavutil/parseutils.h"
 #include "libavutil/opt.h"
         ctx = c->rtp_ctx[i];
         if (ctx) {
             av_write_trailer(ctx);
-            av_metadata_free(&ctx->metadata);
+            av_dict_free(&ctx->metadata);
             av_free(ctx->streams[0]);
             av_free(ctx);
         }
     switch(c->state) {
     case HTTPSTATE_SEND_DATA_HEADER:
         memset(&c->fmt_ctx, 0, sizeof(c->fmt_ctx));
-        av_metadata_set2(&c->fmt_ctx.metadata, "author"   , c->stream->author   , 0);
+        av_dict_set(&c->fmt_ctx.metadata, "author"   , c->stream->author   , 0);
-        av_metadata_set2(&c->fmt_ctx.metadata, "comment"  , c->stream->comment  , 0);
+        av_dict_set(&c->fmt_ctx.metadata, "comment"  , c->stream->comment  , 0);
-        av_metadata_set2(&c->fmt_ctx.metadata, "copyright", c->stream->copyright, 0);
+        av_dict_set(&c->fmt_ctx.metadata, "copyright", c->stream->copyright, 0);
-        av_metadata_set2(&c->fmt_ctx.metadata, "title"    , c->stream->title    , 0);
+        av_dict_set(&c->fmt_ctx.metadata, "title"    , c->stream->title    , 0);
         c->fmt_ctx.streams = av_mallocz(sizeof(AVStream *) * c->stream->nb_streams);
             http_log("Error writing output header\n");
             return -1;
         }
-        av_metadata_free(&c->fmt_ctx.metadata);
+        av_dict_free(&c->fmt_ctx.metadata);
         len = avio_close_dyn_buf(c->fmt_ctx.pb, &c->pb_buffer);
         c->buffer_ptr = c->pb_buffer;
     if (avc == NULL) {
         return -1;
     }
-    av_metadata_set2(&avc->metadata, "title",
+    av_dict_set(&avc->metadata, "title",
-                     stream->title[0] ? stream->title : "No Title", 0);
+               stream->title[0] ? stream->title : "No Title", 0);
     avc->nb_streams = stream->nb_streams;
     if (stream->is_multicast) {
         snprintf(avc->filename, 1024, "rtp://%s:%d?multicast=1?ttl=%d",
  sdp_done:
     av_free(avc->streams);
-    av_metadata_free(&avc->metadata);
+    av_dict_free(&avc->metadata);
     av_free(avc);
     av_free(avs);

libavcodec/dvbsubdec.c+5−4

 #ifdef DEBUG
 #undef fprintf
+#undef perror
 #if 0
 static void png_save(const char *filename, uint8_t *bitmap, int w, int h,
                      uint32_t *rgba_palette)
     f = fopen(fname, "w");
     if (!f) {
         perror(fname);
-        exit(1);
+        return;
     }
     fprintf(f, "P6\n"
             "%d %d\n"
     f = fopen(fname2, "w");
     if (!f) {
         perror(fname2);
-        exit(1);
+        return;
     }
     fprintf(f, "P5\n"
             "%d %d\n"
     f = fopen(fname, "w");
     if (!f) {
         perror(fname);
-        exit(1);
+        return;
     }
     fprintf(f, "P6\n"
             "%d %d\n"
     f = fopen(fname2, "w");
     if (!f) {
         perror(fname2);
-        exit(1);
+        return;
     }
     fprintf(f, "P5\n"
             "%d %d\n"

libavformat/aiffdec.c+1−0

@@ -20,6 +20,7 @@ · 19 unmodified lines
20	*/	20	*/
21		21
22	#include "libavutil/intfloat_readwrite.h"	22	#include "libavutil/intfloat_readwrite.h"
		23	#include "libavutil/dict.h"
23	#include "avformat.h"	24	#include "avformat.h"
24	#include "pcm.h"	25	#include "pcm.h"
25	#include "aiff.h"	26	#include "aiff.h"

libavformat/apetag.c+2−1

  */
 #include "libavutil/intreadwrite.h"
+#include "libavutil/dict.h"
 #include "avformat.h"
 #include "apetag.h"
         return AVERROR(ENOMEM);
     avio_read(pb, value, size);
     value[size] = 0;
-    av_metadata_set2(&s->metadata, key, value, AV_METADATA_DONT_STRDUP_VAL);
+    av_dict_set(&s->metadata, key, value, AV_DICT_DONT_STRDUP_VAL);
     return 0;
 }

libavformat/applehttp.c+2−1

 #include "libavutil/avstring.h"
 #include "libavutil/intreadwrite.h"
 #include "libavutil/opt.h"
+#include "libavutil/dict.h"
 #include "avformat.h"
 #include "internal.h"
 #include <unistd.h>
             }
             avcodec_copy_context(st->codec, v->ctx->streams[j]->codec);
             if (v->bandwidth)
-                av_metadata_set2(&st->metadata, "variant_bitrate", bitrate_str,
+                av_dict_set(&st->metadata, "variant_bitrate", bitrate_str,
                                  0);
         }
         stream_offset += v->ctx->nb_streams;

libavformat/asfdec.c+4−2

 #include "libavutil/bswap.h"
 #include "libavutil/common.h"
 #include "libavutil/avstring.h"
+#include "libavutil/dict.h"
 #include "libavcodec/mpegaudio.h"
 #include "avformat.h"
 #include "avio_internal.h"
         av_log(s, AV_LOG_DEBUG, "Unsupported value type %d in tag %s.\n", type, key);
         goto finish;
     }
-    av_metadata_set2(&s->metadata, key, value, 0);
+    if (*value)
+        av_dict_set(&s->metadata, key, value, 0);
 finish:
     av_freep(&value);
     avio_seek(s->pb, off + len, SEEK_SET);
                     const char primary_tag[3] = { rfc1766[0], rfc1766[1], '\0' }; // ignore country code if any
                     const char *iso6392 = av_convert_lang_to(primary_tag, AV_LANG_ISO639_2_BIBL);
                     if (iso6392)
-                        av_metadata_set2(&st->metadata, "language", iso6392, 0);
+                        av_dict_set(&st->metadata, "language", iso6392, 0);
                 }
             }
         }

libavformat/asfenc.c+9−9

  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 #include "avformat.h"
-#include "metadata.h"
 #include "riff.h"
 #include "asf.h"
 #include "avio_internal.h"
+#include "libavutil/dict.h"
 #undef NDEBUG
 #include <assert.h>
 {
     ASFContext *asf = s->priv_data;
     AVIOContext *pb = s->pb;
-    AVMetadataTag *tags[5];
+    AVDictionaryEntry *tags[5];
     int header_size, n, extra_size, extra_size2, wav_extra_size, file_time;
     int has_title;
     int metadata_count;
     ff_metadata_conv(&s->metadata, ff_asf_metadata_conv, NULL);
-    tags[0] = av_metadata_get(s->metadata, "title"    , NULL, 0);
+    tags[0] = av_dict_get(s->metadata, "title"    , NULL, 0);
-    tags[1] = av_metadata_get(s->metadata, "author"   , NULL, 0);
+    tags[1] = av_dict_get(s->metadata, "author"   , NULL, 0);
-    tags[2] = av_metadata_get(s->metadata, "copyright", NULL, 0);
+    tags[2] = av_dict_get(s->metadata, "copyright", NULL, 0);
-    tags[3] = av_metadata_get(s->metadata, "comment"  , NULL, 0);
+    tags[3] = av_dict_get(s->metadata, "comment"  , NULL, 0);
-    tags[4] = av_metadata_get(s->metadata, "rating"   , NULL, 0);
+    tags[4] = av_dict_get(s->metadata, "rating"   , NULL, 0);
     duration = asf->duration + PREROLL_TIME * 10000;
     has_title = tags[0] || tags[1] || tags[2] || tags[3] || tags[4];
         end_header(pb, hpos);
     }
     if (metadata_count) {
-        AVMetadataTag *tag = NULL;
+        AVDictionaryEntry *tag = NULL;
         hpos = put_header(pb, &ff_asf_extended_content_header);
         avio_wl16(pb, metadata_count);
-        while ((tag = av_metadata_get(s->metadata, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
+        while ((tag = av_dict_get(s->metadata, "", tag, AV_DICT_IGNORE_SUFFIX))) {
             put_str16(pb, tag->key);
             avio_wl16(pb, 0);
             put_str16(pb, tag->value);

libavformat/avformat.h+34−28

 #include <time.h>
 #include <stdio.h>  /* FILE */
 #include "libavcodec/avcodec.h"
+#include "libavutil/dict.h"
 #include "avio.h"
 #include "libavformat/version.h"
  * variant_bitrate -- the total bitrate of the bitrate variant that the current stream is part of
  */
-#define AV_METADATA_MATCH_CASE      1
+#if FF_API_OLD_METADATA2
-#define AV_METADATA_IGNORE_SUFFIX   2
+/**
-#define AV_METADATA_DONT_STRDUP_KEY 4
+ * @defgroup old_metadata Old metadata API
-#define AV_METADATA_DONT_STRDUP_VAL 8
+ * The following functions are deprecated, use
-#define AV_METADATA_DONT_OVERWRITE 16   ///< Don't overwrite existing tags.
+ * their equivalents from libavutil/dict.h instead.
+ * @{
+ */
-typedef struct {
+#define AV_METADATA_MATCH_CASE      AV_DICT_MATCH_CASE
-    char *key;
+#define AV_METADATA_IGNORE_SUFFIX   AV_DICT_IGNORE_SUFFIX
-    char *value;
+#define AV_METADATA_DONT_STRDUP_KEY AV_DICT_DONT_STRDUP_KEY
-}AVMetadataTag;
+#define AV_METADATA_DONT_STRDUP_VAL AV_DICT_DONT_STRDUP_VAL
+#define AV_METADATA_DONT_OVERWRITE  AV_DICT_DONT_OVERWRITE
+typedef attribute_deprecated AVDictionary AVMetadata;
+typedef attribute_deprecated AVDictionaryEntry  AVMetadataTag;
-typedef struct AVMetadata AVMetadata;
-#if FF_API_OLD_METADATA2
 typedef struct AVMetadataConv AVMetadataConv;
-#endif
 /**
  * Get a metadata element with matching key.
  * @param flags Allows case as well as suffix-insensitive comparisons.
  * @return Found tag or NULL, changing key or value leads to undefined behavior.
  */
-AVMetadataTag *
+attribute_deprecated AVDictionaryEntry *
-av_metadata_get(AVMetadata *m, const char *key, const AVMetadataTag *prev, int flags);
+av_metadata_get(AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags);
 /**
  * Set the given tag in *pm, overwriting an existing tag.
  *        Passing a NULL value will cause an existing tag to be deleted.
  * @return >= 0 on success otherwise an error code <0
  */
-int av_metadata_set2(AVMetadata **pm, const char *key, const char *value, int flags);
+attribute_deprecated int av_metadata_set2(AVDictionary **pm, const char *key, const char *value, int flags);
-#if FF_API_OLD_METADATA2
 /**
  * This function is provided for compatibility reason and currently does nothing.
  */
 attribute_deprecated void av_metadata_conv(struct AVFormatContext *ctx, const AVMetadataConv *d_conv,
                                                                         const AVMetadataConv *s_conv);
-#endif
 /**
- * Copy metadata from one AVMetadata struct into another.
+ * Copy metadata from one AVDictionary struct into another.
- * @param dst pointer to a pointer to a AVMetadata struct. If *dst is NULL,
+ * @param dst pointer to a pointer to a AVDictionary struct. If *dst is NULL,
  *            this function will allocate a struct for you and put it in *dst
- * @param src pointer to source AVMetadata struct
+ * @param src pointer to source AVDictionary struct
  * @param flags flags to use when setting metadata in *dst
- * @note metadata is read using the AV_METADATA_IGNORE_SUFFIX flag
+ * @note metadata is read using the AV_DICT_IGNORE_SUFFIX flag
  */
-void av_metadata_copy(AVMetadata **dst, AVMetadata *src, int flags);
+attribute_deprecated void av_metadata_copy(AVDictionary **dst, AVDictionary *src, int flags);
 /**
- * Free all the memory allocated for an AVMetadata struct.
+ * Free all the memory allocated for an AVDictionary struct.
  */
-void av_metadata_free(AVMetadata **m);
+attribute_deprecated void av_metadata_free(AVDictionary **m);
+/**
+ * @}
+ */
+#endif
 /* packet functions */
      */
     AVRational sample_aspect_ratio;
-    AVMetadata *metadata;
+    AVDictionary *metadata;
     /* Intended mostly for av_read_frame() support. Not supposed to be used by */
     /* external applications; try to use something else if at all possible.    */
     enum AVDiscard discard;        ///< selects which program to discard and which to feed to the caller
     unsigned int   *stream_index;
     unsigned int   nb_stream_indexes;
-    AVMetadata *metadata;
+    AVDictionary *metadata;
     int program_num;
     int pmt_pid;
     int id;                 ///< unique ID to identify the chapter
     AVRational time_base;   ///< time base in which the start/end timestamps are specified
     int64_t start, end;     ///< chapter start/end time in time_base units
-    AVMetadata *metadata;
+    AVDictionary *metadata;
 } AVChapter;
 /**
     struct AVPacketList *packet_buffer_end;
-    AVMetadata *metadata;
+    AVDictionary *metadata;
     /**
      * Remaining size available for raw_packet_buffer, in bytes.

libavformat/avidec.c+8−7

 #include "libavutil/intreadwrite.h"
 #include "libavutil/bswap.h"
 #include "libavutil/opt.h"
+#include "libavutil/dict.h"
 #include "avformat.h"
 #include "avi.h"
 #include "dv.h"
     AV_WL32(key, tag);
-    return av_metadata_set2(st ? &st->metadata : &s->metadata, key, value,
+    return av_dict_set(st ? &st->metadata : &s->metadata, key, value,
-                            AV_METADATA_DONT_STRDUP_VAL);
+                            AV_DICT_DONT_STRDUP_VAL);
 }
 static void avi_read_info(AVFormatContext *s, uint64_t end)
 static const char months[12][4] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
                                     "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
-static void avi_metadata_creation_time(AVMetadata **metadata, char *date)
+static void avi_metadata_creation_time(AVDictionary **metadata, char *date)
 {
     char month[4], time[9], buffer[64];
     int i, day, year;
             if (!strcasecmp(month, months[i])) {
                 snprintf(buffer, sizeof(buffer), "%.4d-%.2d-%.2d %s",
                          year, i+1, day, time);
-                av_metadata_set2(metadata, "creation_time", buffer, 0);
+                av_dict_set(metadata, "creation_time", buffer, 0);
             }
     } else if (date[4] == '/' && date[7] == '/') {
         date[4] = date[7] = '-';
-        av_metadata_set2(metadata, "creation_time", date, 0);
+        av_dict_set(metadata, "creation_time", date, 0);
     }
 }
                     break;
                 }
                 if (name)
-                    av_metadata_set2(&s->metadata, name, buffer, 0);
+                    av_dict_set(&s->metadata, name, buffer, 0);
                 avio_skip(s->pb, size);
             }
             break;
         ret = avio_get_str16le(pb, desc_len, desc, sizeof(desc));
         avio_skip(pb, desc_len - ret);
         if (*desc)
-            av_metadata_set2(&st->metadata, "title", desc, 0);
+            av_dict_set(&st->metadata, "title", desc, 0);
         avio_rl16(pb);   /* flags? */
         avio_rl32(pb);   /* data size */

libavformat/avienc.c+4−3

 #include "avio_internal.h"
 #include "riff.h"
 #include "libavutil/intreadwrite.h"
+#include "libavutil/dict.h"
 /*
  * TODO:
     int bitrate, n, i, nb_frames, au_byterate, au_ssize, au_scale;
     AVCodecContext *stream, *video_enc;
     int64_t list1, list2, strh, strf;
-    AVMetadataTag *t = NULL;
+    AVDictionaryEntry *t = NULL;
     if (s->nb_streams > AVI_MAX_STREAM_COUNT) {
         av_log(s, AV_LOG_ERROR, "AVI does not support >%d streams\n",
             return -1;
         }
         ff_end_tag(pb, strf);
-        if ((t = av_metadata_get(s->streams[i]->metadata, "title", NULL, 0))) {
+        if ((t = av_dict_get(s->streams[i]->metadata, "title", NULL, 0))) {
             avi_write_info_tag(s->pb, "strn", t->value);
             t = NULL;
         }
     ffio_wfourcc(pb, "INFO");
     ff_metadata_conv(&s->metadata, ff_avi_metadata_conv, NULL);
     for (i = 0; *ff_avi_tags[i]; i++) {
-        if ((t = av_metadata_get(s->metadata, ff_avi_tags[i], NULL, AV_METADATA_MATCH_CASE)))
+        if ((t = av_dict_get(s->metadata, ff_avi_tags[i], NULL, AV_DICT_MATCH_CASE)))
             avi_write_info_tag(s->pb, t->key, t->value);
     }
     ff_end_tag(pb, list2);

libavformat/cafdec.c+2−1

 #include "riff.h"
 #include "isom.h"
 #include "libavutil/intreadwrite.h"
+#include "libavutil/dict.h"
 #include "caf.h"
 typedef struct {
         char value[1024];
         get_strz(pb, key, sizeof(key));
         get_strz(pb, value, sizeof(value));
-        av_metadata_set2(&s->metadata, key, value, 0);
+        av_dict_set(&s->metadata, key, value, 0);
     }
 }

libavformat/ffmetadec.c+4−3

 #include "avformat.h"
 #include "ffmeta.h"
 #include "internal.h"
+#include "libavutil/dict.h"
 static int probe(AVProbeData *p)
 {
     return ret;
 }
-static int read_tag(uint8_t *line, AVMetadata **m)
+static int read_tag(uint8_t *line, AVDictionary **m)
 {
     uint8_t *key, *value, *p = line;
         return AVERROR(ENOMEM);
     }
-    av_metadata_set2(m, key, value, AV_METADATA_DONT_STRDUP_KEY | AV_METADATA_DONT_STRDUP_VAL);
+    av_dict_set(m, key, value, AV_DICT_DONT_STRDUP_KEY | AV_DICT_DONT_STRDUP_VAL);
     return 0;
 }
 static int read_header(AVFormatContext *s, AVFormatParameters *ap)
 {
-    AVMetadata **m = &s->metadata;
+    AVDictionary **m = &s->metadata;
     uint8_t line[1024];
     while(!url_feof(s->pb)) {

libavformat/ffmetaenc.c+4−3

 #include "avformat.h"
 #include "ffmeta.h"
+#include "libavutil/dict.h"
 static void write_escape_str(AVIOContext *s, const uint8_t *str)
     }
 }
-static void write_tags(AVIOContext *s, AVMetadata *m)
+static void write_tags(AVIOContext *s, AVDictionary *m)
 {
-    AVMetadataTag *t = NULL;
+    AVDictionaryEntry *t = NULL;
-    while ((t = av_metadata_get(m, "", t, AV_METADATA_IGNORE_SUFFIX))) {
+    while ((t = av_dict_get(m, "", t, AV_DICT_IGNORE_SUFFIX))) {
         write_escape_str(s, t->key);
         avio_w8(s, '=');
         write_escape_str(s, t->value);

libavformat/flacenc.c+1−2

 #include "libavcodec/flac.h"
 #include "avformat.h"
 #include "flacenc.h"
-#include "metadata.h"
 #include "vorbiscomment.h"
 #include "libavcodec/bytestream.h"
     return 0;
 }
-static int flac_write_block_comment(AVIOContext *pb, AVMetadata **m,
+static int flac_write_block_comment(AVIOContext *pb, AVDictionary **m,
                                     int last_block, int bitexact)
 {
     const char *vendor = bitexact ? "ffmpeg" : LIBAVFORMAT_IDENT;

libavformat/flvdec.c+4−3

  */
 #include "libavutil/avstring.h"
+#include "libavutil/dict.h"
 #include "libavcodec/bytestream.h"
 #include "libavcodec/mpeg4audio.h"
 #include "avformat.h"
         if(amf_type == AMF_DATA_TYPE_BOOL) {
             av_strlcpy(str_val, num_val > 0 ? "true" : "false", sizeof(str_val));
-            av_metadata_set2(&s->metadata, key, str_val, 0);
+            av_dict_set(&s->metadata, key, str_val, 0);
         } else if(amf_type == AMF_DATA_TYPE_NUMBER) {
             snprintf(str_val, sizeof(str_val), "%.f", num_val);
-            av_metadata_set2(&s->metadata, key, str_val, 0);
+            av_dict_set(&s->metadata, key, str_val, 0);
             if(!strcmp(key, "duration")) s->duration = num_val * AV_TIME_BASE;
             else if(!strcmp(key, "videodatarate") && vcodec && 0 <= (int)(num_val * 1024.0))
                 vcodec->bit_rate = num_val * 1024.0;
             else if(!strcmp(key, "audiodatarate") && acodec && 0 <= (int)(num_val * 1024.0))
                 acodec->bit_rate = num_val * 1024.0;
         } else if (amf_type == AMF_DATA_TYPE_STRING)
-            av_metadata_set2(&s->metadata, key, str_val, 0);
+            av_dict_set(&s->metadata, key, str_val, 0);
     }
     return 0;

libavformat/flvenc.c+3−2

 #include "internal.h"
 #include "avc.h"
 #include "metadata.h"
+#include "libavutil/dict.h"
 #undef NDEBUG
 #include <assert.h>
     int i;
     double framerate = 0.0;
     int metadata_size_pos, data_size;
-    AVMetadataTag *tag = NULL;
+    AVDictionaryEntry *tag = NULL;
     for(i=0; i<s->nb_streams; i++){
         AVCodecContext *enc = s->streams[i]->codec;
         put_amf_double(pb, audio_enc->codec_tag);
     }
-    while ((tag = av_metadata_get(s->metadata, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
+    while ((tag = av_dict_get(s->metadata, "", tag, AV_DICT_IGNORE_SUFFIX))) {
         put_amf_string(pb, tag->key);
         avio_w8(pb, AMF_DATA_TYPE_STRING);
         put_amf_string(pb, tag->value);

libavformat/id3v1.c+4−3

 #include "id3v1.h"
 #include "libavcodec/avcodec.h"
+#include "libavutil/dict.h"
 const char * const ff_id3v1_genre_str[ID3v1_GENRE_MAX + 1] = {
       [0] = "Blues",
     *q = '\0';
     if (*str)
-        av_metadata_set2(&s->metadata, key, str, 0);
+        av_dict_set(&s->metadata, key, str, 0);
 }
 /**
     get_string(s, "comment", buf + 97, 30);
     if (buf[125] == 0 && buf[126] != 0) {
         snprintf(str, sizeof(str), "%d", buf[126]);
-        av_metadata_set2(&s->metadata, "track", str, 0);
+        av_dict_set(&s->metadata, "track", str, 0);
     }
     genre = buf[127];
     if (genre <= ID3v1_GENRE_MAX)
-        av_metadata_set2(&s->metadata, "genre", ff_id3v1_genre_str[genre], 0);
+        av_dict_set(&s->metadata, "genre", ff_id3v1_genre_str[genre], 0);
     return 0;
 }

libavformat/id3v2.c+14−14

@@ -30,7 +30,7 @@ · 29 unmodified lines
30	#include "id3v1.h"	30	#include "id3v1.h"
31	#include "libavutil/avstring.h"	31	#include "libavutil/avstring.h"
32	#include "libavutil/intreadwrite.h"	32	#include "libavutil/intreadwrite.h"
33	#include "metadata.h"	33	#include "libavutil/dict.h"
34	#include "avio_internal.h"	34	#include "avio_internal.h"
35		35
36	int ff_id3v2_match(const uint8_t buf, const char magic)	36	int ff_id3v2_match(const uint8_t buf, const char magic)
@@ -140,7 +140,7 @@ static void read_ttag(AVFormatContext s, AVIOContext pb, int taglen, const cha · 103 unmodified lines
140	val = dst;	140	val = dst;
141		141
142	if (val)	142	if (val)
143	av_metadata_set2(&s->metadata, key, val, AV_METADATA_DONT_OVERWRITE);	143	av_dict_set(&s->metadata, key, val, AV_DICT_DONT_OVERWRITE);
144	}	144	}
145		145
146	static int is_number(const char *str)	146	static int is_number(const char *str)
@@ -149,44 +149,44 @@ static int is_number(const char *str) · 2 unmodified lines
149	return !*str;	149	return !*str;
150	}	150	}
151		151
152	static AVMetadataTag* get_date_tag(AVMetadata m, const char tag)	152	static AVDictionaryEntry* get_date_tag(AVDictionary m, const char tag)
153	{	153	{
154	AVMetadataTag *t;	154	AVDictionaryEntry *t;
155	if ((t = av_metadata_get(m, tag, NULL, AV_METADATA_MATCH_CASE)) &&	155	if ((t = av_dict_get(m, tag, NULL, AV_DICT_MATCH_CASE)) &&
156	strlen(t->value) == 4 && is_number(t->value))	156	strlen(t->value) == 4 && is_number(t->value))
157	return t;	157	return t;
158	return NULL;	158	return NULL;
159	}	159	}
160		160
161	static void merge_date(AVMetadata **m)	161	static void merge_date(AVDictionary **m)
162	{	162	{
163	AVMetadataTag *t;	163	AVDictionaryEntry *t;
164	char date[17] = {0}; // YYYY-MM-DD hh:mm	164	char date[17] = {0}; // YYYY-MM-DD hh:mm
165		165
166	if (!(t = get_date_tag(*m, "TYER")) &&	166	if (!(t = get_date_tag(*m, "TYER")) &&
167	!(t = get_date_tag(*m, "TYE")))	167	!(t = get_date_tag(*m, "TYE")))
168	return;	168	return;
169	av_strlcpy(date, t->value, 5);	169	av_strlcpy(date, t->value, 5);
170	av_metadata_set2(m, "TYER", NULL, 0);	170	av_dict_set(m, "TYER", NULL, 0);
171	av_metadata_set2(m, "TYE", NULL, 0);	171	av_dict_set(m, "TYE", NULL, 0);
172		172
173	if (!(t = get_date_tag(*m, "TDAT")) &&	173	if (!(t = get_date_tag(*m, "TDAT")) &&
174	!(t = get_date_tag(*m, "TDA")))	174	!(t = get_date_tag(*m, "TDA")))
175	goto finish;	175	goto finish;
176	snprintf(date + 4, sizeof(date) - 4, "-%.2s-%.2s", t->value + 2, t->value);	176	snprintf(date + 4, sizeof(date) - 4, "-%.2s-%.2s", t->value + 2, t->value);
177	av_metadata_set2(m, "TDAT", NULL, 0);	177	av_dict_set(m, "TDAT", NULL, 0);
178	av_metadata_set2(m, "TDA", NULL, 0);	178	av_dict_set(m, "TDA", NULL, 0);
179		179
180	if (!(t = get_date_tag(*m, "TIME")) &&	180	if (!(t = get_date_tag(*m, "TIME")) &&
181	!(t = get_date_tag(*m, "TIM")))	181	!(t = get_date_tag(*m, "TIM")))
182	goto finish;	182	goto finish;
183	snprintf(date + 10, sizeof(date) - 10, " %.2s:%.2s", t->value, t->value + 2);	183	snprintf(date + 10, sizeof(date) - 10, " %.2s:%.2s", t->value, t->value + 2);
184	av_metadata_set2(m, "TIME", NULL, 0);	184	av_dict_set(m, "TIME", NULL, 0);
185	av_metadata_set2(m, "TIM", NULL, 0);	185	av_dict_set(m, "TIM", NULL, 0);
186		186
187	finish:	187	finish:
188	if (date[0])	188	if (date[0])
189	av_metadata_set2(m, "date", date, 0);	189	av_dict_set(m, "date", date, 0);
190	}	190	}
191		191
192	static void ff_id3v2_parse(AVFormatContext *s, int len, uint8_t version, uint8_t flags)	192	static void ff_id3v2_parse(AVFormatContext *s, int len, uint8_t version, uint8_t flags)

libavformat/iff.c+2−1

 #include "libavcodec/bytestream.h"
 #include "libavutil/intreadwrite.h"
+#include "libavutil/dict.h"
 #include "avformat.h"
 #define ID_8SVX       MKTAG('8','S','V','X')
         return AVERROR(EIO);
     }
     buf[data_size] = 0;
-    av_metadata_set2(&s->metadata, tag, buf, AV_METADATA_DONT_STRDUP_VAL);
+    av_dict_set(&s->metadata, tag, buf, AV_DICT_DONT_STRDUP_VAL);
     return 0;
 }

libavformat/matroskadec.c+9−8

 #include "libavutil/intreadwrite.h"
 #include "libavutil/avstring.h"
 #include "libavutil/lzo.h"
+#include "libavutil/dict.h"
 #if CONFIG_ZLIB
 #include <zlib.h>
 #endif
 }
 static void matroska_convert_tag(AVFormatContext *s, EbmlList *list,
-                                 AVMetadata **metadata, char *prefix)
+                                 AVDictionary **metadata, char *prefix)
 {
     MatroskaTag *tags = list->elem;
     char key[1024];
         if (prefix)  snprintf(key, sizeof(key), "%s/%s", prefix, tags[i].name);
         else         av_strlcpy(key, tags[i].name, sizeof(key));
         if (tags[i].def || !lang) {
-        av_metadata_set2(metadata, key, tags[i].string, 0);
+        av_dict_set(metadata, key, tags[i].string, 0);
         if (tags[i].sub.nb_elem)
             matroska_convert_tag(s, &tags[i].sub, metadata, key);
         }
         if (lang) {
             av_strlcat(key, "-", sizeof(key));
             av_strlcat(key, lang, sizeof(key));
-            av_metadata_set2(metadata, key, tags[i].string, 0);
+            av_dict_set(metadata, key, tags[i].string, 0);
             if (tags[i].sub.nb_elem)
                 matroska_convert_tag(s, &tags[i].sub, metadata, key);
         }
     if (matroska->duration)
         matroska->ctx->duration = matroska->duration * matroska->time_scale
                                   * 1000 / AV_TIME_BASE;
-    av_metadata_set2(&s->metadata, "title", matroska->title, 0);
+    av_dict_set(&s->metadata, "title", matroska->title, 0);
     tracks = matroska->tracks.elem;
     for (i=0; i < matroska->tracks.nb_elem; i++) {
         st->codec->codec_id = codec_id;
         st->start_time = 0;
         if (strcmp(track->language, "und"))
-            av_metadata_set2(&st->metadata, "language", track->language, 0);
+            av_dict_set(&st->metadata, "language", track->language, 0);
-        av_metadata_set2(&st->metadata, "title", track->name, 0);
+        av_dict_set(&st->metadata, "title", track->name, 0);
         if (track->flag_default)
             st->disposition |= AV_DISPOSITION_DEFAULT;
             AVStream *st = av_new_stream(s, 0);
             if (st == NULL)
                 break;
-            av_metadata_set2(&st->metadata, "filename",attachements[j].filename, 0);
+            av_dict_set(&st->metadata, "filename",attachements[j].filename, 0);
             st->codec->codec_id = CODEC_ID_NONE;
             st->codec->codec_type = AVMEDIA_TYPE_ATTACHMENT;
             st->codec->extradata  = av_malloc(attachements[j].bin.size);
             ff_new_chapter(s, chapters[i].uid, (AVRational){1, 1000000000},
                            chapters[i].start, chapters[i].end,
                            chapters[i].title);
-            av_metadata_set2(&chapters[i].chapter->metadata,
+            av_dict_set(&chapters[i].chapter->metadata,
                              "title", chapters[i].title, 0);
             max_start = chapters[i].start;
         }

libavformat/matroskaenc.c+17−16

 #include "libavutil/intreadwrite.h"
 #include "libavutil/random_seed.h"
 #include "libavutil/lfg.h"
+#include "libavutil/dict.h"
 #include "libavcodec/xiph.h"
 #include "libavcodec/mpeg4audio.h"
 #include <strings.h>
         int bit_depth = av_get_bits_per_sample(codec->codec_id);
         int sample_rate = codec->sample_rate;
         int output_sample_rate = 0;
-        AVMetadataTag *tag;
+        AVDictionaryEntry *tag;
         if (!bit_depth)
             bit_depth = av_get_bits_per_sample_fmt(codec->sample_fmt);
         put_ebml_uint (pb, MATROSKA_ID_TRACKUID        , i + 1);
         put_ebml_uint (pb, MATROSKA_ID_TRACKFLAGLACING , 0);    // no lacing (yet)
-        if ((tag = av_metadata_get(st->metadata, "title", NULL, 0)))
+        if ((tag = av_dict_get(st->metadata, "title", NULL, 0)))
             put_ebml_string(pb, MATROSKA_ID_TRACKNAME, tag->value);
-        tag = av_metadata_get(st->metadata, "language", NULL, 0);
+        tag = av_dict_get(st->metadata, "language", NULL, 0);
         put_ebml_string(pb, MATROSKA_ID_TRACKLANGUAGE, tag ? tag->value:"und");
         if (st->disposition)
                 put_ebml_uint (pb, MATROSKA_ID_VIDEOPIXELWIDTH , codec->width);
                 put_ebml_uint (pb, MATROSKA_ID_VIDEOPIXELHEIGHT, codec->height);
-                if ((tag = av_metadata_get(st->metadata, "stereo_mode", NULL, 0)) ||
+                if ((tag = av_dict_get(st->metadata, "stereo_mode", NULL, 0)) ||
-                    (tag = av_metadata_get( s->metadata, "stereo_mode", NULL, 0))) {
+                    (tag = av_dict_get( s->metadata, "stereo_mode", NULL, 0))) {
                     // save stereo mode flag
                     uint64_t st_mode = MATROSKA_VIDEO_STEREO_MODE_COUNT;
     for (i = 0; i < s->nb_chapters; i++) {
         ebml_master chapteratom, chapterdisplay;
         AVChapter *c     = s->chapters[i];
-        AVMetadataTag *t = NULL;
+        AVDictionaryEntry *t = NULL;
         chapteratom = start_ebml_master(pb, MATROSKA_ID_CHAPTERATOM, 0);
         put_ebml_uint(pb, MATROSKA_ID_CHAPTERUID, c->id);
                       av_rescale_q(c->end,   c->time_base, scale));
         put_ebml_uint(pb, MATROSKA_ID_CHAPTERFLAGHIDDEN , 0);
         put_ebml_uint(pb, MATROSKA_ID_CHAPTERFLAGENABLED, 1);
-        if ((t = av_metadata_get(c->metadata, "title", NULL, 0))) {
+        if ((t = av_dict_get(c->metadata, "title", NULL, 0))) {
             chapterdisplay = start_ebml_master(pb, MATROSKA_ID_CHAPTERDISPLAY, 0);
             put_ebml_string(pb, MATROSKA_ID_CHAPSTRING, t->value);
             put_ebml_string(pb, MATROSKA_ID_CHAPLANG  , "und");
     return 0;
 }
-static void mkv_write_simpletag(AVIOContext *pb, AVMetadataTag *t)
+static void mkv_write_simpletag(AVIOContext *pb, AVDictionaryEntry *t)
 {
     uint8_t *key = av_strdup(t->key);
     uint8_t *p   = key;
     av_freep(&key);
 }
-static int mkv_write_tag(AVFormatContext *s, AVMetadata *m, unsigned int elementid,
+static int mkv_write_tag(AVFormatContext *s, AVDictionary *m, unsigned int elementid,
                          unsigned int uid, ebml_master *tags)
 {
     MatroskaMuxContext *mkv = s->priv_data;
     ebml_master tag, targets;
-    AVMetadataTag *t = NULL;
+    AVDictionaryEntry *t = NULL;
     int ret;
     if (!tags->pos) {
         put_ebml_uint(s->pb, elementid, uid);
     end_ebml_master(s->pb, targets);
-    while ((t = av_metadata_get(m, "", t, AV_METADATA_IGNORE_SUFFIX)))
+    while ((t = av_dict_get(m, "", t, AV_DICT_IGNORE_SUFFIX)))
         if (strcasecmp(t->key, "title") && strcasecmp(t->key, "stereo_mode"))
             mkv_write_simpletag(s->pb, t);
     ff_metadata_conv_ctx(s, ff_mkv_metadata_conv, NULL);
-    if (av_metadata_get(s->metadata, "", NULL, AV_METADATA_IGNORE_SUFFIX)) {
+    if (av_dict_get(s->metadata, "", NULL, AV_DICT_IGNORE_SUFFIX)) {
         ret = mkv_write_tag(s, s->metadata, 0, 0, &tags);
         if (ret < 0) return ret;
     }
     for (i = 0; i < s->nb_streams; i++) {
         AVStream *st = s->streams[i];
-        if (!av_metadata_get(st->metadata, "", 0, AV_METADATA_IGNORE_SUFFIX))
+        if (!av_dict_get(st->metadata, "", 0, AV_DICT_IGNORE_SUFFIX))
             continue;
         ret = mkv_write_tag(s, st->metadata, MATROSKA_ID_TAGTARGETS_TRACKUID, i + 1, &tags);
     for (i = 0; i < s->nb_chapters; i++) {
         AVChapter *ch = s->chapters[i];
-        if (!av_metadata_get(ch->metadata, "", NULL, AV_METADATA_IGNORE_SUFFIX))
+        if (!av_dict_get(ch->metadata, "", NULL, AV_DICT_IGNORE_SUFFIX))
             continue;
         ret = mkv_write_tag(s, ch->metadata, MATROSKA_ID_TAGTARGETS_CHAPTERUID, ch->id, &tags);
     MatroskaMuxContext *mkv = s->priv_data;
     AVIOContext *pb = s->pb;
     ebml_master ebml_header, segment_info;
-    AVMetadataTag *tag;
+    AVDictionaryEntry *tag;
     int ret, i;
     if (!strcmp(s->oformat->name, "webm")) mkv->mode = MODE_WEBM;
     segment_info = start_ebml_master(pb, MATROSKA_ID_INFO, 0);
     put_ebml_uint(pb, MATROSKA_ID_TIMECODESCALE, 1000000);
-    if ((tag = av_metadata_get(s->metadata, "title", NULL, 0)))
+    if ((tag = av_dict_get(s->metadata, "title", NULL, 0)))
         put_ebml_string(pb, MATROSKA_ID_TITLE, tag->value);
     if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
         uint32_t segment_uid[4];

libavformat/metadata.c+20−83

@@ -21,107 +21,51 @@ · 20 unmodified lines
21	#include <strings.h>	21	#include <strings.h>
22	#include "avformat.h"	22	#include "avformat.h"
23	#include "metadata.h"	23	#include "metadata.h"
		24	#include "libavutil/dict.h"
24		25
25	AVMetadataTag *	26	#if FF_API_OLD_METADATA2
26	av_metadata_get(AVMetadata m, const char key, const AVMetadataTag *prev, int flags)	27	AVDictionaryEntry *
		28	av_metadata_get(AVDictionary m, const char key, const AVDictionaryEntry *prev, int flags)
27	{	29	{
28	unsigned int i, j;	30	return av_dict_get(m, key, prev, flags);
29
30	if(!m)
31	return NULL;
32
33	if(prev) i= prev - m->elems + 1;
34	else i= 0;
35
36	for(; i<m->count; i++){
37	const char *s= m->elems[i].key;
38	if(flags & AV_METADATA_MATCH_CASE) for(j=0; s[j] == key[j] && key[j]; j++);
39	else for(j=0; toupper(s[j]) == toupper(key[j]) && key[j]; j++);
40	if(key[j])
41	continue;
42	if(s[j] && !(flags & AV_METADATA_IGNORE_SUFFIX))
43	continue;
44	return &m->elems[i];
45	}
46	return NULL;
47	}	31	}
48		32
49	int av_metadata_set2(AVMetadata *pm, const char key, const char *value, int flags)	33	int av_metadata_set2(AVDictionary *pm, const char key, const char *value, int flags)
50	{	34	{
51	AVMetadata m= pm;	35	return av_dict_set(pm, key, value, flags);
52	AVMetadataTag *tag= av_metadata_get(m, key, NULL, flags);
53
54	if(!m)
55	m=pm= av_mallocz(sizeof(m));
56
57	if(tag){
58	if (flags & AV_METADATA_DONT_OVERWRITE)
59	return 0;
60	av_free(tag->value);
61	av_free(tag->key);
62	*tag= m->elems[--m->count];
63	}else{
64	AVMetadataTag tmp= av_realloc(m->elems, (m->count+1) sizeof(*m->elems));
65	if(tmp){
66	m->elems= tmp;
67	}else
68	return AVERROR(ENOMEM);
69	}
70	if(value){
71	if(flags & AV_METADATA_DONT_STRDUP_KEY){
72	m->elems[m->count].key = key;
73	}else
74	m->elems[m->count].key = av_strdup(key );
75	if(flags & AV_METADATA_DONT_STRDUP_VAL){
76	m->elems[m->count].value= value;
77	}else
78	m->elems[m->count].value= av_strdup(value);
79	m->count++;
80	}
81	if(!m->count) {
82	av_free(m->elems);
83	av_freep(pm);
84	}
85
86	return 0;
87	}	36	}
88		37
89	#if FF_API_OLD_METADATA2
90	void av_metadata_conv(AVFormatContext ctx, const AVMetadataConv d_conv,	38	void av_metadata_conv(AVFormatContext ctx, const AVMetadataConv d_conv,
91	const AVMetadataConv *s_conv)	39	const AVMetadataConv *s_conv)
92	{	40	{
93	return;	41	return;
94	}	42	}
95	#endif
96		43
97	void av_metadata_free(AVMetadata **pm)	44	void av_metadata_free(AVDictionary **pm)
98	{	45	{
99	AVMetadata m= pm;	46	av_dict_free(pm);
		47	}
100		48
101	if(m){	49	void av_metadata_copy(AVDictionary *dst, AVDictionary src, int flags)
102	while(m->count--){	50	{
103	av_free(m->elems[m->count].key);	51	av_dict_copy(dst, src, flags);
104	av_free(m->elems[m->count].value);
105	}
106	av_free(m->elems);
107	}
108	av_freep(pm);
109	}	52	}
		53	#endif
110		54
111	void ff_metadata_conv(AVMetadata *pm, const AVMetadataConv d_conv,	55	void ff_metadata_conv(AVDictionary *pm, const AVMetadataConv d_conv,
112	const AVMetadataConv *s_conv)	56	const AVMetadataConv *s_conv)
113	{	57	{
114	/* TODO: use binary search to look up the two conversion tables	58	/* TODO: use binary search to look up the two conversion tables
115	if the tables are getting big enough that it would matter speed wise */	59	if the tables are getting big enough that it would matter speed wise */
116	const AVMetadataConv sc, dc;	60	const AVMetadataConv sc, dc;
117	AVMetadataTag *mtag = NULL;	61	AVDictionaryEntry *mtag = NULL;
118	AVMetadata *dst = NULL;	62	AVDictionary *dst = NULL;
119	const char *key;	63	const char *key;
120		64
121	if (d_conv == s_conv)	65	if (d_conv == s_conv)
122	return;	66	return;
123		67
124	while((mtag=av_metadata_get(*pm, "", mtag, AV_METADATA_IGNORE_SUFFIX))) {	68	while ((mtag = av_dict_get(*pm, "", mtag, AV_DICT_IGNORE_SUFFIX))) {
125	key = mtag->key;	69	key = mtag->key;
126	if (s_conv)	70	if (s_conv)
127	for (sc=s_conv; sc->native; sc++)	71	for (sc=s_conv; sc->native; sc++)
@@ -135,9 +79,9 @@ void ff_metadata_conv(AVMetadata *pm, const AVMetadataConv d_conv, · 7 unmodified lines
135	key = dc->native;	79	key = dc->native;
136	break;	80	break;
137	}	81	}
138	av_metadata_set2(&dst, key, mtag->value, 0);	82	av_dict_set(&dst, key, mtag->value, 0);
139	}	83	}
140	av_metadata_free(pm);	84	av_dict_free(pm);
141	*pm = dst;	85	*pm = dst;
142	}	86	}
143		87
@@ -154,10 +98,3 @@ void ff_metadata_conv_ctx(AVFormatContext ctx, const AVMetadataConv d_conv, · 10 unmodified lines
154	ff_metadata_conv(&ctx->programs[i]->metadata, d_conv, s_conv);	98	ff_metadata_conv(&ctx->programs[i]->metadata, d_conv, s_conv);
155	}	99	}
156		100
157	void av_metadata_copy(AVMetadata *dst, AVMetadata src, int flags)
158	{
159	AVMetadataTag *t = NULL;
160
161	while ((t = av_metadata_get(src, "", t, AV_METADATA_IGNORE_SUFFIX)))
162	av_metadata_set2(dst, t->key, t->value, flags);
163	}

libavformat/metadata.h+2−6

@@ -29,11 +29,7 @@ · 28 unmodified lines
29		29
30		30
31	#include "avformat.h"	31	#include "avformat.h"
32		32	#include "libavutil/dict.h"
33	struct AVMetadata{
34	int count;
35	AVMetadataTag *elems;
36	};
37		33
38	struct AVMetadataConv{	34	struct AVMetadataConv{
39	const char *native;	35	const char *native;
@@ -43,7 +39,7 @@ struct AVMetadataConv{ · 3 unmodified lines
43	typedef struct AVMetadataConv AVMetadataConv;	39	typedef struct AVMetadataConv AVMetadataConv;
44	#endif	40	#endif
45		41
46	void ff_metadata_conv(AVMetadata *pm, const AVMetadataConv d_conv,	42	void ff_metadata_conv(AVDictionary *pm, const AVMetadataConv d_conv,
47	const AVMetadataConv *s_conv);	43	const AVMetadataConv *s_conv);
48	void ff_metadata_conv_ctx(AVFormatContext ctx, const AVMetadataConv d_conv,	44	void ff_metadata_conv_ctx(AVFormatContext ctx, const AVMetadataConv d_conv,
49	const AVMetadataConv *s_conv);	45	const AVMetadataConv *s_conv);

libavformat/mov.c+10−12

 #include "libavutil/intreadwrite.h"
 #include "libavutil/avstring.h"
+#include "libavutil/dict.h"
 #include "avformat.h"
 #include "avio_internal.h"
 #include "riff.h"
     avio_rb16(pb); // unknown
     snprintf(buf, sizeof(buf), "%d", avio_rb16(pb));
-    av_metadata_set2(&c->fc->metadata, type, buf, 0);
+    av_dict_set(&c->fc->metadata, type, buf, 0);
     avio_rb16(pb); // total tracks/discs
             avio_read(pb, str, str_size);
             str[str_size] = 0;
         }
-        av_metadata_set2(&c->fc->metadata, key, str, 0);
+        av_dict_set(&c->fc->metadata, key, str, 0);
         if (*language && strcmp(language, "und")) {
             snprintf(key2, sizeof(key2), "%s-%s", key, language);
-            av_metadata_set2(&c->fc->metadata, key2, str, 0);
+            av_dict_set(&c->fc->metadata, key2, str, 0);
         }
     }
     av_dlog(c->fc, "lang \"%3s\" ", language);
     if (strcmp(type, "qt  "))
         c->isom = 1;
     av_log(c->fc, AV_LOG_DEBUG, "ISO: File Type Major Brand: %.4s\n",(char *)&type);
-    av_metadata_set2(&c->fc->metadata, "major_brand", type, 0);
+    av_dict_set(&c->fc->metadata, "major_brand", type, 0);
     minor_ver = avio_rb32(pb); /* minor version */
     snprintf(minor_ver_str, sizeof(minor_ver_str), "%d", minor_ver);
-    av_metadata_set2(&c->fc->metadata, "minor_version", minor_ver_str, 0);
+    av_dict_set(&c->fc->metadata, "minor_version", minor_ver_str, 0);
     comp_brand_size = atom.size - 8;
     if (comp_brand_size < 0)
         return AVERROR(ENOMEM);
     avio_read(pb, comp_brands_str, comp_brand_size);
     comp_brands_str[comp_brand_size] = 0;
-    av_metadata_set2(&c->fc->metadata, "compatible_brands", comp_brands_str, 0);
+    av_dict_set(&c->fc->metadata, "compatible_brands", comp_brands_str, 0);
     av_freep(&comp_brands_str);
     return 0;
     return mov_read_default(c, pb, atom);
 }
-static void mov_metadata_creation_time(AVMetadata **metadata, time_t time)
+static void mov_metadata_creation_time(AVDictionary **metadata, time_t time)
 {
     char buffer[32];
     if (time) {
         ptm = gmtime(&time);
         if (!ptm) return;
         strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", ptm);
-        av_metadata_set2(metadata, "creation_time", buffer, 0);
+        av_dict_set(metadata, "creation_time", buffer, 0);
     }
 }
     lang = avio_rb16(pb); /* language */
     if (ff_mov_lang_to_iso639(lang, language))
-        av_metadata_set2(&st->metadata, "language", language, 0);
+        av_dict_set(&st->metadata, "language", language, 0);
     avio_rb16(pb); /* quality */
     return 0;
         goto free_and_return;
     atom.type = MKTAG('m','o','o','v');
     atom.size = moov_len;
-#ifdef DEBUG
-//    { int fd = open("/tmp/uncompheader.mov", O_WRONLY | O_CREAT); write(fd, moov_data, moov_len); close(fd); }
-#endif
     ret = mov_read_default(c, &ctx, atom);
 free_and_return:
     av_free(moov_data);

libavformat/movenc.c+13−12

 #include "internal.h"
 #include "libavutil/avstring.h"
 #include "libavutil/opt.h"
+#include "libavutil/dict.h"
 #undef NDEBUG
 #include <assert.h>
                                      int long_style)
 {
     int l, lang = 0, len, len2;
-    AVMetadataTag *t, *t2 = NULL;
+    AVDictionaryEntry *t, *t2 = NULL;
     char tag2[16];
-    if (!(t = av_metadata_get(s->metadata, tag, NULL, 0)))
+    if (!(t = av_dict_get(s->metadata, tag, NULL, 0)))
         return 0;
     len = strlen(t->key);
     snprintf(tag2, sizeof(tag2), "%s-", tag);
-    while ((t2 = av_metadata_get(s->metadata, tag2, t2, AV_METADATA_IGNORE_SUFFIX))) {
+    while ((t2 = av_dict_get(s->metadata, tag2, t2, AV_DICT_IGNORE_SUFFIX))) {
         len2 = strlen(t2->key);
         if (len2 == len+4 && !strcmp(t->value, t2->value)
             && (l=ff_mov_iso639_to_lang(&t2->key[len2-3], 1)) >= 0) {
 static int mov_write_trkn_tag(AVIOContext *pb, MOVMuxContext *mov,
                               AVFormatContext *s)
 {
-    AVMetadataTag *t = av_metadata_get(s->metadata, "track", NULL, 0);
+    AVDictionaryEntry *t = av_dict_get(s->metadata, "track", NULL, 0);
     int size = 0, track = t ? atoi(t->value) : 0;
     if (track) {
         avio_wb32(pb, 32); /* size */
                                   const char *tag, const char *str)
 {
     int64_t pos = avio_tell(pb);
-    AVMetadataTag *t = av_metadata_get(s->metadata, str, NULL, 0);
+    AVDictionaryEntry *t = av_dict_get(s->metadata, str, NULL, 0);
     if (!t || !utf8len(t->value))
         return 0;
     avio_wb32(pb, 0);   /* size */
         avio_wb16(pb, language_code("eng")); /* language */
         avio_write(pb, t->value, strlen(t->value)+1); /* UTF8 string value */
         if (!strcmp(tag, "albm") &&
-            (t = av_metadata_get(s->metadata, "track", NULL, 0)))
+            (t = av_dict_get(s->metadata, "track", NULL, 0)))
             avio_w8(pb, atoi(t->value));
     }
     return updateSize(pb, pos);
     for (i = 0; i < nb_chapters; i++) {
         AVChapter *c = s->chapters[i];
-        AVMetadataTag *t;
+        AVDictionaryEntry *t;
         avio_wb64(pb, av_rescale_q(c->start, c->time_base, (AVRational){1,10000000}));
-        if ((t = av_metadata_get(c->metadata, "title", NULL, 0))) {
+        if ((t = av_dict_get(c->metadata, "title", NULL, 0))) {
             int len = FFMIN(strlen(t->value), 255);
             avio_w8(pb, len);
             avio_write(pb, t->value, len);
 static int mov_write_uuidusmt_tag(AVIOContext *pb, AVFormatContext *s)
 {
-    AVMetadataTag *title = av_metadata_get(s->metadata, "title", NULL, 0);
+    AVDictionaryEntry *title = av_dict_get(s->metadata, "title", NULL, 0);
     int64_t pos, pos2;
     if (title) {
     for (i = 0; i < s->nb_chapters; i++) {
         AVChapter *c = s->chapters[i];
-        AVMetadataTag *t;
+        AVDictionaryEntry *t;
         int64_t end = av_rescale_q(c->end, c->time_base, (AVRational){1,MOV_TIMESCALE});
         pkt.pts = pkt.dts = av_rescale_q(c->start, c->time_base, (AVRational){1,MOV_TIMESCALE});
         pkt.duration = end - pkt.dts;
-        if ((t = av_metadata_get(c->metadata, "title", NULL, 0))) {
+        if ((t = av_dict_get(c->metadata, "title", NULL, 0))) {
             len = strlen(t->value);
             pkt.size = len+2;
             pkt.data = av_malloc(pkt.size);
     for(i=0; i<s->nb_streams; i++){
         AVStream *st= s->streams[i];
         MOVTrack *track= &mov->tracks[i];
-        AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL,0);
+        AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL,0);
         track->enc = st->codec;
         track->language = ff_mov_iso639_to_lang(lang?lang->value:"und", mov->mode!=MODE_MOV);

libavformat/mp3dec.c+2−1

 #include "libavutil/avstring.h"
 #include "libavutil/intreadwrite.h"
+#include "libavutil/dict.h"
 #include "avformat.h"
 #include "id3v2.h"
 #include "id3v1.h"
     off = avio_tell(s->pb);
-    if (!av_metadata_get(s->metadata, "", NULL, AV_METADATA_IGNORE_SUFFIX))
+    if (!av_dict_get(s->metadata, "", NULL, AV_DICT_IGNORE_SUFFIX))
         ff_id3v1_read(s);
     if (mp3_parse_vbr_tags(s, st, off) < 0)

libavformat/mp3enc.c+9−8

 #include "libavcodec/mpegaudiodata.h"
 #include "libavcodec/mpegaudiodecheader.h"
 #include "libavformat/avio_internal.h"
+#include "libavutil/dict.h"
 static int id3v1_set_string(AVFormatContext *s, const char *key,
                             uint8_t *buf, int buf_size)
 {
-    AVMetadataTag *tag;
+    AVDictionaryEntry *tag;
-    if ((tag = av_metadata_get(s->metadata, key, NULL, 0)))
+    if ((tag = av_dict_get(s->metadata, key, NULL, 0)))
         av_strlcpy(buf, tag->value, buf_size);
     return !!tag;
 }
 static int id3v1_create_tag(AVFormatContext *s, uint8_t *buf)
 {
-    AVMetadataTag *tag;
+    AVDictionaryEntry *tag;
     int i, count = 0;
     memset(buf, 0, ID3v1_TAG_SIZE); /* fail safe */
     count += id3v1_set_string(s, "TALB",    buf + 63, 30);       //album
     count += id3v1_set_string(s, "TDRL",    buf + 93,  4);       //date
     count += id3v1_set_string(s, "comment", buf + 97, 30);
-    if ((tag = av_metadata_get(s->metadata, "TRCK", NULL, 0))) { //track
+    if ((tag = av_dict_get(s->metadata, "TRCK", NULL, 0))) { //track
         buf[125] = 0;
         buf[126] = atoi(tag->value);
         count++;
     }
     buf[127] = 0xFF; /* default to unknown genre */
-    if ((tag = av_metadata_get(s->metadata, "TCON", NULL, 0))) { //genre
+    if ((tag = av_dict_get(s->metadata, "TCON", NULL, 0))) { //genre
         for(i = 0; i <= ID3v1_GENRE_MAX; i++) {
             if (!strcasecmp(tag->value, ff_id3v1_genre_str[i])) {
                 buf[127] = i;
     .version        = LIBAVUTIL_VERSION_INT,
 };
-static int id3v2_check_write_tag(AVFormatContext *s, AVMetadataTag *t, const char table[][4],
+static int id3v2_check_write_tag(AVFormatContext *s, AVDictionaryEntry *t, const char table[][4],
                                  enum ID3v2Encoding enc)
 {
     uint32_t tag;
 static int mp3_write_header(struct AVFormatContext *s)
 {
     MP3Context  *mp3 = s->priv_data;
-    AVMetadataTag *t = NULL;
+    AVDictionaryEntry *t = NULL;
     int totlen = 0, enc = mp3->id3v2_version == 3 ? ID3v2_ENCODING_UTF16BOM :
                                                     ID3v2_ENCODING_UTF8;
     int64_t size_pos, cur_pos;
     if (mp3->id3v2_version == 4)
         ff_metadata_conv(&s->metadata, ff_id3v2_4_metadata_conv, NULL);
-    while ((t = av_metadata_get(s->metadata, "", t, AV_METADATA_IGNORE_SUFFIX))) {
+    while ((t = av_dict_get(s->metadata, "", t, AV_DICT_IGNORE_SUFFIX))) {
         int ret;
         if ((ret = id3v2_check_write_tag(s, t, ff_id3v2_tags, enc)) > 0) {

libavformat/mpc.c+2−1

 #include "avformat.h"
 #include "apetag.h"
 #include "id3v1.h"
+#include "libavutil/dict.h"
 #define MPC_FRAMESIZE  1152
 #define DELAY_FRAMES   32
     if (s->pb->seekable) {
         int64_t pos = avio_tell(s->pb);
         ff_ape_parse_tag(s);
-        if (!av_metadata_get(s->metadata, "", NULL, AV_METADATA_IGNORE_SUFFIX))
+        if (!av_dict_get(s->metadata, "", NULL, AV_DICT_IGNORE_SUFFIX))
             ff_id3v1_read(s);
         avio_seek(s->pb, pos, SEEK_SET);
     }

libavformat/mpegts.c+6−5

 #include "libavutil/crc.h"
 #include "libavutil/intreadwrite.h"
 #include "libavutil/log.h"
+#include "libavutil/dict.h"
 #include "libavutil/opt.h"
 #include "libavcodec/bytestream.h"
 #include "avformat.h"
         language[1] = get8(pp, desc_end);
         language[2] = get8(pp, desc_end);
         language[3] = 0;
-        av_metadata_set2(&st->metadata, "language", language, 0);
+        av_dict_set(&st->metadata, "language", language, 0);
         break;
     case 0x59: /* subtitling descriptor */
         language[0] = get8(pp, desc_end);
             }
         }
         *pp += 4;
-        av_metadata_set2(&st->metadata, "language", language, 0);
+        av_dict_set(&st->metadata, "language", language, 0);
         break;
     case 0x0a: /* ISO 639 language descriptor */
         for (i = 0; i + 4 <= desc_len; i += 4) {
         }
         if (i) {
             language[i - 1] = 0;
-            av_metadata_set2(&st->metadata, "language", language, 0);
+            av_dict_set(&st->metadata, "language", language, 0);
         }
         break;
     case 0x05: /* registration descriptor */
                 if (name) {
                     AVProgram *program = av_new_program(ts->stream, sid);
                     if(program) {
-                        av_metadata_set2(&program->metadata, "service_name", name, 0);
+                        av_dict_set(&program->metadata, "service_name", name, 0);
-                        av_metadata_set2(&program->metadata, "service_provider", provider_name, 0);
+                        av_dict_set(&program->metadata, "service_provider", provider_name, 0);
                     }
                 }
                 av_free(name);

libavformat/mpegtsenc.c+6−5

 #include "libavutil/bswap.h"
 #include "libavutil/crc.h"
+#include "libavutil/dict.h"
 #include "libavutil/opt.h"
 #include "libavcodec/mpegvideo.h"
 #include "avformat.h"
     for(i = 0; i < s->nb_streams; i++) {
         AVStream *st = s->streams[i];
         MpegTSWriteStream *ts_st = st->priv_data;
-        AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL,0);
+        AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL,0);
         switch(st->codec->codec_id) {
         case CODEC_ID_MPEG1VIDEO:
         case CODEC_ID_MPEG2VIDEO:
     MpegTSWriteStream *ts_st;
     MpegTSService *service;
     AVStream *st, *pcr_st = NULL;
-    AVMetadataTag *title, *provider;
+    AVDictionaryEntry *title, *provider;
     int i, j;
     const char *service_name;
     const char *provider_name;
     ts->tsid = ts->transport_stream_id;
     ts->onid = ts->original_network_id;
     /* allocate a single DVB service */
-    title = av_metadata_get(s->metadata, "service_name", NULL, 0);
+    title = av_dict_get(s->metadata, "service_name", NULL, 0);
     if (!title)
-        title = av_metadata_get(s->metadata, "title", NULL, 0);
+        title = av_dict_get(s->metadata, "title", NULL, 0);
     service_name = title ? title->value : DEFAULT_SERVICE_NAME;
-    provider = av_metadata_get(s->metadata, "service_provider", NULL, 0);
+    provider = av_dict_get(s->metadata, "service_provider", NULL, 0);
     provider_name = provider ? provider->value : DEFAULT_PROVIDER_NAME;
     service = mpegts_add_service(ts, ts->service_id, provider_name, service_name);
     service->pmt.write_packet = section_write_packet;

libavformat/nsvdec.c+2−1

  */
 #include "avformat.h"
 #include "riff.h"
+#include "libavutil/dict.h"
 //#define DEBUG
 //#define DEBUG_DUMP_INDEX // XXX dumbdriving-271.nsv breaks with it commented!!
                 break;
             *p++ = '\0';
             av_dlog(s, "NSV NSVf INFO: %s='%s'\n", token, value);
-            av_metadata_set2(&s->metadata, token, value, 0);
+            av_dict_set(&s->metadata, token, value, 0);
         }
         av_free(strings);
     }

libavformat/nutdec.c+3−2

 #include <strings.h>
 #include "libavutil/avstring.h"
 #include "libavutil/bswap.h"
+#include "libavutil/dict.h"
 #include "libavutil/tree.h"
 #include "avio_internal.h"
 #include "nut.h"
     const char *type;
     AVChapter *chapter= NULL;
     AVStream *st= NULL;
-    AVMetadata **metadata = NULL;
+    AVDictionary **metadata = NULL;
     end= get_packetheader(nut, bc, 1, INFO_STARTCODE);
     end += avio_tell(bc);
             }
             if(metadata && strcasecmp(name,"Uses")
                && strcasecmp(name,"Depends") && strcasecmp(name,"Replaces"))
-                av_metadata_set2(metadata, name, str_value, 0);
+                av_dict_set(metadata, name, str_value, 0);
         }
     }

libavformat/nutenc.c+5−4

 #include "libavutil/intreadwrite.h"
 #include "libavutil/tree.h"
+#include "libavutil/dict.h"
 #include "libavcodec/mpegaudiodata.h"
 #include "nut.h"
 #include "internal.h"
 static int write_globalinfo(NUTContext *nut, AVIOContext *bc){
     AVFormatContext *s= nut->avf;
-    AVMetadataTag *t = NULL;
+    AVDictionaryEntry *t = NULL;
     AVIOContext *dyn_bc;
     uint8_t *dyn_buf=NULL;
     int count=0, dyn_size;
     if(ret < 0)
         return ret;
-    while ((t = av_metadata_get(s->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
+    while ((t = av_dict_get(s->metadata, "", t, AV_DICT_IGNORE_SUFFIX)))
         count += add_info(dyn_bc, t->key, t->value);
     ff_put_v(bc, 0); //stream_if_plus1
 {
     AVIOContext *dyn_bc;
     uint8_t *dyn_buf = NULL;
-    AVMetadataTag *t = NULL;
+    AVDictionaryEntry *t = NULL;
     AVChapter *ch    = nut->avf->chapters[id];
     int ret, dyn_size, count = 0;
     put_tt(nut, nut->chapter[id].time_base, bc, ch->start); // chapter_start
     ff_put_v(bc, ch->end - ch->start);                      // chapter_len
-    while ((t = av_metadata_get(ch->metadata, "", t, AV_METADATA_IGNORE_SUFFIX)))
+    while ((t = av_dict_get(ch->metadata, "", t, AV_DICT_IGNORE_SUFFIX)))
         count += add_info(dyn_bc, t->key, t->value);
     ff_put_v(bc, count);

libavformat/oggdec.h+1−1

@@ -112,7 +112,7 @@ extern const struct ogg_codec ff_speex_codec; · 111 unmodified lines
112	extern const struct ogg_codec ff_theora_codec;	112	extern const struct ogg_codec ff_theora_codec;
113	extern const struct ogg_codec ff_vorbis_codec;	113	extern const struct ogg_codec ff_vorbis_codec;
114		114
115	int ff_vorbis_comment(AVFormatContext ms, AVMetadata m, const uint8_t buf, int size);	115	int ff_vorbis_comment(AVFormatContext ms, AVDictionary m, const uint8_t buf, int size);
116		116
117	static inline int	117	static inline int
118	ogg_find_stream (struct ogg * ogg, int serial)	118	ogg_find_stream (struct ogg * ogg, int serial)

libavformat/oggenc.c+3−3

@@ -241,7 +241,7 @@ static int ogg_buffer_data(AVFormatContext s, AVStream st, · 240 unmodified lines
241	}	241	}
242		242
243	static uint8_t *ogg_write_vorbiscomment(int offset, int bitexact,	243	static uint8_t *ogg_write_vorbiscomment(int offset, int bitexact,
244	int header_len, AVMetadata *m, int framing_bit)	244	int header_len, AVDictionary *m, int framing_bit)
245	{	245	{
246	const char *vendor = bitexact ? "ffmpeg" : LIBAVFORMAT_IDENT;	246	const char *vendor = bitexact ? "ffmpeg" : LIBAVFORMAT_IDENT;
247	int size;	247	int size;
@@ -267,7 +267,7 @@ static uint8_t *ogg_write_vorbiscomment(int offset, int bitexact, · 19 unmodified lines
267		267
268	static int ogg_build_flac_headers(AVCodecContext *avctx,	268	static int ogg_build_flac_headers(AVCodecContext *avctx,
269	OGGStreamContext *oggstream, int bitexact,	269	OGGStreamContext *oggstream, int bitexact,
270	AVMetadata **m)	270	AVDictionary **m)
271	{	271	{
272	enum FLACExtradataFormat format;	272	enum FLACExtradataFormat format;
273	uint8_t *streaminfo;	273	uint8_t *streaminfo;
@@ -307,7 +307,7 @@ static int ogg_build_flac_headers(AVCodecContext *avctx, · 33 unmodified lines
307		307
308	static int ogg_build_speex_headers(AVCodecContext *avctx,	308	static int ogg_build_speex_headers(AVCodecContext *avctx,
309	OGGStreamContext *oggstream, int bitexact,	309	OGGStreamContext *oggstream, int bitexact,
310	AVMetadata **m)	310	AVDictionary **m)
311	{	311	{
312	uint8_t *p;	312	uint8_t *p;
313		313

libavformat/oggparsevorbis.c+7−6

 #include <stdlib.h>
 #include "libavutil/avstring.h"
 #include "libavutil/bswap.h"
+#include "libavutil/dict.h"
 #include "libavcodec/get_bits.h"
 #include "libavcodec/bytestream.h"
 #include "avformat.h"
         if (!chapter)
             return 0;
-        av_metadata_set2(&chapter->metadata, "title", val,
+        av_dict_set(&chapter->metadata, "title", val,
-                         AV_METADATA_DONT_STRDUP_VAL);
+                         AV_DICT_DONT_STRDUP_VAL);
     } else
         return 0;
 }
 int
-ff_vorbis_comment(AVFormatContext * as, AVMetadata **m, const uint8_t *buf, int size)
+ff_vorbis_comment(AVFormatContext * as, AVDictionary **m, const uint8_t *buf, int size)
 {
     const uint8_t *p = buf;
     const uint8_t *end = buf + size;
             ct[vl] = 0;
             if (!ogm_chapter(as, tt, ct))
-                av_metadata_set2(m, tt, ct,
+                av_dict_set(m, tt, ct,
-                                   AV_METADATA_DONT_STRDUP_KEY |
+                                   AV_DICT_DONT_STRDUP_KEY |
-                                   AV_METADATA_DONT_STRDUP_VAL);
+                                   AV_DICT_DONT_STRDUP_VAL);
         }
     }

libavformat/options.c+1−1

@@ -62,7 +62,7 @@ static const AVOption options[]={ · 61 unmodified lines
62	{"fdebug", "print specific debug info", OFFSET(debug), FF_OPT_TYPE_FLAGS, {.dbl = DEFAULT }, 0, INT_MAX, E\|D, "fdebug"},	62	{"fdebug", "print specific debug info", OFFSET(debug), FF_OPT_TYPE_FLAGS, {.dbl = DEFAULT }, 0, INT_MAX, E\|D, "fdebug"},
63	{"ts", NULL, 0, FF_OPT_TYPE_CONST, {.dbl = FF_FDEBUG_TS }, INT_MIN, INT_MAX, E\|D, "fdebug"},	63	{"ts", NULL, 0, FF_OPT_TYPE_CONST, {.dbl = FF_FDEBUG_TS }, INT_MIN, INT_MAX, E\|D, "fdebug"},
64	{"max_delay", "maximum muxing or demuxing delay in microseconds", OFFSET(max_delay), FF_OPT_TYPE_INT, {.dbl = DEFAULT }, 0, INT_MAX, E\|D},	64	{"max_delay", "maximum muxing or demuxing delay in microseconds", OFFSET(max_delay), FF_OPT_TYPE_INT, {.dbl = DEFAULT }, 0, INT_MAX, E\|D},
65	{"fpsprobesize", "number of frames used to probe fps", OFFSET(fps_probe_size), FF_OPT_TYPE_INT, -1, -1, INT_MAX-1, D},	65	{"fpsprobesize", "number of frames used to probe fps", OFFSET(fps_probe_size), FF_OPT_TYPE_INT, {.dbl = -1}, -1, INT_MAX-1, D},
66	{NULL},	66	{NULL},
67	};	67	};
68		68

libavformat/r3d.c+2−1

 //#define DEBUG
 #include "libavutil/intreadwrite.h"
+#include "libavutil/dict.h"
 #include "avformat.h"
 typedef struct {
     avio_read(s->pb, filename, 257);
     filename[sizeof(filename)-1] = 0;
-    av_metadata_set2(&st->metadata, "filename", filename, 0);
+    av_dict_set(&st->metadata, "filename", filename, 0);
     av_dlog(s, "filename %s\n", filename);
     av_dlog(s, "resolution %dx%d\n", st->codec->width, st->codec->height);

libavformat/rmdec.c+2−1

 #include "libavutil/avstring.h"
 #include "libavutil/intreadwrite.h"
+#include "libavutil/dict.h"
 #include "avformat.h"
 #include "riff.h"
 #include "rm.h"
     for (i=0; i<FF_ARRAY_ELEMS(ff_rm_metadata); i++) {
         int len = wide ? avio_rb16(s->pb) : avio_r8(s->pb);
         get_strl(s->pb, buf, sizeof(buf), len);
-        av_metadata_set2(&s->metadata, ff_rm_metadata[i], buf, 0);
+        av_dict_set(&s->metadata, ff_rm_metadata[i], buf, 0);
     }
 }

libavformat/rmenc.c+4−3

 #include "avformat.h"
 #include "avio_internal.h"
 #include "rm.h"
+#include "libavutil/dict.h"
 typedef struct {
     int nb_packets;
     const char *desc, *mimetype;
     int nb_packets, packet_total_size, packet_max_size, size, packet_avg_size, i;
     int bit_rate, v, duration, flags, data_pos;
-    AVMetadataTag *tag;
+    AVDictionaryEntry *tag;
     start_ptr = s->buf_ptr;
     ffio_wfourcc(s,"CONT");
     size =  4 * 2 + 10;
     for(i=0; i<FF_ARRAY_ELEMS(ff_rm_metadata); i++) {
-        tag = av_metadata_get(ctx->metadata, ff_rm_metadata[i], NULL, 0);
+        tag = av_dict_get(ctx->metadata, ff_rm_metadata[i], NULL, 0);
         if(tag) size += strlen(tag->value);
     }
     avio_wb32(s,size);
     avio_wb16(s,0);
     for(i=0; i<FF_ARRAY_ELEMS(ff_rm_metadata); i++) {
-        tag = av_metadata_get(ctx->metadata, ff_rm_metadata[i], NULL, 0);
+        tag = av_dict_get(ctx->metadata, ff_rm_metadata[i], NULL, 0);
         put_str(s, tag ? tag->value : "");
     }

libavformat/rpl.c+4−3

  */
 #include "libavutil/avstring.h"
+#include "libavutil/dict.h"
 #include "avformat.h"
 #include <stdlib.h>
     // for the text in a few cases; samples needed.)
     error |= read_line(pb, line, sizeof(line));      // ARMovie
     error |= read_line(pb, line, sizeof(line));      // movie name
-    av_metadata_set2(&s->metadata, "title"    , line, 0);
+    av_dict_set(&s->metadata, "title"    , line, 0);
     error |= read_line(pb, line, sizeof(line));      // date/copyright
-    av_metadata_set2(&s->metadata, "copyright", line, 0);
+    av_dict_set(&s->metadata, "copyright", line, 0);
     error |= read_line(pb, line, sizeof(line));      // author and other
-    av_metadata_set2(&s->metadata, "author"   , line, 0);
+    av_dict_set(&s->metadata, "author"   , line, 0);
     // video headers
     vst = av_new_stream(s, 0);

libavformat/rtpdec_asf.c+1−1

@@ -113,7 +113,7 @@ int ff_wms_parse_sdp_a_line(AVFormatContext s, const char p) · 112 unmodified lines
113	ret = av_open_input_stream(&rt->asf_ctx, &pb, "", &ff_asf_demuxer, NULL);	113	ret = av_open_input_stream(&rt->asf_ctx, &pb, "", &ff_asf_demuxer, NULL);
114	if (ret < 0)	114	if (ret < 0)
115	return ret;	115	return ret;
116	av_metadata_copy(&s->metadata, rt->asf_ctx->metadata, 0);	116	av_dict_copy(&s->metadata, rt->asf_ctx->metadata, 0);
117	rt->asf_pb_pos = avio_tell(&pb);	117	rt->asf_pb_pos = avio_tell(&pb);
118	av_free(buf);	118	av_free(buf);
119	rt->asf_ctx->pb = NULL;	119	rt->asf_ctx->pb = NULL;

libavformat/rtsp.c+3−2

 #include "libavutil/intreadwrite.h"
 #include "libavutil/parseutils.h"
 #include "libavutil/random_seed.h"
+#include "libavutil/dict.h"
 #include "avformat.h"
 #include "avio_internal.h"
         }
         break;
     case 's':
-        av_metadata_set2(&s->metadata, "title", p, 0);
+        av_dict_set(&s->metadata, "title", p, 0);
         break;
     case 'i':
         if (s->nb_streams == 0) {
-            av_metadata_set2(&s->metadata, "comment", p, 0);
+            av_dict_set(&s->metadata, "comment", p, 0);
             break;
         }
         break;

libavformat/sauce.c+3−2

  */
 #include "libavutil/intreadwrite.h"
+#include "libavutil/dict.h"
 #include "avformat.h"
 #include "sauce.h"
 #define GET_SAUCE_META(name,size) \
     if (avio_read(pb, buf, size) == size && buf[0]) { \
         buf[size] = 0; \
-        av_metadata_set2(&avctx->metadata, name, buf, 0); \
+        av_dict_set(&avctx->metadata, name, buf, 0); \
     }
     GET_SAUCE_META("title",     35)
                 str[65*i + 64] = '\n';
             }
             str[65*i] = 0;
-            av_metadata_set2(&avctx->metadata, "comment", str, AV_METADATA_DONT_STRDUP_VAL);
+            av_dict_set(&avctx->metadata, "comment", str, AV_DICT_DONT_STRDUP_VAL);
         }
     }

libavformat/sdp.c+2−1

 #include <string.h>
 #include "libavutil/avstring.h"
 #include "libavutil/base64.h"
+#include "libavutil/dict.h"
 #include "libavutil/parseutils.h"
 #include "libavcodec/xiph.h"
 #include "libavcodec/mpeg4audio.h"
 int av_sdp_create(AVFormatContext *ac[], int n_files, char *buf, int size)
 {
-    AVMetadataTag *title = av_metadata_get(ac[0]->metadata, "title", NULL, 0);
+    AVDictionaryEntry *title = av_dict_get(ac[0]->metadata, "title", NULL, 0);
     struct sdp_session_level s;
     int i, j, port, ttl, is_multicast;
     char dst[32], dst_type[5];

libavformat/soxdec.c+3−2

  */
 #include "libavutil/intreadwrite.h"
+#include "libavutil/dict.h"
 #include "avformat.h"
 #include "pcm.h"
 #include "sox.h"
         }
         comment[comment_size] = 0;
-        av_metadata_set2(&s->metadata, "comment", comment,
+        av_dict_set(&s->metadata, "comment", comment,
-                               AV_METADATA_DONT_STRDUP_VAL);
+                               AV_DICT_DONT_STRDUP_VAL);
     }
     avio_skip(pb, header_size - SOX_FIXED_HDR - comment_size);

libavformat/soxenc.c+3−2

  */
 #include "libavutil/intreadwrite.h"
+#include "libavutil/dict.h"
 #include "avformat.h"
 #include "avio_internal.h"
 #include "sox.h"
     SoXContext *sox = s->priv_data;
     AVIOContext *pb = s->pb;
     AVCodecContext *enc = s->streams[0]->codec;
-    AVMetadataTag *comment;
+    AVDictionaryEntry *comment;
     size_t comment_len = 0, comment_size;
-    comment = av_metadata_get(s->metadata, "comment", NULL, 0);
+    comment = av_dict_get(s->metadata, "comment", NULL, 0);
     if (comment)
         comment_len = strlen(comment->value);
     comment_size = (comment_len + 7) & ~7;

libavformat/tta.c+2−1

 #include "libavcodec/get_bits.h"
 #include "avformat.h"
 #include "id3v1.h"
+#include "libavutil/dict.h"
 typedef struct {
     int totalframes, currentframe;
     int i, channels, bps, samplerate, datalen, framelen;
     uint64_t framepos, start_offset;
-    if (!av_metadata_get(s->metadata, "", NULL, AV_METADATA_IGNORE_SUFFIX))
+    if (!av_dict_get(s->metadata, "", NULL, AV_DICT_IGNORE_SUFFIX))
         ff_id3v1_read(s);
     start_offset = avio_tell(s->pb);

libavformat/tty.c+2−1

 #include "libavutil/intreadwrite.h"
 #include "libavutil/avstring.h"
 #include "libavutil/log.h"
+#include "libavutil/dict.h"
 #include "libavutil/opt.h"
 #include "libavutil/parseutils.h"
 #include "avformat.h"
         return -1; \
     if (avio_read(pb, buf, size) == size) { \
         buf[len] = 0; \
-        av_metadata_set2(&avctx->metadata, name, buf, 0); \
+        av_dict_set(&avctx->metadata, name, buf, 0); \
     }
     GET_EFI_META("filename", 12)

libavformat/utils.c+14−13

 #include "libavcodec/internal.h"
 #include "libavcodec/raw.h"
 #include "libavutil/opt.h"
+#include "libavutil/dict.h"
 #include "metadata.h"
 #include "id3v2.h"
 #include "libavutil/avstring.h"
     AVStream *st;
     av_opt_free(s);
-    if (s->iformat && s->iformat->priv_class)
+    if (s->iformat && s->iformat->priv_class && s->priv_data)
         av_opt_free(s->priv_data);
     for(i=0;i<s->nb_streams;i++) {
             av_parser_close(st->parser);
             av_free_packet(&st->cur_pkt);
         }
-        av_metadata_free(&st->metadata);
+        av_dict_free(&st->metadata);
         av_free(st->index_entries);
         av_free(st->codec->extradata);
         av_free(st->codec->subtitle_header);
         av_free(st);
     }
     for(i=s->nb_programs-1; i>=0; i--) {
-        av_metadata_free(&s->programs[i]->metadata);
+        av_dict_free(&s->programs[i]->metadata);
         av_freep(&s->programs[i]->stream_index);
         av_freep(&s->programs[i]);
     }
     av_freep(&s->programs);
     av_freep(&s->priv_data);
     while(s->nb_chapters--) {
-        av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
+        av_dict_free(&s->chapters[s->nb_chapters]->metadata);
         av_free(s->chapters[s->nb_chapters]);
     }
     av_freep(&s->chapters);
-    av_metadata_free(&s->metadata);
+    av_dict_free(&s->metadata);
     av_freep(&s->streams);
     av_free(s);
 }
             return NULL;
         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
     }
-    av_metadata_set2(&chapter->metadata, "title", title, 0);
+    av_dict_set(&chapter->metadata, "title", title, 0);
     chapter->id    = id;
     chapter->time_base= time_base;
     chapter->start = start;
     /* set muxer identification string */
     if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
-        av_metadata_set2(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
+        av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
     }
     if(s->oformat->write_header){
     else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
 }
-static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
+static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
 {
-    if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
+    if(m && !(m->count == 1 && av_dict_get(m, "language", NULL, 0))){
-        AVMetadataTag *tag=NULL;
+        AVDictionaryEntry *tag=NULL;
         av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
-        while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
+        while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
             if(strcmp("language", tag->key))
                 av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
         }
     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
     AVStream *st = ic->streams[i];
     int g = av_gcd(st->time_base.num, st->time_base.den);
-    AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
+    AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
     avcodec_string(buf, sizeof(buf), st->codec, is_output);
     av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
     /* the pid is an important information, so we display it */
     if(ic->nb_programs) {
         int j, k, total = 0;
         for(j=0; j<ic->nb_programs; j++) {
-            AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
+            AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
                                                   "name", NULL, 0);
             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
                    name ? name->value : "");

libavformat/vorbiscomment.c+7−6

 #include "metadata.h"
 #include "vorbiscomment.h"
 #include "libavcodec/bytestream.h"
+#include "libavutil/dict.h"
 /**
  * VorbisComment metadata conversion mapping.
     { 0 }
 };
-int ff_vorbiscomment_length(AVMetadata *m, const char *vendor_string,
+int ff_vorbiscomment_length(AVDictionary *m, const char *vendor_string,
                             unsigned *count)
 {
     int len = 8;
     len += strlen(vendor_string);
     *count = 0;
     if (m) {
-        AVMetadataTag *tag = NULL;
+        AVDictionaryEntry *tag = NULL;
-        while ((tag = av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
+        while ((tag = av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
             len += 4 +strlen(tag->key) + 1 + strlen(tag->value);
             (*count)++;
         }
     return len;
 }
-int ff_vorbiscomment_write(uint8_t **p, AVMetadata **m,
+int ff_vorbiscomment_write(uint8_t **p, AVDictionary **m,
                            const char *vendor_string, const unsigned count)
 {
     bytestream_put_le32(p, strlen(vendor_string));
     bytestream_put_buffer(p, vendor_string, strlen(vendor_string));
     if (*m) {
-        AVMetadataTag *tag = NULL;
+        AVDictionaryEntry *tag = NULL;
         bytestream_put_le32(p, count);
-        while ((tag = av_metadata_get(*m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
+        while ((tag = av_dict_get(*m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
             unsigned int len1 = strlen(tag->key);
             unsigned int len2 = strlen(tag->value);
             bytestream_put_le32(p, len1+1+len2);

libavformat/vorbiscomment.h+3−3

@@ -35,13 +35,13 @@ · 34 unmodified lines
35	* @param count Pointer to store the number of tags in m because m->count is "not allowed"	35	* @param count Pointer to store the number of tags in m because m->count is "not allowed"
36	* @return The length in bytes.	36	* @return The length in bytes.
37	*/	37	*/
38	int ff_vorbiscomment_length(AVMetadata m, const char vendor_string,	38	int ff_vorbiscomment_length(AVDictionary m, const char vendor_string,
39	unsigned *count);	39	unsigned *count);
40		40
41	/**	41	/**
42	* Writes a VorbisComment into a buffer. The buffer, p, must have enough	42	* Writes a VorbisComment into a buffer. The buffer, p, must have enough
43	* data to hold the whole VorbisComment. The minimum size required can be	43	* data to hold the whole VorbisComment. The minimum size required can be
44	* obtained by passing the same AVMetadata and vendor_string to	44	* obtained by passing the same AVDictionary and vendor_string to
45	* ff_vorbiscomment_length()	45	* ff_vorbiscomment_length()
46	*	46	*
47	* @param p The buffer in which to write.	47	* @param p The buffer in which to write.
@@ -49,7 +49,7 @@ int ff_vorbiscomment_length(AVMetadata m, const char vendor_string, · 1 unmodified line
49	* @param vendor_string The vendor string to write.	49	* @param vendor_string The vendor string to write.
50	* @param count The number of tags in m because m->count is "not allowed"	50	* @param count The number of tags in m because m->count is "not allowed"
51	*/	51	*/
52	int ff_vorbiscomment_write(uint8_t p, AVMetadata m,	52	int ff_vorbiscomment_write(uint8_t p, AVDictionary m,
53	const char *vendor_string, const unsigned count);	53	const char *vendor_string, const unsigned count);
54		54
55	extern const AVMetadataConv ff_vorbiscomment_metadata_conv[];	55	extern const AVMetadataConv ff_vorbiscomment_metadata_conv[];

libavformat/vqf.c+2−1

 #include "avformat.h"
 #include "libavutil/intreadwrite.h"
+#include "libavutil/dict.h"
 typedef struct VqfContext {
     int frame_bit_len;
         return;
     avio_read(s->pb, buf, len);
     buf[len] = 0;
-    av_metadata_set2(&s->metadata, tag, buf, AV_METADATA_DONT_STRDUP_VAL);
+    av_dict_set(&s->metadata, tag, buf, AV_DICT_DONT_STRDUP_VAL);
 }
 static int vqf_read_header(AVFormatContext *s, AVFormatParameters *ap)

libavformat/wc3movie.c+3−2

  */
 #include "libavutil/intreadwrite.h"
+#include "libavutil/dict.h"
 #include "avformat.h"
 #define FORM_TAG MKTAG('F', 'O', 'R', 'M')
             if ((ret = avio_read(pb, buffer, size)) != size)
                 return AVERROR(EIO);
             buffer[size] = 0;
-            av_metadata_set2(&s->metadata, "title", buffer,
+            av_dict_set(&s->metadata, "title", buffer,
-                                   AV_METADATA_DONT_STRDUP_VAL);
+                                   AV_DICT_DONT_STRDUP_VAL);
             break;
         case SIZE_TAG:

libavformat/wv.c+2−1

 #include "libavutil/audioconvert.h"
 #include "libavutil/intreadwrite.h"
+#include "libavutil/dict.h"
 #include "avformat.h"
 #include "apetag.h"
 #include "id3v1.h"
     if(s->pb->seekable) {
         int64_t cur = avio_tell(s->pb);
         ff_ape_parse_tag(s);
-        if(!av_metadata_get(s->metadata, "", NULL, AV_METADATA_IGNORE_SUFFIX))
+        if(!av_dict_get(s->metadata, "", NULL, AV_DICT_IGNORE_SUFFIX))
             ff_id3v1_read(s);
         avio_seek(s->pb, cur, SEEK_SET);
     }

libavutil/Makefile+2−0

           mathematics.h                                                 \
           md5.h                                                         \
           mem.h                                                         \
+          dict.h                                                        \
           opt.h                                                         \
           parseutils.h                                                  \
           pixdesc.h                                                     \
        mathematics.o                                                    \
        md5.o                                                            \
        mem.o                                                            \
+       dict.o                                                           \
        opt.o                                                            \
        parseutils.o                                                     \
        pixdesc.o                                                        \

libavutil/avutil.h+1−1

@@ -40,7 +40,7 @@ · 39 unmodified lines
40	#define AV_VERSION(a, b, c) AV_VERSION_DOT(a, b, c)	40	#define AV_VERSION(a, b, c) AV_VERSION_DOT(a, b, c)
41		41
42	#define LIBAVUTIL_VERSION_MAJOR 51	42	#define LIBAVUTIL_VERSION_MAJOR 51
43	#define LIBAVUTIL_VERSION_MINOR 7	43	#define LIBAVUTIL_VERSION_MINOR 8
44	#define LIBAVUTIL_VERSION_MICRO 0	44	#define LIBAVUTIL_VERSION_MICRO 0
45		45
46	#define LIBAVUTIL_VERSION_INT AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \	46	#define LIBAVUTIL_VERSION_INT AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \

libavutil/dict.c+110−0

@@ -0,0 +1,110 @@
	1	/*
	2	* copyright (c) 2009 Michael Niedermayer
	3	*
	4	* This file is part of Libav.
	5	*
	6	* Libav is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU Lesser General Public
	8	* License as published by the Free Software Foundation; either
	9	* version 2.1 of the License, or (at your option) any later version.
	10	*
	11	* Libav is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	* Lesser General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU Lesser General Public
	17	* License along with Libav; if not, write to the Free Software
	18	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	19	*/
	20
	21	#include <strings.h>
	22	#include "dict.h"
	23	#include "internal.h"
	24	#include "mem.h"
	25
	26	AVDictionaryEntry *
	27	av_dict_get(AVDictionary m, const char key, const AVDictionaryEntry *prev, int flags)
	28	{
	29	unsigned int i, j;
	30
	31	if(!m)
	32	return NULL;
	33
	34	if(prev) i= prev - m->elems + 1;
	35	else i= 0;
	36
	37	for(; i<m->count; i++){
	38	const char *s= m->elems[i].key;
	39	if(flags & AV_DICT_MATCH_CASE) for(j=0; s[j] == key[j] && key[j]; j++);
	40	else for(j=0; toupper(s[j]) == toupper(key[j]) && key[j]; j++);
	41	if(key[j])
	42	continue;
	43	if(s[j] && !(flags & AV_DICT_IGNORE_SUFFIX))
	44	continue;
	45	return &m->elems[i];
	46	}
	47	return NULL;
	48	}
	49
	50	int av_dict_set(AVDictionary *pm, const char key, const char *value, int flags)
	51	{
	52	AVDictionary m = pm;
	53	AVDictionaryEntry *tag = av_dict_get(m, key, NULL, flags);
	54
	55	if(!m)
	56	m = pm = av_mallocz(sizeof(m));
	57
	58	if(tag) {
	59	if (flags & AV_DICT_DONT_OVERWRITE)
	60	return 0;
	61	av_free(tag->value);
	62	av_free(tag->key);
	63	*tag = m->elems[--m->count];
	64	} else {
	65	AVDictionaryEntry tmp = av_realloc(m->elems, (m->count+1) sizeof(*m->elems));
	66	if(tmp) {
	67	m->elems = tmp;
	68	} else
	69	return AVERROR(ENOMEM);
	70	}
	71	if (value) {
	72	if (flags & AV_DICT_DONT_STRDUP_KEY) {
	73	m->elems[m->count].key = key;
	74	} else
	75	m->elems[m->count].key = av_strdup(key );
	76	if (flags & AV_DICT_DONT_STRDUP_VAL) {
	77	m->elems[m->count].value = value;
	78	} else
	79	m->elems[m->count].value = av_strdup(value);
	80	m->count++;
	81	}
	82	if (!m->count) {
	83	av_free(m->elems);
	84	av_freep(pm);
	85	}
	86
	87	return 0;
	88	}
	89
	90	void av_dict_free(AVDictionary **pm)
	91	{
	92	AVDictionary m = pm;
	93
	94	if (m) {
	95	while(m->count--) {
	96	av_free(m->elems[m->count].key);
	97	av_free(m->elems[m->count].value);
	98	}
	99	av_free(m->elems);
	100	}
	101	av_freep(pm);
	102	}
	103
	104	void av_dict_copy(AVDictionary *dst, AVDictionary src, int flags)
	105	{
	106	AVDictionaryEntry *t = NULL;
	107
	108	while ((t = av_dict_get(src, "", t, AV_DICT_IGNORE_SUFFIX)))
	109	av_dict_set(dst, t->key, t->value, flags);
	110	}

libavutil/dict.h+78−0

@@ -0,0 +1,78 @@
	1	/*
	2	*
	3	* This file is part of Libav.
	4	*
	5	* Libav is free software; you can redistribute it and/or
	6	* modify it under the terms of the GNU Lesser General Public
	7	* License as published by the Free Software Foundation; either
	8	* version 2.1 of the License, or (at your option) any later version.
	9	*
	10	* Libav is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	* Lesser General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU Lesser General Public
	16	* License along with Libav; if not, write to the Free Software
	17	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	18	*/
	19
	20	/**
	21	* @file Public dictionary API.
	22	*/
	23
	24	#ifndef AVUTIL_DICT_H
	25	#define AVUTIL_DICT_H
	26
	27	#define AV_DICT_MATCH_CASE 1
	28	#define AV_DICT_IGNORE_SUFFIX 2
	29	#define AV_DICT_DONT_STRDUP_KEY 4
	30	#define AV_DICT_DONT_STRDUP_VAL 8
	31	#define AV_DICT_DONT_OVERWRITE 16 ///< Don't overwrite existing entries.
	32
	33	typedef struct {
	34	char *key;
	35	char *value;
	36	} AVDictionaryEntry;
	37
	38	typedef struct AVDictionary AVDictionary;
	39
	40	/**
	41	* Get a dictionary entry with matching key.
	42	*
	43	* @param prev Set to the previous matching element to find the next.
	44	* If set to NULL the first matching element is returned.
	45	* @param flags Allows case as well as suffix-insensitive comparisons.
	46	* @return Found entry or NULL, changing key or value leads to undefined behavior.
	47	*/
	48	AVDictionaryEntry *
	49	av_dict_get(AVDictionary m, const char key, const AVDictionaryEntry *prev, int flags);
	50
	51	/**
	52	* Set the given entry in *pm, overwriting an existing entry.
	53	*
	54	* @param pm pointer to a pointer to a dictionary struct. If *pm is NULL
	55	* a dictionary struct is allocated and put in *pm.
	56	* @param key entry key to add to *pm (will be av_strduped depending on flags)
	57	* @param value entry value to add to *pm (will be av_strduped depending on flags).
	58	* Passing a NULL value will cause an existing tag to be deleted.
	59	* @return >= 0 on success otherwise an error code <0
	60	*/
	61	int av_dict_set(AVDictionary *pm, const char key, const char *value, int flags);
	62
	63	/**
	64	* Copy entries from one AVDictionary struct into another.
	65	* @param dst pointer to a pointer to a AVDictionary struct. If *dst is NULL,
	66	* this function will allocate a struct for you and put it in *dst
	67	* @param src pointer to source AVDictionary struct
	68	* @param flags flags to use when setting entries in *dst
	69	* @note metadata is read using the AV_DICT_IGNORE_SUFFIX flag
	70	*/
	71	void av_dict_copy(AVDictionary *dst, AVDictionary src, int flags);
	72
	73	/**
	74	* Free all the memory allocated for an AVDictionary struct.
	75	*/
	76	void av_dict_free(AVDictionary **m);
	77
	78	#endif // AVUTIL_DICT_H

libavutil/internal.h+6−0

 #include "attributes.h"
 #include "timer.h"
 #include "cpu.h"
+#include "dict.h"
+struct AVDictionary {
+    int count;
+    AVDictionaryEntry *elems;
+};
 #ifndef attribute_align_arg
 #if ARCH_X86_32 && AV_GCC_VERSION_AT_LEAST(4,2)

libswscale/swscale.c+8−34

@@ -380,40 +380,14 @@ yuv2NBPS(10, LE, 0); · 379 unmodified lines
380	yuv2NBPS(16, BE, 1);	380	yuv2NBPS(16, BE, 1);
381	yuv2NBPS(16, LE, 0);	381	yuv2NBPS(16, LE, 0);
382		382
383	static inline void yuv2yuvX16_c(SwsContext c, const int16_t lumFilter, const int16_t **lumSrc, int lumFilterSize,	383	static inline void yuv2yuvX_c(SwsContext c, const int16_t lumFilter,
384	const int16_t chrFilter, const int16_t chrUSrc, const int16_t *chrVSrc, int chrFilterSize,	384	const int16_t **lumSrc, int lumFilterSize,
385	const int16_t *alpSrc, uint16_t dest, uint16_t uDest, uint16_t vDest, uint16_t *aDest, int dstW, int chrDstW,	385	const int16_t chrFilter, const int16_t *chrUSrc,
386	enum PixelFormat dstFormat)	386	const int16_t **chrVSrc,
387	{	387	int chrFilterSize, const int16_t **alpSrc,
388	if (isNBPS(dstFormat)) {	388	uint8_t dest, uint8_t uDest, uint8_t *vDest,
389	const int depth = av_pix_fmt_descriptors[dstFormat].comp[0].depth_minus1+1;	389	uint8_t *aDest, int dstW, int chrDstW,
390	yuv2yuvX16_c_template(lumFilter, lumSrc, lumFilterSize,	390	const uint8_t lumDither, const uint8_t chrDither)
391	chrFilter, chrUSrc, chrVSrc, chrFilterSize,
392	alpSrc,
393	dest, uDest, vDest, aDest,
394	dstW, chrDstW, isBE(dstFormat), depth);
395	} else {
396	if (isBE(dstFormat)) {
397	yuv2yuvX16_c_template(lumFilter, lumSrc, lumFilterSize,
398	chrFilter, chrUSrc, chrVSrc, chrFilterSize,
399	alpSrc,
400	dest, uDest, vDest, aDest,
401	dstW, chrDstW, 1, 16);
402	} else {
403	yuv2yuvX16_c_template(lumFilter, lumSrc, lumFilterSize,
404	chrFilter, chrUSrc, chrVSrc, chrFilterSize,
405	alpSrc,
406	dest, uDest, vDest, aDest,
407	dstW, chrDstW, 0, 16);
408	}
409	}
410	}
411
412	static void yuv2yuvX_c(SwsContext c, const int16_t lumFilter, const int16_t **lumSrc, int lumFilterSize,
413	const int16_t chrFilter, const int16_t *chrUSrc,
414	const int16_t **chrVSrc, int chrFilterSize,
415	const int16_t *alpSrc, uint8_t dest, uint8_t uDest, uint8_t vDest, uint8_t *aDest, int dstW, int chrDstW,
416	const uint8_t lumDither, const uint8_t chrDither)
417	{	391	{
418	//FIXME Optimize (just quickly written not optimized..)	392	//FIXME Optimize (just quickly written not optimized..)
419	int i;	393	int i;

libswscale/x86/swscale_template.c+31−37

     YSCALEYUV2YV12X_ACCURATE(LUM_MMX_FILTER_OFFSET, dest, dstW, 0)
 }
-#define YSCALEYUV2YV121 \
-    "mov %2, %%"REG_a"                    \n\t"\
-    ".p2align               4             \n\t" /* FIXME Unroll? */\
-    "1:                                   \n\t"\
-    "movq  (%0, %%"REG_a", 2), %%mm0      \n\t"\
-    "movq 8(%0, %%"REG_a", 2), %%mm1      \n\t"\
-    "psraw                 $7, %%mm0      \n\t"\
-    "psraw                 $7, %%mm1      \n\t"\
-    "packuswb           %%mm1, %%mm0      \n\t"\
-    MOVNTQ(%%mm0, (%1, %%REGa))\
-    "add                   $8, %%"REG_a"  \n\t"\
-    "jnc                   1b             \n\t"
 static inline void RENAME(yuv2yuv1)(SwsContext *c, const int16_t *lumSrc,
                                     const int16_t *chrUSrc, const int16_t *chrVSrc,
                                     const int16_t *alpSrc,
     while (p--) {
         if (dst[p]) {
             __asm__ volatile(
-               YSCALEYUV2YV121
+                "mov %2, %%"REG_a"                    \n\t"
-               :: "r" (src[p]), "r" (dst[p] + counter[p]),
+                ".p2align               4             \n\t" /* FIXME Unroll? */
-                  "g" (-counter[p])
+                "1:                                   \n\t"
-               : "%"REG_a
+                "movq  (%0, %%"REG_a", 2), %%mm0      \n\t"
+                "movq 8(%0, %%"REG_a", 2), %%mm1      \n\t"
+                "psraw                 $7, %%mm0      \n\t"
+                "psraw                 $7, %%mm1      \n\t"
+                "packuswb           %%mm1, %%mm0      \n\t"
+                MOVNTQ(%%mm0, (%1, %%REGa))
+                "add                   $8, %%"REG_a"  \n\t"
+                "jnc                   1b             \n\t"
+                :: "r" (src[p]), "r" (dst[p] + counter[p]),
+                   "g" (-counter[p])
+                : "%"REG_a
             );
         }
     }
 }
-#define YSCALEYUV2YV121_ACCURATE \
-    "mov %2, %%"REG_a"                    \n\t"\
-    "movq               0(%3), %%mm6      \n\t"\
-    "movq               8(%3), %%mm7      \n\t"\
-    ".p2align                4            \n\t" /* FIXME Unroll? */\
-    "1:                                   \n\t"\
-    "movq  (%0, %%"REG_a", 2), %%mm0      \n\t"\
-    "movq 8(%0, %%"REG_a", 2), %%mm1      \n\t"\
-    "paddsw             %%mm6, %%mm0      \n\t"\
-    "paddsw             %%mm7, %%mm1      \n\t"\
-    "psraw                 $7, %%mm0      \n\t"\
-    "psraw                 $7, %%mm1      \n\t"\
-    "packuswb           %%mm1, %%mm0      \n\t"\
-    MOVNTQ(%%mm0, (%1, %%REGa))\
-    "add                   $8, %%"REG_a"  \n\t"\
-    "jnc                   1b             \n\t"
 static inline void RENAME(yuv2yuv1_ar)(SwsContext *c, const int16_t *lumSrc,
                                        const int16_t *chrUSrc, const int16_t *chrVSrc,
                                        const int16_t *alpSrc,
             int i;
             for(i=0; i<8; i++) c->dither16[i] = i<2 ? lumDither[i] : chrDither[i];
             __asm__ volatile(
-                YSCALEYUV2YV121_ACCURATE
+                "mov %2, %%"REG_a"                    \n\t"
+                "movq               0(%3), %%mm6      \n\t"
+                "movq               8(%3), %%mm7      \n\t"
+                ".p2align                4            \n\t" /* FIXME Unroll? */
+                "1:                                   \n\t"
+                "movq  (%0, %%"REG_a", 2), %%mm0      \n\t"
+                "movq 8(%0, %%"REG_a", 2), %%mm1      \n\t"
+                "paddsw             %%mm6, %%mm0      \n\t"
+                "paddsw             %%mm7, %%mm1      \n\t"
+                "psraw                 $7, %%mm0      \n\t"
+                "psraw                 $7, %%mm1      \n\t"
+                "packuswb           %%mm1, %%mm0      \n\t"
+                MOVNTQ(%%mm0, (%1, %%REGa))
+                "add                   $8, %%"REG_a"  \n\t"
+                "jnc                   1b             \n\t"
                 :: "r" (src[p]), "r" (dst[p] + counter[p]),
                    "g" (-counter[p]), "r"(c->dither16)
                 : "%"REG_a
                                         int dstWidth, const uint8_t *src, int srcW,
                                         int xInc)
 {
-    int32_t *filterPos = c->hLumFilterPos;
+    int16_t *filterPos = c->hLumFilterPos;
     int16_t *filter    = c->hLumFilter;
     void    *mmx2FilterCode= c->lumMmx2FilterCode;
     int i;
                                         int dstWidth, const uint8_t *src1,
                                         const uint8_t *src2, int srcW, int xInc)
 {
-    int32_t *filterPos = c->hChrFilterPos;
+    int16_t *filterPos = c->hChrFilterPos;
     int16_t *filter    = c->hChrFilter;
     void    *mmx2FilterCode= c->chrMmx2FilterCode;
     int i;

Merge remote-tracking branch 'qatar/master'

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code