~thopiekar/arm-mali/libvdpau-sunxi

« back to all changes in this revision

Viewing changes to h265.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:
20
20
#include <stdlib.h>
21
21
#include <string.h>
22
22
#include <unistd.h>
 
23
#include <cedrus/cedrus.h>
 
24
#include <cedrus/cedrus_regs.h>
23
25
#include "vdpau_private.h"
24
 
#include "ve.h"
25
26
 
26
27
static int find_startcode(const uint8_t *data, int len, int start)
27
28
{
158
159
        video_surface_ctx_t *output;
159
160
        uint8_t nal_unit_type;
160
161
 
161
 
        struct ve_mem *neighbor_info;
162
 
        struct ve_mem *entry_points;
 
162
        cedrus_mem_t *neighbor_info;
 
163
        cedrus_mem_t *entry_points;
163
164
 
164
165
        struct h265_slice_header slice;
165
166
};
166
167
 
167
168
struct h265_video_private
168
169
{
169
 
        struct ve_mem *extra_data;
 
170
        cedrus_mem_t *extra_data;
170
171
};
171
172
 
172
173
static void h265_video_private_free(video_surface_ctx_t *surface)
173
174
{
174
175
        struct h265_video_private *vp = surface->decoder_private;
175
 
        ve_free(vp->extra_data);
 
176
        cedrus_mem_free(vp->extra_data);
176
177
        free(vp);
177
178
}
178
179
 
186
187
                if (!vp)
187
188
                        return NULL;
188
189
 
189
 
                vp->extra_data = ve_malloc(PicSizeInCtbsY * 160);
 
190
                vp->extra_data = cedrus_mem_alloc(surface->device->cedrus, PicSizeInCtbsY * 160);
190
191
                if (!vp->extra_data)
191
192
                {
192
193
                        free(vp);
435
436
                        writel(VE_SRAM_HEVC_PIC_LIST + i * 0x20, p->regs + VE_HEVC_SRAM_ADDR);
436
437
                        writel(p->info->PicOrderCntVal[i], p->regs + VE_HEVC_SRAM_DATA);
437
438
                        writel(p->info->PicOrderCntVal[i], p->regs + VE_HEVC_SRAM_DATA);
438
 
                        writel(vp->extra_data->phys >> 8, p->regs + VE_HEVC_SRAM_DATA);
439
 
                        writel(vp->extra_data->phys >> 8, p->regs + VE_HEVC_SRAM_DATA);
440
 
                        writel(v->yuv->data->phys >> 8, p->regs + VE_HEVC_SRAM_DATA);
441
 
                        writel((v->yuv->data->phys + v->luma_size) >> 8, p->regs + VE_HEVC_SRAM_DATA);
 
439
                        writel(cedrus_mem_get_bus_addr(vp->extra_data) >> 8, p->regs + VE_HEVC_SRAM_DATA);
 
440
                        writel(cedrus_mem_get_bus_addr(vp->extra_data) >> 8, p->regs + VE_HEVC_SRAM_DATA);
 
441
                        writel(cedrus_mem_get_bus_addr(v->yuv->data) >> 8, p->regs + VE_HEVC_SRAM_DATA);
 
442
                        writel((cedrus_mem_get_bus_addr(v->yuv->data) + v->luma_size) >> 8, p->regs + VE_HEVC_SRAM_DATA);
442
443
                }
443
444
        }
444
445
 
447
448
        writel(VE_SRAM_HEVC_PIC_LIST + i * 0x20, p->regs + VE_HEVC_SRAM_ADDR);
448
449
        writel(p->info->CurrPicOrderCntVal, p->regs + VE_HEVC_SRAM_DATA);
449
450
        writel(p->info->CurrPicOrderCntVal, p->regs + VE_HEVC_SRAM_DATA);
450
 
        writel(vp->extra_data->phys >> 8, p->regs + VE_HEVC_SRAM_DATA);
451
 
        writel(vp->extra_data->phys >> 8, p->regs + VE_HEVC_SRAM_DATA);
452
 
        writel(p->output->yuv->data->phys >> 8, p->regs + VE_HEVC_SRAM_DATA);
453
 
        writel((p->output->yuv->data->phys + p->output->luma_size) >> 8, p->regs + VE_HEVC_SRAM_DATA);
 
451
        writel(cedrus_mem_get_bus_addr(vp->extra_data) >> 8, p->regs + VE_HEVC_SRAM_DATA);
 
452
        writel(cedrus_mem_get_bus_addr(vp->extra_data) >> 8, p->regs + VE_HEVC_SRAM_DATA);
 
453
        writel(cedrus_mem_get_bus_addr(p->output->yuv->data) >> 8, p->regs + VE_HEVC_SRAM_DATA);
 
454
        writel((cedrus_mem_get_bus_addr(p->output->yuv->data) + p->output->luma_size) >> 8, p->regs + VE_HEVC_SRAM_DATA);
454
455
 
455
456
        writel(i, p->regs + VE_HEVC_REC_BUF_IDX);
456
457
}
549
550
        writel((y << 16) | (x << 0), p->regs + VE_HEVC_TILE_START_CTB);
550
551
        writel(((y + p->info->row_height_minus1[ty]) << 16) | ((x + p->info->column_width_minus1[tx]) << 0), p->regs + VE_HEVC_TILE_END_CTB);
551
552
 
552
 
        uint32_t *entry_points = p->entry_points->virt;
 
553
        uint32_t *entry_points = cedrus_mem_get_pointer(p->entry_points);
553
554
        for (i = 0; i < p->slice.num_entry_point_offsets; i++)
554
555
        {
555
556
                if (tx + 1 >= p->info->num_tile_columns_minus1 + 1)
568
569
                entry_points[i * 4 + 3] = ((y + p->info->row_height_minus1[ty]) << 16) | ((x + p->info->column_width_minus1[tx]) << 0);
569
570
        }
570
571
 
571
 
        ve_flush_cache(p->entry_points);
572
 
        writel(p->entry_points->phys >> 8, p->regs + VE_HEVC_TILE_LIST_ADDR);
 
572
        cedrus_mem_flush_cache(p->entry_points);
 
573
        writel(cedrus_mem_get_bus_addr(p->entry_points) >> 8, p->regs + VE_HEVC_TILE_LIST_ADDR);
573
574
}
574
575
 
575
576
static void write_weighted_pred(struct h265_private *p)
724
725
        if (ret != VDP_STATUS_OK)
725
726
                return ret;
726
727
 
727
 
        p->regs = ve_get(VE_ENGINE_HEVC, 0x0);
 
728
        p->regs = cedrus_ve_get(decoder->device->cedrus, CEDRUS_ENGINE_HEVC, 0x0);
728
729
 
729
730
        int pos = 0;
730
 
        while ((pos = find_startcode(decoder->data->virt, len, pos)) != -1)
 
731
        while ((pos = find_startcode(cedrus_mem_get_pointer(decoder->data), len, pos)) != -1)
731
732
        {
732
 
                writel((decoder->data->phys + VBV_SIZE - 1) >> 8, p->regs + VE_HEVC_BITS_END_ADDR);
 
733
                writel((cedrus_mem_get_bus_addr(decoder->data) + VBV_SIZE - 1) >> 8, p->regs + VE_HEVC_BITS_END_ADDR);
733
734
                writel((len - pos) * 8, p->regs + VE_HEVC_BITS_LEN);
734
735
                writel(pos * 8, p->regs + VE_HEVC_BITS_OFFSET);
735
 
                writel((decoder->data->phys >> 8) | (0x7 << 28), p->regs + VE_HEVC_BITS_ADDR);
 
736
                writel((cedrus_mem_get_bus_addr(decoder->data) >> 8) | (0x7 << 28), p->regs + VE_HEVC_BITS_ADDR);
736
737
 
737
738
                writel(0x7, p->regs + VE_HEVC_TRIG);
738
739
 
825
826
                write_entry_point_list(p);
826
827
 
827
828
                writel(0x0, p->regs + 0x580);
828
 
                writel(p->neighbor_info->phys >> 8, p->regs + VE_HEVC_NEIGHBOR_INFO_ADDR);
 
829
                writel(cedrus_mem_get_bus_addr(p->neighbor_info) >> 8, p->regs + VE_HEVC_NEIGHBOR_INFO_ADDR);
829
830
 
830
831
                write_pic_list(p);
831
832
 
833
834
                write_weighted_pred(p);
834
835
 
835
836
                writel(0x8, p->regs + VE_HEVC_TRIG);
836
 
                ve_wait(1);
 
837
                cedrus_ve_wait(decoder->device->cedrus, 1);
837
838
 
838
839
                writel(readl(p->regs + VE_HEVC_STATUS) & 0x7, p->regs + VE_HEVC_STATUS);
839
840
        }
840
841
 
841
 
        ve_put();
 
842
        cedrus_ve_put(decoder->device->cedrus);
842
843
 
843
844
        return VDP_STATUS_OK;
844
845
}
847
848
{
848
849
        struct h265_private *p = decoder->private;
849
850
 
850
 
        ve_free(p->neighbor_info);
851
 
        ve_free(p->entry_points);
 
851
        cedrus_mem_free(p->neighbor_info);
 
852
        cedrus_mem_free(p->entry_points);
852
853
 
853
854
        free(p);
854
855
}
859
860
        if (!p)
860
861
                return VDP_STATUS_RESOURCES;
861
862
 
862
 
        p->neighbor_info = ve_malloc(397 * 1024);
863
 
        p->entry_points = ve_malloc(4 * 1024);
 
863
        p->neighbor_info = cedrus_mem_alloc(decoder->device->cedrus, 397 * 1024);
 
864
        p->entry_points = cedrus_mem_alloc(decoder->device->cedrus, 4 * 1024);
864
865
 
865
866
        decoder->decode = h265_decode;
866
867
        decoder->private = p;