src/FMedia_CodecFactory.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 #include <cstdlib>
  19 #include <new>
  20 #include <pthread.h>
  21 #include <stdio.h>
  22 #include <unique_ptr.h>
  23 #include <FBaseColArrayListT.h>
  24 #include <FBaseColHashMapT.h>
  25 #include <FMediaTypes.h>
  26 #include <FMediaAudioTypes.h>
  27 #include <FBaseSysLog.h>
  28 #include <FMedia_CodecFactory.h>
  29
  30 using namespace Tizen::Base;
  31 using namespace Tizen::Base::Collection;
  32
  33 namespace Tizen { namespace Media
  34 {
  35
  36 _CodecFactory* _CodecFactory::__pTheInstance = null;
  37
  38 void
  39 _CodecFactory::InitSingleton(void)
  40 {
  41         std::unique_ptr<_CodecFactory> pInst(new (std::nothrow) _CodecFactory());
  42
  43         SysTryReturnVoidResult(NID_MEDIA, pInst, E_OUT_OF_MEMORY,
  44                                                    "[%s] Memory allocation failed.",
  45                                                    GetErrorMessage(E_OUT_OF_MEMORY));
  46
  47         result r = pInst->Construct();
  48         SysTryReturnVoidResult(NID_MEDIA, r == E_SUCCESS, r,
  49                                                    "[%s] Propagating.", GetErrorMessage(r));
  50
  51         r = pInst->RegisterAllCodec();
  52         SysTryReturnVoidResult(NID_MEDIA, r == E_SUCCESS, r,
  53                                                    "[%s] _CodecFactory:RegisterAllCodec", GetErrorMessage(r));
  54
  55         __pTheInstance  = pInst.release();
  56         std::atexit(DestroySingleton);
  57 }
  58
  59 void
  60 _CodecFactory::DestroySingleton(void)
  61 {
  62         delete __pTheInstance;
  63 }
  64
  65 _CodecFactory*
  66 _CodecFactory::GetInstance(void)
  67 {
  68         static pthread_once_t onceBlock = PTHREAD_ONCE_INIT;
  69
  70         if (__pTheInstance == null)
  71         {
  72                 ClearLastResult();
  73                 pthread_once(&onceBlock, InitSingleton);
  74                 result r = GetLastResult();
  75                 if (IsFailed(r))
  76                 {
  77                         onceBlock = PTHREAD_ONCE_INIT;
  78                 }
  79         }
  80         return __pTheInstance;
  81 }
  82
  83 _CodecFactory::_CodecFactory(void)
  84 {
  85 }
  86
  87
  88 _CodecFactory::~_CodecFactory(void)
  89 {
  90 }
  91
  92 result
  93 _CodecFactory::Construct(void)
  94 {
  95         result r = E_SUCCESS;
  96
  97         r = __videoDecoderRegister.Construct();
  98         SysTryCatch(NID_MEDIA, r == E_SUCCESS, r = E_SYSTEM, E_SYSTEM, "Factory Hash Map Failed");
  99         r = __videoEncoderRegister.Construct();
 100         SysTryCatch(NID_MEDIA, r == E_SUCCESS, r = E_SYSTEM, E_SYSTEM, "Factory Hash Map Failed");
 101         r = __audioDecoderRegister.Construct();
 102         SysTryCatch(NID_MEDIA, r == E_SUCCESS, r = E_SYSTEM, E_SYSTEM, "Factory Hash Map Failed");
 103         r = __audioEncoderRegister.Construct();
 104         SysTryCatch(NID_MEDIA, r == E_SUCCESS, r = E_SYSTEM, E_SYSTEM, "Factory Hash Map Failed");
 105         return r;
 106
 107 CATCH:
 108         return r;
 109 }
 110
 111 result
 112 _CodecFactory::CreateCodecInstance(CodecType codecType, _IVideoDecoder*& pVideoDecoder)
 113 {
 114         result r = E_SUCCESS;
 115         _VideoDecoderCreateFunc createFunc = null;
 116
 117         r = __videoDecoderRegister.GetValue(codecType, createFunc);
 118         SysTryCatch(NID_MEDIA, r == E_SUCCESS && createFunc != null,
 119                            r = E_UNSUPPORTED_CODEC, E_UNSUPPORTED_CODEC,
 120                            "[E_UNSUPPORTED_CODEC] CreateCodecInstance Failed ");
 121
 122         pVideoDecoder = createFunc();
 123         SysTryCatch(NID_MEDIA, pVideoDecoder != null, r = GetLastResult(), GetLastResult(),
 124                            "[%s] CreateCodecInstance Failed", GetErrorMessage(GetLastResult()));
 125         return r;
 126
 127 CATCH:
 128         return r;
 129 }
 130
 131 result
 132 _CodecFactory::CreateCodecInstance(CodecType codecType, _IVideoEncoder*& pVideoEncoder)
 133 {
 134         result r = E_SUCCESS;
 135         _VideoEncoderCreateFunc createFunc = null;
 136
 137         r = __videoEncoderRegister.GetValue(codecType, createFunc);
 138         SysTryCatch(NID_MEDIA, r == E_SUCCESS && createFunc != null,
 139                            r = E_UNSUPPORTED_CODEC, E_UNSUPPORTED_CODEC,
 140                            "[E_UNSUPPORTED_CODEC] CreateCodecInstance Failed ");
 141
 142         pVideoEncoder = createFunc();
 143         SysTryCatch(NID_MEDIA, pVideoEncoder != null, r = GetLastResult(), GetLastResult(),
 144                            "[%s] CreateCodecInstance Failed", GetErrorMessage(GetLastResult()));
 145         return r;
 146
 147 CATCH:
 148         return r;
 149 }
 150
 151 result
 152 _CodecFactory::CreateCodecInstance(CodecType codecType, _IAudioDecoder*& pAudioDecoder)
 153 {
 154         result r = E_SUCCESS;
 155         _AudioDecoderCreateFunc createFunc = null;
 156
 157         r = __audioDecoderRegister.GetValue(codecType, createFunc);
 158         SysTryCatch(NID_MEDIA, r == E_SUCCESS && createFunc != null,
 159                            r = E_UNSUPPORTED_CODEC, E_UNSUPPORTED_CODEC,
 160                            "[E_UNSUPPORTED_CODEC] CreateCodecInstance Failed ");
 161
 162         pAudioDecoder = createFunc();
 163         SysTryCatch(NID_MEDIA, pAudioDecoder != null, r = GetLastResult(), GetLastResult(),
 164                            "[%s] CreateCodecInstance", GetErrorMessage(GetLastResult()));
 165         return r;
 166
 167 CATCH:
 168         return r;
 169 }
 170
 171 result
 172 _CodecFactory::CreateCodecInstance(CodecType codecType, _IAudioEncoder*& pAudioEncoder)
 173 {
 174         result r = E_SUCCESS;
 175         _AudioEncoderCreateFunc createFunc = null;
 176
 177         r = __audioEncoderRegister.GetValue(codecType, createFunc);
 178         SysTryCatch(NID_MEDIA, r == E_SUCCESS && createFunc != null,
 179                            r = E_UNSUPPORTED_CODEC, E_UNSUPPORTED_CODEC,
 180                            "[E_UNSUPPORTED_CODEC] CreateCodecInstance Failed ");
 181
 182         pAudioEncoder = createFunc();
 183         SysTryCatch(NID_MEDIA, pAudioEncoder != null, r = GetLastResult(), GetLastResult(),
 184                            "[%s] CreateCodecInstance", GetErrorMessage(GetLastResult()));
 185         return r;
 186
 187 CATCH:
 188         return r;
 189 }
 190
 191 result
 192 _CodecFactory::RegisterCodecCreateFunc(CodecType codecType, _VideoDecoderCreateFunc createFunc)
 193 {
 194         result r = E_SUCCESS;
 195
 196         r = __videoDecoderRegister.Add(codecType, createFunc);
 197         SysTryCatch(NID_MEDIA, r == E_SUCCESS, r = E_SYSTEM, E_SYSTEM,
 198                            "Codec Registration Failed ");
 199         return r;
 200
 201 CATCH:
 202         return r;
 203 }
 204
 205 result
 206 _CodecFactory::RegisterCodecCreateFunc(CodecType codecType, _VideoEncoderCreateFunc createFunc)
 207 {
 208         result r = E_SUCCESS;
 209
 210         r = __videoEncoderRegister.Add(codecType, createFunc);
 211         SysTryCatch(NID_MEDIA, r == E_SUCCESS, r = E_SYSTEM, E_SYSTEM,
 212                            "Codec Registration Failed ");
 213         return r;
 214
 215 CATCH:
 216         return r;
 217 }
 218
 219 result
 220 _CodecFactory::RegisterCodecCreateFunc(CodecType codecType, _AudioDecoderCreateFunc createFunc)
 221 {
 222         result r = E_SUCCESS;
 223
 224         r = __audioDecoderRegister.Add(codecType, createFunc);
 225         SysTryCatch(NID_MEDIA, r == E_SUCCESS, r = E_SYSTEM, E_SYSTEM,
 226                            "Codec Registration Failed ");
 227         return r;
 228
 229 CATCH:
 230         return r;
 231 }
 232
 233 result
 234 _CodecFactory::RegisterCodecCreateFunc(CodecType codecType, _AudioEncoderCreateFunc createFunc)
 235 {
 236         result r = E_SUCCESS;
 237
 238         r = __audioEncoderRegister.Add(codecType, createFunc);
 239         SysTryCatch(NID_MEDIA, r == E_SUCCESS, r = E_SYSTEM, E_SYSTEM,
 240                            "Codec Registration Failed ");
 241         return r;
 242
 243 CATCH:
 244         return r;
 245 }
 246
 247
 248 extern _IAudioDecoder* _AacDecoder_CreateInstance();
 249 extern _IAudioDecoder* _Mp3Decoder_CreateInstance();
 250 extern _IAudioDecoder* _AmrDecoder_CreateInstance();
 251 extern _IAudioDecoder* _VorbisDecoder_CreateInstance();
 252 extern _IAudioDecoder* _AlawDecoder_CreateInstance();
 253 extern _IAudioDecoder* _UlawDecoder_CreateInstance();
 254
 255 extern _IAudioEncoder* _AmrEncoder_CreateInstance();
 256 extern _IAudioEncoder* _AacEncoder_CreateInstance();
 257
 258 extern _IVideoDecoder* _H263Decoder_CreateInstance();
 259 extern _IVideoDecoder* _H264Decoder_CreateInstance();
 260 extern _IVideoDecoder* _Mpeg4Decoder_CreateInstance();
 261
 262 extern _IVideoEncoder* _H263Encoder_CreateInstance();
 263 extern _IVideoEncoder* _Mpeg4Encoder_CreateInstance();
 264
 265 result
 266 _CodecFactory::RegisterAllCodec(void)
 267 {
 268         result r = E_SUCCESS;
 269
 270         __videoDecoderRegister.Add(CODEC_H264, _H264Decoder_CreateInstance);
 271         __videoDecoderRegister.Add(CODEC_H263, _H263Decoder_CreateInstance);
 272         __videoDecoderRegister.Add(CODEC_MPEG4, _Mpeg4Decoder_CreateInstance);
 273
 274         __videoEncoderRegister.Add(CODEC_H263, _H263Encoder_CreateInstance);
 275         __videoEncoderRegister.Add(CODEC_MPEG4, _Mpeg4Encoder_CreateInstance);
 276
 277         __audioDecoderRegister.Add(CODEC_AAC, _AacDecoder_CreateInstance);
 278         __audioDecoderRegister.Add(CODEC_MP3, _Mp3Decoder_CreateInstance);
 279         __audioDecoderRegister.Add(CODEC_AMR_NB, _AmrDecoder_CreateInstance);
 280         __audioDecoderRegister.Add(CODEC_VORBIS, _VorbisDecoder_CreateInstance);
 281         __audioDecoderRegister.Add(CODEC_ALAW, _AlawDecoder_CreateInstance);
 282         __audioDecoderRegister.Add(CODEC_ULAW, _UlawDecoder_CreateInstance);
 283
 284         __audioEncoderRegister.Add(CODEC_AAC, _AacEncoder_CreateInstance);
 285         __audioEncoderRegister.Add(CODEC_AMR_NB, _AmrEncoder_CreateInstance);
 286
 287         return r;
 288 }
 289
 290 Tizen::Base::Collection::IListT<CodecType>*
 291 _CodecFactory::GetSupportedAudioDecoderListN(void)
 292 {
 293         IListT<CodecType> *pList = null;
 294
 295         pList = __audioDecoderRegister.GetKeysN();
 296         SysTryReturn(NID_MEDIA, pList != null, null, E_OUT_OF_MEMORY,
 297                                 "[%s] Propagated.", GetErrorMessage(GetLastResult()));
 298         SetLastResult(E_SUCCESS);
 299         return pList;
 300 }
 301
 302 Tizen::Base::Collection::IListT<CodecType>*
 303 _CodecFactory::GetSupportedAudioEncoderListN(void)
 304 {
 305         IListT<CodecType> *pList = null;
 306
 307         pList = __audioEncoderRegister.GetKeysN();
 308         SysTryReturn(NID_MEDIA, pList != null, null, E_OUT_OF_MEMORY,
 309                                 "[%s] Propagated.", GetErrorMessage(GetLastResult()));
 310         SetLastResult(E_SUCCESS);
 311         return pList;
 312 }
 313
 314 Tizen::Base::Collection::IListT<CodecType>*
 315 _CodecFactory::GetSupportedVideoDecoderListN(void)
 316 {
 317         IListT<CodecType> *pList = null;
 318
 319         pList = __videoDecoderRegister.GetKeysN();
 320         SysTryReturn(NID_MEDIA, pList != null, null, E_OUT_OF_MEMORY,
 321                                 "[%s] Propagated.", GetErrorMessage(GetLastResult()));
 322         SetLastResult(E_SUCCESS);
 323         return pList;
 324 }
 325
 326 Tizen::Base::Collection::IListT<CodecType>*
 327 _CodecFactory::GetSupportedVideoEncoderListN(void)
 328 {
 329         IListT<CodecType> *pList = __videoEncoderRegister.GetKeysN();
 330
 331         SysTryReturn(NID_MEDIA, pList != null, null, E_OUT_OF_MEMORY,
 332                                 "[%s] Propagated.", GetErrorMessage(GetLastResult()));
 333         SetLastResult(E_SUCCESS);
 334         return pList;
 335 }
 336
 337 }} // Tizen::Media