~thopiekar/arm-mali/libvdpau-sunxi

« back to all changes in this revision

Viewing changes to mpeg12.c

  • Committer: Jens Kuske
  • Date: 2016-02-16 13:12:22 UTC
  • Revision ID: git-v1:685769372a8281bf67046a958883323aaf14d232
Use libcedrus

Show diffs side-by-side

added added

removed removed

Lines of Context:
18
18
 */
19
19
 
20
20
#include <string.h>
 
21
#include <cedrus/cedrus.h>
 
22
#include <cedrus/cedrus_regs.h>
21
23
#include "vdpau_private.h"
22
 
#include "ve.h"
23
24
 
24
25
static const uint8_t zigzag_scan[64] =
25
26
{
66
67
                               video_surface_ctx_t *output)
67
68
{
68
69
        VdpPictureInfoMPEG1Or2 const *info = (VdpPictureInfoMPEG1Or2 const *)_info;
69
 
        int start_offset = mpeg_find_startcode(decoder->data->virt, len);
 
70
        int start_offset = mpeg_find_startcode(cedrus_mem_get_pointer(decoder->data), len);
70
71
 
71
72
        VdpStatus ret = yuv_prepare(output);
72
73
        if (ret != VDP_STATUS_OK)
79
80
        int i;
80
81
 
81
82
        // activate MPEG engine
82
 
        void *ve_regs = ve_get(VE_ENGINE_MPEG, 0);
 
83
        void *ve_regs = cedrus_ve_get(decoder->device->cedrus, CEDRUS_ENGINE_MPEG, 0);
83
84
 
84
85
        // set quantisation tables
85
86
        for (i = 0; i < 64; i++)
115
116
        writel(pic_header, ve_regs + VE_MPEG_PIC_HDR);
116
117
 
117
118
        // ??
118
 
        writel(0x80000138 | ((ve_get_version() != 0x1680) << 7), ve_regs + VE_MPEG_CTRL);
119
 
        if (ve_get_version() == 0x1680)
 
119
        writel(0x80000138 | ((cedrus_get_ve_version(decoder->device->cedrus) != 0x1680) << 7), ve_regs + VE_MPEG_CTRL);
 
120
        if (cedrus_get_ve_version(decoder->device->cedrus) == 0x1680)
120
121
                writel((0x2 << 30) | (0x1 << 28) | (output->chroma_size / 2), ve_regs + VE_EXTRA_OUT_FMT_OFFSET);
121
122
 
122
123
        // set forward/backward predicion buffers
123
124
        if (info->forward_reference != VDP_INVALID_HANDLE)
124
125
        {
125
126
                video_surface_ctx_t *forward = handle_get(info->forward_reference);
126
 
                writel(forward->rec->phys, ve_regs + VE_MPEG_FWD_LUMA);
127
 
                writel(forward->rec->phys + forward->luma_size, ve_regs + VE_MPEG_FWD_CHROMA);
 
127
                writel(cedrus_mem_get_bus_addr(forward->rec), ve_regs + VE_MPEG_FWD_LUMA);
 
128
                writel(cedrus_mem_get_bus_addr(forward->rec) + forward->luma_size, ve_regs + VE_MPEG_FWD_CHROMA);
128
129
        }
129
130
        if (info->backward_reference != VDP_INVALID_HANDLE)
130
131
        {
131
132
                video_surface_ctx_t *backward = handle_get(info->backward_reference);
132
 
                writel(backward->rec->phys, ve_regs + VE_MPEG_BACK_LUMA);
133
 
                writel(backward->rec->phys + backward->luma_size, ve_regs + VE_MPEG_BACK_CHROMA);
 
133
                writel(cedrus_mem_get_bus_addr(backward->rec), ve_regs + VE_MPEG_BACK_LUMA);
 
134
                writel(cedrus_mem_get_bus_addr(backward->rec) + backward->luma_size, ve_regs + VE_MPEG_BACK_CHROMA);
134
135
        }
135
136
 
136
137
        // set output buffers (Luma / Croma)
137
 
        writel(output->rec->phys, ve_regs + VE_MPEG_REC_LUMA);
138
 
        writel(output->rec->phys + output->luma_size, ve_regs + VE_MPEG_REC_CHROMA);
139
 
        writel(output->yuv->data->phys, ve_regs + VE_MPEG_ROT_LUMA);
140
 
        writel(output->yuv->data->phys + output->luma_size, ve_regs + VE_MPEG_ROT_CHROMA);
 
138
        writel(cedrus_mem_get_bus_addr(output->rec), ve_regs + VE_MPEG_REC_LUMA);
 
139
        writel(cedrus_mem_get_bus_addr(output->rec) + output->luma_size, ve_regs + VE_MPEG_REC_CHROMA);
 
140
        writel(cedrus_mem_get_bus_addr(output->yuv->data), ve_regs + VE_MPEG_ROT_LUMA);
 
141
        writel(cedrus_mem_get_bus_addr(output->yuv->data) + output->luma_size, ve_regs + VE_MPEG_ROT_CHROMA);
141
142
 
142
143
        // set input offset in bits
143
144
        writel(start_offset * 8, ve_regs + VE_MPEG_VLD_OFFSET);
146
147
        writel((len - start_offset) * 8, ve_regs + VE_MPEG_VLD_LEN);
147
148
 
148
149
        // input end
149
 
        uint32_t input_addr = decoder->data->phys;
 
150
        uint32_t input_addr = cedrus_mem_get_bus_addr(decoder->data);
150
151
        writel(input_addr + VBV_SIZE - 1, ve_regs + VE_MPEG_VLD_END);
151
152
 
152
153
        // set input buffer
156
157
        writel((((decoder->profile == VDP_DECODER_PROFILE_MPEG1) ? 1 : 2) << 24) | 0x8000000f, ve_regs + VE_MPEG_TRIGGER);
157
158
 
158
159
        // wait for interrupt
159
 
        ve_wait(1);
 
160
        cedrus_ve_wait(decoder->device->cedrus, 1);
160
161
 
161
162
        // clean interrupt flag
162
163
        writel(0x0000c00f, ve_regs + VE_MPEG_STATUS);
163
164
 
164
165
        // stop MPEG engine
165
 
        ve_put();
 
166
        cedrus_ve_put(decoder->device->cedrus);
166
167
 
167
168
        return VDP_STATUS_OK;
168
169
}