Ticket #551: mov.c.diff

mov.c

@@ -20 +20 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+//------------------------------------------------------Modifications History
+// DATE            DESCRIPTION
+// 06-06-2011      support reading H263 'bitr' box
+// 02-25-2011      added support for max NALSize
+// 02-22-2011      added support for max bitrate
+// 12-10-2010      Allow parsing udta box metadata on stream level
+
+
 #include <limits.h>
+#include <alloca.h>
 
 //#define DEBUG
 //#define DEBUG_METADATA
-//#define MOV_EXPORT_ALL_METADATA
+#define MOV_EXPORT_ALL_METADATA
 
 #include "libavutil/intreadwrite.h"
 #include "libavutil/avstring.h"
@@ -93 +102 @@
     return 0;
 }
 
+static int mov_metadata_hnti(MOVContext *c, ByteIOContext *pb, unsigned len)
+{
+    unsigned int remainder = len;
+    int size, tag;
+    AVMetadata **pm;
+    AVStream *st;
+    char *str;
+
+    if (c->metadata_ext & META_EXT_STREAM_LEVEL)
+    {
+        if (c->fc->nb_streams < 1)
+            return 0;
+
+        st = c->fc->streams[c->fc->nb_streams-1];
+        pm = &st->metadata;
+    }
+    else
+    {
+        pm = &c->fc->metadata;
+    }
+
+    str = alloca(len + 1);
+
+    while (remainder > 4)
+    {
+        // read next element
+        size = get_be32(pb);
+        tag = get_le32(pb);
+
+        if (tag == MKTAG('s','d','p',' '))
+        {
+            get_buffer(pb, str, size - 8);
+            str[size - 8] = 0;
+
+            av_metadata_set2(pm, "sdp", str, 0);
+        }
+
+        remainder -= size;
+
+    }
+
+    return 0;
+}
+
 static const uint32_t mac_to_unicode[128] = {
     0x00C4,0x00C5,0x00C7,0x00C9,0x00D1,0x00D6,0x00DC,0x00E1,
     0x00E0,0x00E2,0x00E4,0x00E3,0x00E5,0x00E7,0x00E9,0x00E8,
@@ -141 +194 @@
     uint32_t data_type = 0;
     int (*parse)(MOVContext*, ByteIOContext*, unsigned) = NULL;
 
-    switch (atom.type) {
+    AVMetadata **pm;
+    AVStream *st;
+
+    if (c->metadata_ext & META_EXT_STREAM_LEVEL)
+    {
+       if (c->fc->nb_streams < 1)
+            return 0;
+
+        st = c->fc->streams[c->fc->nb_streams-1];
+        pm = &st->metadata;
+    }
+    else
+    {
+       pm = &c->fc->metadata;
+    }
+
+    switch (atom.type)
+    {
     case MKTAG(0xa9,'n','a','m'): key = "title";     break;
     case MKTAG(0xa9,'a','u','t'):
     case MKTAG(0xa9,'A','R','T'): key = "artist";    break;
@@ -161 +231 @@
     case MKTAG( 't','v','e','n'): key = "episode_id";break;
     case MKTAG( 't','v','n','n'): key = "network";   break;
     case MKTAG( 't','r','k','n'): key = "track";
-        parse = mov_metadata_trkn; break;
+        parse = mov_metadata_trkn;
+        break;
+
+    case MKTAG( 'h','n','t','i'):
+        parse = mov_metadata_hnti;
+        break;
+
     }
 
-    if (c->itunes_metadata && atom.size > 8) {
+    if ((c->metadata_ext & META_EXT_ITUNES_TYPE) && atom.size > 8)
+    {
         int data_size = get_be32(pb);
         int tag = get_le32(pb);
-        if (tag == MKTAG('d','a','t','a')) {
+        if (tag == MKTAG('d','a','t','a'))
+        {
             data_type = get_be32(pb); // type
             get_be32(pb); // unknown
             str_size = data_size - 16;
             atom.size -= 16;
         } else return 0;
-    } else if (atom.size > 4 && key && !c->itunes_metadata) {
+    }
+    else if (atom.size > 4 && key && !(c->metadata_ext & META_EXT_ITUNES_TYPE))
+    {
         str_size = get_be16(pb); // string length
         langcode = get_be16(pb);
         ff_mov_lang_to_iso639(langcode, language);
@@ -197 +277 @@
 
     if (parse)
         parse(c, pb, str_size);
-    else {
+    else
+    {
         if (data_type == 3 || (data_type == 0 && langcode < 0x800)) { // MAC Encoded
             mov_read_mac_string(c, pb, str_size, str, sizeof(str));
         } else {
             get_buffer(pb, str, str_size);
             str[str_size] = 0;
         }
-        av_metadata_set2(&c->fc->metadata, key, str, 0);
+        av_metadata_set2(pm, 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_metadata_set2(pm, key2, str, 0);
         }
     }
 #ifdef DEBUG_METADATA
@@ -1759 +1840 @@
     st->codec->codec_type = AVMEDIA_TYPE_DATA;
     sc->ffindex = st->index;
 
+    /* we are at the stream level now */
+    c->metadata_ext = c->metadata_ext | META_EXT_STREAM_LEVEL;
+
     if ((ret = mov_read_default(c, pb, atom)) < 0)
         return ret;
 
@@ -1839 +1923 @@
     av_freep(&sc->stts_data);
     av_freep(&sc->stps_data);
 
+    c->metadata_ext = c->metadata_ext & ~META_EXT_STREAM_LEVEL;
+
     return 0;
 }
 
 static int mov_read_ilst(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
 {
     int ret;
-    c->itunes_metadata = 1;
+    c->metadata_ext = c->metadata_ext | META_EXT_ITUNES_TYPE;
     ret = mov_read_default(c, pb, atom);
-    c->itunes_metadata = 0;
+    c->metadata_ext = c->metadata_ext & ~META_EXT_ITUNES_TYPE;
     return ret;
 }
 
@@ -2194 +2280 @@
     return 0;
 }
 
+/* MP4/H264 variant of bitrate box */
+static int mov_read_btrt(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
+{
+    AVFormatContext* myContext = NULL;
+    AVStream* myStream = NULL;
+
+    int nMaxBitRate = 0;
+
+    myContext = c->fc;
+    get_be32(pb); //buffSize
+    nMaxBitRate = get_be32(pb);
+    get_be32(pb); // nBitRate
+
+    if (myContext->nb_streams < 1)
+    {
+        av_log(myContext, AV_LOG_ERROR,
+            "mov_read_btrt() number of streams is 0 ");
+        return 0;
+    }
+    av_log(myContext, AV_LOG_DEBUG,
+        "mov_read_btrt() reads nMaxBitRate=%d, \n",
+        nMaxBitRate);
+
+    myStream = myContext->streams[(myContext->nb_streams -1)];
+    myStream->codec->rc_max_rate = nMaxBitRate;
+
+    return 0;
+}
+
+/* H263 specific variant of bitrate box */
+static int mov_read_bitr(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
+{
+    AVFormatContext* myContext = NULL;
+    AVStream* myStream = NULL;
+
+    int nMaxBitRate = 0;
+
+    myContext = c->fc;
+    get_be32(pb); // avgBitRate - we are not interested right now
+
+    nMaxBitRate = get_be32(pb);
+
+    if (myContext->nb_streams < 1)
+    {
+        av_log(myContext, AV_LOG_ERROR,
+            "%s(): number of streams is 0 ", __FUNCTION__);
+        return 0;
+    }
+    av_log(myContext, AV_LOG_DEBUG,
+        "%s(): reads nMaxBitRate=%d", __FUNCTION__,
+        nMaxBitRate);
+
+    myStream = myContext->streams[(myContext->nb_streams -1)];
+    myStream->codec->rc_max_rate = nMaxBitRate;
+
+    return 0;
+}
+
+
+static int mov_read_cmvt(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
+{
+
+    AVFormatContext* myContext = NULL;
+    AVStream* myStream = NULL;
+    int nNalSize = 0;
+    char buffer[8];
+
+
+    myContext = c->fc;
+
+    nNalSize = get_be32(pb); // NAL Size
+    get_be32(pb); // empty
+    get_be32(pb); // empty
+
+    if (myContext->nb_streams < 1)
+    {
+        av_log(myContext, AV_LOG_ERROR,
+            "mov_read_cmvt() number of streams is 0 ");
+        return 0;
+    }
+    av_log(myContext, AV_LOG_DEBUG,
+        "mov_read_cmvt() reads nNalSize=%d\n",
+        nNalSize);
+
+    myStream = myContext->streams[(myContext->nb_streams -1)];
+    snprintf(buffer, sizeof(buffer), "%d", nNalSize);
+    av_metadata_set2(&myStream->metadata, "NALSize", buffer, 0);
+
+    return 0;
+}
+
+/* Read the H263 decoder info. Usually not very important,
+   contrary to avcC in H264 for example */
+static int mov_read_d263(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
+{
+   MOVAtom a = { 0 };
+
+   url_fskip(pb, 7); /* 7 bytes fixed data of decoder config */
+
+   /* May have optional bitr box, which we are interested in */
+   /* 15 below is: 
+      7 bytes of decoder data we skipped above + 8 bytes of bitr header */
+   if (atom.size > 15)
+   {
+      a.size = atom.size - 7;
+      return mov_read_default(c, pb, a);
+   }
+   else
+   {
+      return 0;
+   }
+}
+
 static const MOVParseTableEntry mov_default_parse_table[] = {
 { MKTAG('a','v','s','s'), mov_read_extradata },
 { MKTAG('c','h','p','l'), mov_read_chpl },
@@ -2221 +2420 @@
 { MKTAG('m','v','h','d'), mov_read_mvhd },
 { MKTAG('S','M','I',' '), mov_read_smi }, /* Sorenson extension ??? */
 { MKTAG('a','l','a','c'), mov_read_extradata }, /* alac specific atom */
-{ MKTAG('a','v','c','C'), mov_read_glbl },
+{ MKTAG('a','v','c','C'), mov_read_glbl },  /* H264 decoder config */
+{ MKTAG('d','2','6','3'), mov_read_d263 }, /* H263 decoder config */
 { MKTAG('p','a','s','p'), mov_read_pasp },
 { MKTAG('s','t','b','l'), mov_read_default },
 { MKTAG('s','t','c','o'), mov_read_stco },
@@ -2246 +2446 @@
 { MKTAG('e','s','d','s'), mov_read_esds },
 { MKTAG('w','i','d','e'), mov_read_wide }, /* place holder */
 { MKTAG('c','m','o','v'), mov_read_cmov },
+{ MKTAG('b','t','r','t'), mov_read_btrt },
+{ MKTAG('b','i','t','r'), mov_read_bitr },
+{ MKTAG('c','m','v','t'), mov_read_cmvt },
 { 0, NULL }
 };