aboutsummaryrefslogtreecommitdiffstats
path: root/src/libdash/source/mpd/AdaptationSet.h
blob: 5a17cf4a16931b6de0cf4aff3b6b0a9cf76d654c (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
/*
 * AdaptationSet.h
 *****************************************************************************
 * Copyright (C) 2012, bitmovin Softwareentwicklung OG, All Rights Reserved
 *
 * Email: libdash-dev@vicky.bitmovin.net
 *
 * This source code and its use and distribution, is subject to the terms
 * and conditions of the applicable license agreement.
 *****************************************************************************/

#ifndef ADAPTATIONSET_H_
#define ADAPTATIONSET_H_

#include "config.h"

#include "IAdaptationSet.h"
#include "RepresentationBase.h"
#include "BaseUrl.h"
#include "SegmentBase.h"
#include "SegmentList.h"
#include "SegmentTemplate.h"
#include "ContentComponent.h"
#include "Representation.h"

namespace dash
{
    namespace mpd
    {
        class AdaptationSet : public IAdaptationSet, public RepresentationBase
        {
            public:
                AdaptationSet           ();
                virtual ~AdaptationSet  ();

                const std::vector<IDescriptor *>&       GetAccessibility                ()  const;
                const std::vector<IDescriptor *>&       GetRole                         ()  const;
                const std::vector<IDescriptor *>&       GetRating                       ()  const;
                const std::vector<IDescriptor *>&       GetViewpoint                    ()  const;
                const std::vector<IContentComponent *>& GetContentComponent             ()  const;
                const std::vector<IBaseUrl *>&          GetBaseURLs                     ()  const;
                ISegmentBase*                           GetSegmentBase                  ()  const;
                ISegmentList*                           GetSegmentList                  ()  const;
                ISegmentTemplate*                       GetSegmentTemplate              ()  const;
                const std::vector<IRepresentation *>&   GetRepresentation               ()  const;
                const std::string&                      GetXlinkHref                    ()  const;
                const std::string&                      GetXlinkActuate                 ()  const;
                uint32_t                                GetId                           ()  const;
                uint32_t                                GetGroup                        ()  const;
                const std::string&                      GetLang                         ()  const;
                const std::string&                      GetContentType                  ()  const;
                const std::string&                      GetPar                          ()  const;
                uint32_t                                GetMinBandwidth                 ()  const;
                uint32_t                                GetMaxBandwidth                 ()  const;
                uint32_t                                GetMinWidth                     ()  const;
                uint32_t                                GetMaxWidth                     ()  const;
                uint32_t                                GetMinHeight                    ()  const;
                uint32_t                                GetMaxHeight                    ()  const;
                const std::string&                      GetMinFramerate                 ()  const;
                const std::string&                      GetMaxFramerate                 ()  const;
                bool                                    SegmentAlignmentIsBoolValue     ()  const;
                bool                                    HasSegmentAlignment             ()  const;
                uint32_t                                GetSegmentAligment              ()  const;
                bool                                    SubsegmentAlignmentIsBoolValue  ()  const;
                bool                                    HasSubsegmentAlignment          ()  const;
                uint32_t                                GetSubsegmentAlignment          ()  const;
                uint8_t                                 GetSubsegmentStartsWithSAP      ()  const;
                bool                                    GetBitstreamSwitching           ()  const;

                void    AddAccessibity              (Descriptor *accessibility);
                void    AddRole                     (Descriptor *role);
                void    AddRating                   (Descriptor *rating);
                void    AddViewpoint                (Descriptor *viewpoint);
                void    AddContentComponent         (ContentComponent *contentComponent);
                void    AddBaseURL                  (BaseUrl *baseURL);
                void    SetSegmentBase              (SegmentBase *segmentBase);
                void    SetSegmentList              (SegmentList *segmentList);
                void    SetSegmentTemplate          (SegmentTemplate *segmentTemplate);
                void    AddRepresentation           (Representation* representation);
                void    SetXlinkHref                (const std::string& xlinkHref);
                void    SetXlinkActuate             (const std::string& xlinkActuate);
                void    SetId                       (uint32_t id);
                void    SetGroup                    (uint32_t group);
                void    SetLang                     (const std::string& lang);
                void    SetContentType              (const std::string& contentType);
                void    SetPar                      (const std::string& par);
                void    SetMinBandwidth             (uint32_t minBandwidth);
                void    SetMaxBandwidth             (uint32_t maxBandwidth);
                void    SetMinWidth                 (uint32_t minWidth);
                void    SetMaxWidth                 (uint32_t maxWidth);
                void    SetMinHeight                (uint32_t minHeight);
                void    SetMaxHeight                (uint32_t maxHeight);
                void    SetMinFramerate             (const std::string& minFramerate);
                void    SetMaxFramerate             (const std::string& maxFramerate);
                void    SetSegmentAlignment         (const std::string& segmentAlignment);
                void    SetSubsegmentAlignment      (const std::string& subsegmentAlignment);
                void    SetSubsegmentStartsWithSAP  (uint8_t subsegmentStartsWithSAP);
                void    SetBitstreamSwitching       (bool value);

            private:
                std::vector<Descriptor *>       accessibility;
                std::vector<Descriptor *>       role;
                std::vector<Descriptor *>       rating;
                std::vector<Descriptor *>       viewpoint;
                std::vector<ContentComponent *> contentComponent;
                std::vector<BaseUrl *>          baseURLs;
                SegmentBase                     *segmentBase;
                SegmentList                     *segmentList;
                SegmentTemplate                 *segmentTemplate;
                std::vector<Representation *>   representation;
                std::string                     xlinkHref;
                std::string                     xlinkActuate;
                uint32_t                        id;
                uint32_t                        group;
                std::string                     lang;
                std::string                     contentType;
                std::string                     par;
                uint32_t                        minBandwidth;
                uint32_t                        maxBandwidth;
                uint32_t                        minWidth;
                uint32_t                        maxWidth;
                uint32_t                        minHeight;
                uint32_t                        maxHeight;
                std::string                     minFramerate;
                std::string                     maxFramerate;
                bool                            segmentAlignmentIsBool;
                bool                            subsegmentAlignmentIsBool;
                bool                            usesSegmentAlignment;
                bool                            usesSubsegmentAlignment;
                uint32_t                        segmentAlignment;
                uint32_t                        subsegmentAlignment;
                uint8_t                         subsegmentStartsWithSAP;
                bool                            isBitstreamSwitching;
        };
    }
}

#endif /* ADAPTATIONSET_H_ */