Support Digital Watermark.

vod/src/VodClient.cc

@@ -159,6 +159,42 @@ VodClient::AddEditingProjectOutcomeCallable VodClient::addEditingProjectCallable
 	return task->get_future();
 }
 
+VodClient::AddEditingProjectMaterialsOutcome VodClient::addEditingProjectMaterials(const AddEditingProjectMaterialsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AddEditingProjectMaterialsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AddEditingProjectMaterialsOutcome(AddEditingProjectMaterialsResult(outcome.result()));
+	else
+		return AddEditingProjectMaterialsOutcome(outcome.error());
+}
+
+void VodClient::addEditingProjectMaterialsAsync(const AddEditingProjectMaterialsRequest& request, const AddEditingProjectMaterialsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, addEditingProjectMaterials(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+VodClient::AddEditingProjectMaterialsOutcomeCallable VodClient::addEditingProjectMaterialsCallable(const AddEditingProjectMaterialsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AddEditingProjectMaterialsOutcome()>>(
+			[this, request]()
+			{
+			return this->addEditingProjectMaterials(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 VodClient::AddTranscodeTemplateGroupOutcome VodClient::addTranscodeTemplateGroup(const AddTranscodeTemplateGroupRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -951,6 +987,42 @@ VodClient::DeleteEditingProjectOutcomeCallable VodClient::deleteEditingProjectCa
 	return task->get_future();
 }
 
+VodClient::DeleteEditingProjectMaterialsOutcome VodClient::deleteEditingProjectMaterials(const DeleteEditingProjectMaterialsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteEditingProjectMaterialsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteEditingProjectMaterialsOutcome(DeleteEditingProjectMaterialsResult(outcome.result()));
+	else
+		return DeleteEditingProjectMaterialsOutcome(outcome.error());
+}
+
+void VodClient::deleteEditingProjectMaterialsAsync(const DeleteEditingProjectMaterialsRequest& request, const DeleteEditingProjectMaterialsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteEditingProjectMaterials(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+VodClient::DeleteEditingProjectMaterialsOutcomeCallable VodClient::deleteEditingProjectMaterialsCallable(const DeleteEditingProjectMaterialsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteEditingProjectMaterialsOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteEditingProjectMaterials(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 VodClient::DeleteImageOutcome VodClient::deleteImage(const DeleteImageRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2499,6 +2571,42 @@ VodClient::GetDefaultAITemplateOutcomeCallable VodClient::getDefaultAITemplateCa
 	return task->get_future();
 }
 
+VodClient::GetDigitalWatermarkExtractResultOutcome VodClient::getDigitalWatermarkExtractResult(const GetDigitalWatermarkExtractResultRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetDigitalWatermarkExtractResultOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetDigitalWatermarkExtractResultOutcome(GetDigitalWatermarkExtractResultResult(outcome.result()));
+	else
+		return GetDigitalWatermarkExtractResultOutcome(outcome.error());
+}
+
+void VodClient::getDigitalWatermarkExtractResultAsync(const GetDigitalWatermarkExtractResultRequest& request, const GetDigitalWatermarkExtractResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getDigitalWatermarkExtractResult(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+VodClient::GetDigitalWatermarkExtractResultOutcomeCallable VodClient::getDigitalWatermarkExtractResultCallable(const GetDigitalWatermarkExtractResultRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetDigitalWatermarkExtractResultOutcome()>>(
+			[this, request]()
+			{
+			return this->getDigitalWatermarkExtractResult(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 VodClient::GetEditingProjectOutcome VodClient::getEditingProject(const GetEditingProjectRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -4623,6 +4731,42 @@ VodClient::SubmitAIMediaAuditJobOutcomeCallable VodClient::submitAIMediaAuditJob
 	return task->get_future();
 }
 
+VodClient::SubmitDigitalWatermarkExtractJobOutcome VodClient::submitDigitalWatermarkExtractJob(const SubmitDigitalWatermarkExtractJobRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SubmitDigitalWatermarkExtractJobOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SubmitDigitalWatermarkExtractJobOutcome(SubmitDigitalWatermarkExtractJobResult(outcome.result()));
+	else
+		return SubmitDigitalWatermarkExtractJobOutcome(outcome.error());
+}
+
+void VodClient::submitDigitalWatermarkExtractJobAsync(const SubmitDigitalWatermarkExtractJobRequest& request, const SubmitDigitalWatermarkExtractJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, submitDigitalWatermarkExtractJob(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+VodClient::SubmitDigitalWatermarkExtractJobOutcomeCallable VodClient::submitDigitalWatermarkExtractJobCallable(const SubmitDigitalWatermarkExtractJobRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SubmitDigitalWatermarkExtractJobOutcome()>>(
+			[this, request]()
+			{
+			return this->submitDigitalWatermarkExtractJob(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 VodClient::SubmitDynamicImageJobOutcome VodClient::submitDynamicImageJob(const SubmitDynamicImageJobRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

vod/src/model/AddEditingProjectMaterialsRequest.cc

@@ -0,0 +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/vod/model/AddEditingProjectMaterialsRequest.h>
+
+using AlibabaCloud::Vod::Model::AddEditingProjectMaterialsRequest;
+
+AddEditingProjectMaterialsRequest::AddEditingProjectMaterialsRequest()
+    : RpcServiceRequest("vod", "2017-03-21", "AddEditingProjectMaterials") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+AddEditingProjectMaterialsRequest::~AddEditingProjectMaterialsRequest() {}
+
+std::string AddEditingProjectMaterialsRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void AddEditingProjectMaterialsRequest::setResourceOwnerId(const std::string &resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), resourceOwnerId);
+}
+
+std::string AddEditingProjectMaterialsRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void AddEditingProjectMaterialsRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string AddEditingProjectMaterialsRequest::getMaterialType() const {
+  return materialType_;
+}
+
+void AddEditingProjectMaterialsRequest::setMaterialType(const std::string &materialType) {
+  materialType_ = materialType;
+  setParameter(std::string("MaterialType"), materialType);
+}
+
+std::string AddEditingProjectMaterialsRequest::getProjectId() const {
+  return projectId_;
+}
+
+void AddEditingProjectMaterialsRequest::setProjectId(const std::string &projectId) {
+  projectId_ = projectId;
+  setParameter(std::string("ProjectId"), projectId);
+}
+
+std::string AddEditingProjectMaterialsRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void AddEditingProjectMaterialsRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string AddEditingProjectMaterialsRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void AddEditingProjectMaterialsRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+std::string AddEditingProjectMaterialsRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void AddEditingProjectMaterialsRequest::setOwnerId(const std::string &ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), ownerId);
+}
+
+std::string AddEditingProjectMaterialsRequest::getMaterialIds() const {
+  return materialIds_;
+}
+
+void AddEditingProjectMaterialsRequest::setMaterialIds(const std::string &materialIds) {
+  materialIds_ = materialIds;
+  setParameter(std::string("MaterialIds"), materialIds);
+}
+

vod/src/model/AddEditingProjectMaterialsResult.cc

@@ -0,0 +1,91 @@
+/*
+ * 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/vod/model/AddEditingProjectMaterialsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vod;
+using namespace AlibabaCloud::Vod::Model;
+
+AddEditingProjectMaterialsResult::AddEditingProjectMaterialsResult() :
+	ServiceResult()
+{}
+
+AddEditingProjectMaterialsResult::AddEditingProjectMaterialsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+AddEditingProjectMaterialsResult::~AddEditingProjectMaterialsResult()
+{}
+
+void AddEditingProjectMaterialsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allMaterialListNode = value["MaterialList"]["Material"];
+	for (auto valueMaterialListMaterial : allMaterialListNode)
+	{
+		Material materialListObject;
+		if(!valueMaterialListMaterial["Status"].isNull())
+			materialListObject.status = valueMaterialListMaterial["Status"].asString();
+		if(!valueMaterialListMaterial["CateId"].isNull())
+			materialListObject.cateId = std::stoi(valueMaterialListMaterial["CateId"].asString());
+		if(!valueMaterialListMaterial["CreateTime"].isNull())
+			materialListObject.createTime = valueMaterialListMaterial["CreateTime"].asString();
+		if(!valueMaterialListMaterial["MaterialType"].isNull())
+			materialListObject.materialType = valueMaterialListMaterial["MaterialType"].asString();
+		if(!valueMaterialListMaterial["Tags"].isNull())
+			materialListObject.tags = valueMaterialListMaterial["Tags"].asString();
+		if(!valueMaterialListMaterial["SpriteConfig"].isNull())
+			materialListObject.spriteConfig = valueMaterialListMaterial["SpriteConfig"].asString();
+		if(!valueMaterialListMaterial["CateName"].isNull())
+			materialListObject.cateName = valueMaterialListMaterial["CateName"].asString();
+		if(!valueMaterialListMaterial["Description"].isNull())
+			materialListObject.description = valueMaterialListMaterial["Description"].asString();
+		if(!valueMaterialListMaterial["MaterialId"].isNull())
+			materialListObject.materialId = valueMaterialListMaterial["MaterialId"].asString();
+		if(!valueMaterialListMaterial["Size"].isNull())
+			materialListObject.size = std::stol(valueMaterialListMaterial["Size"].asString());
+		if(!valueMaterialListMaterial["CoverURL"].isNull())
+			materialListObject.coverURL = valueMaterialListMaterial["CoverURL"].asString();
+		if(!valueMaterialListMaterial["Duration"].isNull())
+			materialListObject.duration = std::stof(valueMaterialListMaterial["Duration"].asString());
+		if(!valueMaterialListMaterial["CustomerId"].isNull())
+			materialListObject.customerId = std::stol(valueMaterialListMaterial["CustomerId"].asString());
+		if(!valueMaterialListMaterial["Title"].isNull())
+			materialListObject.title = valueMaterialListMaterial["Title"].asString();
+		if(!valueMaterialListMaterial["ModifyTime"].isNull())
+			materialListObject.modifyTime = valueMaterialListMaterial["ModifyTime"].asString();
+		auto allSprites = value["Sprites"]["Sprite"];
+		for (auto value : allSprites)
+			materialListObject.sprites.push_back(value.asString());
+		auto allSnapshots = value["Snapshots"]["Snapshot"];
+		for (auto value : allSnapshots)
+			materialListObject.snapshots.push_back(value.asString());
+		materialList_.push_back(materialListObject);
+	}
+
+}
+
+std::vector<AddEditingProjectMaterialsResult::Material> AddEditingProjectMaterialsResult::getMaterialList()const
+{
+	return materialList_;
+}
+

vod/src/model/DeleteEditingProjectMaterialsRequest.cc

@@ -0,0 +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/vod/model/DeleteEditingProjectMaterialsRequest.h>
+
+using AlibabaCloud::Vod::Model::DeleteEditingProjectMaterialsRequest;
+
+DeleteEditingProjectMaterialsRequest::DeleteEditingProjectMaterialsRequest()
+    : RpcServiceRequest("vod", "2017-03-21", "DeleteEditingProjectMaterials") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteEditingProjectMaterialsRequest::~DeleteEditingProjectMaterialsRequest() {}
+
+std::string DeleteEditingProjectMaterialsRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void DeleteEditingProjectMaterialsRequest::setResourceOwnerId(const std::string &resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), resourceOwnerId);
+}
+
+std::string DeleteEditingProjectMaterialsRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void DeleteEditingProjectMaterialsRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string DeleteEditingProjectMaterialsRequest::getMaterialType() const {
+  return materialType_;
+}
+
+void DeleteEditingProjectMaterialsRequest::setMaterialType(const std::string &materialType) {
+  materialType_ = materialType;
+  setParameter(std::string("MaterialType"), materialType);
+}
+
+std::string DeleteEditingProjectMaterialsRequest::getProjectId() const {
+  return projectId_;
+}
+
+void DeleteEditingProjectMaterialsRequest::setProjectId(const std::string &projectId) {
+  projectId_ = projectId;
+  setParameter(std::string("ProjectId"), projectId);
+}
+
+std::string DeleteEditingProjectMaterialsRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void DeleteEditingProjectMaterialsRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string DeleteEditingProjectMaterialsRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void DeleteEditingProjectMaterialsRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+std::string DeleteEditingProjectMaterialsRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DeleteEditingProjectMaterialsRequest::setOwnerId(const std::string &ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), ownerId);
+}
+
+std::string DeleteEditingProjectMaterialsRequest::getMaterialIds() const {
+  return materialIds_;
+}
+
+void DeleteEditingProjectMaterialsRequest::setMaterialIds(const std::string &materialIds) {
+  materialIds_ = materialIds;
+  setParameter(std::string("MaterialIds"), materialIds);
+}
+

vod/src/model/DeleteEditingProjectMaterialsResult.cc

@@ -0,0 +1,44 @@
+/*
+ * 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/vod/model/DeleteEditingProjectMaterialsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vod;
+using namespace AlibabaCloud::Vod::Model;
+
+DeleteEditingProjectMaterialsResult::DeleteEditingProjectMaterialsResult() :
+	ServiceResult()
+{}
+
+DeleteEditingProjectMaterialsResult::DeleteEditingProjectMaterialsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteEditingProjectMaterialsResult::~DeleteEditingProjectMaterialsResult()
+{}
+
+void DeleteEditingProjectMaterialsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

vod/src/model/DeleteVodSpecificConfigRequest.cc

@@ -43,6 +43,15 @@ void DeleteVodSpecificConfigRequest::setOwnerId(long ownerId) {
   setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
+std::string DeleteVodSpecificConfigRequest::getEnv() const {
+  return env_;
+}
+
+void DeleteVodSpecificConfigRequest::setEnv(const std::string &env) {
+  env_ = env;
+  setParameter(std::string("Env"), env);
+}
+
 std::string DeleteVodSpecificConfigRequest::getSecurityToken() const {
   return securityToken_;
 }

vod/src/model/GetDigitalWatermarkExtractResultRequest.cc

@@ -0,0 +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/vod/model/GetDigitalWatermarkExtractResultRequest.h>
+
+using AlibabaCloud::Vod::Model::GetDigitalWatermarkExtractResultRequest;
+
+GetDigitalWatermarkExtractResultRequest::GetDigitalWatermarkExtractResultRequest()
+    : RpcServiceRequest("vod", "2017-03-21", "GetDigitalWatermarkExtractResult") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetDigitalWatermarkExtractResultRequest::~GetDigitalWatermarkExtractResultRequest() {}
+
+std::string GetDigitalWatermarkExtractResultRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void GetDigitalWatermarkExtractResultRequest::setResourceOwnerId(const std::string &resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), resourceOwnerId);
+}
+
+std::string GetDigitalWatermarkExtractResultRequest::getExtractType() const {
+  return extractType_;
+}
+
+void GetDigitalWatermarkExtractResultRequest::setExtractType(const std::string &extractType) {
+  extractType_ = extractType;
+  setParameter(std::string("ExtractType"), extractType);
+}
+
+std::string GetDigitalWatermarkExtractResultRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void GetDigitalWatermarkExtractResultRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string GetDigitalWatermarkExtractResultRequest::getJobId() const {
+  return jobId_;
+}
+
+void GetDigitalWatermarkExtractResultRequest::setJobId(const std::string &jobId) {
+  jobId_ = jobId;
+  setParameter(std::string("JobId"), jobId);
+}
+
+std::string GetDigitalWatermarkExtractResultRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void GetDigitalWatermarkExtractResultRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string GetDigitalWatermarkExtractResultRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void GetDigitalWatermarkExtractResultRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+std::string GetDigitalWatermarkExtractResultRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void GetDigitalWatermarkExtractResultRequest::setOwnerId(const std::string &ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), ownerId);
+}
+
+std::string GetDigitalWatermarkExtractResultRequest::getMediaId() const {
+  return mediaId_;
+}
+
+void GetDigitalWatermarkExtractResultRequest::setMediaId(const std::string &mediaId) {
+  mediaId_ = mediaId;
+  setParameter(std::string("MediaId"), mediaId);
+}
+

vod/src/model/GetDigitalWatermarkExtractResultResult.cc

@@ -0,0 +1,67 @@
+/*
+ * 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/vod/model/GetDigitalWatermarkExtractResultResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vod;
+using namespace AlibabaCloud::Vod::Model;
+
+GetDigitalWatermarkExtractResultResult::GetDigitalWatermarkExtractResultResult() :
+	ServiceResult()
+{}
+
+GetDigitalWatermarkExtractResultResult::GetDigitalWatermarkExtractResultResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetDigitalWatermarkExtractResultResult::~GetDigitalWatermarkExtractResultResult()
+{}
+
+void GetDigitalWatermarkExtractResultResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allAiExtractResultListNode = value["AiExtractResultList"]["AiExtractResult"];
+	for (auto valueAiExtractResultListAiExtractResult : allAiExtractResultListNode)
+	{
+		AiExtractResult aiExtractResultListObject;
+		if(!valueAiExtractResultListAiExtractResult["JobId"].isNull())
+			aiExtractResultListObject.jobId = valueAiExtractResultListAiExtractResult["JobId"].asString();
+		if(!valueAiExtractResultListAiExtractResult["CreateTime"].isNull())
+			aiExtractResultListObject.createTime = valueAiExtractResultListAiExtractResult["CreateTime"].asString();
+		if(!valueAiExtractResultListAiExtractResult["ModifyTime"].isNull())
+			aiExtractResultListObject.modifyTime = valueAiExtractResultListAiExtractResult["ModifyTime"].asString();
+		if(!valueAiExtractResultListAiExtractResult["Status"].isNull())
+			aiExtractResultListObject.status = valueAiExtractResultListAiExtractResult["Status"].asString();
+		if(!valueAiExtractResultListAiExtractResult["ErrorMessage"].isNull())
+			aiExtractResultListObject.errorMessage = valueAiExtractResultListAiExtractResult["ErrorMessage"].asString();
+		if(!valueAiExtractResultListAiExtractResult["WaterMarkText"].isNull())
+			aiExtractResultListObject.waterMarkText = valueAiExtractResultListAiExtractResult["WaterMarkText"].asString();
+		aiExtractResultList_.push_back(aiExtractResultListObject);
+	}
+
+}
+
+std::vector<GetDigitalWatermarkExtractResultResult::AiExtractResult> GetDigitalWatermarkExtractResultResult::getAiExtractResultList()const
+{
+	return aiExtractResultList_;
+}
+

vod/src/model/GetPlayInfoRequest.cc

@@ -43,6 +43,15 @@ void GetPlayInfoRequest::setChannel(const std::string &channel) {
   setParameter(std::string("Channel"), channel);
 }
 
+std::string GetPlayInfoRequest::getDigitalWatermarkType() const {
+  return digitalWatermarkType_;
+}
+
+void GetPlayInfoRequest::setDigitalWatermarkType(const std::string &digitalWatermarkType) {
+  digitalWatermarkType_ = digitalWatermarkType;
+  setParameter(std::string("DigitalWatermarkType"), digitalWatermarkType);
+}
+
 std::string GetPlayInfoRequest::getPlayerVersion() const {
   return playerVersion_;
 }
@@ -61,6 +70,15 @@ void GetPlayInfoRequest::setRand(const std::string &rand) {
   setParameter(std::string("Rand"), rand);
 }
 
+std::string GetPlayInfoRequest::getTrace() const {
+  return trace_;
+}
+
+void GetPlayInfoRequest::setTrace(const std::string &trace) {
+  trace_ = trace;
+  setParameter(std::string("Trace"), trace);
+}
+
 std::string GetPlayInfoRequest::getReAuthInfo() const {
   return reAuthInfo_;
 }

vod/src/model/GetPlayInfoResult.cc

@@ -93,6 +93,10 @@ void GetPlayInfoResult::parse(const std::string &payload)
 			playInfoListObject.hDRType = valuePlayInfoListPlayInfo["HDRType"].asString();
 		if(!valuePlayInfoListPlayInfo["BitDepth"].isNull())
 			playInfoListObject.bitDepth = std::stoi(valuePlayInfoListPlayInfo["BitDepth"].asString());
+		if(!valuePlayInfoListPlayInfo["JobType"].isNull())
+			playInfoListObject.jobType = std::stoi(valuePlayInfoListPlayInfo["JobType"].asString());
+		if(!valuePlayInfoListPlayInfo["JobExt"].isNull())
+			playInfoListObject.jobExt = valuePlayInfoListPlayInfo["JobExt"].asString();
 		playInfoList_.push_back(playInfoListObject);
 	}
 	auto videoBaseNode = value["VideoBase"];

vod/src/model/GetTranscodeTemplateGroupResult.cc

@@ -96,6 +96,10 @@ void GetTranscodeTemplateGroupResult::parse(const std::string &payload)
 			transcodeTemplateObject.muxConfig = transcodeTemplateGroupNodeTranscodeTemplateListTranscodeTemplate["MuxConfig"].asString();
 		if(!transcodeTemplateGroupNodeTranscodeTemplateListTranscodeTemplate["TailSlateList"].isNull())
 			transcodeTemplateObject.tailSlateList = transcodeTemplateGroupNodeTranscodeTemplateListTranscodeTemplate["TailSlateList"].asString();
+		if(!transcodeTemplateGroupNodeTranscodeTemplateListTranscodeTemplate["TraceMark"].isNull())
+			transcodeTemplateObject.traceMark = transcodeTemplateGroupNodeTranscodeTemplateListTranscodeTemplate["TraceMark"].asString();
+		if(!transcodeTemplateGroupNodeTranscodeTemplateListTranscodeTemplate["CopyrightMark"].isNull())
+			transcodeTemplateObject.copyrightMark = transcodeTemplateGroupNodeTranscodeTemplateListTranscodeTemplate["CopyrightMark"].asString();
 		auto allWatermarkIds = value["WatermarkIds"]["WatermarkId"];
 		for (auto value : allWatermarkIds)
 			transcodeTemplateObject.watermarkIds.push_back(value.asString());

vod/src/model/SubmitDigitalWatermarkExtractJobRequest.cc

@@ -0,0 +1,90 @@
+/*
+ * 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/vod/model/SubmitDigitalWatermarkExtractJobRequest.h>
+
+using AlibabaCloud::Vod::Model::SubmitDigitalWatermarkExtractJobRequest;
+
+SubmitDigitalWatermarkExtractJobRequest::SubmitDigitalWatermarkExtractJobRequest()
+    : RpcServiceRequest("vod", "2017-03-21", "SubmitDigitalWatermarkExtractJob") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+SubmitDigitalWatermarkExtractJobRequest::~SubmitDigitalWatermarkExtractJobRequest() {}
+
+std::string SubmitDigitalWatermarkExtractJobRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void SubmitDigitalWatermarkExtractJobRequest::setResourceOwnerId(const std::string &resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), resourceOwnerId);
+}
+
+std::string SubmitDigitalWatermarkExtractJobRequest::getExtractType() const {
+  return extractType_;
+}
+
+void SubmitDigitalWatermarkExtractJobRequest::setExtractType(const std::string &extractType) {
+  extractType_ = extractType;
+  setParameter(std::string("ExtractType"), extractType);
+}
+
+std::string SubmitDigitalWatermarkExtractJobRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void SubmitDigitalWatermarkExtractJobRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string SubmitDigitalWatermarkExtractJobRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void SubmitDigitalWatermarkExtractJobRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string SubmitDigitalWatermarkExtractJobRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void SubmitDigitalWatermarkExtractJobRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+std::string SubmitDigitalWatermarkExtractJobRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void SubmitDigitalWatermarkExtractJobRequest::setOwnerId(const std::string &ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), ownerId);
+}
+
+std::string SubmitDigitalWatermarkExtractJobRequest::getMediaId() const {
+  return mediaId_;
+}
+
+void SubmitDigitalWatermarkExtractJobRequest::setMediaId(const std::string &mediaId) {
+  mediaId_ = mediaId;
+  setParameter(std::string("MediaId"), mediaId);
+}
+

vod/src/model/SubmitDigitalWatermarkExtractJobResult.cc

@@ -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/vod/model/SubmitDigitalWatermarkExtractJobResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Vod;
+using namespace AlibabaCloud::Vod::Model;
+
+SubmitDigitalWatermarkExtractJobResult::SubmitDigitalWatermarkExtractJobResult() :
+	ServiceResult()
+{}
+
+SubmitDigitalWatermarkExtractJobResult::SubmitDigitalWatermarkExtractJobResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+SubmitDigitalWatermarkExtractJobResult::~SubmitDigitalWatermarkExtractJobResult()
+{}
+
+void SubmitDigitalWatermarkExtractJobResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["JobId"].isNull())
+		jobId_ = value["JobId"].asString();
+
+}
+
+std::string SubmitDigitalWatermarkExtractJobResult::getJobId()const
+{
+	return jobId_;
+}
+

vod/src/model/UploadMediaByURLRequest.cc

@@ -34,6 +34,15 @@ void UploadMediaByURLRequest::setMessageCallback(const std::string &messageCallb
   setParameter(std::string("MessageCallback"), messageCallback);
 }
 
+std::string UploadMediaByURLRequest::getSessionId() const {
+  return sessionId_;
+}
+
+void UploadMediaByURLRequest::setSessionId(const std::string &sessionId) {
+  sessionId_ = sessionId;
+  setParameter(std::string("SessionId"), sessionId);
+}
+
 std::string UploadMediaByURLRequest::getStorageLocation() const {
   return storageLocation_;
 }