1585346868/aliyun-openapi-cpp-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Release MergeVideoModelFace.

Browse Source
This commit is contained in:
sdk-team
2022-11-10 09:00:12 +00:00
parent 6de92913f1
commit 43fef9b25b
37 changed files with 1505 additions and 1825 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
VERSION
View File

@@ -1 +1 @@
1.36.1331
1.36.1332

92
videoenhan/include/alibabacloud/videoenhan/model/AbstractEcommerceVideoRequest.h
View File

@@ -1,60 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VIDEOENHAN_MODEL_ABSTRACTECOMMERCEVIDEOREQUEST_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_ABSTRACTECOMMERCEVIDEOREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/videoenhan/VideoenhanExport.h>
namespace AlibabaCloud
{
namespace Videoenhan
{
namespace Model
{
class ALIBABACLOUD_VIDEOENHAN_EXPORT AbstractEcommerceVideoRequest : public RpcServiceRequest
{
public:
AbstractEcommerceVideoRequest();
~AbstractEcommerceVideoRequest();
float getDuration()const;
void setDuration(float duration);
int getHeight()const;
void setHeight(int height);
bool getAsync()const;
void setAsync(bool async);
std::string getVideoUrl()const;
void setVideoUrl(const std::string& videoUrl);
int getWidth()const;
void setWidth(int width);
private:
float duration_;
int height_;
bool async_;
std::string videoUrl_;
int width_;
};
}
}
}
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_ABSTRACTECOMMERCEVIDEOREQUEST_H_
*/
#ifndef ALIBABACLOUD_VIDEOENHAN_MODEL_ABSTRACTECOMMERCEVIDEOREQUEST_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_ABSTRACTECOMMERCEVIDEOREQUEST_H_
#include <alibabacloud/videoenhan/VideoenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Videoenhan {
namespace Model {
class ALIBABACLOUD_VIDEOENHAN_EXPORT AbstractEcommerceVideoRequest : public RpcServiceRequest {
public:
AbstractEcommerceVideoRequest();
~AbstractEcommerceVideoRequest();
float getDuration() const;
void setDuration(float duration);
int getHeight() const;
void setHeight(int height);
bool getAsync() const;
void setAsync(bool async);
std::string getVideoUrl() const;
void setVideoUrl(const std::string &videoUrl);
int getWidth() const;
void setWidth(int width);
private:
float duration_;
int height_;
bool async_;
std::string videoUrl_;
int width_;
};
} // namespace Model
} // namespace Videoenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_ABSTRACTECOMMERCEVIDEOREQUEST_H_

80
videoenhan/include/alibabacloud/videoenhan/model/AbstractFilmVideoRequest.h
View File

@@ -1,54 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VIDEOENHAN_MODEL_ABSTRACTFILMVIDEOREQUEST_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_ABSTRACTFILMVIDEOREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/videoenhan/VideoenhanExport.h>
namespace AlibabaCloud
{
namespace Videoenhan
{
namespace Model
{
class ALIBABACLOUD_VIDEOENHAN_EXPORT AbstractFilmVideoRequest : public RpcServiceRequest
{
public:
AbstractFilmVideoRequest();
~AbstractFilmVideoRequest();
int getLength()const;
void setLength(int length);
bool getAsync()const;
void setAsync(bool async);
std::string getVideoUrl()const;
void setVideoUrl(const std::string& videoUrl);
private:
int length_;
bool async_;
std::string videoUrl_;
};
}
}
}
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_ABSTRACTFILMVIDEOREQUEST_H_
*/
#ifndef ALIBABACLOUD_VIDEOENHAN_MODEL_ABSTRACTFILMVIDEOREQUEST_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_ABSTRACTFILMVIDEOREQUEST_H_
#include <alibabacloud/videoenhan/VideoenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Videoenhan {
namespace Model {
class ALIBABACLOUD_VIDEOENHAN_EXPORT AbstractFilmVideoRequest : public RpcServiceRequest {
public:
AbstractFilmVideoRequest();
~AbstractFilmVideoRequest();
int getLength() const;
void setLength(int length);
bool getAsync() const;
void setAsync(bool async);
std::string getVideoUrl() const;
void setVideoUrl(const std::string &videoUrl);
private:
int length_;
bool async_;
std::string videoUrl_;
};
} // namespace Model
} // namespace Videoenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_ABSTRACTFILMVIDEOREQUEST_H_

80
videoenhan/include/alibabacloud/videoenhan/model/AddFaceVideoTemplateRequest.h
View File

@@ -1,54 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VIDEOENHAN_MODEL_ADDFACEVIDEOTEMPLATEREQUEST_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_ADDFACEVIDEOTEMPLATEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/videoenhan/VideoenhanExport.h>
namespace AlibabaCloud
{
namespace Videoenhan
{
namespace Model
{
class ALIBABACLOUD_VIDEOENHAN_EXPORT AddFaceVideoTemplateRequest : public RpcServiceRequest
{
public:
AddFaceVideoTemplateRequest();
~AddFaceVideoTemplateRequest();
std::string getUserId()const;
void setUserId(const std::string& userId);
bool getAsync()const;
void setAsync(bool async);
std::string getVideoURL()const;
void setVideoURL(const std::string& videoURL);
private:
std::string userId_;
bool async_;
std::string videoURL_;
};
}
}
}
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_ADDFACEVIDEOTEMPLATEREQUEST_H_
*/
#ifndef ALIBABACLOUD_VIDEOENHAN_MODEL_ADDFACEVIDEOTEMPLATEREQUEST_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_ADDFACEVIDEOTEMPLATEREQUEST_H_
#include <alibabacloud/videoenhan/VideoenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Videoenhan {
namespace Model {
class ALIBABACLOUD_VIDEOENHAN_EXPORT AddFaceVideoTemplateRequest : public RpcServiceRequest {
public:
AddFaceVideoTemplateRequest();
~AddFaceVideoTemplateRequest();
std::string getUserId() const;
void setUserId(const std::string &userId);
bool getAsync() const;
void setAsync(bool async);
std::string getVideoURL() const;
void setVideoURL(const std::string &videoURL);
private:
std::string userId_;
bool async_;
std::string videoURL_;
};
} // namespace Model
} // namespace Videoenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_ADDFACEVIDEOTEMPLATEREQUEST_H_

98
videoenhan/include/alibabacloud/videoenhan/model/AdjustVideoColorRequest.h
View File

@@ -1,63 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VIDEOENHAN_MODEL_ADJUSTVIDEOCOLORREQUEST_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_ADJUSTVIDEOCOLORREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/videoenhan/VideoenhanExport.h>
namespace AlibabaCloud
{
namespace Videoenhan
{
namespace Model
{
class ALIBABACLOUD_VIDEOENHAN_EXPORT AdjustVideoColorRequest : public RpcServiceRequest
{
public:
AdjustVideoColorRequest();
~AdjustVideoColorRequest();
std::string getMode()const;
void setMode(const std::string& mode);
bool getAsync()const;
void setAsync(bool async);
std::string getVideoUrl()const;
void setVideoUrl(const std::string& videoUrl);
long getVideoBitrate()const;
void setVideoBitrate(long videoBitrate);
std::string getVideoCodec()const;
void setVideoCodec(const std::string& videoCodec);
std::string getVideoFormat()const;
void setVideoFormat(const std::string& videoFormat);
private:
std::string mode_;
bool async_;
std::string videoUrl_;
long videoBitrate_;
std::string videoCodec_;
std::string videoFormat_;
};
}
}
}
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_ADJUSTVIDEOCOLORREQUEST_H_
*/
#ifndef ALIBABACLOUD_VIDEOENHAN_MODEL_ADJUSTVIDEOCOLORREQUEST_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_ADJUSTVIDEOCOLORREQUEST_H_
#include <alibabacloud/videoenhan/VideoenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Videoenhan {
namespace Model {
class ALIBABACLOUD_VIDEOENHAN_EXPORT AdjustVideoColorRequest : public RpcServiceRequest {
public:
AdjustVideoColorRequest();
~AdjustVideoColorRequest();
std::string getMode() const;
void setMode(const std::string &mode);
bool getAsync() const;
void setAsync(bool async);
std::string getVideoUrl() const;
void setVideoUrl(const std::string &videoUrl);
long getVideoBitrate() const;
void setVideoBitrate(long videoBitrate);
std::string getVideoCodec() const;
void setVideoCodec(const std::string &videoCodec);
std::string getVideoFormat() const;
void setVideoFormat(const std::string &videoFormat);
private:
std::string mode_;
bool async_;
std::string videoUrl_;
long videoBitrate_;
std::string videoCodec_;
std::string videoFormat_;
};
} // namespace Model
} // namespace Videoenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_ADJUSTVIDEOCOLORREQUEST_H_

122
videoenhan/include/alibabacloud/videoenhan/model/ChangeVideoSizeRequest.h
View File

@@ -1,75 +1,69 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VIDEOENHAN_MODEL_CHANGEVIDEOSIZEREQUEST_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_CHANGEVIDEOSIZEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/videoenhan/VideoenhanExport.h>
namespace AlibabaCloud
{
namespace Videoenhan
{
namespace Model
{
class ALIBABACLOUD_VIDEOENHAN_EXPORT ChangeVideoSizeRequest : public RpcServiceRequest
{
public:
ChangeVideoSizeRequest();
~ChangeVideoSizeRequest();
int getHeight()const;
void setHeight(int height);
int getB()const;
void setB(int b);
std::string getFillType()const;
void setFillType(const std::string& fillType);
int getG()const;
void setG(int g);
std::string getCropType()const;
void setCropType(const std::string& cropType);
bool getAsync()const;
void setAsync(bool async);
int getR()const;
void setR(int r);
std::string getVideoUrl()const;
void setVideoUrl(const std::string& videoUrl);
int getWidth()const;
void setWidth(int width);
float getTightness()const;
void setTightness(float tightness);
private:
int height_;
int b_;
std::string fillType_;
int g_;
std::string cropType_;
bool async_;
int r_;
std::string videoUrl_;
int width_;
float tightness_;
};
}
}
}
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_CHANGEVIDEOSIZEREQUEST_H_
*/
#ifndef ALIBABACLOUD_VIDEOENHAN_MODEL_CHANGEVIDEOSIZEREQUEST_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_CHANGEVIDEOSIZEREQUEST_H_
#include <alibabacloud/videoenhan/VideoenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Videoenhan {
namespace Model {
class ALIBABACLOUD_VIDEOENHAN_EXPORT ChangeVideoSizeRequest : public RpcServiceRequest {
public:
ChangeVideoSizeRequest();
~ChangeVideoSizeRequest();
int getHeight() const;
void setHeight(int height);
int getB() const;
void setB(int b);
std::string getFillType() const;
void setFillType(const std::string &fillType);
int getG() const;
void setG(int g);
std::string getCropType() const;
void setCropType(const std::string &cropType);
bool getAsync() const;
void setAsync(bool async);
int getR() const;
void setR(int r);
std::string getVideoUrl() const;
void setVideoUrl(const std::string &videoUrl);
int getWidth() const;
void setWidth(int width);
float getTightness() const;
void setTightness(float tightness);
private:
int height_;
int b_;
std::string fillType_;
int g_;
std::string cropType_;
bool async_;
int r_;
std::string videoUrl_;
int width_;
float tightness_;
};
} // namespace Model
} // namespace Videoenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_CHANGEVIDEOSIZEREQUEST_H_

92
videoenhan/include/alibabacloud/videoenhan/model/ConvertHdrVideoRequest.h
View File

@@ -1,60 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VIDEOENHAN_MODEL_CONVERTHDRVIDEOREQUEST_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_CONVERTHDRVIDEOREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/videoenhan/VideoenhanExport.h>
namespace AlibabaCloud
{
namespace Videoenhan
{
namespace Model
{
class ALIBABACLOUD_VIDEOENHAN_EXPORT ConvertHdrVideoRequest : public RpcServiceRequest
{
public:
ConvertHdrVideoRequest();
~ConvertHdrVideoRequest();
std::string getHDRFormat()const;
void setHDRFormat(const std::string& hDRFormat);
int getMaxIlluminance()const;
void setMaxIlluminance(int maxIlluminance);
int getBitrate()const;
void setBitrate(int bitrate);
bool getAsync()const;
void setAsync(bool async);
std::string getVideoURL()const;
void setVideoURL(const std::string& videoURL);
private:
std::string hDRFormat_;
int maxIlluminance_;
int bitrate_;
bool async_;
std::string videoURL_;
};
}
}
}
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_CONVERTHDRVIDEOREQUEST_H_
*/
#ifndef ALIBABACLOUD_VIDEOENHAN_MODEL_CONVERTHDRVIDEOREQUEST_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_CONVERTHDRVIDEOREQUEST_H_
#include <alibabacloud/videoenhan/VideoenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Videoenhan {
namespace Model {
class ALIBABACLOUD_VIDEOENHAN_EXPORT ConvertHdrVideoRequest : public RpcServiceRequest {
public:
ConvertHdrVideoRequest();
~ConvertHdrVideoRequest();
std::string getHDRFormat() const;
void setHDRFormat(const std::string &hDRFormat);
int getMaxIlluminance() const;
void setMaxIlluminance(int maxIlluminance);
int getBitrate() const;
void setBitrate(int bitrate);
bool getAsync() const;
void setAsync(bool async);
std::string getVideoURL() const;
void setVideoURL(const std::string &videoURL);
private:
std::string hDRFormat_;
int maxIlluminance_;
int bitrate_;
bool async_;
std::string videoURL_;
};
} // namespace Model
} // namespace Videoenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_CONVERTHDRVIDEOREQUEST_H_

74
videoenhan/include/alibabacloud/videoenhan/model/DeleteFaceVideoTemplateRequest.h
View File

@@ -1,51 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VIDEOENHAN_MODEL_DELETEFACEVIDEOTEMPLATEREQUEST_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_DELETEFACEVIDEOTEMPLATEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/videoenhan/VideoenhanExport.h>
namespace AlibabaCloud
{
namespace Videoenhan
{
namespace Model
{
class ALIBABACLOUD_VIDEOENHAN_EXPORT DeleteFaceVideoTemplateRequest : public RpcServiceRequest
{
public:
DeleteFaceVideoTemplateRequest();
~DeleteFaceVideoTemplateRequest();
std::string getUserId()const;
void setUserId(const std::string& userId);
std::string getTemplateId()const;
void setTemplateId(const std::string& templateId);
private:
std::string userId_;
std::string templateId_;
};
}
}
}
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_DELETEFACEVIDEOTEMPLATEREQUEST_H_
*/
#ifndef ALIBABACLOUD_VIDEOENHAN_MODEL_DELETEFACEVIDEOTEMPLATEREQUEST_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_DELETEFACEVIDEOTEMPLATEREQUEST_H_
#include <alibabacloud/videoenhan/VideoenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Videoenhan {
namespace Model {
class ALIBABACLOUD_VIDEOENHAN_EXPORT DeleteFaceVideoTemplateRequest : public RpcServiceRequest {
public:
DeleteFaceVideoTemplateRequest();
~DeleteFaceVideoTemplateRequest();
std::string getUserId() const;
void setUserId(const std::string &userId);
std::string getTemplateId() const;
void setTemplateId(const std::string &templateId);
private:
std::string userId_;
std::string templateId_;
};
} // namespace Model
} // namespace Videoenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_DELETEFACEVIDEOTEMPLATEREQUEST_H_

110
videoenhan/include/alibabacloud/videoenhan/model/EnhanceVideoQualityRequest.h
View File

@@ -1,69 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VIDEOENHAN_MODEL_ENHANCEVIDEOQUALITYREQUEST_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_ENHANCEVIDEOQUALITYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/videoenhan/VideoenhanExport.h>
namespace AlibabaCloud
{
namespace Videoenhan
{
namespace Model
{
class ALIBABACLOUD_VIDEOENHAN_EXPORT EnhanceVideoQualityRequest : public RpcServiceRequest
{
public:
EnhanceVideoQualityRequest();
~EnhanceVideoQualityRequest();
std::string getHDRFormat()const;
void setHDRFormat(const std::string& hDRFormat);
int getFrameRate()const;
void setFrameRate(int frameRate);
int getMaxIlluminance()const;
void setMaxIlluminance(int maxIlluminance);
int getBitrate()const;
void setBitrate(int bitrate);
int getOutPutWidth()const;
void setOutPutWidth(int outPutWidth);
int getOutPutHeight()const;
void setOutPutHeight(int outPutHeight);
bool getAsync()const;
void setAsync(bool async);
std::string getVideoURL()const;
void setVideoURL(const std::string& videoURL);
private:
std::string hDRFormat_;
int frameRate_;
int maxIlluminance_;
int bitrate_;
int outPutWidth_;
int outPutHeight_;
bool async_;
std::string videoURL_;
};
}
}
}
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_ENHANCEVIDEOQUALITYREQUEST_H_
*/
#ifndef ALIBABACLOUD_VIDEOENHAN_MODEL_ENHANCEVIDEOQUALITYREQUEST_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_ENHANCEVIDEOQUALITYREQUEST_H_
#include <alibabacloud/videoenhan/VideoenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Videoenhan {
namespace Model {
class ALIBABACLOUD_VIDEOENHAN_EXPORT EnhanceVideoQualityRequest : public RpcServiceRequest {
public:
EnhanceVideoQualityRequest();
~EnhanceVideoQualityRequest();
std::string getHDRFormat() const;
void setHDRFormat(const std::string &hDRFormat);
int getFrameRate() const;
void setFrameRate(int frameRate);
int getMaxIlluminance() const;
void setMaxIlluminance(int maxIlluminance);
int getBitrate() const;
void setBitrate(int bitrate);
int getOutPutWidth() const;
void setOutPutWidth(int outPutWidth);
int getOutPutHeight() const;
void setOutPutHeight(int outPutHeight);
bool getAsync() const;
void setAsync(bool async);
std::string getVideoURL() const;
void setVideoURL(const std::string &videoURL);
private:
std::string hDRFormat_;
int frameRate_;
int maxIlluminance_;
int bitrate_;
int outPutWidth_;
int outPutHeight_;
bool async_;
std::string videoURL_;
};
} // namespace Model
} // namespace Videoenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_ENHANCEVIDEOQUALITYREQUEST_H_

94
videoenhan/include/alibabacloud/videoenhan/model/EraseVideoLogoRequest.h
View File

@@ -1,62 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VIDEOENHAN_MODEL_ERASEVIDEOLOGOREQUEST_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_ERASEVIDEOLOGOREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/videoenhan/VideoenhanExport.h>
namespace AlibabaCloud
{
namespace Videoenhan
{
namespace Model
{
class ALIBABACLOUD_VIDEOENHAN_EXPORT EraseVideoLogoRequest : public RpcServiceRequest
{
public:
struct Boxes
{
float w;
float h;
float x;
float y;
};
public:
EraseVideoLogoRequest();
~EraseVideoLogoRequest();
std::vector<Boxes> getBoxes()const;
void setBoxes(const std::vector<Boxes>& boxes);
bool getAsync()const;
void setAsync(bool async);
std::string getVideoUrl()const;
void setVideoUrl(const std::string& videoUrl);
private:
std::vector<Boxes> boxes_;
bool async_;
std::string videoUrl_;
};
}
}
}
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_ERASEVIDEOLOGOREQUEST_H_
*/
#ifndef ALIBABACLOUD_VIDEOENHAN_MODEL_ERASEVIDEOLOGOREQUEST_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_ERASEVIDEOLOGOREQUEST_H_
#include <alibabacloud/videoenhan/VideoenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Videoenhan {
namespace Model {
class ALIBABACLOUD_VIDEOENHAN_EXPORT EraseVideoLogoRequest : public RpcServiceRequest {
public:
struct Boxes {
float w;
float h;
float x;
float y;
};
EraseVideoLogoRequest();
~EraseVideoLogoRequest();
std::vector<Boxes> getBoxes() const;
void setBoxes(const std::vector<Boxes> &boxes);
bool getAsync() const;
void setAsync(bool async);
std::string getVideoUrl() const;
void setVideoUrl(const std::string &videoUrl);
private:
std::vector<Boxes> boxes_;
bool async_;
std::string videoUrl_;
};
} // namespace Model
} // namespace Videoenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_ERASEVIDEOLOGOREQUEST_H_

98
videoenhan/include/alibabacloud/videoenhan/model/EraseVideoSubtitlesRequest.h
View File

@@ -1,63 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VIDEOENHAN_MODEL_ERASEVIDEOSUBTITLESREQUEST_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_ERASEVIDEOSUBTITLESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/videoenhan/VideoenhanExport.h>
namespace AlibabaCloud
{
namespace Videoenhan
{
namespace Model
{
class ALIBABACLOUD_VIDEOENHAN_EXPORT EraseVideoSubtitlesRequest : public RpcServiceRequest
{
public:
EraseVideoSubtitlesRequest();
~EraseVideoSubtitlesRequest();
float getBH()const;
void setBH(float bH);
float getBW()const;
void setBW(float bW);
float getBX()const;
void setBX(float bX);
float getBY()const;
void setBY(float bY);
bool getAsync()const;
void setAsync(bool async);
std::string getVideoUrl()const;
void setVideoUrl(const std::string& videoUrl);
private:
float bH_;
float bW_;
float bX_;
float bY_;
bool async_;
std::string videoUrl_;
};
}
}
}
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_ERASEVIDEOSUBTITLESREQUEST_H_
*/
#ifndef ALIBABACLOUD_VIDEOENHAN_MODEL_ERASEVIDEOSUBTITLESREQUEST_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_ERASEVIDEOSUBTITLESREQUEST_H_
#include <alibabacloud/videoenhan/VideoenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Videoenhan {
namespace Model {
class ALIBABACLOUD_VIDEOENHAN_EXPORT EraseVideoSubtitlesRequest : public RpcServiceRequest {
public:
EraseVideoSubtitlesRequest();
~EraseVideoSubtitlesRequest();
float getBH() const;
void setBH(float bH);
float getBW() const;
void setBW(float bW);
float getBX() const;
void setBX(float bX);
float getBY() const;
void setBY(float bY);
bool getAsync() const;
void setAsync(bool async);
std::string getVideoUrl() const;
void setVideoUrl(const std::string &videoUrl);
private:
float bH_;
float bW_;
float bX_;
float bY_;
bool async_;
std::string videoUrl_;
};
} // namespace Model
} // namespace Videoenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_ERASEVIDEOSUBTITLESREQUEST_H_

146
videoenhan/include/alibabacloud/videoenhan/model/GenerateVideoRequest.h
View File

@@ -1,88 +1,80 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VIDEOENHAN_MODEL_GENERATEVIDEOREQUEST_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_GENERATEVIDEOREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/videoenhan/VideoenhanExport.h>
namespace AlibabaCloud
{
namespace Videoenhan
{
namespace Model
{
class ALIBABACLOUD_VIDEOENHAN_EXPORT GenerateVideoRequest : public RpcServiceRequest
{
public:
struct FileList
{
std::string fileName;
std::string fileUrl;
std::string type;
};
public:
GenerateVideoRequest();
~GenerateVideoRequest();
std::string getTransitionStyle()const;
void setTransitionStyle(const std::string& transitionStyle);
std::string getScene()const;
void setScene(const std::string& scene);
float getDuration()const;
void setDuration(float duration);
bool getPuzzleEffect()const;
void setPuzzleEffect(bool puzzleEffect);
int getHeight()const;
void setHeight(int height);
bool getDurationAdaption()const;
void setDurationAdaption(bool durationAdaption);
std::vector<FileList> getFileList()const;
void setFileList(const std::vector<FileList>& fileList);
bool getMute()const;
void setMute(bool mute);
bool getAsync()const;
void setAsync(bool async);
bool getSmartEffect()const;
void setSmartEffect(bool smartEffect);
int getWidth()const;
void setWidth(int width);
std::string getStyle()const;
void setStyle(const std::string& style);
private:
std::string transitionStyle_;
std::string scene_;
float duration_;
bool puzzleEffect_;
int height_;
bool durationAdaption_;
std::vector<FileList> fileList_;
bool mute_;
bool async_;
bool smartEffect_;
int width_;
std::string style_;
};
}
}
}
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_GENERATEVIDEOREQUEST_H_
*/
#ifndef ALIBABACLOUD_VIDEOENHAN_MODEL_GENERATEVIDEOREQUEST_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_GENERATEVIDEOREQUEST_H_
#include <alibabacloud/videoenhan/VideoenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Videoenhan {
namespace Model {
class ALIBABACLOUD_VIDEOENHAN_EXPORT GenerateVideoRequest : public RpcServiceRequest {
public:
struct FileList {
std::string fileName;
std::string fileUrl;
std::string type;
};
GenerateVideoRequest();
~GenerateVideoRequest();
std::string getTransitionStyle() const;
void setTransitionStyle(const std::string &transitionStyle);
std::string getScene() const;
void setScene(const std::string &scene);
float getDuration() const;
void setDuration(float duration);
bool getPuzzleEffect() const;
void setPuzzleEffect(bool puzzleEffect);
int getHeight() const;
void setHeight(int height);
bool getDurationAdaption() const;
void setDurationAdaption(bool durationAdaption);
std::vector<FileList> getFileList() const;
void setFileList(const std::vector<FileList> &fileList);
bool getMute() const;
void setMute(bool mute);
bool getAsync() const;
void setAsync(bool async);
bool getSmartEffect() const;
void setSmartEffect(bool smartEffect);
int getWidth() const;
void setWidth(int width);
std::string getStyle() const;
void setStyle(const std::string &style);
private:
std::string transitionStyle_;
std::string scene_;
float duration_;
bool puzzleEffect_;
int height_;
bool durationAdaption_;
std::vector<FileList> fileList_;
bool mute_;
bool async_;
bool smartEffect_;
int width_;
std::string style_;
};
} // namespace Model
} // namespace Videoenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_GENERATEVIDEOREQUEST_H_

74
videoenhan/include/alibabacloud/videoenhan/model/GetAsyncJobResultRequest.h
View File

@@ -1,51 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VIDEOENHAN_MODEL_GETASYNCJOBRESULTREQUEST_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_GETASYNCJOBRESULTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/videoenhan/VideoenhanExport.h>
namespace AlibabaCloud
{
namespace Videoenhan
{
namespace Model
{
class ALIBABACLOUD_VIDEOENHAN_EXPORT GetAsyncJobResultRequest : public RpcServiceRequest
{
public:
GetAsyncJobResultRequest();
~GetAsyncJobResultRequest();
std::string getJobId()const;
void setJobId(const std::string& jobId);
bool getAsync()const;
void setAsync(bool async);
private:
std::string jobId_;
bool async_;
};
}
}
}
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_GETASYNCJOBRESULTREQUEST_H_
*/
#ifndef ALIBABACLOUD_VIDEOENHAN_MODEL_GETASYNCJOBRESULTREQUEST_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_GETASYNCJOBRESULTREQUEST_H_
#include <alibabacloud/videoenhan/VideoenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Videoenhan {
namespace Model {
class ALIBABACLOUD_VIDEOENHAN_EXPORT GetAsyncJobResultRequest : public RpcServiceRequest {
public:
GetAsyncJobResultRequest();
~GetAsyncJobResultRequest();
std::string getJobId() const;
void setJobId(const std::string &jobId);
bool getAsync() const;
void setAsync(bool async);
private:
std::string jobId_;
bool async_;
};
} // namespace Model
} // namespace Videoenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_GETASYNCJOBRESULTREQUEST_H_

86
videoenhan/include/alibabacloud/videoenhan/model/InterpolateVideoFrameRequest.h
View File

@@ -1,57 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VIDEOENHAN_MODEL_INTERPOLATEVIDEOFRAMEREQUEST_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_INTERPOLATEVIDEOFRAMEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/videoenhan/VideoenhanExport.h>
namespace AlibabaCloud
{
namespace Videoenhan
{
namespace Model
{
class ALIBABACLOUD_VIDEOENHAN_EXPORT InterpolateVideoFrameRequest : public RpcServiceRequest
{
public:
InterpolateVideoFrameRequest();
~InterpolateVideoFrameRequest();
int getFrameRate()const;
void setFrameRate(int frameRate);
int getBitrate()const;
void setBitrate(int bitrate);
bool getAsync()const;
void setAsync(bool async);
std::string getVideoURL()const;
void setVideoURL(const std::string& videoURL);
private:
int frameRate_;
int bitrate_;
bool async_;
std::string videoURL_;
};
}
}
}
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_INTERPOLATEVIDEOFRAMEREQUEST_H_
*/
#ifndef ALIBABACLOUD_VIDEOENHAN_MODEL_INTERPOLATEVIDEOFRAMEREQUEST_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_INTERPOLATEVIDEOFRAMEREQUEST_H_
#include <alibabacloud/videoenhan/VideoenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Videoenhan {
namespace Model {
class ALIBABACLOUD_VIDEOENHAN_EXPORT InterpolateVideoFrameRequest : public RpcServiceRequest {
public:
InterpolateVideoFrameRequest();
~InterpolateVideoFrameRequest();
int getFrameRate() const;
void setFrameRate(int frameRate);
int getBitrate() const;
void setBitrate(int bitrate);
bool getAsync() const;
void setAsync(bool async);
std::string getVideoURL() const;
void setVideoURL(const std::string &videoURL);
private:
int frameRate_;
int bitrate_;
bool async_;
std::string videoURL_;
};
} // namespace Model
} // namespace Videoenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_INTERPOLATEVIDEOFRAMEREQUEST_H_

86
videoenhan/include/alibabacloud/videoenhan/model/MergeVideoFaceRequest.h
View File

@@ -1,57 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VIDEOENHAN_MODEL_MERGEVIDEOFACEREQUEST_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_MERGEVIDEOFACEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/videoenhan/VideoenhanExport.h>
namespace AlibabaCloud
{
namespace Videoenhan
{
namespace Model
{
class ALIBABACLOUD_VIDEOENHAN_EXPORT MergeVideoFaceRequest : public RpcServiceRequest
{
public:
MergeVideoFaceRequest();
~MergeVideoFaceRequest();
std::string getReferenceURL()const;
void setReferenceURL(const std::string& referenceURL);
std::string getPostURL()const;
void setPostURL(const std::string& postURL);
bool getAsync()const;
void setAsync(bool async);
std::string getVideoURL()const;
void setVideoURL(const std::string& videoURL);
private:
std::string referenceURL_;
std::string postURL_;
bool async_;
std::string videoURL_;
};
}
}
}
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_MERGEVIDEOFACEREQUEST_H_
*/
#ifndef ALIBABACLOUD_VIDEOENHAN_MODEL_MERGEVIDEOFACEREQUEST_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_MERGEVIDEOFACEREQUEST_H_
#include <alibabacloud/videoenhan/VideoenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Videoenhan {
namespace Model {
class ALIBABACLOUD_VIDEOENHAN_EXPORT MergeVideoFaceRequest : public RpcServiceRequest {
public:
MergeVideoFaceRequest();
~MergeVideoFaceRequest();
std::string getReferenceURL() const;
void setReferenceURL(const std::string &referenceURL);
std::string getPostURL() const;
void setPostURL(const std::string &postURL);
bool getAsync() const;
void setAsync(bool async);
std::string getVideoURL() const;
void setVideoURL(const std::string &videoURL);
private:
std::string referenceURL_;
std::string postURL_;
bool async_;
std::string videoURL_;
};
} // namespace Model
} // namespace Videoenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_MERGEVIDEOFACEREQUEST_H_

86
videoenhan/include/alibabacloud/videoenhan/model/MergeVideoModelFaceRequest.h
View File

@@ -1,57 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VIDEOENHAN_MODEL_MERGEVIDEOMODELFACEREQUEST_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_MERGEVIDEOMODELFACEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/videoenhan/VideoenhanExport.h>
namespace AlibabaCloud
{
namespace Videoenhan
{
namespace Model
{
class ALIBABACLOUD_VIDEOENHAN_EXPORT MergeVideoModelFaceRequest : public RpcServiceRequest
{
public:
MergeVideoModelFaceRequest();
~MergeVideoModelFaceRequest();
std::string getFaceImageURL()const;
void setFaceImageURL(const std::string& faceImageURL);
std::string getUserId()const;
void setUserId(const std::string& userId);
std::string getTemplateId()const;
void setTemplateId(const std::string& templateId);
std::string getAsync()const;
void setAsync(const std::string& async);
private:
std::string faceImageURL_;
std::string userId_;
std::string templateId_;
std::string async_;
};
}
}
}
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_MERGEVIDEOMODELFACEREQUEST_H_
*/
#ifndef ALIBABACLOUD_VIDEOENHAN_MODEL_MERGEVIDEOMODELFACEREQUEST_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_MERGEVIDEOMODELFACEREQUEST_H_
#include <alibabacloud/videoenhan/VideoenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Videoenhan {
namespace Model {
class ALIBABACLOUD_VIDEOENHAN_EXPORT MergeVideoModelFaceRequest : public RpcServiceRequest {
public:
MergeVideoModelFaceRequest();
~MergeVideoModelFaceRequest();
std::string getFaceImageURL() const;
void setFaceImageURL(const std::string &faceImageURL);
std::string getUserId() const;
void setUserId(const std::string &userId);
std::string getTemplateId() const;
void setTemplateId(const std::string &templateId);
std::string getAsync() const;
void setAsync(const std::string &async);
private:
std::string faceImageURL_;
std::string userId_;
std::string templateId_;
std::string async_;
};
} // namespace Model
} // namespace Videoenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_MERGEVIDEOMODELFACEREQUEST_H_

74
videoenhan/include/alibabacloud/videoenhan/model/QueryFaceVideoTemplateRequest.h
View File

@@ -1,51 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VIDEOENHAN_MODEL_QUERYFACEVIDEOTEMPLATEREQUEST_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_QUERYFACEVIDEOTEMPLATEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/videoenhan/VideoenhanExport.h>
namespace AlibabaCloud
{
namespace Videoenhan
{
namespace Model
{
class ALIBABACLOUD_VIDEOENHAN_EXPORT QueryFaceVideoTemplateRequest : public RpcServiceRequest
{
public:
QueryFaceVideoTemplateRequest();
~QueryFaceVideoTemplateRequest();
std::string getUserId()const;
void setUserId(const std::string& userId);
std::string getTemplateId()const;
void setTemplateId(const std::string& templateId);
private:
std::string userId_;
std::string templateId_;
};
}
}
}
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_QUERYFACEVIDEOTEMPLATEREQUEST_H_
*/
#ifndef ALIBABACLOUD_VIDEOENHAN_MODEL_QUERYFACEVIDEOTEMPLATEREQUEST_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_QUERYFACEVIDEOTEMPLATEREQUEST_H_
#include <alibabacloud/videoenhan/VideoenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Videoenhan {
namespace Model {
class ALIBABACLOUD_VIDEOENHAN_EXPORT QueryFaceVideoTemplateRequest : public RpcServiceRequest {
public:
QueryFaceVideoTemplateRequest();
~QueryFaceVideoTemplateRequest();
std::string getUserId() const;
void setUserId(const std::string &userId);
std::string getTemplateId() const;
void setTemplateId(const std::string &templateId);
private:
std::string userId_;
std::string templateId_;
};
} // namespace Model
} // namespace Videoenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_QUERYFACEVIDEOTEMPLATEREQUEST_H_

80
videoenhan/include/alibabacloud/videoenhan/model/SuperResolveVideoRequest.h
View File

@@ -1,54 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VIDEOENHAN_MODEL_SUPERRESOLVEVIDEOREQUEST_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_SUPERRESOLVEVIDEOREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/videoenhan/VideoenhanExport.h>
namespace AlibabaCloud
{
namespace Videoenhan
{
namespace Model
{
class ALIBABACLOUD_VIDEOENHAN_EXPORT SuperResolveVideoRequest : public RpcServiceRequest
{
public:
SuperResolveVideoRequest();
~SuperResolveVideoRequest();
int getBitRate()const;
void setBitRate(int bitRate);
bool getAsync()const;
void setAsync(bool async);
std::string getVideoUrl()const;
void setVideoUrl(const std::string& videoUrl);
private:
int bitRate_;
bool async_;
std::string videoUrl_;
};
}
}
}
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_SUPERRESOLVEVIDEOREQUEST_H_
*/
#ifndef ALIBABACLOUD_VIDEOENHAN_MODEL_SUPERRESOLVEVIDEOREQUEST_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_SUPERRESOLVEVIDEOREQUEST_H_
#include <alibabacloud/videoenhan/VideoenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Videoenhan {
namespace Model {
class ALIBABACLOUD_VIDEOENHAN_EXPORT SuperResolveVideoRequest : public RpcServiceRequest {
public:
SuperResolveVideoRequest();
~SuperResolveVideoRequest();
int getBitRate() const;
void setBitRate(int bitRate);
bool getAsync() const;
void setAsync(bool async);
std::string getVideoUrl() const;
void setVideoUrl(const std::string &videoUrl);
private:
int bitRate_;
bool async_;
std::string videoUrl_;
};
} // namespace Model
} // namespace Videoenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_SUPERRESOLVEVIDEOREQUEST_H_

86
videoenhan/include/alibabacloud/videoenhan/model/ToneSdrVideoRequest.h
View File

@@ -1,57 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VIDEOENHAN_MODEL_TONESDRVIDEOREQUEST_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_TONESDRVIDEOREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/videoenhan/VideoenhanExport.h>
namespace AlibabaCloud
{
namespace Videoenhan
{
namespace Model
{
class ALIBABACLOUD_VIDEOENHAN_EXPORT ToneSdrVideoRequest : public RpcServiceRequest
{
public:
ToneSdrVideoRequest();
~ToneSdrVideoRequest();
int getBitrate()const;
void setBitrate(int bitrate);
std::string getRecolorModel()const;
void setRecolorModel(const std::string& recolorModel);
bool getAsync()const;
void setAsync(bool async);
std::string getVideoURL()const;
void setVideoURL(const std::string& videoURL);
private:
int bitrate_;
std::string recolorModel_;
bool async_;
std::string videoURL_;
};
}
}
}
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_TONESDRVIDEOREQUEST_H_
*/
#ifndef ALIBABACLOUD_VIDEOENHAN_MODEL_TONESDRVIDEOREQUEST_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_TONESDRVIDEOREQUEST_H_
#include <alibabacloud/videoenhan/VideoenhanExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Videoenhan {
namespace Model {
class ALIBABACLOUD_VIDEOENHAN_EXPORT ToneSdrVideoRequest : public RpcServiceRequest {
public:
ToneSdrVideoRequest();
~ToneSdrVideoRequest();
int getBitrate() const;
void setBitrate(int bitrate);
std::string getRecolorModel() const;
void setRecolorModel(const std::string &recolorModel);
bool getAsync() const;
void setAsync(bool async);
std::string getVideoURL() const;
void setVideoURL(const std::string &videoURL);
private:
int bitrate_;
std::string recolorModel_;
bool async_;
std::string videoURL_;
};
} // namespace Model
} // namespace Videoenhan
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_TONESDRVIDEOREQUEST_H_

94
videoenhan/src/model/AbstractEcommerceVideoRequest.cc
View File

@@ -1,84 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/videoenhan/model/AbstractEcommerceVideoRequest.h>
using AlibabaCloud::Videoenhan::Model::AbstractEcommerceVideoRequest;
AbstractEcommerceVideoRequest::AbstractEcommerceVideoRequest() :
RpcServiceRequest("videoenhan", "2020-03-20", "AbstractEcommerceVideo")
{
setMethod(HttpRequest::Method::Post);
}
AbstractEcommerceVideoRequest::~AbstractEcommerceVideoRequest()
{}
float AbstractEcommerceVideoRequest::getDuration()const
{
return duration_;
*/
#include <alibabacloud/videoenhan/model/AbstractEcommerceVideoRequest.h>
using AlibabaCloud::Videoenhan::Model::AbstractEcommerceVideoRequest;
AbstractEcommerceVideoRequest::AbstractEcommerceVideoRequest()
: RpcServiceRequest("videoenhan", "2020-03-20", "AbstractEcommerceVideo") {
setMethod(HttpRequest::Method::Post);
}
void AbstractEcommerceVideoRequest::setDuration(float duration)
{
duration_ = duration;
setBodyParameter("Duration", std::to_string(duration));
AbstractEcommerceVideoRequest::~AbstractEcommerceVideoRequest() {}
float AbstractEcommerceVideoRequest::getDuration() const {
return duration_;
}
int AbstractEcommerceVideoRequest::getHeight()const
{
return height_;
void AbstractEcommerceVideoRequest::setDuration(float duration) {
duration_ = duration;
setBodyParameter(std::string("Duration"), std::to_string(duration));
}
void AbstractEcommerceVideoRequest::setHeight(int height)
{
height_ = height;
setBodyParameter("Height", std::to_string(height));
int AbstractEcommerceVideoRequest::getHeight() const {
return height_;
}
bool AbstractEcommerceVideoRequest::getAsync()const
{
return async_;
void AbstractEcommerceVideoRequest::setHeight(int height) {
height_ = height;
setBodyParameter(std::string("Height"), std::to_string(height));
}
void AbstractEcommerceVideoRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
bool AbstractEcommerceVideoRequest::getAsync() const {
return async_;
}
std::string AbstractEcommerceVideoRequest::getVideoUrl()const
{
return videoUrl_;
void AbstractEcommerceVideoRequest::setAsync(bool async) {
async_ = async;
setBodyParameter(std::string("Async"), async ? "true" : "false");
}
void AbstractEcommerceVideoRequest::setVideoUrl(const std::string& videoUrl)
{
videoUrl_ = videoUrl;
setBodyParameter("VideoUrl", videoUrl);
std::string AbstractEcommerceVideoRequest::getVideoUrl() const {
return videoUrl_;
}
int AbstractEcommerceVideoRequest::getWidth()const
{
return width_;
void AbstractEcommerceVideoRequest::setVideoUrl(const std::string &videoUrl) {
videoUrl_ = videoUrl;
setBodyParameter(std::string("VideoUrl"), videoUrl);
}
void AbstractEcommerceVideoRequest::setWidth(int width)
{
width_ = width;
setBodyParameter("Width", std::to_string(width));
int AbstractEcommerceVideoRequest::getWidth() const {
return width_;
}
void AbstractEcommerceVideoRequest::setWidth(int width) {
width_ = width;
setBodyParameter(std::string("Width"), std::to_string(width));
}

70
videoenhan/src/model/AbstractFilmVideoRequest.cc
View File

@@ -1,62 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/videoenhan/model/AbstractFilmVideoRequest.h>
using AlibabaCloud::Videoenhan::Model::AbstractFilmVideoRequest;
AbstractFilmVideoRequest::AbstractFilmVideoRequest() :
RpcServiceRequest("videoenhan", "2020-03-20", "AbstractFilmVideo")
{
setMethod(HttpRequest::Method::Post);
}
AbstractFilmVideoRequest::~AbstractFilmVideoRequest()
{}
int AbstractFilmVideoRequest::getLength()const
{
return length_;
*/
#include <alibabacloud/videoenhan/model/AbstractFilmVideoRequest.h>
using AlibabaCloud::Videoenhan::Model::AbstractFilmVideoRequest;
AbstractFilmVideoRequest::AbstractFilmVideoRequest()
: RpcServiceRequest("videoenhan", "2020-03-20", "AbstractFilmVideo") {
setMethod(HttpRequest::Method::Post);
}
void AbstractFilmVideoRequest::setLength(int length)
{
length_ = length;
setBodyParameter("Length", std::to_string(length));
AbstractFilmVideoRequest::~AbstractFilmVideoRequest() {}
int AbstractFilmVideoRequest::getLength() const {
return length_;
}
bool AbstractFilmVideoRequest::getAsync()const
{
return async_;
void AbstractFilmVideoRequest::setLength(int length) {
length_ = length;
setBodyParameter(std::string("Length"), std::to_string(length));
}
void AbstractFilmVideoRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
bool AbstractFilmVideoRequest::getAsync() const {
return async_;
}
std::string AbstractFilmVideoRequest::getVideoUrl()const
{
return videoUrl_;
void AbstractFilmVideoRequest::setAsync(bool async) {
async_ = async;
setBodyParameter(std::string("Async"), async ? "true" : "false");
}
void AbstractFilmVideoRequest::setVideoUrl(const std::string& videoUrl)
{
videoUrl_ = videoUrl;
setBodyParameter("VideoUrl", videoUrl);
std::string AbstractFilmVideoRequest::getVideoUrl() const {
return videoUrl_;
}
void AbstractFilmVideoRequest::setVideoUrl(const std::string &videoUrl) {
videoUrl_ = videoUrl;
setBodyParameter(std::string("VideoUrl"), videoUrl);
}

70
videoenhan/src/model/AddFaceVideoTemplateRequest.cc
View File

@@ -1,62 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/videoenhan/model/AddFaceVideoTemplateRequest.h>
using AlibabaCloud::Videoenhan::Model::AddFaceVideoTemplateRequest;
AddFaceVideoTemplateRequest::AddFaceVideoTemplateRequest() :
RpcServiceRequest("videoenhan", "2020-03-20", "AddFaceVideoTemplate")
{
setMethod(HttpRequest::Method::Post);
}
AddFaceVideoTemplateRequest::~AddFaceVideoTemplateRequest()
{}
std::string AddFaceVideoTemplateRequest::getUserId()const
{
return userId_;
*/
#include <alibabacloud/videoenhan/model/AddFaceVideoTemplateRequest.h>
using AlibabaCloud::Videoenhan::Model::AddFaceVideoTemplateRequest;
AddFaceVideoTemplateRequest::AddFaceVideoTemplateRequest()
: RpcServiceRequest("videoenhan", "2020-03-20", "AddFaceVideoTemplate") {
setMethod(HttpRequest::Method::Post);
}
void AddFaceVideoTemplateRequest::setUserId(const std::string& userId)
{
userId_ = userId;
setBodyParameter("UserId", userId);
AddFaceVideoTemplateRequest::~AddFaceVideoTemplateRequest() {}
std::string AddFaceVideoTemplateRequest::getUserId() const {
return userId_;
}
bool AddFaceVideoTemplateRequest::getAsync()const
{
return async_;
void AddFaceVideoTemplateRequest::setUserId(const std::string &userId) {
userId_ = userId;
setBodyParameter(std::string("UserId"), userId);
}
void AddFaceVideoTemplateRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
bool AddFaceVideoTemplateRequest::getAsync() const {
return async_;
}
std::string AddFaceVideoTemplateRequest::getVideoURL()const
{
return videoURL_;
void AddFaceVideoTemplateRequest::setAsync(bool async) {
async_ = async;
setBodyParameter(std::string("Async"), async ? "true" : "false");
}
void AddFaceVideoTemplateRequest::setVideoURL(const std::string& videoURL)
{
videoURL_ = videoURL;
setBodyParameter("VideoURL", videoURL);
std::string AddFaceVideoTemplateRequest::getVideoURL() const {
return videoURL_;
}
void AddFaceVideoTemplateRequest::setVideoURL(const std::string &videoURL) {
videoURL_ = videoURL;
setBodyParameter(std::string("VideoURL"), videoURL);
}

106
videoenhan/src/model/AdjustVideoColorRequest.cc
View File

@@ -1,95 +1,81 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/videoenhan/model/AdjustVideoColorRequest.h>
using AlibabaCloud::Videoenhan::Model::AdjustVideoColorRequest;
AdjustVideoColorRequest::AdjustVideoColorRequest() :
RpcServiceRequest("videoenhan", "2020-03-20", "AdjustVideoColor")
{
setMethod(HttpRequest::Method::Post);
}
AdjustVideoColorRequest::~AdjustVideoColorRequest()
{}
std::string AdjustVideoColorRequest::getMode()const
{
return mode_;
*/
#include <alibabacloud/videoenhan/model/AdjustVideoColorRequest.h>
using AlibabaCloud::Videoenhan::Model::AdjustVideoColorRequest;
AdjustVideoColorRequest::AdjustVideoColorRequest()
: RpcServiceRequest("videoenhan", "2020-03-20", "AdjustVideoColor") {
setMethod(HttpRequest::Method::Post);
}
void AdjustVideoColorRequest::setMode(const std::string& mode)
{
mode_ = mode;
setBodyParameter("Mode", mode);
AdjustVideoColorRequest::~AdjustVideoColorRequest() {}
std::string AdjustVideoColorRequest::getMode() const {
return mode_;
}
bool AdjustVideoColorRequest::getAsync()const
{
return async_;
void AdjustVideoColorRequest::setMode(const std::string &mode) {
mode_ = mode;
setBodyParameter(std::string("Mode"), mode);
}
void AdjustVideoColorRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
bool AdjustVideoColorRequest::getAsync() const {
return async_;
}
std::string AdjustVideoColorRequest::getVideoUrl()const
{
return videoUrl_;
void AdjustVideoColorRequest::setAsync(bool async) {
async_ = async;
setBodyParameter(std::string("Async"), async ? "true" : "false");
}
void AdjustVideoColorRequest::setVideoUrl(const std::string& videoUrl)
{
videoUrl_ = videoUrl;
setBodyParameter("VideoUrl", videoUrl);
std::string AdjustVideoColorRequest::getVideoUrl() const {
return videoUrl_;
}
long AdjustVideoColorRequest::getVideoBitrate()const
{
return videoBitrate_;
void AdjustVideoColorRequest::setVideoUrl(const std::string &videoUrl) {
videoUrl_ = videoUrl;
setBodyParameter(std::string("VideoUrl"), videoUrl);
}
void AdjustVideoColorRequest::setVideoBitrate(long videoBitrate)
{
videoBitrate_ = videoBitrate;
setBodyParameter("VideoBitrate", std::to_string(videoBitrate));
long AdjustVideoColorRequest::getVideoBitrate() const {
return videoBitrate_;
}
std::string AdjustVideoColorRequest::getVideoCodec()const
{
return videoCodec_;
void AdjustVideoColorRequest::setVideoBitrate(long videoBitrate) {
videoBitrate_ = videoBitrate;
setBodyParameter(std::string("VideoBitrate"), std::to_string(videoBitrate));
}
void AdjustVideoColorRequest::setVideoCodec(const std::string& videoCodec)
{
videoCodec_ = videoCodec;
setBodyParameter("VideoCodec", videoCodec);
std::string AdjustVideoColorRequest::getVideoCodec() const {
return videoCodec_;
}
std::string AdjustVideoColorRequest::getVideoFormat()const
{
return videoFormat_;
void AdjustVideoColorRequest::setVideoCodec(const std::string &videoCodec) {
videoCodec_ = videoCodec;
setBodyParameter(std::string("VideoCodec"), videoCodec);
}
void AdjustVideoColorRequest::setVideoFormat(const std::string& videoFormat)
{
videoFormat_ = videoFormat;
setBodyParameter("VideoFormat", videoFormat);
std::string AdjustVideoColorRequest::getVideoFormat() const {
return videoFormat_;
}
void AdjustVideoColorRequest::setVideoFormat(const std::string &videoFormat) {
videoFormat_ = videoFormat;
setBodyParameter(std::string("VideoFormat"), videoFormat);
}

154
videoenhan/src/model/ChangeVideoSizeRequest.cc
View File

@@ -1,139 +1,117 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/videoenhan/model/ChangeVideoSizeRequest.h>
using AlibabaCloud::Videoenhan::Model::ChangeVideoSizeRequest;
ChangeVideoSizeRequest::ChangeVideoSizeRequest() :
RpcServiceRequest("videoenhan", "2020-03-20", "ChangeVideoSize")
{
setMethod(HttpRequest::Method::Post);
}
ChangeVideoSizeRequest::~ChangeVideoSizeRequest()
{}
int ChangeVideoSizeRequest::getHeight()const
{
return height_;
*/
#include <alibabacloud/videoenhan/model/ChangeVideoSizeRequest.h>
using AlibabaCloud::Videoenhan::Model::ChangeVideoSizeRequest;
ChangeVideoSizeRequest::ChangeVideoSizeRequest()
: RpcServiceRequest("videoenhan", "2020-03-20", "ChangeVideoSize") {
setMethod(HttpRequest::Method::Post);
}
void ChangeVideoSizeRequest::setHeight(int height)
{
height_ = height;
setBodyParameter("Height", std::to_string(height));
ChangeVideoSizeRequest::~ChangeVideoSizeRequest() {}
int ChangeVideoSizeRequest::getHeight() const {
return height_;
}
int ChangeVideoSizeRequest::getB()const
{
return b_;
void ChangeVideoSizeRequest::setHeight(int height) {
height_ = height;
setBodyParameter(std::string("Height"), std::to_string(height));
}
void ChangeVideoSizeRequest::setB(int b)
{
b_ = b;
setBodyParameter("B", std::to_string(b));
int ChangeVideoSizeRequest::getB() const {
return b_;
}
std::string ChangeVideoSizeRequest::getFillType()const
{
return fillType_;
void ChangeVideoSizeRequest::setB(int b) {
b_ = b;
setBodyParameter(std::string("B"), std::to_string(b));
}
void ChangeVideoSizeRequest::setFillType(const std::string& fillType)
{
fillType_ = fillType;
setBodyParameter("FillType", fillType);
std::string ChangeVideoSizeRequest::getFillType() const {
return fillType_;
}
int ChangeVideoSizeRequest::getG()const
{
return g_;
void ChangeVideoSizeRequest::setFillType(const std::string &fillType) {
fillType_ = fillType;
setBodyParameter(std::string("FillType"), fillType);
}
void ChangeVideoSizeRequest::setG(int g)
{
g_ = g;
setBodyParameter("G", std::to_string(g));
int ChangeVideoSizeRequest::getG() const {
return g_;
}
std::string ChangeVideoSizeRequest::getCropType()const
{
return cropType_;
void ChangeVideoSizeRequest::setG(int g) {
g_ = g;
setBodyParameter(std::string("G"), std::to_string(g));
}
void ChangeVideoSizeRequest::setCropType(const std::string& cropType)
{
cropType_ = cropType;
setBodyParameter("CropType", cropType);
std::string ChangeVideoSizeRequest::getCropType() const {
return cropType_;
}
bool ChangeVideoSizeRequest::getAsync()const
{
return async_;
void ChangeVideoSizeRequest::setCropType(const std::string &cropType) {
cropType_ = cropType;
setBodyParameter(std::string("CropType"), cropType);
}
void ChangeVideoSizeRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
bool ChangeVideoSizeRequest::getAsync() const {
return async_;
}
int ChangeVideoSizeRequest::getR()const
{
return r_;
void ChangeVideoSizeRequest::setAsync(bool async) {
async_ = async;
setBodyParameter(std::string("Async"), async ? "true" : "false");
}
void ChangeVideoSizeRequest::setR(int r)
{
r_ = r;
setBodyParameter("R", std::to_string(r));
int ChangeVideoSizeRequest::getR() const {
return r_;
}
std::string ChangeVideoSizeRequest::getVideoUrl()const
{
return videoUrl_;
void ChangeVideoSizeRequest::setR(int r) {
r_ = r;
setBodyParameter(std::string("R"), std::to_string(r));
}
void ChangeVideoSizeRequest::setVideoUrl(const std::string& videoUrl)
{
videoUrl_ = videoUrl;
setBodyParameter("VideoUrl", videoUrl);
std::string ChangeVideoSizeRequest::getVideoUrl() const {
return videoUrl_;
}
int ChangeVideoSizeRequest::getWidth()const
{
return width_;
void ChangeVideoSizeRequest::setVideoUrl(const std::string &videoUrl) {
videoUrl_ = videoUrl;
setBodyParameter(std::string("VideoUrl"), videoUrl);
}
void ChangeVideoSizeRequest::setWidth(int width)
{
width_ = width;
setBodyParameter("Width", std::to_string(width));
int ChangeVideoSizeRequest::getWidth() const {
return width_;
}
float ChangeVideoSizeRequest::getTightness()const
{
return tightness_;
void ChangeVideoSizeRequest::setWidth(int width) {
width_ = width;
setBodyParameter(std::string("Width"), std::to_string(width));
}
void ChangeVideoSizeRequest::setTightness(float tightness)
{
tightness_ = tightness;
setBodyParameter("Tightness", std::to_string(tightness));
float ChangeVideoSizeRequest::getTightness() const {
return tightness_;
}
void ChangeVideoSizeRequest::setTightness(float tightness) {
tightness_ = tightness;
setBodyParameter(std::string("Tightness"), std::to_string(tightness));
}

94
videoenhan/src/model/ConvertHdrVideoRequest.cc
View File

@@ -1,84 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/videoenhan/model/ConvertHdrVideoRequest.h>
using AlibabaCloud::Videoenhan::Model::ConvertHdrVideoRequest;
ConvertHdrVideoRequest::ConvertHdrVideoRequest() :
RpcServiceRequest("videoenhan", "2020-03-20", "ConvertHdrVideo")
{
setMethod(HttpRequest::Method::Post);
}
ConvertHdrVideoRequest::~ConvertHdrVideoRequest()
{}
std::string ConvertHdrVideoRequest::getHDRFormat()const
{
return hDRFormat_;
*/
#include <alibabacloud/videoenhan/model/ConvertHdrVideoRequest.h>
using AlibabaCloud::Videoenhan::Model::ConvertHdrVideoRequest;
ConvertHdrVideoRequest::ConvertHdrVideoRequest()
: RpcServiceRequest("videoenhan", "2020-03-20", "ConvertHdrVideo") {
setMethod(HttpRequest::Method::Post);
}
void ConvertHdrVideoRequest::setHDRFormat(const std::string& hDRFormat)
{
hDRFormat_ = hDRFormat;
setBodyParameter("HDRFormat", hDRFormat);
ConvertHdrVideoRequest::~ConvertHdrVideoRequest() {}
std::string ConvertHdrVideoRequest::getHDRFormat() const {
return hDRFormat_;
}
int ConvertHdrVideoRequest::getMaxIlluminance()const
{
return maxIlluminance_;
void ConvertHdrVideoRequest::setHDRFormat(const std::string &hDRFormat) {
hDRFormat_ = hDRFormat;
setBodyParameter(std::string("HDRFormat"), hDRFormat);
}
void ConvertHdrVideoRequest::setMaxIlluminance(int maxIlluminance)
{
maxIlluminance_ = maxIlluminance;
setBodyParameter("MaxIlluminance", std::to_string(maxIlluminance));
int ConvertHdrVideoRequest::getMaxIlluminance() const {
return maxIlluminance_;
}
int ConvertHdrVideoRequest::getBitrate()const
{
return bitrate_;
void ConvertHdrVideoRequest::setMaxIlluminance(int maxIlluminance) {
maxIlluminance_ = maxIlluminance;
setBodyParameter(std::string("MaxIlluminance"), std::to_string(maxIlluminance));
}
void ConvertHdrVideoRequest::setBitrate(int bitrate)
{
bitrate_ = bitrate;
setBodyParameter("Bitrate", std::to_string(bitrate));
int ConvertHdrVideoRequest::getBitrate() const {
return bitrate_;
}
bool ConvertHdrVideoRequest::getAsync()const
{
return async_;
void ConvertHdrVideoRequest::setBitrate(int bitrate) {
bitrate_ = bitrate;
setBodyParameter(std::string("Bitrate"), std::to_string(bitrate));
}
void ConvertHdrVideoRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
bool ConvertHdrVideoRequest::getAsync() const {
return async_;
}
std::string ConvertHdrVideoRequest::getVideoURL()const
{
return videoURL_;
void ConvertHdrVideoRequest::setAsync(bool async) {
async_ = async;
setBodyParameter(std::string("Async"), async ? "true" : "false");
}
void ConvertHdrVideoRequest::setVideoURL(const std::string& videoURL)
{
videoURL_ = videoURL;
setBodyParameter("VideoURL", videoURL);
std::string ConvertHdrVideoRequest::getVideoURL() const {
return videoURL_;
}
void ConvertHdrVideoRequest::setVideoURL(const std::string &videoURL) {
videoURL_ = videoURL;
setBodyParameter(std::string("VideoURL"), videoURL);
}

58
videoenhan/src/model/DeleteFaceVideoTemplateRequest.cc
View File

@@ -1,51 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/videoenhan/model/DeleteFaceVideoTemplateRequest.h>
using AlibabaCloud::Videoenhan::Model::DeleteFaceVideoTemplateRequest;
DeleteFaceVideoTemplateRequest::DeleteFaceVideoTemplateRequest() :
RpcServiceRequest("videoenhan", "2020-03-20", "DeleteFaceVideoTemplate")
{
setMethod(HttpRequest::Method::Post);
}
DeleteFaceVideoTemplateRequest::~DeleteFaceVideoTemplateRequest()
{}
std::string DeleteFaceVideoTemplateRequest::getUserId()const
{
return userId_;
*/
#include <alibabacloud/videoenhan/model/DeleteFaceVideoTemplateRequest.h>
using AlibabaCloud::Videoenhan::Model::DeleteFaceVideoTemplateRequest;
DeleteFaceVideoTemplateRequest::DeleteFaceVideoTemplateRequest()
: RpcServiceRequest("videoenhan", "2020-03-20", "DeleteFaceVideoTemplate") {
setMethod(HttpRequest::Method::Post);
}
void DeleteFaceVideoTemplateRequest::setUserId(const std::string& userId)
{
userId_ = userId;
setBodyParameter("UserId", userId);
DeleteFaceVideoTemplateRequest::~DeleteFaceVideoTemplateRequest() {}
std::string DeleteFaceVideoTemplateRequest::getUserId() const {
return userId_;
}
std::string DeleteFaceVideoTemplateRequest::getTemplateId()const
{
return templateId_;
void DeleteFaceVideoTemplateRequest::setUserId(const std::string &userId) {
userId_ = userId;
setBodyParameter(std::string("UserId"), userId);
}
void DeleteFaceVideoTemplateRequest::setTemplateId(const std::string& templateId)
{
templateId_ = templateId;
setBodyParameter("TemplateId", templateId);
std::string DeleteFaceVideoTemplateRequest::getTemplateId() const {
return templateId_;
}
void DeleteFaceVideoTemplateRequest::setTemplateId(const std::string &templateId) {
templateId_ = templateId;
setBodyParameter(std::string("TemplateId"), templateId);
}

130
videoenhan/src/model/EnhanceVideoQualityRequest.cc
View File

@@ -1,117 +1,99 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/videoenhan/model/EnhanceVideoQualityRequest.h>
using AlibabaCloud::Videoenhan::Model::EnhanceVideoQualityRequest;
EnhanceVideoQualityRequest::EnhanceVideoQualityRequest() :
RpcServiceRequest("videoenhan", "2020-03-20", "EnhanceVideoQuality")
{
setMethod(HttpRequest::Method::Post);
}
EnhanceVideoQualityRequest::~EnhanceVideoQualityRequest()
{}
std::string EnhanceVideoQualityRequest::getHDRFormat()const
{
return hDRFormat_;
*/
#include <alibabacloud/videoenhan/model/EnhanceVideoQualityRequest.h>
using AlibabaCloud::Videoenhan::Model::EnhanceVideoQualityRequest;
EnhanceVideoQualityRequest::EnhanceVideoQualityRequest()
: RpcServiceRequest("videoenhan", "2020-03-20", "EnhanceVideoQuality") {
setMethod(HttpRequest::Method::Post);
}
void EnhanceVideoQualityRequest::setHDRFormat(const std::string& hDRFormat)
{
hDRFormat_ = hDRFormat;
setBodyParameter("HDRFormat", hDRFormat);
EnhanceVideoQualityRequest::~EnhanceVideoQualityRequest() {}
std::string EnhanceVideoQualityRequest::getHDRFormat() const {
return hDRFormat_;
}
int EnhanceVideoQualityRequest::getFrameRate()const
{
return frameRate_;
void EnhanceVideoQualityRequest::setHDRFormat(const std::string &hDRFormat) {
hDRFormat_ = hDRFormat;
setBodyParameter(std::string("HDRFormat"), hDRFormat);
}
void EnhanceVideoQualityRequest::setFrameRate(int frameRate)
{
frameRate_ = frameRate;
setBodyParameter("FrameRate", std::to_string(frameRate));
int EnhanceVideoQualityRequest::getFrameRate() const {
return frameRate_;
}
int EnhanceVideoQualityRequest::getMaxIlluminance()const
{
return maxIlluminance_;
void EnhanceVideoQualityRequest::setFrameRate(int frameRate) {
frameRate_ = frameRate;
setBodyParameter(std::string("FrameRate"), std::to_string(frameRate));
}
void EnhanceVideoQualityRequest::setMaxIlluminance(int maxIlluminance)
{
maxIlluminance_ = maxIlluminance;
setBodyParameter("MaxIlluminance", std::to_string(maxIlluminance));
int EnhanceVideoQualityRequest::getMaxIlluminance() const {
return maxIlluminance_;
}
int EnhanceVideoQualityRequest::getBitrate()const
{
return bitrate_;
void EnhanceVideoQualityRequest::setMaxIlluminance(int maxIlluminance) {
maxIlluminance_ = maxIlluminance;
setBodyParameter(std::string("MaxIlluminance"), std::to_string(maxIlluminance));
}
void EnhanceVideoQualityRequest::setBitrate(int bitrate)
{
bitrate_ = bitrate;
setBodyParameter("Bitrate", std::to_string(bitrate));
int EnhanceVideoQualityRequest::getBitrate() const {
return bitrate_;
}
int EnhanceVideoQualityRequest::getOutPutWidth()const
{
return outPutWidth_;
void EnhanceVideoQualityRequest::setBitrate(int bitrate) {
bitrate_ = bitrate;
setBodyParameter(std::string("Bitrate"), std::to_string(bitrate));
}
void EnhanceVideoQualityRequest::setOutPutWidth(int outPutWidth)
{
outPutWidth_ = outPutWidth;
setBodyParameter("OutPutWidth", std::to_string(outPutWidth));
int EnhanceVideoQualityRequest::getOutPutWidth() const {
return outPutWidth_;
}
int EnhanceVideoQualityRequest::getOutPutHeight()const
{
return outPutHeight_;
void EnhanceVideoQualityRequest::setOutPutWidth(int outPutWidth) {
outPutWidth_ = outPutWidth;
setBodyParameter(std::string("OutPutWidth"), std::to_string(outPutWidth));
}
void EnhanceVideoQualityRequest::setOutPutHeight(int outPutHeight)
{
outPutHeight_ = outPutHeight;
setBodyParameter("OutPutHeight", std::to_string(outPutHeight));
int EnhanceVideoQualityRequest::getOutPutHeight() const {
return outPutHeight_;
}
bool EnhanceVideoQualityRequest::getAsync()const
{
return async_;
void EnhanceVideoQualityRequest::setOutPutHeight(int outPutHeight) {
outPutHeight_ = outPutHeight;
setBodyParameter(std::string("OutPutHeight"), std::to_string(outPutHeight));
}
void EnhanceVideoQualityRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
bool EnhanceVideoQualityRequest::getAsync() const {
return async_;
}
std::string EnhanceVideoQualityRequest::getVideoURL()const
{
return videoURL_;
void EnhanceVideoQualityRequest::setAsync(bool async) {
async_ = async;
setBodyParameter(std::string("Async"), async ? "true" : "false");
}
void EnhanceVideoQualityRequest::setVideoURL(const std::string& videoURL)
{
videoURL_ = videoURL;
setBodyParameter("VideoURL", videoURL);
std::string EnhanceVideoQualityRequest::getVideoURL() const {
return videoURL_;
}
void EnhanceVideoQualityRequest::setVideoURL(const std::string &videoURL) {
videoURL_ = videoURL;
setBodyParameter(std::string("VideoURL"), videoURL);
}

84
videoenhan/src/model/EraseVideoLogoRequest.cc
View File

@@ -1,69 +1,61 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/videoenhan/model/EraseVideoLogoRequest.h>
using AlibabaCloud::Videoenhan::Model::EraseVideoLogoRequest;
EraseVideoLogoRequest::EraseVideoLogoRequest() :
RpcServiceRequest("videoenhan", "2020-03-20", "EraseVideoLogo")
{
setMethod(HttpRequest::Method::Post);
}
EraseVideoLogoRequest::~EraseVideoLogoRequest()
{}
std::vector<EraseVideoLogoRequest::Boxes> EraseVideoLogoRequest::getBoxes()const
{
return boxes_;
*/
#include <alibabacloud/videoenhan/model/EraseVideoLogoRequest.h>
using AlibabaCloud::Videoenhan::Model::EraseVideoLogoRequest;
EraseVideoLogoRequest::EraseVideoLogoRequest()
: RpcServiceRequest("videoenhan", "2020-03-20", "EraseVideoLogo") {
setMethod(HttpRequest::Method::Post);
}
void EraseVideoLogoRequest::setBoxes(const std::vector<Boxes>& boxes)
{
boxes_ = boxes;
for(int dep1 = 0; dep1!= boxes.size(); dep1++) {
auto boxesObj = boxes.at(dep1);
std::string boxesObjStr = "Boxes." + std::to_string(dep1 + 1);
setParameter(boxesObjStr + ".W", std::to_string(boxesObj.w));
setParameter(boxesObjStr + ".H", std::to_string(boxesObj.h));
setParameter(boxesObjStr + ".X", std::to_string(boxesObj.x));
setParameter(boxesObjStr + ".Y", std::to_string(boxesObj.y));
}
EraseVideoLogoRequest::~EraseVideoLogoRequest() {}
std::vector<EraseVideoLogoRequest::Boxes> EraseVideoLogoRequest::getBoxes() const {
return boxes_;
}
bool EraseVideoLogoRequest::getAsync()const
{
return async_;
void EraseVideoLogoRequest::setBoxes(const std::vector<EraseVideoLogoRequest::Boxes> &boxes) {
boxes_ = boxes;
for(int dep1 = 0; dep1 != boxes.size(); dep1++) {
auto boxesObj = boxes.at(dep1);
std::string boxesObjStr = std::string("Boxes") + "." + std::to_string(dep1 + 1);
setBodyParameter(boxesObjStr + ".W", std::to_string(boxesObj.w));
setBodyParameter(boxesObjStr + ".H", std::to_string(boxesObj.h));
setBodyParameter(boxesObjStr + ".X", std::to_string(boxesObj.x));
setBodyParameter(boxesObjStr + ".Y", std::to_string(boxesObj.y));
}
}
void EraseVideoLogoRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
bool EraseVideoLogoRequest::getAsync() const {
return async_;
}
std::string EraseVideoLogoRequest::getVideoUrl()const
{
return videoUrl_;
void EraseVideoLogoRequest::setAsync(bool async) {
async_ = async;
setBodyParameter(std::string("Async"), async ? "true" : "false");
}
void EraseVideoLogoRequest::setVideoUrl(const std::string& videoUrl)
{
videoUrl_ = videoUrl;
setBodyParameter("VideoUrl", videoUrl);
std::string EraseVideoLogoRequest::getVideoUrl() const {
return videoUrl_;
}
void EraseVideoLogoRequest::setVideoUrl(const std::string &videoUrl) {
videoUrl_ = videoUrl;
setBodyParameter(std::string("VideoUrl"), videoUrl);
}

106
videoenhan/src/model/EraseVideoSubtitlesRequest.cc
View File

@@ -1,95 +1,81 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/videoenhan/model/EraseVideoSubtitlesRequest.h>
using AlibabaCloud::Videoenhan::Model::EraseVideoSubtitlesRequest;
EraseVideoSubtitlesRequest::EraseVideoSubtitlesRequest() :
RpcServiceRequest("videoenhan", "2020-03-20", "EraseVideoSubtitles")
{
setMethod(HttpRequest::Method::Post);
}
EraseVideoSubtitlesRequest::~EraseVideoSubtitlesRequest()
{}
float EraseVideoSubtitlesRequest::getBH()const
{
return bH_;
*/
#include <alibabacloud/videoenhan/model/EraseVideoSubtitlesRequest.h>
using AlibabaCloud::Videoenhan::Model::EraseVideoSubtitlesRequest;
EraseVideoSubtitlesRequest::EraseVideoSubtitlesRequest()
: RpcServiceRequest("videoenhan", "2020-03-20", "EraseVideoSubtitles") {
setMethod(HttpRequest::Method::Post);
}
void EraseVideoSubtitlesRequest::setBH(float bH)
{
bH_ = bH;
setBodyParameter("BH", std::to_string(bH));
EraseVideoSubtitlesRequest::~EraseVideoSubtitlesRequest() {}
float EraseVideoSubtitlesRequest::getBH() const {
return bH_;
}
float EraseVideoSubtitlesRequest::getBW()const
{
return bW_;
void EraseVideoSubtitlesRequest::setBH(float bH) {
bH_ = bH;
setBodyParameter(std::string("BH"), std::to_string(bH));
}
void EraseVideoSubtitlesRequest::setBW(float bW)
{
bW_ = bW;
setBodyParameter("BW", std::to_string(bW));
float EraseVideoSubtitlesRequest::getBW() const {
return bW_;
}
float EraseVideoSubtitlesRequest::getBX()const
{
return bX_;
void EraseVideoSubtitlesRequest::setBW(float bW) {
bW_ = bW;
setBodyParameter(std::string("BW"), std::to_string(bW));
}
void EraseVideoSubtitlesRequest::setBX(float bX)
{
bX_ = bX;
setBodyParameter("BX", std::to_string(bX));
float EraseVideoSubtitlesRequest::getBX() const {
return bX_;
}
float EraseVideoSubtitlesRequest::getBY()const
{
return bY_;
void EraseVideoSubtitlesRequest::setBX(float bX) {
bX_ = bX;
setBodyParameter(std::string("BX"), std::to_string(bX));
}
void EraseVideoSubtitlesRequest::setBY(float bY)
{
bY_ = bY;
setBodyParameter("BY", std::to_string(bY));
float EraseVideoSubtitlesRequest::getBY() const {
return bY_;
}
bool EraseVideoSubtitlesRequest::getAsync()const
{
return async_;
void EraseVideoSubtitlesRequest::setBY(float bY) {
bY_ = bY;
setBodyParameter(std::string("BY"), std::to_string(bY));
}
void EraseVideoSubtitlesRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
bool EraseVideoSubtitlesRequest::getAsync() const {
return async_;
}
std::string EraseVideoSubtitlesRequest::getVideoUrl()const
{
return videoUrl_;
void EraseVideoSubtitlesRequest::setAsync(bool async) {
async_ = async;
setBodyParameter(std::string("Async"), async ? "true" : "false");
}
void EraseVideoSubtitlesRequest::setVideoUrl(const std::string& videoUrl)
{
videoUrl_ = videoUrl;
setBodyParameter("VideoUrl", videoUrl);
std::string EraseVideoSubtitlesRequest::getVideoUrl() const {
return videoUrl_;
}
void EraseVideoSubtitlesRequest::setVideoUrl(const std::string &videoUrl) {
videoUrl_ = videoUrl;
setBodyParameter(std::string("VideoUrl"), videoUrl);
}

190
videoenhan/src/model/GenerateVideoRequest.cc
View File

@@ -1,167 +1,141 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/videoenhan/model/GenerateVideoRequest.h>
using AlibabaCloud::Videoenhan::Model::GenerateVideoRequest;
GenerateVideoRequest::GenerateVideoRequest() :
RpcServiceRequest("videoenhan", "2020-03-20", "GenerateVideo")
{
setMethod(HttpRequest::Method::Post);
}
GenerateVideoRequest::~GenerateVideoRequest()
{}
std::string GenerateVideoRequest::getTransitionStyle()const
{
return transitionStyle_;
*/
#include <alibabacloud/videoenhan/model/GenerateVideoRequest.h>
using AlibabaCloud::Videoenhan::Model::GenerateVideoRequest;
GenerateVideoRequest::GenerateVideoRequest()
: RpcServiceRequest("videoenhan", "2020-03-20", "GenerateVideo") {
setMethod(HttpRequest::Method::Post);
}
void GenerateVideoRequest::setTransitionStyle(const std::string& transitionStyle)
{
transitionStyle_ = transitionStyle;
setBodyParameter("TransitionStyle", transitionStyle);
GenerateVideoRequest::~GenerateVideoRequest() {}
std::string GenerateVideoRequest::getTransitionStyle() const {
return transitionStyle_;
}
std::string GenerateVideoRequest::getScene()const
{
return scene_;
void GenerateVideoRequest::setTransitionStyle(const std::string &transitionStyle) {
transitionStyle_ = transitionStyle;
setBodyParameter(std::string("TransitionStyle"), transitionStyle);
}
void GenerateVideoRequest::setScene(const std::string& scene)
{
scene_ = scene;
setBodyParameter("Scene", scene);
std::string GenerateVideoRequest::getScene() const {
return scene_;
}
float GenerateVideoRequest::getDuration()const
{
return duration_;
void GenerateVideoRequest::setScene(const std::string &scene) {
scene_ = scene;
setBodyParameter(std::string("Scene"), scene);
}
void GenerateVideoRequest::setDuration(float duration)
{
duration_ = duration;
setBodyParameter("Duration", std::to_string(duration));
float GenerateVideoRequest::getDuration() const {
return duration_;
}
bool GenerateVideoRequest::getPuzzleEffect()const
{
return puzzleEffect_;
void GenerateVideoRequest::setDuration(float duration) {
duration_ = duration;
setBodyParameter(std::string("Duration"), std::to_string(duration));
}
void GenerateVideoRequest::setPuzzleEffect(bool puzzleEffect)
{
puzzleEffect_ = puzzleEffect;
setBodyParameter("PuzzleEffect", puzzleEffect ? "true" : "false");
bool GenerateVideoRequest::getPuzzleEffect() const {
return puzzleEffect_;
}
int GenerateVideoRequest::getHeight()const
{
return height_;
void GenerateVideoRequest::setPuzzleEffect(bool puzzleEffect) {
puzzleEffect_ = puzzleEffect;
setBodyParameter(std::string("PuzzleEffect"), puzzleEffect ? "true" : "false");
}
void GenerateVideoRequest::setHeight(int height)
{
height_ = height;
setBodyParameter("Height", std::to_string(height));
int GenerateVideoRequest::getHeight() const {
return height_;
}
bool GenerateVideoRequest::getDurationAdaption()const
{
return durationAdaption_;
void GenerateVideoRequest::setHeight(int height) {
height_ = height;
setBodyParameter(std::string("Height"), std::to_string(height));
}
void GenerateVideoRequest::setDurationAdaption(bool durationAdaption)
{
durationAdaption_ = durationAdaption;
setBodyParameter("DurationAdaption", durationAdaption ? "true" : "false");
bool GenerateVideoRequest::getDurationAdaption() const {
return durationAdaption_;
}
std::vector<GenerateVideoRequest::FileList> GenerateVideoRequest::getFileList()const
{
return fileList_;
void GenerateVideoRequest::setDurationAdaption(bool durationAdaption) {
durationAdaption_ = durationAdaption;
setBodyParameter(std::string("DurationAdaption"), durationAdaption ? "true" : "false");
}
void GenerateVideoRequest::setFileList(const std::vector<FileList>& fileList)
{
fileList_ = fileList;
for(int dep1 = 0; dep1!= fileList.size(); dep1++) {
auto fileListObj = fileList.at(dep1);
std::string fileListObjStr = "FileList." + std::to_string(dep1 + 1);
setParameter(fileListObjStr + ".FileName", fileListObj.fileName);
setParameter(fileListObjStr + ".FileUrl", fileListObj.fileUrl);
setParameter(fileListObjStr + ".Type", fileListObj.type);
}
std::vector<GenerateVideoRequest::FileList> GenerateVideoRequest::getFileList() const {
return fileList_;
}
bool GenerateVideoRequest::getMute()const
{
return mute_;
void GenerateVideoRequest::setFileList(const std::vector<GenerateVideoRequest::FileList> &fileList) {
fileList_ = fileList;
for(int dep1 = 0; dep1 != fileList.size(); dep1++) {
auto fileListObj = fileList.at(dep1);
std::string fileListObjStr = std::string("FileList") + "." + std::to_string(dep1 + 1);
setBodyParameter(fileListObjStr + ".FileName", fileListObj.fileName);
setBodyParameter(fileListObjStr + ".FileUrl", fileListObj.fileUrl);
setBodyParameter(fileListObjStr + ".Type", fileListObj.type);
}
}
void GenerateVideoRequest::setMute(bool mute)
{
mute_ = mute;
setBodyParameter("Mute", mute ? "true" : "false");
bool GenerateVideoRequest::getMute() const {
return mute_;
}
bool GenerateVideoRequest::getAsync()const
{
return async_;
void GenerateVideoRequest::setMute(bool mute) {
mute_ = mute;
setBodyParameter(std::string("Mute"), mute ? "true" : "false");
}
void GenerateVideoRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
bool GenerateVideoRequest::getAsync() const {
return async_;
}
bool GenerateVideoRequest::getSmartEffect()const
{
return smartEffect_;
void GenerateVideoRequest::setAsync(bool async) {
async_ = async;
setBodyParameter(std::string("Async"), async ? "true" : "false");
}
void GenerateVideoRequest::setSmartEffect(bool smartEffect)
{
smartEffect_ = smartEffect;
setBodyParameter("SmartEffect", smartEffect ? "true" : "false");
bool GenerateVideoRequest::getSmartEffect() const {
return smartEffect_;
}
int GenerateVideoRequest::getWidth()const
{
return width_;
void GenerateVideoRequest::setSmartEffect(bool smartEffect) {
smartEffect_ = smartEffect;
setBodyParameter(std::string("SmartEffect"), smartEffect ? "true" : "false");
}
void GenerateVideoRequest::setWidth(int width)
{
width_ = width;
setBodyParameter("Width", std::to_string(width));
int GenerateVideoRequest::getWidth() const {
return width_;
}
std::string GenerateVideoRequest::getStyle()const
{
return style_;
void GenerateVideoRequest::setWidth(int width) {
width_ = width;
setBodyParameter(std::string("Width"), std::to_string(width));
}
void GenerateVideoRequest::setStyle(const std::string& style)
{
style_ = style;
setBodyParameter("Style", style);
std::string GenerateVideoRequest::getStyle() const {
return style_;
}
void GenerateVideoRequest::setStyle(const std::string &style) {
style_ = style;
setBodyParameter(std::string("Style"), style);
}

58
videoenhan/src/model/GetAsyncJobResultRequest.cc
View File

@@ -1,51 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/videoenhan/model/GetAsyncJobResultRequest.h>
using AlibabaCloud::Videoenhan::Model::GetAsyncJobResultRequest;
GetAsyncJobResultRequest::GetAsyncJobResultRequest() :
RpcServiceRequest("videoenhan", "2020-03-20", "GetAsyncJobResult")
{
setMethod(HttpRequest::Method::Post);
}
GetAsyncJobResultRequest::~GetAsyncJobResultRequest()
{}
std::string GetAsyncJobResultRequest::getJobId()const
{
return jobId_;
*/
#include <alibabacloud/videoenhan/model/GetAsyncJobResultRequest.h>
using AlibabaCloud::Videoenhan::Model::GetAsyncJobResultRequest;
GetAsyncJobResultRequest::GetAsyncJobResultRequest()
: RpcServiceRequest("videoenhan", "2020-03-20", "GetAsyncJobResult") {
setMethod(HttpRequest::Method::Post);
}
void GetAsyncJobResultRequest::setJobId(const std::string& jobId)
{
jobId_ = jobId;
setBodyParameter("JobId", jobId);
GetAsyncJobResultRequest::~GetAsyncJobResultRequest() {}
std::string GetAsyncJobResultRequest::getJobId() const {
return jobId_;
}
bool GetAsyncJobResultRequest::getAsync()const
{
return async_;
void GetAsyncJobResultRequest::setJobId(const std::string &jobId) {
jobId_ = jobId;
setBodyParameter(std::string("JobId"), jobId);
}
void GetAsyncJobResultRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
bool GetAsyncJobResultRequest::getAsync() const {
return async_;
}
void GetAsyncJobResultRequest::setAsync(bool async) {
async_ = async;
setBodyParameter(std::string("Async"), async ? "true" : "false");
}

82
videoenhan/src/model/InterpolateVideoFrameRequest.cc
View File

@@ -1,73 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/videoenhan/model/InterpolateVideoFrameRequest.h>
using AlibabaCloud::Videoenhan::Model::InterpolateVideoFrameRequest;
InterpolateVideoFrameRequest::InterpolateVideoFrameRequest() :
RpcServiceRequest("videoenhan", "2020-03-20", "InterpolateVideoFrame")
{
setMethod(HttpRequest::Method::Post);
}
InterpolateVideoFrameRequest::~InterpolateVideoFrameRequest()
{}
int InterpolateVideoFrameRequest::getFrameRate()const
{
return frameRate_;
*/
#include <alibabacloud/videoenhan/model/InterpolateVideoFrameRequest.h>
using AlibabaCloud::Videoenhan::Model::InterpolateVideoFrameRequest;
InterpolateVideoFrameRequest::InterpolateVideoFrameRequest()
: RpcServiceRequest("videoenhan", "2020-03-20", "InterpolateVideoFrame") {
setMethod(HttpRequest::Method::Post);
}
void InterpolateVideoFrameRequest::setFrameRate(int frameRate)
{
frameRate_ = frameRate;
setBodyParameter("FrameRate", std::to_string(frameRate));
InterpolateVideoFrameRequest::~InterpolateVideoFrameRequest() {}
int InterpolateVideoFrameRequest::getFrameRate() const {
return frameRate_;
}
int InterpolateVideoFrameRequest::getBitrate()const
{
return bitrate_;
void InterpolateVideoFrameRequest::setFrameRate(int frameRate) {
frameRate_ = frameRate;
setBodyParameter(std::string("FrameRate"), std::to_string(frameRate));
}
void InterpolateVideoFrameRequest::setBitrate(int bitrate)
{
bitrate_ = bitrate;
setBodyParameter("Bitrate", std::to_string(bitrate));
int InterpolateVideoFrameRequest::getBitrate() const {
return bitrate_;
}
bool InterpolateVideoFrameRequest::getAsync()const
{
return async_;
void InterpolateVideoFrameRequest::setBitrate(int bitrate) {
bitrate_ = bitrate;
setBodyParameter(std::string("Bitrate"), std::to_string(bitrate));
}
void InterpolateVideoFrameRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
bool InterpolateVideoFrameRequest::getAsync() const {
return async_;
}
std::string InterpolateVideoFrameRequest::getVideoURL()const
{
return videoURL_;
void InterpolateVideoFrameRequest::setAsync(bool async) {
async_ = async;
setBodyParameter(std::string("Async"), async ? "true" : "false");
}
void InterpolateVideoFrameRequest::setVideoURL(const std::string& videoURL)
{
videoURL_ = videoURL;
setBodyParameter("VideoURL", videoURL);
std::string InterpolateVideoFrameRequest::getVideoURL() const {
return videoURL_;
}
void InterpolateVideoFrameRequest::setVideoURL(const std::string &videoURL) {
videoURL_ = videoURL;
setBodyParameter(std::string("VideoURL"), videoURL);
}

82
videoenhan/src/model/MergeVideoFaceRequest.cc
View File

@@ -1,73 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/videoenhan/model/MergeVideoFaceRequest.h>
using AlibabaCloud::Videoenhan::Model::MergeVideoFaceRequest;
MergeVideoFaceRequest::MergeVideoFaceRequest() :
RpcServiceRequest("videoenhan", "2020-03-20", "MergeVideoFace")
{
setMethod(HttpRequest::Method::Post);
}
MergeVideoFaceRequest::~MergeVideoFaceRequest()
{}
std::string MergeVideoFaceRequest::getReferenceURL()const
{
return referenceURL_;
*/
#include <alibabacloud/videoenhan/model/MergeVideoFaceRequest.h>
using AlibabaCloud::Videoenhan::Model::MergeVideoFaceRequest;
MergeVideoFaceRequest::MergeVideoFaceRequest()
: RpcServiceRequest("videoenhan", "2020-03-20", "MergeVideoFace") {
setMethod(HttpRequest::Method::Post);
}
void MergeVideoFaceRequest::setReferenceURL(const std::string& referenceURL)
{
referenceURL_ = referenceURL;
setBodyParameter("ReferenceURL", referenceURL);
MergeVideoFaceRequest::~MergeVideoFaceRequest() {}
std::string MergeVideoFaceRequest::getReferenceURL() const {
return referenceURL_;
}
std::string MergeVideoFaceRequest::getPostURL()const
{
return postURL_;
void MergeVideoFaceRequest::setReferenceURL(const std::string &referenceURL) {
referenceURL_ = referenceURL;
setBodyParameter(std::string("ReferenceURL"), referenceURL);
}
void MergeVideoFaceRequest::setPostURL(const std::string& postURL)
{
postURL_ = postURL;
setBodyParameter("PostURL", postURL);
std::string MergeVideoFaceRequest::getPostURL() const {
return postURL_;
}
bool MergeVideoFaceRequest::getAsync()const
{
return async_;
void MergeVideoFaceRequest::setPostURL(const std::string &postURL) {
postURL_ = postURL;
setBodyParameter(std::string("PostURL"), postURL);
}
void MergeVideoFaceRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
bool MergeVideoFaceRequest::getAsync() const {
return async_;
}
std::string MergeVideoFaceRequest::getVideoURL()const
{
return videoURL_;
void MergeVideoFaceRequest::setAsync(bool async) {
async_ = async;
setBodyParameter(std::string("Async"), async ? "true" : "false");
}
void MergeVideoFaceRequest::setVideoURL(const std::string& videoURL)
{
videoURL_ = videoURL;
setBodyParameter("VideoURL", videoURL);
std::string MergeVideoFaceRequest::getVideoURL() const {
return videoURL_;
}
void MergeVideoFaceRequest::setVideoURL(const std::string &videoURL) {
videoURL_ = videoURL;
setBodyParameter(std::string("VideoURL"), videoURL);
}

82
videoenhan/src/model/MergeVideoModelFaceRequest.cc
View File

@@ -1,73 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/videoenhan/model/MergeVideoModelFaceRequest.h>
using AlibabaCloud::Videoenhan::Model::MergeVideoModelFaceRequest;
MergeVideoModelFaceRequest::MergeVideoModelFaceRequest() :
RpcServiceRequest("videoenhan", "2020-03-20", "MergeVideoModelFace")
{
setMethod(HttpRequest::Method::Post);
}
MergeVideoModelFaceRequest::~MergeVideoModelFaceRequest()
{}
std::string MergeVideoModelFaceRequest::getFaceImageURL()const
{
return faceImageURL_;
*/
#include <alibabacloud/videoenhan/model/MergeVideoModelFaceRequest.h>
using AlibabaCloud::Videoenhan::Model::MergeVideoModelFaceRequest;
MergeVideoModelFaceRequest::MergeVideoModelFaceRequest()
: RpcServiceRequest("videoenhan", "2020-03-20", "MergeVideoModelFace") {
setMethod(HttpRequest::Method::Post);
}
void MergeVideoModelFaceRequest::setFaceImageURL(const std::string& faceImageURL)
{
faceImageURL_ = faceImageURL;
setBodyParameter("FaceImageURL", faceImageURL);
MergeVideoModelFaceRequest::~MergeVideoModelFaceRequest() {}
std::string MergeVideoModelFaceRequest::getFaceImageURL() const {
return faceImageURL_;
}
std::string MergeVideoModelFaceRequest::getUserId()const
{
return userId_;
void MergeVideoModelFaceRequest::setFaceImageURL(const std::string &faceImageURL) {
faceImageURL_ = faceImageURL;
setBodyParameter(std::string("FaceImageURL"), faceImageURL);
}
void MergeVideoModelFaceRequest::setUserId(const std::string& userId)
{
userId_ = userId;
setBodyParameter("UserId", userId);
std::string MergeVideoModelFaceRequest::getUserId() const {
return userId_;
}
std::string MergeVideoModelFaceRequest::getTemplateId()const
{
return templateId_;
void MergeVideoModelFaceRequest::setUserId(const std::string &userId) {
userId_ = userId;
setBodyParameter(std::string("UserId"), userId);
}
void MergeVideoModelFaceRequest::setTemplateId(const std::string& templateId)
{
templateId_ = templateId;
setBodyParameter("TemplateId", templateId);
std::string MergeVideoModelFaceRequest::getTemplateId() const {
return templateId_;
}
std::string MergeVideoModelFaceRequest::getAsync()const
{
return async_;
void MergeVideoModelFaceRequest::setTemplateId(const std::string &templateId) {
templateId_ = templateId;
setBodyParameter(std::string("TemplateId"), templateId);
}
void MergeVideoModelFaceRequest::setAsync(const std::string& async)
{
async_ = async;
setBodyParameter("Async", async);
std::string MergeVideoModelFaceRequest::getAsync() const {
return async_;
}
void MergeVideoModelFaceRequest::setAsync(const std::string &async) {
async_ = async;
setBodyParameter(std::string("Async"), async);
}

58
videoenhan/src/model/QueryFaceVideoTemplateRequest.cc
View File

@@ -1,51 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/videoenhan/model/QueryFaceVideoTemplateRequest.h>
using AlibabaCloud::Videoenhan::Model::QueryFaceVideoTemplateRequest;
QueryFaceVideoTemplateRequest::QueryFaceVideoTemplateRequest() :
RpcServiceRequest("videoenhan", "2020-03-20", "QueryFaceVideoTemplate")
{
setMethod(HttpRequest::Method::Post);
}
QueryFaceVideoTemplateRequest::~QueryFaceVideoTemplateRequest()
{}
std::string QueryFaceVideoTemplateRequest::getUserId()const
{
return userId_;
*/
#include <alibabacloud/videoenhan/model/QueryFaceVideoTemplateRequest.h>
using AlibabaCloud::Videoenhan::Model::QueryFaceVideoTemplateRequest;
QueryFaceVideoTemplateRequest::QueryFaceVideoTemplateRequest()
: RpcServiceRequest("videoenhan", "2020-03-20", "QueryFaceVideoTemplate") {
setMethod(HttpRequest::Method::Post);
}
void QueryFaceVideoTemplateRequest::setUserId(const std::string& userId)
{
userId_ = userId;
setParameter("UserId", userId);
QueryFaceVideoTemplateRequest::~QueryFaceVideoTemplateRequest() {}
std::string QueryFaceVideoTemplateRequest::getUserId() const {
return userId_;
}
std::string QueryFaceVideoTemplateRequest::getTemplateId()const
{
return templateId_;
void QueryFaceVideoTemplateRequest::setUserId(const std::string &userId) {
userId_ = userId;
setParameter(std::string("UserId"), userId);
}
void QueryFaceVideoTemplateRequest::setTemplateId(const std::string& templateId)
{
templateId_ = templateId;
setParameter("TemplateId", templateId);
std::string QueryFaceVideoTemplateRequest::getTemplateId() const {
return templateId_;
}
void QueryFaceVideoTemplateRequest::setTemplateId(const std::string &templateId) {
templateId_ = templateId;
setParameter(std::string("TemplateId"), templateId);
}

70
videoenhan/src/model/SuperResolveVideoRequest.cc
View File

@@ -1,62 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/videoenhan/model/SuperResolveVideoRequest.h>
using AlibabaCloud::Videoenhan::Model::SuperResolveVideoRequest;
SuperResolveVideoRequest::SuperResolveVideoRequest() :
RpcServiceRequest("videoenhan", "2020-03-20", "SuperResolveVideo")
{
setMethod(HttpRequest::Method::Post);
}
SuperResolveVideoRequest::~SuperResolveVideoRequest()
{}
int SuperResolveVideoRequest::getBitRate()const
{
return bitRate_;
*/
#include <alibabacloud/videoenhan/model/SuperResolveVideoRequest.h>
using AlibabaCloud::Videoenhan::Model::SuperResolveVideoRequest;
SuperResolveVideoRequest::SuperResolveVideoRequest()
: RpcServiceRequest("videoenhan", "2020-03-20", "SuperResolveVideo") {
setMethod(HttpRequest::Method::Post);
}
void SuperResolveVideoRequest::setBitRate(int bitRate)
{
bitRate_ = bitRate;
setBodyParameter("BitRate", std::to_string(bitRate));
SuperResolveVideoRequest::~SuperResolveVideoRequest() {}
int SuperResolveVideoRequest::getBitRate() const {
return bitRate_;
}
bool SuperResolveVideoRequest::getAsync()const
{
return async_;
void SuperResolveVideoRequest::setBitRate(int bitRate) {
bitRate_ = bitRate;
setBodyParameter(std::string("BitRate"), std::to_string(bitRate));
}
void SuperResolveVideoRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
bool SuperResolveVideoRequest::getAsync() const {
return async_;
}
std::string SuperResolveVideoRequest::getVideoUrl()const
{
return videoUrl_;
void SuperResolveVideoRequest::setAsync(bool async) {
async_ = async;
setBodyParameter(std::string("Async"), async ? "true" : "false");
}
void SuperResolveVideoRequest::setVideoUrl(const std::string& videoUrl)
{
videoUrl_ = videoUrl;
setBodyParameter("VideoUrl", videoUrl);
std::string SuperResolveVideoRequest::getVideoUrl() const {
return videoUrl_;
}
void SuperResolveVideoRequest::setVideoUrl(const std::string &videoUrl) {
videoUrl_ = videoUrl;
setBodyParameter(std::string("VideoUrl"), videoUrl);
}

82
videoenhan/src/model/ToneSdrVideoRequest.cc
View File

@@ -1,73 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/videoenhan/model/ToneSdrVideoRequest.h>
using AlibabaCloud::Videoenhan::Model::ToneSdrVideoRequest;
ToneSdrVideoRequest::ToneSdrVideoRequest() :
RpcServiceRequest("videoenhan", "2020-03-20", "ToneSdrVideo")
{
setMethod(HttpRequest::Method::Post);
}
ToneSdrVideoRequest::~ToneSdrVideoRequest()
{}
int ToneSdrVideoRequest::getBitrate()const
{
return bitrate_;
*/
#include <alibabacloud/videoenhan/model/ToneSdrVideoRequest.h>
using AlibabaCloud::Videoenhan::Model::ToneSdrVideoRequest;
ToneSdrVideoRequest::ToneSdrVideoRequest()
: RpcServiceRequest("videoenhan", "2020-03-20", "ToneSdrVideo") {
setMethod(HttpRequest::Method::Post);
}
void ToneSdrVideoRequest::setBitrate(int bitrate)
{
bitrate_ = bitrate;
setBodyParameter("Bitrate", std::to_string(bitrate));
ToneSdrVideoRequest::~ToneSdrVideoRequest() {}
int ToneSdrVideoRequest::getBitrate() const {
return bitrate_;
}
std::string ToneSdrVideoRequest::getRecolorModel()const
{
return recolorModel_;
void ToneSdrVideoRequest::setBitrate(int bitrate) {
bitrate_ = bitrate;
setBodyParameter(std::string("Bitrate"), std::to_string(bitrate));
}
void ToneSdrVideoRequest::setRecolorModel(const std::string& recolorModel)
{
recolorModel_ = recolorModel;
setBodyParameter("RecolorModel", recolorModel);
std::string ToneSdrVideoRequest::getRecolorModel() const {
return recolorModel_;
}
bool ToneSdrVideoRequest::getAsync()const
{
return async_;
void ToneSdrVideoRequest::setRecolorModel(const std::string &recolorModel) {
recolorModel_ = recolorModel;
setBodyParameter(std::string("RecolorModel"), recolorModel);
}
void ToneSdrVideoRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
bool ToneSdrVideoRequest::getAsync() const {
return async_;
}
std::string ToneSdrVideoRequest::getVideoURL()const
{
return videoURL_;
void ToneSdrVideoRequest::setAsync(bool async) {
async_ = async;
setBodyParameter(std::string("Async"), async ? "true" : "false");
}
void ToneSdrVideoRequest::setVideoURL(const std::string& videoURL)
{
videoURL_ = videoURL;
setBodyParameter("VideoURL", videoURL);
std::string ToneSdrVideoRequest::getVideoURL() const {
return videoURL_;
}
void ToneSdrVideoRequest::setVideoURL(const std::string &videoURL) {
videoURL_ = videoURL;
setBodyParameter(std::string("VideoURL"), videoURL);
}