|| || || || || || || ||

---

Mpeg7Doc.h

Go to the documentation of this file.

#ifndef Impala_Core_VideoSet_Mpeg7Doc_h
#define Impala_Core_VideoSet_Mpeg7Doc_h

#include "Util/Database.h"
#include "Util/XmlDoc.h"
#include "Util/QuickSort.h"
#include "Util/StringParser.h"
#include "Persistency/XmlFileReader.h"
#include "Core/Geometry/OverlapsAnywhere1d.h"

namespace Impala
{
namespace Core
{
namespace VideoSet
{


class Mpeg7Doc : public Util::XmlDoc
{

public:

#ifndef REPOSITORY_USED // Here comes the deprecated stuff
    Mpeg7Doc(String fileName, Util::Database* db)
    {
        mAnnoIsConcept = false;
        Util::IOBuffer* ioBuf = db->GetIOBuffer(fileName, true, true, "");
        ReadData(fileName, ioBuf); // ReadData deletes ioBuf
    }
#endif // REPOSITORY_USED

    // ioBuf will be deleted by this constructor
    Mpeg7Doc(String fileName, Util::IOBuffer* ioBuf)
    {
        mAnnoIsConcept = false;
        ReadData(fileName, ioBuf); // ReadData deletes ioBuf
    }

    Mpeg7Doc(String id, String fileName, int nrFrames, int fractions,
             bool withKeyframes, String conceptSet, String annoFileName)
    {
        mId = id;
        mVideoFileName = fileName;
        mNrFrames = nrFrames;
        mFractions = fractions;
        mOriginalHadKeyframes = withKeyframes;
        mConceptSet = conceptSet;
        mAnnoFileName = annoFileName;
        mAnnoIsConcept = false;
    }

    virtual
    ~Mpeg7Doc()
    {
    }

    void
    AddShot(String name, int startFrame, int endFrame)
    {
        mShotName.push_back(name);
        mStartFrame.push_back(startFrame);
        mEndFrame.push_back(endFrame);
    }

    void
    AddShot(String name, int startFrame, int endFrame,
            std::vector<String> keyframeNames, std::vector<int> keyframeFrames)
    {
        mShotName.push_back(name);
        mStartFrame.push_back(startFrame);
        mEndFrame.push_back(endFrame);
        mKeyframeName.push_back(keyframeNames);
        mKeyframeFrame.push_back(keyframeFrames);
    }

    void
    AddAnnotation(String annotation, String shotName, int startFrame,
                  int endFrame, double relevance, double confidence)
    {
        mAnnotation.push_back(annotation);
        mShotName.push_back(shotName);
        mStartFrame.push_back(startFrame);
        mEndFrame.push_back(endFrame);
        mRelevance.push_back(relevance);
        mConfidence.push_back(confidence);
    }

    // To allow identification of segment to be replaced, by any frame
    // within it, rather than identification by startFrame only
    int
    ReplaceAnnotationEx(String annotation, String shotName,
                        int aFrame, int startFrame, int endFrame,
                        double relevance, double confidence)
    {
        int idx = FindShot(aFrame);
        if (idx == -1)
        {
            mAnnotation.push_back(annotation);
            mShotName.push_back(shotName);
            mStartFrame.push_back(startFrame);
            mEndFrame.push_back(endFrame);
            mRelevance.push_back(relevance);
            mConfidence.push_back(confidence);
        }
        else
        {   // assume only one kind of annotation
            mShotName[idx] = shotName;
            mStartFrame[idx] = startFrame;
            mEndFrame[idx] = endFrame;
            mRelevance[idx] = relevance;
            mConfidence[idx] = confidence;
        }
        return idx;
    }

    int
    ReplaceAnnotation(String annotation, String shotName,
                      int startFrame, int endFrame, double relevance,
                      double confidence)
    {
        return ReplaceAnnotationEx(annotation, shotName, startFrame,
                                   startFrame, endFrame,relevance, confidence);
    }

    void
    SetAnnoIsConcept()
    {
        mAnnoIsConcept = true;
    }

    bool
    GetAnnoIsConcept()
    {
        return mAnnoIsConcept;
    }

    // inquiry

    String
    GetId()
    {
        return mId;
    }

    String
    GetVideoFileName()
    {
        return mVideoFileName;
    }

    int
    GetNrFrames()
    {
        return mNrFrames;
    }

    int
    GetFractions()
    {
        return mFractions;
    }

    int
    NrShots()
    {
        return mShotName.size();
    }

    String
    ShotName(int shot)
    {
        return mShotName[shot];
    }

    int
    StartFrame(int shot)
    {
        return mStartFrame[shot];
    }

    int
    EndFrame(int shot)
    {
        return mEndFrame[shot];
    }

    int
    NrKeyframes(int shot)
    {
        return mKeyframeName[shot].size();
    }

    String
    KeyframeName(int shot, int keyframe)
    {
        return mKeyframeName[shot][keyframe];
    }

    int
    KeyframeFrame(int shot, int keyframe)
    {
        return mKeyframeFrame[shot][keyframe];
    }

    double
    Relevance(int shot)
    {
        return mRelevance[shot];
    }

    double
    FrameRelevance(int frameNr)
    {
        int shotIdx = FindShot(frameNr);
        return shotIdx != -1 ? Relevance(shotIdx) : 0.0;
    }

    double
    Confidence(int shot)
    {
        return mConfidence[shot];
    }

    int
    FindShot(int frameNr)
    {
        for (int i=0 ; i<mStartFrame.size() ; i++)
        {
            int sF = mStartFrame[i];
            int eF = mEndFrame[i];
            if (eF > 13000)
                int g = 10;
            if ((mStartFrame[i] <= frameNr) && (frameNr <= mEndFrame[i]))
                return i;
        }
        return -1;
    }

    std::vector<int>
    FindShots(int startFrame, int endFrame)
    {
        std::vector<int> res;
        for (int i=0 ; i<mStartFrame.size() ; i++)
        {
            if (Geometry::OverlapsAnywhere1d(startFrame, endFrame,
                                             mStartFrame[i], mEndFrame[i]))
            {
                res.push_back(i);
            }
        }
        return res;
    }

    // Annotation / Concept part

    bool
    HasAnnotations()
    {
        return !mAnnotation.empty();
    }

    void
    SetConceptSet(String conceptSet)
    {
        mConceptSet = conceptSet;
    }

    String
    GetConceptSet()
    {
        return mConceptSet;
    }

    String
    GetAnnoFileName()
    {
        return mAnnoFileName;
    }

    String
    Annotation(int shot)
    {
        return mAnnotation[shot];
    }

    /*

Impala annotatietool uses the following conventions:

positive: relevance="1" confidence="1"
negative: relevance="0" confidence="1"
skip: relevance="0.5" confidence="1"

Trec2007 annotations:

positive: relevance="1" confidence="1"
positive skip: relevance="1" confidence="0.5"
negative: relevance="0" confidence="1"
negative skip: relevance="0" confidence="0.5"

    */

    bool
    IsPositiveAnno(int shot)
    {
        return (Relevance(shot) == 1.0) && (Confidence(shot) > 0.5);
    }

    bool
    IsNegativeAnno(int shot)
    {
        return (Relevance(shot) == 0.0) && (Confidence(shot) > 0.5);
    }

    // Feature part

    bool
    HasFeatures()
    {
        return mFeatureName.size() != 0;
    }

    String
    GetFeature()
    {
        return mFeatureName[0];
    }

    void
    AddFeature(String featureName, String shotName, int startFrame,
               int endFrame, std::vector<double> featureValues)
    {
        mFeatureName.push_back(featureName);
        mShotName.push_back(shotName);
        mStartFrame.push_back(startFrame);
        mEndFrame.push_back(endFrame);
        mFeatureValues.push_back(featureValues);
    }

    // I/O

    /*
    void
    WriteVxs(String fileName)
    {
        File f(fileName, "w");
        if (! f.Valid())
            return;
        fprintf(f.Fp(), "#@ \"start\" \"end\" \"id\" \"keystr\"\n");
        fprintf(f.Fp(), "#= \"int\" \"int\" \"string\" \"string\"\n");
        for (int i=0 ; i<NrShots() ; i++)
        {
            int dummy = 0;
            fprintf(f.Fp(), " %d %d \"%s\" \"", mStartFrame[i], mEndFrame[i],
                    mShotName[i].c_str());
            for (int k=0 ; k<mKeyframeName[i].size() ; k++)
                fprintf(f.Fp(), " %s %d", mKeyframeName[i][k].c_str(), 
                        mKeyframeFrame[i][k]);
            fprintf(f.Fp(), "\"\n");
        }
    }
    */

    void
    WriteTo(std::ostream& os)
    {
        for (int i=0 ; i<NrShots() ; i++)
        {
            os << mShotName[i] << " " << mStartFrame[i] << " " << mEndFrame[i];
            if (mOriginalHadKeyframes)
                for (int k=0 ; k<mKeyframeName[i].size() ; k++)
                    os << " " << mKeyframeName[i][k] << " "
                       << mKeyframeFrame[i][k];
            if (HasAnnotations())
                os << " " << mAnnotation[i];
            os << std::endl;
        }
    }

    void
    ExportXml(Util::IOBuffer* ioBuf)
    {
        ioBuf->Puts("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
        ioBuf->Puts("<Mpeg7 xmlns=\"urn:mpeg:mpeg7:schema:2001\" xmlns:mpeg7=\"urn:mpeg:mpeg7:schema:2001\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">");
        ioBuf->Puts("<Description xsi:type=\"ContentEntityType\">");
        ioBuf->Puts("<MultimediaContent xsi:type=\"VideoType\">");
        ioBuf->Puts("");
        ioBuf->Puts("<Video id=\"" + String2Xml(mId) + "\">");
        ioBuf->Puts("<MediaLocator>");
        ioBuf->Puts("<MediaUri>" + String2Xml(mVideoFileName) + "</MediaUri>");
        ioBuf->Puts("</MediaLocator>");
        ExportMediaTime(ioBuf, 0, mNrFrames);
        if (mStartFrame.size() > 0)
        {
            if (HasAnnotations())
                ioBuf->Puts("<TemporalDecomposition gap=\"true\" overlap=\"true\">");
            else
                ioBuf->Puts("<TemporalDecomposition gap=\"false\" overlap=\"false\">");
            int nrFrames = mStartFrame.size();
            int* frames = new int[nrFrames];
            int* order = new int[nrFrames];
            for (int i=0 ; i<nrFrames ; i++)
            {
                frames[i] = mStartFrame[i];
                order[i] = i;
            }
            Util::QuickSortCo(frames, order, 0, nrFrames - 1);
            for (int i=0 ; i<mStartFrame.size() ; i++)
                //ExportShot(ioBuf, i);
                ExportShot(ioBuf, order[i]);
            delete frames;
            delete order;
            ioBuf->Puts("</TemporalDecomposition>");
        }
        ioBuf->Puts("</Video>");
        ioBuf->Puts("</MultimediaContent>");
        ioBuf->Puts("</Description>");
        ioBuf->Puts("</Mpeg7>");
    }

private:

    /* file excerpt:

<?xml version="1.0" encoding="UTF-8"?>
<Mpeg7 xmlns="urn:mpeg:mpeg7:schema:2001" xmlns:mpeg7="urn:mpeg:mpeg7:schema:2001" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<Description xsi:type="ContentEntityType">
<MultimediaContent xsi:type="VideoType">

<!-- Shots with keyframes look like this: -->

<Video id="TRECVID2006_1">
  <MediaLocator>
    <MediaUri>20051102_142800_LBC_NAHAR_ARB.mpg</MediaUri>
  </MediaLocator>
  <MediaTime>
    <MediaTimePoint>T00:00:00:0F30000</MediaTimePoint>
    <MediaDuration>PT01H02M19S28086N30000F</MediaDuration>
  </MediaTime>
  <TemporalDecomposition gap="false" overlap="false">

    <VideoSegment id="shot1_1">
      <MediaTime>
        <MediaTimePoint>T00:00:00:0F30000</MediaTimePoint>
        <MediaDuration>PT00H00M04S2122N30000F</MediaDuration>
      </MediaTime>
      <TemporalDecomposition>
        <VideoSegment id="shot1_1_RKF">
          <MediaTime>
            <MediaTimePoint>T00:00:02:60F30000</MediaTimePoint>
          </MediaTime>
        </VideoSegment>
      </TemporalDecomposition>
    </VideoSegment>

    <VideoSegment id="shot1_5">
      <MediaTime>
        <MediaTimePoint>T00:00:16:27507F30000</MediaTimePoint>
        <MediaDuration>PT00H00M02S19079N30000F</MediaDuration>
      </MediaTime>
      <TemporalDecomposition>
        <VideoSegment id="shot1_5_NRKF_1">
          <MediaTime>
            <MediaTimePoint>T00:00:17:17527F30000</MediaTimePoint>
          </MediaTime>
        </VideoSegment>
        <VideoSegment id="shot1_5_RKF">
          <MediaTime>
            <MediaTimePoint>T00:00:18:6546F30000</MediaTimePoint>
          </MediaTime>
        </VideoSegment>
        <VideoSegment id="shot1_5_NRKF_2">
          <MediaTime>
            <MediaTimePoint>T00:00:18:27567F30000</MediaTimePoint>
          </MediaTime>
        </VideoSegment>
      </TemporalDecomposition>
    </VideoSegment>

  </TemporalDecomposition>
</Video>

<!-- Annotations look like this: -->

<Video id="20051102_142800_LBC_NAHAR_ARB.mpg">
  <MediaLocator>
    <MediaUri>20051102_142800_LBC_NAHAR_ARB.mpg</MediaUri>
  </MediaLocator>
  <MediaTime>
    <MediaTimePoint>T00:00:00:0F30000</MediaTimePoint>
    <MediaDuration>PT01H02M19S28086N30000F</MediaDuration>
  </MediaTime>
  <TemporalDecomposition gap="true" overlap="true">

    <VideoSegment id="shot1_1_RKF">
      <MediaTime>
        <MediaTimePoint>T00:00:00:0F30000</MediaTimePoint>
        <MediaDuration>PT00H00M00S1001N30000F</MediaDuration>
      </MediaTime>
      <TextAnnotation relevance="1" confidence="1">
        <KeywordAnnotation>
          <Keyword>Airplane</Keyword>
        </KeywordAnnotation>
      </TextAnnotation>
    </VideoSegment>

  </TemporalDecomposition>
</Video>

<!-- Note that the old version can also be read: -->

      <TextAnnotation relevance="1" confidence="1">
        <FreeTextAnnotation>desert</FreeTextAnnotation>
      </TextAnnotation>

<!-- Features look like this: -->

<Video id="20051102_142800_LBC_NAHAR_ARB.mpg">
  <MediaLocator>
    <MediaUri>20051102_142800_LBC_NAHAR_ARB.mpg</MediaUri>
  </MediaLocator>
  <MediaTime>
    <MediaTimePoint>T00:00:00:0F30000</MediaTimePoint>
    <MediaDuration>PT01H02M19S28086N30000F</MediaDuration>
  </MediaTime>
  <TemporalDecomposition gap="true" overlap="true">

    <VideoSegment id="shot1_1_RKF">
      <MediaTime>
        <MediaTimePoint>T00:00:00:0F30000</MediaTimePoint>
        <MediaDuration>PT00H00M00S1001N30000F</MediaDuration>
      </MediaTime>
      <DescriptorUnit xsi:type="DescriptorCollectionType">
        <Descriptor xsi:type="VissemVisualFeatures">
          <Coefficients>
            <!--numbers separated by spaces-->
          </Coefficients>
        </Descriptor>
      </DescriptorUnit>
    </VideoSegment>

  </TemporalDecomposition>
</Video>

<!-- common part for the end -->

</MultimediaContent>
</Description>
</Mpeg7>

    */

    String
    String2(int nr)
    {
        return MakeString(nr, 2, '0');
    }

    String
    Frame2TimePoint(int frame)
    {
        // produce something like T00:28:21:5985F30000
        long totalFractions = frame;
        if (mFractions == 30000) // probably NTSC with time unit PT1001N30000F
            totalFractions *= 1001;
        long nrFractions = totalFractions % mFractions;
        long totalSeconds = (totalFractions - nrFractions) / mFractions;
        long hours = totalSeconds / 3600;
        totalSeconds %= 3600;
        long minutes = totalSeconds / 60;
        long seconds = totalSeconds % 60;
        return "T" + String2(hours) + ":" + String2(minutes) + ":" +
            String2(seconds) + ":" + MakeString(nrFractions) + "F" +
            String2(mFractions);
    }

    String
    Frame2Duration(int frame)
    {
        // produce something like PT00H00M04S2122N30000F
        long totalFractions = frame;
        if (mFractions == 30000) // probably NTSC with time unit PT1001N30000F
            totalFractions *= 1001;
        long nrFractions = totalFractions % mFractions;
        long totalSeconds = (totalFractions - nrFractions) / mFractions;
        long hours = totalSeconds / 3600;
        totalSeconds %= 3600;
        long minutes = totalSeconds / 60;
        long seconds = totalSeconds % 60;
        return "PT" + String2(hours) + "H" + String2(minutes) + "M" +
            String2(seconds) + "S" + String2(nrFractions) + "N" +
            String2(mFractions) + "F";
    }

    void
    ExportShot(Util::IOBuffer* ioBuf, int idx)
    {
        ioBuf->Puts("<VideoSegment id=\"" + mShotName[idx] + "\">");
        ExportMediaTime(ioBuf, mStartFrame[idx],
                        mEndFrame[idx] - mStartFrame[idx] + 1);
        if (HasAnnotations())
        {
            String r = "relevance=\"" + MakeString(mRelevance[idx]) + "\"";
            String c = "confidence=\"" + MakeString(mConfidence[idx]) + "\"";
            ioBuf->Puts("<TextAnnotation " + r + " " + c + ">");
            ioBuf->Puts("<KeywordAnnotation>");
            ioBuf->Puts("<Keyword>" + mAnnotation[idx] + "</Keyword>");
            ioBuf->Puts("</KeywordAnnotation>");
            ioBuf->Puts("</TextAnnotation>"); 
           
        }
        if (mOriginalHadKeyframes)
        {
            ioBuf->Puts("<TemporalDecomposition>");
            std::vector<String> names = mKeyframeName[idx];
            std::vector<int> frames = mKeyframeFrame[idx];
            for (int i=0 ; i<names.size() ; i++)
            {
                ioBuf->Puts("<VideoSegment id=\"" + names[i] + "\">");
                ExportMediaTime(ioBuf, frames[i], -1);
                ioBuf->Puts("</VideoSegment>");
            }
            ioBuf->Puts("</TemporalDecomposition>");
        }
        if (HasFeatures())
        {
            ioBuf->Puts("<DescriptorUnit xsi:type=\"DescriptorCollectionType\">");
            ioBuf->Puts("<Descriptor xsi:type=\"" + mFeatureName[idx] + "\">");
            ioBuf->Puts("<Coefficients>");
            std::vector<double> v = mFeatureValues[idx];
            int nr = 0;
            String s;
            for (int i=0 ; i<v.size() ; i++)
            {
                s += MakeString(v[i]) + " ";
                if (++nr == 10)
                {
                    ioBuf->Puts(s);
                    s = "";
                    nr = 0;
                }
            }
            if (nr != 0)
                ioBuf->Puts(s);
            ioBuf->Puts("</Coefficients>");
            ioBuf->Puts("</Descriptor>");
            ioBuf->Puts("</DescriptorUnit>");
            
        }
        ioBuf->Puts("</VideoSegment>");
    }

    void
    ExportMediaTime(Util::IOBuffer* ioBuf, int point, int duration)
    {
        ioBuf->Puts("<MediaTime>");
        ioBuf->Puts("<MediaTimePoint>" + Frame2TimePoint(point) +
                    "</MediaTimePoint>");
        if (duration != -1)
            ioBuf->Puts("<MediaDuration>" + Frame2Duration(duration) +
                        "</MediaDuration>");
        ioBuf->Puts("</MediaTime>");
    }

    // ioBuf will be delete as soon as possible by ReadData
    void
    ReadData(String fileName, Util::IOBuffer* ioBuf)
    {
        Persistency::XmlFileReader reader;
        DOMDocument* doc = reader.Read(fileName, ioBuf);
        delete ioBuf;
        DOMNode* mpeg7 = GetChildNode(doc, "Mpeg7", true);
        DOMNode* desc = GetChildNode(mpeg7, "Description", true);
        DOMNode* mmContent = GetChildNode(desc, "MultimediaContent", true);
        DOMNode* video = GetChildNode(mmContent, "Video", true);
        mId = Xml2String(GetAttributeValue(video, "id"));
        ILOG_DEBUG("video id = " << mId);
        DOMNode* mediaLoc = GetChildNode(video, "MediaLocator", true);
        DOMNode* mediaUri = GetChildNode(mediaLoc, "MediaUri", true);
        mVideoFileName = Xml2String(GetElementValue(mediaUri));
        ILOG_DEBUG("filename = " << mVideoFileName);
        DOMNode* mediaTime = GetChildNode(video, "MediaTime", true);
        mNrFrames = GetMediaDuration(mediaTime);
        ILOG_DEBUG("nrFrames = " << mNrFrames);
        mFractions = GetFractions(mediaTime);
        ILOG_DEBUG("fractions = " << mFractions);
        DOMNode* decomp = GetChildNode(video, "TemporalDecomposition", true);
        std::vector<DOMNode*> segments = GetChildNodes(decomp, "VideoSegment");
        ILOG_DEBUG("nr VideoSegments = " << segments.size());
        for (int i=0 ; i<segments.size() ; i++)
            AddShot(segments[i]);
    }

    void
    AddShot(DOMNode* segment)
    {
        String id = GetAttributeValue(segment, "id");
        ILOG_DEBUG("shot id = " << id);
        mShotName.push_back(id);
        DOMNode* textAnno = GetChildNode(segment, "TextAnnotation", false);
        if (textAnno)
        {
            String rel = GetAttributeValue(textAnno, "relevance");
            mRelevance.push_back(atof(rel));
            String conf = GetAttributeValue(textAnno, "confidence");
            mConfidence.push_back(atof(conf));
            String anno;
            DOMNode* freeText = GetChildNode(textAnno, "FreeTextAnnotation",
                                             false);
            if (freeText)
            {
                anno = GetElementValue(freeText);
            }
            else
            {
                DOMNode* keyAnno = GetChildNode(textAnno, "KeywordAnnotation",
                                                true);
                DOMNode* keyWord = GetChildNode(keyAnno, "Keyword", true);
                anno = GetElementValue(keyWord);
            }
            mAnnotation.push_back(anno);
            mAnnoFileName = anno;
        }
        else
        {
            mAnnoFileName = "";
        }
        DOMNode* mediaTime = GetChildNode(segment, "MediaTime", true);
        long frame = GetMediaTimePoint(mediaTime);
        long duration = GetMediaDuration(mediaTime);
        mStartFrame.push_back(frame);
        mEndFrame.push_back(frame + duration - 1);

        std::vector<String> keyframeNames;
        std::vector<int> keyframeFrames;
        DOMNode* td = GetChildNode(segment, "TemporalDecomposition", false);
        if (td)
        {
            mOriginalHadKeyframes = true;
            GetTemporalDecomposition(td, keyframeNames, keyframeFrames);
        }
        else
        {
            mOriginalHadKeyframes = false;
            keyframeNames.push_back(id + "_RKF");
            keyframeFrames.push_back(frame + duration/2);
        }
        mKeyframeName.push_back(keyframeNames);
        mKeyframeFrame.push_back(keyframeFrames);
    }

    long
    GetMediaTimePoint(DOMNode* mediaTime)
    {
        DOMNode* timePoint = GetChildNode(mediaTime, "MediaTimePoint", true);
        String s = GetElementValue(timePoint);
        // e.g. s = T00:28:21:5985F30000
        Util::StringParser p(s);
        p.Eat('T'); // T is begin of time point
        long hours = p.GetInt(':');
        long minutes = p.GetInt(':');
        long seconds = p.GetInt(':');
        p.AdvanceP(1); // skip ':', since it is not whitespace for next
        long fractions = p.GetInt('F');
        p.AdvanceP(1);
        long nrFractions = p.GetInt();
        long frame;
        frame = (hours*3600 + minutes*60 + seconds)*nrFractions + fractions;
        if (nrFractions == 30000) // probably NTSC with time unit PT1001N30000F
            frame = frame / 1001;
        return frame;
    }

    long
    GetMediaDuration(DOMNode* mediaTime)
    {
        DOMNode* duration = GetChildNode(mediaTime, "MediaDuration", true);
        String s = GetElementValue(duration);
        // e.g. s = PT00H00M04S2122N30000F
        Util::StringParser p(s);
        p.Eat('T'); // T is begin of duration
        long total = 0;
        if (p.Contains("H"))
        {
            total += p.GetInt('H') * 3600;
            p.AdvanceP(1);
        }
        if (p.Contains("M"))
        {
            total += p.GetInt('M') * 60;
            p.AdvanceP(1);
        }
        if (p.Contains("S"))
        {
            total += p.GetInt('S');
            p.AdvanceP(1);
        }
        long fractions = p.GetInt('N');
        p.AdvanceP(1);
        long nrFractions = p.GetInt('F');
        long dur = total*nrFractions + fractions;
        if (nrFractions == 30000) // probably NTSC with time unit PT1001N30000F
            dur /= 1001;
        return dur;
    }

    int
    GetFractions(DOMNode* mediaTime)
    {
        DOMNode* timePoint = GetChildNode(mediaTime, "MediaTimePoint", true);
        String s = GetElementValue(timePoint);
        // e.g. s = T00:28:21:5985F30000
        Util::StringParser p(s);
        p.Eat('F');
        return p.GetInt();
    }

    void
    GetTemporalDecomposition(DOMNode* td, std::vector<String>& names,
                             std::vector<int>& frames)
    {
        std::vector<DOMNode*> segments = GetChildNodes(td, "VideoSegment");
        for (int i=0 ; i<segments.size() ; i++)
        {
            DOMNode* segment = segments[i];
            String id = GetAttributeValue(segment, "id");
            names.push_back(id);
            DOMNode* mediaTime = GetChildNode(segment, "MediaTime", true);
            long frame = GetMediaTimePoint(mediaTime);
            frames.push_back(frame);
        }
    }

    String 
    String2Xml(CString src)
    {
        return StringReplaceAll(src, "&", "&amp;", false);
    }

    String 
    Xml2String(CString src)
    {
        return StringReplaceAll(src, "&amp;", "&", false);
    }
 
    // data

    String mId; // e.g. TRECVID2006_1
    String mVideoFileName;
    int    mNrFrames;
    int    mFractions;
    bool   mOriginalHadKeyframes;
    String mConceptSet;
    String mAnnoFileName;
    bool   mAnnoIsConcept;

    std::vector<String>                mShotName;
    std::vector<int>                   mStartFrame;
    std::vector<int>                   mEndFrame;
    std::vector< std::vector<String> > mKeyframeName;
    std::vector< std::vector<int> >    mKeyframeFrame;
    std::vector<String>                mAnnotation;
    std::vector<double>                mRelevance;
    std::vector<double>                mConfidence;
    std::vector<String>                mFeatureName;
    std::vector< std::vector<double> > mFeatureValues;

    ILOG_VAR_DEC;

};

ILOG_VAR_INIT(Mpeg7Doc, Impala.Core.VideoSet);

} // namespace VideoSet
} // namespace Core
} // namespace Impala

#endif

---