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

---

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:

    // ioBuf will be deleted by this constructor
    Mpeg7Doc(String fileName, Util::IOBuffer* ioBuf, int frameRateNum,
             int frameRateDen)
    {
        mAnnoIsConcept = false;
        mFractions = 0;
        mFrameRateNum = frameRateNum;
        mFrameRateDen = frameRateDen;
        ReadData(fileName, ioBuf); // ReadData deletes ioBuf
    }

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

    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() const
    {
        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) const
    {
        return mKeyframeName[shot].size();
    }

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

    int
    KeyframeFrame(int shot, int keyframe) const
    {
        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) const
    {
        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);
    }

    // Misc

    void
    Dump(int from = 0, int to = -1)
    {
        if (to == -1 || to > NrShots())
            to = NrShots();
        if (to < from)
            to = from;
        std::cout << "Dumping mpeg7 from " << from << " to " << to
                  << " (size=" << NrShots() << ")" << std::endl;
        for (int i=from ; i<to ; i++)
        {
            std::cout << "segment " << ShotName(i) << " from " << StartFrame(i)
                      << " to " << EndFrame(i) << ": ";
            if (HasAnnotations())
            {
                std::cout << "relevance=" << Relevance(i) << ", confidence="
                          << Confidence(i) << ", anno=" << Annotation(i);
            }
            if (mOriginalHadKeyframes)
            {
                for (int j=0 ; j<NrKeyframes(i) ; j++)
                {
                    std::cout << "keyname=" << KeyframeName(i, j)
                              << ",frame=" << KeyframeFrame(i, j) << " ";
                }
            }
            if (HasFeatures())
            {
                std::cout << "feature=" << mFeatureName[i] + ", values=";
                for (int j=0 ; j<mFeatureValues[i].size() ; j++)
                {
                    std::cout << mFeatureValues[i][j] << " ";
                }
            }
            std::cout << std::endl;
        }
    }

    int
    Diff(Mpeg7Doc* arg)
    {
        if (NrShots() != arg->NrShots())
        {
            ILOG_ERROR("Diff: nrShots differs: " << NrShots() << " vs " <<
                       arg->NrShots());
            return 1;
        }
        int nDiff = 0;
        for (int i=0 ; i<NrShots() ; i++)
        {
            if (ShotName(i) != arg->ShotName(i))
            {
                ILOG_DEBUG("ShotName " << i << " differs " << ShotName(i) <<
                           " vs " << arg->ShotName(i));
                nDiff++;
            }
            else if (StartFrame(i) != arg->StartFrame(i))
            {
                ILOG_DEBUG("Start " << i << " differs " << StartFrame(i) <<
                           " vs " << arg->StartFrame(i));
                nDiff++;
            }
            else if (EndFrame(i) != arg->EndFrame(i))
            {
                ILOG_DEBUG("End " << i << " differs " << EndFrame(i) <<
                           " vs " << arg->EndFrame(i));
                nDiff++;
            }
            else if (HasAnnotations())
            {
                if (Relevance(i) != arg->Relevance(i))
                {
                    ILOG_DEBUG("Relevance " << i << " differs " << Relevance(i)
                               << " vs " << arg->Relevance(i));
                    nDiff++;
                }
                else if (Confidence(i) != arg->Confidence(i))
                {
                    ILOG_DEBUG("Confidence " << i << " differs " << Confidence(i)
                               << " vs " << arg->Confidence(i));
                    nDiff++;
                }
            }
            else if (mOriginalHadKeyframes)
            {
                for (int j=0 ; j<NrKeyframes(i) ; j++)
                {
                    if (KeyframeName(i, j) != arg->KeyframeName(i, j))
                    {
                        ILOG_DEBUG("KeyframeName " << i << "," << j <<
                                   " differs " << KeyframeName(i, j) <<
                                   " vs " << arg->KeyframeName(i, j));
                        nDiff++;
                        break;
                    }
                    else if (KeyframeFrame(i, j) != arg->KeyframeFrame(i, j))
                    {
                        ILOG_DEBUG("KeyframeFrame " << i << "," << j <<
                                   " differs " << KeyframeFrame(i, j) <<
                                   " vs " << arg->KeyframeFrame(i, j));
                        nDiff++;
                        break;
                    }
                }
            }
            else if (HasFeatures())
            {
                if (mFeatureName[i] != arg->mFeatureName[i])
                {
                    ILOG_DEBUG("FeatureName " << i << " differs " <<
                               mFeatureName[i] << " vs " << arg->mFeatureName[i]);
                    nDiff++;
                }
                else for (int j=0 ; j<mFeatureValues[i].size() ; j++)
                {
                    if (mFeatureValues[i][j] != arg->mFeatureValues[i][j])
                    {
                        ILOG_DEBUG("FeatureValue " << i << "," << j <<
                                   " differs " << mFeatureValues[i][j] <<
                                   " vs " << mFeatureValues[i][j]);
                        nDiff++;
                        break;
                    }
                }
            }
        }
        if (nDiff > 0)
            ILOG_ERROR("Found " << nDiff << " differences");
        return nDiff;
    }

    // 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');
    }

/* Note on time to frame conversion:

The key element in conversion is the mediaTimeUnit (which is often
not present in the mpeg7 file itself but can be retrieved from the video).
This class encountered the following units:

PT1N25F       = PAL  = 25    fps
PT1001N30000F = NTSC = 29.97 fps = 30000 / 1001

*/

    bool
    CheckKnownFraction()
    {
        if ((mFrameRateNum != 0) && (mFrameRateDen != 0))
        {
            mFractions = mFrameRateNum;
            return true;
        }

        if (mFractions == 25)
        {
            mFrameRateNum = 25;
            mFrameRateDen = 1;
            return true;
        }
        if (mFractions == 30000)
        {
            mFrameRateNum = 30000;
            mFrameRateDen = 1001;
            return true;
        }

        ILOG_ERROR("Unknown fraction " << mFractions << " in " <<
                   mVideoFileName);
        mFrameRateNum = mFractions;
        mFrameRateDen = 1;
        return false;
    }

    long
    Frame2Fraction(long frame)
    {
        CheckKnownFraction();
        return frame * mFrameRateDen;
    }

    long
    Fraction2Frame(long fractionCount)
    {
        CheckKnownFraction();
        return fractionCount / mFrameRateDen;
    }
 
    String
    Frame2TimePoint(int frame)
    {
        // produce something like T00:28:21:5985F30000
        long totalFractions = Frame2Fraction(frame);
        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 = Frame2Fraction(frame);
        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);
        mFractions = GetFractions(mediaTime);
        ILOG_DEBUG("fractions = " << mFractions);
        CheckKnownFraction();
        mNrFrames = GetMediaDuration(mediaTime);
        ILOG_DEBUG("nrFrames = " << mNrFrames);
        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;
        return Fraction2Frame(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;
        return Fraction2Frame(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;
    long   mFrameRateNum;
    long   mFrameRateDen;
    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

---