1 /*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16 /**
17 *************************************************************************
18 * @file M4VSS3GPP_Codecs.c
19 * @brief VSS implementation
20 * @note This file contains all functions related to audio/video
21 * codec manipulations.
22 *************************************************************************
23 */
24
25 #include "NXPSW_CompilerSwitches.h"
26
27 #include "M4OSA_Debug.h" /**< Include for OSAL debug services */
28 #include "M4VSS3GPP_ErrorCodes.h"
29 #include "M4VSS3GPP_InternalTypes.h" /**< Internal types of the VSS */
30
31 /**
32 ************************************************************************
33 * M4OSA_ERR M4VSS3GPP_clearInterfaceTables()
34 * @brief Clear encoders, decoders, reader and writers interfaces tables
35 * @param pContext (IN/OUT) VSS context.
36 * @return M4NO_ERROR: No error
37 * @return M4ERR_PARAMETER: The context is null
38 ************************************************************************
39 */
M4VSS3GPP_clearInterfaceTables(M4VSS3GPP_MediaAndCodecCtxt * pC)40 M4OSA_ERR M4VSS3GPP_clearInterfaceTables( M4VSS3GPP_MediaAndCodecCtxt *pC )
41 {
42 M4OSA_UInt8 i;
43
44 M4OSA_DEBUG_IF1((M4OSA_NULL == pC), M4ERR_PARAMETER,
45 "invalid context pointer");
46
47 /* Initialisation that will allow to check if registering twice */
48 pC->pWriterGlobalFcts = M4OSA_NULL;
49 pC->pWriterDataFcts = M4OSA_NULL;
50 pC->pVideoEncoderGlobalFcts = M4OSA_NULL;
51 pC->pAudioEncoderGlobalFcts = M4OSA_NULL;
52 pC->pCurrentAudioEncoderUserData = M4OSA_NULL;
53 pC->pCurrentAudioDecoderUserData = M4OSA_NULL;
54
55 pC->pCurrentVideoEncoderExternalAPI = M4OSA_NULL;
56 pC->pCurrentVideoEncoderUserData = M4OSA_NULL;
57
58 for ( i = 0; i < M4WRITER_kType_NB; i++ )
59 {
60 pC->WriterInterface[i].pGlobalFcts = M4OSA_NULL;
61 pC->WriterInterface[i].pDataFcts = M4OSA_NULL;
62 }
63
64 for ( i = 0; i < M4ENCODER_kVideo_NB; i++ )
65 {
66 pC->pVideoEncoderInterface[i] = M4OSA_NULL;
67 pC->pVideoEncoderExternalAPITable[i] = M4OSA_NULL;
68 pC->pVideoEncoderUserDataTable[i] = M4OSA_NULL;
69 }
70
71 for ( i = 0; i < M4ENCODER_kAudio_NB; i++ )
72 {
73 pC->pAudioEncoderInterface[i] = M4OSA_NULL;
74 pC->pAudioEncoderFlag[i] = M4OSA_FALSE;
75 pC->pAudioEncoderUserDataTable[i] = M4OSA_NULL;
76 }
77
78 /* Initialisation that will allow to check if registering twice */
79 pC->m_pReader = M4OSA_NULL;
80 pC->m_pReaderDataIt = M4OSA_NULL;
81 pC->m_uiNbRegisteredReaders = 0;
82
83 for ( i = 0; i < M4READER_kMediaType_NB; i++ )
84 {
85 pC->m_pReaderGlobalItTable[i] = M4OSA_NULL;
86 pC->m_pReaderDataItTable[i] = M4OSA_NULL;
87 }
88
89 pC->m_pVideoDecoder = M4OSA_NULL;
90 #ifdef M4VSS_ENABLE_EXTERNAL_DECODERS
91
92 pC->m_pCurrentVideoDecoderUserData = M4OSA_NULL;
93 #endif /* M4VSS_ENABLE_EXTERNAL_DECODERS */
94
95 pC->m_uiNbRegisteredVideoDec = 0;
96
97 for ( i = 0; i < M4DECODER_kVideoType_NB; i++ )
98 {
99 pC->m_pVideoDecoderItTable[i] = M4OSA_NULL;
100 #ifdef M4VSS_ENABLE_EXTERNAL_DECODERS
101
102 pC->m_pVideoDecoderUserDataTable[i] = M4OSA_NULL;
103
104 #endif /* M4VSS_ENABLE_EXTERNAL_DECODERS */
105
106 }
107
108 pC->m_pAudioDecoder = M4OSA_NULL;
109
110 for ( i = 0; i < M4AD_kType_NB; i++ )
111 {
112 pC->m_pAudioDecoderItTable[i] = M4OSA_NULL;
113 pC->m_pAudioDecoderFlagTable[i] = M4OSA_FALSE;
114 pC->pAudioDecoderUserDataTable[i] = M4OSA_NULL;
115 }
116
117 return M4NO_ERROR;
118 }
119
120 /**
121 ******************************************************************************
122 * M4OSA_ERR M4VSS3GPP_registerWriter()
123 * @brief This function will register a specific file format writer.
124 * @note According to the Mediatype, this function will store in the internal
125 * context the writer context.
126 * @param pContext: (IN) Execution context.
127 * @return M4NO_ERROR: there is no error
128 * @return M4ERR_PARAMETER pContext,pWtrGlobalInterface or pWtrDataInterface is M4OSA_NULL
129 * (debug only), or invalid MediaType
130 ******************************************************************************
131 */
M4VSS3GPP_registerWriter(M4VSS3GPP_MediaAndCodecCtxt * pC,M4WRITER_OutputFileType MediaType,M4WRITER_GlobalInterface * pWtrGlobalInterface,M4WRITER_DataInterface * pWtrDataInterface)132 M4OSA_ERR M4VSS3GPP_registerWriter( M4VSS3GPP_MediaAndCodecCtxt *pC,
133 M4WRITER_OutputFileType MediaType,
134 M4WRITER_GlobalInterface *pWtrGlobalInterface,
135 M4WRITER_DataInterface *pWtrDataInterface )
136 {
137 /**
138 * Check input parameters */
139 M4OSA_DEBUG_IF2((pC == M4OSA_NULL), M4ERR_PARAMETER,
140 "VSS: context is M4OSA_NULL in M4VSS3GPP_registerWriter");
141 M4OSA_DEBUG_IF2((pWtrGlobalInterface == M4OSA_NULL), M4ERR_PARAMETER,
142 "pWtrGlobalInterface is M4OSA_NULL in M4VSS3GPP_registerWriter");
143 M4OSA_DEBUG_IF2((pWtrDataInterface == M4OSA_NULL), M4ERR_PARAMETER,
144 "pWtrDataInterface is M4OSA_NULL in M4VSS3GPP_registerWriter");
145
146 M4OSA_TRACE3_3(
147 "VSS: M4VSS3GPP_registerWriter called with pContext=0x%x, pWtrGlobalInterface=0x%x,\
148 pWtrDataInterface=0x%x",
149 pC, pWtrGlobalInterface, pWtrDataInterface);
150
151 if( ( MediaType == M4WRITER_kUnknown) || (MediaType >= M4WRITER_kType_NB) )
152 {
153 M4OSA_DEBUG_IF1(M4OSA_TRUE, M4ERR_PARAMETER, "Invalid media type");
154 return M4ERR_PARAMETER;
155 }
156
157 if( pC->WriterInterface[MediaType].pGlobalFcts != M4OSA_NULL )
158 {
159 /* a writer corresponding to this media type has already been registered !*/
160 M4OSA_DEBUG_IF1(M4OSA_TRUE, M4ERR_PARAMETER,
161 "This media type has already been registered");
162 return M4ERR_PARAMETER;
163 }
164
165 /*
166 * Save writer interface in context */
167 pC->WriterInterface[MediaType].pGlobalFcts = pWtrGlobalInterface;
168 pC->WriterInterface[MediaType].pDataFcts = pWtrDataInterface;
169
170 return M4NO_ERROR;
171 }
172
173 /**
174 ******************************************************************************
175 * M4OSA_ERR M4VSS3GPP_registerVideoEncoder()
176 * @brief This function will register a specific video encoder.
177 * @note According to the Mediatype, this function will store in the internal
178 * context the encoder context.
179 * @param pContext: (IN) Execution context.
180 * @return M4NO_ERROR: there is no error
181 * @return M4ERR_PARAMETER pContext or pEncGlobalInterface is M4OSA_NULL (debug only),
182 * or invalid MediaType
183 ******************************************************************************
184 */
M4VSS3GPP_registerVideoEncoder(M4VSS3GPP_MediaAndCodecCtxt * pC,M4ENCODER_Format MediaType,M4ENCODER_GlobalInterface * pEncGlobalInterface)185 M4OSA_ERR M4VSS3GPP_registerVideoEncoder( M4VSS3GPP_MediaAndCodecCtxt *pC,
186 M4ENCODER_Format MediaType,
187 M4ENCODER_GlobalInterface *pEncGlobalInterface )
188 {
189 /**
190 * Check input parameters */
191 M4OSA_DEBUG_IF2((pC == M4OSA_NULL), M4ERR_PARAMETER,
192 "VSS: context is M4OSA_NULL in M4VSS3GPP_registerVideoEncoder");
193 M4OSA_DEBUG_IF2((pEncGlobalInterface == M4OSA_NULL), M4ERR_PARAMETER,
194 "pEncGlobalInterface is M4OSA_NULL in M4VSS3GPP_registerVideoEncoder");
195
196 M4OSA_TRACE3_3(
197 "VSS: M4VSS3GPP_registerEncoder called with pContext=0x%x, pEncGlobalInterface=0x%x,\
198 MediaType=0x%x",
199 pC, pEncGlobalInterface, MediaType);
200
201 if( MediaType >= M4ENCODER_kVideo_NB )
202 {
203 M4OSA_DEBUG_IF1(M4OSA_TRUE, M4ERR_PARAMETER,
204 "Invalid video encoder type");
205 return M4ERR_PARAMETER;
206 }
207
208 if( pC->pVideoEncoderInterface[MediaType] != M4OSA_NULL )
209 {
210 /* can be legitimate, in cases where we have one version that can use external encoders
211 but which still has the built-in one to be able to work without an external encoder; in
212 this case the new encoder simply replaces the old one (i.e. we unregister it first). */
213 #ifdef M4VSS_SUPPORT_OMX_CODECS
214
215 if( M4OSA_TRUE == pC->bAllowFreeingOMXCodecInterface )
216 {
217
218 #endif
219
220 free(pC->pVideoEncoderInterface[MediaType]);
221 #ifdef M4VSS_SUPPORT_OMX_CODECS
222
223 }
224
225 #endif
226
227 pC->pVideoEncoderInterface[MediaType] = M4OSA_NULL;
228 }
229
230 /*
231 * Save encoder interface in context */
232 pC->pVideoEncoderInterface[MediaType] = pEncGlobalInterface;
233 /* The actual userData and external API will be set by the registration function in the case
234 of an external encoder (add it as a parameter to this function in the long run?) */
235 pC->pVideoEncoderUserDataTable[MediaType] = M4OSA_NULL;
236 pC->pVideoEncoderExternalAPITable[MediaType] = M4OSA_NULL;
237
238 return M4NO_ERROR;
239 }
240
241 /**
242 ******************************************************************************
243 * M4OSA_ERR M4VSS3GPP_registerAudioEncoder()
244 * @brief This function will register a specific audio encoder.
245 * @note According to the Mediatype, this function will store in the internal
246 * context the encoder context.
247 * @param pContext: (IN) Execution context.
248 * @param mediaType: (IN) The media type.
249 * @param pEncGlobalInterface: (OUT) the encoder interface functions.
250 * @return M4NO_ERROR: there is no error
251 * @return M4ERR_PARAMETER: pContext or pEncGlobalInterface is M4OSA_NULL (debug only)
252 ******************************************************************************
253 */
M4VSS3GPP_registerAudioEncoder(M4VSS3GPP_MediaAndCodecCtxt * pC,M4ENCODER_AudioFormat MediaType,M4ENCODER_AudioGlobalInterface * pEncGlobalInterface)254 M4OSA_ERR M4VSS3GPP_registerAudioEncoder( M4VSS3GPP_MediaAndCodecCtxt *pC,
255 M4ENCODER_AudioFormat MediaType,
256 M4ENCODER_AudioGlobalInterface *pEncGlobalInterface )
257 {
258 /**
259 * Check input parameters */
260 M4OSA_DEBUG_IF2((pC == M4OSA_NULL), M4ERR_PARAMETER,
261 "VSS: context is M4OSA_NULL in M4VSS3GPP_registerAudioEncoder");
262 M4OSA_DEBUG_IF2((pEncGlobalInterface == M4OSA_NULL), M4ERR_PARAMETER,
263 "pEncGlobalInterface is M4OSA_NULL in M4VSS3GPP_registerAudioEncoder");
264
265 M4OSA_TRACE3_3(
266 "VSS: M4VSS3GPP_registerAudioEncoder called pContext=0x%x, pEncGlobalInterface=0x%x,\
267 MediaType=0x%x",
268 pC, pEncGlobalInterface, MediaType);
269
270 if( MediaType >= M4ENCODER_kAudio_NB )
271 {
272 M4OSA_DEBUG_IF1(M4OSA_TRUE, M4ERR_PARAMETER,
273 "Invalid audio encoder type");
274 return M4ERR_PARAMETER;
275 }
276
277 if( pC->pAudioEncoderInterface[MediaType] != M4OSA_NULL )
278 {
279 free(pC->pAudioEncoderInterface[MediaType]);
280 pC->pAudioEncoderInterface[MediaType] = M4OSA_NULL;
281 }
282 /*
283 * Save encoder interface in context */
284 pC->pAudioEncoderInterface[MediaType] = pEncGlobalInterface;
285 pC->pAudioEncoderFlag[MediaType] = M4OSA_FALSE; /* internal encoder */
286 pC->pAudioEncoderUserDataTable[MediaType] = M4OSA_NULL;
287
288 M4OSA_TRACE3_2(
289 "M4VSS3GPP_registerAudioEncoder: pC->pAudioEncoderInterface[0x%x] = 0x%x",
290 MediaType, pC->pAudioEncoderInterface[MediaType]);
291
292 return M4NO_ERROR;
293 }
294
295 /**
296 ************************************************************************
297 * M4OSA_ERR M4VSS3GPP_registerReader()
298 * @brief Register reader.
299 * @param pContext (IN/OUT) VSS context.
300 * @return M4NO_ERROR: No error
301 * @return M4ERR_PARAMETER: A parameter is null (in DEBUG only)
302 ************************************************************************
303 */
M4VSS3GPP_registerReader(M4VSS3GPP_MediaAndCodecCtxt * pC,M4READER_MediaType mediaType,M4READER_GlobalInterface * pRdrGlobalInterface,M4READER_DataInterface * pRdrDataInterface)304 M4OSA_ERR M4VSS3GPP_registerReader( M4VSS3GPP_MediaAndCodecCtxt *pC,
305 M4READER_MediaType mediaType,
306 M4READER_GlobalInterface *pRdrGlobalInterface,
307 M4READER_DataInterface *pRdrDataInterface )
308 {
309 M4OSA_DEBUG_IF1((M4OSA_NULL == pC), M4ERR_PARAMETER,
310 "invalid context pointer");
311 M4OSA_DEBUG_IF1((M4OSA_NULL == pRdrGlobalInterface), M4ERR_PARAMETER,
312 "M4VSS3GPP_registerReader: invalid pointer on global interface");
313 M4OSA_DEBUG_IF1((M4OSA_NULL == pRdrDataInterface), M4ERR_PARAMETER,
314 "M4VSS3GPP_registerReader: invalid pointer on data interface");
315
316 if( mediaType == M4READER_kMediaTypeUnknown
317 || mediaType >= M4READER_kMediaType_NB )
318 {
319 M4OSA_DEBUG_IF1(M4OSA_TRUE, M4ERR_PARAMETER, "Invalid media type");
320 return M4ERR_PARAMETER;
321 }
322
323 if( pC->m_pReaderGlobalItTable[mediaType] != M4OSA_NULL )
324 {
325 /* a reader corresponding to this media type has already been registered !*/
326 M4OSA_DEBUG_IF1(M4OSA_TRUE, M4ERR_PARAMETER,
327 "This media type has already been registered");
328 return M4ERR_PARAMETER;
329 }
330
331 pC->m_pReaderGlobalItTable[mediaType] = pRdrGlobalInterface;
332 pC->m_pReaderDataItTable[mediaType] = pRdrDataInterface;
333
334 pC->m_uiNbRegisteredReaders++;
335
336 return M4NO_ERROR;
337 }
338
339 /**
340 ************************************************************************
341 * M4OSA_ERR M4VSS3GPP_registerVideoDecoder()
342 * @brief Register video decoder
343 * @param pContext (IN/OUT) VSS context.
344 * @param decoderType (IN) Decoder type
345 * @param pDecoderInterface (IN) Decoder interface.
346 * @return M4NO_ERROR: No error
347 * @return M4ERR_PARAMETER: A parameter is null (in DEBUG only),
348 * or the decoder type is invalid
349 ************************************************************************
350 */
M4VSS3GPP_registerVideoDecoder(M4VSS3GPP_MediaAndCodecCtxt * pC,M4DECODER_VideoType decoderType,M4DECODER_VideoInterface * pDecoderInterface)351 M4OSA_ERR M4VSS3GPP_registerVideoDecoder( M4VSS3GPP_MediaAndCodecCtxt *pC,
352 M4DECODER_VideoType decoderType,
353 M4DECODER_VideoInterface *pDecoderInterface )
354 {
355 M4OSA_DEBUG_IF1((M4OSA_NULL == pC), M4ERR_PARAMETER,
356 "invalid context pointer");
357 M4OSA_DEBUG_IF1((M4OSA_NULL == pDecoderInterface), M4ERR_PARAMETER,
358 "M4VSS3GPP_registerVideoDecoder: invalid pointer on decoder interface");
359
360 if( decoderType >= M4DECODER_kVideoType_NB )
361 {
362 M4OSA_DEBUG_IF1(M4OSA_TRUE, M4ERR_PARAMETER,
363 "Invalid video decoder type");
364 return M4ERR_PARAMETER;
365 }
366
367 if( pC->m_pVideoDecoderItTable[decoderType] != M4OSA_NULL )
368 {
369 #ifndef M4VSS_ENABLE_EXTERNAL_DECODERS
370 /* a decoder corresponding to this media type has already been registered !*/
371
372 M4OSA_DEBUG_IF1(M4OSA_TRUE, M4ERR_PARAMETER,
373 "Decoder has already been registered");
374 return M4ERR_PARAMETER;
375
376 #else /* external decoders are possible */
377 /* can be legitimate, in cases where we have one version that can use external decoders
378 but which still has the built-in one to be able to work without an external decoder; in
379 this case the new decoder simply replaces the old one (i.e. we unregister it first). */
380 #ifdef M4VSS_SUPPORT_OMX_CODECS
381
382 if( M4OSA_TRUE == pC->bAllowFreeingOMXCodecInterface )
383 {
384
385 #endif
386
387 free(pC->m_pVideoDecoderItTable[decoderType]);
388 #ifdef M4VSS_SUPPORT_OMX_CODECS
389
390 }
391
392 #endif
393
394 pC->m_pVideoDecoderItTable[decoderType] = M4OSA_NULL;
395 /* oh, and don't forget the user data, too. */
396 if( pC->m_pVideoDecoderUserDataTable[decoderType] != M4OSA_NULL )
397 {
398 free(pC->m_pVideoDecoderUserDataTable[decoderType]);
399 pC->m_pVideoDecoderUserDataTable[decoderType] = M4OSA_NULL;
400 }
401 #endif /* are external decoders possible? */
402
403 }
404
405 pC->m_pVideoDecoderItTable[decoderType] = pDecoderInterface;
406 #ifdef M4VSS_ENABLE_EXTERNAL_DECODERS
407
408 pC->m_pVideoDecoderUserDataTable[decoderType] = M4OSA_NULL;
409 /* The actual userData will be set by the registration function in the case
410 of an external decoder (add it as a parameter to this function in the long run?) */
411
412 #endif /* M4VSS_ENABLE_EXTERNAL_DECODERS */
413
414 pC->m_uiNbRegisteredVideoDec++;
415
416 return M4NO_ERROR;
417 }
418
419 /**
420 ************************************************************************
421 * M4OSA_ERR M4VSS3GPP_registerAudioDecoder()
422 * @brief Register audio decoder
423 * @note This function is used internaly by the VSS to register NXP audio decoders,
424 * @param context (IN/OUT) VSS context.
425 * @param decoderType (IN) Audio decoder type
426 * @param pDecoderInterface (IN) Audio decoder interface.
427 * @return M4NO_ERROR: No error
428 * @return M4ERR_PARAMETER: A parameter is null, or the decoder type is invalid(in DEBUG only)
429 ************************************************************************
430 */
M4VSS3GPP_registerAudioDecoder(M4VSS3GPP_MediaAndCodecCtxt * pC,M4AD_Type decoderType,M4AD_Interface * pDecoderInterface)431 M4OSA_ERR M4VSS3GPP_registerAudioDecoder( M4VSS3GPP_MediaAndCodecCtxt *pC,
432 M4AD_Type decoderType, M4AD_Interface *pDecoderInterface)
433 {
434 M4OSA_DEBUG_IF1((M4OSA_NULL == pC), M4ERR_PARAMETER,
435 "invalid context pointer");
436 M4OSA_DEBUG_IF1((M4OSA_NULL == pDecoderInterface), M4ERR_PARAMETER,
437 "M4VSS3GPP_registerAudioDecoder: invalid pointer on decoder interface");
438
439 if( decoderType >= M4AD_kType_NB )
440 {
441 M4OSA_DEBUG_IF1(M4OSA_TRUE, M4ERR_PARAMETER,
442 "Invalid audio decoder type");
443 return M4ERR_PARAMETER;
444 }
445 if(M4OSA_NULL != pC->m_pAudioDecoderItTable[decoderType])
446 {
447 free(pC->m_pAudioDecoderItTable[decoderType]);
448 pC->m_pAudioDecoderItTable[decoderType] = M4OSA_NULL;
449
450 if(M4OSA_NULL != pC->m_pAudioDecoderItTable[decoderType])
451 {
452 free(pC->m_pAudioDecoderItTable[decoderType]);
453 pC->m_pAudioDecoderItTable[decoderType] = M4OSA_NULL;
454 }
455 }
456
457
458
459 pC->m_pAudioDecoderItTable[decoderType] = pDecoderInterface;
460 pC->m_pAudioDecoderFlagTable[decoderType] =
461 M4OSA_FALSE; /* internal decoder */
462 pC->pAudioDecoderUserDataTable[decoderType] = M4OSA_NULL;
463
464 return M4NO_ERROR;
465 }
466
467 /**
468 ************************************************************************
469 * M4OSA_ERR M4VSS3GPP_unRegisterAllWriters()
470 * @brief Unregister writer
471 * @param pContext (IN/OUT) VSS context.
472 * @return M4NO_ERROR: No error
473 * @return M4ERR_PARAMETER: A parameter is null (in DEBUG only)
474 ************************************************************************
475 */
M4VSS3GPP_unRegisterAllWriters(M4VSS3GPP_MediaAndCodecCtxt * pC)476 M4OSA_ERR M4VSS3GPP_unRegisterAllWriters( M4VSS3GPP_MediaAndCodecCtxt *pC )
477 {
478 M4OSA_Int32 i;
479
480 M4OSA_DEBUG_IF1((M4OSA_NULL == pC), M4ERR_PARAMETER,
481 "invalid context pointer");
482
483 for ( i = 0; i < M4WRITER_kType_NB; i++ )
484 {
485 if( pC->WriterInterface[i].pGlobalFcts != M4OSA_NULL )
486 {
487 free(pC->WriterInterface[i].pGlobalFcts);
488 pC->WriterInterface[i].pGlobalFcts = M4OSA_NULL;
489 }
490
491 if( pC->WriterInterface[i].pDataFcts != M4OSA_NULL )
492 {
493 free(pC->WriterInterface[i].pDataFcts);
494 pC->WriterInterface[i].pDataFcts = M4OSA_NULL;
495 }
496 }
497
498 pC->pWriterGlobalFcts = M4OSA_NULL;
499 pC->pWriterDataFcts = M4OSA_NULL;
500
501 return M4NO_ERROR;
502 }
503
504 /**
505 ************************************************************************
506 * M4OSA_ERR M4VSS3GPP_unRegisterAllEncoders()
507 * @brief Unregister the encoders
508 * @param pContext (IN/OUT) VSS context.
509 * @return M4NO_ERROR: No error
510 * @return M4ERR_PARAMETER: A parameter is null (in DEBUG only)
511 ************************************************************************
512 */
M4VSS3GPP_unRegisterAllEncoders(M4VSS3GPP_MediaAndCodecCtxt * pC)513 M4OSA_ERR M4VSS3GPP_unRegisterAllEncoders( M4VSS3GPP_MediaAndCodecCtxt *pC )
514 {
515 M4OSA_Int32 i;
516
517 M4OSA_DEBUG_IF1((M4OSA_NULL == pC), M4ERR_PARAMETER,
518 "invalid context pointer");
519 M4OSA_TRACE3_1("M4VSS3GPP_unRegisterAllEncoders: pC=0x%x", pC);
520
521 for ( i = 0; i < M4ENCODER_kVideo_NB; i++ )
522 {
523 if( pC->pVideoEncoderInterface[i] != M4OSA_NULL )
524 {
525 #ifdef M4VSS_SUPPORT_OMX_CODECS
526
527 if( M4OSA_TRUE == pC->bAllowFreeingOMXCodecInterface )
528 {
529
530 #endif
531
532 free(pC->pVideoEncoderInterface[i]);
533 #ifdef M4VSS_SUPPORT_OMX_CODECS
534
535 }
536
537 #endif
538
539 pC->pVideoEncoderInterface[i] = M4OSA_NULL;
540 }
541 }
542
543 for ( i = 0; i < M4ENCODER_kAudio_NB; i++ )
544 {
545 if( pC->pAudioEncoderInterface[i] != M4OSA_NULL )
546 {
547 #ifdef M4VSS_SUPPORT_OMX_CODECS
548
549 if( M4OSA_TRUE == pC->bAllowFreeingOMXCodecInterface )
550 {
551
552 #endif
553 /*Don't free external audio encoders interfaces*/
554
555 if( M4OSA_FALSE == pC->pAudioEncoderFlag[i] )
556 {
557 free(pC->pAudioEncoderInterface[i]);
558 }
559 #ifdef M4VSS_SUPPORT_OMX_CODECS
560
561 }
562
563 #endif
564
565 pC->pAudioEncoderInterface[i] = M4OSA_NULL;
566 }
567 }
568
569 pC->pVideoEncoderGlobalFcts = M4OSA_NULL;
570 pC->pAudioEncoderGlobalFcts = M4OSA_NULL;
571
572 return M4NO_ERROR;
573 }
574
575 /**
576 ************************************************************************
577 * M4OSA_ERR M4VSS3GPP_unRegisterAllReaders()
578 * @brief Unregister reader
579 * @param pContext (IN/OUT) VSS context.
580 * @return M4NO_ERROR: No error
581 * @return M4ERR_PARAMETER: A parameter is null (in DEBUG only)
582 ************************************************************************
583 */
M4VSS3GPP_unRegisterAllReaders(M4VSS3GPP_MediaAndCodecCtxt * pC)584 M4OSA_ERR M4VSS3GPP_unRegisterAllReaders( M4VSS3GPP_MediaAndCodecCtxt *pC )
585 {
586 M4OSA_Int32 i;
587
588 M4OSA_DEBUG_IF1((M4OSA_NULL == pC), M4ERR_PARAMETER,
589 "invalid context pointer");
590
591 for ( i = 0; i < M4READER_kMediaType_NB; i++ )
592 {
593 if( pC->m_pReaderGlobalItTable[i] != M4OSA_NULL )
594 {
595 free(pC->m_pReaderGlobalItTable[i]);
596 pC->m_pReaderGlobalItTable[i] = M4OSA_NULL;
597 }
598
599 if( pC->m_pReaderDataItTable[i] != M4OSA_NULL )
600 {
601 free(pC->m_pReaderDataItTable[i]);
602 pC->m_pReaderDataItTable[i] = M4OSA_NULL;
603 }
604 }
605
606 pC->m_uiNbRegisteredReaders = 0;
607 pC->m_pReader = M4OSA_NULL;
608 pC->m_pReaderDataIt = M4OSA_NULL;
609
610 return M4NO_ERROR;
611 }
612
613 /**
614 ************************************************************************
615 * M4OSA_ERR M4VSS3GPP_unRegisterAllDecoders()
616 * @brief Unregister the decoders
617 * @param pContext (IN/OUT) VSS context.
618 * @return M4NO_ERROR: No error
619 * @return M4ERR_PARAMETER: A parameter is null (in DEBUG only)
620 ************************************************************************
621 */
M4VSS3GPP_unRegisterAllDecoders(M4VSS3GPP_MediaAndCodecCtxt * pC)622 M4OSA_ERR M4VSS3GPP_unRegisterAllDecoders( M4VSS3GPP_MediaAndCodecCtxt *pC )
623 {
624 M4OSA_Int32 i;
625
626 M4OSA_DEBUG_IF1((M4OSA_NULL == pC), M4ERR_PARAMETER,
627 "invalid context pointer");
628 M4OSA_TRACE3_1("M4VSS3GPP_unRegisterAllDecoders: pC=0x%x", pC);
629
630 for ( i = 0; i < M4DECODER_kVideoType_NB; i++ )
631 {
632 if( pC->m_pVideoDecoderItTable[i] != M4OSA_NULL )
633 {
634 #ifdef M4VSS_SUPPORT_OMX_CODECS
635
636 if( M4OSA_TRUE == pC->bAllowFreeingOMXCodecInterface )
637 {
638
639 #endif
640
641 free(pC->m_pVideoDecoderItTable[i]);
642 #ifdef M4VSS_SUPPORT_OMX_CODECS
643
644 }
645
646 #endif
647
648 pC->m_pVideoDecoderItTable[i] = M4OSA_NULL;
649
650 }
651 }
652
653 for ( i = 0; i < M4AD_kType_NB; i++ )
654 {
655 if( pC->m_pAudioDecoderItTable[i] != M4OSA_NULL )
656 {
657 #ifdef M4VSS_SUPPORT_OMX_CODECS
658
659 if( M4OSA_TRUE == pC->bAllowFreeingOMXCodecInterface )
660 {
661
662 #endif
663 /*Don't free external audio decoders interfaces*/
664
665 if( M4OSA_FALSE == pC->m_pAudioDecoderFlagTable[i] )
666 {
667 free(pC->m_pAudioDecoderItTable[i]);
668 }
669 #ifdef M4VSS_SUPPORT_OMX_CODECS
670
671 }
672
673 #endif
674
675 pC->m_pAudioDecoderItTable[i] = M4OSA_NULL;
676 }
677 }
678
679 pC->m_uiNbRegisteredVideoDec = 0;
680 pC->m_pVideoDecoder = M4OSA_NULL;
681
682 pC->m_pAudioDecoder = M4OSA_NULL;
683
684 return M4NO_ERROR;
685 }
686
687 /**
688 ************************************************************************
689 * M4OSA_ERR M4VSS3GPP_setCurrentWriter()
690 * @brief Set current writer
691 * @param pContext (IN/OUT) VSS context.
692 * @param mediaType (IN) Media type.
693 * @return M4NO_ERROR: No error
694 * @return M4ERR_PARAMETER: A parameter is null (in DEBUG only)
695 * @return M4WAR_VSS_MEDIATYPE_NOT_SUPPORTED: Media type not supported
696 ************************************************************************
697 */
M4VSS3GPP_setCurrentWriter(M4VSS3GPP_MediaAndCodecCtxt * pC,M4VIDEOEDITING_FileType mediaType)698 M4OSA_ERR M4VSS3GPP_setCurrentWriter( M4VSS3GPP_MediaAndCodecCtxt *pC,
699 M4VIDEOEDITING_FileType mediaType )
700 {
701 M4WRITER_OutputFileType writerType;
702
703 M4OSA_DEBUG_IF1((M4OSA_NULL == pC), M4ERR_PARAMETER,
704 "invalid context pointer");
705
706 switch( mediaType )
707 {
708 case M4VIDEOEDITING_kFileType_3GPP:
709 writerType = M4WRITER_k3GPP;
710 break;
711 default:
712 M4OSA_DEBUG_IF1(M4OSA_TRUE, M4VSS3GPP_ERR_INVALID_FILE_TYPE,
713 "Writer type not supported");
714 return M4VSS3GPP_ERR_INVALID_FILE_TYPE;
715 }
716
717 pC->pWriterGlobalFcts = pC->WriterInterface[writerType].pGlobalFcts;
718 pC->pWriterDataFcts = pC->WriterInterface[writerType].pDataFcts;
719
720 if( pC->pWriterGlobalFcts == M4OSA_NULL
721 || pC->pWriterDataFcts == M4OSA_NULL )
722 {
723 M4OSA_DEBUG_IF1(M4OSA_TRUE, M4VSS3GPP_ERR_INVALID_FILE_TYPE,
724 "Writer type not supported");
725 M4OSA_TRACE1_0("Writer type not supported");
726 return M4VSS3GPP_ERR_INVALID_FILE_TYPE;
727 }
728
729 pC->pWriterDataFcts->pWriterContext = M4OSA_NULL;
730
731 return M4NO_ERROR;
732 }
733
734 /**
735 ************************************************************************
736 * M4OSA_ERR M4VSS3GPP_setCurrentVideoEncoder()
737 * @brief Set a video encoder
738 * @param pContext (IN/OUT) VSS context.
739 * @param MediaType (IN) Encoder type
740 * @return M4NO_ERROR: No error
741 * @return M4ERR_PARAMETER: A parameter is null (in DEBUG only)
742 * @return M4WAR_VSS_MEDIATYPE_NOT_SUPPORTED: Media type not supported
743 ************************************************************************
744 */
M4VSS3GPP_setCurrentVideoEncoder(M4VSS3GPP_MediaAndCodecCtxt * pC,M4SYS_StreamType mediaType)745 M4OSA_ERR M4VSS3GPP_setCurrentVideoEncoder( M4VSS3GPP_MediaAndCodecCtxt *pC,
746 M4SYS_StreamType mediaType )
747 {
748 M4ENCODER_Format encoderType;
749
750 M4OSA_DEBUG_IF1((M4OSA_NULL == pC), M4ERR_PARAMETER,
751 "invalid context pointer");
752 M4OSA_TRACE3_2("M4VSS3GPP_setCurrentVideoEncoder: pC=0x%x, mediaType=0x%x",
753 pC, mediaType);
754
755 switch( mediaType )
756 {
757 case M4SYS_kH263:
758 encoderType = M4ENCODER_kH263;
759 break;
760
761 case M4SYS_kMPEG_4:
762 encoderType = M4ENCODER_kMPEG4;
763 break;
764
765 case M4SYS_kH264:
766 encoderType = M4ENCODER_kH264;
767 break;
768
769 default:
770 M4OSA_DEBUG_IF1(M4OSA_TRUE,
771 M4VSS3GPP_ERR_EDITING_UNSUPPORTED_VIDEO_FORMAT,
772 "Video encoder type not supported");
773 return M4VSS3GPP_ERR_EDITING_UNSUPPORTED_VIDEO_FORMAT;
774 }
775
776 pC->pVideoEncoderGlobalFcts = pC->pVideoEncoderInterface[encoderType];
777 pC->pCurrentVideoEncoderExternalAPI =
778 pC->pVideoEncoderExternalAPITable[encoderType];
779 pC->pCurrentVideoEncoderUserData =
780 pC->pVideoEncoderUserDataTable[encoderType];
781
782 if( pC->pVideoEncoderGlobalFcts == M4OSA_NULL )
783 {
784 M4OSA_DEBUG_IF1(M4OSA_TRUE,
785 M4VSS3GPP_ERR_EDITING_UNSUPPORTED_VIDEO_FORMAT,
786 "Video encoder type not supported");
787 M4OSA_TRACE1_0("Video encoder type not supported");
788 return M4VSS3GPP_ERR_EDITING_UNSUPPORTED_VIDEO_FORMAT;
789 }
790
791 return M4NO_ERROR;
792 }
793
794 /**
795 ************************************************************************
796 * M4OSA_ERR M4VSS3GPP_setCurrentAudioEncoder()
797 * @brief Set an audio encoder
798 * @param context (IN/OUT) VSS context.
799 * @param MediaType (IN) Encoder type
800 * @return M4NO_ERROR: No error
801 * @return M4ERR_PARAMETER: A parameter is null (in DEBUG only)
802 ************************************************************************
803 */
M4VSS3GPP_setCurrentAudioEncoder(M4VSS3GPP_MediaAndCodecCtxt * pC,M4SYS_StreamType mediaType)804 M4OSA_ERR M4VSS3GPP_setCurrentAudioEncoder( M4VSS3GPP_MediaAndCodecCtxt *pC,
805 M4SYS_StreamType mediaType )
806 {
807 M4ENCODER_AudioFormat encoderType;
808
809 M4OSA_DEBUG_IF1((M4OSA_NULL == pC), M4ERR_PARAMETER,
810 "invalid context pointer");
811 M4OSA_TRACE3_2("M4VSS3GPP_setCurrentAudioEncoder: pC=0x%x, mediaType=0x%x",
812 pC, mediaType);
813
814 switch( mediaType )
815 {
816 case M4SYS_kAMR:
817 M4OSA_TRACE3_0(
818 "M4VSS3GPP_setCurrentAudioEncoder: encoder type AMR");
819 encoderType = M4ENCODER_kAMRNB;
820 break;
821
822 case M4SYS_kAAC:
823 M4OSA_TRACE3_0(
824 "M4VSS3GPP_setCurrentAudioEncoder: encoder type AAC");
825 encoderType = M4ENCODER_kAAC;
826 break;
827
828 default:
829 M4OSA_DEBUG_IF1(M4OSA_TRUE,
830 M4VSS3GPP_ERR_EDITING_UNSUPPORTED_AUDIO_FORMAT,
831 "Audio encoder type not supported");
832 return M4VSS3GPP_ERR_EDITING_UNSUPPORTED_AUDIO_FORMAT;
833 }
834
835 pC->pAudioEncoderGlobalFcts = pC->pAudioEncoderInterface[encoderType];
836 pC->pCurrentAudioEncoderUserData =
837 pC->pAudioEncoderUserDataTable[encoderType];
838
839 M4OSA_TRACE3_3(
840 "M4VSS3GPP_setCurrentAudioEncoder: pC->pAudioEncoderInterface[0x%x]=0x%x,\
841 pC->pAudioEncoderGlobalFcts = 0x%x",
842 encoderType, pC->pAudioEncoderInterface[encoderType],
843 pC->pAudioEncoderGlobalFcts);
844
845 if( pC->pAudioEncoderGlobalFcts == M4OSA_NULL )
846 {
847 M4OSA_DEBUG_IF1(M4OSA_TRUE,
848 M4VSS3GPP_ERR_EDITING_UNSUPPORTED_AUDIO_FORMAT,
849 "Audio encoder type not supported");
850 M4OSA_TRACE1_0("Audio encoder type not supported");
851 return M4VSS3GPP_ERR_EDITING_UNSUPPORTED_AUDIO_FORMAT;
852 }
853
854 return M4NO_ERROR;
855 }
856
857 /**
858 ************************************************************************
859 * M4OSA_ERR M4VSS3GPP_setCurrentReader()
860 * @brief Set current reader
861 * @param pContext (IN/OUT) VSS context.
862 * @param mediaType (IN) Media type.
863 * @return M4NO_ERROR: No error
864 * @return M4ERR_PARAMETER: A parameter is null (in DEBUG only)
865 * @return M4WAR_VSS_MEDIATYPE_NOT_SUPPORTED: Media type not supported
866 ************************************************************************
867 */
M4VSS3GPP_setCurrentReader(M4VSS3GPP_MediaAndCodecCtxt * pC,M4VIDEOEDITING_FileType mediaType)868 M4OSA_ERR M4VSS3GPP_setCurrentReader( M4VSS3GPP_MediaAndCodecCtxt *pC,
869 M4VIDEOEDITING_FileType mediaType )
870 {
871 M4READER_MediaType readerType;
872
873 M4OSA_DEBUG_IF1((M4OSA_NULL == pC), M4ERR_PARAMETER,
874 "invalid context pointer");
875
876 switch( mediaType )
877 {
878 case M4VIDEOEDITING_kFileType_3GPP:
879 case M4VIDEOEDITING_kFileType_MP4:
880 case M4VIDEOEDITING_kFileType_M4V:
881 readerType = M4READER_kMediaType3GPP;
882 break;
883
884 case M4VIDEOEDITING_kFileType_AMR:
885 readerType = M4READER_kMediaTypeAMR;
886 break;
887
888 case M4VIDEOEDITING_kFileType_MP3:
889 readerType = M4READER_kMediaTypeMP3;
890 break;
891
892 case M4VIDEOEDITING_kFileType_PCM:
893 readerType = M4READER_kMediaTypePCM;
894 break;
895
896 default:
897 M4OSA_DEBUG_IF1(M4OSA_TRUE, M4VSS3GPP_ERR_INVALID_FILE_TYPE,
898 "Reader type not supported");
899 return M4VSS3GPP_ERR_INVALID_FILE_TYPE;
900 }
901
902 pC->m_pReader = pC->m_pReaderGlobalItTable[readerType];
903 pC->m_pReaderDataIt = pC->m_pReaderDataItTable[readerType];
904
905 if( pC->m_pReader == M4OSA_NULL || pC->m_pReaderDataIt == M4OSA_NULL )
906 {
907 M4OSA_DEBUG_IF1(M4OSA_TRUE, M4VSS3GPP_ERR_INVALID_FILE_TYPE,
908 "Reader type not supported");
909 M4OSA_TRACE1_0("Reader type not supported");
910 return M4VSS3GPP_ERR_INVALID_FILE_TYPE;
911 }
912 return M4NO_ERROR;
913 }
914
915 /**
916 ************************************************************************
917 * M4OSA_ERR M4VSS3GPP_setCurrentVideoDecoder()
918 * @brief Set a video decoder
919 * @param pContext (IN/OUT) VSS context.
920 * @param decoderType (IN) Decoder type
921 * @return M4NO_ERROR: No error
922 * @return M4ERR_PARAMETER: A parameter is null (in DEBUG only)
923 * @return M4WAR_VSS_MEDIATYPE_NOT_SUPPORTED: Media type not supported
924 ************************************************************************
925 */
M4VSS3GPP_setCurrentVideoDecoder(M4VSS3GPP_MediaAndCodecCtxt * pC,M4_StreamType mediaType)926 M4OSA_ERR M4VSS3GPP_setCurrentVideoDecoder( M4VSS3GPP_MediaAndCodecCtxt *pC,
927 M4_StreamType mediaType )
928 {
929 M4DECODER_VideoType decoderType;
930
931 M4OSA_DEBUG_IF1((M4OSA_NULL == pC), M4ERR_PARAMETER,
932 "invalid context pointer");
933 M4OSA_TRACE3_2("M4VSS3GPP_setCurrentVideoDecoder: pC=0x%x, mediaType=0x%x",
934 pC, mediaType);
935
936 switch( mediaType )
937 {
938 case M4DA_StreamTypeVideoMpeg4:
939 case M4DA_StreamTypeVideoH263:
940 decoderType = M4DECODER_kVideoTypeMPEG4;
941 break;
942
943 case M4DA_StreamTypeVideoMpeg4Avc:
944 decoderType = M4DECODER_kVideoTypeAVC;
945 break;
946 case M4DA_StreamTypeVideoARGB8888:
947 decoderType = M4DECODER_kVideoTypeYUV420P;
948 break;
949 default:
950 M4OSA_DEBUG_IF1(M4OSA_TRUE,
951 M4VSS3GPP_ERR_UNSUPPORTED_INPUT_VIDEO_FORMAT,
952 "Video decoder type not supported");
953 return M4VSS3GPP_ERR_UNSUPPORTED_INPUT_VIDEO_FORMAT;
954 }
955
956 pC->m_pVideoDecoder = pC->m_pVideoDecoderItTable[decoderType];
957 #ifdef M4VSS_ENABLE_EXTERNAL_DECODERS
958
959 pC->m_pCurrentVideoDecoderUserData =
960 pC->m_pVideoDecoderUserDataTable[decoderType];
961
962 #endif /* M4VSS_ENABLE_EXTERNAL_DECODERS */
963
964 if( pC->m_pVideoDecoder == M4OSA_NULL )
965 {
966 M4OSA_DEBUG_IF1(M4OSA_TRUE,
967 M4VSS3GPP_ERR_UNSUPPORTED_INPUT_VIDEO_FORMAT,
968 "Video decoder type not supported");
969 M4OSA_TRACE1_0("Video decoder type not supported");
970 return M4VSS3GPP_ERR_UNSUPPORTED_INPUT_VIDEO_FORMAT;
971 }
972
973 return M4NO_ERROR;
974 }
975
976 /**
977 ************************************************************************
978 * M4OSA_ERR M4VSS3GPP_setCurrentAudioDecoder()
979 * @brief Set an audio decoder
980 * @param context (IN/OUT) VSS context.
981 * @param decoderType (IN) Decoder type
982 * @return M4NO_ERROR: No error
983 * @return M4ERR_PARAMETER: A parameter is null (in DEBUG only)
984 ************************************************************************
985 */
M4VSS3GPP_setCurrentAudioDecoder(M4VSS3GPP_MediaAndCodecCtxt * pC,M4_StreamType mediaType)986 M4OSA_ERR M4VSS3GPP_setCurrentAudioDecoder( M4VSS3GPP_MediaAndCodecCtxt *pC,
987 M4_StreamType mediaType )
988 {
989 M4AD_Type decoderType;
990
991 M4OSA_DEBUG_IF1((M4OSA_NULL == pC), M4ERR_PARAMETER,
992 "invalid context pointer");
993 M4OSA_TRACE3_2("M4VSS3GPP_setCurrentAudioDecoder: pC=0x%x, mediaType=0x%x",
994 pC, mediaType);
995
996 switch( mediaType )
997 {
998 case M4DA_StreamTypeAudioAmrNarrowBand:
999 decoderType = M4AD_kTypeAMRNB;
1000 break;
1001
1002 case M4DA_StreamTypeAudioAac:
1003 case M4DA_StreamTypeAudioAacADTS:
1004 case M4DA_StreamTypeAudioAacADIF:
1005 decoderType = M4AD_kTypeAAC;
1006 break;
1007
1008 case M4DA_StreamTypeAudioMp3:
1009 decoderType = M4AD_kTypeMP3;
1010 break;
1011
1012 case M4DA_StreamTypeAudioPcm:
1013 decoderType = M4AD_kTypePCM;
1014 break;
1015
1016 default:
1017 M4OSA_DEBUG_IF1(M4OSA_TRUE,
1018 M4VSS3GPP_ERR_UNSUPPORTED_INPUT_AUDIO_FORMAT,
1019 "Audio decoder type not supported");
1020 return M4VSS3GPP_ERR_UNSUPPORTED_INPUT_AUDIO_FORMAT;
1021 }
1022
1023 pC->m_pAudioDecoder = pC->m_pAudioDecoderItTable[decoderType];
1024 pC->pCurrentAudioDecoderUserData =
1025 pC->pAudioDecoderUserDataTable[decoderType];
1026
1027 if( pC->m_pAudioDecoder == M4OSA_NULL )
1028 {
1029 M4OSA_DEBUG_IF1(M4OSA_TRUE,
1030 M4VSS3GPP_ERR_UNSUPPORTED_INPUT_AUDIO_FORMAT,
1031 "Audio decoder type not supported");
1032 M4OSA_TRACE1_0("Audio decoder type not supported");
1033 return M4VSS3GPP_ERR_UNSUPPORTED_INPUT_AUDIO_FORMAT;
1034 }
1035
1036 return M4NO_ERROR;
1037 }
1038