Added copycodectest and yuvcopy test source files
[glsdk/omapdrmtest.git] / copycodectest.c
1 /*
2  * Copyright (C) 2012 Texas Instruments
3  * Author: Ramprasad(x0038811@ti.com)
4  *
5  * This program is free software; you can redistribute it and/or modify it
6  * under the terms of the GNU General Public License version 2 as published by
7  * the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it will be useful, but WITHOUT
10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
12  * more details.
13  *
14  * You should have received a copy of the GNU General Public License along with
15  * this program.  If not, see <http://www.gnu.org/licenses/>.
16  */
17 #include <sys/types.h>
18 #include <sys/stat.h>
19 #include <fcntl.h>
20 #include <stdlib.h>
21 #include <string.h>
22 #include <stdio.h>
24 #include <libdce.h>
25 #include <xf86drm.h>
26 #include <omap_drm.h>
27 #include <omap_drmif.h>
28 #include "util.h"
30 #define MAX_IO_BUFS 16
32 typedef struct MemHeader {
33     unsigned int size;
34     void    *ptr;       /* vptr/handle for mpu access */
35     unsigned int dma_buf_fd; /* shared dma buf fd */
36     unsigned int region;    /* mem region the buffer allocated from */
37     /* internal meta data for the buffer */
38     unsigned int offset;    /* offset for the actual data with in the buffer */
39     unsigned int map_fd;     /* mmapped fd */
40     void * handle;      /*custom handle for the HLOS memallocator*/
41 } MemHeader;
42 #define P2H(p) (&(((MemHeader *)(p))[-1]))
43 /* omap drm device handle */
44 struct omap_device *dev = NULL;
46 struct decoder {
47         Engine_Handle engine;
48         VIDDEC2_Handle codec;
49         VIDDEC2_Params *params;
50         VIDDEC2_DynamicParams *dynParams;
51         VIDDEC2_Status *status;
52         XDM1_BufDesc *inBufs;
53         XDM_BufDesc *outBufs;
54         VIDDEC2_InArgs *inArgs;
55         VIDDEC2_OutArgs *outArgs;
56         char *input;
57         char *output;
58         int input_sz, output_sz;
59         XDAS_Int8 **outBuffer;
60         XDAS_Int32 *outBufSizes;
61 };
63 static void
64 decoder_close(struct decoder *decoder)
65 {
66         if (decoder->codec)          VIDDEC2_delete(decoder->codec);
67         if (decoder->engine)         Engine_close(decoder->engine);
68         if (decoder->params)         dce_free(decoder->params);
69         if (decoder->dynParams)      dce_free(decoder->dynParams);
70         if (decoder->status)         dce_free(decoder->status);
71         if (decoder->inBufs)         dce_free(decoder->inBufs);
72         if (decoder->outBufs)        dce_free(decoder->outBufs);
73         if (decoder->inArgs)         dce_free(decoder->inArgs);
74         if (decoder->outArgs)        dce_free(decoder->outArgs);
75         if (decoder->input)          dce_free(decoder->input);
76         if (decoder->output)         dce_free(decoder->output);
77         if (decoder->outBuffer)      dce_free(decoder->outBuffer);
78         if (decoder->outBufSizes)    dce_free(decoder->outBufSizes);
79         free(decoder);
81         if (dev)                             dce_deinit(dev);
82 }
84 static struct decoder *
85 decoder_open(int pattern)
86 {
87         struct decoder *decoder;
88         int i;
89         int width = 176, height = 144;
90         Engine_Error ec;
91         XDAS_Int32 err;
93         decoder = calloc(1, sizeof(*decoder));
94         if (!decoder)
95                 return NULL;
97         MSG("%p: Opening Engine..", decoder);
98         dev = dce_init();
99         if(dev == NULL) {
100                 ERROR("%p: dce init failed", dev);
101                 goto fail;
102         }
103         decoder->engine = Engine_open("dsp_vidsvr", NULL, &ec);
104         if (!decoder->engine) {
105                 ERROR("%p: could not open engine", decoder);
106                 goto fail;
107         }
108         decoder->input_sz = width * height;
109         decoder->input = dce_alloc(decoder->input_sz);
111         decoder->output_sz = width * height;
112         decoder->output = dce_alloc(decoder->output_sz);
114         decoder->params = dce_alloc(sizeof(IVIDDEC2_Params));
115         decoder->params->size = sizeof(IVIDDEC2_Params);
117         decoder->codec = VIDDEC2_create(decoder->engine,
118                                         "dsp_universalCopy", decoder->params);
120         if (!decoder->codec) {
121                 ERROR("%p: could not create codec", decoder);
122                 goto fail;
123         }
124     MSG("Created dsp_universalCopy \n");
125         decoder->dynParams = dce_alloc(sizeof(IVIDDEC2_DynamicParams));
126         decoder->dynParams->size = sizeof(IVIDDEC2_DynamicParams);
128         decoder->status = dce_alloc(sizeof(IVIDDEC2_Status));
129         decoder->status->size = sizeof(IVIDDEC2_Status);
131         err = VIDDEC2_control(decoder->codec, XDM_SETPARAMS,
132                         decoder->dynParams, decoder->status);
133         if (err) {
134                 ERROR("%p: fail: %d", decoder, err);
135                 goto fail;
136         }
137         /* not entirely sure why we need to call this here.. just copying omx.. */
138         err = VIDDEC2_control(decoder->codec, XDM_GETBUFINFO,
139                         decoder->dynParams, decoder->status);
140         if (err) {
141                 ERROR("%p: fail: %d", decoder, err);
142                 goto fail;
143         }
145         decoder->outBuffer = dce_alloc(sizeof(XDAS_Int8*) * MAX_IO_BUFS);
146         decoder->outBufSizes = dce_alloc(sizeof(XDAS_Int32)* MAX_IO_BUFS);
148         decoder->inBufs = dce_alloc(sizeof(XDM1_BufDesc));
149         decoder->inBufs->numBufs = 1;
150         decoder->inBufs->descs[0].buf = (XDAS_Int8 *)omap_bo_dmabuf((P2H(decoder->input))->ptr);
151         decoder->inBufs->descs[0].bufSize = (P2H(decoder->input))->size;
153         decoder->outBuffer[0] = (XDAS_Int8*)(omap_bo_dmabuf((P2H(decoder->output))->ptr));
154         decoder->outBuffer[1] = decoder->outBuffer[0];
155         decoder->outBufSizes[0] = (XDAS_Int32)((P2H(decoder->output))->size);
156         decoder->outBufSizes[1] = decoder->outBufSizes[0];
158         decoder->outBufs = dce_alloc(sizeof(XDM_BufDesc));
159         decoder->outBufs->numBufs = 2;
160         decoder->outBufs->bufs = (XDAS_Int8**)decoder->outBuffer;
161         decoder->outBufs->bufSizes = &decoder->outBufSizes[0];
163         decoder->inArgs = dce_alloc(sizeof(IVIDDEC2_InArgs));
164         decoder->inArgs->size = sizeof(IVIDDEC2_InArgs);
166         decoder->outArgs = dce_alloc(sizeof(IVIDDEC2_OutArgs));
167         decoder->outArgs->size = sizeof(IVIDDEC2_OutArgs);
169         // Fill input buffer with a pattern for testing */
170         MSG("Fill first 10 bytes of input buffer with pattern %d\n", pattern);
171         for(i = 0; i < 10 ; i++)
172            decoder->input[i] = pattern;
174         return decoder;
177 usage:
178         MSG("Fail\n");
179 fail:
180         if (decoder)
181            decoder_close(decoder);
182         return NULL;
185 static int
186 decoder_process(struct decoder *decoder)
188     XDM1_BufDesc *inBufs = decoder->inBufs;
189     XDM_BufDesc *outBufs = decoder->outBufs;
190     VIDDEC2_InArgs *inArgs = decoder->inArgs;
191     VIDDEC2_OutArgs *outArgs = decoder->outArgs;
192     XDAS_Int32 err = XDM_EOK, i,j;
194     err = VIDDEC2_process(decoder->codec, inBufs, outBufs, inArgs, outArgs);
195     if (err) {
196        ERROR("%p: process returned error: %d", decoder, err);
197        return -1;
198       }
200     MSG("Verifing the UniversalCopy algorithm\n");
201     MSG("First 10 bytes of Output buffer\n");
203     for(j= 0 ; j < 10 ; j++){
204         MSG("%d\t", decoder->output[j]);
205      }
207     MSG("Tested UniversalCopy successfully\n");
208         return 0;
211 int
212 main(int argc, char **argv)
214     struct decoder *decoder = NULL;
215     int pattern;
216     if(argc != 2){
217        MSG("Usage: copycodectest pattern(0 to 255) \t");
218        MSG("Example: copycodectest 100\n");
219        exit(0);
220     }
221     pattern = atoi(argv[1]);
222     decoder = decoder_open(pattern);
224     if(decoder)
225        decoder_process(decoder);
227     if(decoder)
228        decoder_close(decoder);
230     return 0;