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 M4MCS_Codecs.c
19 * @brief MCS implementation
20 * @note This file contains all functions related to audio/video
21 * codec manipulations.
22 ************************************************************************
23 */
24
25 /**
26 ********************************************************************
27 * Includes
28 ********************************************************************
29 */
30 #include "NXPSW_CompilerSwitches.h"
31 #include "M4OSA_Debug.h" /* Include for OSAL debug services */
32 #include "M4MCS_InternalTypes.h" /* Internal types of the MCS */
33
34
35 #ifdef M4MCS_SUPPORT_VIDEC_3GP
36 #include "M4_MPEG4VI_VideoHandler.h" /*needed for renderer error codes*/
37 #endif
38
39
40 /**
41 ************************************************************************
42 * M4OSA_ERR M4MCS_clearInterfaceTables()
43 * @brief Clear encoders, decoders, reader and writers interfaces tables
44 * @param pContext (IN/OUT) MCS context.
45 * @return M4NO_ERROR: No error
46 * @return M4ERR_PARAMETER: The context is null
47 ************************************************************************
48 */
M4MCS_clearInterfaceTables(M4MCS_Context pContext)49 M4OSA_ERR M4MCS_clearInterfaceTables(M4MCS_Context pContext)
50 {
51 M4MCS_InternalContext* pC = (M4MCS_InternalContext*)pContext;
52 M4OSA_UInt8 i;
53
54 M4OSA_DEBUG_IF1((M4OSA_NULL == pC), M4ERR_PARAMETER, "invalid context pointer");
55
56 /* Initialisation that will allow to check if registering twice */
57 pC->pWriterGlobalFcts = M4OSA_NULL;
58 pC->pWriterDataFcts = M4OSA_NULL;
59 pC->pVideoEncoderGlobalFcts = M4OSA_NULL;
60 pC->pAudioEncoderGlobalFcts = M4OSA_NULL;
61
62 pC->pCurrentVideoEncoderExternalAPI = M4OSA_NULL;
63 pC->pCurrentVideoEncoderUserData = M4OSA_NULL;
64
65 for (i = 0; i < M4WRITER_kType_NB; i++ )
66 {
67 pC->WriterInterface[i].pGlobalFcts = M4OSA_NULL;
68 pC->WriterInterface[i].pDataFcts = M4OSA_NULL;
69 }
70
71 for (i = 0; i < M4ENCODER_kVideo_NB; i++ )
72 {
73 pC->pVideoEncoderInterface[i] = M4OSA_NULL;
74 pC->pVideoEncoderExternalAPITable[i] = M4OSA_NULL;
75 pC->pVideoEncoderUserDataTable[i] = M4OSA_NULL;
76 }
77
78 for (i = 0; i < M4ENCODER_kAudio_NB; i++ )
79 {
80 pC->pAudioEncoderInterface[i] = M4OSA_NULL;
81 pC->pAudioEncoderFlag[i] = M4OSA_FALSE;
82 pC->pAudioEncoderUserDataTable[i] = M4OSA_NULL;
83 }
84
85 /* Initialisation that will allow to check if registering twice */
86 pC->m_pReader = M4OSA_NULL;
87 pC->m_pReaderDataIt = M4OSA_NULL;
88 pC->m_uiNbRegisteredReaders = 0;
89
90 for (i = 0; i < M4READER_kMediaType_NB; i++ )
91 {
92 pC->m_pReaderGlobalItTable[i] = M4OSA_NULL;
93 pC->m_pReaderDataItTable[i] = M4OSA_NULL;
94 }
95
96 pC->m_pVideoDecoder = M4OSA_NULL;
97 #ifdef M4VSS_ENABLE_EXTERNAL_DECODERS
98 pC->m_pCurrentVideoDecoderUserData = M4OSA_NULL;
99 #endif /* M4VSS_ENABLE_EXTERNAL_DECODERS */
100 pC->m_uiNbRegisteredVideoDec = 0;
101 for (i = 0; i < M4DECODER_kVideoType_NB; i++ )
102 {
103 pC->m_pVideoDecoderItTable[i] = M4OSA_NULL;
104 #ifdef M4VSS_ENABLE_EXTERNAL_DECODERS
105 pC->m_pVideoDecoderUserDataTable[i] = M4OSA_NULL;
106 #endif /* M4VSS_ENABLE_EXTERNAL_DECODERS */
107 }
108
109 pC->m_pAudioDecoder = M4OSA_NULL;
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->m_pAudioDecoderUserDataTable[i] = M4OSA_NULL;
115 }
116
117 return M4NO_ERROR;
118 }
119
120 /**
121 ******************************************************************************
122 * M4OSA_ERR M4MCS_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 context
125 * the writer context.
126 * @param pContext: (IN) Execution context.
127 * @return M4NO_ERROR: there is no error
128 * @return M4ERR_PARAMETER pContext,pWtrGlobalInterface or
129 * pWtrDataInterface is M4OSA_NULL
130 * (debug only), or invalid MediaType
131 ******************************************************************************
132 */
M4MCS_registerWriter(M4MCS_Context pContext,M4WRITER_OutputFileType MediaType,M4WRITER_GlobalInterface * pWtrGlobalInterface,M4WRITER_DataInterface * pWtrDataInterface)133 M4OSA_ERR M4MCS_registerWriter(M4MCS_Context pContext, M4WRITER_OutputFileType MediaType,
134 M4WRITER_GlobalInterface* pWtrGlobalInterface,
135 M4WRITER_DataInterface* pWtrDataInterface)
136 {
137 M4MCS_InternalContext* pC = (M4MCS_InternalContext*)pContext;
138
139 /**
140 * Check input parameters */
141 M4OSA_DEBUG_IF2((pC == M4OSA_NULL),M4ERR_PARAMETER,
142 "MCS: context is M4OSA_NULL in M4MCS_registerWriter");
143 M4OSA_DEBUG_IF2((pWtrGlobalInterface == M4OSA_NULL),M4ERR_PARAMETER,
144 "pWtrGlobalInterface is M4OSA_NULL in M4MCS_registerWriter");
145 M4OSA_DEBUG_IF2((pWtrDataInterface == M4OSA_NULL),M4ERR_PARAMETER,
146 "pWtrDataInterface is M4OSA_NULL in M4MCS_registerWriter");
147
148 M4OSA_TRACE3_3("MCS: M4MCS_registerWriter called with pContext=0x%x,\
149 pWtrGlobalInterface=0x%x, pWtrDataInterface=0x%x", pC,pWtrGlobalInterface,
150 pWtrDataInterface);
151
152 if((MediaType == M4WRITER_kUnknown) || (MediaType >= M4WRITER_kType_NB))
153 {
154 M4OSA_DEBUG_IF1(M4OSA_TRUE, M4ERR_PARAMETER, "Invalid media type");
155 return M4ERR_PARAMETER;
156 }
157
158 if (pC->WriterInterface[MediaType].pGlobalFcts != M4OSA_NULL)
159 {
160 /* a writer corresponding to this media type has already been registered !*/
161 M4OSA_DEBUG_IF1(M4OSA_TRUE, M4ERR_PARAMETER, "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 M4MCS_registerEncoder()
176 * @brief This function will register a specific video encoder.
177 * @note According to the Mediatype, this function will store in the internal context
178 * 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 */
M4MCS_registerVideoEncoder(M4MCS_Context pContext,M4ENCODER_Format MediaType,M4ENCODER_GlobalInterface * pEncGlobalInterface)185 M4OSA_ERR M4MCS_registerVideoEncoder (
186 M4MCS_Context pContext,
187 M4ENCODER_Format MediaType,
188 M4ENCODER_GlobalInterface *pEncGlobalInterface)
189 {
190 M4MCS_InternalContext* pC = (M4MCS_InternalContext*)pContext;
191
192 /**
193 * Check input parameters */
194 M4OSA_DEBUG_IF2((pC == M4OSA_NULL),M4ERR_PARAMETER,
195 "MCS: context is M4OSA_NULL in M4MCS_registerVideoEncoder");
196 M4OSA_DEBUG_IF2((pEncGlobalInterface == M4OSA_NULL),M4ERR_PARAMETER,
197 "pEncGlobalInterface is M4OSA_NULL in M4MCS_registerVideoEncoder");
198
199 M4OSA_TRACE3_2("MCS: M4MCS_registerVideoEncoder called with pContext=0x%x,\
200 pEncGlobalInterface=0x%x", pC, pEncGlobalInterface);
201
202 if (MediaType >= M4ENCODER_kVideo_NB)
203 {
204 M4OSA_DEBUG_IF1(M4OSA_TRUE, M4ERR_PARAMETER, "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 free(pC->pVideoEncoderInterface[MediaType]);
214 pC->pVideoEncoderInterface[MediaType] = M4OSA_NULL;
215 }
216
217 /*
218 * Save encoder interface in context */
219 pC->pVideoEncoderInterface[MediaType] = pEncGlobalInterface;
220 /* The actual userData and external API will be set by the registration function in the case
221 of an external encoder (add it as a parameter to this function in the long run?) */
222 pC->pVideoEncoderUserDataTable[MediaType] = M4OSA_NULL;
223 pC->pVideoEncoderExternalAPITable[MediaType] = M4OSA_NULL;
224
225 return M4NO_ERROR;
226 }
227
228 /**
229 ******************************************************************************
230 * M4OSA_ERR M4MCS_registerAudioEncoder()
231 * @brief This function will register a specific audio encoder.
232 * @note According to the Mediatype, this function will store in the internal context
233 * the encoder context.
234 * @param pContext: (IN) Execution context.
235 * @param mediaType: (IN) The media type.
236 * @param pEncGlobalInterface: (OUT) the encoder interface functions.
237 * @return M4NO_ERROR: there is no error
238 * @return M4ERR_PARAMETER: pContext or pEncGlobalInterface is
239 * M4OSA_NULL (debug only)
240 ******************************************************************************
241 */
M4MCS_registerAudioEncoder(M4MCS_Context pContext,M4ENCODER_AudioFormat MediaType,M4ENCODER_AudioGlobalInterface * pEncGlobalInterface)242 M4OSA_ERR M4MCS_registerAudioEncoder(
243 M4MCS_Context pContext,
244 M4ENCODER_AudioFormat MediaType,
245 M4ENCODER_AudioGlobalInterface *pEncGlobalInterface)
246 {
247 M4MCS_InternalContext* pC = (M4MCS_InternalContext*)pContext;
248
249 /**
250 * Check input parameters */
251 M4OSA_DEBUG_IF2((pC == M4OSA_NULL),M4ERR_PARAMETER,
252 "MCS: context is M4OSA_NULL in M4MCS_registerAudioEncoder");
253 M4OSA_DEBUG_IF2((pEncGlobalInterface == M4OSA_NULL),M4ERR_PARAMETER,
254 "pEncGlobalInterface is M4OSA_NULL in M4MCS_registerAudioEncoder");
255
256 M4OSA_TRACE3_2("MCS: M4MCS_registerAudioEncoder called with pContext=0x%x,\
257 pEncGlobalInterface=0x%x", pC, pEncGlobalInterface);
258
259 if (MediaType >= M4ENCODER_kAudio_NB)
260 {
261 M4OSA_DEBUG_IF1(M4OSA_TRUE, M4ERR_PARAMETER, "Invalid audio encoder type");
262 return M4ERR_PARAMETER;
263 }
264
265 if(M4OSA_NULL != pC->pAudioEncoderInterface[MediaType])
266 {
267 free(pC->pAudioEncoderInterface[MediaType]);
268 pC->pAudioEncoderInterface[MediaType] = M4OSA_NULL;
269
270 if(M4OSA_NULL != pC->pAudioEncoderUserDataTable[MediaType])
271 {
272 free(pC->pAudioEncoderUserDataTable[MediaType]);
273 pC->pAudioEncoderUserDataTable[MediaType] = M4OSA_NULL;
274 }
275 }
276
277 /*
278 * Save encoder interface in context */
279 pC->pAudioEncoderInterface[MediaType] = pEncGlobalInterface;
280 pC->pAudioEncoderFlag[MediaType] = M4OSA_FALSE; /* internal encoder */
281
282 return M4NO_ERROR;
283 }
284
285 /**
286 ************************************************************************
287 * M4OSA_ERR M4MCS_registerReader()
288 * @brief Register reader.
289 * @param pContext (IN/OUT) MCS context.
290 * @return M4NO_ERROR: No error
291 * @return M4ERR_PARAMETER: A parameter is null (in DEBUG only)
292 ************************************************************************
293 */
M4MCS_registerReader(M4MCS_Context pContext,M4READER_MediaType mediaType,M4READER_GlobalInterface * pRdrGlobalInterface,M4READER_DataInterface * pRdrDataInterface)294 M4OSA_ERR M4MCS_registerReader(
295 M4MCS_Context pContext,
296 M4READER_MediaType mediaType,
297 M4READER_GlobalInterface *pRdrGlobalInterface,
298 M4READER_DataInterface *pRdrDataInterface)
299 {
300 M4MCS_InternalContext* pC = (M4MCS_InternalContext*)pContext;
301
302 M4OSA_DEBUG_IF1((M4OSA_NULL == pC), M4ERR_PARAMETER, "invalid context pointer");
303 M4OSA_DEBUG_IF1((M4OSA_NULL == pRdrGlobalInterface),
304 M4ERR_PARAMETER, "M4MCS_registerReader: invalid pointer on global interface");
305 M4OSA_DEBUG_IF1((M4OSA_NULL == pRdrDataInterface),
306 M4ERR_PARAMETER, "M4MCS_registerReader: invalid pointer on data interface");
307
308 if (mediaType == M4READER_kMediaTypeUnknown || mediaType >= M4READER_kMediaType_NB)
309 {
310 M4OSA_DEBUG_IF1(M4OSA_TRUE, M4ERR_PARAMETER, "Invalid media type");
311 return M4ERR_PARAMETER;
312 }
313
314 if (pC->m_pReaderGlobalItTable[mediaType] != M4OSA_NULL)
315 {
316 /* a reader corresponding to this media type has already been registered !*/
317 M4OSA_DEBUG_IF1(M4OSA_TRUE, M4ERR_PARAMETER, "This media type has already been registered");
318 return M4ERR_PARAMETER;
319 }
320
321 pC->m_pReaderGlobalItTable[mediaType] = pRdrGlobalInterface;
322 pC->m_pReaderDataItTable[mediaType] = pRdrDataInterface;
323
324 pC->m_uiNbRegisteredReaders++;
325
326 return M4NO_ERROR;
327 }
328
329 /**
330 ************************************************************************
331 * M4OSA_ERR M4MCS_registerVideoDecoder()
332 * @brief Register video decoder
333 * @param pContext (IN/OUT) MCS context.
334 * @param decoderType (IN) Decoder type
335 * @param pDecoderInterface (IN) Decoder interface.
336 * @return M4NO_ERROR: No error
337 * @return M4ERR_PARAMETER: A parameter is null (in DEBUG only), or the decoder
338 * type is invalid
339 ************************************************************************
340 */
M4MCS_registerVideoDecoder(M4MCS_Context pContext,M4DECODER_VideoType decoderType,M4DECODER_VideoInterface * pDecoderInterface)341 M4OSA_ERR M4MCS_registerVideoDecoder(
342 M4MCS_Context pContext,
343 M4DECODER_VideoType decoderType,
344 M4DECODER_VideoInterface *pDecoderInterface)
345 {
346 M4MCS_InternalContext* pC = (M4MCS_InternalContext*)pContext;
347
348 M4OSA_DEBUG_IF1((M4OSA_NULL == pC), M4ERR_PARAMETER, "invalid context pointer");
349 M4OSA_DEBUG_IF1((M4OSA_NULL == pDecoderInterface), M4ERR_PARAMETER,
350 "M4MCS_registerVideoDecoder: invalid pointer on decoder interface");
351
352 if (decoderType >= M4DECODER_kVideoType_NB)
353 {
354 M4OSA_DEBUG_IF1(M4OSA_TRUE, M4ERR_PARAMETER, "Invalid video decoder type");
355 return M4ERR_PARAMETER;
356 }
357
358 if (pC->m_pVideoDecoderItTable[decoderType] != M4OSA_NULL)
359 {
360 #ifndef M4VSS_ENABLE_EXTERNAL_DECODERS
361 /* a decoder corresponding to this media type has already been registered !*/
362 M4OSA_DEBUG_IF1(M4OSA_TRUE, M4ERR_PARAMETER, "Decoder has already been registered");
363 return M4ERR_PARAMETER;
364 #else /* external decoders are possible */
365 /* can be legitimate, in cases where we have one version that can use external decoders
366 but which still has the built-in one to be able to work without an external decoder; in
367 this case the new decoder simply replaces the old one (i.e. we unregister it first). */
368 free(pC->m_pVideoDecoderItTable[decoderType]);
369 pC->m_pVideoDecoderItTable[decoderType] = M4OSA_NULL;
370 /* oh, and don't forget the user data, too. */
371 if (pC->m_pVideoDecoderUserDataTable[decoderType] != M4OSA_NULL)
372 {
373 free(pC->m_pVideoDecoderUserDataTable[decoderType]);
374 pC->m_pVideoDecoderUserDataTable[decoderType] = M4OSA_NULL;
375 }
376 #endif /* are external decoders possible? */
377 }
378
379 pC->m_pVideoDecoderItTable[decoderType] = pDecoderInterface;
380 #ifdef M4VSS_ENABLE_EXTERNAL_DECODERS
381 pC->m_pVideoDecoderUserDataTable[decoderType] = M4OSA_NULL;
382 /* The actual userData will be set by the registration function in the case
383 of an external decoder (add it as a parameter to this function in the long run?) */
384 #endif /* M4VSS_ENABLE_EXTERNAL_DECODERS */
385 pC->m_uiNbRegisteredVideoDec++;
386
387 return M4NO_ERROR;
388 }
389
390 /**
391 ************************************************************************
392 * M4OSA_ERR M4MCS_registerAudioDecoder()
393 * @brief Register audio decoder
394 * @note This function is used internaly by the MCS to
395 * register audio decoders,
396 * @param context (IN/OUT) MCS context.
397 * @param decoderType (IN) Audio decoder type
398 * @param pDecoderInterface (IN) Audio decoder interface.
399 * @return M4NO_ERROR: No error
400 * @return M4ERR_PARAMETER: A parameter is null, or the decoder type is invalid(in DEBUG only)
401 ************************************************************************
402 */
M4MCS_registerAudioDecoder(M4MCS_Context pContext,M4AD_Type decoderType,M4AD_Interface * pDecoderInterface)403 M4OSA_ERR M4MCS_registerAudioDecoder(
404 M4MCS_Context pContext,
405 M4AD_Type decoderType,
406 M4AD_Interface *pDecoderInterface)
407 {
408 M4MCS_InternalContext* pC = (M4MCS_InternalContext*)pContext;
409
410 M4OSA_DEBUG_IF1((M4OSA_NULL == pC), M4ERR_PARAMETER, "invalid context pointer");
411 M4OSA_DEBUG_IF1((M4OSA_NULL == pDecoderInterface), M4ERR_PARAMETER,
412 "M4MCS_registerAudioDecoder: invalid pointer on decoder interface");
413
414 if (decoderType >= M4AD_kType_NB)
415 {
416 M4OSA_DEBUG_IF1(M4OSA_TRUE, M4ERR_PARAMETER, "Invalid audio decoder type");
417 return M4ERR_PARAMETER;
418 }
419
420 if(M4OSA_NULL != pC->m_pAudioDecoderItTable[decoderType])
421 {
422 free(pC->m_pAudioDecoderItTable[decoderType]);
423 pC->m_pAudioDecoderItTable[decoderType] = M4OSA_NULL;
424
425 if(M4OSA_NULL != pC->m_pAudioDecoderUserDataTable[decoderType])
426 {
427 free(pC->m_pAudioDecoderUserDataTable[decoderType]);
428 pC->m_pAudioDecoderUserDataTable[decoderType] = M4OSA_NULL;
429 }
430 }
431 pC->m_pAudioDecoderItTable[decoderType] = pDecoderInterface;
432 pC->m_pAudioDecoderFlagTable[decoderType] = M4OSA_FALSE; /* internal decoder */
433
434 return M4NO_ERROR;
435 }
436
437 /**
438 ************************************************************************
439 * M4OSA_ERR M4MCS_unRegisterAllWriters()
440 * @brief Unregister writer
441 * @param pContext (IN/OUT) MCS context.
442 * @return M4NO_ERROR: No error
443 * @return M4ERR_PARAMETER: A parameter is null (in DEBUG only)
444 ************************************************************************
445 */
M4MCS_unRegisterAllWriters(M4MCS_Context pContext)446 M4OSA_ERR M4MCS_unRegisterAllWriters(M4MCS_Context pContext)
447 {
448 M4MCS_InternalContext* pC = (M4MCS_InternalContext*)pContext;
449 M4OSA_Int32 i;
450
451 M4OSA_DEBUG_IF1((M4OSA_NULL == pC), M4ERR_PARAMETER, "invalid context pointer");
452
453 for (i = 0; i < M4WRITER_kType_NB; i++)
454 {
455 if (pC->WriterInterface[i].pGlobalFcts != M4OSA_NULL)
456 {
457 free(pC->WriterInterface[i].pGlobalFcts );
458 pC->WriterInterface[i].pGlobalFcts = M4OSA_NULL;
459 }
460 if (pC->WriterInterface[i].pDataFcts != M4OSA_NULL)
461 {
462 free(pC->WriterInterface[i].pDataFcts );
463 pC->WriterInterface[i].pDataFcts = M4OSA_NULL;
464 }
465 }
466
467 pC->pWriterGlobalFcts = M4OSA_NULL;
468 pC->pWriterDataFcts = M4OSA_NULL;
469
470 return M4NO_ERROR;
471 }
472
473 /**
474 ************************************************************************
475 * M4OSA_ERR M4MCS_unRegisterAllEncoders()
476 * @brief Unregister the encoders
477 * @param pContext (IN/OUT) MCS context.
478 * @return M4NO_ERROR: No error
479 * @return M4ERR_PARAMETER: A parameter is null (in DEBUG only)
480 ************************************************************************
481 */
M4MCS_unRegisterAllEncoders(M4MCS_Context pContext)482 M4OSA_ERR M4MCS_unRegisterAllEncoders(M4MCS_Context pContext)
483 {
484 M4MCS_InternalContext* pC = (M4MCS_InternalContext*)pContext;
485 M4OSA_Int32 i;
486
487 M4OSA_DEBUG_IF1((M4OSA_NULL == pC), M4ERR_PARAMETER, "invalid context pointer");
488
489 for (i = 0; i < M4ENCODER_kVideo_NB; i++)
490 {
491 if (pC->pVideoEncoderInterface[i] != M4OSA_NULL)
492 {
493 free(pC->pVideoEncoderInterface[i] );
494 pC->pVideoEncoderInterface[i] = M4OSA_NULL;
495 }
496 }
497
498 for (i = 0; i < M4ENCODER_kAudio_NB; i++)
499 {
500 if (pC->pAudioEncoderInterface[i] != M4OSA_NULL)
501 {
502 /*Don't free external audio encoders interfaces*/
503 if (M4OSA_FALSE == pC->pAudioEncoderFlag[i])
504 {
505 free(pC->pAudioEncoderInterface[i] );
506 }
507 pC->pAudioEncoderInterface[i] = M4OSA_NULL;
508 }
509 }
510
511 pC->pVideoEncoderGlobalFcts = M4OSA_NULL;
512 pC->pAudioEncoderGlobalFcts = M4OSA_NULL;
513
514 return M4NO_ERROR;
515 }
516
517 /**
518 ************************************************************************
519 * M4OSA_ERR M4MCS_unRegisterAllReaders()
520 * @brief Unregister reader
521 * @param pContext (IN/OUT) MCS context.
522 * @return M4NO_ERROR: No error
523 * @return M4ERR_PARAMETER: A parameter is null (in DEBUG only)
524 ************************************************************************
525 */
M4MCS_unRegisterAllReaders(M4MCS_Context pContext)526 M4OSA_ERR M4MCS_unRegisterAllReaders(M4MCS_Context pContext)
527 {
528 M4MCS_InternalContext* pC = (M4MCS_InternalContext*)pContext;
529 M4OSA_Int32 i;
530
531 M4OSA_DEBUG_IF1((M4OSA_NULL == pC), M4ERR_PARAMETER, "invalid context pointer");
532
533 for (i = 0; i < M4READER_kMediaType_NB; i++)
534 {
535 if (pC->m_pReaderGlobalItTable[i] != M4OSA_NULL)
536 {
537 free(pC->m_pReaderGlobalItTable[i] );
538 pC->m_pReaderGlobalItTable[i] = M4OSA_NULL;
539 }
540 if (pC->m_pReaderDataItTable[i] != M4OSA_NULL)
541 {
542 free(pC->m_pReaderDataItTable[i] );
543 pC->m_pReaderDataItTable[i] = M4OSA_NULL;
544 }
545 }
546
547 pC->m_uiNbRegisteredReaders = 0;
548 pC->m_pReader = M4OSA_NULL;
549 pC->m_pReaderDataIt = M4OSA_NULL;
550
551 return M4NO_ERROR;
552 }
553
554 /**
555 ************************************************************************
556 * M4OSA_ERR M4MCS_unRegisterAllDecoders()
557 * @brief Unregister the decoders
558 * @param pContext (IN/OUT) MCS context.
559 * @return M4NO_ERROR: No error
560 * @return M4ERR_PARAMETER: A parameter is null (in DEBUG only)
561 ************************************************************************
562 */
M4MCS_unRegisterAllDecoders(M4MCS_Context pContext)563 M4OSA_ERR M4MCS_unRegisterAllDecoders(M4MCS_Context pContext)
564 {
565 M4MCS_InternalContext* pC = (M4MCS_InternalContext*)pContext;
566 M4OSA_Int32 i;
567
568 M4OSA_DEBUG_IF1((M4OSA_NULL == pC), M4ERR_PARAMETER, "invalid context pointer");
569
570 for (i = 0; i < M4DECODER_kVideoType_NB; i++)
571 {
572 if (pC->m_pVideoDecoderItTable[i] != M4OSA_NULL)
573 {
574 free(pC->m_pVideoDecoderItTable[i] );
575 pC->m_pVideoDecoderItTable[i] = M4OSA_NULL;
576 }
577 }
578
579 for (i = 0; i < M4AD_kType_NB; i++)
580 {
581 if (pC->m_pAudioDecoderItTable[i] != M4OSA_NULL)
582 {
583 /*Don't free external audio decoders interfaces*/
584 if (M4OSA_FALSE == pC->m_pAudioDecoderFlagTable[i])
585 {
586 free(pC->m_pAudioDecoderItTable[i] );
587 }
588 pC->m_pAudioDecoderItTable[i] = M4OSA_NULL;
589 }
590 }
591
592 pC->m_uiNbRegisteredVideoDec = 0;
593 pC->m_pVideoDecoder = M4OSA_NULL;
594
595 pC->m_pAudioDecoder = M4OSA_NULL;
596
597 return M4NO_ERROR;
598 }
599
600 /**
601 ************************************************************************
602 * M4OSA_ERR M4MCS_setCurrentWriter()
603 * @brief Set current writer
604 * @param pContext (IN/OUT) MCS context.
605 * @param mediaType (IN) Media type.
606 * @return M4NO_ERROR: No error
607 * @return M4ERR_PARAMETER: A parameter is null (in DEBUG only)
608 * @return M4WAR_MCS_MEDIATYPE_NOT_SUPPORTED: Media type not supported
609 ************************************************************************
610 */
M4MCS_setCurrentWriter(M4MCS_Context pContext,M4VIDEOEDITING_FileType mediaType)611 M4OSA_ERR M4MCS_setCurrentWriter( M4MCS_Context pContext,
612 M4VIDEOEDITING_FileType mediaType)
613 {
614 M4MCS_InternalContext* pC = (M4MCS_InternalContext*)pContext;
615 M4WRITER_OutputFileType writerType;
616
617 M4OSA_DEBUG_IF1((M4OSA_NULL == pC), M4ERR_PARAMETER, "invalid context pointer");
618
619 switch (mediaType)
620 {
621 case M4VIDEOEDITING_kFileType_3GPP:
622 case M4VIDEOEDITING_kFileType_MP4:
623 case M4VIDEOEDITING_kFileType_M4V:
624 writerType = M4WRITER_k3GPP;
625 break;
626 case M4VIDEOEDITING_kFileType_AMR:
627 writerType = M4WRITER_kAMR;
628 break;
629 case M4VIDEOEDITING_kFileType_MP3:
630 writerType = M4WRITER_kMP3;
631 break;
632 case M4VIDEOEDITING_kFileType_PCM:
633 pC->b_isRawWriter = M4OSA_TRUE;
634 writerType = M4WRITER_kPCM;
635 break;
636 default:
637 M4OSA_DEBUG_IF1(M4OSA_TRUE, M4MCS_WAR_MEDIATYPE_NOT_SUPPORTED,
638 "Writer type not supported");
639 return M4MCS_WAR_MEDIATYPE_NOT_SUPPORTED;
640 }
641
642 pC->pWriterGlobalFcts = pC->WriterInterface[writerType].pGlobalFcts;
643 pC->pWriterDataFcts = pC->WriterInterface[writerType].pDataFcts;
644
645 if (pC->pWriterGlobalFcts == M4OSA_NULL || pC->pWriterDataFcts == M4OSA_NULL)
646 {
647 M4OSA_DEBUG_IF1(M4OSA_TRUE, M4MCS_WAR_MEDIATYPE_NOT_SUPPORTED,
648 "Writer type not supported");
649 return M4MCS_WAR_MEDIATYPE_NOT_SUPPORTED;
650 }
651
652 pC->pWriterDataFcts->pWriterContext = M4OSA_NULL;
653
654 return M4NO_ERROR;
655 }
656
657 /**
658 ************************************************************************
659 * M4OSA_ERR M4MCS_setCurrentVideoEncoder()
660 * @brief Set a video encoder
661 * @param pContext (IN/OUT) MCS context.
662 * @param MediaType (IN) Encoder type
663 * @return M4NO_ERROR: No error
664 * @return M4ERR_PARAMETER: A parameter is null (in DEBUG only)
665 * @return M4WAR_MCS_MEDIATYPE_NOT_SUPPORTED: Media type not supported
666 ************************************************************************
667 */
M4MCS_setCurrentVideoEncoder(M4MCS_Context pContext,M4VIDEOEDITING_VideoFormat mediaType)668 M4OSA_ERR M4MCS_setCurrentVideoEncoder(
669 M4MCS_Context pContext,
670 M4VIDEOEDITING_VideoFormat mediaType)
671 {
672 M4MCS_InternalContext* pC = (M4MCS_InternalContext*)pContext;
673 M4ENCODER_Format encoderType;
674
675 M4OSA_DEBUG_IF1((M4OSA_NULL == pC), M4ERR_PARAMETER, "invalid context pointer");
676
677 switch (mediaType)
678 {
679 case M4VIDEOEDITING_kH263:
680 encoderType = M4ENCODER_kH263;
681 break;
682 case M4VIDEOEDITING_kMPEG4:
683 encoderType = M4ENCODER_kMPEG4;
684 break;
685 case M4VIDEOEDITING_kH264:
686 #ifdef M4VSS_SUPPORT_ENCODER_AVC
687 encoderType = M4ENCODER_kH264;
688 break;
689 #endif
690 default:
691 M4OSA_DEBUG_IF1(M4OSA_TRUE, M4MCS_WAR_MEDIATYPE_NOT_SUPPORTED,
692 "Video encoder type not supported");
693 return M4MCS_WAR_MEDIATYPE_NOT_SUPPORTED;
694 }
695
696 pC->pVideoEncoderGlobalFcts = pC->pVideoEncoderInterface[encoderType];
697 pC->pCurrentVideoEncoderExternalAPI = pC->pVideoEncoderExternalAPITable[encoderType];
698 pC->pCurrentVideoEncoderUserData = pC->pVideoEncoderUserDataTable[encoderType];
699
700 if (pC->pVideoEncoderGlobalFcts == M4OSA_NULL)
701 {
702 M4OSA_DEBUG_IF1(M4OSA_TRUE, M4MCS_WAR_MEDIATYPE_NOT_SUPPORTED,
703 "Video encoder type not supported");
704 return M4MCS_WAR_MEDIATYPE_NOT_SUPPORTED;
705 }
706
707 return M4NO_ERROR;
708 }
709
710 /**
711 ************************************************************************
712 * M4OSA_ERR M4MCS_setCurrentAudioEncoder()
713 * @brief Set an audio encoder
714 * @param context (IN/OUT) MCS context.
715 * @param MediaType (IN) Encoder type
716 * @return M4NO_ERROR: No error
717 * @return M4ERR_PARAMETER: A parameter is null (in DEBUG only)
718 ************************************************************************
719 */
M4MCS_setCurrentAudioEncoder(M4MCS_Context pContext,M4VIDEOEDITING_AudioFormat mediaType)720 M4OSA_ERR M4MCS_setCurrentAudioEncoder(
721 M4MCS_Context pContext,
722 M4VIDEOEDITING_AudioFormat mediaType)
723 {
724 M4MCS_InternalContext* pC = (M4MCS_InternalContext*)pContext;
725 M4ENCODER_AudioFormat encoderType;
726
727 M4OSA_DEBUG_IF1((M4OSA_NULL == pC), M4ERR_PARAMETER, "invalid context pointer");
728
729 switch (mediaType)
730 {
731 case M4VIDEOEDITING_kAMR_NB:
732 encoderType = M4ENCODER_kAMRNB;
733 break;
734 case M4VIDEOEDITING_kAAC:
735 encoderType = M4ENCODER_kAAC;
736 break;
737 case M4VIDEOEDITING_kMP3:
738 encoderType = M4ENCODER_kMP3;
739 break;
740 //EVRC
741 // case M4VIDEOEDITING_kEVRC:
742 // encoderType = M4ENCODER_kEVRC;
743 // break;
744 default:
745 M4OSA_DEBUG_IF1(M4OSA_TRUE, M4MCS_WAR_MEDIATYPE_NOT_SUPPORTED,
746 "Audio encoder type not supported");
747 return M4MCS_WAR_MEDIATYPE_NOT_SUPPORTED;
748 }
749
750 pC->pAudioEncoderGlobalFcts = pC->pAudioEncoderInterface[encoderType];
751 pC->pCurrentAudioEncoderUserData = pC->pAudioEncoderUserDataTable[encoderType];
752
753 if (pC->pAudioEncoderGlobalFcts == M4OSA_NULL)
754 {
755 M4OSA_DEBUG_IF1(M4OSA_TRUE, M4MCS_WAR_MEDIATYPE_NOT_SUPPORTED,
756 "Audio encoder type not supported");
757 return M4MCS_WAR_MEDIATYPE_NOT_SUPPORTED;
758 }
759
760 return M4NO_ERROR;
761 }
762
763 /**
764 ************************************************************************
765 * M4OSA_ERR M4MCS_setCurrentReader()
766 * @brief Set current reader
767 * @param pContext (IN/OUT) MCS context.
768 * @param mediaType (IN) Media type.
769 * @return M4NO_ERROR: No error
770 * @return M4ERR_PARAMETER: A parameter is null (in DEBUG only)
771 * @return M4WAR_MCS_MEDIATYPE_NOT_SUPPORTED: Media type not supported
772 ************************************************************************
773 */
M4MCS_setCurrentReader(M4MCS_Context pContext,M4VIDEOEDITING_FileType mediaType)774 M4OSA_ERR M4MCS_setCurrentReader( M4MCS_Context pContext,
775 M4VIDEOEDITING_FileType mediaType)
776 {
777 M4MCS_InternalContext* pC = (M4MCS_InternalContext*)pContext;
778 M4READER_MediaType readerType;
779
780 M4OSA_DEBUG_IF1((M4OSA_NULL == pC), M4ERR_PARAMETER, "invalid context pointer");
781
782 switch (mediaType)
783 {
784 case M4VIDEOEDITING_kFileType_3GPP:
785 case M4VIDEOEDITING_kFileType_MP4:
786 case M4VIDEOEDITING_kFileType_M4V:
787 readerType = M4READER_kMediaType3GPP;
788 break;
789 case M4VIDEOEDITING_kFileType_AMR:
790 readerType = M4READER_kMediaTypeAMR;
791 break;
792 case M4VIDEOEDITING_kFileType_MP3:
793 readerType = M4READER_kMediaTypeMP3;
794 break;
795 default:
796 M4OSA_DEBUG_IF1(M4OSA_TRUE, M4MCS_WAR_MEDIATYPE_NOT_SUPPORTED,
797 "Reader type not supported");
798 return M4MCS_WAR_MEDIATYPE_NOT_SUPPORTED;
799 }
800
801 pC->m_pReader = pC->m_pReaderGlobalItTable[readerType];
802 pC->m_pReaderDataIt = pC->m_pReaderDataItTable[readerType];
803
804 if (pC->m_pReader == M4OSA_NULL || pC->m_pReaderDataIt == M4OSA_NULL)
805 {
806 M4OSA_DEBUG_IF1(M4OSA_TRUE, M4MCS_WAR_MEDIATYPE_NOT_SUPPORTED,
807 "Reader type not supported");
808 return M4MCS_WAR_MEDIATYPE_NOT_SUPPORTED;
809 }
810 return M4NO_ERROR;
811 }
812
813 /**
814 ************************************************************************
815 * M4OSA_ERR M4MCS_setCurrentVideoDecoder()
816 * @brief Set a video decoder
817 * @param pContext (IN/OUT) MCS context.
818 * @param decoderType (IN) Decoder type
819 * @return M4NO_ERROR: No error
820 * @return M4ERR_PARAMETER: A parameter is null (in DEBUG only)
821 * @return M4WAR_MCS_MEDIATYPE_NOT_SUPPORTED: Media type not supported
822 ************************************************************************
823 */
M4MCS_setCurrentVideoDecoder(M4MCS_Context pContext,M4_StreamType mediaType)824 M4OSA_ERR M4MCS_setCurrentVideoDecoder( M4MCS_Context pContext,
825 M4_StreamType mediaType)
826 {
827 M4MCS_InternalContext* pC = (M4MCS_InternalContext*)pContext;
828 M4DECODER_VideoType decoderType;
829
830 M4OSA_DEBUG_IF1((M4OSA_NULL == pC), M4ERR_PARAMETER, "invalid context pointer");
831
832 switch (mediaType)
833 {
834 case M4DA_StreamTypeVideoMpeg4:
835 case M4DA_StreamTypeVideoH263:
836 decoderType = M4DECODER_kVideoTypeMPEG4;
837 break;
838 case M4DA_StreamTypeVideoMpeg4Avc:
839 decoderType = M4DECODER_kVideoTypeAVC;
840 break;
841 default:
842 M4OSA_DEBUG_IF1(M4OSA_TRUE, M4MCS_WAR_MEDIATYPE_NOT_SUPPORTED,
843 "Video decoder type not supported");
844 return M4MCS_WAR_MEDIATYPE_NOT_SUPPORTED;
845 }
846
847 pC->m_pVideoDecoder = pC->m_pVideoDecoderItTable[decoderType];
848 #ifdef M4VSS_ENABLE_EXTERNAL_DECODERS
849 pC->m_pCurrentVideoDecoderUserData =
850 pC->m_pVideoDecoderUserDataTable[decoderType];
851 #endif /* M4VSS_ENABLE_EXTERNAL_DECODERS */
852
853 if (pC->m_pVideoDecoder == M4OSA_NULL)
854 {
855 M4OSA_DEBUG_IF1(M4OSA_TRUE, M4MCS_WAR_MEDIATYPE_NOT_SUPPORTED,
856 "Video decoder type not supported");
857 return M4MCS_WAR_MEDIATYPE_NOT_SUPPORTED;
858 }
859
860 return M4NO_ERROR;
861 }
862
863 /**
864 ************************************************************************
865 * M4OSA_ERR M4MCS_setCurrentAudioDecoder()
866 * @brief Set an audio decoder
867 * @param context (IN/OUT) MCS context.
868 * @param decoderType (IN) Decoder type
869 * @return M4NO_ERROR: No error
870 * @return M4ERR_PARAMETER: A parameter is null (in DEBUG only)
871 ************************************************************************
872 */
M4MCS_setCurrentAudioDecoder(M4MCS_Context pContext,M4_StreamType mediaType)873 M4OSA_ERR M4MCS_setCurrentAudioDecoder( M4MCS_Context pContext,
874 M4_StreamType mediaType)
875 {
876 M4MCS_InternalContext* pC = (M4MCS_InternalContext*)pContext;
877 M4AD_Type decoderType;
878
879 M4OSA_DEBUG_IF1((M4OSA_NULL == pC), M4ERR_PARAMETER, "invalid context pointer");
880
881 switch (mediaType)
882 {
883 case M4DA_StreamTypeAudioAmrNarrowBand:
884 decoderType = M4AD_kTypeAMRNB;
885 break;
886 case M4DA_StreamTypeAudioAac:
887 case M4DA_StreamTypeAudioAacADTS:
888 case M4DA_StreamTypeAudioAacADIF:
889 decoderType = M4AD_kTypeAAC;
890 break;
891 case M4DA_StreamTypeAudioMp3:
892 decoderType = M4AD_kTypeMP3;
893 break;
894 //EVRC
895 // case M4DA_StreamTypeAudioEvrc:
896 // decoderType = M4AD_kTypeEVRC;
897 // break;
898 default:
899 M4OSA_DEBUG_IF1(M4OSA_TRUE, M4MCS_WAR_MEDIATYPE_NOT_SUPPORTED,
900 "Audio decoder type not supported");
901 return M4MCS_WAR_MEDIATYPE_NOT_SUPPORTED;
902 }
903
904 pC->m_pAudioDecoder = pC->m_pAudioDecoderItTable[decoderType];
905 pC->m_pCurrentAudioDecoderUserData =
906 pC->m_pAudioDecoderUserDataTable[decoderType];
907
908 if (pC->m_pAudioDecoder == M4OSA_NULL)
909 {
910 M4OSA_DEBUG_IF1(M4OSA_TRUE, M4MCS_WAR_MEDIATYPE_NOT_SUPPORTED,
911 "Audio decoder type not supported");
912 return M4MCS_WAR_MEDIATYPE_NOT_SUPPORTED;
913 }
914
915 return M4NO_ERROR;
916 }
917
918