void vpu_close_encoding_instance(EncodingInstance* instance) { int i; EncOutputInfo outinfo = {}; RetCode ret; EncodingInstance ptr = *instance; for(i = 0; i < ptr->fbcount; i++) { framebuf_free(ptr->pfbpool[i]); } free(ptr->fb); free(ptr->pfbpool); ret = vpu_EncClose(ptr->handle); if(ret == RETCODE_FRAME_NOT_COMPLETE) { vpu_EncGetOutputInfo(ptr->handle, &outinfo); vpu_EncClose(ptr->handle); } IOFreeVirtMem(&(ptr->mem_desc)); IOFreePhyMem(&(ptr->mem_desc)); close(ptr->fd); free(*instance); *instance = NULL; }
int vpu_encode_one_frame(EncodingInstance instance, const unsigned char* data) { EncHandle handle = instance->handle; int src_fbid = instance->src_fbid; EncOutputInfo outinfo = {}; int ret; u32 vbuf; u32 yuv_addr; yuv_addr = instance->pfbpool[src_fbid]->addrY + instance->pfbpool[src_fbid]->desc.virt_uaddr - instance->pfbpool[src_fbid]->desc.phy_addr; MEMCPY((unsigned char*)yuv_addr, data, instance->input_size); pthread_mutex_lock(&vpu_mutex); ret = vpu_EncStartOneFrame(handle, &(instance->enc_param)); if(vpu_IsBusy()) { usleep(0); vpu_WaitForInt(200); } ret = vpu_EncGetOutputInfo(handle, &outinfo); pthread_mutex_unlock(&vpu_mutex); vbuf = (instance->virt_bsbuf_addr + outinfo.bitstreamBuffer - instance->phy_bsbuf_addr); ret = vpu_write(instance->fd, (void*)vbuf, outinfo.bitstreamSize); return 0; }
static void x264_encoder_close(struct x264_encode *enc) { EncOutputInfo outinfo = {0}; RetCode ret; ret = vpu_EncClose(enc->handle); if (ret == RETCODE_FRAME_NOT_COMPLETE) { vpu_EncGetOutputInfo(enc->handle, &outinfo); vpu_EncClose(enc->handle); } }
static int x264_encoder_start(EncData *d,MSPicture *pic,MSQueue *nalus,int* sizeAll,SPSInfo *sps,PPSInfo *pps,int* key) { struct x264_encode *enc=d->enc; EncHandle handle = enc->handle; EncParam enc_param = {0}; EncOpenParam encop = {0}; EncOutputInfo outinfo = {0}; RetCode ret = 0; int src_fbid = enc->src_fbid, img_size; FrameBuffer *fb = enc->fb; struct frame_buf **pfbpool = enc->pfbpool; struct frame_buf *pfb; unsigned int yuv_addr; unsigned int vbuf; mblk_t *m; int i; if(d->framenum==0) { ret = x264_encoder_fill_headers(enc,nalus,d,sizeAll,sps,pps); if (ret) { ms_error("MSH264Enc: Encode fill headers failed\n"); return -1; } } enc_param.sourceFrame = &enc->fb[src_fbid]; enc_param.quantParam = 23; if(d->framenum%100==0) { enc_param.forceIPicture = 1; } else { enc_param.forceIPicture = 0; } enc_param.skipPicture = 0; enc_param.enableAutoSkip = 1; enc_param.encLeftOffset = 0; enc_param.encTopOffset = 0; if ((enc_param.encLeftOffset + enc->enc_picwidth) > enc->src_picwidth) { ms_error("MSH264Enc: Configure is failure for width and left offset\n"); return -1; } if ((enc_param.encTopOffset + enc->enc_picheight) > enc->src_picheight) { ms_error("MSH264Enc: Configure is failure for height and top offset\n"); return -1; } img_size = enc->src_picwidth * enc->src_picheight * 3 / 2; /* The main encoding loop */ pfb = pfbpool[src_fbid]; yuv_addr = pfb->addrY + pfb->desc.virt_uaddr - pfb->desc.phy_addr; memcpy((void *)yuv_addr, pic->planes[0],img_size); ret = vpu_EncStartOneFrame(handle, &enc_param); if (ret != RETCODE_SUCCESS) { ms_error("MSH264Enc: vpu_EncStartOneFrame failed Err code:%d\n", ret); goto err2; } //struct timeval tv1,tv2; //gettimeofday(&tv2,NULL); while (vpu_IsBusy()) { vpu_WaitForInt(200); } //gettimeofday(&tv1,NULL); //ms_message("[INFO] TIME=%d ",tv1.tv_sec*1000 + tv1.tv_usec/1000 - tv2.tv_sec*1000 - tv2.tv_usec/1000); ret = vpu_EncGetOutputInfo(handle, &outinfo); if (ret != RETCODE_SUCCESS) { ms_error("MSH264Enc: vpu_EncGetOutputInfo failed Err code: %d\n", ret); goto err2; } if (outinfo.skipEncoded) ms_message("[INFO] Skip encoding one Frame!\n"); vbuf = (enc->virt_bsbuf_addr + outinfo.bitstreamBuffer - enc->phy_bsbuf_addr); //ms_message("[INFO] LEN=%d NUM=%d",outinfo.bitstreamSize,outinfo.numOfSlices); if( (*((char*)vbuf+4) & 0x1F) ==5 ) { *key=1; //ms_message("[KEY]=%x num=%llu",*((char*)vbuf+4),d->framenum); } for(i=1;i<=outinfo.numOfSlices;i++) { void *ptr; int size; if(i==outinfo.numOfSlices) { m=allocb(outinfo.bitstreamSize+10,0); memcpy(m->b_wptr,(void*)vbuf+4,outinfo.bitstreamSize-4); m->b_wptr+=outinfo.bitstreamSize-4; ms_queue_put(nalus,m); *sizeAll+=outinfo.bitstreamSize; //ms_message("[INFO] LEN[%d]=%d",i,outinfo.bitstreamSize); break; } ptr=x264_find_header((void*)vbuf+1000,outinfo.bitstreamSize-1000); if(ptr==NULL) { ms_error("MSH264Enc: x264_find_header failed error"); goto err2; } size=ptr-(void*)vbuf; m=allocb(size+10,0); memcpy(m->b_wptr,(void*)vbuf+4,size-4); m->b_wptr+=size-4; ms_queue_put(nalus,m); *sizeAll+=size; vbuf=(unsigned int)ptr; outinfo.bitstreamSize-=size; //ms_message("[INFO] LEN[%d]=%d",i,size); } err2: /* For automation of test case */ if (ret > 0) ret = 0; return ret; }
int main(void){ int ret = 0, i; vpu_versioninfo ver; // vpu version information vpu_mem_desc bit_stream_buf; // input bit stream allocated memory vpu_mem_desc source_buf; // source buffer allocated memory FrameBuffer source_frame; // source framebuffer // VPU specific members defined in vpu_lib.h EncHandle *handle = malloc(sizeof(EncHandle)); EncOpenParam *encOP = malloc(sizeof(EncOpenParam)); EncInitialInfo *initialInfo = malloc(sizeof(EncInitialInfo)); EncOutputInfo *outputInfo = malloc(sizeof(EncOutputInfo)); EncParam *encParam = malloc(sizeof(EncParam)); // Set allocated memory to zero memset (initialInfo, 0, sizeof (EncInitialInfo)); memset (encParam, 0, sizeof (EncParam)); memset (encOP, 0, sizeof (EncOpenParam)); memset (outputInfo, 0, sizeof (EncOutputInfo)); memset (&bit_stream_buf, 0, sizeof (vpu_mem_desc)); // Init VPU if(vpu_Init (NULL) < 0) { printf(">> failed to call vpu_Init()\n"); ret = -1; goto free; } vpu_GetVersionInfo(&ver); printf("VPU Version: firmware %d.%d.%d; libvpu: %d.%d.%d \n", ver.fw_major, ver.fw_minor, ver.fw_release, ver.lib_major, ver.lib_minor, ver.lib_release); // Allocate input buffer bit_stream_buf.size = BUFF_FILL_SIZE; IOGetPhyMem (&bit_stream_buf); if(bit_stream_buf.phy_addr == 0) { printf(">> error allocating encoder bitstream buffer\n"); ret = -1; goto free; } IOGetVirtMem (&bit_stream_buf); // Set up encoder operation parameters encOP->bitstreamBuffer = bit_stream_buf.phy_addr; encOP->bitstreamBufferSize = BUFF_FILL_SIZE; encOP->bitstreamFormat = STD_AVC; encOP->gopSize = DEFAULT_GOP_SIZE; encOP->rcIntraQp = VPU_DEFAULT_H264_QP; encOP->userQpMaxEnable = 1; encOP->userQpMax = H264_QP_MAX; encOP->userQpMinEnable = 1; encOP->userQpMin = H264_QP_MIN; encOP->frameRateInfo = DEFAULT_FRAME_RATE; encOP->picWidth = DEFAULT_WIDTH; encOP->picHeight = DEFAULT_HEIGHT; encOP->ringBufferEnable = 0; // Open encoder vpu_EncOpen (handle, encOP); // Configure IRAM memory SearchRamParam search_pa = { 0 }; iram_t iram; int ram_size; memset (&iram, 0, sizeof (iram_t)); ram_size = ((DEFAULT_WIDTH + 15) & ~15) * 36 + 2048; IOGetIramBase (&iram); if ((iram.end - iram.start) < ram_size) ram_size = iram.end - iram.start; search_pa.searchRamAddr = iram.start; search_pa.SearchRamSize = ram_size; vpu_EncGiveCommand (*handle, ENC_SET_SEARCHRAM_PARAM, &search_pa); vpu_EncGetInitialInfo (*handle, initialInfo); // Disable rotation/mirroring vpu_EncGiveCommand (*handle, DISABLE_ROTATION, 0); vpu_EncGiveCommand (*handle, DISABLE_MIRRORING, 0); // Allocate memory for source frame buffer source_buf.size = DEFAULT_WIDTH * DEFAULT_HEIGHT * 3/2; IOGetPhyMem (&source_buf); if(source_buf.phy_addr == 0) { printf(">> error allocating source frame buffer\n"); ret = -1; goto close; } IOGetVirtMem(&source_buf); source_frame.strideY = DEFAULT_WIDTH; source_frame.strideC = DEFAULT_WIDTH >> 1; source_frame.bufY = source_buf.phy_addr; source_frame.bufCb = source_frame.bufY + DEFAULT_WIDTH * DEFAULT_HEIGHT; source_frame.bufCr = source_frame.bufCb + (DEFAULT_WIDTH * DEFAULT_HEIGHT >> 2); printf("source frame buffer %i phys(%p) virt(%p)\n", 0, source_buf.phy_addr, source_buf.virt_uaddr); // Get number of destination frame buffers and allocate int num = initialInfo->minFrameBufferCount; printf("number of needed frame buffers: %d\n", num); vpu_mem_desc *framedesc = malloc(sizeof(vpu_mem_desc) * num); FrameBuffer *frame = malloc(sizeof(FrameBuffer) * num); memset (framedesc, 0, (sizeof (vpu_mem_desc) * num)); memset (frame, 0, (sizeof (FrameBuffer) * num)); // Allocate each destination frame buffer for (i = 0; i < num; i++) { framedesc[i].size = DEFAULT_WIDTH * DEFAULT_HEIGHT * 3/2; IOGetPhyMem (&(framedesc[i])); if (framedesc[i].phy_addr == 0) { printf(">> error allocating destination frame buffers\n"); ret = -1; goto frame; } IOGetVirtMem (&(framedesc[i])); frame[i].strideY = DEFAULT_WIDTH; frame[i].strideC = DEFAULT_WIDTH >> 1; frame[i].bufY = framedesc[i].phy_addr; frame[i].bufCb = frame[i].bufY + (DEFAULT_WIDTH * DEFAULT_HEIGHT); frame[i].bufCr = frame[i].bufCb + ((DEFAULT_WIDTH * DEFAULT_HEIGHT) >> 2); printf("destination frame buffer %i phys(%p) virt(%p)\n", i, framedesc[i].phy_addr, framedesc[i].virt_uaddr); } // Register allocated frame buffers vpu_EncRegisterFrameBuffer (*handle, frame, num, DEFAULT_WIDTH, DEFAULT_WIDTH, 0, 0, NULL); encParam->forceIPicture = 0; encParam->skipPicture = 0; encParam->enableAutoSkip = 0; encParam->quantParam = VPU_DEFAULT_H264_QP; // Get encoding Headers EncHeaderParam enchdr_param = { 0 }; uint8_t *ptr; uint8_t *header[NUM_INPUT_BUF]; uint32_t headersize[NUM_INPUT_BUF]; // size for each header element enchdr_param.headerType = SPS_RBSP; vpu_EncGiveCommand (*handle, ENC_PUT_AVC_HEADER, &enchdr_param); headersize[SPS_HDR] = enchdr_param.size; header[SPS_HDR] = malloc (enchdr_param.size); if (header[SPS_HDR] == NULL) { printf (">> error in allocating memory for SPS_RBSP Header" ); ret = -1; goto frame; } ptr = (uint8_t*) (bit_stream_buf.virt_uaddr + enchdr_param.buf - bit_stream_buf.phy_addr); memcpy (header[SPS_HDR], ptr, enchdr_param.size); printf("header[SPS_HDR]: %d bytes\n", headersize[SPS_HDR]); enchdr_param.headerType = PPS_RBSP; vpu_EncGiveCommand (*handle, ENC_PUT_AVC_HEADER, &enchdr_param); headersize[PPS_HDR] = enchdr_param.size; header[PPS_HDR] = malloc (enchdr_param.size); if (header[PPS_HDR] == NULL) { printf (">> error in allocating memory for PPS_HDR Header" ); ret = -1; goto frame; } ptr = (uint8_t*) (bit_stream_buf.virt_uaddr + enchdr_param.buf - bit_stream_buf.phy_addr); memcpy (header[PPS_HDR], ptr, enchdr_param.size); printf("header[PPS_HDR]: %d bytes\n", headersize[PPS_HDR]); // Open output file and write headers FILE *out = fopen ("BigBuckBunny_640x360_small.h264", "w"); //stdout fwrite(header[SPS_HDR], 1, headersize[SPS_HDR], out); fwrite(header[PPS_HDR], 1, headersize[PPS_HDR], out); // Copy and Encode FILE *in = fopen ("BigBuckBunny_640x360_small.yuv", "r"); while(fread((void*) source_buf.virt_uaddr, 1, DEFAULT_WIDTH * DEFAULT_HEIGHT * 3/2, in)) { encParam->sourceFrame = &source_frame; // Encode a single frame vpu_EncStartOneFrame (*handle, encParam); while(vpu_IsBusy()) { vpu_WaitForInt (100); } vpu_EncGetOutputInfo (*handle, outputInfo); // Write bitstream to file fwrite((void*) bit_stream_buf.virt_uaddr, 1, outputInfo->bitstreamSize, out); } printf("\n"); fclose(in); fclose(out); frame: for (i = 0; i < num; i++) { IOFreeVirtMem(&(framedesc[i])); IOFreePhyMem(&(framedesc[i])); } free(frame); free(framedesc); close: // Close encoder vpu_EncClose (*handle); // Free alocated input buffer IOFreeVirtMem (&bit_stream_buf); IOFreePhyMem (&bit_stream_buf); free: free(encOP); free(initialInfo); free(outputInfo); free(encParam); free(handle); return ret; }