/*
* Copyright (c) 2020-2022 Huawei Device Co., Ltd.
* 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 "camera_device.h"
#include <fcntl.h>
#include <pthread.h>
#include <string>
#include <sys/io.h>
#include <sys/prctl.h>
#include <sys/select.h>
#include <thread>
#include <unistd.h>
#include "codec_interface.h"
#include "display_layer.h"
#include "hal_camera.h"
#include "media_log.h"
#include "meta_data.h"
#include "securec.h"
#include <iostream>
using namespace OHOS;
using namespace OHOS::Media;
using namespace std;
/** Indicates that the current frame is an Instantaneous Decoder Refresh (IDR) frame. */
const int32_t KEY_IS_SYNC_FRAME = 1;
/** Indicates the frame timestamp. */
const int32_t KEY_TIME_US = 2;
const int32_t IMAGE_WIDTH = 3; // "DATA_PIX_FORMAT"
const int32_t IMAGE_HEIGHT = 4; // "DATA_PIX_FORMAT"
const int32_t IMAGE_SIZE = 5; // "DATA_PIX_FORMAT"
const int32_t DELAY_TIME_ONE_FRAME = 30000;
const int32_t VIDEO_MAX_NUM = 2; // "video max num"
const int32_t INVALID_STREAM_ID = -1;
namespace OHOS {
namespace Media {
extern Surface *g_surface;
AvCodecMime ConverFormat(ImageFormat format)
{
if (format == FORMAT_JPEG) {
return MEDIA_MIMETYPE_IMAGE_JPEG;
} else if (format == FORMAT_AVC) {
return MEDIA_MIMETYPE_VIDEO_AVC;
} else if (format == FORMAT_HEVC) {
return MEDIA_MIMETYPE_VIDEO_HEVC;
} else {
return MEDIA_MIMETYPE_INVALID;
}
}
static int32_t SetVencSource(CODEC_HANDLETYPE codecHdl, uint32_t deviceId)
{
Param param = {.key = KEY_DEVICE_ID, .val = (void *)&deviceId, .size = sizeof(uint32_t)};
int32_t ret = CodecSetParameter(codecHdl, ¶m, 1);
if (ret != 0) {
MEDIA_ERR_LOG("Set enc source failed.(ret=%d)", ret);
return ret;
}
return MEDIA_OK;
}
static uint32_t GetDefaultBitrate(uint32_t width, uint32_t height)
{
uint32_t rate; /* auto calc bitrate if set 0 */
if (width * height == 640 * 360) { /* 640,width 360,height */
rate = 0x800; /* 2048kbps */
} else if (width * height == 1280 * 720) { /* 1280,width 720,height */
rate = 0x400; /* 1024kbps */
} else if (width * height >= 2560 * 1440 && width * height <= 2716 * 1524) { /* 2560,2716 width 1440,1524,height */
rate = 0x1800; /* 6144kbps */
} else if (width * height == 3840 * 2160 || width * height == 4096 * 2160) { /* 3840,4096 width 2160,height */
rate = 0xa000; /* 40960kbps */
} else {
rate = 0x0;
}
return rate;
}
static int32_t CameraCreateVideoEnc(FrameConfig &fc,
StreamAttr stream,
uint32_t srcDev,
CODEC_HANDLETYPE *codecHdl)
{
const uint32_t maxParamNum = 10;
uint32_t paramIndex = 0;
Param param[maxParamNum];
CodecType domainKind = VIDEO_ENCODER;
param[paramIndex].key = KEY_CODEC_TYPE;
param[paramIndex].val = &domainKind;
param[paramIndex].size = sizeof(CodecType);
paramIndex++;
AvCodecMime codecMime = ConverFormat(stream.format);
param[paramIndex].key = KEY_MIMETYPE;
param[paramIndex].val = &codecMime;
param[paramIndex].size = sizeof(AvCodecMime);
paramIndex++;
VideoCodecRcMode rcMode = VID_CODEC_RC_CBR;
param[paramIndex].key = KEY_VIDEO_RC_MODE;
param[paramIndex].val = &rcMode;
param[paramIndex].size = sizeof(VideoCodecRcMode);
paramIndex++;
VideoCodecGopMode gopMode = VID_CODEC_GOPMODE_NORMALP;
param[paramIndex].key = KEY_VIDEO_GOP_MODE;
param[paramIndex].val = &gopMode;
param[paramIndex].size = sizeof(VideoCodecGopMode);
paramIndex++;
Profile profile = HEVC_MAIN_PROFILE;
param[paramIndex].key = KEY_VIDEO_PROFILE;
param[paramIndex].val = &profile;
param[paramIndex].size = sizeof(Profile);
paramIndex++;
#if (!defined(__LINUX__)) || (defined(ENABLE_PASSTHROUGH_MODE))
uint32_t width = stream.width;
uint32_t height = stream.height;
#else
uint32_t width = g_surface->GetWidth();
uint32_t height = g_surface->GetHeight();
#endif
MEDIA_DEBUG_LOG("width=%d", width);
param[paramIndex].key = KEY_VIDEO_WIDTH;
param[paramIndex].val = &width;
param[paramIndex].size = sizeof(uint32_t);
paramIndex++;
MEDIA_DEBUG_LOG("height=%d", height);
param[paramIndex].key = KEY_VIDEO_HEIGHT;
param[paramIndex].val = &height;
param[paramIndex].size = sizeof(uint32_t);
paramIndex++;
uint32_t frameRate = stream.fps;
MEDIA_DEBUG_LOG("frameRate=%u", frameRate);
param[paramIndex].key = KEY_VIDEO_FRAME_RATE;
param[paramIndex].val = &frameRate;
param[paramIndex].size = sizeof(uint32_t);
paramIndex++;
uint32_t bitRate = GetDefaultBitrate(width, height);
MEDIA_DEBUG_LOG("bitRate=%u kbps", bitRate);
param[paramIndex].key = KEY_BITRATE;
param[paramIndex].val = &bitRate;
param[paramIndex].size = sizeof(uint32_t);
paramIndex++;
int32_t ret = CodecCreateByType(domainKind, codecMime, codecHdl);
if (ret != 0) {
MEDIA_ERR_LOG("Create video encoder failed.");
return MEDIA_ERR;
}
ret = CodecSetParameter(*codecHdl, param, paramIndex);
if (ret != 0) {
CodecDestroy(*codecHdl);
MEDIA_ERR_LOG("video CodecSetParameter failed.");
return MEDIA_ERR;
}
ret = SetVencSource(*codecHdl, srcDev);
if (ret != 0) {
CodecDestroy(*codecHdl);
return MEDIA_ERR;
}
return MEDIA_OK;
}
static void FillParam(Param ¶m, ParamKey key, uint8_t *data, uint32_t size)
{
param.key = key;
param.val = data;
param.size = size;
}
static CODEC_HANDLETYPE CameraCreateJpegEncProc(FrameConfig &fc, uint32_t srcDev, AvCodecMime codecMime,
const Param* param, uint32_t paramNum)
{
CODEC_HANDLETYPE codecHdl = nullptr;
if (CodecCreateByType(VIDEO_ENCODER, codecMime, &codecHdl) != 0) {
return nullptr;
}
int32_t ret = CodecSetParameter(codecHdl, param, paramNum);
if (ret != 0) {
CodecDestroy(codecHdl);
return nullptr;
}
int32_t qfactor = -1;
fc.GetParameter(PARAM_KEY_IMAGE_ENCODE_QFACTOR, qfactor);
if (qfactor != -1) {
Param jpegParam = {
.key = KEY_IMAGE_Q_FACTOR,
.val = &qfactor,
.size = sizeof(qfactor)
};
ret = CodecSetParameter(codecHdl, &jpegParam, 1);
if (ret != 0) {
MEDIA_ERR_LOG("CodecSetParameter set jpeg qfactor failed.(ret=%u)", ret);
}
}
ret = SetVencSource(codecHdl, srcDev);
if (ret != 0) {
MEDIA_ERR_LOG("Set video encoder source failed.");
CodecDestroy(codecHdl);
return nullptr;
}
return codecHdl;
}
static int32_t CameraCreateJpegEnc(FrameConfig &fc, StreamAttr stream, uint32_t srcDev, CODEC_HANDLETYPE *codecHdl)
{
uint32_t maxParamNum = 10; /* 10 maxParamNum */
Param param[maxParamNum];
uint32_t paramIndex = 0;
CodecType domainKind = VIDEO_ENCODER;
FillParam(param[paramIndex], KEY_CODEC_TYPE, reinterpret_cast<uint8_t *>(&domainKind), sizeof(CodecType));
paramIndex++;
AvCodecMime codecMime = ConverFormat(stream.format);
FillParam(param[paramIndex], KEY_MIMETYPE, reinterpret_cast<uint8_t *>(&codecMime), sizeof(AvCodecMime));
paramIndex++;
auto surfaceList = fc.GetSurfaces();
Surface *surface = surfaceList.front();
uint32_t width = surface->GetWidth();
MEDIA_DEBUG_LOG("width=%d", width);
FillParam(param[paramIndex], KEY_VIDEO_WIDTH, reinterpret_cast<uint8_t *>(&width), sizeof(uint32_t));
paramIndex++;
uint32_t height = surface->GetHeight();
MEDIA_DEBUG_LOG("height=%d", height);
FillParam(param[paramIndex], KEY_VIDEO_HEIGHT, reinterpret_cast<uint8_t *>(&height), sizeof(uint32_t));
paramIndex++;
if (codecMime == MEDIA_MIMETYPE_VIDEO_HEVC) {
VideoCodecRcMode rcMode = VID_CODEC_RC_FIXQP;
FillParam(param[paramIndex], KEY_VIDEO_RC_MODE, reinterpret_cast<uint8_t *>(&rcMode), sizeof(VideoCodecRcMode));
paramIndex++;
Profile profile = HEVC_MAIN_PROFILE;
FillParam(param[paramIndex], KEY_VIDEO_PROFILE, reinterpret_cast<uint8_t *>(&profile), sizeof(Profile));
paramIndex++;
uint32_t frameRate = stream.fps;
FillParam(param[paramIndex], KEY_VIDEO_FRAME_RATE, reinterpret_cast<uint8_t *>(&frameRate), sizeof(uint32_t));
paramIndex++;
}
*codecHdl = CameraCreateJpegEncProc(fc, srcDev, codecMime, param, paramIndex);
return (*codecHdl != nullptr) ? MEDIA_OK : MEDIA_ERR;
}
static int32_t CopyCodecOutput(uint8_t *dst, uint32_t *size, CodecBuffer *buffer)
{
if (dst == nullptr || size == nullptr || buffer == nullptr) {
return MEDIA_ERR;
}
char *dstBuf = reinterpret_cast<char *>(dst);
for (uint32_t i = 0; i < buffer->bufferCnt; i++) {
uint32_t packSize = buffer->buffer[i].length - buffer->buffer[i].offset;
errno_t ret = memcpy_s(dstBuf, *size, (void *)(buffer->buffer[i].buf + buffer->buffer[i].offset), packSize);
if (ret != EOK) {
return MEDIA_ERR;
}
*size -= packSize;
dstBuf += packSize;
}
return MEDIA_OK;
}
static void StreamAttrInitialize(StreamAttr *streamAttr, Surface *surface,
StreamType streamType, FrameConfig &fc)
{
if (streamAttr == nullptr || surface == nullptr) {
return;
}
(void)memset_s(streamAttr, sizeof(StreamAttr), 0, sizeof(StreamAttr));
streamAttr->type = streamType;
fc.GetParameter(CAM_IMAGE_FORMAT, streamAttr->format);
streamAttr->width = surface->GetWidth();
streamAttr->height = surface->GetHeight();
fc.GetParameter(CAM_FRAME_FPS, streamAttr->fps);
fc.GetParameter(CAM_IMAGE_INVERT_MODE, streamAttr->invertMode);
fc.GetParameter(CAM_IMAGE_CROP_RECT, streamAttr->crop);
}
static ImageFormat Convert2HalImageFormat(uint32_t format)
{
if (format == CAM_IMAGE_RAW12) {
return FORMAT_RGB_BAYER_12BPP;
}
return FORMAT_YVU420;
}
static int32_t SurfaceSetSize(SurfaceBuffer* surfaceBuf, Surface* surface, uint32_t size)
{
#if (!defined(__LINUX__)) || (defined(ENABLE_PASSTHROUGH_MODE))
surfaceBuf->SetSize(surface->GetSize() - size);
if (surface->FlushBuffer(surfaceBuf) != 0) {
MEDIA_ERR_LOG("Flush g_surface failed.");
surface->CancelBuffer(surfaceBuf);
return -1;
}
#else
surfaceBuf->SetSize(g_surface->GetSize() - size);
if (g_surface->FlushBuffer(surfaceBuf) != 0) {
MEDIA_ERR_LOG("Flush surface failed.");
g_surface->CancelBuffer(surfaceBuf);
return -1;
}
#endif
return 0;
}
int32_t RecordAssistant::OnVencBufferAvailble(UINTPTR userData, CodecBuffer* outBuf, int32_t *acquireFd)
{
(void)acquireFd;
CodecDesc* codecInfo = reinterpret_cast<CodecDesc* >(userData);
list<Surface*> *surfaceList = &codecInfo->vencSurfaces_;
if (surfaceList == nullptr || surfaceList->empty()) {
MEDIA_ERR_LOG("Encoder handle is illegal.");
return MEDIA_ERR;
}
int32_t ret = -1;
for (auto &surface : *surfaceList) {
#if (!defined(__LINUX__)) || (defined(ENABLE_PASSTHROUGH_MODE))
SurfaceBuffer *surfaceBuf = surface->RequestBuffer();
#else
SurfaceBuffer *surfaceBuf = g_surface->RequestBuffer();
#endif
if (surfaceBuf == nullptr) {
MEDIA_ERR_LOG("No available buffer in surface.");
break;
}
#if (!defined(__LINUX__)) || (defined(ENABLE_PASSTHROUGH_MODE))
uint32_t size = surface->GetSize();
#else
uint32_t size = g_surface->GetSize();
#endif
void *buf = surfaceBuf->GetVirAddr();
if (buf == nullptr) {
MEDIA_ERR_LOG("Invalid buffer address.");
break;
}
ret = CopyCodecOutput((uint8_t*)buf, &size, outBuf);
if (ret != MEDIA_OK) {
MEDIA_ERR_LOG("No available outBuf in surface.");
#if (!defined(__LINUX__)) || (defined(ENABLE_PASSTHROUGH_MODE))
surface->CancelBuffer(surfaceBuf);
#else
g_surface->CancelBuffer(surfaceBuf);
#endif
break;
}
surfaceBuf->SetInt32(KEY_IS_SYNC_FRAME, (((outBuf->flag & STREAM_FLAG_KEYFRAME) == 0) ? 0 : 1));
surfaceBuf->SetInt64(KEY_TIME_US, outBuf->timeStamp);
ret = SurfaceSetSize(surfaceBuf, surface, size);
if (ret != 0) {
break;
}
}
if (CodecQueueOutput(codecInfo->vencHdl_, outBuf, 0, -1) != 0) {
MEDIA_ERR_LOG("Codec queue output failed.");
}
return ret;
}
CodecCallback RecordAssistant::recordCodecCb_ = {nullptr, nullptr, RecordAssistant::OnVencBufferAvailble};
void RecordAssistant::ClearFrameConfig()
{
for (uint32_t i = 0; i < codecInfo_.size(); i++) {
CodecStop(codecInfo_[i].vencHdl_);
CodecDestroy(codecInfo_[i].vencHdl_);
}
codecInfo_.clear();
}
int32_t RecordAssistant::SetFrameConfigEnd(int32_t result)
{
if (result != MEDIA_OK) {
for (uint32_t i = 0; i < codecInfo_.size(); i++) {
CodecDestroy(codecInfo_[i].vencHdl_);
}
codecInfo_.clear();
return result;
}
for (uint32_t i = 0; i < codecInfo_.size(); i++) {
result = CodecSetCallback(codecInfo_[i].vencHdl_, &recordCodecCb_, reinterpret_cast<UINTPTR>(&codecInfo_[i]));
if (result != 0) {
MEDIA_ERR_LOG("set CodecSetCallback failed ret:%d", result);
CodecDestroy(codecInfo_[i].vencHdl_);
break;
}
}
if (result == MEDIA_OK) {
state_ = LOOP_READY;
} else {
for (uint32_t i = 0; i < codecInfo_.size(); i++) {
CodecDestroy(codecInfo_[i].vencHdl_);
}
codecInfo_.clear();
}
return result;
}
int32_t RecordAssistant::SetFrameConfig(FrameConfig &fc, uint32_t *streamId)
{
fc_ = &fc;
auto surfaceList = fc.GetSurfaces();
if (surfaceList.size() > VIDEO_MAX_NUM || surfaceList.size() == 0) {
MEDIA_ERR_LOG("the number of surface in frame config must 1 or 2 now.\n");
return MEDIA_ERR;
}
uint32_t num = 0;
int32_t ret = MEDIA_OK;
for (auto &surface : surfaceList) {
CODEC_HANDLETYPE codecHdl = nullptr;
StreamAttr stream = {};
#if (!defined(__LINUX__)) || (defined(ENABLE_PASSTHROUGH_MODE))
StreamAttrInitialize(&stream, surface, STREAM_VIDEO, fc);
#else
StreamAttrInitialize(&stream, g_surface, STREAM_VIDEO, fc);
#endif
ret = HalCameraStreamCreate(cameraId_, &stream, streamId);
if (ret != MEDIA_OK) {
MEDIA_ERR_LOG(" creat recorder stream failed.");
ClearFrameConfig();
break;
}
streamId_ = *streamId;
streamIdNum_[num] = *streamId;
num++;
StreamInfo streamInfo;
streamInfo.type = STERAM_INFO_PRIVATE;
fc.GetVendorParameter(streamInfo.u.data, PRIVATE_TAG_LEN);
HalCameraStreamSetInfo(cameraId_, *streamId, &streamInfo);
uint32_t deviceId = 0;
HalCameraGetDeviceId(cameraId_, *streamId, &deviceId);
ret = CameraCreateVideoEnc(fc, stream, deviceId, &codecHdl);
if (ret != MEDIA_OK) {
MEDIA_ERR_LOG("Cannot create suitble video encoder.");
ClearFrameConfig();
break;
}
#if (!defined(__LINUX__)) || (defined(ENABLE_PASSTHROUGH_MODE))
list<Surface*> conList({surface});
#else
list<Surface*> conList({g_surface});
#endif
CodecDesc info;
info.vencHdl_ = codecHdl;
info.vencSurfaces_ = conList;
codecInfo_.emplace_back(info);
}
return SetFrameConfigEnd(ret);
}
int32_t RecordAssistant::Start(uint32_t streamId)
{
if (state_ != LOOP_READY) {
return MEDIA_ERR;
}
HalCameraStreamOn(cameraId_, streamId);
int32_t ret = MEDIA_OK;
int32_t i;
for (i = 0; static_cast<uint32_t>(i) < codecInfo_.size(); i++) {
ret = CodecStart(codecInfo_[i].vencHdl_);
if (ret != MEDIA_OK) {
MEDIA_ERR_LOG("Video encoder start failed.");
ret = MEDIA_ERR;
break;
}
}
if (ret == MEDIA_ERR) {
/* rollback */
for (; i >= 0; i--) {
CodecStop(codecInfo_[i].vencHdl_);
}
return MEDIA_ERR;
}
state_ = LOOP_LOOPING;
MEDIA_INFO_LOG("Start camera recording succeed.");
return MEDIA_OK;
}
int32_t RecordAssistant::Stop()
{
if (state_ != LOOP_LOOPING) {
return MEDIA_ERR;
}
ClearFrameConfig();
for (uint32_t i = 0; i < VIDEO_MAX_NUM; i++) {
if (streamIdNum_[i] != INVALID_STREAM_ID) {
HalCameraStreamOff(cameraId_, streamIdNum_[i]);
HalCameraStreamDestroy(cameraId_, streamIdNum_[i]);
}
streamIdNum_[i] = INVALID_STREAM_ID;
}
state_ = LOOP_STOP;
return MEDIA_OK;
}
void* PreviewAssistant::YuvCopyProcess(void *arg)
{
return nullptr;
}
static void GetSurfaceRect(Surface *surface, IRect *attr)
{
attr->x = std::stoi(surface->GetUserData(string("region_position_x")));
attr->y = std::stoi(surface->GetUserData(string("region_position_y")));
attr->w = std::stoi(surface->GetUserData(string("region_width")));
attr->h = std::stoi(surface->GetUserData(string("region_hegiht")));
}
int32_t PreviewAssistant::SetFrameConfig(FrameConfig &fc, uint32_t *streamId)
{
fc_ = &fc;
auto surfaceList = fc.GetSurfaces();
if (surfaceList.size() != 1) {
MEDIA_ERR_LOG("Only support one surface in frame config now.");
return MEDIA_ERR;
}
Surface *surface = surfaceList.front();
StreamAttr stream = {};
StreamAttrInitialize(&stream, surface, STREAM_PREVIEW, fc);
int32_t ret = HalCameraStreamCreate(cameraId_, &stream, streamId);
if (ret != MEDIA_OK) {
MEDIA_ERR_LOG(" creat preview stream failed.");
return MEDIA_ERR;
}
StreamInfo streamInfo;
streamInfo.type = STREAM_INFO_POS;
streamInfo.u.pos.x = std::stoi(surface->GetUserData(string("region_position_x")));
streamInfo.u.pos.y = std::stoi(surface->GetUserData(string("region_position_y")));
HalCameraStreamSetInfo(cameraId_, *streamId, &streamInfo);
streamId_ = *streamId;
return MEDIA_OK;
}
int32_t PreviewAssistant::Start(uint32_t streamId)
{
if (state_ == LOOP_LOOPING) {
return MEDIA_ERR;
}
state_ = LOOP_LOOPING;
int32_t retCode = pthread_create(&threadId, nullptr, YuvCopyProcess, this);
if (retCode != 0) {
MEDIA_ERR_LOG("fork thread YuvCopyProcess failed: %d.", retCode);
}
int32_t ret = HalCameraStreamOn(cameraId_, streamId);
if (ret != MEDIA_OK) {
MEDIA_ERR_LOG("Preview start failed of HalCameraStreamOn.(ret=%d)", ret);
Stop();
return MEDIA_ERR;
}
return MEDIA_OK;
}
int32_t PreviewAssistant::Stop()
{
if (state_ != LOOP_LOOPING) {
return MEDIA_ERR;
}
state_ = LOOP_STOP;
pthread_join(threadId, NULL);
HalCameraStreamOff(cameraId_, streamId_);
HalCameraStreamDestroy(cameraId_, streamId_);
return MEDIA_OK;
}
int32_t CaptureAssistant::SetFrameConfig(FrameConfig &fc, uint32_t *streamId)
{
auto surfaceList = fc.GetSurfaces();
if (surfaceList.size() != 1) {
MEDIA_ERR_LOG("Only support one surface in frame config now.");
return MEDIA_ERR;
}
if (surfaceList.empty()) {
MEDIA_ERR_LOG("Frame config with empty surface list.");
return MEDIA_ERR;
}
if (surfaceList.size() > 1) {
MEDIA_WARNING_LOG("Capture only fullfill the first surface in frame config.");
}
Surface *surface = surfaceList.front();
StreamAttr stream = {};
StreamAttrInitialize(&stream, surface, STREAM_CAPTURE, fc);
uint32_t deviceId = 0;
int32_t ret = HalCameraStreamCreate(cameraId_, &stream, streamId);
if (ret != MEDIA_OK) {
MEDIA_ERR_LOG(" creat capture stream failed.");
return MEDIA_ERR;
}
streamId_ = *streamId;
HalCameraGetDeviceId(cameraId_, *streamId, &deviceId);
ret = CameraCreateJpegEnc(fc, stream, deviceId, &vencHdl_);
if (ret != MEDIA_OK) {
MEDIA_ERR_LOG("Create capture venc failed.");
return MEDIA_ERR;
}
capSurface_ = surface;
state_ = LOOP_READY;
return MEDIA_OK;
}
/* Block method, waiting for capture completed */
int32_t CaptureAssistant::Start(uint32_t streamId)
{
state_ = LOOP_LOOPING;
HalCameraStreamOn(cameraId_, streamId);
int32_t ret = CodecStart(vencHdl_);
if (ret != 0) {
MEDIA_ERR_LOG("Start capture encoder failed.(ret=%d)", ret);
state_ = LOOP_STOP;
return MEDIA_ERR;
}
CodecBuffer* outInfo = (CodecBuffer*)new char[sizeof(CodecBuffer) + sizeof(CodecBufferInfo) * 3]; /* 3 buffCnt */
if (outInfo == NULL) {
MEDIA_ERR_LOG("malloc Dequeue buffer failed!");
return MEDIA_ERR;
}
SurfaceBuffer *surfaceBuf = NULL;
do {
if (memset_s(outInfo, sizeof(CodecBuffer) + sizeof(CodecBufferInfo) * 0x3, 0,
sizeof(CodecBuffer) + sizeof(CodecBufferInfo) * 3) != MEDIA_OK) { /* 3 buffCnt */
MEDIA_ERR_LOG("memset_s failed!");
delete(outInfo);
return MEDIA_ERR;
}
outInfo->bufferCnt = 3; /* 3 buffCnt */
ret = CodecDequeueOutput(vencHdl_, 0, nullptr, outInfo);
if (ret != 0) {
MEDIA_ERR_LOG("Dequeue capture frame failed.(ret=%d)", ret);
break;
}
surfaceBuf = capSurface_->RequestBuffer();
if (surfaceBuf == NULL) {
break;
}
uint32_t size = capSurface_->GetSize();
void *buf = surfaceBuf->GetVirAddr();
if (buf == nullptr) {
MEDIA_ERR_LOG("Invalid buffer address.");
break;
}
if (CopyCodecOutput((uint8_t*)buf, &size, outInfo) != MEDIA_OK) {
MEDIA_ERR_LOG("No available buffer in capSurface_.");
break;
}
surfaceBuf->SetSize(capSurface_->GetSize() - size);
if (capSurface_->FlushBuffer(surfaceBuf) != 0) {
MEDIA_ERR_LOG("Flush surface buffer failed.");
break;
}
} while (0);
CodecStop(vencHdl_);
CodecDestroy(vencHdl_);
HalCameraStreamOff(cameraId_, streamId);
HalCameraStreamDestroy(cameraId_, streamId);
delete outInfo;
outInfo = NULL;
state_ = LOOP_STOP;
return ret;
}
int32_t CaptureAssistant::Stop()
{
MEDIA_DEBUG_LOG("No support method.");
return MEDIA_OK;
}
int32_t CallbackAssistant::SetFrameConfig(FrameConfig &fc, uint32_t *streamId)
{
fc_ = &fc;
auto surfaceList = fc.GetSurfaces();
if (surfaceList.size() != 1) {
MEDIA_ERR_LOG("Only support one surface in frame config now.");
return MEDIA_ERR;
}
uint32_t imageFormat = 0;
fc.GetParameter(CAM_IMAGE_FORMAT, imageFormat);
ImageFormat halImageFormat = Convert2HalImageFormat(imageFormat);
MEDIA_INFO_LOG("Imageformat is %d", imageFormat);
Surface *surface = surfaceList.front();
StreamAttr stream = {};
StreamAttrInitialize(&stream, surface, STREAM_CALLBACK, fc);
stream.format = halImageFormat;
int32_t ret = HalCameraStreamCreate(cameraId_, &stream, streamId);
if (ret != MEDIA_OK) {
MEDIA_ERR_LOG(" creat callback stream failed.");
return MEDIA_ERR;
}
streamId_ = *streamId;
capSurface_ = surface;
state_ = LOOP_READY;
return MEDIA_OK;
}
int32_t CallbackAssistant::Start(uint32_t streamId)
{
if (state_ == LOOP_LOOPING) {
return MEDIA_ERR;
}
state_ = LOOP_LOOPING;
int32_t retCode = pthread_create(&threadId, nullptr, StreamCopyProcess, this);
if (retCode != 0) {
MEDIA_ERR_LOG("fork thread StreamCopyProcess failed: %d.", retCode);
}
HalCameraStreamOn(cameraId_, streamId);
return MEDIA_OK;
}
void* CallbackAssistant::StreamCopyProcess(void *arg)
{
CallbackAssistant *assistant = (CallbackAssistant *)arg;
if (assistant == nullptr) {
MEDIA_ERR_LOG("CallbackAssistant create failed.");
return nullptr;
}
if (assistant->capSurface_ == nullptr) {
MEDIA_ERR_LOG("capSurface_ is null.\n");
return nullptr;
}
int32_t ret;
HalBuffer streamBuffer;
(void)memset_s(&streamBuffer, sizeof(HalBuffer), 0, sizeof(HalBuffer));
while (assistant->state_ == LOOP_LOOPING) {
SurfaceBuffer *surfaceBuf = assistant->capSurface_->RequestBuffer();
if (surfaceBuf == nullptr) {
usleep(DELAY_TIME_ONE_FRAME);
continue;
}
if (streamBuffer.size != 0x0) {
HalCameraQueueBuf(assistant->cameraId_, assistant->streamId_, &streamBuffer);
(void)memset_s(&streamBuffer, sizeof(HalBuffer), 0, sizeof(HalBuffer));
}
streamBuffer.format = FORMAT_PRIVATE;
streamBuffer.size = assistant->capSurface_->GetSize();
if (surfaceBuf->GetVirAddr() == NULL) {
MEDIA_ERR_LOG("Invalid buffer address.");
break;
}
streamBuffer.virAddr = surfaceBuf->GetVirAddr();
ret = HalCameraDequeueBuf(assistant->cameraId_, assistant->streamId_, &streamBuffer);
if (ret != MEDIA_OK) {
usleep(DELAY_TIME_ONE_FRAME);
continue;
}
if (assistant->capSurface_->FlushBuffer(surfaceBuf) != 0) {
MEDIA_ERR_LOG("Flush surface failed.");
assistant->capSurface_->CancelBuffer(surfaceBuf);
break;
}
usleep(DELAY_TIME_ONE_FRAME);
}
if (streamBuffer.size != 0x0) {
HalCameraQueueBuf(assistant->cameraId_, assistant->streamId_, &streamBuffer);
}
MEDIA_DEBUG_LOG(" yuv thread joined \n");
return nullptr;
}
int32_t CallbackAssistant::Stop()
{
if (state_ != LOOP_LOOPING) {
return MEDIA_ERR;
}
state_ = LOOP_STOP;
pthread_join(threadId, NULL);
HalCameraStreamOff(cameraId_, streamId_);
HalCameraStreamDestroy(cameraId_, streamId_);
return MEDIA_OK;
}
CameraDevice::CameraDevice() {}
CameraDevice::CameraDevice(uint32_t cameraId)
{
this->cameraId = cameraId;
}
CameraDevice::~CameraDevice() {}
int32_t CameraDevice::Initialize()
{
// Need to be Refactored when delete config file
int32_t ret = CodecInit();
if (ret != 0) {
MEDIA_ERR_LOG("Codec module init failed.(ret=%d)", ret);
return MEDIA_ERR;
}
MEDIA_INFO_LOG("Codec module init succeed.");
captureAssistant_.state_ = LOOP_READY;
previewAssistant_.state_ = LOOP_READY;
recordAssistant_.state_ = LOOP_READY;
callbackAssistant_.state_ = LOOP_READY;
captureAssistant_.cameraId_ = cameraId;
previewAssistant_.cameraId_ = cameraId;
recordAssistant_.cameraId_ = cameraId;
callbackAssistant_.cameraId_ = cameraId;
return MEDIA_OK;
}
int32_t CameraDevice::UnInitialize()
{
return MEDIA_OK;
}
int32_t CameraDevice::TriggerLoopingCapture(FrameConfig &fc, uint32_t *streamId)
{
MEDIA_DEBUG_LOG("Camera device start looping capture.");
DeviceAssistant *assistant = nullptr;
int32_t fcType = fc.GetFrameConfigType();
switch (fcType) {
case FRAME_CONFIG_RECORD:
assistant = &recordAssistant_;
break;
case FRAME_CONFIG_PREVIEW:
assistant = &previewAssistant_;
break;
case FRAME_CONFIG_CAPTURE:
assistant = &captureAssistant_;
break;
case FRAME_CONFIG_CALLBACK:
assistant = &callbackAssistant_;
break;
default:
break;
}
if (assistant == nullptr) {
MEDIA_ERR_LOG("Invalid frame config type.(type=%d)", fcType);
return MEDIA_ERR;
}
if (assistant->state_ == LOOP_IDLE || assistant->state_ == LOOP_LOOPING || assistant->state_ == LOOP_ERROR) {
MEDIA_ERR_LOG("Device state is %d, cannot start looping capture.", assistant->state_);
return MEDIA_ERR;
}
uint8_t count = 1;
if (fcType == FRAME_CONFIG_CAPTURE) {
auto surfaceList = fc.GetSurfaces();
if (surfaceList.size() != 1) {
MEDIA_ERR_LOG("Only support one surface in frame config now");
return MEDIA_ERR;
}
Surface* surface = surfaceList.front();
count = surface->GetQueueSize();
}
do {
int32_t ret = assistant->SetFrameConfig(fc, streamId);
if (ret != MEDIA_OK) {
MEDIA_ERR_LOG("Check and set frame config failed (ret=%d)", ret);
return MEDIA_ERR;
}
ret = assistant->Start(*streamId);
if (ret != MEDIA_OK) {
MEDIA_ERR_LOG("Start looping capture failed (ret=%d)", ret);
return MEDIA_ERR;
}
} while (--count);
return MEDIA_OK;
}
void CameraDevice::StopLoopingCapture(int32_t type)
{
MEDIA_INFO_LOG("Stop looping capture in camera_device.cpp");
switch (type) {
case FRAME_CONFIG_RECORD:
MEDIA_INFO_LOG("Stop recorder");
recordAssistant_.Stop();;
break;
case FRAME_CONFIG_PREVIEW:
MEDIA_INFO_LOG("Stop preview");
previewAssistant_.Stop();
break;
case FRAME_CONFIG_CALLBACK:
MEDIA_INFO_LOG("Stop callback");
callbackAssistant_.Stop();
break;
default:
MEDIA_INFO_LOG("Stop all");
previewAssistant_.Stop();
recordAssistant_.Stop();
callbackAssistant_.Stop();
break;
}
}
int32_t CameraDevice::TriggerSingleCapture(FrameConfig &fc, uint32_t *streamId)
{
return TriggerLoopingCapture(fc, streamId);
}
int32_t CameraDevice::SetCameraConfig()
{
return MEDIA_OK;
}
} // namespace Media
} // namespace OHOS