static int encoder_allocate_framebuffer(struct EncodingInstance* instance)
{
EncHandle handle = instance->handle;
int i, enc_stride, src_stride, fbcount = instance->fbcount, src_fbid = instance->src_fbid;
RetCode ret;
FrameBuffer *fb;
struct frame_buf **pfbpool;
fb = instance->fb = calloc(fbcount + 1, sizeof(FrameBuffer));
if(fb == NULL)
{
fputs("Failed to allocate enc->fb\n", stderr);
return -1;
}
pfbpool = instance->pfbpool = calloc(fbcount + 1, sizeof(struct frame_buf*));
if(pfbpool == NULL)
{
fputs("Failed to allocate enc->pfbpool", stderr);
free(fb);
return -1;
}
for(i = 0; i < fbcount; i++)
{
pfbpool[i] = framebuf_alloc(STD_AVC, MODE420, (instance->enc_picwidth + 15) & ~15, (instance->enc_picheight + 15) & ~15);
if(pfbpool[i] == NULL)
{
fbcount = i;
goto err1;
}
fb[i].bufY = pfbpool[i]->addrY;
fb[i].bufCb = pfbpool[i]->addrCb;
fb[i].bufCr = pfbpool[i]->addrCr;
fb[i].strideY = pfbpool[i]->strideY;
fb[i].strideC = pfbpool[i]->strideC;
}
/* Must be a multiple of 16 */
enc_stride = (instance->enc_picwidth + 15) & ~15;
src_stride = (instance->src_picwidth + 15) & ~15;
ret = vpu_EncRegisterFrameBuffer(handle, fb, fbcount, enc_stride, src_stride);
if(ret != RETCODE_SUCCESS)
{
fputs("Register frame buffer failed", stderr);
goto err1;
}
pfbpool[src_fbid] = framebuf_alloc(STD_AVC, MODE420, instance->src_picwidth, instance->src_picheight);
if(pfbpool[src_fbid] == NULL)
{
goto err1;
}
fb[src_fbid].bufY = pfbpool[src_fbid]->addrY;
fb[src_fbid].bufCb = pfbpool[src_fbid]->addrCb;
fb[src_fbid].bufCr = pfbpool[src_fbid]->addrCr;
fb[src_fbid].strideY = pfbpool[src_fbid]->strideY;
fb[src_fbid].strideC = pfbpool[src_fbid]->strideC;
instance->fbcount++;
return 0;
err1: for(i = 0; i < fbcount; i++)
{
framebuf_free(pfbpool[i]);
}
free(fb);
free(pfbpool);
return -1;
}
int VpuDec::calloc_FrameBuff(VencBlk * src)
{
int mvCol = 1;
int ret = -1;
int i;
DecBufInfo bufinfo;
FrameBuffer *fb;
struct frame_buf **pfbpool;
if (dec_format == STD_MJPG)
mvCol = 0;
fb = dec_fb = (FrameBuffer *)calloc(regfbcount, sizeof(FrameBuffer));
if (fb == NULL) {
printf("Failed to allocate fb,LINE:%d\n",__LINE__);
return -1;
}
pfbpool = dec_pfbpool = (frame_buf **)calloc(regfbcount, sizeof(struct frame_buf *));
if (pfbpool == NULL) {
printf("Failed to allocate pfbpool,LINE:%d\n",__LINE__);
free(dec_fb);
dec_fb = NULL;
return -1;
}
for (i = 0; i < regfbcount; i++) {
pfbpool[i] = framebuf_alloc(&fbpool[i], STD_AVC, 0, src->width, src->height, mvCol);
if (pfbpool[i] == NULL)
return -1;
}
for (i = 0; i < regfbcount; i++) {
fb[i].myIndex = i;
fb[i].bufY = pfbpool[i]->addrY;
fb[i].bufCb = pfbpool[i]->addrCb;
fb[i].bufCr = pfbpool[i]->addrCr;
fb[i].bufMvCol = pfbpool[i]->mvColBuf;
}
if (dec_format == STD_AVC) {
ret = IOGetPhyMem(&slice_mem_desc);
if (ret) {
printf("Unable to obtain physical slice save mem,LINE:%d\n",__LINE__);
return -1;
}
bufinfo.avcSliceBufInfo.bufferBase = slice_mem_desc.phy_addr;
bufinfo.avcSliceBufInfo.bufferSize = slice_mem_desc.size;
}
bufinfo.maxDecFrmInfo.maxMbX = src->width / 16;
bufinfo.maxDecFrmInfo.maxMbY = src->height / 16;
bufinfo.maxDecFrmInfo.maxMbNum = src->width * src->height / 256;
ret = vpu_DecRegisterFrameBuffer(handle, fb, regfbcount, src->width, &bufinfo);
if (ret != RETCODE_SUCCESS) {
printf("Register frame buffer failed, ret=%d,LINE:%d\n", ret,__LINE__);
return -1;
}
return 0;
}
int32_t encoder_allocate_framebuffer(struct encode *enc)
{
EncHandle handle = enc->handle;
int32_t i, enc_stride, src_stride, src_fbid;
int32_t totalfb, minfbcount, srcfbcount, extrafbcount;
RetCode ret;
FrameBuffer *fb;
PhysicalAddress subSampBaseA = 0, subSampBaseB = 0;
struct frame_buf **pfbpool;
EncExtBufInfo extbufinfo = { 0 };
int32_t enc_fbwidth, enc_fbheight, src_fbwidth, src_fbheight;
minfbcount = enc->minFrameBufferCount;
srcfbcount = 1;
enc_fbwidth = (enc->enc_picwidth + 15) & ~15;
enc_fbheight = (enc->enc_picheight + 15) & ~15;
src_fbwidth = (enc->src_picwidth + 15) & ~15;
src_fbheight = (enc->src_picheight + 15) & ~15;
if (cpu_is_mx6()) {
if (enc->codecctrl->format == STD_AVC && enc->mvc_extension) /* MVC */
extrafbcount = 2 + 2; /* Subsamp [2] + Subsamp MVC [2] */
else if (enc->codecctrl->format == STD_MJPG)
extrafbcount = 0;
else
extrafbcount = 2; /* Subsamp buffer [2] */
} else
extrafbcount = 0;
enc->totalfb = totalfb = minfbcount + extrafbcount + srcfbcount;
/* last framebuffer is used as src frame in the test */
enc->src_fbid = src_fbid = totalfb - 1;
fb = enc->fb = calloc(totalfb, sizeof(FrameBuffer));
if (fb == NULL) {
err_msg("Failed to allocate enc->fb\n");
return -1;
}
pfbpool = enc->pfbpool = calloc(totalfb, sizeof(struct frame_buf *));
if (pfbpool == NULL) {
err_msg("Failed to allocate enc->pfbpool\n");
free(fb);
return -1;
}
if (enc->codecctrl->mapType == LINEAR_FRAME_MAP) {
/* All buffers are linear */
for (i = 0; i < minfbcount + extrafbcount; i++) {
pfbpool[i] = framebuf_alloc(enc->codecctrl->format, enc->mjpg_fmt,
enc_fbwidth, enc_fbheight, 0);
if (pfbpool[i] == NULL) {
goto err1;
}
}
} else {
/* Encoded buffers are tiled */
for (i = 0; i < minfbcount; i++) {
pfbpool[i] = tiled_framebuf_alloc(enc->codecctrl->format, enc->mjpg_fmt,
enc_fbwidth, enc_fbheight, 0,
enc->codecctrl->mapType);
if (pfbpool[i] == NULL)
goto err1;
}
/* sub frames are linear */
for (i = minfbcount; i < minfbcount + extrafbcount; i++) {
pfbpool[i] = framebuf_alloc(enc->codecctrl->format, enc->mjpg_fmt,
enc_fbwidth, enc_fbheight, 0);
if (pfbpool[i] == NULL)
goto err1;
}
}
for (i = 0; i < minfbcount + extrafbcount; i++) {
fb[i].myIndex = i;
fb[i].bufY = pfbpool[i]->addrY;
fb[i].bufCb = pfbpool[i]->addrCb;
fb[i].bufCr = pfbpool[i]->addrCr;
fb[i].strideY = pfbpool[i]->strideY;
fb[i].strideC = pfbpool[i]->strideC;
}
if (cpu_is_mx6() && (enc->codecctrl->format != STD_MJPG)) {
subSampBaseA = fb[minfbcount].bufY;
subSampBaseB = fb[minfbcount + 1].bufY;
if (enc->codecctrl->format == STD_AVC && enc->mvc_extension) { /* MVC */
extbufinfo.subSampBaseAMvc = fb[minfbcount + 2].bufY;
extbufinfo.subSampBaseBMvc = fb[minfbcount + 3].bufY;
}
}
/* Must be a multiple of 16 */
if (enc->codecctrl->rot_angle == 90 || enc->codecctrl->rot_angle == 270)
enc_stride = (enc->enc_picheight + 15) & ~15;
else
enc_stride = (enc->enc_picwidth + 15) & ~15;
src_stride = (enc->src_picwidth + 15) & ~15;
extbufinfo.scratchBuf = enc->scratchBuf;
ret = VPU_EncRegisterFrameBuffer(handle, fb, minfbcount, enc_stride, src_stride,
subSampBaseA, subSampBaseB, &extbufinfo);
if (ret != RETCODE_SUCCESS) {
err_msg("Register frame buffer failed\n");
goto err1;
}
{
/* Allocate a single frame buffer for source frame */
pfbpool[src_fbid] = framebuf_alloc(enc->codecctrl->format, enc->mjpg_fmt,
src_fbwidth, src_fbheight, 0);
if (pfbpool[src_fbid] == NULL) {
err_msg("failed to allocate single framebuf\n");
goto err1;
}
fb[src_fbid].myIndex = enc->src_fbid;
fb[src_fbid].bufY = pfbpool[src_fbid]->addrY;
fb[src_fbid].bufCb = pfbpool[src_fbid]->addrCb;
fb[src_fbid].bufCr = pfbpool[src_fbid]->addrCr;
fb[src_fbid].strideY = pfbpool[src_fbid]->strideY;
fb[src_fbid].strideC = pfbpool[src_fbid]->strideC;
}
return 0;
err1:
for (i = 0; i < totalfb; i++) {
framebuf_free(pfbpool[i]);
}
free(fb);
free(pfbpool);
return -1;
}
