benn/lumiera_
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

kill "the EDL"

Browse source
This commit is contained in:
Fischlurch 2010-02-22 03:52:52 +01:00
parent 93cd85ea07
commit 092ea07b76
42 changed files with 228 additions and 422 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/proc/asset/clip.cpp
View file

@ -75,7 +75,7 @@ namespace asset
* asset::Clip internally holds a Clip-MO, which has
* been created alongside. This Clip-MO may have several
* Placements or no placement at all (meaning it need not
* be placed within the EDL)
* be placed within the session)
*/
Media::PClipMO
Clip::createClip () const

4
src/proc/asset/media.cpp
View file

@ -213,8 +213,8 @@ namespace asset
/** Factory method for creating a Clip asset based
* on the given Media asset. This asset::Clip can be used
* to create clip in the EDL covering the whole length of
* this media.
* to create a clip in the session covering the whole length
* of this media.
* @note creates a dependency between media and new clip
* @throw Invalid if the given media asset is not top-level,
* but rather part or a multichannel (compound) media

2
src/proc/asset/media.hpp
View file

@ -96,7 +96,7 @@ namespace asset {
PProcPatt howtoProc () const;
/** Service Access Point for creating a Clip entity usable within
* the EDL/Session from a given Media or Clip Asset. As a sideeffect,
* the Session from a given Media or Clip Asset. As a sideeffect,
* a corresponding asset::Clip is created as well if necessary.
* It is OK to use and throw away the returned Clip-MO, because
* it can be regenerated from the corresponding asset::Clip

8
src/proc/asset/struct.hpp
View file

@ -22,11 +22,11 @@
/** @file struct.hpp
** Structural facilities of the EDL (e.g. Tracks) can be treated in the
** "bookkeeping view" as a specific Kind of Asset.
** For the different <i>Kinds</i> of Assets, we use sub-intefaces inheriting
** Structural parts of the Session (e.g. Tracks) can be reflected
** into the "bookkeeping view" as a specific Kind of Asset.
** For the different <i>Kinds</i> of Assets, we use sub-interfaces inheriting
** from the general Asset interface. To be able to get asset::Struct instances
** directly from the AssetManager, we define a specialization of the Asset ID.
** directly from the AssetManager, we define a specialisation of the Asset ID.
**
** @see asset.hpp for explanation
** @see StructFactory creating concrete asset::Struct instances

2
src/proc/asset/track.cpp
View file

@ -1,5 +1,5 @@
/*
Track - structural asset holding the configuration of a track in the EDL
Track - structural asset holding the configuration of a track in the Session
Copyright (C) Lumiera.org
2008, Hermann Vosseler <Ichthyostega@web.de>

6
src/proc/asset/track.hpp
View file

@ -35,10 +35,10 @@ namespace asset
/**
* Structural Asset using as a global identifier for placing
* some object onto a given track. Not to be confused with the "track-MO":
* To actually use a track within an EDL, we need to attach a
* Placement<mobject::session::Track> to the tree-of-tracks of this EDL.
* To actually use a track within an Sequence, we need to attach a
* Placement<mobject::session::Track> to the tree-of-tracks of this Sequence.
* Thus, we have one global track-identifier (this class here), but
* maybe several instances (track-MO) within various EDLs
* maybe several instances (track-MO) within various Sequences
*/
class Track : public Struct
{

2
src/proc/common.hpp
View file

@ -105,7 +105,7 @@ namespace mobject {
/**
* Namespace of Session, EDL and user visible high-level objects.
* Namespace of Session and user visible high-level objects.
*/
namespace session { }

2
src/proc/mobject/builder/buildertool.hpp
View file

@ -23,7 +23,7 @@
/** @file buildertool.hpp
** Visiting-tool mechanism configured specifically for the Builder.
** The Builder creates the render nodes network by applying several Builder Tools
** to the objects found in the Session, EDL and Fixture. These BuilderTool instances
** to the objects found in the Session and Fixture. These BuilderTool instances
** contain the details of the builder implementation.
**
** As the objects to be treated are normally handled by smart-ptrs, BuilderTool provides

4
src/proc/mobject/explicitplacement.hpp
View file

@ -35,8 +35,8 @@ namespace mobject {
/**
* Special kind of Placement, where the location of the
* MObject has been nailed down to a fixed position.
* The Session allways contains one special EDL, which
* actually is a snapshot of all EDLs contents fixed
* The Session maintains a special list of Placements,
* which actually is a snapshot of all Session contents fixed
* and reduced to simple positions. This so called Fixture
* contains only ExplicitPlacement objects and is processed
* by the Builder to create the render engine node network.

4
src/proc/mobject/mobject.hpp
View file

@ -59,8 +59,8 @@ namespace mobject {
/**
* MObject is the interface class for all "Media Objects".
* All the contents and elements that can be placed and
* manipulated and finally rendered within Lumiera's EDL
* are MObjects.
* manipulated and finally rendered within Lumiera's
* high-level model and Session are MObjects.
*/
class MObject
: public Buildable,

6
src/proc/mobject/placement.hpp
View file

@ -24,7 +24,7 @@
/** @file placement.hpp
** Placements are at the very core of all editing operations,
** because they act as handles to access the media objects to be manipulated.
** Moreover, Placements are the actual content of the EDL(s) and Fixture and thus
** Moreover, Placements are the actual "content" of the Session and Fixture and thus
** are small handle like objects. Many editing tasks include locating some Placement
** within the Session or directly take a ref to a Placement.
**
@ -35,7 +35,7 @@
** which takes ownership of the MObject.
**
** Besides being a handle, Placements define the logical position where some MObject is
** supposed to be located within the EDL or Fixture. The way in which this placing happens
** supposed to be located within the Session or Fixture. The way in which this placing happens
** is controlled and parametrised by a collection (chain) of LocatingPin objects. By adding
** to this chain, the position of the MObject is increasingly constrained. The simplest
** case of such constraining is to add a FixedLocation, thus placing the MObject at one
@ -92,7 +92,7 @@ namespace mobject {
/**
* A refcounting Handle to an MObject of type MO,
* used to constrain or explicitly specify the location
* where the MObject is supposed to be within the Session/EDL.
* where the MObject is supposed to be within the Session/Model.
* Placements are copyable (like values), but may be distinguished
* by their identity (reference semantics), which is based on an
* \link lib::HashIndexed hash-ID \endlink.

6
src/proc/mobject/session.hpp
View file

@ -60,7 +60,6 @@ namespace mobject {
namespace session {
class SessManager;
class EDL;
class Fixture;
typedef std::tr1::shared_ptr<Fixture> PFix;
}
@ -104,9 +103,6 @@ namespace mobject {
virtual void add (PMO& placement) = 0;
virtual bool remove (PMO& placement) = 0;
/// @deprecated Ichthyo doubts it is good design to hand out the EDL??
virtual session::EDL& currEDL () = 0;
virtual session::PFix& getFixture () = 0;
virtual void rebuildFixture () = 0;
@ -134,7 +130,7 @@ namespace mobject {
/** clear current session contents
* without resetting overall session config.
* Afterwards, the session will contain only one
* empty EDL, while all Assets are retained.
* empty Sequence, while all Assets are retained.
*/
virtual void clear () =0;

2
src/proc/mobject/session/clip.hpp
View file

@ -44,7 +44,7 @@ namespace session {
* A user visible/editable Clip is a reference to a contiguous
* sequence of media data loaded as Asset into the current Session.
* As such, it is a virtual (non destructive) cut or edit of the
* source material and can be placed into the EDL to be rendered
* source material and can be placed into the Session to be rendered
* into the output. The actual media type of a clip will be derived
* at runtime by resolving this reference to the underlying Asset.
*

90
src/proc/mobject/session/edl.cpp
View file

@ -1,90 +0,0 @@
/*
EDL - the (high level) Edit Decision List within the current Session
Copyright (C) Lumiera.org
2008, Hermann Vosseler <Ichthyostega@web.de>
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
* *****************************************************/
#include "proc/mobject/session/edl.hpp"
#include "proc/mobject/session/track.hpp"
#include "proc/mobject/placement.hpp"
#include "proc/mobject/session/mobjectfactory.hpp"
#include "proc/asset/track.hpp"
namespace mobject
{
namespace session
{
namespace // Implementation details
{
using asset::Query;
/** helper: create a default configured track asset */
const Placement<Track>
makeDefaultTrack ()
{
PTrackAsset tA = asset::Struct::create (Query<asset::Track> ("dummy()"));
return MObject::create (tA);
}
}
/** create an empty default configured EDL */
EDL::EDL ()
: track (makeDefaultTrack ()),
clips (0)
{
}
/** @deprecated not sure if it is a good idea
* to have this on the interface
*/
bool
EDL::contains (const PMO& placement)
{
UNIMPLEMENTED ("test if a given placement is contained within this EDL");
}
PMO&
EDL::find (const string& id)
{
UNIMPLEMENTED ("serch for a given 'thing' within the EDL");
}
bool
EDL::validate()
{
UNIMPLEMENTED ("self-check");
return false;
}
} // namespace mobject::session
} // namespace mobject

76
src/proc/mobject/session/edl.hpp
View file

@ -1,76 +0,0 @@
/*
EDL.hpp - the (high level) Edit Decision List within the current Session
Copyright (C) Lumiera.org
2008, Hermann Vosseler <Ichthyostega@web.de>
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#ifndef MOBJECT_SESSION_EDL_H
#define MOBJECT_SESSION_EDL_H
#include <vector>
#include <string>
#include "proc/mobject/mobject.hpp"
#include "proc/mobject/placement.hpp"
#include "proc/mobject/session/track.hpp"
using proc_interface::PAsset; // TODO better way to refer to a track?
using std::vector;
using std::string;
namespace mobject {
namespace session {
class EDL ///////////////////////////TICKET #152 EDL will be renamed to "Sequence".
///////////////////////////TODO: Should be converted to an facade interface
///////////////////////////TODO: what follows is dummy code and will be dropped!
{
protected:
Placement<Track> track;
vector<MObject *> clips;
public:
EDL();
bool contains (const PMO& placement);
PMO& find (const string& id); ///< @todo how to refer to clips? using asset IDs??
Placement<Track>& getTracks () { return track; } ///< @todo work out the correct use of tracks! make const correct!
size_t size ()
{
UNIMPLEMENTED ("what is the 'size' of an EDL?");
return 0;
}
bool isValid() { return this->validate(); }
private:
virtual bool validate();
};
} // namespace mobject::session
} // namespace mobject
#endif

2
src/proc/mobject/session/effect.cpp
View file

@ -1,5 +1,5 @@
/*
Effect - EDL representation of a pluggable and automatable effect.
Effect - Model representation of a pluggable and automatable effect.
Copyright (C) Lumiera.org
2008, Hermann Vosseler <Ichthyostega@web.de>

2
src/proc/mobject/session/effect.hpp
View file

@ -1,5 +1,5 @@
/*
EFFECT.hpp - EDL representation of a pluggable and automatable effect.
EFFECT.hpp - Model representation of a pluggable and automatable effect.
Copyright (C) Lumiera.org
2008, Hermann Vosseler <Ichthyostega@web.de>

2
src/proc/mobject/session/fixedlocation.hpp
View file

@ -37,7 +37,7 @@ namespace mobject
/**
* The most common case of positioning a MObject
* in the EDL: directly specifying a constant position.
* in the Session: directly specifying a constant position.
* @todo use a subclass to represent the LocatingSolution?
* would solve the construction of a ExplicitPlacement
* much more natural. (ichthyo: siehe trac #100)

62
src/proc/mobject/session/fixture.cpp
View file

@ -1,5 +1,5 @@
/*
Fixture - the (low level) representation of the EDL with explicit placement data
Fixture - the (low level) representation of the Session with explicit placement data
Copyright (C) Lumiera.org
2008, Hermann Vosseler <Ichthyostega@web.de>
@ -25,37 +25,37 @@
#include "include/logging.h"
namespace mobject {
namespace session {
namespace session {
list<ExplicitPlacement> &
Fixture::getPlaylistForRender ()
{
UNIMPLEMENTED ("get Playlist For Render");
}
/** TODO: a placeholder for the Operation needed for
* wiring the Automation providers in the Build process
*/
Auto<double>*
Fixture::getAutomation ()
{
UNIMPLEMENTED ("getAutomation from Fixture");
return 0;
}
/** @todo self-verification of the fixture? necessary? */
bool
Fixture::isValid() const
{
TODO ("actually do a self-verification of the Fixture");
return true;
}
list<ExplicitPlacement> &
Fixture::getPlaylistForRender ()
{
UNIMPLEMENTED ("get Playlist For Render");
}
/** TODO: a placeholder for the Operation needed for
* wiring the Automation providers in the Build process
*/
Auto<double>*
Fixture::getAutomation ()
{
UNIMPLEMENTED ("getAutomation from Fixture");
return 0;
}
} // namespace mobject::session
} // namespace mobject
/*
// Local Variables:
// mode: C++
// c-file-style: "gnu"
// indent-tabs-mode: nil
// End:
*/
}} // namespace mobject::session

73
src/proc/mobject/session/fixture.hpp
View file

@ -1,5 +1,5 @@
/*
FIXTURE.hpp - the (low level) representation of the EDL with explicit placement data
FIXTURE.hpp - the (low level) representation of the Session with explicit placement data
Copyright (C) Lumiera.org
2008, Hermann Vosseler <Ichthyostega@web.de>
@ -24,15 +24,15 @@
#ifndef MOBJECT_SESSION_FIXTURE_H
#define MOBJECT_SESSION_FIXTURE_H
#include <list>
#include <boost/scoped_ptr.hpp>
#include "proc/mobject/session/edl.hpp"
#include "proc/mobject/session/segmentation.hpp"
#include "proc/mobject/session/track.hpp"
#include "proc/mobject/explicitplacement.hpp"
#include "proc/mobject/session/auto.hpp"
#include <list>
#include <boost/noncopyable.hpp>
#include <boost/scoped_ptr.hpp>
using std::list;
using std::tr1::shared_ptr;
@ -40,38 +40,39 @@ using std::tr1::shared_ptr;
namespace mobject {
namespace session {
namespace session {
class Fixture : public EDL
{
protected:
list<ExplicitPlacement> content_;
boost::scoped_ptr<Segmentation> partitioning_;
/////////////TODO: who creates this?
public:
list<ExplicitPlacement> & getPlaylistForRender () ;
Auto<double>* getAutomation () ; ///< @todo: just a placeholder at the moment!!!
private:
virtual bool validate()
{
TODO ("how to validate a Fixture?");
return false;
}
};
typedef shared_ptr<Fixture> PFix;
} // namespace mobject::session
} // namespace mobject
class Fixture
: boost::noncopyable
{
protected:
list<ExplicitPlacement> content_;
boost::scoped_ptr<Segmentation> partitioning_;
/////////////TODO: who creates this?
public:
list<ExplicitPlacement> & getPlaylistForRender () ;
Auto<double>* getAutomation () ; ///< @todo: just a placeholder at the moment!!!
bool isValid() const;
private:
virtual bool validate()
{
TODO ("how to validate a Fixture?");
return false;
}
};
typedef shared_ptr<Fixture> PFix;
}} // namespace mobject::session
#endif

2
src/proc/mobject/session/locatingpin.hpp
View file

@ -23,7 +23,7 @@
/** @file locatingpin.hpp
** Implementing the Placement mechanics. The various specifications how
** some MObject is to be placed (logically) within the EDL are given by small
** to place some MObject (logically) within the Session are given by small
** LocatingPin objects forming a chain. For resolving the actual position, at the
** moment (10/07) we use a preliminary implementation to support the most common
** Placement types (fixed and relative). It is comprised of the nested LocatingSolution

2
src/proc/mobject/session/meta.hpp
View file

@ -36,7 +36,7 @@ namespace session {
* Meta-MObject doesn't represent real Media Content,
* but rather all sorts of Processing Instructions
* and other metadata, which can be placed and
* attached within the EDL/Session.
* attached within the Model/Session.
* @todo do we need this abstract baseclass?
*/
class Meta : public AbstractMO

17
src/proc/mobject/session/mobjectfactory.cpp
View file

@ -53,18 +53,17 @@ namespace session {
}
/** creating a Clip-MObject to be placed within
* the EDL, based on a clip asset, which typically
* is obtained by calling the createClip()-function
* on some asset::Media. The newly created Clip-MO is
* internally linked with this media Asset and wrapped
* into a Placement, which takes ownership. So, when the
* render engine gets across this Clip-MO, it is able to
* obtain the media information contained in the corresponding
/** creating a Clip-MObject to be placed within the Session,
* based on a clip asset, which typically is obtained by calling
* the createClip()-function on some asset::Media.
* The newly created Clip-MO is (back)linked with this media Asset
* internally and wrapped into a Placement, which takes ownership.
* So, when the render engine gets across this Clip-MO, it is able
* to obtain the media information contained in the corresponding
* media asset. Note this will create a single track clip.
* @param mediaDef the actual asset::Media to be used
* created Clip could be a compound (multichannel) clip
* comprised of several SimpleClip subobjects.
* comprised of several SimpleClip sub-objects.
*/
Placement<Clip>
MObjectFactory::operator() (const asset::Clip& clipRef, const asset::Media& mediaDef)

25
src/proc/mobject/session/session-impl.cpp
View file

@ -52,8 +52,6 @@ namespace session {
SessionImpl::SessionImpl ()
: Session( getDummyDefaultsManager() ) ///////TODO temporary hack
, pIdx_( MObject::create (getDummyDefaultsManager())) ////TODO temporary hack
, focusEDL_(0)
, edls() /////////// this is dummy code. How to initialise the default session? ///////TICKET #497
, fixture(new Fixture)
{
INFO (session, "new Session created.");
@ -61,22 +59,19 @@ namespace session {
/** @internal used by SessionManager#clear
* discard all EDL content, without
* touching global configuration.
* discard all Session content,
* without touching global configuration.
*/
void
SessionImpl::clear ()
{
try
{
edls.clear();
edls.resize(1); //////////////////////////////////////////////////////////////////////////TICKET #513
focusEDL_ = 0;
//////////////////////////////////////////////////////////////////////////TICKET #496
}
catch (...)
{
focusEDL_ = 0;
throw lumiera::error::Fatal ("unexpected exception while clearing EDLs");
throw lumiera::error::Fatal ("unexpected exception while clearing the session"); ///////////TODO still required??
}
}
@ -92,25 +87,17 @@ namespace session {
void
SessionImpl::add (PMO& placement)
{
UNIMPLEMENTED ("add Placement to the current EDL");
UNIMPLEMENTED ("add Placement to the current Session");
}
bool
SessionImpl::remove (PMO& placement)
{
UNIMPLEMENTED ("search and remove a given Placement from current EDL");
UNIMPLEMENTED ("search and remove a given Placement from current Session");
return false; // TODO
}
/// @deprecated should not grant direct access to EDL objects
EDL&
SessionImpl::currEDL ()
{
ASSERT (focusEDL_ < edls.size());
return edls[focusEDL_];
}
PFix&
SessionImpl::getFixture ()

5
src/proc/mobject/session/session-impl.hpp
View file

@ -47,7 +47,6 @@
#define MOBJECT_SESSION_SESSIONIMPL_H
#include "proc/mobject/session.hpp"
#include "proc/mobject/session/edl.hpp"
#include "proc/mobject/session/fixture.hpp"
#include "proc/mobject/session/placement-index.hpp"
#include "proc/mobject/session/session-services.hpp"
@ -80,8 +79,6 @@ namespace session {
{
PlacementIndex pIdx_;
uint focusEDL_;
vector<EDL> edls; /////////////////////TICKET #500 #513 #514
PFix fixture;
@ -93,8 +90,6 @@ namespace session {
virtual void add (PMO& placement);
virtual bool remove (PMO& placement);
virtual EDL& currEDL ();
virtual PFix& getFixture ();
virtual void rebuildFixture ();

2
src/proc/mobject/session/track.cpp
View file

@ -1,5 +1,5 @@
/*
Track - A grouping device within the EDL.
Track - A grouping device within the Session.
Copyright (C) Lumiera.org
2008, Hermann Vosseler <Ichthyostega@web.de>

10
src/proc/mobject/session/track.hpp
View file

@ -1,5 +1,5 @@
/*
TRACK.hpp - A grouping device within the EDL.
TRACK.hpp - A grouping device within the Session.
Copyright (C) Lumiera.org
2008, Hermann Vosseler <Ichthyostega@web.de>
@ -43,7 +43,7 @@ namespace session {
/**
* A Track is grouping device within the EDL.
* A Track is grouping device within the Session.
* The corresponding Placement by which this Track object is referred
* defines fallback placing properties to be used by all objects placed on this track
* in case they don't specify more concrete placements.
@ -52,11 +52,11 @@ namespace session {
* of clips. Note tracks are grouped in a tree like fashion.
* \par
* This Media Object (often referred to as "track-MO") is always dealt with
* locally within one EDL. Client code normally doesn't have to care for creating
* locally within one Sequence. Client code normally doesn't have to care for creating
* or retrieving track-MO. Rather, it refers to the global track-asset-ID. The same
* holds true when placing some other Media Object onto a track: the corresponding
* placement just refers the global trackID, while the builder automatically retrieves
* the matching track-MO for the EDL in question. If some EDL contains several instances
* placement just refers the global trackID, while the builder automatically retrieves the
* matching track-MO for the Sequence in question. If the Session contains several instances
* (track-MO) referring to the same trackID (asset), then this causes all objects placed
* onto this track to be included several times in the resulting render nodes network
* (possibly with varying placement properties)

2
tests/43session.tests
View file

@ -1,4 +1,4 @@
TESTING "Component Test Suite: MObjects and Session/EDL" ./test-components --group=session
TESTING "Component Test Suite: MObjects and Session/Model" ./test-components --group=session

2
tests/components/proc/asset/testasset.cpp
View file

@ -1,5 +1,5 @@
/*
TestClip - test clip (stub) for checking EDL/Session functionality
TestClip - test clip (stub) for checking Model/Session functionality
Copyright (C) Lumiera.org
2008, Hermann Vosseler <Ichthyostega@web.de>

4
tests/components/proc/mobject/builder/buildsegmenttest.cpp
View file

@ -1,5 +1,5 @@
/*
BuildSegment(Test) - building the render-tree for a segment of the EDL
BuildSegment(Test) - building the render-tree for a segment of the Timeline
Copyright (C) Lumiera.org
2008, Hermann Vosseler <Ichthyostega@web.de>
@ -44,7 +44,7 @@ namespace mobject
/*******************************************************************
* @test the builder core functionality: create a render pipeline
* for a given segment of the EDL.
* for a given segment of the Session/Timeline.
*/
class BuildSegment_test : public Test
{

8
tests/components/proc/mobject/controller/rendersegmenttest.cpp
View file

@ -42,10 +42,10 @@ namespace mobject
/*******************************************************************
* @test create a render process from a given segment of the EDL.
/********************************************************************
* @test create a render process from a given segment of the Session.
* Basically this includes cooperation of all parts of the
* Lumiera Proc Layer. For a prepared test-EDL we invoke the
* Lumiera Proc Layer. For a prepared test-Session we invoke the
* controller to create a render process. This includes building
* the render pipeline. Finally, we analyze all the created
* Structures.
@ -56,7 +56,7 @@ namespace mobject
{
virtual void run(Arg arg)
{
UNIMPLEMENTED ("complete render process for a given test segment of the EDL");
UNIMPLEMENTED ("complete render process for a given test segment of the Session");
}
};

1
tests/components/proc/mobject/placement-basic-test.cpp
View file

@ -24,7 +24,6 @@
#include "lib/test/run.hpp"
#include "proc/asset/media.hpp"
#include "proc/mobject/session.hpp"
#include "proc/mobject/session/edl.hpp"
#include "proc/mobject/session/testclip.hpp"
#include "proc/mobject/placement.hpp"
#include "proc/mobject/explicitplacement.hpp"

7
tests/components/proc/mobject/session/addcliptest.cpp
View file

@ -1,5 +1,5 @@
/*
AddClip(Test) - adding an Clip-MObject to the EDL/Session
AddClip(Test) - adding an Clip-MObject to the Model/Session
Copyright (C) Lumiera.org
2008, Hermann Vosseler <Ichthyostega@web.de>
@ -23,7 +23,6 @@
#include "lib/test/run.hpp"
#include "proc/mobject/session.hpp"
#include "proc/mobject/session/edl.hpp"
#include "proc/mobject/session/testclip.hpp"
#include "proc/mobject/placement.hpp"
#include "lib/util.hpp"
@ -49,9 +48,9 @@ namespace mobject
/*******************************************************************
* @test adding an test clip to the EDL/Session.
* @test adding an test clip to the Model/Session.
* @see mobject::session::Clip
* @see mobject::session::EDL
* @see mobject::Session
*/
class AddClip_test : public Test
{

15
tests/components/proc/mobject/session/deletecliptest.cpp
View file

@ -24,7 +24,6 @@
#include "lib/test/run.hpp"
#include "proc/assetmanager.hpp"
#include "proc/mobject/session.hpp"
#include "proc/mobject/session/edl.hpp" // TODO: really neded?
#include "proc/mobject/session/testsession1.hpp"
#include "proc/mobject/session/clip.hpp" // TODO: really neded?
//#include "lib/util.hpp"
@ -51,9 +50,11 @@ namespace test {
/*******************************************************************
* @test removing a test clip from the EDL.
* @test removing a test clip from the Session/Model.
* @see mobject::session::Clip
* @see mobject::session::EDL
* @see mobject::Session
*
* @todo ////////////////////////////////////////////////TICKET #499
*/
class DeleteClip_test : public Test
{
@ -64,13 +65,13 @@ namespace test {
PSess sess = Session::current;
AssetManager& aMang = AssetManager::instance();
UNIMPLEMENTED("typesafe searching for MObjects in the EDL");
UNIMPLEMENTED("typesafe searching for MObjects in the Session");
#if false /////////////////////////////////////////////////////////////////////////////////////////////////////TODO: work out how to search within EDL!!
#if false /////////////////////////////////////////////////////////////////////////////////////////////////////TODO: work out how to search within the Model!!
PClipMO clipPlacement = sess->currEDL().find(SESSION1_CLIP);
// global Var asigned in buildTestsession1()
// global Var assigned in buildTestsession1()
PMedia media = clipPlacement->getMedia();
IDA clipAID = media->getID();
ASSERT (clipPlacement);
@ -80,7 +81,7 @@ namespace test {
ASSERT (!sess->currEDL().find(SESSION1_CLIP)); // EDL forgot the Clip/Placement
ASSERT (!aMang.known (clipAID)); // corresponding Clip Asset has disappeared
ASSERT (!clipPlacement->getMedia()); // internal cross-links removed
#endif /////////////////////////////////////////////////////////////////////////////////////////////////////TODO: work out how to search within EDL!!
#endif /////////////////////////////////////////////////////////////////////////////////////////////////////TODO: work out how to search within the Model!!
}
};

7
tests/components/proc/mobject/session/rebuildfixturetest.cpp
View file

@ -23,16 +23,13 @@
#include "lib/test/run.hpp"
#include "proc/mobject/session.hpp"
#include "proc/mobject/session/edl.hpp"
#include "proc/mobject/session/testsession1.hpp"
#include "lib/util-foreach.hpp"
#include "lib/util.hpp"
//#include <boost/format.hpp>
#include <tr1/functional>
#include <iostream>
//using boost::format;
using std::tr1::bind;
using util::contains;
using util::for_each;
@ -49,7 +46,7 @@ namespace test {
/*******************************************************************
* @test (re)building the ExplicitPlacement objects from the objects
* placed into the Session/EDL.
* placed into the Session/Model.
* @see mobject::session::Fixture
* @see mobject::ExplicitPlacement
*/
@ -63,6 +60,7 @@ namespace test {
buildTestsession1();
ASSERT (sess->isValid());
sess->rebuildFixture();
#if false ////////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #548
TODO ("check the fixture has been touched. e.g. by hash.");
TODO ("query all Placements of all Clips (via AssetManager). Verify explicit plac contained in Fixture.");
@ -82,6 +80,7 @@ namespace test {
// PMO originalPlacement = explicitPlacement->subject->getPlacement();
// ASSERT (edl.contains(originalPlacement));
#endif ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #548
}
};

82
tests/components/proc/mobject/session/session-structure-test.cpp Normal file
View file

@ -0,0 +1,82 @@
/*
SessionStructure(Test) - verifying basic Session/Model structure
Copyright (C) Lumiera.org
2008-2010, Hermann Vosseler <Ichthyostega@web.de>
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
* *****************************************************/
#include "lib/test/run.hpp"
#include "proc/mobject/session.hpp"
#include "proc/mobject/session/fixture.hpp" // TODO only temporarily needed
#include "proc/assetmanager.hpp"
//#include "lib/util.hpp"
#include <iostream>
using std::string;
using std::cout;
namespace mobject {
namespace session {
namespace test {
using proc_interface::AssetManager;
using proc_interface::PAsset;
/*******************************************************************************
* @test access the current session and verify the correct
* structure of the most important components: The session
* contains an Sequence, we can get at the Fixture, we have at least
* one Track and the corresponding Track asset is available.
* @todo define further criteria to be checked
* @todo implement Sequence, Fixture, Session#rebuildFixture, asset::Track
*/
class SessionStructure_test : public Test
{
virtual void
run (Arg arg)
{
PSess sess = Session::current;
UNIMPLEMENTED("the real standard structure of the session"); //////////////////////////TICKET #499
#if false //////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #546
ASSERT (0 <= sess->currEDL().size()); // TODO implement
ASSERT (0 <= sess->getFixture()->size()); // TODO implement
ASSERT (sess->currEDL().getTracks()->isValid());
// PAsset track = sess->currEDL().getTracks()[0];
// AssetManager& aMang = AssetManager::instance();
// ASSERT (track == aMang.getAsset (track->getID()));
#endif //////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #546
UNIMPLEMENTED ("how to refer to tracks...");
}
};
/** Register this test class... */
LAUNCHER (SessionStructure_test, "unit session");
}}} // namespace mobject::session::test

2
tests/components/proc/mobject/session/sessionmanagertest.cpp
View file

@ -1,5 +1,5 @@
/*
SessionManager(Test) - accessing, loading and saving the Session/EDL
SessionManager(Test) - accessing, loading and saving the Session/Model
Copyright (C) Lumiera.org
2008, Hermann Vosseler <Ichthyostega@web.de>

86
tests/components/proc/mobject/session/sessionstructuretest.cpp
View file

@ -1,86 +0,0 @@
/*
SessionStructure(Test) - verifying basic Session/EDL structure
Copyright (C) Lumiera.org
2008, Hermann Vosseler <Ichthyostega@web.de>
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
* *****************************************************/
#include "lib/test/run.hpp"
#include "proc/mobject/session.hpp"
#include "proc/mobject/session/edl.hpp" // TODO only temporarily needed
#include "proc/mobject/session/fixture.hpp" // TODO only temporarily needed
#include "proc/assetmanager.hpp"
//#include "lib/util.hpp"
//#include <boost/format.hpp>
#include <iostream>
//using boost::format;
using std::string;
using std::cout;
namespace mobject
{
namespace session
{
namespace test
{
using proc_interface::AssetManager;
using proc_interface::PAsset;
/*******************************************************************************
* @test access the current session and verify the correct
* structure of the most important components: The session
* contains an EDL, we can get at the Fixture, we have at least
* one Track and the corresponding Track asset is available.
* @todo define further criteria to be checked
* @todo implement EDL, Fixture, Session#rebuildFixture, asset::Track
*/
class SessionStructure_test : public Test
{
virtual void
run (Arg arg)
{
PSess sess = Session::current;
UNIMPLEMENTED("the real standard structure of the session"); //////////////////////////TICKET #499
ASSERT (0 <= sess->currEDL().size()); // TODO implement
ASSERT (0 <= sess->getFixture()->size()); // TODO implement
ASSERT (sess->currEDL().getTracks()->isValid());
// PAsset track = sess->currEDL().getTracks()[0];
// AssetManager& aMang = AssetManager::instance();
// ASSERT (track == aMang.getAsset (track->getID()));
UNIMPLEMENTED ("how to refer to tracks...");
}
};
/** Register this test class... */
LAUNCHER (SessionStructure_test, "unit session");
} // namespace test
} // namespace session
} // namespace mobject

2
tests/components/proc/mobject/session/testclip.cpp
View file

@ -1,5 +1,5 @@
/*
TestClip - test clip (stub) for checking EDL/Session functionality
TestClip - test clip (stub) for checking Model/Session functionality
Copyright (C) Lumiera.org
2008, Hermann Vosseler <Ichthyostega@web.de>

4
tests/components/proc/mobject/session/testclip.hpp
View file

@ -1,5 +1,5 @@
/*
TESTCLIP.hpp - test clip (stub) for checking EDL/Session functionality
TESTCLIP.hpp - test clip (stub) for checking Model/Session functionality
Copyright (C) Lumiera.org
2008, Hermann Vosseler <Ichthyostega@web.de>
@ -43,7 +43,7 @@ namespace test {
/**
* Sample or Test Clip for checking
* various EDL, session and builder operations.
* various model, session and builder operations.
* @todo maybe use this as Mock object to record invoked operations?
*
*/

2
tests/components/proc/mobject/session/testroot.hpp
View file

@ -1,5 +1,5 @@
/*
TESTROOT.hpp - test dummy model root for checking EDL/Session functionality
TESTROOT.hpp - test dummy model root for checking Model/Session functionality
Copyright (C) Lumiera.org
2009, Hermann Vosseler <Ichthyostega@web.de>

6
tests/lib/visitingtoolconcept.cpp
View file

@ -22,7 +22,7 @@
/** @file visitingtoolconept.cpp
** While laying the foundations for EDL and Builder, Ichthyo came accross
** While laying the foundations for Session and Builder, Ichthyo came across
** the necessity to create a custom implementation of the Visitor Pattern
** optimally suited for Lumiera's needs. This implementation file was
** used for the draft and is self-contained. The final solution was then
@ -35,7 +35,7 @@
** <li>Visitor is about <i>double dispatch</i>, thus we can't avoid
** using some table lookup implementation, and we can't avoid using
** some of the cooperating classes vtables. Besides that, the
** implementation should not be too wastefull...</li>
** implementation should not be too wasteful...</li>
** <li>individual Visiting Tool implementation classes should be able
** to opt in or opt out on implementing functions treating some of
** the visitable subclasses.</li>
@ -48,7 +48,7 @@
**
** @see visitor.hpp the final lib implementation
** @see visitingtooltest.cpp test cases using our lib implementation
** @see BuilderTool one especially important instantiiation
** @see BuilderTool one especially important instantiation
**
*/