summaryrefslogtreecommitdiff
path: root/audio_codec/libcook/ra_decode.c (plain)
blob: 36322b617f7c779b59d0a98a83ba2a70969892c8
1#include <memory.h>
2#include "helix_types.h"
3#include "helix_result.h"
4#include "ra_decode.h"
5#include "rm_memory.h"
6#include "rm_error.h"
7#include "rm_memory_default.h"
8
9//#include "ra8hbr_decode.h"
10#include "ra8lbr_decode.h"
11//#include "sipro_decode.h"
12#include "aac_decode.h"
13#include <stdio.h>
14//#include <core/dsp.h>
15
16/* ra_decode_create()
17 * Creates RA decoder frontend struct, copies memory utilities.
18 * Returns struct pointer on success, NULL on failure. */
19ra_decode*
20ra_decode_create(void* pUserError,
21 rm_error_func_ptr fpError)
22{
23 return ra_decode_create2(pUserError,
24 fpError,
25 HXNULL,
26 rm_memory_default_malloc,
27 rm_memory_default_free);
28}
29
30ra_decode*
31ra_decode_create2(void* pUserError,
32 rm_error_func_ptr fpError,
33 void* pUserMem,
34 rm_malloc_func_ptr fpMalloc,
35 rm_free_func_ptr fpFree)
36{
37 ra_decode* pRet = HXNULL;
38
39 if (fpMalloc && fpFree) {
40 pRet = (ra_decode*) fpMalloc(pUserMem, sizeof(ra_decode));
41
42 if (pRet) {
43 /* Zero out the struct */
44 memset((void*) pRet, 0, sizeof(ra_decode));
45 /* Assign the error function */
46 pRet->fpError = fpError;
47 pRet->pUserError = pUserError;
48 /* Assign the memory functions */
49 pRet->fpMalloc = fpMalloc;
50 pRet->fpFree = fpFree;
51 pRet->pUserMem = pUserMem;
52 }
53 }
54
55 return pRet;
56}
57
58/* ra_decode_destroy()
59 * Deletes the decoder backend and frontend instances. */
60void
61ra_decode_destroy(ra_decode* pFrontEnd)
62{
63 rm_free_func_ptr fpFree;
64 void* pUserMem;
65
66 if (pFrontEnd && pFrontEnd->fpFree) {
67 /* Save a pointer to fpFree and pUserMem */
68 fpFree = pFrontEnd->fpFree;
69 pUserMem = pFrontEnd->pUserMem;
70
71 if (pFrontEnd->pDecode && pFrontEnd->fpClose) {
72 /* Free the decoder instance and backend */
73 pFrontEnd->fpClose(pFrontEnd->pDecode,
74 pUserMem,
75 fpFree);
76 }
77
78 /* Free the ra_decode struct memory */
79 fpFree(pUserMem, pFrontEnd);
80 }
81}
82
83/* ra_decode_init()
84 * Selects decoder backend with fourCC code.
85 * Calls decoder backend init function with init params.
86 * Returns zero on success, negative result indicates failure. */
87HX_RESULT
88ra_decode_init(ra_decode* pFrontEnd,
89 UINT32 ulFourCC,
90 void* pInitParams,
91 UINT32 ulInitParamsSize,
92 ra_format_info* pStreamInfo)
93{
94 HX_RESULT retVal = HXR_OK;
95
96 /* Assign the backend function pointers */
97 if (ulFourCC == 0x636F6F6B) { /* 'cook' */
98 pFrontEnd->fpInit = ra8lbr_decode_init;
99 pFrontEnd->fpReset = ra8lbr_decode_reset;
100 pFrontEnd->fpConceal = ra8lbr_decode_conceal;
101 pFrontEnd->fpDecode = ra8lbr_decode_decode;
102 pFrontEnd->fpGetMaxSize = ra8lbr_decode_getmaxsize;
103 pFrontEnd->fpGetChannels = ra8lbr_decode_getchannels;
104 pFrontEnd->fpGetChannelMask = ra8lbr_decode_getchannelmask;
105 pFrontEnd->fpGetSampleRate = ra8lbr_decode_getrate;
106 pFrontEnd->fpMaxSamp = ra8lbr_decode_getdelay;
107 pFrontEnd->fpClose = ra8lbr_decode_close;
108 }
109#if 0
110 else if (ulFourCC == 0x72616163 || /* 'raac' */
111 ulFourCC == 0x72616370) { /* 'racp' */
112 pFrontEnd->fpInit = aac_decode_init;
113 pFrontEnd->fpReset = aac_decode_reset;
114 pFrontEnd->fpConceal = aac_decode_conceal;
115 pFrontEnd->fpDecode = aac_decode_decode;
116 pFrontEnd->fpGetMaxSize = aac_decode_getmaxsize;
117 pFrontEnd->fpGetChannels = aac_decode_getchannels;
118 pFrontEnd->fpGetChannelMask = aac_decode_getchannelmask;
119 pFrontEnd->fpGetSampleRate = aac_decode_getrate;
120 pFrontEnd->fpMaxSamp = aac_decode_getdelay;
121 pFrontEnd->fpClose = aac_decode_close;
122 }
123#endif
124#if 0
125 else if (ulFourCC == 0x61747263) { /* 'atrc' */
126 pFrontEnd->fpInit = ra8hbr_decode_init;
127 pFrontEnd->fpReset = ra8hbr_decode_reset;
128 pFrontEnd->fpConceal = ra8hbr_decode_conceal;
129 pFrontEnd->fpDecode = ra8hbr_decode_decode;
130 pFrontEnd->fpGetMaxSize = ra8hbr_decode_getmaxsize;
131 pFrontEnd->fpGetChannels = ra8hbr_decode_getchannels;
132 pFrontEnd->fpGetChannelMask = ra8hbr_decode_getchannelmask;
133 pFrontEnd->fpGetSampleRate = ra8hbr_decode_getrate;
134 pFrontEnd->fpMaxSamp = ra8hbr_decode_getdelay;
135 pFrontEnd->fpClose = ra8hbr_decode_close;
136 } else if (ulFourCC == 0x73697072) { /* 'sipr' */
137 pFrontEnd->fpInit = sipro_decode_init;
138 pFrontEnd->fpReset = sipro_decode_reset;
139 pFrontEnd->fpConceal = sipro_decode_conceal;
140 pFrontEnd->fpDecode = sipro_decode_decode;
141 pFrontEnd->fpGetMaxSize = sipro_decode_getmaxsize;
142 pFrontEnd->fpGetChannels = sipro_decode_getchannels;
143 pFrontEnd->fpGetChannelMask = sipro_decode_getchannelmask;
144 pFrontEnd->fpGetSampleRate = sipro_decode_getrate;
145 pFrontEnd->fpMaxSamp = sipro_decode_getdelay;
146 pFrontEnd->fpClose = sipro_decode_close;
147 }
148#endif
149 else {
150 /* error - codec not supported */
151 //printk(" cook decode: not supported fourcc\n");
152 retVal = HXR_DEC_NOT_FOUND;
153 }
154
155 if (retVal == HXR_OK && pFrontEnd && pFrontEnd->fpInit && pStreamInfo) {
156 retVal = pFrontEnd->fpInit(pInitParams, ulInitParamsSize, pStreamInfo,
157 &pFrontEnd->pDecode, pFrontEnd->pUserMem,
158 pFrontEnd->fpMalloc, pFrontEnd->fpFree);
159 }
160
161 return retVal;
162}
163
164/* ra_decode_reset()
165 * Calls decoder backend reset function.
166 * Depending on which codec is in use, *pNumSamplesOut samples may
167 * be flushed. After reset, the decoder returns to its initial state.
168 * Returns zero on success, negative result indicates failure. */
169HX_RESULT
170ra_decode_reset(ra_decode* pFrontEnd,
171 UINT16* pSamplesOut,
172 UINT32 ulNumSamplesAvail,
173 UINT32* pNumSamplesOut)
174{
175 HX_RESULT retVal = HXR_FAIL;
176
177 if (pFrontEnd && pFrontEnd->fpReset) {
178 retVal = pFrontEnd->fpReset(pFrontEnd->pDecode, pSamplesOut,
179 ulNumSamplesAvail, pNumSamplesOut);
180 }
181
182 return retVal;
183}
184
185/* ra_decode_conceal()
186 * Calls decoder backend conceal function.
187 * On successive calls to ra_decode_decode(), the decoder will attempt
188 * to conceal ulNumSamples. No input data should be sent while concealed
189 * frames are being produced. Once the decoder has exhausted the concealed
190 * samples, it can proceed normally with decoding valid input data.
191 * Returns zero on success, negative result indicates failure. */
192HX_RESULT
193ra_decode_conceal(ra_decode* pFrontEnd,
194 UINT32 ulNumSamples)
195{
196 HX_RESULT retVal = HXR_FAIL;
197
198 if (pFrontEnd && pFrontEnd->fpConceal) {
199 retVal = pFrontEnd->fpConceal(pFrontEnd->pDecode, ulNumSamples);
200 }
201
202 return retVal;
203}
204
205/* ra_decode_decode()
206 * Calls decoder backend decode function.
207 * pData : input data (compressed frame).
208 * ulNumBytes : input data size in bytes.
209 * pNumBytesConsumed : amount of input data consumed by decoder.
210 * pSamplesOut : output data (uncompressed frame).
211 * ulNumSamplesAvail : size of output buffer.
212 * pNumSamplesOut : amount of ouput data produced by decoder.
213 * ulFlags : control flags for decoder.
214 * Returns zero on success, negative result indicates failure. */
215HX_RESULT
216ra_decode_decode(ra_decode* pFrontEnd,
217 UINT8* pData,
218 UINT32 ulNumBytes,
219 UINT32* pNumBytesConsumed,
220 UINT16* pSamplesOut,
221 UINT32 ulNumSamplesAvail,
222 UINT32* pNumSamplesOut,
223 UINT32 ulFlags,
224 UINT32 ulTimeStamp)
225{
226 HX_RESULT retVal = HXR_FAIL;
227
228 if (pFrontEnd && pFrontEnd->fpDecode) {
229 retVal = pFrontEnd->fpDecode(pFrontEnd->pDecode, pData, ulNumBytes,
230 pNumBytesConsumed, pSamplesOut,
231 ulNumSamplesAvail, pNumSamplesOut, ulFlags, ulTimeStamp);
232 }
233
234 return retVal;
235}
236
237
238/**************** Accessor Functions *******************/
239/* ra_decode_getmaxsize()
240 * pNumSamples receives the maximum number of samples produced
241 * by the decoder in response to a call to ra_decode_decode().
242 * Returns zero on success, negative result indicates failure. */
243HX_RESULT
244ra_decode_getmaxsize(ra_decode* pFrontEnd,
245 UINT32* pNumSamples)
246{
247 HX_RESULT retVal = HXR_FAIL;
248
249 if (pFrontEnd && pFrontEnd->fpGetMaxSize) {
250 retVal = pFrontEnd->fpGetMaxSize(pFrontEnd->pDecode, pNumSamples);
251 }
252
253 return retVal;
254}
255
256/* ra_decode_getchannels()
257 * pNumChannels receives the number of audio channels in the bitstream.
258 * Returns zero on success, negative result indicates failure. */
259HX_RESULT
260ra_decode_getchannels(ra_decode* pFrontEnd,
261 UINT32* pNumChannels)
262{
263 HX_RESULT retVal = HXR_FAIL;
264
265 if (pFrontEnd && pFrontEnd->fpGetChannels) {
266 retVal = pFrontEnd->fpGetChannels(pFrontEnd->pDecode, pNumChannels);
267 }
268
269 return retVal;
270}
271
272/* ra_decode_getchannelmask()
273 * pChannelMask receives the 32-bit mapping of the audio output channels.
274 * Returns zero on success, negative result indicates failure. */
275HX_RESULT
276ra_decode_getchannelmask(ra_decode* pFrontEnd,
277 UINT32* pChannelMask)
278{
279 HX_RESULT retVal = HXR_FAIL;
280
281 if (pFrontEnd && pFrontEnd->fpGetChannelMask) {
282 retVal = pFrontEnd->fpGetChannelMask(pFrontEnd->pDecode, pChannelMask);
283 }
284
285 return retVal;
286}
287
288/* ra_decode_getrate()
289 * pSampleRate receives the sampling rate of the output samples.
290 * Returns zero on success, negative result indicates failure. */
291HX_RESULT
292ra_decode_getrate(ra_decode* pFrontEnd,
293 UINT32* pSampleRate)
294{
295 HX_RESULT retVal = HXR_FAIL;
296
297 if (pFrontEnd && pFrontEnd->fpGetSampleRate) {
298 retVal = pFrontEnd->fpGetSampleRate(pFrontEnd->pDecode, pSampleRate);
299 }
300
301 return retVal;
302}
303
304/* ra_decode_getdelay()
305 * pNumSamples receives the number of invalid output samples
306 * produced by the decoder at startup.
307 * If non-zero, it is up to the user to discard these samples.
308 * Returns zero on success, negative result indicates failure. */
309HX_RESULT
310ra_decode_getdelay(ra_decode* pFrontEnd,
311 UINT32* pNumSamples)
312{
313 HX_RESULT retVal = HXR_FAIL;
314
315 if (pFrontEnd && pFrontEnd->fpMaxSamp) {
316 retVal = pFrontEnd->fpMaxSamp(pFrontEnd->pDecode, pNumSamples);
317 }
318
319 return retVal;
320}
321
322
generated by cgit at 2024-05-18 22:09:09 (GMT)