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 */
40M4OSA_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 */
132M4OSA_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 */
185M4OSA_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 */
254M4OSA_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 */
304M4OSA_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 */
351M4OSA_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 */
431M4OSA_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 */
476M4OSA_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 */
513M4OSA_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 */
584M4OSA_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 */
622M4OSA_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 */
698M4OSA_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 */
745M4OSA_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 */
804M4OSA_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 */
868M4OSA_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 */
926M4OSA_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 */
986M4OSA_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