FreeRDP
Loading...
Searching...
No Matches
tsmf_ffmpeg.c
1
20#include <freerdp/config.h>
21
22#include <stdio.h>
23#include <stdlib.h>
24#include <string.h>
25
26#include <winpr/crt.h>
27
28#include <freerdp/channels/log.h>
29#include <freerdp/client/tsmf.h>
30
31#include <libavcodec/avcodec.h>
32#include <libavutil/common.h>
33#include <libavutil/cpu.h>
34#include <libavutil/imgutils.h>
35
36#include "tsmf_constants.h"
37#include "tsmf_decoder.h"
38#include "tsmf_audio.h"
39
40/* Compatibility with older FFmpeg */
41#if LIBAVUTIL_VERSION_MAJOR < 50
42#define AVMEDIA_TYPE_VIDEO 0
43#define AVMEDIA_TYPE_AUDIO 1
44#endif
45
46#if LIBAVCODEC_VERSION_MAJOR < 54
47#define MAX_AUDIO_FRAME_SIZE AVCODEC_MAX_AUDIO_FRAME_SIZE
48#else
49#define MAX_AUDIO_FRAME_SIZE 192000
50#endif
51
52#if LIBAVCODEC_VERSION_MAJOR < 55
53#define AV_CODEC_ID_VC1 CODEC_ID_VC1
54#define AV_CODEC_ID_WMAV2 CODEC_ID_WMAV2
55#define AV_CODEC_ID_WMAPRO CODEC_ID_WMAPRO
56#define AV_CODEC_ID_MP3 CODEC_ID_MP3
57#define AV_CODEC_ID_MP2 CODEC_ID_MP2
58#define AV_CODEC_ID_MPEG2VIDEO CODEC_ID_MPEG2VIDEO
59#define AV_CODEC_ID_WMV3 CODEC_ID_WMV3
60#define AV_CODEC_ID_AAC CODEC_ID_AAC
61#define AV_CODEC_ID_H264 CODEC_ID_H264
62#define AV_CODEC_ID_AC3 CODEC_ID_AC3
63#endif
64
65#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(56, 34, 2)
66#define AV_CODEC_CAP_TRUNCATED CODEC_CAP_TRUNCATED
67#define AV_CODEC_FLAG_TRUNCATED CODEC_FLAG_TRUNCATED
68#endif
69
70#if LIBAVUTIL_VERSION_MAJOR < 52
71#define AV_PIX_FMT_YUV420P PIX_FMT_YUV420P
72#endif
73
74typedef struct
75{
76 ITSMFDecoder iface;
77
78 int media_type;
79#if LIBAVCODEC_VERSION_MAJOR < 55
80 enum CodecID codec_id;
81#else
82 enum AVCodecID codec_id;
83#endif
84 AVCodecContext* codec_context;
85 const AVCodec* codec;
86 AVFrame* frame;
87 int prepared;
88
89 BYTE* decoded_data;
90 UINT32 decoded_size;
91 UINT32 decoded_size_max;
92} TSMFFFmpegDecoder;
93
94static BOOL tsmf_ffmpeg_init_context(ITSMFDecoder* decoder)
95{
96 TSMFFFmpegDecoder* mdecoder = (TSMFFFmpegDecoder*)decoder;
97 mdecoder->codec_context = avcodec_alloc_context3(nullptr);
98
99 if (!mdecoder->codec_context)
100 {
101 WLog_ERR(TAG, "avcodec_alloc_context failed.");
102 return FALSE;
103 }
104
105 return TRUE;
106}
107
108static BOOL tsmf_ffmpeg_init_video_stream(ITSMFDecoder* decoder, const TS_AM_MEDIA_TYPE* media_type)
109{
110 TSMFFFmpegDecoder* mdecoder = (TSMFFFmpegDecoder*)decoder;
111 mdecoder->codec_context->width = WINPR_ASSERTING_INT_CAST(int, media_type->Width);
112 mdecoder->codec_context->height = WINPR_ASSERTING_INT_CAST(int, media_type->Height);
113 mdecoder->codec_context->bit_rate = WINPR_ASSERTING_INT_CAST(int, media_type->BitRate);
114 mdecoder->codec_context->time_base.den =
115 WINPR_ASSERTING_INT_CAST(int, media_type->SamplesPerSecond.Numerator);
116 mdecoder->codec_context->time_base.num =
117 WINPR_ASSERTING_INT_CAST(int, media_type->SamplesPerSecond.Denominator);
118#if LIBAVCODEC_VERSION_MAJOR < 55
119 mdecoder->frame = avcodec_alloc_frame();
120#else
121 mdecoder->frame = av_frame_alloc();
122#endif
123 return TRUE;
124}
125
126static BOOL tsmf_ffmpeg_init_audio_stream(ITSMFDecoder* decoder, const TS_AM_MEDIA_TYPE* media_type)
127{
128 TSMFFFmpegDecoder* mdecoder = (TSMFFFmpegDecoder*)decoder;
129 mdecoder->codec_context->sample_rate =
130 WINPR_ASSERTING_INT_CAST(int, media_type->SamplesPerSecond.Numerator);
131 mdecoder->codec_context->bit_rate = WINPR_ASSERTING_INT_CAST(int, media_type->BitRate);
132#if LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(57, 28, 100)
133 mdecoder->codec_context->ch_layout.nb_channels =
134 WINPR_ASSERTING_INT_CAST(int, media_type->Channels);
135#else
136 mdecoder->codec_context->channels = WINPR_ASSERTING_INT_CAST(int, media_type->Channels);
137#endif
138 mdecoder->codec_context->block_align = WINPR_ASSERTING_INT_CAST(int, media_type->BlockAlign);
139#if LIBAVCODEC_VERSION_MAJOR < 55
140#ifdef AV_CPU_FLAG_SSE2
141 mdecoder->codec_context->dsp_mask = AV_CPU_FLAG_SSE2 | AV_CPU_FLAG_MMX2;
142#else
143#if LIBAVCODEC_VERSION_MAJOR < 53
144 mdecoder->codec_context->dsp_mask = FF_MM_SSE2 | FF_MM_MMXEXT;
145#else
146 mdecoder->codec_context->dsp_mask = FF_MM_SSE2 | FF_MM_MMX2;
147#endif
148#endif
149#else /* LIBAVCODEC_VERSION_MAJOR < 55 */
150#ifdef AV_CPU_FLAG_SSE2
151#if LIBAVUTIL_VERSION_INT < AV_VERSION_INT(57, 17, 100)
152 av_set_cpu_flags_mask(AV_CPU_FLAG_SSE2 | AV_CPU_FLAG_MMXEXT);
153#else
154 av_force_cpu_flags(AV_CPU_FLAG_SSE2 | AV_CPU_FLAG_MMXEXT);
155#endif
156#else
157 av_set_cpu_flags_mask(FF_MM_SSE2 | FF_MM_MMX2);
158#endif
159#endif /* LIBAVCODEC_VERSION_MAJOR < 55 */
160 return TRUE;
161}
162
163static BOOL tsmf_ffmpeg_init_stream(ITSMFDecoder* decoder, const TS_AM_MEDIA_TYPE* media_type)
164{
165 BYTE* p = nullptr;
166 UINT32 size = 0;
167 const BYTE* s = nullptr;
168 TSMFFFmpegDecoder* mdecoder = (TSMFFFmpegDecoder*)decoder;
169
170 WINPR_PRAGMA_DIAG_PUSH
171 WINPR_PRAGMA_DIAG_IGNORED_QUALIFIERS
172 mdecoder->codec = avcodec_find_decoder(mdecoder->codec_id);
173 WINPR_PRAGMA_DIAG_POP
174
175 if (!mdecoder->codec)
176 {
177 WLog_ERR(TAG, "avcodec_find_decoder failed.");
178 return FALSE;
179 }
180
181 mdecoder->codec_context->codec_id = mdecoder->codec_id;
182 mdecoder->codec_context->codec_type = mdecoder->media_type;
183
184 switch (mdecoder->media_type)
185 {
186 case AVMEDIA_TYPE_VIDEO:
187 if (!tsmf_ffmpeg_init_video_stream(decoder, media_type))
188 return FALSE;
189
190 break;
191
192 case AVMEDIA_TYPE_AUDIO:
193 if (!tsmf_ffmpeg_init_audio_stream(decoder, media_type))
194 return FALSE;
195
196 break;
197
198 default:
199 WLog_ERR(TAG, "unknown media_type %d", mdecoder->media_type);
200 break;
201 }
202
203 if (media_type->ExtraData)
204 {
205 if (media_type->ExtraDataSize < 12)
206 return FALSE;
207
208 /* Add a padding to avoid invalid memory read in some codec */
209 mdecoder->codec_context->extradata_size =
210 WINPR_ASSERTING_INT_CAST(int, media_type->ExtraDataSize + 8);
211 if (mdecoder->codec_context->extradata_size == 0)
212 return FALSE;
213 mdecoder->codec_context->extradata = calloc(1, mdecoder->codec_context->extradata_size);
214
215 if (!mdecoder->codec_context->extradata)
216 return FALSE;
217
218 if (media_type->SubType == TSMF_SUB_TYPE_AVC1 &&
219 media_type->FormatType == TSMF_FORMAT_TYPE_MPEG2VIDEOINFO)
220 {
221 size_t required = 6;
222 /* The extradata format that FFmpeg uses is following CodecPrivate in Matroska.
223 See http://haali.su/mkv/codecs.pdf */
224 p = mdecoder->codec_context->extradata;
225 if ((mdecoder->codec_context->extradata_size < 0) ||
226 ((size_t)mdecoder->codec_context->extradata_size < required))
227 return FALSE;
228 if (media_type->ExtraDataSize < 21)
229 return FALSE;
230
231 *p++ = 1; /* Reserved? */
232 *p++ = media_type->ExtraData[8]; /* Profile */
233 *p++ = 0; /* Profile */
234 *p++ = media_type->ExtraData[12]; /* Level */
235 *p++ = 0xff; /* Flag? */
236 *p++ = 0xe0 | 0x01; /* Reserved | #sps */
237 s = media_type->ExtraData + 20;
238 size = ((UINT32)(*s)) * 256 + ((UINT32)(*(s + 1)));
239 required += size + 2;
240 if ((mdecoder->codec_context->extradata_size < 0) ||
241 ((size_t)mdecoder->codec_context->extradata_size < required))
242 return FALSE;
243
244 size_t offset = 12ull + size + 2ull;
245 if (media_type->ExtraDataSize < offset)
246 return FALSE;
247
248 memcpy(p, s, size + 2);
249 s += size + 2;
250 p += size + 2;
251 required++;
252 if ((mdecoder->codec_context->extradata_size < 0) ||
253 ((size_t)mdecoder->codec_context->extradata_size < required))
254 return FALSE;
255 *p++ = 1; /* #pps */
256
257 offset += 5;
258 if (media_type->ExtraDataSize < offset)
259 return FALSE;
260 size = ((UINT32)(*s)) * 256 + ((UINT32)(*(s + 1)));
261 required += size + 2;
262 if ((mdecoder->codec_context->extradata_size < 0) ||
263 ((size_t)mdecoder->codec_context->extradata_size < required))
264 return FALSE;
265
266 offset += size + 2ull;
267 if (media_type->ExtraDataSize < offset)
268 return FALSE;
269 memcpy(p, s, size + 2);
270 }
271 else
272 {
273 if (media_type->ExtraDataSize > mdecoder->codec_context->extradata_size)
274 return FALSE;
275
276 memcpy(mdecoder->codec_context->extradata, media_type->ExtraData,
277 media_type->ExtraDataSize);
278 if ((mdecoder->codec_context->extradata_size < 0) ||
279 ((size_t)mdecoder->codec_context->extradata_size <
280 media_type->ExtraDataSize + 8ull))
281 return FALSE;
282 memset(mdecoder->codec_context->extradata + media_type->ExtraDataSize, 0, 8);
283 }
284 }
285
286#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(59, 18, 100)
287 if (mdecoder->codec->capabilities & AV_CODEC_CAP_TRUNCATED)
288 mdecoder->codec_context->flags |= AV_CODEC_FLAG_TRUNCATED;
289#endif
290
291 return TRUE;
292}
293
294static BOOL tsmf_ffmpeg_prepare(ITSMFDecoder* decoder)
295{
296 TSMFFFmpegDecoder* mdecoder = (TSMFFFmpegDecoder*)decoder;
297
298 if (avcodec_open2(mdecoder->codec_context, mdecoder->codec, nullptr) < 0)
299 {
300 WLog_ERR(TAG, "avcodec_open2 failed.");
301 return FALSE;
302 }
303
304 mdecoder->prepared = 1;
305 return TRUE;
306}
307
308static BOOL tsmf_ffmpeg_set_format(ITSMFDecoder* decoder, TS_AM_MEDIA_TYPE* media_type)
309{
310 TSMFFFmpegDecoder* mdecoder = (TSMFFFmpegDecoder*)decoder;
311
312 WINPR_ASSERT(mdecoder);
313 WINPR_ASSERT(media_type);
314
315 switch (media_type->MajorType)
316 {
317 case TSMF_MAJOR_TYPE_VIDEO:
318 mdecoder->media_type = AVMEDIA_TYPE_VIDEO;
319 break;
320
321 case TSMF_MAJOR_TYPE_AUDIO:
322 mdecoder->media_type = AVMEDIA_TYPE_AUDIO;
323 break;
324
325 default:
326 return FALSE;
327 }
328
329 switch (media_type->SubType)
330 {
331 case TSMF_SUB_TYPE_WVC1:
332 mdecoder->codec_id = AV_CODEC_ID_VC1;
333 break;
334
335 case TSMF_SUB_TYPE_WMA2:
336 mdecoder->codec_id = AV_CODEC_ID_WMAV2;
337 break;
338
339 case TSMF_SUB_TYPE_WMA9:
340 mdecoder->codec_id = AV_CODEC_ID_WMAPRO;
341 break;
342
343 case TSMF_SUB_TYPE_MP3:
344 mdecoder->codec_id = AV_CODEC_ID_MP3;
345 break;
346
347 case TSMF_SUB_TYPE_MP2A:
348 mdecoder->codec_id = AV_CODEC_ID_MP2;
349 break;
350
351 case TSMF_SUB_TYPE_MP2V:
352 mdecoder->codec_id = AV_CODEC_ID_MPEG2VIDEO;
353 break;
354
355 case TSMF_SUB_TYPE_WMV3:
356 mdecoder->codec_id = AV_CODEC_ID_WMV3;
357 break;
358
359 case TSMF_SUB_TYPE_AAC:
360 mdecoder->codec_id = AV_CODEC_ID_AAC;
361
362 /* For AAC the pFormat is a HEAACWAVEINFO struct, and the codec data
363 is at the end of it. See
364 http://msdn.microsoft.com/en-us/library/dd757806.aspx */
365 if (media_type->ExtraData)
366 {
367 if (media_type->ExtraDataSize < 12)
368 return FALSE;
369
370 media_type->ExtraData += 12;
371 media_type->ExtraDataSize -= 12;
372 }
373
374 break;
375
376 case TSMF_SUB_TYPE_H264:
377 case TSMF_SUB_TYPE_AVC1:
378 mdecoder->codec_id = AV_CODEC_ID_H264;
379 break;
380
381 case TSMF_SUB_TYPE_AC3:
382 mdecoder->codec_id = AV_CODEC_ID_AC3;
383 break;
384
385 default:
386 return FALSE;
387 }
388
389 if (!tsmf_ffmpeg_init_context(decoder))
390 return FALSE;
391
392 if (!tsmf_ffmpeg_init_stream(decoder, media_type))
393 return FALSE;
394
395 if (!tsmf_ffmpeg_prepare(decoder))
396 return FALSE;
397
398 return TRUE;
399}
400
401static BOOL tsmf_ffmpeg_decode_video(ITSMFDecoder* decoder, const BYTE* data, UINT32 data_size,
402 UINT32 extensions)
403{
404 TSMFFFmpegDecoder* mdecoder = (TSMFFFmpegDecoder*)decoder;
405 int decoded = 0;
406 int len = 0;
407 AVFrame* frame = nullptr;
408 BOOL ret = TRUE;
409#if LIBAVCODEC_VERSION_MAJOR < 52 || \
410 (LIBAVCODEC_VERSION_MAJOR == 52 && LIBAVCODEC_VERSION_MINOR <= 20)
411 len = avcodec_decode_video(mdecoder->codec_context, mdecoder->frame, &decoded, data, data_size);
412#else
413 {
414 AVPacket pkt = WINPR_C_ARRAY_INIT;
415#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(58, 133, 100)
416 av_init_packet(&pkt);
417#endif
418 pkt.data = WINPR_CAST_CONST_PTR_AWAY(data, BYTE*);
419 pkt.size = WINPR_ASSERTING_INT_CAST(int, data_size);
420
421 if (extensions & TSMM_SAMPLE_EXT_CLEANPOINT)
422 pkt.flags |= AV_PKT_FLAG_KEY;
423
424#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(57, 48, 101)
425 len = avcodec_decode_video2(mdecoder->codec_context, mdecoder->frame, &decoded, &pkt);
426#else
427 len = avcodec_send_packet(mdecoder->codec_context, &pkt);
428 if (len > 0)
429 {
430 len = avcodec_receive_frame(mdecoder->codec_context, mdecoder->frame);
431 if (len == AVERROR(EAGAIN))
432 return TRUE;
433 }
434#endif
435 }
436#endif
437
438 if (len < 0)
439 {
440 WLog_ERR(TAG, "data_size %" PRIu32 ", avcodec_decode_video failed (%d)", data_size, len);
441 ret = FALSE;
442 }
443 else if (!decoded)
444 {
445 WLog_ERR(TAG, "data_size %" PRIu32 ", no frame is decoded.", data_size);
446 ret = FALSE;
447 }
448 else
449 {
450 DEBUG_TSMF("linesize[0] %d linesize[1] %d linesize[2] %d linesize[3] %d "
451 "pix_fmt %d width %d height %d",
452 mdecoder->frame->linesize[0], mdecoder->frame->linesize[1],
453 mdecoder->frame->linesize[2], mdecoder->frame->linesize[3],
454 mdecoder->codec_context->pix_fmt, mdecoder->codec_context->width,
455 mdecoder->codec_context->height);
456 mdecoder->decoded_size = av_image_get_buffer_size(mdecoder->codec_context->pix_fmt,
457 mdecoder->codec_context->width,
458 mdecoder->codec_context->height, 1);
459 mdecoder->decoded_data = calloc(1, mdecoder->decoded_size);
460
461 if (!mdecoder->decoded_data)
462 return FALSE;
463
464#if LIBAVCODEC_VERSION_MAJOR < 55
465 frame = avcodec_alloc_frame();
466#else
467 frame = av_frame_alloc();
468#endif
469 av_image_fill_arrays(frame->data, frame->linesize, mdecoder->decoded_data,
470 mdecoder->codec_context->pix_fmt, mdecoder->codec_context->width,
471 mdecoder->codec_context->height, 1);
472
473 const uint8_t* ptr[AV_NUM_DATA_POINTERS] = WINPR_C_ARRAY_INIT;
474 for (size_t x = 0; x < AV_NUM_DATA_POINTERS; x++)
475 ptr[x] = mdecoder->frame->data[x];
476
477 av_image_copy(frame->data, frame->linesize, ptr, mdecoder->frame->linesize,
478 mdecoder->codec_context->pix_fmt, mdecoder->codec_context->width,
479 mdecoder->codec_context->height);
480 av_free(frame);
481 }
482
483 return ret;
484}
485
486static BOOL tsmf_ffmpeg_decode_audio(ITSMFDecoder* decoder, const BYTE* data, UINT32 data_size,
487 WINPR_ATTR_UNUSED UINT32 extensions)
488{
489 TSMFFFmpegDecoder* mdecoder = (TSMFFFmpegDecoder*)decoder;
490 int len = 0;
491 int frame_size = 0;
492
493 if (mdecoder->decoded_size_max == 0)
494 mdecoder->decoded_size_max = MAX_AUDIO_FRAME_SIZE + 16;
495
496 mdecoder->decoded_data = calloc(1, mdecoder->decoded_size_max);
497
498 if (!mdecoder->decoded_data)
499 return FALSE;
500
501 /* align the memory for SSE2 needs */
502 BYTE* dst = (BYTE*)(((uintptr_t)mdecoder->decoded_data + 15) & ~0x0F);
503 size_t dst_offset = (size_t)(dst - mdecoder->decoded_data);
504 const BYTE* src = data;
505 UINT32 src_size = data_size;
506
507 while (src_size > 0)
508 {
509 /* Ensure enough space for decoding */
510 if (mdecoder->decoded_size_max - mdecoder->decoded_size < MAX_AUDIO_FRAME_SIZE)
511 {
512 BYTE* tmp_data = nullptr;
513 tmp_data = realloc(mdecoder->decoded_data, mdecoder->decoded_size_max * 2ull + 16ull);
514
515 if (!tmp_data)
516 return FALSE;
517
518 mdecoder->decoded_size_max = mdecoder->decoded_size_max * 2ull + 16ull;
519 mdecoder->decoded_data = tmp_data;
520 dst = (BYTE*)(((uintptr_t)mdecoder->decoded_data + 15) & ~0x0F);
521
522 const size_t diff = (size_t)(dst - mdecoder->decoded_data);
523 if (diff != dst_offset)
524 {
525 /* re-align the memory if the alignment has changed after realloc */
526 memmove(dst, mdecoder->decoded_data + dst_offset, mdecoder->decoded_size);
527 dst_offset = diff;
528 }
529
530 dst += mdecoder->decoded_size;
531 }
532
533#if LIBAVCODEC_VERSION_MAJOR < 52 || \
534 (LIBAVCODEC_VERSION_MAJOR == 52 && LIBAVCODEC_VERSION_MINOR <= 20)
535 frame_size = mdecoder->decoded_size_max - mdecoder->decoded_size;
536 len = avcodec_decode_audio2(mdecoder->codec_context, (int16_t*)dst, &frame_size, src,
537 src_size);
538#else
539 {
540#if LIBAVCODEC_VERSION_MAJOR < 55
541 AVFrame* decoded_frame = avcodec_alloc_frame();
542#else
543 AVFrame* decoded_frame = av_frame_alloc();
544#endif
545 int got_frame = 0;
546 AVPacket pkt = WINPR_C_ARRAY_INIT;
547#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(58, 133, 100)
548 av_init_packet(&pkt);
549#endif
550
551 pkt.data = WINPR_CAST_CONST_PTR_AWAY(src, BYTE*);
552 pkt.size = WINPR_ASSERTING_INT_CAST(int, src_size);
553#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(57, 48, 101)
554 len = avcodec_decode_audio4(mdecoder->codec_context, decoded_frame, &got_frame, &pkt);
555#else
556 len = avcodec_send_packet(mdecoder->codec_context, &pkt);
557 if (len > 0)
558 {
559 len = avcodec_receive_frame(mdecoder->codec_context, decoded_frame);
560 if (len == AVERROR(EAGAIN))
561 return TRUE;
562 }
563#endif
564
565 if (len >= 0 && got_frame)
566 {
567#if LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(57, 28, 100)
568 const int channels = mdecoder->codec_context->ch_layout.nb_channels;
569#else
570 const int channels = mdecoder->codec_context->channels;
571#endif
572 frame_size =
573 av_samples_get_buffer_size(nullptr, channels, decoded_frame->nb_samples,
574 mdecoder->codec_context->sample_fmt, 1);
575 memcpy(dst, decoded_frame->data[0], frame_size);
576 }
577 else
578 {
579 frame_size = 0;
580 }
581
582 av_free(decoded_frame);
583 }
584#endif
585
586 if (len > 0)
587 {
588 src += len;
589 src_size -= len;
590 }
591
592 if (frame_size > 0)
593 {
594 mdecoder->decoded_size += frame_size;
595 dst += frame_size;
596 }
597 }
598
599 if (mdecoder->decoded_size == 0)
600 {
601 free(mdecoder->decoded_data);
602 mdecoder->decoded_data = nullptr;
603 }
604 else if (dst_offset)
605 {
606 /* move the aligned decoded data to original place */
607 memmove(mdecoder->decoded_data, mdecoder->decoded_data + dst_offset,
608 mdecoder->decoded_size);
609 }
610
611 DEBUG_TSMF("data_size %" PRIu32 " decoded_size %" PRIu32 "", data_size, mdecoder->decoded_size);
612 return TRUE;
613}
614
615static BOOL tsmf_ffmpeg_decode(ITSMFDecoder* decoder, const BYTE* data, UINT32 data_size,
616 UINT32 extensions)
617{
618 TSMFFFmpegDecoder* mdecoder = (TSMFFFmpegDecoder*)decoder;
619
620 if (mdecoder->decoded_data)
621 {
622 free(mdecoder->decoded_data);
623 mdecoder->decoded_data = nullptr;
624 }
625
626 mdecoder->decoded_size = 0;
627
628 switch (mdecoder->media_type)
629 {
630 case AVMEDIA_TYPE_VIDEO:
631 return tsmf_ffmpeg_decode_video(decoder, data, data_size, extensions);
632
633 case AVMEDIA_TYPE_AUDIO:
634 return tsmf_ffmpeg_decode_audio(decoder, data, data_size, extensions);
635
636 default:
637 WLog_ERR(TAG, "unknown media type.");
638 return FALSE;
639 }
640}
641
642static BYTE* tsmf_ffmpeg_get_decoded_data(ITSMFDecoder* decoder, UINT32* size)
643{
644 BYTE* buf = nullptr;
645 TSMFFFmpegDecoder* mdecoder = (TSMFFFmpegDecoder*)decoder;
646 *size = mdecoder->decoded_size;
647 buf = mdecoder->decoded_data;
648 mdecoder->decoded_data = nullptr;
649 mdecoder->decoded_size = 0;
650 return buf;
651}
652
653static UINT32 tsmf_ffmpeg_get_decoded_format(ITSMFDecoder* decoder)
654{
655 TSMFFFmpegDecoder* mdecoder = (TSMFFFmpegDecoder*)decoder;
656
657 switch (mdecoder->codec_context->pix_fmt)
658 {
659 case AV_PIX_FMT_YUV420P:
660 return RDP_PIXFMT_I420;
661
662 default:
663 WLog_ERR(TAG, "unsupported pixel format %d", mdecoder->codec_context->pix_fmt);
664 return (UINT32)-1;
665 }
666}
667
668static BOOL tsmf_ffmpeg_get_decoded_dimension(ITSMFDecoder* decoder, UINT32* width, UINT32* height)
669{
670 TSMFFFmpegDecoder* mdecoder = (TSMFFFmpegDecoder*)decoder;
671
672 if (mdecoder->codec_context->width > 0 && mdecoder->codec_context->height > 0)
673 {
674 *width = mdecoder->codec_context->width;
675 *height = mdecoder->codec_context->height;
676 return TRUE;
677 }
678 else
679 {
680 return FALSE;
681 }
682}
683
684static void tsmf_ffmpeg_free(ITSMFDecoder* decoder)
685{
686 TSMFFFmpegDecoder* mdecoder = (TSMFFFmpegDecoder*)decoder;
687
688 if (mdecoder->frame)
689 av_free(mdecoder->frame);
690
691 free(mdecoder->decoded_data);
692
693 if (mdecoder->codec_context)
694 {
695 free(mdecoder->codec_context->extradata);
696 mdecoder->codec_context->extradata = nullptr;
697
698#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(55, 69, 100)
699 avcodec_free_context(&mdecoder->codec_context);
700#else
701 if (mdecoder->prepared)
702 avcodec_close(mdecoder->codec_context);
703
704 av_free(mdecoder->codec_context);
705#endif
706 }
707
708 free(decoder);
709}
710
711static INIT_ONCE g_Initialized = INIT_ONCE_STATIC_INIT;
712static BOOL CALLBACK InitializeAvCodecs(WINPR_ATTR_UNUSED PINIT_ONCE once,
713 WINPR_ATTR_UNUSED PVOID param,
714 WINPR_ATTR_UNUSED PVOID* context)
715{
716#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(58, 10, 100)
717 avcodec_register_all();
718#endif
719 return TRUE;
720}
721
722FREERDP_ENTRY_POINT(UINT VCAPITYPE ffmpeg_freerdp_tsmf_client_decoder_subsystem_entry(void* ptr))
723{
724 ITSMFDecoder** sptr = (ITSMFDecoder**)ptr;
725 WINPR_ASSERT(sptr);
726 *sptr = nullptr;
727
728 TSMFFFmpegDecoder* decoder = nullptr;
729 if (!InitOnceExecuteOnce(&g_Initialized, InitializeAvCodecs, nullptr, nullptr))
730 return ERROR_INTERNAL_ERROR;
731 WLog_DBG(TAG, "TSMFDecoderEntry FFMPEG");
732 decoder = (TSMFFFmpegDecoder*)calloc(1, sizeof(TSMFFFmpegDecoder));
733
734 if (!decoder)
735 return ERROR_OUTOFMEMORY;
736
737 decoder->iface.SetFormat = tsmf_ffmpeg_set_format;
738 decoder->iface.Decode = tsmf_ffmpeg_decode;
739 decoder->iface.GetDecodedData = tsmf_ffmpeg_get_decoded_data;
740 decoder->iface.GetDecodedFormat = tsmf_ffmpeg_get_decoded_format;
741 decoder->iface.GetDecodedDimension = tsmf_ffmpeg_get_decoded_dimension;
742 decoder->iface.Free = tsmf_ffmpeg_free;
743 *sptr = &decoder->iface;
744 return CHANNEL_RC_OK;
745}
RTL_RUN_ONCE
Definition include/winpr/synch.h:388
TS_AM_MEDIA_TYPE
Definition tsmf_types.h:41