VdpStatus vdp_decoder_render(VdpDecoder decoder, VdpVideoSurface target, VdpPictureInfo const *picture_info, uint32_t bitstream_buffer_count, VdpBitstreamBuffer const *bitstream_buffers) { decoder_ctx_t *dec = handle_get(decoder); if (!dec) return VDP_STATUS_INVALID_HANDLE; video_surface_ctx_t *vid = handle_get(target); if (!vid) return VDP_STATUS_INVALID_HANDLE; vid->source_format = INTERNAL_YCBCR_FORMAT; unsigned int i, pos = 0; for (i = 0; i < bitstream_buffer_count; i++) { memcpy(dec->data + pos, bitstream_buffers[i].bitstream, bitstream_buffers[i].bitstream_bytes); pos += bitstream_buffers[i].bitstream_bytes; } ve_flush_cache(dec->data, pos); return dec->decode(dec, picture_info, pos, vid); }
void decode_jpeg(struct jpeg_t *jpeg) { if (!ve_open()) err(EXIT_FAILURE, "Can't open VE"); int input_size =(jpeg->data_len + 65535) & ~65535; uint8_t *input_buffer = ve_malloc(input_size); int output_size = ((jpeg->width + 31) & ~31) * ((jpeg->height + 31) & ~31); uint8_t *luma_output = ve_malloc(output_size); uint8_t *chroma_output = ve_malloc(output_size); memcpy(input_buffer, jpeg->data, jpeg->data_len); ve_flush_cache(input_buffer, jpeg->data_len); // activate MPEG engine void *ve_regs = ve_get(VE_ENGINE_MPEG, 0); // set restart interval writel(jpeg->restart_interval, ve_regs + VE_MPEG_JPEG_RES_INT); // set JPEG format set_format(jpeg, ve_regs); // set output buffers (Luma / Croma) writel(ve_virt2phys(luma_output), ve_regs + VE_MPEG_ROT_LUMA); writel(ve_virt2phys(chroma_output), ve_regs + VE_MPEG_ROT_CHROMA); // set size set_size(jpeg, ve_regs); // ?? writel(0x00000000, ve_regs + VE_MPEG_SDROT_CTRL); // input end writel(ve_virt2phys(input_buffer) + input_size - 1, ve_regs + VE_MPEG_VLD_END); // ?? writel(0x0000007c, ve_regs + VE_MPEG_CTRL); // set input offset in bits writel(0 * 8, ve_regs + VE_MPEG_VLD_OFFSET); // set input length in bits writel(jpeg->data_len * 8, ve_regs + VE_MPEG_VLD_LEN); // set input buffer writel(ve_virt2phys(input_buffer) | 0x70000000, ve_regs + VE_MPEG_VLD_ADDR); // set Quantisation Table set_quantization_tables(jpeg, ve_regs); // set Huffman Table writel(0x00000000, ve_regs + VE_MPEG_RAM_WRITE_PTR); set_huffman_tables(jpeg, ve_regs); // start writeb(0x0e, ve_regs + VE_MPEG_TRIGGER); // wait for interrupt ve_wait(1); // clean interrupt flag (??) writel(0x0000c00f, ve_regs + VE_MPEG_STATUS); // stop MPEG engine ve_put(); //output_ppm(stdout, jpeg, output, output + (output_buf_size / 2)); if (!disp_open()) { fprintf(stderr, "Can't open /dev/disp\n"); return; } int color; switch ((jpeg->comp[0].samp_h << 4) | jpeg->comp[0].samp_v) { case 0x11: case 0x21: color = COLOR_YUV422; break; case 0x12: case 0x22: default: color = COLOR_YUV420; break; } disp_set_para(ve_virt2phys(luma_output), ve_virt2phys(chroma_output), color, jpeg->width, jpeg->height, 0, 0, 800, 600); getchar(); disp_close(); ve_free(input_buffer); ve_free(luma_output); ve_free(chroma_output); ve_close(); }
int h264enc_encode_picture(h264enc *c) { c->current_slice_type = c->current_frame_num ? SLICE_P : SLICE_I; c->regs = ve_get(VE_ENGINE_AVC, 0); /* flush buffers (output because otherwise we might read old data later) */ ve_flush_cache(c->bytestream_buffer, c->bytestream_buffer_size); ve_flush_cache(c->luma_buffer, c->input_buffer_size); /* set output buffer */ writel(0x0, c->regs + VE_AVC_VLE_OFFSET); writel(ve_virt2phys(c->bytestream_buffer), c->regs + VE_AVC_VLE_ADDR); writel(ve_virt2phys(c->bytestream_buffer) + c->bytestream_buffer_size - 1, c->regs + VE_AVC_VLE_END); writel(c->bytestream_buffer_size * 8, c->regs + VE_AVC_VLE_MAX); /* write headers */ if (c->write_sps_pps) { put_seq_parameter_set(c); put_pic_parameter_set(c); c->write_sps_pps = 0; } put_slice_header(c); /* set input size */ writel(c->mb_stride << 16, c->regs + VE_ISP_INPUT_STRIDE); writel((c->mb_width << 16) | (c->mb_height << 0), c->regs + VE_ISP_INPUT_SIZE); /* set input format */ writel(c->input_color_format << 29, c->regs + VE_ISP_CTRL); /* set input buffer */ writel(ve_virt2phys(c->luma_buffer), c->regs + VE_ISP_INPUT_LUMA); writel(ve_virt2phys(c->chroma_buffer), c->regs + VE_ISP_INPUT_CHROMA); /* set reconstruction buffers */ struct h264enc_ref_pic *ref_pic = &c->ref_picture[c->current_frame_num % 2]; writel(ve_virt2phys(ref_pic->luma_buffer), c->regs + VE_AVC_REC_LUMA); writel(ve_virt2phys(ref_pic->chroma_buffer), c->regs + VE_AVC_REC_CHROMA); writel(ve_virt2phys(ref_pic->extra_buffer), c->regs + VE_AVC_REC_SLUMA); /* set reference buffers */ if (c->current_slice_type != SLICE_I) { ref_pic = &c->ref_picture[(c->current_frame_num + 1) % 2]; writel(ve_virt2phys(ref_pic->luma_buffer), c->regs + VE_AVC_REF_LUMA); writel(ve_virt2phys(ref_pic->chroma_buffer), c->regs + VE_AVC_REF_CHROMA); writel(ve_virt2phys(ref_pic->extra_buffer), c->regs + VE_AVC_REF_SLUMA); } /* set unknown purpose buffers */ writel(ve_virt2phys(c->extra_buffer_line), c->regs + VE_AVC_MB_INFO); writel(ve_virt2phys(c->extra_buffer_frame), c->regs + VE_AVC_UNK_BUF); /* enable interrupt and clear status flags */ writel(readl(c->regs + VE_AVC_CTRL) | 0xf, c->regs + VE_AVC_CTRL); writel(readl(c->regs + VE_AVC_STATUS) | 0x7, c->regs + VE_AVC_STATUS); /* set encoding parameters */ uint32_t params = 0x0; if (c->entropy_coding_mode_flag) params |= 0x100; if (c->current_slice_type == SLICE_P) params |= 0x10; writel(params, c->regs + VE_AVC_PARAM); writel((4 << 16) | (c->pic_init_qp << 8) | c->pic_init_qp, c->regs + VE_AVC_QP); writel(0x00000104, c->regs + VE_AVC_MOTION_EST); /* trigger encoding */ writel(0x8, c->regs + VE_AVC_TRIGGER); ve_wait(1); /* check result */ uint32_t status = readl(c->regs + VE_AVC_STATUS); writel(status, c->regs + VE_AVC_STATUS); /* save bytestream length */ c->bytestream_length = readl(c->regs + VE_AVC_VLE_LENGTH) / 8; /* next frame */ c->current_frame_num++; if (c->current_frame_num >= c->keyframe_interval) c->current_frame_num = 0; ve_put(); return (status & 0x3) == 0x1; }
void decode_mpeg(struct frame_buffers_t *frame_buffers, const struct mpeg_t * const mpeg) { int input_size = (mpeg->len + 65535) & ~65535; uint8_t *input_buffer = ve_malloc(input_size); memcpy(input_buffer, mpeg->data, mpeg->len); ve_flush_cache(input_buffer, mpeg->len); void *ve_regs = ve_get_regs(); // set quantisation tables set_quantization_tables(ve_regs, mpeg_default_intra_quant, mpeg_default_non_intra_quant); // set size uint16_t width = (mpeg->width + 15) / 16; uint16_t height = (mpeg->height + 15) / 16; writel(ve_regs + 0x100 + 0x08, (width << 8) | height); writel(ve_regs + 0x100 + 0x0c, ((width * 16) << 16) | (height * 16)); // set picture header uint32_t pic_header = 0x00000000; pic_header |= ((mpeg->picture_coding_type & 0xf) << 28); pic_header |= ((mpeg->f_code[0][0] & 0xf) << 24); pic_header |= ((mpeg->f_code[0][1] & 0xf) << 20); pic_header |= ((mpeg->f_code[1][0] & 0xf) << 16); pic_header |= ((mpeg->f_code[1][1] & 0xf) << 12); pic_header |= ((mpeg->intra_dc_precision & 0x3) << 10); pic_header |= ((mpeg->picture_structure & 0x3) << 8); pic_header |= ((mpeg->top_field_first & 0x1) << 7); pic_header |= ((mpeg->frame_pred_frame_dct & 0x1) << 6); pic_header |= ((mpeg->concealment_motion_vectors & 0x1) << 5); pic_header |= ((mpeg->q_scale_type & 0x1) << 4); pic_header |= ((mpeg->intra_vlc_format & 0x1) << 3); pic_header |= ((mpeg->alternate_scan & 0x1) << 2); pic_header |= ((mpeg->full_pel_forward_vector & 0x1) << 1); pic_header |= ((mpeg->full_pel_backward_vector & 0x1) << 0); writel(ve_regs + 0x100 + 0x00, pic_header); // ?? writel(ve_regs + 0x100 + 0x10, 0x00000000); // ?? writel(ve_regs + 0x100 + 0x14, 0x800001b8); // ?? writel(ve_regs + 0x100 + 0xc4, 0x00000000); // ?? writel(ve_regs + 0x100 + 0xc8, 0x00000000); // set forward/backward predicion buffers if (mpeg->picture_coding_type == PCT_I || mpeg->picture_coding_type == PCT_P) { frame_unref(frame_buffers->forward); frame_buffers->forward = frame_ref(frame_buffers->backward); frame_unref(frame_buffers->backward); frame_buffers->backward = frame_ref(frame_buffers->output); } writel(ve_regs + 0x100 + 0x50, ve_virt2phys(frame_buffers->forward->luma_buffer)); writel(ve_regs + 0x100 + 0x54, ve_virt2phys(frame_buffers->forward->chroma_buffer)); writel(ve_regs + 0x100 + 0x58, ve_virt2phys(frame_buffers->backward->luma_buffer)); writel(ve_regs + 0x100 + 0x5c, ve_virt2phys(frame_buffers->backward->chroma_buffer)); // set output buffers (Luma / Croma) writel(ve_regs + 0x100 + 0x48, ve_virt2phys(frame_buffers->output->luma_buffer)); writel(ve_regs + 0x100 + 0x4c, ve_virt2phys(frame_buffers->output->chroma_buffer)); writel(ve_regs + 0x100 + 0xcc, ve_virt2phys(frame_buffers->output->luma_buffer)); writel(ve_regs + 0x100 + 0xd0, ve_virt2phys(frame_buffers->output->chroma_buffer)); // set input offset in bits writel(ve_regs + 0x100 + 0x2c, (mpeg->pos - 4) * 8); // set input length in bits (+ little bit more, else it fails sometimes ??) writel(ve_regs + 0x100 + 0x30, (mpeg->len - (mpeg->pos - 4) + 16) * 8); // input end writel(ve_regs + 0x100 + 0x34, ve_virt2phys(input_buffer) + input_size - 1); // set input buffer writel(ve_regs + 0x100 + 0x28, ve_virt2phys(input_buffer) | 0x50000000); // trigger writel(ve_regs + 0x100 + 0x18, (mpeg->type ? 0x02000000 : 0x01000000) | 0x8000000f); // wait for interrupt ve_wait(1); // clean interrupt flag (??) writel(ve_regs + 0x100 + 0x1c, 0x0000c00f); ve_free(input_buffer); }
int main(int argc, char *argv[]) { int rc; char *outjpeg = "poc.jpeg"; int quality = 100; uint32_t w = 0; uint32_t h = 0; uint32_t bufsize = 0; struct ve_mem *Y_mem = NULL; struct ve_mem *C_mem = NULL; struct ve_mem *J_mem = NULL; uint8_t *Y = NULL; uint8_t *C = NULL; uint8_t *J = NULL; uint32_t Jsize = 0; uint32_t Jwritten = 0; if (argc != 4 && argc != 5) { fprintf(stderr, "usage: %s width height quality [out.jpeg]\n", argv[0]); return 1; } w = atoi(argv[1]); h = atoi(argv[2]); quality = atoi(argv[3]); if (argc > 4) outjpeg = argv[4]; rc = ve_open(); if (rc == 0) { printf("[JEPOC] error: could not open ve engine!\n"); return 1; } w = (w + 15) & ~15; h = (h + 15) & ~15; printf("[JEPOC] picture %dx%-d at %d quality\n", w, h, quality); /* 3 times to leave enough room to try different color formats */ bufsize = w * h; Y_mem = ve_malloc(bufsize); if (!Y_mem) { printf("[JEPOC] ve memory error! [%d]\n", __LINE__); return 1; } Y = (uint8_t *) Y_mem->virt; C_mem = ve_malloc(bufsize); if (!C_mem) { printf("[JEPOC] ve memory error! [%d]\n", __LINE__); return 1; } C = (uint8_t *) C_mem->virt; memset(Y, 0x80, bufsize); memset(C, 0x80, bufsize); picture_generate(w, h, Y, C); printf("[JEPOC] picture generated.\n"); /* flush for H3 */ ve_flush_cache(Y_mem); ve_flush_cache(C_mem); Jsize = 0x800000; J_mem = ve_malloc(Jsize); if (!J_mem) { printf("[JEPOC] ve memory error! [%d]\n", __LINE__); return 1; } J = (uint8_t *) J_mem->virt; veavc_select_subengine(); veisp_set_buffers(Y_mem, C_mem); veisp_init_picture(w, h, VEISP_COLOR_FORMAT_NV12); veavc_init_vle(J_mem, Jsize); veavc_init_ctrl(VEAVC_ENCODER_MODE_JPEG); veavc_jpeg_parameters(1, 0, 0, 0); vejpeg_header_create(w, h, quality); vejpeg_write_SOF0(); vejpeg_write_SOS(); vejpeg_write_quantization(); printf("[JEPOC] launch encoding.\n"); veavc_launch_encoding(); ve_wait(2); veavc_check_status(); Jwritten = veavc_get_written(); /* flush for H3 */ ve_flush_cache(J_mem); vejpeg_write_file(outjpeg, J, Jwritten); printf("[JEPOC] written %d bytes to %s\n", Jwritten, outjpeg); ve_free(J_mem); ve_free(C_mem); ve_free(Y_mem); ve_close(); return 0; }