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

Update RecognizeVideoCastCrewList.

Browse Source
This commit is contained in:
sdk-team
2022-06-28 09:21:02 +00:00
parent da3168809b
commit 5c8834a283
24 changed files with 804 additions and 312 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGELOG
View File

@@ -1,3 +1,6 @@
2022-06-28 Version: 1.36.1161
- Update RecognizeVideoCastCrewList.
2022-06-24 Version: 1.36.1160
- Update ScreenChestCT.

2
VERSION
View File

@@ -1 +1 @@
1.36.1160
1.36.1161

8
videorecog/CMakeLists.txt
View File

@@ -27,6 +27,10 @@ set(videorecog_public_header_model
include/alibabacloud/videorecog/model/GenerateVideoCoverResult.h
include/alibabacloud/videorecog/model/GetAsyncJobResultRequest.h
include/alibabacloud/videorecog/model/GetAsyncJobResultResult.h
include/alibabacloud/videorecog/model/RecognizeVideoCastCrewListRequest.h
include/alibabacloud/videorecog/model/RecognizeVideoCastCrewListResult.h
include/alibabacloud/videorecog/model/SplitVideoPartsRequest.h
include/alibabacloud/videorecog/model/SplitVideoPartsResult.h
include/alibabacloud/videorecog/model/UnderstandVideoContentRequest.h
include/alibabacloud/videorecog/model/UnderstandVideoContentResult.h )
@@ -38,6 +42,10 @@ set(videorecog_src
src/model/GenerateVideoCoverResult.cc
src/model/GetAsyncJobResultRequest.cc
src/model/GetAsyncJobResultResult.cc
src/model/RecognizeVideoCastCrewListRequest.cc
src/model/RecognizeVideoCastCrewListResult.cc
src/model/SplitVideoPartsRequest.cc
src/model/SplitVideoPartsResult.cc
src/model/UnderstandVideoContentRequest.cc
src/model/UnderstandVideoContentResult.cc )

16
videorecog/include/alibabacloud/videorecog/VideorecogClient.h
View File

@@ -28,6 +28,10 @@
#include "model/GenerateVideoCoverResult.h"
#include "model/GetAsyncJobResultRequest.h"
#include "model/GetAsyncJobResultResult.h"
#include "model/RecognizeVideoCastCrewListRequest.h"
#include "model/RecognizeVideoCastCrewListResult.h"
#include "model/SplitVideoPartsRequest.h"
#include "model/SplitVideoPartsResult.h"
#include "model/UnderstandVideoContentRequest.h"
#include "model/UnderstandVideoContentResult.h"
@@ -48,6 +52,12 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::GetAsyncJobResultResult> GetAsyncJobResultOutcome;
typedef std::future<GetAsyncJobResultOutcome> GetAsyncJobResultOutcomeCallable;
typedef std::function<void(const VideorecogClient*, const Model::GetAsyncJobResultRequest&, const GetAsyncJobResultOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAsyncJobResultAsyncHandler;
typedef Outcome<Error, Model::RecognizeVideoCastCrewListResult> RecognizeVideoCastCrewListOutcome;
typedef std::future<RecognizeVideoCastCrewListOutcome> RecognizeVideoCastCrewListOutcomeCallable;
typedef std::function<void(const VideorecogClient*, const Model::RecognizeVideoCastCrewListRequest&, const RecognizeVideoCastCrewListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeVideoCastCrewListAsyncHandler;
typedef Outcome<Error, Model::SplitVideoPartsResult> SplitVideoPartsOutcome;
typedef std::future<SplitVideoPartsOutcome> SplitVideoPartsOutcomeCallable;
typedef std::function<void(const VideorecogClient*, const Model::SplitVideoPartsRequest&, const SplitVideoPartsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SplitVideoPartsAsyncHandler;
typedef Outcome<Error, Model::UnderstandVideoContentResult> UnderstandVideoContentOutcome;
typedef std::future<UnderstandVideoContentOutcome> UnderstandVideoContentOutcomeCallable;
typedef std::function<void(const VideorecogClient*, const Model::UnderstandVideoContentRequest&, const UnderstandVideoContentOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UnderstandVideoContentAsyncHandler;
@@ -65,6 +75,12 @@ namespace AlibabaCloud
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;
RecognizeVideoCastCrewListOutcome recognizeVideoCastCrewList(const Model::RecognizeVideoCastCrewListRequest &request)const;
void recognizeVideoCastCrewListAsync(const Model::RecognizeVideoCastCrewListRequest& request, const RecognizeVideoCastCrewListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeVideoCastCrewListOutcomeCallable recognizeVideoCastCrewListCallable(const Model::RecognizeVideoCastCrewListRequest& request) const;
SplitVideoPartsOutcome splitVideoParts(const Model::SplitVideoPartsRequest &request)const;
void splitVideoPartsAsync(const Model::SplitVideoPartsRequest& request, const SplitVideoPartsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SplitVideoPartsOutcomeCallable splitVideoPartsCallable(const Model::SplitVideoPartsRequest& request) const;
UnderstandVideoContentOutcome understandVideoContent(const Model::UnderstandVideoContentRequest &request)const;
void understandVideoContentAsync(const Model::UnderstandVideoContentRequest& request, const UnderstandVideoContentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UnderstandVideoContentOutcomeCallable understandVideoContentCallable(const Model::UnderstandVideoContentRequest& request) const;

74
videorecog/include/alibabacloud/videorecog/model/DetectVideoShotRequest.h
View File

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

80
videorecog/include/alibabacloud/videorecog/model/GenerateVideoCoverRequest.h
View File

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

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

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

54
videorecog/include/alibabacloud/videorecog/model/RecognizeVideoCastCrewListRequest.h Normal file
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_VIDEORECOG_MODEL_RECOGNIZEVIDEOCASTCREWLISTREQUEST_H_
#define ALIBABACLOUD_VIDEORECOG_MODEL_RECOGNIZEVIDEOCASTCREWLISTREQUEST_H_
#include <alibabacloud/videorecog/VideorecogExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Videorecog {
namespace Model {
class ALIBABACLOUD_VIDEORECOG_EXPORT RecognizeVideoCastCrewListRequest : public RpcServiceRequest {
public:
struct Params {
std::string type;
};
RecognizeVideoCastCrewListRequest();
~RecognizeVideoCastCrewListRequest();
std::vector<Params> getParams() const;
void setParams(const std::vector<Params> &params);
bool getAsync() const;
void setAsync(bool async);
std::string getRegisterUrl() const;
void setRegisterUrl(const std::string &registerUrl);
std::string getVideoUrl() const;
void setVideoUrl(const std::string &videoUrl);
private:
std::vector<Params> params_;
bool async_;
std::string registerUrl_;
std::string videoUrl_;
};
} // namespace Model
} // namespace Videorecog
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_VIDEORECOG_MODEL_RECOGNIZEVIDEOCASTCREWLISTREQUEST_H_

49
videorecog/include/alibabacloud/videorecog/model/RecognizeVideoCastCrewListResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* 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_VIDEORECOG_MODEL_RECOGNIZEVIDEOCASTCREWLISTRESULT_H_
#define ALIBABACLOUD_VIDEORECOG_MODEL_RECOGNIZEVIDEOCASTCREWLISTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/videorecog/VideorecogExport.h>
namespace AlibabaCloud
{
namespace Videorecog
{
namespace Model
{
class ALIBABACLOUD_VIDEORECOG_EXPORT RecognizeVideoCastCrewListResult : public ServiceResult
{
public:
RecognizeVideoCastCrewListResult();
explicit RecognizeVideoCastCrewListResult(const std::string &payload);
~RecognizeVideoCastCrewListResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_VIDEORECOG_MODEL_RECOGNIZEVIDEOCASTCREWLISTRESULT_H_

45
videorecog/include/alibabacloud/videorecog/model/SplitVideoPartsRequest.h Normal file
View File

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

65
videorecog/include/alibabacloud/videorecog/model/SplitVideoPartsResult.h Normal file
View File

@@ -0,0 +1,65 @@
/*
* 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_VIDEORECOG_MODEL_SPLITVIDEOPARTSRESULT_H_
#define ALIBABACLOUD_VIDEORECOG_MODEL_SPLITVIDEOPARTSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/videorecog/VideorecogExport.h>
namespace AlibabaCloud
{
namespace Videorecog
{
namespace Model
{
class ALIBABACLOUD_VIDEORECOG_EXPORT SplitVideoPartsResult : public ServiceResult
{
public:
struct Data
{
struct ElementsItem
{
float endTime;
float beginTime;
long index;
};
std::vector<ElementsItem> elements;
};
SplitVideoPartsResult();
explicit SplitVideoPartsResult(const std::string &payload);
~SplitVideoPartsResult();
std::string getMessage()const;
Data getData()const;
std::string getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
Data data_;
std::string code_;
};
}
}
}
#endif // !ALIBABACLOUD_VIDEORECOG_MODEL_SPLITVIDEOPARTSRESULT_H_

74
videorecog/include/alibabacloud/videorecog/model/UnderstandVideoContentRequest.h
View File

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

2
videorecog/include/alibabacloud/videorecog/model/UnderstandVideoContentResult.h
View File

@@ -37,8 +37,8 @@ namespace AlibabaCloud
struct VideoInfo
{
float fps;
long duration;
long height;
long duration;
long width;
};
std::string tagInfo;

72
videorecog/src/VideorecogClient.cc
View File

@@ -159,6 +159,78 @@ VideorecogClient::GetAsyncJobResultOutcomeCallable VideorecogClient::getAsyncJob
return task->get_future();
}
VideorecogClient::RecognizeVideoCastCrewListOutcome VideorecogClient::recognizeVideoCastCrewList(const RecognizeVideoCastCrewListRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RecognizeVideoCastCrewListOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RecognizeVideoCastCrewListOutcome(RecognizeVideoCastCrewListResult(outcome.result()));
else
return RecognizeVideoCastCrewListOutcome(outcome.error());
}
void VideorecogClient::recognizeVideoCastCrewListAsync(const RecognizeVideoCastCrewListRequest& request, const RecognizeVideoCastCrewListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, recognizeVideoCastCrewList(request), context);
};
asyncExecute(new Runnable(fn));
}
VideorecogClient::RecognizeVideoCastCrewListOutcomeCallable VideorecogClient::recognizeVideoCastCrewListCallable(const RecognizeVideoCastCrewListRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RecognizeVideoCastCrewListOutcome()>>(
[this, request]()
{
return this->recognizeVideoCastCrewList(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
VideorecogClient::SplitVideoPartsOutcome VideorecogClient::splitVideoParts(const SplitVideoPartsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return SplitVideoPartsOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return SplitVideoPartsOutcome(SplitVideoPartsResult(outcome.result()));
else
return SplitVideoPartsOutcome(outcome.error());
}
void VideorecogClient::splitVideoPartsAsync(const SplitVideoPartsRequest& request, const SplitVideoPartsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, splitVideoParts(request), context);
};
asyncExecute(new Runnable(fn));
}
VideorecogClient::SplitVideoPartsOutcomeCallable VideorecogClient::splitVideoPartsCallable(const SplitVideoPartsRequest &request) const
{
auto task = std::make_shared<std::packaged_task<SplitVideoPartsOutcome()>>(
[this, request]()
{
return this->splitVideoParts(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
VideorecogClient::UnderstandVideoContentOutcome VideorecogClient::understandVideoContent(const UnderstandVideoContentRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

58
videorecog/src/model/DetectVideoShotRequest.cc
View File

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

70
videorecog/src/model/GenerateVideoCoverRequest.cc
View File

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

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

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

8
videorecog/src/model/GetAsyncJobResultResult.cc
View File

@@ -42,14 +42,14 @@ void GetAsyncJobResultResult::parse(const std::string &payload)
auto dataNode = value["Data"];
if(!dataNode["Status"].isNull())
data_.status = dataNode["Status"].asString();
if(!dataNode["ErrorCode"].isNull())
data_.errorCode = dataNode["ErrorCode"].asString();
if(!dataNode["ErrorMessage"].isNull())
data_.errorMessage = dataNode["ErrorMessage"].asString();
if(!dataNode["JobId"].isNull())
data_.jobId = dataNode["JobId"].asString();
if(!dataNode["Result"].isNull())
data_.result = dataNode["Result"].asString();
if(!dataNode["ErrorCode"].isNull())
data_.errorCode = dataNode["ErrorCode"].asString();
if(!dataNode["JobId"].isNull())
data_.jobId = dataNode["JobId"].asString();
}

65
videorecog/src/model/RecognizeVideoCastCrewListRequest.cc Normal file
View File

@@ -0,0 +1,65 @@
/*
* 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/videorecog/model/RecognizeVideoCastCrewListRequest.h>
using AlibabaCloud::Videorecog::Model::RecognizeVideoCastCrewListRequest;
RecognizeVideoCastCrewListRequest::RecognizeVideoCastCrewListRequest()
: RpcServiceRequest("videorecog", "2020-03-20", "RecognizeVideoCastCrewList") {
setMethod(HttpRequest::Method::Post);
}
RecognizeVideoCastCrewListRequest::~RecognizeVideoCastCrewListRequest() {}
std::vector<RecognizeVideoCastCrewListRequest::Params> RecognizeVideoCastCrewListRequest::getParams() const {
return params_;
}
void RecognizeVideoCastCrewListRequest::setParams(const std::vector<RecognizeVideoCastCrewListRequest::Params> &params) {
params_ = params;
for(int dep1 = 0; dep1 != params.size(); dep1++) {
setBodyParameter(std::string("Params") + "." + std::to_string(dep1 + 1) + ".Type", params[dep1].type);
}
}
bool RecognizeVideoCastCrewListRequest::getAsync() const {
return async_;
}
void RecognizeVideoCastCrewListRequest::setAsync(bool async) {
async_ = async;
setBodyParameter(std::string("Async"), async ? "true" : "false");
}
std::string RecognizeVideoCastCrewListRequest::getRegisterUrl() const {
return registerUrl_;
}
void RecognizeVideoCastCrewListRequest::setRegisterUrl(const std::string &registerUrl) {
registerUrl_ = registerUrl;
setBodyParameter(std::string("RegisterUrl"), registerUrl);
}
std::string RecognizeVideoCastCrewListRequest::getVideoUrl() const {
return videoUrl_;
}
void RecognizeVideoCastCrewListRequest::setVideoUrl(const std::string &videoUrl) {
videoUrl_ = videoUrl;
setBodyParameter(std::string("VideoUrl"), videoUrl);
}

44
videorecog/src/model/RecognizeVideoCastCrewListResult.cc Normal file
View File

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

45
videorecog/src/model/SplitVideoPartsRequest.cc Normal file
View File

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

76
videorecog/src/model/SplitVideoPartsResult.cc Normal file
View File

@@ -0,0 +1,76 @@
/*
* 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/videorecog/model/SplitVideoPartsResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Videorecog;
using namespace AlibabaCloud::Videorecog::Model;
SplitVideoPartsResult::SplitVideoPartsResult() :
ServiceResult()
{}
SplitVideoPartsResult::SplitVideoPartsResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
SplitVideoPartsResult::~SplitVideoPartsResult()
{}
void SplitVideoPartsResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
auto allElementsNode = dataNode["Elements"]["elementsItem"];
for (auto dataNodeElementselementsItem : allElementsNode)
{
Data::ElementsItem elementsItemObject;
if(!dataNodeElementselementsItem["BeginTime"].isNull())
elementsItemObject.beginTime = std::stof(dataNodeElementselementsItem["BeginTime"].asString());
if(!dataNodeElementselementsItem["EndTime"].isNull())
elementsItemObject.endTime = std::stof(dataNodeElementselementsItem["EndTime"].asString());
if(!dataNodeElementselementsItem["Index"].isNull())
elementsItemObject.index = std::stol(dataNodeElementselementsItem["Index"].asString());
data_.elements.push_back(elementsItemObject);
}
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["Message"].isNull())
message_ = value["Message"].asString();
}
std::string SplitVideoPartsResult::getMessage()const
{
return message_;
}
SplitVideoPartsResult::Data SplitVideoPartsResult::getData()const
{
return data_;
}
std::string SplitVideoPartsResult::getCode()const
{
return code_;
}

58
videorecog/src/model/UnderstandVideoContentRequest.cc
View File

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

16
videorecog/src/model/UnderstandVideoContentResult.cc
View File

@@ -43,18 +43,18 @@ void UnderstandVideoContentResult::parse(const std::string &payload)
if(!dataNode["TagInfo"].isNull())
data_.tagInfo = dataNode["TagInfo"].asString();
auto videoInfoNode = dataNode["VideoInfo"];
if(!videoInfoNode["Fps"].isNull())
data_.videoInfo.fps = std::stof(videoInfoNode["Fps"].asString());
if(!videoInfoNode["Duration"].isNull())
data_.videoInfo.duration = std::stol(videoInfoNode["Duration"].asString());
if(!videoInfoNode["Height"].isNull())
data_.videoInfo.height = std::stol(videoInfoNode["Height"].asString());
if(!videoInfoNode["Width"].isNull())
data_.videoInfo.width = std::stol(videoInfoNode["Width"].asString());
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!videoInfoNode["Height"].isNull())
data_.videoInfo.height = std::stol(videoInfoNode["Height"].asString());
if(!videoInfoNode["Duration"].isNull())
data_.videoInfo.duration = std::stol(videoInfoNode["Duration"].asString());
if(!videoInfoNode["Fps"].isNull())
data_.videoInfo.fps = std::stof(videoInfoNode["Fps"].asString());
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["Message"].isNull())
message_ = value["Message"].asString();
}