FreeRDP
Loading...
Searching...
No Matches
h264_openh264.c
1
21#include <freerdp/config.h>
22
23#include <winpr/winpr.h>
24#include <winpr/library.h>
25#include <winpr/assert.h>
26#include <winpr/cast.h>
27
28#include <freerdp/log.h>
29#include <freerdp/codec/h264.h>
30
31#include <wels/codec_def.h>
32#include <wels/codec_api.h>
33#include <wels/codec_ver.h>
34
35#include "h264.h"
36
37typedef void (*pWelsGetCodecVersionEx)(OpenH264Version* pVersion);
38
39typedef long (*pWelsCreateDecoder)(ISVCDecoder** ppDecoder);
40typedef void (*pWelsDestroyDecoder)(ISVCDecoder* pDecoder);
41
42typedef int (*pWelsCreateSVCEncoder)(ISVCEncoder** ppEncoder);
43typedef void (*pWelsDestroySVCEncoder)(ISVCEncoder* pEncoder);
44
45typedef struct
46{
47#if defined(WITH_OPENH264_LOADING)
48 HMODULE lib;
49 OpenH264Version version;
50#endif
51 pWelsGetCodecVersionEx WelsGetCodecVersionEx;
52 WINPR_ATTR_NODISCARD pWelsCreateDecoder WelsCreateDecoder;
53 pWelsDestroyDecoder WelsDestroyDecoder;
54 WINPR_ATTR_NODISCARD pWelsCreateSVCEncoder WelsCreateSVCEncoder;
55 pWelsDestroySVCEncoder WelsDestroySVCEncoder;
56 ISVCDecoder* pDecoder;
57 ISVCEncoder* pEncoder;
58 SEncParamExt EncParamExt;
59} H264_CONTEXT_OPENH264;
60
61#if defined(WITH_OPENH264_LOADING)
62static const char* openh264_library_names[] = {
63#if defined(_WIN32)
64 "openh264.dll"
65#elif defined(__APPLE__)
66 "libopenh264.dylib"
67#else
68 "libopenh264.so.8", "libopenh264.so.2.6.0", "libopenh264.so.7",
69 "libopenh264.so.2.5.0", "libopenh264.so.2.4.1", "libopenh264.so.2.4.0",
70 "libopenh264.so.2.3.1", "libopenh264.so.2.3.0", "libopenh264.so",
71
72#endif
73};
74#endif
75
76static void openh264_trace_callback(void* ctx, int level, const char* message)
77{
78 H264_CONTEXT* h264 = ctx;
79 if (h264)
80 WLog_Print(h264->log, WLOG_TRACE, "%d - %s", level, message);
81}
82
83static int openh264_decompress(H264_CONTEXT* WINPR_RESTRICT h264,
84 const BYTE* WINPR_RESTRICT pSrcData, UINT32 SrcSize)
85{
86 DECODING_STATE state = dsInvalidArgument;
87 SBufferInfo sBufferInfo = WINPR_C_ARRAY_INIT;
88 SSysMEMBuffer* pSystemBuffer = nullptr;
89 H264_CONTEXT_OPENH264* sys = nullptr;
90 UINT32* iStride = nullptr;
91 BYTE** pYUVData = nullptr;
92
93 WINPR_ASSERT(h264);
94 WINPR_ASSERT(pSrcData || (SrcSize == 0));
95
96 sys = (H264_CONTEXT_OPENH264*)h264->pSystemData;
97 WINPR_ASSERT(sys);
98
99 iStride = h264->iStride;
100 WINPR_ASSERT(iStride);
101
102 pYUVData = h264->pYUVData;
103 WINPR_ASSERT(pYUVData);
104
105 if (!sys->pDecoder)
106 return -2001;
107
108 /* DecodeFrame2 takes the size as int */
109 if (SrcSize > INT32_MAX)
110 {
111 WLog_Print(h264->log, WLOG_WARN, "SrcSize %" PRIu32 " exceeds INT32_MAX", SrcSize);
112 return -2007;
113 }
114
115 /*
116 * Decompress the image. The RDP host only seems to send I420 format.
117 */
118 pYUVData[0] = nullptr;
119 pYUVData[1] = nullptr;
120 pYUVData[2] = nullptr;
121
122 WINPR_ASSERT(sys->pDecoder);
123 state = (*sys->pDecoder)
124 ->DecodeFrame2(sys->pDecoder, pSrcData, WINPR_ASSERTING_INT_CAST(int, SrcSize),
125 pYUVData, &sBufferInfo);
126
127 if (sBufferInfo.iBufferStatus != 1)
128 {
129 if (state == dsNoParamSets)
130 {
131 /* this happens on the first frame due to missing parameter sets */
132 state =
133 (*sys->pDecoder)->DecodeFrame2(sys->pDecoder, nullptr, 0, pYUVData, &sBufferInfo);
134 }
135 else if (state == dsErrorFree)
136 {
137 /* call DecodeFrame2 again to decode without delay */
138 state =
139 (*sys->pDecoder)->DecodeFrame2(sys->pDecoder, nullptr, 0, pYUVData, &sBufferInfo);
140 }
141 else
142 {
143 WLog_Print(h264->log, WLOG_WARN, "DecodeFrame2 state: 0x%04X iBufferStatus: %d", state,
144 sBufferInfo.iBufferStatus);
145 return -2002;
146 }
147 }
148
149 if (state != dsErrorFree)
150 {
151 WLog_Print(h264->log, WLOG_WARN, "DecodeFrame2 state: 0x%02X", state);
152 return -2003;
153 }
154
155#if OPENH264_MAJOR >= 2
156 state = (*sys->pDecoder)->FlushFrame(sys->pDecoder, pYUVData, &sBufferInfo);
157 if (state != dsErrorFree)
158 {
159 WLog_Print(h264->log, WLOG_WARN, "FlushFrame state: 0x%02X", state);
160 return -2003;
161 }
162#endif
163
164 pSystemBuffer = &sBufferInfo.UsrData.sSystemBuffer;
165 iStride[0] = WINPR_ASSERTING_INT_CAST(uint32_t, pSystemBuffer->iStride[0]);
166 iStride[1] = WINPR_ASSERTING_INT_CAST(uint32_t, pSystemBuffer->iStride[1]);
167 iStride[2] = WINPR_ASSERTING_INT_CAST(uint32_t, pSystemBuffer->iStride[1]);
168
169 if (sBufferInfo.iBufferStatus != 1)
170 {
171 WLog_Print(h264->log, WLOG_WARN, "DecodeFrame2 iBufferStatus: %d",
172 sBufferInfo.iBufferStatus);
173 return 0;
174 }
175
176 if (state != dsErrorFree)
177 {
178 WLog_Print(h264->log, WLOG_WARN, "DecodeFrame2 state: 0x%02X", state);
179 return -2003;
180 }
181
182 if (pSystemBuffer->iFormat != videoFormatI420)
183 return -2004;
184
185 if (!pYUVData[0] || !pYUVData[1] || !pYUVData[2])
186 return -2005;
187
188 if ((pSystemBuffer->iWidth <= 0) || (pSystemBuffer->iHeight <= 0))
189 return -2006;
190
191 h264->YUVWidth = WINPR_ASSERTING_INT_CAST(UINT32, pSystemBuffer->iWidth);
192 h264->YUVHeight = WINPR_ASSERTING_INT_CAST(UINT32, pSystemBuffer->iHeight);
193
194 return 1;
195}
196
197static int openh264_compress(H264_CONTEXT* WINPR_RESTRICT h264,
198 const BYTE** WINPR_RESTRICT pYUVData,
199 const UINT32* WINPR_RESTRICT iStride, BYTE** WINPR_RESTRICT ppDstData,
200 UINT32* WINPR_RESTRICT pDstSize)
201{
202 int status = 0;
203 SFrameBSInfo info = WINPR_C_ARRAY_INIT;
204 SSourcePicture pic = WINPR_C_ARRAY_INIT;
205
206 H264_CONTEXT_OPENH264* sys = nullptr;
207
208 WINPR_ASSERT(h264);
209 WINPR_ASSERT(pYUVData);
210 WINPR_ASSERT(iStride);
211 WINPR_ASSERT(ppDstData);
212 WINPR_ASSERT(pDstSize);
213
214 sys = &((H264_CONTEXT_OPENH264*)h264->pSystemData)[0];
215 WINPR_ASSERT(sys);
216
217 if (!sys->pEncoder)
218 return -1;
219
220 if (!pYUVData[0] || !pYUVData[1] || !pYUVData[2])
221 return -1;
222
223 if ((h264->width > INT_MAX) || (h264->height > INT_MAX))
224 return -1;
225
226 if ((h264->FrameRate > INT_MAX) || (h264->NumberOfThreads > INT_MAX) ||
227 (h264->BitRate > INT_MAX) || (h264->QP > INT_MAX))
228 return -1;
229
230 WINPR_ASSERT(sys->pEncoder);
231 if ((sys->EncParamExt.iPicWidth != (int)h264->width) ||
232 (sys->EncParamExt.iPicHeight != (int)h264->height))
233 {
234 WINPR_ASSERT((*sys->pEncoder)->GetDefaultParams);
235 status = (*sys->pEncoder)->GetDefaultParams(sys->pEncoder, &sys->EncParamExt);
236
237 if (status != cmResultSuccess)
238 {
239 WLog_Print(h264->log, WLOG_ERROR,
240 "Failed to get OpenH264 default parameters (status=%d)", status);
241 return status > 0 ? -status : status;
242 }
243
244 EUsageType usageType = SCREEN_CONTENT_REAL_TIME;
245
246 switch (h264->UsageType)
247 {
248 case H264_CAMERA_VIDEO_NON_REAL_TIME:
249 usageType = CAMERA_VIDEO_NON_REAL_TIME;
250 break;
251 case H264_CAMERA_VIDEO_REAL_TIME:
252 usageType = CAMERA_VIDEO_REAL_TIME;
253 break;
254 case H264_SCREEN_CONTENT_NON_REAL_TIME:
255 usageType = SCREEN_CONTENT_NON_REAL_TIME;
256 break;
257 case H264_SCREEN_CONTENT_REAL_TIME:
258 default:
259 break;
260 }
261
262 sys->EncParamExt.iUsageType = usageType;
263 sys->EncParamExt.iPicWidth = WINPR_ASSERTING_INT_CAST(int, h264->width);
264 sys->EncParamExt.iPicHeight = WINPR_ASSERTING_INT_CAST(int, h264->height);
265 sys->EncParamExt.fMaxFrameRate = WINPR_ASSERTING_INT_CAST(short, h264->FrameRate);
266 sys->EncParamExt.iMaxBitrate = UNSPECIFIED_BIT_RATE;
267 sys->EncParamExt.bEnableDenoise = 0;
268 sys->EncParamExt.bEnableLongTermReference = 0;
269 sys->EncParamExt.iSpatialLayerNum = 1;
270 sys->EncParamExt.iMultipleThreadIdc =
271 WINPR_ASSERTING_INT_CAST(unsigned short, h264->NumberOfThreads);
272 sys->EncParamExt.sSpatialLayers[0].fFrameRate =
273 WINPR_ASSERTING_INT_CAST(short, h264->FrameRate);
274 sys->EncParamExt.sSpatialLayers[0].iVideoWidth = sys->EncParamExt.iPicWidth;
275 sys->EncParamExt.sSpatialLayers[0].iVideoHeight = sys->EncParamExt.iPicHeight;
276 sys->EncParamExt.sSpatialLayers[0].iMaxSpatialBitrate = sys->EncParamExt.iMaxBitrate;
277
278 switch (h264->RateControlMode)
279 {
280 case H264_RATECONTROL_VBR:
281 sys->EncParamExt.iRCMode = RC_BITRATE_MODE;
282 sys->EncParamExt.iTargetBitrate = (int)h264->BitRate;
283 sys->EncParamExt.sSpatialLayers[0].iSpatialBitrate =
284 sys->EncParamExt.iTargetBitrate;
285 sys->EncParamExt.bEnableFrameSkip = 1;
286 break;
287
288 case H264_RATECONTROL_CQP:
289 sys->EncParamExt.iRCMode = RC_OFF_MODE;
290 sys->EncParamExt.sSpatialLayers[0].iDLayerQp = (int)h264->QP;
291 sys->EncParamExt.bEnableFrameSkip = 0;
292 break;
293 default:
294 break;
295 }
296
297 if (sys->EncParamExt.iMultipleThreadIdc > 1)
298 {
299#if (OPENH264_MAJOR == 1) && (OPENH264_MINOR <= 5)
300 sys->EncParamExt.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_AUTO_SLICE;
301#else
302 sys->EncParamExt.sSpatialLayers[0].sSliceArgument.uiSliceMode = SM_FIXEDSLCNUM_SLICE;
303#endif
304 }
305
306 WINPR_ASSERT((*sys->pEncoder)->InitializeExt);
307 status = (*sys->pEncoder)->InitializeExt(sys->pEncoder, &sys->EncParamExt);
308
309 if (status != cmResultSuccess)
310 {
311 WLog_Print(h264->log, WLOG_ERROR, "Failed to initialize OpenH264 encoder (status=%d)",
312 status);
313 return status > 0 ? -status : status;
314 }
315
316 WINPR_ASSERT((*sys->pEncoder)->GetOption);
317 status =
318 (*sys->pEncoder)
319 ->GetOption(sys->pEncoder, ENCODER_OPTION_SVC_ENCODE_PARAM_EXT, &sys->EncParamExt);
320
321 if (status != cmResultSuccess)
322 {
323 WLog_Print(h264->log, WLOG_ERROR,
324 "Failed to get initial OpenH264 encoder parameters (status=%d)", status);
325 return status > 0 ? -status : status;
326 }
327 }
328 else
329 {
330 switch (h264->RateControlMode)
331 {
332 case H264_RATECONTROL_VBR:
333 if (sys->EncParamExt.iTargetBitrate != (int)h264->BitRate)
334 {
335 SBitrateInfo bitrate = WINPR_C_ARRAY_INIT;
336
337 sys->EncParamExt.iTargetBitrate = (int)h264->BitRate;
338 bitrate.iLayer = SPATIAL_LAYER_ALL;
339 bitrate.iBitrate = (int)h264->BitRate;
340
341 WINPR_ASSERT((*sys->pEncoder)->SetOption);
342 status = (*sys->pEncoder)
343 ->SetOption(sys->pEncoder, ENCODER_OPTION_BITRATE, &bitrate);
344
345 if (status != cmResultSuccess)
346 {
347 WLog_Print(h264->log, WLOG_ERROR,
348 "Failed to set encoder bitrate (status=%d)", status);
349 return status > 0 ? -status : status;
350 }
351 }
352
353 if ((uint32_t)sys->EncParamExt.fMaxFrameRate != h264->FrameRate)
354 {
355 sys->EncParamExt.fMaxFrameRate =
356 WINPR_ASSERTING_INT_CAST(float, h264->FrameRate);
357
358 WINPR_ASSERT((*sys->pEncoder)->SetOption);
359 status = (*sys->pEncoder)
360 ->SetOption(sys->pEncoder, ENCODER_OPTION_FRAME_RATE,
361 &sys->EncParamExt.fMaxFrameRate);
362
363 if (status != cmResultSuccess)
364 {
365 WLog_Print(h264->log, WLOG_ERROR,
366 "Failed to set encoder framerate (status=%d)", status);
367 return status > 0 ? -status : status;
368 }
369 }
370
371 break;
372
373 case H264_RATECONTROL_CQP:
374 if (sys->EncParamExt.sSpatialLayers[0].iDLayerQp != (int)h264->QP)
375 {
376 sys->EncParamExt.sSpatialLayers[0].iDLayerQp = (int)h264->QP;
377
378 WINPR_ASSERT((*sys->pEncoder)->SetOption);
379 status = (*sys->pEncoder)
380 ->SetOption(sys->pEncoder, ENCODER_OPTION_SVC_ENCODE_PARAM_EXT,
381 &sys->EncParamExt);
382
383 if (status != cmResultSuccess)
384 {
385 WLog_Print(h264->log, WLOG_ERROR,
386 "Failed to set encoder parameters (status=%d)", status);
387 return status > 0 ? -status : status;
388 }
389 }
390
391 break;
392 default:
393 break;
394 }
395 }
396
397 pic.iPicWidth = (int)h264->width;
398 pic.iPicHeight = (int)h264->height;
399 pic.iColorFormat = videoFormatI420;
400 pic.iStride[0] = (int)iStride[0];
401 pic.iStride[1] = (int)iStride[1];
402 pic.iStride[2] = (int)iStride[2];
403 pic.pData[0] = WINPR_CAST_CONST_PTR_AWAY(pYUVData[0], BYTE*);
404 pic.pData[1] = WINPR_CAST_CONST_PTR_AWAY(pYUVData[1], BYTE*);
405 pic.pData[2] = WINPR_CAST_CONST_PTR_AWAY(pYUVData[2], BYTE*);
406
407 WINPR_ASSERT((*sys->pEncoder)->EncodeFrame);
408 status = (*sys->pEncoder)->EncodeFrame(sys->pEncoder, &pic, &info);
409
410 if (status != cmResultSuccess)
411 {
412 WLog_Print(h264->log, WLOG_ERROR, "Failed to encode frame (status=%d)", status);
413 return status > 0 ? -status : status;
414 }
415
416 *ppDstData = info.sLayerInfo[0].pBsBuf;
417 *pDstSize = 0;
418
419 for (int i = 0; i < info.iLayerNum; i++)
420 {
421 for (int j = 0; j < info.sLayerInfo[i].iNalCount; j++)
422 {
423 const int val = info.sLayerInfo[i].pNalLengthInByte[j];
424 *pDstSize += WINPR_ASSERTING_INT_CAST(uint32_t, val);
425 }
426 }
427
428 return 1;
429}
430
431static void openh264_uninit(H264_CONTEXT* h264)
432{
433 H264_CONTEXT_OPENH264* sysContexts = nullptr;
434
435 WINPR_ASSERT(h264);
436
437 sysContexts = (H264_CONTEXT_OPENH264*)h264->pSystemData;
438
439 if (sysContexts)
440 {
441 for (UINT32 x = 0; x < h264->numSystemData; x++)
442 {
443 H264_CONTEXT_OPENH264* sys = &sysContexts[x];
444
445 if (sys->pDecoder)
446 {
447 (*sys->pDecoder)->Uninitialize(sys->pDecoder);
448 sysContexts->WelsDestroyDecoder(sys->pDecoder);
449 sys->pDecoder = nullptr;
450 }
451
452 if (sys->pEncoder)
453 {
454 (*sys->pEncoder)->Uninitialize(sys->pEncoder);
455 sysContexts->WelsDestroySVCEncoder(sys->pEncoder);
456 sys->pEncoder = nullptr;
457 }
458 }
459
460#if defined(WITH_OPENH264_LOADING)
461 if (sysContexts->lib)
462 FreeLibrary(sysContexts->lib);
463#endif
464 free(h264->pSystemData);
465 h264->pSystemData = nullptr;
466 }
467}
468
469#if defined(WITH_OPENH264_LOADING)
470static BOOL openh264_load_functionpointers(H264_CONTEXT* h264, const char* name)
471{
472 H264_CONTEXT_OPENH264* sysContexts;
473
474 WINPR_ASSERT(name);
475
476 if (!h264)
477 return FALSE;
478
479 sysContexts = h264->pSystemData;
480
481 if (!sysContexts)
482 return FALSE;
483
484 sysContexts->lib = LoadLibraryA(name);
485
486 if (!sysContexts->lib)
487 return FALSE;
488
489 sysContexts->WelsGetCodecVersionEx =
490 GetProcAddressAs(sysContexts->lib, "WelsGetCodecVersionEx", pWelsGetCodecVersionEx);
491 sysContexts->WelsCreateDecoder =
492 GetProcAddressAs(sysContexts->lib, "WelsCreateDecoder", pWelsCreateDecoder);
493 sysContexts->WelsDestroyDecoder =
494 GetProcAddressAs(sysContexts->lib, "WelsDestroyDecoder", pWelsDestroyDecoder);
495 sysContexts->WelsCreateSVCEncoder =
496 GetProcAddressAs(sysContexts->lib, "WelsCreateSVCEncoder", pWelsCreateSVCEncoder);
497 sysContexts->WelsDestroySVCEncoder =
498 GetProcAddressAs(sysContexts->lib, "WelsDestroySVCEncoder", pWelsDestroySVCEncoder);
499
500 if (!sysContexts->WelsCreateDecoder || !sysContexts->WelsDestroyDecoder ||
501 !sysContexts->WelsCreateSVCEncoder || !sysContexts->WelsDestroySVCEncoder ||
502 !sysContexts->WelsGetCodecVersionEx)
503 {
504 FreeLibrary(sysContexts->lib);
505 sysContexts->lib = nullptr;
506 return FALSE;
507 }
508
509 sysContexts->WelsGetCodecVersionEx(&sysContexts->version);
510 WLog_Print(h264->log, WLOG_DEBUG, "loaded %s %u.%u.%u", name, sysContexts->version.uMajor,
511 sysContexts->version.uMinor, sysContexts->version.uRevision);
512
513 if ((sysContexts->version.uMajor < 1) ||
514 ((sysContexts->version.uMajor == 1) && (sysContexts->version.uMinor < 6)))
515 {
516 WLog_Print(
517 h264->log, WLOG_ERROR,
518 "OpenH264 %s %u.%u.%u is too old, need at least version 1.6.0 for dynamic loading",
519 name, sysContexts->version.uMajor, sysContexts->version.uMinor,
520 sysContexts->version.uRevision);
521 FreeLibrary(sysContexts->lib);
522 sysContexts->lib = nullptr;
523 return FALSE;
524 }
525
526 return TRUE;
527}
528#endif
529
530static BOOL openh264_init(H264_CONTEXT* h264)
531{
532#if defined(WITH_OPENH264_LOADING)
533 BOOL success = FALSE;
534#endif
535 long status = 0;
536 H264_CONTEXT_OPENH264* sysContexts = nullptr;
537 static int traceLevel = WELS_LOG_DEBUG;
538#if (OPENH264_MAJOR == 1) && (OPENH264_MINOR <= 5)
539 static EVideoFormatType videoFormat = videoFormatI420;
540#endif
541 static WelsTraceCallback traceCallback = openh264_trace_callback;
542
543 WINPR_ASSERT(h264);
544
545 h264->numSystemData = 1;
546 sysContexts =
547 (H264_CONTEXT_OPENH264*)calloc(h264->numSystemData, sizeof(H264_CONTEXT_OPENH264));
548
549 if (!sysContexts)
550 goto EXCEPTION;
551
552 h264->pSystemData = (void*)sysContexts;
553#if defined(WITH_OPENH264_LOADING)
554
555 for (size_t i = 0; i < ARRAYSIZE(openh264_library_names); i++)
556 {
557 const char* current = openh264_library_names[i];
558 success = openh264_load_functionpointers(h264, current);
559
560 if (success)
561 break;
562 }
563
564 if (!success)
565 goto EXCEPTION;
566
567#else
568 sysContexts->WelsGetCodecVersionEx = WelsGetCodecVersionEx;
569 sysContexts->WelsCreateDecoder = WelsCreateDecoder;
570 sysContexts->WelsDestroyDecoder = WelsDestroyDecoder;
571 sysContexts->WelsCreateSVCEncoder = WelsCreateSVCEncoder;
572 sysContexts->WelsDestroySVCEncoder = WelsDestroySVCEncoder;
573#endif
574
575 for (UINT32 x = 0; x < h264->numSystemData; x++)
576 {
577 SDecodingParam sDecParam = WINPR_C_ARRAY_INIT;
578 H264_CONTEXT_OPENH264* sys = &sysContexts[x];
579
580 if (h264->Compressor)
581 {
582#if defined(WITH_OPENH264_LOADING)
583 if (sysContexts->version.uMajor != OPENH264_MAJOR ||
584 sysContexts->version.uMinor != OPENH264_MINOR)
585 {
586 WLog_Print(h264->log, WLOG_WARN,
587 "OpenH264 encoder ABI mismatch: runtime %d.%d.%d vs compiled %d.%d.%d",
588 sysContexts->version.uMajor, sysContexts->version.uMinor,
589 sysContexts->version.uRevision, OPENH264_MAJOR, OPENH264_MINOR,
590 OPENH264_REVISION);
591 goto EXCEPTION;
592 }
593#endif
594 const int rc = sysContexts->WelsCreateSVCEncoder(&sys->pEncoder);
595 if (rc != 0)
596 {
597 WLog_Print(h264->log, WLOG_ERROR, "Failed to create OpenH264 encoder: %d", rc);
598 goto EXCEPTION;
599 }
600 if (!sys->pEncoder)
601 {
602 WLog_Print(h264->log, WLOG_ERROR, "Failed to create OpenH264 encoder");
603 goto EXCEPTION;
604 }
605 }
606 else
607 {
608 const long rc = sysContexts->WelsCreateDecoder(&sys->pDecoder);
609 if (rc != 0)
610 {
611 WLog_Print(h264->log, WLOG_ERROR, "Failed to create OpenH264 decoder: %ld", rc);
612 goto EXCEPTION;
613 }
614 if (!sys->pDecoder)
615 {
616 WLog_Print(h264->log, WLOG_ERROR, "Failed to create OpenH264 decoder");
617 goto EXCEPTION;
618 }
619
620#if (OPENH264_MAJOR == 1) && (OPENH264_MINOR <= 5)
621 sDecParam.eOutputColorFormat = videoFormatI420;
622#endif
623 sDecParam.eEcActiveIdc = ERROR_CON_FRAME_COPY;
624 sDecParam.sVideoProperty.eVideoBsType = VIDEO_BITSTREAM_AVC;
625 status = (*sys->pDecoder)->Initialize(sys->pDecoder, &sDecParam);
626
627 if (status != 0)
628 {
629 WLog_Print(h264->log, WLOG_ERROR,
630 "Failed to initialize OpenH264 decoder (status=%ld)", status);
631 goto EXCEPTION;
632 }
633
634#if (OPENH264_MAJOR == 1) && (OPENH264_MINOR <= 5)
635 status =
636 (*sys->pDecoder)->SetOption(sys->pDecoder, DECODER_OPTION_DATAFORMAT, &videoFormat);
637#endif
638
639 if (status != 0)
640 {
641 WLog_Print(h264->log, WLOG_ERROR,
642 "Failed to set data format option on OpenH264 decoder (status=%ld)",
643 status);
644 goto EXCEPTION;
645 }
646
647 if (WLog_GetLogLevel(h264->log) == WLOG_TRACE)
648 {
649 status = (*sys->pDecoder)
650 ->SetOption(sys->pDecoder, DECODER_OPTION_TRACE_LEVEL, &traceLevel);
651
652 if (status != 0)
653 {
654 WLog_Print(h264->log, WLOG_ERROR,
655 "Failed to set trace level option on OpenH264 decoder (status=%ld)",
656 status);
657 goto EXCEPTION;
658 }
659
660 status = (*sys->pDecoder)
661 ->SetOption(sys->pDecoder, DECODER_OPTION_TRACE_CALLBACK_CONTEXT,
662 (void*)&h264);
663
664 if (status != 0)
665 {
666 WLog_Print(h264->log, WLOG_ERROR,
667 "Failed to set trace callback context option on OpenH264 decoder "
668 "(status=%ld)",
669 status);
670 goto EXCEPTION;
671 }
672
673 status = (*sys->pDecoder)
674 ->SetOption(sys->pDecoder, DECODER_OPTION_TRACE_CALLBACK,
675 (void*)&traceCallback);
676
677 if (status != 0)
678 {
679 WLog_Print(
680 h264->log, WLOG_ERROR,
681 "Failed to set trace callback option on OpenH264 decoder (status=%ld)",
682 status);
683 goto EXCEPTION;
684 }
685 }
686 }
687 }
688
689 h264->hwAccel = FALSE; /* not supported */
690 return TRUE;
691EXCEPTION:
692 openh264_uninit(h264);
693 return FALSE;
694}
695
696const H264_CONTEXT_SUBSYSTEM g_Subsystem_OpenH264 = { "OpenH264", openh264_init, openh264_uninit,
697 openh264_decompress, openh264_compress };