ffmpeg roll of source to mar 9 version...

patched-ffmpeg-mt/libavformat/asfdec.c

 /*
  * ASF compatible demuxer
  * Copyright (c) 2000, 2001 Fabrice Bellard
  *
  * This file is part of FFmpeg.
  *
  * FFmpeg is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
@@ skipping 64 matching lines @@
     else PRINT_IF_GUID(g, ff_asf_data_header);
     else PRINT_IF_GUID(g, index_guid);
     else PRINT_IF_GUID(g, ff_asf_head1_guid);
     else PRINT_IF_GUID(g, ff_asf_head2_guid);
     else PRINT_IF_GUID(g, ff_asf_my_guid);
     else PRINT_IF_GUID(g, ff_asf_ext_stream_header);
     else PRINT_IF_GUID(g, ff_asf_extended_content_header);
     else PRINT_IF_GUID(g, ff_asf_ext_stream_embed_stream_header);
     else PRINT_IF_GUID(g, ff_asf_ext_stream_audio_stream);
     else PRINT_IF_GUID(g, ff_asf_metadata_header);
+    else PRINT_IF_GUID(g, ff_asf_marker_header);
     else PRINT_IF_GUID(g, stream_bitrate_guid);
     else PRINT_IF_GUID(g, ff_asf_language_guid);
     else
         dprintf(NULL, "(GUID: unknown) ");
     for(i=0;i<16;i++)
         dprintf(NULL, " 0x%02x,", (*g)[i]);
     dprintf(NULL, "}\n");
 }
 #undef PRINT_IF_GUID
 #else
@@ skipping 20 matching lines @@
             *q++ = c;
         len--;
     }
     *q = '\0';
 }
 #endif
 
 static void get_str16_nolen(ByteIOContext *pb, int len, char *buf, int buf_size)
 {
     char* q = buf;
-    for (; len > 1; len -= 2) {
+    while (len > 1) {
         uint8_t tmp;
-        PUT_UTF8(get_le16(pb), tmp, if (q - buf < buf_size - 1) *q++ = tmp;)
+        uint32_t ch;
+
+        GET_UTF16(ch, (len -= 2) >= 0 ? get_le16(pb) : 0, break;)
+        PUT_UTF8(ch, tmp, if (q - buf < buf_size - 1) *q++ = tmp;)
     }
     if (len > 0)
         url_fskip(pb, len);
     *q = '\0';
 }
 
 static int asf_probe(AVProbeData *pd)
 {
     /* check file header */
     if (!guidcmp(pd->buf, &ff_asf_header))
         return AVPROBE_SCORE_MAX;
     else
         return 0;
 }
 
 static int get_value(ByteIOContext *pb, int type){
     switch(type){
         case 2: return get_le32(pb);
         case 3: return get_le32(pb);
         case 4: return get_le64(pb);
         case 5: return get_le16(pb);
         default:return INT_MIN;
     }
 }
 
 static void get_tag(AVFormatContext *s, const char *key, int type, int len)
 {
     char *value;
 
-    if ((unsigned)len >= UINT_MAX)
+    if ((unsigned)len >= (UINT_MAX - 1)/2)
         return;
 
-    value = av_malloc(len+1);
+    value = av_malloc(2*len+1);
     if (!value)
         return;
 
-    if (type <= 1) {         // unicode or byte
-        get_str16_nolen(s->pb, len, value, len);
-    } else if (type <= 5) {  // boolean or DWORD or QWORD or WORD
+    if (type == 0) {         // UTF16-LE
+        get_str16_nolen(s->pb, len, value, 2*len + 1);
+    } else if (type > 1 && type <= 5) {  // boolean or DWORD or QWORD or WORD
         uint64_t num = get_value(s->pb, type);
         snprintf(value, len, "%"PRIu64, num);
     } else {
         url_fskip(s->pb, len);
+        av_freep(&value);
+        av_log(s, AV_LOG_DEBUG, "Unsupported value type %d in tag %s.\n", type, key);
         return;
     }
-    if (!strncmp(key, "WM/", 3))
-        key += 3;
-    av_metadata_set2(&s->metadata, key, value, AV_METADATA_DONT_STRDUP_VAL);
+    av_metadata_set2(&s->metadata, key, value, 0);
+    av_freep(&value);
 }
 
 static int asf_read_header(AVFormatContext *s, AVFormatParameters *ap)
 {
     ASFContext *asf = s->priv_data;
     ff_asf_guid g;
     ByteIOContext *pb = s->pb;
     AVStream *st;
     ASFStream *asf_st;
     int size, i;
@@ skipping 243 matching lines @@
             }
         } else if (!guidcmp(&g, &ff_asf_extended_content_header)) {
             int desc_count, i;
 
             desc_count = get_le16(pb);
             for(i=0;i<desc_count;i++) {
                     int name_len,value_type,value_len;
                     char name[1024];
 
                     name_len = get_le16(pb);
+                    if (name_len%2)     // must be even, broken lavf versions wrote len-1
+                        name_len += 1;
                     get_str16_nolen(pb, name_len, name, sizeof(name));
                     value_type = get_le16(pb);
                     value_len  = get_le16(pb);
+                    if (!value_type && value_len%2)
+                        value_len += 1;
                     get_tag(s, name, value_type, value_len);
             }
         } else if (!guidcmp(&g, &ff_asf_metadata_header)) {
             int n, stream_num, name_len, value_len, value_type, value_num;
             n = get_le16(pb);
 
             for(i=0;i<n;i++) {
                 char name[1024];
 
                 get_le16(pb); //lang_list_index
@@ skipping 53 matching lines @@
                 url_fseek(pb, ext_len, SEEK_CUR);
             }
 
             // there could be a optional stream properties object to follow
             // if so the next iteration will pick it up
         } else if (!guidcmp(&g, &ff_asf_head1_guid)) {
             int v1, v2;
             get_guid(pb, &g);
             v1 = get_le32(pb);
             v2 = get_le16(pb);
+        } else if (!guidcmp(&g, &ff_asf_marker_header)) {
+            int i, count, name_len;
+            char name[1024];
+
+            get_le64(pb);            // reserved 16 bytes
+            get_le64(pb);            // ...
+            count = get_le32(pb);    // markers count
+            get_le16(pb);            // reserved 2 bytes
+            name_len = get_le16(pb); // name length
+            for(i=0;i<name_len;i++){
+                get_byte(pb); // skip the name
+            }
+
+            for(i=0;i<count;i++){
+                int64_t pres_time;
+                int name_len;
+
+                get_le64(pb);             // offset, 8 bytes
+                pres_time = get_le64(pb); // presentation time
+                get_le16(pb);             // entry length
+                get_le32(pb);             // send time
+                get_le32(pb);             // flags
+                name_len = get_le32(pb);  // name length
+                get_str16_nolen(pb, name_len * 2, name, sizeof(name));
+                ff_new_chapter(s, i, (AVRational){1, 10000000}, pres_time, AV_NOPTS_VALUE, name );
+            }
 #if 0
         } else if (!guidcmp(&g, &ff_asf_codec_comment_header)) {
             int len, v1, n, num;
             char str[256], *q;
             char tag[16];
 
             get_guid(pb, &g);
             print_guid(&g);
 
             n = get_le32(pb);
@@ skipping 633 matching lines @@
     NULL_IF_CONFIG_SMALL("ASF format"),
     sizeof(ASFContext),
     asf_probe,
     asf_read_header,
     asf_read_packet,
     asf_read_close,
     asf_read_seek,
     asf_read_pts,
     .metadata_conv = ff_asf_metadata_conv,
 };