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;
}
