FreeRDP
Loading...
Searching...
No Matches
h264.c
1
21#include <freerdp/config.h>
22
23#include <winpr/crt.h>
24#include <winpr/print.h>
25#include <winpr/library.h>
26#include <winpr/bitstream.h>
27#include <winpr/synch.h>
28
29#include <freerdp/primitives.h>
30#include <freerdp/codec/h264.h>
31#include <freerdp/codec/yuv.h>
32#include <freerdp/log.h>
33
34#include "h264.h"
35
36#define TAG FREERDP_TAG("codec")
37
38static BOOL avc444_ensure_buffer(H264_CONTEXT* h264, DWORD nDstHeight);
39
40static BOOL yuv_ensure_buffer(H264_CONTEXT* h264, UINT32 stride, UINT32 width, UINT32 height)
41{
42 BOOL isNull = FALSE;
43 UINT32 pheight = height;
44
45 if (!h264)
46 return FALSE;
47
48 if (stride == 0)
49 stride = width;
50
51 if (stride % 16 != 0)
52 stride += 16 - stride % 16;
53
54 if (pheight % 16 != 0)
55 pheight += 16 - pheight % 16;
56
57 const size_t nPlanes = h264->hwAccel ? 2 : 3;
58
59 for (size_t x = 0; x < nPlanes; x++)
60 {
61 if (!h264->pYUVData[x] || !h264->pOldYUVData[x])
62 isNull = TRUE;
63 }
64
65 if (pheight == 0)
66 return FALSE;
67 if (stride == 0)
68 return FALSE;
69
70 if (isNull || (width != h264->width) || (height != h264->height) ||
71 (stride != h264->iStride[0]))
72 {
73 if (h264->hwAccel) /* NV12 */
74 {
75 h264->iStride[0] = stride;
76 h264->iStride[1] = stride;
77 h264->iStride[2] = 0;
78 }
79 else /* I420 */
80 {
81 h264->iStride[0] = stride;
82 h264->iStride[1] = (stride + 1) / 2;
83 h264->iStride[2] = (stride + 1) / 2;
84 }
85
86 h264->width = width;
87 h264->height = height;
88
89 for (size_t x = 0; x < nPlanes; x++)
90 {
91 BYTE* tmp1 = winpr_aligned_recalloc(h264->pYUVData[x], h264->iStride[x], pheight, 16);
92 BYTE* tmp2 =
93 winpr_aligned_recalloc(h264->pOldYUVData[x], h264->iStride[x], pheight, 16);
94 if (tmp1)
95 h264->pYUVData[x] = tmp1;
96 if (tmp2)
97 h264->pOldYUVData[x] = tmp2;
98 if (!tmp1 || !tmp2)
99 return FALSE;
100 }
101 }
102
103 return TRUE;
104}
105
106BOOL avc420_ensure_buffer(H264_CONTEXT* h264, UINT32 stride, UINT32 width, UINT32 height)
107{
108 return yuv_ensure_buffer(h264, stride, width, height);
109}
110
111INT32 avc420_decompress(H264_CONTEXT* h264, const BYTE* pSrcData, UINT32 SrcSize, BYTE* pDstData,
112 DWORD DstFormat, UINT32 nDstStep, WINPR_ATTR_UNUSED UINT32 nDstWidth,
113 WINPR_ATTR_UNUSED UINT32 nDstHeight, const RECTANGLE_16* regionRects,
114 UINT32 numRegionRects)
115{
116 int status = 0;
117 const BYTE* pYUVData[3];
118
119 if (!h264 || h264->Compressor)
120 return -1001;
121
122 status = h264->subsystem->Decompress(h264, pSrcData, SrcSize);
123
124 if (status == 0)
125 return 1;
126
127 if (status < 0)
128 return status;
129
130 pYUVData[0] = h264->pYUVData[0];
131 pYUVData[1] = h264->pYUVData[1];
132 pYUVData[2] = h264->pYUVData[2];
133 if (!yuv420_context_decode(h264->yuv, pYUVData, h264->iStride, h264->height, DstFormat,
134 pDstData, nDstStep, regionRects, numRegionRects))
135 return -1002;
136
137 return 1;
138}
139
140static BOOL allocate_h264_metablock(UINT32 QP, RECTANGLE_16* rectangles,
141 RDPGFX_H264_METABLOCK* meta, size_t count)
142{
143 /* [MS-RDPEGFX] 2.2.4.4.2 RDPGFX_AVC420_QUANT_QUALITY */
144 if (!meta || (QP > UINT8_MAX))
145 {
146 free(rectangles);
147 return FALSE;
148 }
149
150 meta->regionRects = rectangles;
151 if (count == 0)
152 return TRUE;
153
154 if (count > UINT32_MAX)
155 return FALSE;
156
157 meta->quantQualityVals = calloc(count, sizeof(RDPGFX_H264_QUANT_QUALITY));
158
159 if (!meta->quantQualityVals || !meta->regionRects)
160 return FALSE;
161 meta->numRegionRects = (UINT32)count;
162 for (size_t x = 0; x < count; x++)
163 {
164 RDPGFX_H264_QUANT_QUALITY* cur = &meta->quantQualityVals[x];
165 cur->qp = (UINT8)QP;
166
167 /* qpVal bit 6 and 7 are flags, so mask them out here.
168 * qualityVal is [0-100] so 100 - qpVal [0-64] is always in range */
169 cur->qualityVal = 100 - (QP & 0x3F);
170 }
171 return TRUE;
172}
173
174static inline BOOL diff_tile(const RECTANGLE_16* regionRect, BYTE* pYUVData[3],
175 BYTE* pOldYUVData[3], UINT32 const iStride[3])
176{
177 size_t size = 0;
178
179 if (!regionRect || !pYUVData || !pOldYUVData || !iStride)
180 return FALSE;
181 size = regionRect->right - regionRect->left;
182 if (regionRect->right > iStride[0])
183 return FALSE;
184 if (regionRect->right / 2u > iStride[1])
185 return FALSE;
186 if (regionRect->right / 2u > iStride[2])
187 return FALSE;
188
189 for (size_t y = regionRect->top; y < regionRect->bottom; y++)
190 {
191 const BYTE* cur0 = &pYUVData[0][y * iStride[0]];
192 const BYTE* cur1 = &pYUVData[1][y * iStride[1]];
193 const BYTE* cur2 = &pYUVData[2][y * iStride[2]];
194 const BYTE* old0 = &pOldYUVData[0][y * iStride[0]];
195 const BYTE* old1 = &pOldYUVData[1][y * iStride[1]];
196 const BYTE* old2 = &pOldYUVData[2][y * iStride[2]];
197
198 if (memcmp(&cur0[regionRect->left], &old0[regionRect->left], size) != 0)
199 return TRUE;
200 if (memcmp(&cur1[regionRect->left / 2], &old1[regionRect->left / 2], size / 2) != 0)
201 return TRUE;
202 if (memcmp(&cur2[regionRect->left / 2], &old2[regionRect->left / 2], size / 2) != 0)
203 return TRUE;
204 }
205 return FALSE;
206}
207
208static BOOL detect_changes(BOOL firstFrameDone, const UINT32 QP, const RECTANGLE_16* regionRect,
209 BYTE* pYUVData[3], BYTE* pOldYUVData[3], UINT32 const iStride[3],
210 RDPGFX_H264_METABLOCK* meta)
211{
212 size_t count = 0;
213 size_t wc = 0;
214 size_t hc = 0;
215 RECTANGLE_16* rectangles = nullptr;
216
217 if (!regionRect || !pYUVData || !pOldYUVData || !iStride || !meta)
218 return FALSE;
219
220 wc = (regionRect->right - regionRect->left) / 64 + 1;
221 hc = (regionRect->bottom - regionRect->top) / 64 + 1;
222 rectangles = calloc(wc * hc, sizeof(RECTANGLE_16));
223 if (!rectangles)
224 return FALSE;
225 if (!firstFrameDone)
226 {
227 rectangles[0] = *regionRect;
228 count = 1;
229 }
230 else
231 {
232 for (size_t y = regionRect->top; y < regionRect->bottom; y += 64)
233 {
234 for (size_t x = regionRect->left; x < regionRect->right; x += 64)
235 {
236 RECTANGLE_16 rect;
237 rect.left = (UINT16)MIN(UINT16_MAX, regionRect->left + x);
238 rect.top = (UINT16)MIN(UINT16_MAX, regionRect->top + y);
239 rect.right =
240 (UINT16)MIN(UINT16_MAX, MIN(regionRect->left + x + 64, regionRect->right));
241 rect.bottom =
242 (UINT16)MIN(UINT16_MAX, MIN(regionRect->top + y + 64, regionRect->bottom));
243 if (diff_tile(&rect, pYUVData, pOldYUVData, iStride))
244 rectangles[count++] = rect;
245 }
246 }
247 }
248 if (!allocate_h264_metablock(QP, rectangles, meta, count))
249 return FALSE;
250 return TRUE;
251}
252
253INT32 h264_get_yuv_buffer(H264_CONTEXT* h264, UINT32 nSrcStride, UINT32 nSrcWidth,
254 UINT32 nSrcHeight, BYTE* YUVData[3], UINT32 stride[3])
255{
256 if (!h264 || !h264->Compressor || !h264->subsystem || !h264->subsystem->Compress)
257 return -1;
258
259 if (!yuv_ensure_buffer(h264, nSrcStride, nSrcWidth, nSrcHeight))
260 return -1;
261
262 for (size_t x = 0; x < 3; x++)
263 {
264 YUVData[x] = h264->pYUVData[x];
265 stride[x] = h264->iStride[x];
266 }
267
268 return 0;
269}
270
271INT32 h264_compress(H264_CONTEXT* h264, BYTE** ppDstData, UINT32* pDstSize)
272{
273 if (!h264 || !h264->Compressor || !h264->subsystem || !h264->subsystem->Compress)
274 return -1;
275
276 const BYTE* pcYUVData[3] = { h264->pYUVData[0], h264->pYUVData[1], h264->pYUVData[2] };
277
278 return h264->subsystem->Compress(h264, pcYUVData, h264->iStride, ppDstData, pDstSize);
279}
280
281INT32 avc420_compress(H264_CONTEXT* h264, const BYTE* pSrcData, DWORD SrcFormat, UINT32 nSrcStep,
282 UINT32 nSrcWidth, UINT32 nSrcHeight, const RECTANGLE_16* regionRect,
283 BYTE** ppDstData, UINT32* pDstSize, RDPGFX_H264_METABLOCK* meta)
284{
285 INT32 rc = -1;
286 BYTE* pYUVData[3] = WINPR_C_ARRAY_INIT;
287 const BYTE* pcYUVData[3] = WINPR_C_ARRAY_INIT;
288 BYTE* pOldYUVData[3] = WINPR_C_ARRAY_INIT;
289
290 if (!h264 || !regionRect || !meta || !h264->Compressor)
291 return -1;
292
293 if (!h264->subsystem->Compress)
294 return -1;
295
296 if (!avc420_ensure_buffer(h264, nSrcStep, nSrcWidth, nSrcHeight))
297 return -1;
298
299 if (h264->encodingBuffer)
300 {
301 for (size_t x = 0; x < 3; x++)
302 {
303 pYUVData[x] = h264->pYUVData[x];
304 pOldYUVData[x] = h264->pOldYUVData[x];
305 }
306 }
307 else
308 {
309 for (size_t x = 0; x < 3; x++)
310 {
311 pYUVData[x] = h264->pOldYUVData[x];
312 pOldYUVData[x] = h264->pYUVData[x];
313 }
314 }
315 h264->encodingBuffer = !h264->encodingBuffer;
316
317 if (!yuv420_context_encode(h264->yuv, pSrcData, nSrcStep, SrcFormat, h264->iStride, pYUVData,
318 regionRect, 1))
319 goto fail;
320
321 if (!detect_changes(h264->firstLumaFrameDone, h264->QP, regionRect, pYUVData, pOldYUVData,
322 h264->iStride, meta))
323 goto fail;
324
325 if (meta->numRegionRects == 0)
326 {
327 rc = 0;
328 goto fail;
329 }
330
331 for (size_t x = 0; x < 3; x++)
332 pcYUVData[x] = pYUVData[x];
333
334 rc = h264->subsystem->Compress(h264, pcYUVData, h264->iStride, ppDstData, pDstSize);
335 if (rc >= 0)
336 h264->firstLumaFrameDone = TRUE;
337
338fail:
339 if (rc < 0)
340 free_h264_metablock(meta);
341 return rc;
342}
343
344INT32 avc444_compress(H264_CONTEXT* h264, const BYTE* pSrcData, DWORD SrcFormat, UINT32 nSrcStep,
345 UINT32 nSrcWidth, UINT32 nSrcHeight, BYTE version, const RECTANGLE_16* region,
346 BYTE* op, BYTE** ppDstData, UINT32* pDstSize, BYTE** ppAuxDstData,
347 UINT32* pAuxDstSize, RDPGFX_H264_METABLOCK* meta,
348 RDPGFX_H264_METABLOCK* auxMeta)
349{
350 int rc = -1;
351 BYTE* coded = nullptr;
352 UINT32 codedSize = 0;
353 BYTE** pYUV444Data = nullptr;
354 BYTE** pOldYUV444Data = nullptr;
355 BYTE** pYUVData = nullptr;
356 BYTE** pOldYUVData = nullptr;
357
358 if (!h264 || !h264->Compressor)
359 return -1;
360
361 if (!h264->subsystem->Compress)
362 return -1;
363
364 if (!avc420_ensure_buffer(h264, nSrcStep, nSrcWidth, nSrcHeight))
365 return -1;
366
367 if (!avc444_ensure_buffer(h264, nSrcHeight))
368 return -1;
369
370 if (h264->encodingBuffer)
371 {
372 pYUV444Data = h264->pOldYUV444Data;
373 pOldYUV444Data = h264->pYUV444Data;
374 pYUVData = h264->pOldYUVData;
375 pOldYUVData = h264->pYUVData;
376 }
377 else
378 {
379 pYUV444Data = h264->pYUV444Data;
380 pOldYUV444Data = h264->pOldYUV444Data;
381 pYUVData = h264->pYUVData;
382 pOldYUVData = h264->pOldYUVData;
383 }
384 h264->encodingBuffer = !h264->encodingBuffer;
385
386 if (!yuv444_context_encode(h264->yuv, version, pSrcData, nSrcStep, SrcFormat, h264->iStride,
387 pYUV444Data, pYUVData, region, 1))
388 goto fail;
389
390 if (!detect_changes(h264->firstLumaFrameDone, h264->QP, region, pYUV444Data, pOldYUV444Data,
391 h264->iStride, meta))
392 goto fail;
393 if (!detect_changes(h264->firstChromaFrameDone, h264->QP, region, pYUVData, pOldYUVData,
394 h264->iStride, auxMeta))
395 goto fail;
396
397 /* [MS-RDPEGFX] 2.2.4.5 RFX_AVC444_BITMAP_STREAM
398 * LC:
399 * 0 ... Luma & Chroma
400 * 1 ... Luma
401 * 2 ... Chroma
402 */
403 if ((meta->numRegionRects > 0) && (auxMeta->numRegionRects > 0))
404 *op = 0;
405 else if (meta->numRegionRects > 0)
406 *op = 1;
407 else if (auxMeta->numRegionRects > 0)
408 *op = 2;
409 else
410 {
411 WLog_INFO(TAG, "no changes detected for luma or chroma frame");
412 rc = 0;
413 goto fail;
414 }
415
416 if ((*op == 0) || (*op == 1))
417 {
418 const BYTE* pcYUV444Data[3] = { pYUV444Data[0], pYUV444Data[1], pYUV444Data[2] };
419
420 if (h264->subsystem->Compress(h264, pcYUV444Data, h264->iStride, &coded, &codedSize) < 0)
421 goto fail;
422 h264->firstLumaFrameDone = TRUE;
423 memcpy(h264->lumaData, coded, codedSize);
424 *ppDstData = h264->lumaData;
425 *pDstSize = codedSize;
426 }
427
428 if ((*op == 0) || (*op == 2))
429 {
430 const BYTE* pcYUVData[3] = { pYUVData[0], pYUVData[1], pYUVData[2] };
431
432 if (h264->subsystem->Compress(h264, pcYUVData, h264->iStride, &coded, &codedSize) < 0)
433 goto fail;
434 h264->firstChromaFrameDone = TRUE;
435 *ppAuxDstData = coded;
436 *pAuxDstSize = codedSize;
437 }
438
439 rc = 1;
440fail:
441 if (rc < 0)
442 {
443 free_h264_metablock(meta);
444 free_h264_metablock(auxMeta);
445 }
446 return rc;
447}
448
449static BOOL avc444_ensure_buffer(H264_CONTEXT* h264, DWORD nDstHeight)
450{
451 WINPR_ASSERT(h264);
452
453 const UINT32* piMainStride = h264->iStride;
454 UINT32* piDstSize = h264->iYUV444Size;
455 UINT32* piDstStride = h264->iYUV444Stride;
456 BYTE** ppYUVDstData = h264->pYUV444Data;
457 BYTE** ppOldYUVDstData = h264->pOldYUV444Data;
458
459 nDstHeight = MAX(h264->height, nDstHeight);
460 const UINT32 pad = nDstHeight % 16;
461 UINT32 padDstHeight = nDstHeight; /* Need alignment to 16x16 blocks */
462
463 if (pad != 0)
464 padDstHeight += 16 - pad;
465
466 if ((piMainStride[0] != piDstStride[0]) ||
467 (piDstSize[0] != 1ull * piMainStride[0] * padDstHeight))
468 {
469 for (UINT32 x = 0; x < 3; x++)
470 {
471 piDstStride[x] = piMainStride[0];
472 piDstSize[x] = piDstStride[x] * padDstHeight;
473
474 if (piDstSize[x] == 0)
475 return FALSE;
476
477 BYTE* tmp1 = winpr_aligned_recalloc(ppYUVDstData[x], piDstSize[x], 1, 16);
478 if (!tmp1)
479 return FALSE;
480 ppYUVDstData[x] = tmp1;
481 BYTE* tmp2 = winpr_aligned_recalloc(ppOldYUVDstData[x], piDstSize[x], 1, 16);
482 if (!tmp2)
483 return FALSE;
484 ppOldYUVDstData[x] = tmp2;
485 }
486
487 {
488 BYTE* tmp = winpr_aligned_recalloc(h264->lumaData, piDstSize[0], 4, 16);
489 if (!tmp)
490 goto fail;
491 h264->lumaData = tmp;
492 }
493 }
494
495 for (UINT32 x = 0; x < 3; x++)
496 {
497 if (!ppOldYUVDstData[x] || !ppYUVDstData[x] || (piDstSize[x] == 0) || (piDstStride[x] == 0))
498 {
499 WLog_Print(h264->log, WLOG_ERROR,
500 "YUV buffer not initialized! check your decoder settings");
501 goto fail;
502 }
503 }
504
505 if (!h264->lumaData)
506 goto fail;
507
508 return TRUE;
509fail:
510 return FALSE;
511}
512
513static BOOL avc444_process_rects(H264_CONTEXT* h264, const BYTE* pSrcData, UINT32 SrcSize,
514 BYTE* pDstData, UINT32 DstFormat, UINT32 nDstStep,
515 WINPR_ATTR_UNUSED UINT32 nDstWidth, UINT32 nDstHeight,
516 const RECTANGLE_16* rects, UINT32 nrRects, avc444_frame_type type)
517{
518 const BYTE* pYUVData[3];
519 BYTE* pYUVDstData[3];
520 UINT32* piDstStride = h264->iYUV444Stride;
521 BYTE** ppYUVDstData = h264->pYUV444Data;
522 const UINT32* piStride = h264->iStride;
523
524 if (h264->subsystem->Decompress(h264, pSrcData, SrcSize) < 0)
525 return FALSE;
526
527 pYUVData[0] = h264->pYUVData[0];
528 pYUVData[1] = h264->pYUVData[1];
529 pYUVData[2] = h264->pYUVData[2];
530 if (!avc444_ensure_buffer(h264, nDstHeight))
531 return FALSE;
532
533 pYUVDstData[0] = ppYUVDstData[0];
534 pYUVDstData[1] = ppYUVDstData[1];
535 pYUVDstData[2] = ppYUVDstData[2];
536 return (yuv444_context_decode(h264->yuv, (BYTE)type, pYUVData, piStride, h264->height,
537 pYUVDstData, piDstStride, DstFormat, pDstData, nDstStep, rects,
538 nrRects));
539}
540
541#if defined(AVC444_FRAME_STAT)
542static UINT64 op1 = 0;
543static double op1sum = 0;
544static UINT64 op2 = 0;
545static double op2sum = 0;
546static UINT64 op3 = 0;
547static double op3sum = 0;
548static double avg(UINT64* count, double old, double size)
549{
550 double tmp = size + *count * old;
551 (*count)++;
552 tmp = tmp / *count;
553 return tmp;
554}
555#endif
556
557INT32 avc444_decompress(H264_CONTEXT* h264, BYTE op, const RECTANGLE_16* regionRects,
558 UINT32 numRegionRects, const BYTE* pSrcData, UINT32 SrcSize,
559 const RECTANGLE_16* auxRegionRects, UINT32 numAuxRegionRect,
560 const BYTE* pAuxSrcData, UINT32 AuxSrcSize, BYTE* pDstData, DWORD DstFormat,
561 UINT32 nDstStep, UINT32 nDstWidth, UINT32 nDstHeight, UINT32 codecId)
562{
563 INT32 status = -1;
564 avc444_frame_type chroma =
565 (codecId == RDPGFX_CODECID_AVC444) ? AVC444_CHROMAv1 : AVC444_CHROMAv2;
566
567 if (!h264 || !regionRects || !pSrcData || !pDstData || h264->Compressor)
568 return -1001;
569
570 switch (op)
571 {
572 case 0: /* YUV420 in stream 1
573 * Chroma420 in stream 2 */
574 if (!avc444_process_rects(h264, pSrcData, SrcSize, pDstData, DstFormat, nDstStep,
575 nDstWidth, nDstHeight, regionRects, numRegionRects,
576 AVC444_LUMA))
577 status = -1;
578 else if (!avc444_process_rects(h264, pAuxSrcData, AuxSrcSize, pDstData, DstFormat,
579 nDstStep, nDstWidth, nDstHeight, auxRegionRects,
580 numAuxRegionRect, chroma))
581 status = -1;
582 else
583 status = 0;
584
585 break;
586
587 case 2: /* Chroma420 in stream 1 */
588 if (!avc444_process_rects(h264, pSrcData, SrcSize, pDstData, DstFormat, nDstStep,
589 nDstWidth, nDstHeight, regionRects, numRegionRects, chroma))
590 status = -1;
591 else
592 status = 0;
593
594 break;
595
596 case 1: /* YUV420 in stream 1 */
597 if (!avc444_process_rects(h264, pSrcData, SrcSize, pDstData, DstFormat, nDstStep,
598 nDstWidth, nDstHeight, regionRects, numRegionRects,
599 AVC444_LUMA))
600 status = -1;
601 else
602 status = 0;
603
604 break;
605
606 default: /* WTF? */
607 break;
608 }
609
610#if defined(AVC444_FRAME_STAT)
611
612 switch (op)
613 {
614 case 0:
615 op1sum = avg(&op1, op1sum, SrcSize + AuxSrcSize);
616 break;
617
618 case 1:
619 op2sum = avg(&op2, op2sum, SrcSize);
620 break;
621
622 case 2:
623 op3sum = avg(&op3, op3sum, SrcSize);
624 break;
625
626 default:
627 break;
628 }
629
630 WLog_Print(h264->log, WLOG_INFO,
631 "luma=%" PRIu64 " [avg=%lf] chroma=%" PRIu64 " [avg=%lf] combined=%" PRIu64
632 " [avg=%lf]",
633 op1, op1sum, op2, op2sum, op3, op3sum);
634#endif
635 return status;
636}
637
638#define MAX_SUBSYSTEMS 10
639static INIT_ONCE subsystems_once = INIT_ONCE_STATIC_INIT;
640static const H264_CONTEXT_SUBSYSTEM* subSystems[MAX_SUBSYSTEMS] = WINPR_C_ARRAY_INIT;
641
642static BOOL CALLBACK h264_register_subsystems(WINPR_ATTR_UNUSED PINIT_ONCE once,
643 WINPR_ATTR_UNUSED PVOID param,
644 WINPR_ATTR_UNUSED PVOID* context)
645{
646 int i = 0;
647
648#ifdef WITH_MEDIACODEC
649 {
650 subSystems[i] = &g_Subsystem_mediacodec;
651 i++;
652 }
653#endif
654#if defined(_WIN32) && defined(WITH_MEDIA_FOUNDATION)
655 {
656 subSystems[i] = &g_Subsystem_MF;
657 i++;
658 }
659#endif
660#ifdef WITH_OPENH264
661 {
662 subSystems[i] = &g_Subsystem_OpenH264;
663 i++;
664 }
665#endif
666#ifdef WITH_VIDEO_FFMPEG
667 {
668 subSystems[i] = &g_Subsystem_libavcodec;
669 i++;
670 }
671#endif
672 return i > 0;
673}
674
675static BOOL h264_context_init(H264_CONTEXT* h264)
676{
677 if (!h264)
678 return FALSE;
679
680 h264->subsystem = nullptr;
681 if (!InitOnceExecuteOnce(&subsystems_once, h264_register_subsystems, nullptr, nullptr))
682 return FALSE;
683
684 for (size_t i = 0; i < MAX_SUBSYSTEMS; i++)
685 {
686 const H264_CONTEXT_SUBSYSTEM* subsystem = subSystems[i];
687
688 if (!subsystem || !subsystem->Init)
689 break;
690
691 if (subsystem->Init(h264))
692 {
693 h264->subsystem = subsystem;
694 return TRUE;
695 }
696 }
697
698 return FALSE;
699}
700
701BOOL h264_context_reset(H264_CONTEXT* h264, UINT32 width, UINT32 height)
702{
703 if (!h264)
704 return FALSE;
705
706 h264->width = width;
707 h264->height = height;
708
709 if (h264->subsystem && h264->subsystem->Uninit)
710 h264->subsystem->Uninit(h264);
711 if (!h264_context_init(h264))
712 return FALSE;
713
714 return yuv_context_reset(h264->yuv, width, height);
715}
716
717H264_CONTEXT* h264_context_new(BOOL Compressor)
718{
719 H264_CONTEXT* h264 = (H264_CONTEXT*)calloc(1, sizeof(H264_CONTEXT));
720 if (!h264)
721 return nullptr;
722
723 h264->log = WLog_Get(TAG);
724
725 if (!h264->log)
726 goto fail;
727
728 h264->Compressor = Compressor;
729 if (Compressor)
730 {
731 /* Default compressor settings, may be changed by caller */
732 h264->BitRate = 1000000;
733 h264->FrameRate = 30;
734 }
735
736 if (!h264_context_init(h264))
737 goto fail;
738
739 h264->yuv = yuv_context_new(Compressor, 0);
740 if (!h264->yuv)
741 goto fail;
742
743 return h264;
744
745fail:
746 WINPR_PRAGMA_DIAG_PUSH
747 WINPR_PRAGMA_DIAG_IGNORED_MISMATCHED_DEALLOC
748 h264_context_free(h264);
749 WINPR_PRAGMA_DIAG_POP
750 return nullptr;
751}
752
753void h264_context_free(H264_CONTEXT* h264)
754{
755 if (h264)
756 {
757 if (h264->subsystem)
758 {
759 WINPR_ASSERT(h264->subsystem->Uninit);
760 h264->subsystem->Uninit(h264);
761 }
762
763 for (size_t x = 0; x < 3; x++)
764 {
765 if (h264->Compressor)
766 {
767 winpr_aligned_free(h264->pYUVData[x]);
768 winpr_aligned_free(h264->pOldYUVData[x]);
769 }
770 winpr_aligned_free(h264->pYUV444Data[x]);
771 winpr_aligned_free(h264->pOldYUV444Data[x]);
772 }
773 winpr_aligned_free(h264->lumaData);
774
775 yuv_context_free(h264->yuv);
776 free(h264);
777 }
778}
779
780void free_h264_metablock(RDPGFX_H264_METABLOCK* meta)
781{
782 RDPGFX_H264_METABLOCK m = WINPR_C_ARRAY_INIT;
783 if (!meta)
784 return;
785 free(meta->quantQualityVals);
786 free(meta->regionRects);
787 *meta = m;
788}
789
790BOOL h264_context_set_option(H264_CONTEXT* h264, H264_CONTEXT_OPTION option, UINT32 value)
791{
792 WINPR_ASSERT(h264);
793 switch (option)
794 {
795 case H264_CONTEXT_OPTION_BITRATE:
796 h264->BitRate = value;
797 return TRUE;
798 case H264_CONTEXT_OPTION_FRAMERATE:
799 h264->FrameRate = value;
800 return TRUE;
801 case H264_CONTEXT_OPTION_RATECONTROL:
802 {
803 switch (value)
804 {
805 case H264_RATECONTROL_VBR:
806 h264->RateControlMode = H264_RATECONTROL_VBR;
807 return TRUE;
808 case H264_RATECONTROL_CQP:
809 h264->RateControlMode = H264_RATECONTROL_CQP;
810 return TRUE;
811 default:
812 WLog_Print(h264->log, WLOG_WARN,
813 "Unknown H264_CONTEXT_OPTION_RATECONTROL value [0x%08" PRIx32 "]",
814 value);
815 return FALSE;
816 }
817 return TRUE;
818 }
819 case H264_CONTEXT_OPTION_QP:
820 h264->QP = value;
821 return TRUE;
822 case H264_CONTEXT_OPTION_USAGETYPE:
823 h264->UsageType = value;
824 return TRUE;
825 case H264_CONTEXT_OPTION_HW_ACCEL:
826 h264->hwAccel = (value);
827 return TRUE;
828 default:
829 WLog_Print(h264->log, WLOG_WARN, "Unknown H264_CONTEXT_OPTION[0x%08" PRIx32 "]",
830 option);
831 return FALSE;
832 }
833}
834
835UINT32 h264_context_get_option(H264_CONTEXT* h264, H264_CONTEXT_OPTION option)
836{
837 WINPR_ASSERT(h264);
838 switch (option)
839 {
840 case H264_CONTEXT_OPTION_BITRATE:
841 return h264->BitRate;
842 case H264_CONTEXT_OPTION_FRAMERATE:
843 return h264->FrameRate;
844 case H264_CONTEXT_OPTION_RATECONTROL:
845 return h264->RateControlMode;
846 case H264_CONTEXT_OPTION_QP:
847 return h264->QP;
848 case H264_CONTEXT_OPTION_USAGETYPE:
849 return h264->UsageType;
850 case H264_CONTEXT_OPTION_HW_ACCEL:
851 return h264->hwAccel;
852 default:
853 WLog_Print(h264->log, WLOG_WARN, "Unknown H264_CONTEXT_OPTION[0x%08" PRIx32 "]",
854 option);
855 return 0;
856 }
857}
RDPGFX_H264_METABLOCK
Definition channels/rdpgfx.h:378
RDPGFX_H264_QUANT_QUALITY
Definition channels/rdpgfx.h:368
RECTANGLE_16
Definition types.h:109
RTL_RUN_ONCE
Definition include/winpr/synch.h:382