segment_info.h

Go to the documentation of this file.

/* Tide
 *
 * Header for the SegmentInfo element.
 *
 * Copyright 2011 Geoffrey Biggs geoffrey.biggs@aist.go.jp
 *     RT-Synthesis Research Group
 *     Intelligent Systems Research Institute,
 *     National Institute of Advanced Industrial Science and Technology (AIST),
 *     Japan
 *     All rights reserved.
 *
 * This file is part of Tide.
 *
 * Tide is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2.1 of the License, or
 * (at your option) any later version.
 *
 * Tide 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 Lesser General Public
 * License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with Tide. If not, see <http://www.gnu.org/licenses/>.
 */

#if !defined(TIDE_SEGMENT_INFO_H_)
#define TIDE_SEGMENT_INFO_H_

#include <tide/binary_element.h>
#include <tide/date_element.h>
#include <tide/el_ids.h>
#include <tide/float_element.h>
#include <tide/master_element.h>
#include <tide/string_element.h>
#include <tide/uint_element.h>
#include <tide/win_dll.h>
#include <vector>


namespace tide
{
    class TIDE_EXPORT SegmentInfo : public MasterElement
    {
        public:
            SegmentInfo();

            virtual ~SegmentInfo() {}

            std::vector<char> uid() const { return uid_.value(); }
            void uid(std::vector<char> const& uid);

            std::string filename() const { return seg_fn_.value(); }
            void filename(std::string const& filename);

            std::vector<char> prev_uid() const { return prev_uid_.value(); }
            void prev_uid(std::vector<char> const& uid);
            std::string prev_filename() const { return prev_fn_.value(); }
            void prev_filename(std::string const& filename);

            std::vector<char> next_uid() const { return next_uid_.value(); }
            void next_uid(std::vector<char> const& uid);
            std::string next_filename() const { return next_fn_.value(); }
            void next_filename(std::string const& filename);

            std::vector<char> segment_family() const
            { return seg_fam_.value(); }
            void segment_family(std::vector<char> const& segment_family);

            uint64_t timecode_scale() const { return tc_scale_.value(); }
            void timecode_scale(uint64_t scale);

            double duration() const { return duration_.value(); }
            void duration(double duration);

            int64_t date() const { return date_.value(); }
            void date(int64_t date);

            std::string title() const { return title_.value(); }
            void title(std::string const& title);

            std::string muxing_app() const { return muxer_.value(); }
            void muxing_app(std::string const& muxing_app);

            std::string writing_app() const { return writer_.value(); }
            void writing_app(std::string const& writing_app);

            virtual std::streamsize write_body(std::ostream& output);

        protected:
            BinaryElement uid_;
            bool have_uid_;
            StringElement seg_fn_;
            bool have_seg_fn_;
            BinaryElement prev_uid_;
            bool have_prev_uid_;
            StringElement prev_fn_;
            bool have_prev_fn_;
            BinaryElement next_uid_;
            bool have_next_uid_;
            StringElement next_fn_;
            bool have_next_fn_;
            BinaryElement seg_fam_;
            bool have_seg_fam_;
            // TimecodeScale is a mandatory element, so no boolean is needed
            UIntElement tc_scale_;
            FloatElement duration_;
            bool have_duration_;
            DateElement date_;
            bool have_date_;
            StringElement title_;
            bool have_title_;
            StringElement muxer_;
            bool have_muxer_;
            StringElement writer_;
            bool have_writer_;

            virtual std::streamsize body_size() const;

            virtual std::streamsize read_body(std::istream& input,
                    std::streamsize size);

            void reset();
    }; // class SegmentInfo
}; // namespace tide


#endif // TIDE_SEGMENT_INFO_H_