Update videoenhan.

This commit is contained in:
sdk-team
2020-11-16 03:11:25 +00:00
parent 528d90a5e0
commit 5c14e9a77f
41 changed files with 3026 additions and 0 deletions

View File

@@ -1,3 +1,6 @@
2020-11-16 Version: patch
- Update videoenhan.
2020-11-16 Version: patch
- Update videoseg.

118
videoenhan/CMakeLists.txt Normal file
View File

@@ -0,0 +1,118 @@
#
# 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.
#
set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include)
set(videoenhan_public_header
include/alibabacloud/videoenhan/VideoenhanClient.h
include/alibabacloud/videoenhan/VideoenhanExport.h )
set(videoenhan_public_header_model
include/alibabacloud/videoenhan/model/AbstractEcommerceVideoRequest.h
include/alibabacloud/videoenhan/model/AbstractEcommerceVideoResult.h
include/alibabacloud/videoenhan/model/AbstractFilmVideoRequest.h
include/alibabacloud/videoenhan/model/AbstractFilmVideoResult.h
include/alibabacloud/videoenhan/model/AdjustVideoColorRequest.h
include/alibabacloud/videoenhan/model/AdjustVideoColorResult.h
include/alibabacloud/videoenhan/model/ChangeVideoSizeRequest.h
include/alibabacloud/videoenhan/model/ChangeVideoSizeResult.h
include/alibabacloud/videoenhan/model/EraseVideoLogoRequest.h
include/alibabacloud/videoenhan/model/EraseVideoLogoResult.h
include/alibabacloud/videoenhan/model/EraseVideoSubtitlesRequest.h
include/alibabacloud/videoenhan/model/EraseVideoSubtitlesResult.h
include/alibabacloud/videoenhan/model/GenerateVideoRequest.h
include/alibabacloud/videoenhan/model/GenerateVideoResult.h
include/alibabacloud/videoenhan/model/GetAsyncJobResultRequest.h
include/alibabacloud/videoenhan/model/GetAsyncJobResultResult.h
include/alibabacloud/videoenhan/model/SuperResolveVideoRequest.h
include/alibabacloud/videoenhan/model/SuperResolveVideoResult.h )
set(videoenhan_src
src/VideoenhanClient.cc
src/model/AbstractEcommerceVideoRequest.cc
src/model/AbstractEcommerceVideoResult.cc
src/model/AbstractFilmVideoRequest.cc
src/model/AbstractFilmVideoResult.cc
src/model/AdjustVideoColorRequest.cc
src/model/AdjustVideoColorResult.cc
src/model/ChangeVideoSizeRequest.cc
src/model/ChangeVideoSizeResult.cc
src/model/EraseVideoLogoRequest.cc
src/model/EraseVideoLogoResult.cc
src/model/EraseVideoSubtitlesRequest.cc
src/model/EraseVideoSubtitlesResult.cc
src/model/GenerateVideoRequest.cc
src/model/GenerateVideoResult.cc
src/model/GetAsyncJobResultRequest.cc
src/model/GetAsyncJobResultResult.cc
src/model/SuperResolveVideoRequest.cc
src/model/SuperResolveVideoResult.cc )
add_library(videoenhan ${LIB_TYPE}
${videoenhan_public_header}
${videoenhan_public_header_model}
${videoenhan_src})
set_target_properties(videoenhan
PROPERTIES
LINKER_LANGUAGE CXX
ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
OUTPUT_NAME ${TARGET_OUTPUT_NAME_PREFIX}videoenhan
)
if(${LIB_TYPE} STREQUAL "SHARED")
set_target_properties(videoenhan
PROPERTIES
DEFINE_SYMBOL ALIBABACLOUD_VIDEOENHAN_LIBRARY)
endif()
target_include_directories(videoenhan
PRIVATE include
${CMAKE_SOURCE_DIR}/core/include
)
target_link_libraries(videoenhan
core)
if(CMAKE_HOST_WIN32)
ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
set(jsoncpp_install_dir ${INSTALL_DIR})
add_dependencies(videoenhan
jsoncpp)
target_include_directories(videoenhan
PRIVATE ${jsoncpp_install_dir}/include)
target_link_libraries(videoenhan
${jsoncpp_install_dir}/lib/jsoncpp.lib)
set_target_properties(videoenhan
PROPERTIES
COMPILE_OPTIONS "/bigobj")
else()
target_include_directories(videoenhan
PRIVATE /usr/include/jsoncpp)
target_link_libraries(videoenhan
jsoncpp)
endif()
install(FILES ${videoenhan_public_header}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/videoenhan)
install(FILES ${videoenhan_public_header_model}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/videoenhan/model)
install(TARGETS videoenhan
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)

View File

@@ -0,0 +1,118 @@
/*
* 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_VIDEOENHANCLIENT_H_
#define ALIBABACLOUD_VIDEOENHAN_VIDEOENHANCLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "VideoenhanExport.h"
#include "model/AbstractEcommerceVideoRequest.h"
#include "model/AbstractEcommerceVideoResult.h"
#include "model/AbstractFilmVideoRequest.h"
#include "model/AbstractFilmVideoResult.h"
#include "model/AdjustVideoColorRequest.h"
#include "model/AdjustVideoColorResult.h"
#include "model/ChangeVideoSizeRequest.h"
#include "model/ChangeVideoSizeResult.h"
#include "model/EraseVideoLogoRequest.h"
#include "model/EraseVideoLogoResult.h"
#include "model/EraseVideoSubtitlesRequest.h"
#include "model/EraseVideoSubtitlesResult.h"
#include "model/GenerateVideoRequest.h"
#include "model/GenerateVideoResult.h"
#include "model/GetAsyncJobResultRequest.h"
#include "model/GetAsyncJobResultResult.h"
#include "model/SuperResolveVideoRequest.h"
#include "model/SuperResolveVideoResult.h"
namespace AlibabaCloud
{
namespace Videoenhan
{
class ALIBABACLOUD_VIDEOENHAN_EXPORT VideoenhanClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::AbstractEcommerceVideoResult> AbstractEcommerceVideoOutcome;
typedef std::future<AbstractEcommerceVideoOutcome> AbstractEcommerceVideoOutcomeCallable;
typedef std::function<void(const VideoenhanClient*, const Model::AbstractEcommerceVideoRequest&, const AbstractEcommerceVideoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AbstractEcommerceVideoAsyncHandler;
typedef Outcome<Error, Model::AbstractFilmVideoResult> AbstractFilmVideoOutcome;
typedef std::future<AbstractFilmVideoOutcome> AbstractFilmVideoOutcomeCallable;
typedef std::function<void(const VideoenhanClient*, const Model::AbstractFilmVideoRequest&, const AbstractFilmVideoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AbstractFilmVideoAsyncHandler;
typedef Outcome<Error, Model::AdjustVideoColorResult> AdjustVideoColorOutcome;
typedef std::future<AdjustVideoColorOutcome> AdjustVideoColorOutcomeCallable;
typedef std::function<void(const VideoenhanClient*, const Model::AdjustVideoColorRequest&, const AdjustVideoColorOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AdjustVideoColorAsyncHandler;
typedef Outcome<Error, Model::ChangeVideoSizeResult> ChangeVideoSizeOutcome;
typedef std::future<ChangeVideoSizeOutcome> ChangeVideoSizeOutcomeCallable;
typedef std::function<void(const VideoenhanClient*, const Model::ChangeVideoSizeRequest&, const ChangeVideoSizeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ChangeVideoSizeAsyncHandler;
typedef Outcome<Error, Model::EraseVideoLogoResult> EraseVideoLogoOutcome;
typedef std::future<EraseVideoLogoOutcome> EraseVideoLogoOutcomeCallable;
typedef std::function<void(const VideoenhanClient*, const Model::EraseVideoLogoRequest&, const EraseVideoLogoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EraseVideoLogoAsyncHandler;
typedef Outcome<Error, Model::EraseVideoSubtitlesResult> EraseVideoSubtitlesOutcome;
typedef std::future<EraseVideoSubtitlesOutcome> EraseVideoSubtitlesOutcomeCallable;
typedef std::function<void(const VideoenhanClient*, const Model::EraseVideoSubtitlesRequest&, const EraseVideoSubtitlesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EraseVideoSubtitlesAsyncHandler;
typedef Outcome<Error, Model::GenerateVideoResult> GenerateVideoOutcome;
typedef std::future<GenerateVideoOutcome> GenerateVideoOutcomeCallable;
typedef std::function<void(const VideoenhanClient*, const Model::GenerateVideoRequest&, const GenerateVideoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GenerateVideoAsyncHandler;
typedef Outcome<Error, Model::GetAsyncJobResultResult> GetAsyncJobResultOutcome;
typedef std::future<GetAsyncJobResultOutcome> GetAsyncJobResultOutcomeCallable;
typedef std::function<void(const VideoenhanClient*, const Model::GetAsyncJobResultRequest&, const GetAsyncJobResultOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAsyncJobResultAsyncHandler;
typedef Outcome<Error, Model::SuperResolveVideoResult> SuperResolveVideoOutcome;
typedef std::future<SuperResolveVideoOutcome> SuperResolveVideoOutcomeCallable;
typedef std::function<void(const VideoenhanClient*, const Model::SuperResolveVideoRequest&, const SuperResolveVideoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SuperResolveVideoAsyncHandler;
VideoenhanClient(const Credentials &credentials, const ClientConfiguration &configuration);
VideoenhanClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
VideoenhanClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~VideoenhanClient();
AbstractEcommerceVideoOutcome abstractEcommerceVideo(const Model::AbstractEcommerceVideoRequest &request)const;
void abstractEcommerceVideoAsync(const Model::AbstractEcommerceVideoRequest& request, const AbstractEcommerceVideoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AbstractEcommerceVideoOutcomeCallable abstractEcommerceVideoCallable(const Model::AbstractEcommerceVideoRequest& request) const;
AbstractFilmVideoOutcome abstractFilmVideo(const Model::AbstractFilmVideoRequest &request)const;
void abstractFilmVideoAsync(const Model::AbstractFilmVideoRequest& request, const AbstractFilmVideoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AbstractFilmVideoOutcomeCallable abstractFilmVideoCallable(const Model::AbstractFilmVideoRequest& request) const;
AdjustVideoColorOutcome adjustVideoColor(const Model::AdjustVideoColorRequest &request)const;
void adjustVideoColorAsync(const Model::AdjustVideoColorRequest& request, const AdjustVideoColorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AdjustVideoColorOutcomeCallable adjustVideoColorCallable(const Model::AdjustVideoColorRequest& request) const;
ChangeVideoSizeOutcome changeVideoSize(const Model::ChangeVideoSizeRequest &request)const;
void changeVideoSizeAsync(const Model::ChangeVideoSizeRequest& request, const ChangeVideoSizeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ChangeVideoSizeOutcomeCallable changeVideoSizeCallable(const Model::ChangeVideoSizeRequest& request) const;
EraseVideoLogoOutcome eraseVideoLogo(const Model::EraseVideoLogoRequest &request)const;
void eraseVideoLogoAsync(const Model::EraseVideoLogoRequest& request, const EraseVideoLogoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
EraseVideoLogoOutcomeCallable eraseVideoLogoCallable(const Model::EraseVideoLogoRequest& request) const;
EraseVideoSubtitlesOutcome eraseVideoSubtitles(const Model::EraseVideoSubtitlesRequest &request)const;
void eraseVideoSubtitlesAsync(const Model::EraseVideoSubtitlesRequest& request, const EraseVideoSubtitlesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
EraseVideoSubtitlesOutcomeCallable eraseVideoSubtitlesCallable(const Model::EraseVideoSubtitlesRequest& request) const;
GenerateVideoOutcome generateVideo(const Model::GenerateVideoRequest &request)const;
void generateVideoAsync(const Model::GenerateVideoRequest& request, const GenerateVideoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GenerateVideoOutcomeCallable generateVideoCallable(const Model::GenerateVideoRequest& request) const;
GetAsyncJobResultOutcome getAsyncJobResult(const Model::GetAsyncJobResultRequest &request)const;
void getAsyncJobResultAsync(const Model::GetAsyncJobResultRequest& request, const GetAsyncJobResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetAsyncJobResultOutcomeCallable getAsyncJobResultCallable(const Model::GetAsyncJobResultRequest& request) const;
SuperResolveVideoOutcome superResolveVideo(const Model::SuperResolveVideoRequest &request)const;
void superResolveVideoAsync(const Model::SuperResolveVideoRequest& request, const SuperResolveVideoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SuperResolveVideoOutcomeCallable superResolveVideoCallable(const Model::SuperResolveVideoRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_VIDEOENHAN_VIDEOENHANCLIENT_H_

View File

@@ -0,0 +1,32 @@
/*
* 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_VIDEOENHANEXPORT_H_
#define ALIBABACLOUD_VIDEOENHAN_VIDEOENHANEXPORT_H_
#include <alibabacloud/core/Global.h>
#if defined(ALIBABACLOUD_SHARED)
# if defined(ALIBABACLOUD_VIDEOENHAN_LIBRARY)
# define ALIBABACLOUD_VIDEOENHAN_EXPORT ALIBABACLOUD_DECL_EXPORT
# else
# define ALIBABACLOUD_VIDEOENHAN_EXPORT ALIBABACLOUD_DECL_IMPORT
# endif
#else
# define ALIBABACLOUD_VIDEOENHAN_EXPORT
#endif
#endif // !ALIBABACLOUD_VIDEOENHAN_VIDEOENHANEXPORT_H_

View File

@@ -0,0 +1,60 @@
/*
* 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);
bool getAsync()const;
void setAsync(bool async);
std::string getVideoUrl()const;
void setVideoUrl(const std::string& videoUrl);
int getWidth()const;
void setWidth(int width);
int getHeight()const;
void setHeight(int height);
private:
float duration_;
bool async_;
std::string videoUrl_;
int width_;
int height_;
};
}
}
}
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_ABSTRACTECOMMERCEVIDEOREQUEST_H_

View File

@@ -0,0 +1,56 @@
/*
* 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_ABSTRACTECOMMERCEVIDEORESULT_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_ABSTRACTECOMMERCEVIDEORESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/videoenhan/VideoenhanExport.h>
namespace AlibabaCloud
{
namespace Videoenhan
{
namespace Model
{
class ALIBABACLOUD_VIDEOENHAN_EXPORT AbstractEcommerceVideoResult : public ServiceResult
{
public:
struct Data
{
std::string videoCoverUrl;
std::string videoUrl;
};
AbstractEcommerceVideoResult();
explicit AbstractEcommerceVideoResult(const std::string &payload);
~AbstractEcommerceVideoResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_ABSTRACTECOMMERCEVIDEORESULT_H_

View File

@@ -0,0 +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_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_

View File

@@ -0,0 +1,55 @@
/*
* 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_ABSTRACTFILMVIDEORESULT_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_ABSTRACTFILMVIDEORESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/videoenhan/VideoenhanExport.h>
namespace AlibabaCloud
{
namespace Videoenhan
{
namespace Model
{
class ALIBABACLOUD_VIDEOENHAN_EXPORT AbstractFilmVideoResult : public ServiceResult
{
public:
struct Data
{
std::string videoUrl;
};
AbstractFilmVideoResult();
explicit AbstractFilmVideoResult(const std::string &payload);
~AbstractFilmVideoResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_ABSTRACTFILMVIDEORESULT_H_

View File

@@ -0,0 +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_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);
std::string getVideoBitrate()const;
void setVideoBitrate(const std::string& 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_;
std::string videoBitrate_;
std::string videoCodec_;
std::string videoFormat_;
};
}
}
}
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_ADJUSTVIDEOCOLORREQUEST_H_

View File

@@ -0,0 +1,55 @@
/*
* 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_ADJUSTVIDEOCOLORRESULT_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_ADJUSTVIDEOCOLORRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/videoenhan/VideoenhanExport.h>
namespace AlibabaCloud
{
namespace Videoenhan
{
namespace Model
{
class ALIBABACLOUD_VIDEOENHAN_EXPORT AdjustVideoColorResult : public ServiceResult
{
public:
struct Data
{
std::string videoUrl;
};
AdjustVideoColorResult();
explicit AdjustVideoColorResult(const std::string &payload);
~AdjustVideoColorResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_ADJUSTVIDEOCOLORRESULT_H_

View File

@@ -0,0 +1,75 @@
/*
* 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_

View File

@@ -0,0 +1,56 @@
/*
* 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_CHANGEVIDEOSIZERESULT_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_CHANGEVIDEOSIZERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/videoenhan/VideoenhanExport.h>
namespace AlibabaCloud
{
namespace Videoenhan
{
namespace Model
{
class ALIBABACLOUD_VIDEOENHAN_EXPORT ChangeVideoSizeResult : public ServiceResult
{
public:
struct Data
{
std::string videoCoverUrl;
std::string videoUrl;
};
ChangeVideoSizeResult();
explicit ChangeVideoSizeResult(const std::string &payload);
~ChangeVideoSizeResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_CHANGEVIDEOSIZERESULT_H_

View File

@@ -0,0 +1,62 @@
/*
* 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_

View File

@@ -0,0 +1,55 @@
/*
* 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_ERASEVIDEOLOGORESULT_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_ERASEVIDEOLOGORESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/videoenhan/VideoenhanExport.h>
namespace AlibabaCloud
{
namespace Videoenhan
{
namespace Model
{
class ALIBABACLOUD_VIDEOENHAN_EXPORT EraseVideoLogoResult : public ServiceResult
{
public:
struct Data
{
std::string videoUrl;
};
EraseVideoLogoResult();
explicit EraseVideoLogoResult(const std::string &payload);
~EraseVideoLogoResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_ERASEVIDEOLOGORESULT_H_

View File

@@ -0,0 +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_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);
bool getAsync()const;
void setAsync(bool async);
std::string getVideoUrl()const;
void setVideoUrl(const std::string& videoUrl);
float getBW()const;
void setBW(float bW);
float getBX()const;
void setBX(float bX);
float getBY()const;
void setBY(float bY);
private:
float bH_;
bool async_;
std::string videoUrl_;
float bW_;
float bX_;
float bY_;
};
}
}
}
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_ERASEVIDEOSUBTITLESREQUEST_H_

View File

@@ -0,0 +1,55 @@
/*
* 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_ERASEVIDEOSUBTITLESRESULT_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_ERASEVIDEOSUBTITLESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/videoenhan/VideoenhanExport.h>
namespace AlibabaCloud
{
namespace Videoenhan
{
namespace Model
{
class ALIBABACLOUD_VIDEOENHAN_EXPORT EraseVideoSubtitlesResult : public ServiceResult
{
public:
struct Data
{
std::string videoUrl;
};
EraseVideoSubtitlesResult();
explicit EraseVideoSubtitlesResult(const std::string &payload);
~EraseVideoSubtitlesResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_ERASEVIDEOSUBTITLESRESULT_H_

View File

@@ -0,0 +1,88 @@
/*
* 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_

View File

@@ -0,0 +1,56 @@
/*
* 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_GENERATEVIDEORESULT_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_GENERATEVIDEORESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/videoenhan/VideoenhanExport.h>
namespace AlibabaCloud
{
namespace Videoenhan
{
namespace Model
{
class ALIBABACLOUD_VIDEOENHAN_EXPORT GenerateVideoResult : public ServiceResult
{
public:
struct Data
{
std::string videoCoverUrl;
std::string videoUrl;
};
GenerateVideoResult();
explicit GenerateVideoResult(const std::string &payload);
~GenerateVideoResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_GENERATEVIDEORESULT_H_

View File

@@ -0,0 +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_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();
bool getAsync()const;
void setAsync(bool async);
std::string getJobId()const;
void setJobId(const std::string& jobId);
private:
bool async_;
std::string jobId_;
};
}
}
}
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_GETASYNCJOBRESULTREQUEST_H_

View File

@@ -0,0 +1,59 @@
/*
* 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_GETASYNCJOBRESULTRESULT_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_GETASYNCJOBRESULTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/videoenhan/VideoenhanExport.h>
namespace AlibabaCloud
{
namespace Videoenhan
{
namespace Model
{
class ALIBABACLOUD_VIDEOENHAN_EXPORT GetAsyncJobResultResult : public ServiceResult
{
public:
struct Data
{
std::string status;
std::string errorCode;
std::string errorMessage;
std::string jobId;
std::string result;
};
GetAsyncJobResultResult();
explicit GetAsyncJobResultResult(const std::string &payload);
~GetAsyncJobResultResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_GETASYNCJOBRESULTRESULT_H_

View File

@@ -0,0 +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_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_

View File

@@ -0,0 +1,55 @@
/*
* 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_SUPERRESOLVEVIDEORESULT_H_
#define ALIBABACLOUD_VIDEOENHAN_MODEL_SUPERRESOLVEVIDEORESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/videoenhan/VideoenhanExport.h>
namespace AlibabaCloud
{
namespace Videoenhan
{
namespace Model
{
class ALIBABACLOUD_VIDEOENHAN_EXPORT SuperResolveVideoResult : public ServiceResult
{
public:
struct Data
{
std::string videoUrl;
};
SuperResolveVideoResult();
explicit SuperResolveVideoResult(const std::string &payload);
~SuperResolveVideoResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_VIDEOENHAN_MODEL_SUPERRESOLVEVIDEORESULT_H_

View File

@@ -0,0 +1,377 @@
/*
* 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/VideoenhanClient.h>
#include <alibabacloud/core/SimpleCredentialsProvider.h>
using namespace AlibabaCloud;
using namespace AlibabaCloud::Location;
using namespace AlibabaCloud::Videoenhan;
using namespace AlibabaCloud::Videoenhan::Model;
namespace
{
const std::string SERVICE_NAME = "videoenhan";
}
VideoenhanClient::VideoenhanClient(const Credentials &credentials, const ClientConfiguration &configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "videoenhan");
}
VideoenhanClient::VideoenhanClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
{
auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "videoenhan");
}
VideoenhanClient::VideoenhanClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
{
auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "videoenhan");
}
VideoenhanClient::~VideoenhanClient()
{}
VideoenhanClient::AbstractEcommerceVideoOutcome VideoenhanClient::abstractEcommerceVideo(const AbstractEcommerceVideoRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return AbstractEcommerceVideoOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return AbstractEcommerceVideoOutcome(AbstractEcommerceVideoResult(outcome.result()));
else
return AbstractEcommerceVideoOutcome(outcome.error());
}
void VideoenhanClient::abstractEcommerceVideoAsync(const AbstractEcommerceVideoRequest& request, const AbstractEcommerceVideoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, abstractEcommerceVideo(request), context);
};
asyncExecute(new Runnable(fn));
}
VideoenhanClient::AbstractEcommerceVideoOutcomeCallable VideoenhanClient::abstractEcommerceVideoCallable(const AbstractEcommerceVideoRequest &request) const
{
auto task = std::make_shared<std::packaged_task<AbstractEcommerceVideoOutcome()>>(
[this, request]()
{
return this->abstractEcommerceVideo(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
VideoenhanClient::AbstractFilmVideoOutcome VideoenhanClient::abstractFilmVideo(const AbstractFilmVideoRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return AbstractFilmVideoOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return AbstractFilmVideoOutcome(AbstractFilmVideoResult(outcome.result()));
else
return AbstractFilmVideoOutcome(outcome.error());
}
void VideoenhanClient::abstractFilmVideoAsync(const AbstractFilmVideoRequest& request, const AbstractFilmVideoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, abstractFilmVideo(request), context);
};
asyncExecute(new Runnable(fn));
}
VideoenhanClient::AbstractFilmVideoOutcomeCallable VideoenhanClient::abstractFilmVideoCallable(const AbstractFilmVideoRequest &request) const
{
auto task = std::make_shared<std::packaged_task<AbstractFilmVideoOutcome()>>(
[this, request]()
{
return this->abstractFilmVideo(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
VideoenhanClient::AdjustVideoColorOutcome VideoenhanClient::adjustVideoColor(const AdjustVideoColorRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return AdjustVideoColorOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return AdjustVideoColorOutcome(AdjustVideoColorResult(outcome.result()));
else
return AdjustVideoColorOutcome(outcome.error());
}
void VideoenhanClient::adjustVideoColorAsync(const AdjustVideoColorRequest& request, const AdjustVideoColorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, adjustVideoColor(request), context);
};
asyncExecute(new Runnable(fn));
}
VideoenhanClient::AdjustVideoColorOutcomeCallable VideoenhanClient::adjustVideoColorCallable(const AdjustVideoColorRequest &request) const
{
auto task = std::make_shared<std::packaged_task<AdjustVideoColorOutcome()>>(
[this, request]()
{
return this->adjustVideoColor(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
VideoenhanClient::ChangeVideoSizeOutcome VideoenhanClient::changeVideoSize(const ChangeVideoSizeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return ChangeVideoSizeOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return ChangeVideoSizeOutcome(ChangeVideoSizeResult(outcome.result()));
else
return ChangeVideoSizeOutcome(outcome.error());
}
void VideoenhanClient::changeVideoSizeAsync(const ChangeVideoSizeRequest& request, const ChangeVideoSizeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, changeVideoSize(request), context);
};
asyncExecute(new Runnable(fn));
}
VideoenhanClient::ChangeVideoSizeOutcomeCallable VideoenhanClient::changeVideoSizeCallable(const ChangeVideoSizeRequest &request) const
{
auto task = std::make_shared<std::packaged_task<ChangeVideoSizeOutcome()>>(
[this, request]()
{
return this->changeVideoSize(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
VideoenhanClient::EraseVideoLogoOutcome VideoenhanClient::eraseVideoLogo(const EraseVideoLogoRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return EraseVideoLogoOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return EraseVideoLogoOutcome(EraseVideoLogoResult(outcome.result()));
else
return EraseVideoLogoOutcome(outcome.error());
}
void VideoenhanClient::eraseVideoLogoAsync(const EraseVideoLogoRequest& request, const EraseVideoLogoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, eraseVideoLogo(request), context);
};
asyncExecute(new Runnable(fn));
}
VideoenhanClient::EraseVideoLogoOutcomeCallable VideoenhanClient::eraseVideoLogoCallable(const EraseVideoLogoRequest &request) const
{
auto task = std::make_shared<std::packaged_task<EraseVideoLogoOutcome()>>(
[this, request]()
{
return this->eraseVideoLogo(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
VideoenhanClient::EraseVideoSubtitlesOutcome VideoenhanClient::eraseVideoSubtitles(const EraseVideoSubtitlesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return EraseVideoSubtitlesOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return EraseVideoSubtitlesOutcome(EraseVideoSubtitlesResult(outcome.result()));
else
return EraseVideoSubtitlesOutcome(outcome.error());
}
void VideoenhanClient::eraseVideoSubtitlesAsync(const EraseVideoSubtitlesRequest& request, const EraseVideoSubtitlesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, eraseVideoSubtitles(request), context);
};
asyncExecute(new Runnable(fn));
}
VideoenhanClient::EraseVideoSubtitlesOutcomeCallable VideoenhanClient::eraseVideoSubtitlesCallable(const EraseVideoSubtitlesRequest &request) const
{
auto task = std::make_shared<std::packaged_task<EraseVideoSubtitlesOutcome()>>(
[this, request]()
{
return this->eraseVideoSubtitles(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
VideoenhanClient::GenerateVideoOutcome VideoenhanClient::generateVideo(const GenerateVideoRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GenerateVideoOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GenerateVideoOutcome(GenerateVideoResult(outcome.result()));
else
return GenerateVideoOutcome(outcome.error());
}
void VideoenhanClient::generateVideoAsync(const GenerateVideoRequest& request, const GenerateVideoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, generateVideo(request), context);
};
asyncExecute(new Runnable(fn));
}
VideoenhanClient::GenerateVideoOutcomeCallable VideoenhanClient::generateVideoCallable(const GenerateVideoRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GenerateVideoOutcome()>>(
[this, request]()
{
return this->generateVideo(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
VideoenhanClient::GetAsyncJobResultOutcome VideoenhanClient::getAsyncJobResult(const GetAsyncJobResultRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return GetAsyncJobResultOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return GetAsyncJobResultOutcome(GetAsyncJobResultResult(outcome.result()));
else
return GetAsyncJobResultOutcome(outcome.error());
}
void VideoenhanClient::getAsyncJobResultAsync(const GetAsyncJobResultRequest& request, const GetAsyncJobResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, getAsyncJobResult(request), context);
};
asyncExecute(new Runnable(fn));
}
VideoenhanClient::GetAsyncJobResultOutcomeCallable VideoenhanClient::getAsyncJobResultCallable(const GetAsyncJobResultRequest &request) const
{
auto task = std::make_shared<std::packaged_task<GetAsyncJobResultOutcome()>>(
[this, request]()
{
return this->getAsyncJobResult(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
VideoenhanClient::SuperResolveVideoOutcome VideoenhanClient::superResolveVideo(const SuperResolveVideoRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SuperResolveVideoOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SuperResolveVideoOutcome(SuperResolveVideoResult(outcome.result()));
else
return SuperResolveVideoOutcome(outcome.error());
}
void VideoenhanClient::superResolveVideoAsync(const SuperResolveVideoRequest& request, const SuperResolveVideoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, superResolveVideo(request), context);
};
asyncExecute(new Runnable(fn));
}
VideoenhanClient::SuperResolveVideoOutcomeCallable VideoenhanClient::superResolveVideoCallable(const SuperResolveVideoRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SuperResolveVideoOutcome()>>(
[this, request]()
{
return this->superResolveVideo(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}

View File

@@ -0,0 +1,84 @@
/*
* 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_;
}
void AbstractEcommerceVideoRequest::setDuration(float duration)
{
duration_ = duration;
setBodyParameter("Duration", std::to_string(duration));
}
bool AbstractEcommerceVideoRequest::getAsync()const
{
return async_;
}
void AbstractEcommerceVideoRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
}
std::string AbstractEcommerceVideoRequest::getVideoUrl()const
{
return videoUrl_;
}
void AbstractEcommerceVideoRequest::setVideoUrl(const std::string& videoUrl)
{
videoUrl_ = videoUrl;
setBodyParameter("VideoUrl", videoUrl);
}
int AbstractEcommerceVideoRequest::getWidth()const
{
return width_;
}
void AbstractEcommerceVideoRequest::setWidth(int width)
{
width_ = width;
setBodyParameter("Width", std::to_string(width));
}
int AbstractEcommerceVideoRequest::getHeight()const
{
return height_;
}
void AbstractEcommerceVideoRequest::setHeight(int height)
{
height_ = height;
setBodyParameter("Height", std::to_string(height));
}

View File

@@ -0,0 +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/AbstractEcommerceVideoResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Videoenhan;
using namespace AlibabaCloud::Videoenhan::Model;
AbstractEcommerceVideoResult::AbstractEcommerceVideoResult() :
ServiceResult()
{}
AbstractEcommerceVideoResult::AbstractEcommerceVideoResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
AbstractEcommerceVideoResult::~AbstractEcommerceVideoResult()
{}
void AbstractEcommerceVideoResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["VideoUrl"].isNull())
data_.videoUrl = dataNode["VideoUrl"].asString();
if(!dataNode["VideoCoverUrl"].isNull())
data_.videoCoverUrl = dataNode["VideoCoverUrl"].asString();
}
AbstractEcommerceVideoResult::Data AbstractEcommerceVideoResult::getData()const
{
return data_;
}

View File

@@ -0,0 +1,62 @@
/*
* 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_;
}
void AbstractFilmVideoRequest::setLength(int length)
{
length_ = length;
setBodyParameter("Length", std::to_string(length));
}
bool AbstractFilmVideoRequest::getAsync()const
{
return async_;
}
void AbstractFilmVideoRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
}
std::string AbstractFilmVideoRequest::getVideoUrl()const
{
return videoUrl_;
}
void AbstractFilmVideoRequest::setVideoUrl(const std::string& videoUrl)
{
videoUrl_ = videoUrl;
setBodyParameter("VideoUrl", videoUrl);
}

View File

@@ -0,0 +1,52 @@
/*
* 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/AbstractFilmVideoResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Videoenhan;
using namespace AlibabaCloud::Videoenhan::Model;
AbstractFilmVideoResult::AbstractFilmVideoResult() :
ServiceResult()
{}
AbstractFilmVideoResult::AbstractFilmVideoResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
AbstractFilmVideoResult::~AbstractFilmVideoResult()
{}
void AbstractFilmVideoResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["VideoUrl"].isNull())
data_.videoUrl = dataNode["VideoUrl"].asString();
}
AbstractFilmVideoResult::Data AbstractFilmVideoResult::getData()const
{
return data_;
}

View File

@@ -0,0 +1,95 @@
/*
* 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_;
}
void AdjustVideoColorRequest::setMode(const std::string& mode)
{
mode_ = mode;
setBodyParameter("Mode", mode);
}
bool AdjustVideoColorRequest::getAsync()const
{
return async_;
}
void AdjustVideoColorRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
}
std::string AdjustVideoColorRequest::getVideoUrl()const
{
return videoUrl_;
}
void AdjustVideoColorRequest::setVideoUrl(const std::string& videoUrl)
{
videoUrl_ = videoUrl;
setBodyParameter("VideoUrl", videoUrl);
}
std::string AdjustVideoColorRequest::getVideoBitrate()const
{
return videoBitrate_;
}
void AdjustVideoColorRequest::setVideoBitrate(const std::string& videoBitrate)
{
videoBitrate_ = videoBitrate;
setBodyParameter("VideoBitrate", videoBitrate);
}
std::string AdjustVideoColorRequest::getVideoCodec()const
{
return videoCodec_;
}
void AdjustVideoColorRequest::setVideoCodec(const std::string& videoCodec)
{
videoCodec_ = videoCodec;
setBodyParameter("VideoCodec", videoCodec);
}
std::string AdjustVideoColorRequest::getVideoFormat()const
{
return videoFormat_;
}
void AdjustVideoColorRequest::setVideoFormat(const std::string& videoFormat)
{
videoFormat_ = videoFormat;
setBodyParameter("VideoFormat", videoFormat);
}

View File

@@ -0,0 +1,52 @@
/*
* 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/AdjustVideoColorResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Videoenhan;
using namespace AlibabaCloud::Videoenhan::Model;
AdjustVideoColorResult::AdjustVideoColorResult() :
ServiceResult()
{}
AdjustVideoColorResult::AdjustVideoColorResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
AdjustVideoColorResult::~AdjustVideoColorResult()
{}
void AdjustVideoColorResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["VideoUrl"].isNull())
data_.videoUrl = dataNode["VideoUrl"].asString();
}
AdjustVideoColorResult::Data AdjustVideoColorResult::getData()const
{
return data_;
}

View File

@@ -0,0 +1,139 @@
/*
* 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_;
}
void ChangeVideoSizeRequest::setHeight(int height)
{
height_ = height;
setBodyParameter("Height", std::to_string(height));
}
int ChangeVideoSizeRequest::getB()const
{
return b_;
}
void ChangeVideoSizeRequest::setB(int b)
{
b_ = b;
setBodyParameter("B", std::to_string(b));
}
std::string ChangeVideoSizeRequest::getFillType()const
{
return fillType_;
}
void ChangeVideoSizeRequest::setFillType(const std::string& fillType)
{
fillType_ = fillType;
setBodyParameter("FillType", fillType);
}
int ChangeVideoSizeRequest::getG()const
{
return g_;
}
void ChangeVideoSizeRequest::setG(int g)
{
g_ = g;
setBodyParameter("G", std::to_string(g));
}
std::string ChangeVideoSizeRequest::getCropType()const
{
return cropType_;
}
void ChangeVideoSizeRequest::setCropType(const std::string& cropType)
{
cropType_ = cropType;
setBodyParameter("CropType", cropType);
}
bool ChangeVideoSizeRequest::getAsync()const
{
return async_;
}
void ChangeVideoSizeRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
}
int ChangeVideoSizeRequest::getR()const
{
return r_;
}
void ChangeVideoSizeRequest::setR(int r)
{
r_ = r;
setBodyParameter("R", std::to_string(r));
}
std::string ChangeVideoSizeRequest::getVideoUrl()const
{
return videoUrl_;
}
void ChangeVideoSizeRequest::setVideoUrl(const std::string& videoUrl)
{
videoUrl_ = videoUrl;
setBodyParameter("VideoUrl", videoUrl);
}
int ChangeVideoSizeRequest::getWidth()const
{
return width_;
}
void ChangeVideoSizeRequest::setWidth(int width)
{
width_ = width;
setBodyParameter("Width", std::to_string(width));
}
float ChangeVideoSizeRequest::getTightness()const
{
return tightness_;
}
void ChangeVideoSizeRequest::setTightness(float tightness)
{
tightness_ = tightness;
setBodyParameter("Tightness", std::to_string(tightness));
}

View File

@@ -0,0 +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/ChangeVideoSizeResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Videoenhan;
using namespace AlibabaCloud::Videoenhan::Model;
ChangeVideoSizeResult::ChangeVideoSizeResult() :
ServiceResult()
{}
ChangeVideoSizeResult::ChangeVideoSizeResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
ChangeVideoSizeResult::~ChangeVideoSizeResult()
{}
void ChangeVideoSizeResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["VideoUrl"].isNull())
data_.videoUrl = dataNode["VideoUrl"].asString();
if(!dataNode["VideoCoverUrl"].isNull())
data_.videoCoverUrl = dataNode["VideoCoverUrl"].asString();
}
ChangeVideoSizeResult::Data ChangeVideoSizeResult::getData()const
{
return data_;
}

View File

@@ -0,0 +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.
*/
#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_;
}
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));
}
}
bool EraseVideoLogoRequest::getAsync()const
{
return async_;
}
void EraseVideoLogoRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
}
std::string EraseVideoLogoRequest::getVideoUrl()const
{
return videoUrl_;
}
void EraseVideoLogoRequest::setVideoUrl(const std::string& videoUrl)
{
videoUrl_ = videoUrl;
setBodyParameter("VideoUrl", videoUrl);
}

View File

@@ -0,0 +1,52 @@
/*
* 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/EraseVideoLogoResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Videoenhan;
using namespace AlibabaCloud::Videoenhan::Model;
EraseVideoLogoResult::EraseVideoLogoResult() :
ServiceResult()
{}
EraseVideoLogoResult::EraseVideoLogoResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
EraseVideoLogoResult::~EraseVideoLogoResult()
{}
void EraseVideoLogoResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["VideoUrl"].isNull())
data_.videoUrl = dataNode["VideoUrl"].asString();
}
EraseVideoLogoResult::Data EraseVideoLogoResult::getData()const
{
return data_;
}

View File

@@ -0,0 +1,95 @@
/*
* 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_;
}
void EraseVideoSubtitlesRequest::setBH(float bH)
{
bH_ = bH;
setBodyParameter("BH", std::to_string(bH));
}
bool EraseVideoSubtitlesRequest::getAsync()const
{
return async_;
}
void EraseVideoSubtitlesRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
}
std::string EraseVideoSubtitlesRequest::getVideoUrl()const
{
return videoUrl_;
}
void EraseVideoSubtitlesRequest::setVideoUrl(const std::string& videoUrl)
{
videoUrl_ = videoUrl;
setBodyParameter("VideoUrl", videoUrl);
}
float EraseVideoSubtitlesRequest::getBW()const
{
return bW_;
}
void EraseVideoSubtitlesRequest::setBW(float bW)
{
bW_ = bW;
setBodyParameter("BW", std::to_string(bW));
}
float EraseVideoSubtitlesRequest::getBX()const
{
return bX_;
}
void EraseVideoSubtitlesRequest::setBX(float bX)
{
bX_ = bX;
setBodyParameter("BX", std::to_string(bX));
}
float EraseVideoSubtitlesRequest::getBY()const
{
return bY_;
}
void EraseVideoSubtitlesRequest::setBY(float bY)
{
bY_ = bY;
setBodyParameter("BY", std::to_string(bY));
}

View File

@@ -0,0 +1,52 @@
/*
* 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/EraseVideoSubtitlesResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Videoenhan;
using namespace AlibabaCloud::Videoenhan::Model;
EraseVideoSubtitlesResult::EraseVideoSubtitlesResult() :
ServiceResult()
{}
EraseVideoSubtitlesResult::EraseVideoSubtitlesResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
EraseVideoSubtitlesResult::~EraseVideoSubtitlesResult()
{}
void EraseVideoSubtitlesResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["VideoUrl"].isNull())
data_.videoUrl = dataNode["VideoUrl"].asString();
}
EraseVideoSubtitlesResult::Data EraseVideoSubtitlesResult::getData()const
{
return data_;
}

View File

@@ -0,0 +1,167 @@
/*
* 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_;
}
void GenerateVideoRequest::setTransitionStyle(const std::string& transitionStyle)
{
transitionStyle_ = transitionStyle;
setBodyParameter("TransitionStyle", transitionStyle);
}
std::string GenerateVideoRequest::getScene()const
{
return scene_;
}
void GenerateVideoRequest::setScene(const std::string& scene)
{
scene_ = scene;
setBodyParameter("Scene", scene);
}
float GenerateVideoRequest::getDuration()const
{
return duration_;
}
void GenerateVideoRequest::setDuration(float duration)
{
duration_ = duration;
setBodyParameter("Duration", std::to_string(duration));
}
bool GenerateVideoRequest::getPuzzleEffect()const
{
return puzzleEffect_;
}
void GenerateVideoRequest::setPuzzleEffect(bool puzzleEffect)
{
puzzleEffect_ = puzzleEffect;
setBodyParameter("PuzzleEffect", puzzleEffect ? "true" : "false");
}
int GenerateVideoRequest::getHeight()const
{
return height_;
}
void GenerateVideoRequest::setHeight(int height)
{
height_ = height;
setBodyParameter("Height", std::to_string(height));
}
bool GenerateVideoRequest::getDurationAdaption()const
{
return durationAdaption_;
}
void GenerateVideoRequest::setDurationAdaption(bool durationAdaption)
{
durationAdaption_ = durationAdaption;
setBodyParameter("DurationAdaption", durationAdaption ? "true" : "false");
}
std::vector<GenerateVideoRequest::FileList> GenerateVideoRequest::getFileList()const
{
return fileList_;
}
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);
}
}
bool GenerateVideoRequest::getMute()const
{
return mute_;
}
void GenerateVideoRequest::setMute(bool mute)
{
mute_ = mute;
setBodyParameter("Mute", mute ? "true" : "false");
}
bool GenerateVideoRequest::getAsync()const
{
return async_;
}
void GenerateVideoRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
}
bool GenerateVideoRequest::getSmartEffect()const
{
return smartEffect_;
}
void GenerateVideoRequest::setSmartEffect(bool smartEffect)
{
smartEffect_ = smartEffect;
setBodyParameter("SmartEffect", smartEffect ? "true" : "false");
}
int GenerateVideoRequest::getWidth()const
{
return width_;
}
void GenerateVideoRequest::setWidth(int width)
{
width_ = width;
setBodyParameter("Width", std::to_string(width));
}
std::string GenerateVideoRequest::getStyle()const
{
return style_;
}
void GenerateVideoRequest::setStyle(const std::string& style)
{
style_ = style;
setBodyParameter("Style", style);
}

View File

@@ -0,0 +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/GenerateVideoResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Videoenhan;
using namespace AlibabaCloud::Videoenhan::Model;
GenerateVideoResult::GenerateVideoResult() :
ServiceResult()
{}
GenerateVideoResult::GenerateVideoResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GenerateVideoResult::~GenerateVideoResult()
{}
void GenerateVideoResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["VideoUrl"].isNull())
data_.videoUrl = dataNode["VideoUrl"].asString();
if(!dataNode["VideoCoverUrl"].isNull())
data_.videoCoverUrl = dataNode["VideoCoverUrl"].asString();
}
GenerateVideoResult::Data GenerateVideoResult::getData()const
{
return data_;
}

View File

@@ -0,0 +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.
*/
#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()
{}
bool GetAsyncJobResultRequest::getAsync()const
{
return async_;
}
void GetAsyncJobResultRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
}
std::string GetAsyncJobResultRequest::getJobId()const
{
return jobId_;
}
void GetAsyncJobResultRequest::setJobId(const std::string& jobId)
{
jobId_ = jobId;
setBodyParameter("JobId", jobId);
}

View File

@@ -0,0 +1,60 @@
/*
* 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/GetAsyncJobResultResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Videoenhan;
using namespace AlibabaCloud::Videoenhan::Model;
GetAsyncJobResultResult::GetAsyncJobResultResult() :
ServiceResult()
{}
GetAsyncJobResultResult::GetAsyncJobResultResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
GetAsyncJobResultResult::~GetAsyncJobResultResult()
{}
void GetAsyncJobResultResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["JobId"].isNull())
data_.jobId = dataNode["JobId"].asString();
if(!dataNode["Status"].isNull())
data_.status = dataNode["Status"].asString();
if(!dataNode["Result"].isNull())
data_.result = dataNode["Result"].asString();
if(!dataNode["ErrorCode"].isNull())
data_.errorCode = dataNode["ErrorCode"].asString();
if(!dataNode["ErrorMessage"].isNull())
data_.errorMessage = dataNode["ErrorMessage"].asString();
}
GetAsyncJobResultResult::Data GetAsyncJobResultResult::getData()const
{
return data_;
}

View File

@@ -0,0 +1,62 @@
/*
* 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_;
}
void SuperResolveVideoRequest::setBitRate(int bitRate)
{
bitRate_ = bitRate;
setBodyParameter("BitRate", std::to_string(bitRate));
}
bool SuperResolveVideoRequest::getAsync()const
{
return async_;
}
void SuperResolveVideoRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
}
std::string SuperResolveVideoRequest::getVideoUrl()const
{
return videoUrl_;
}
void SuperResolveVideoRequest::setVideoUrl(const std::string& videoUrl)
{
videoUrl_ = videoUrl;
setBodyParameter("VideoUrl", videoUrl);
}

View File

@@ -0,0 +1,52 @@
/*
* 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/SuperResolveVideoResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Videoenhan;
using namespace AlibabaCloud::Videoenhan::Model;
SuperResolveVideoResult::SuperResolveVideoResult() :
ServiceResult()
{}
SuperResolveVideoResult::SuperResolveVideoResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SuperResolveVideoResult::~SuperResolveVideoResult()
{}
void SuperResolveVideoResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["VideoUrl"].isNull())
data_.videoUrl = dataNode["VideoUrl"].asString();
}
SuperResolveVideoResult::Data SuperResolveVideoResult::getData()const
{
return data_;
}