608 lines
18 KiB
C
608 lines
18 KiB
C
/**
|
|
* FreeRDP: A Remote Desktop Protocol Implementation
|
|
* Video Redirection Virtual Channel - Codec
|
|
*
|
|
* Copyright 2010-2011 Vic Lee
|
|
* Copyright 2012 Hewlett-Packard Development Company, L.P.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include <winpr/crt.h>
|
|
#include <winpr/stream.h>
|
|
#include <winpr/print.h>
|
|
|
|
#include "tsmf_decoder.h"
|
|
#include "tsmf_constants.h"
|
|
#include "tsmf_types.h"
|
|
|
|
#include "tsmf_codec.h"
|
|
|
|
#include <freerdp/log.h>
|
|
|
|
#define TAG CHANNELS_TAG("tsmf.client")
|
|
|
|
typedef struct _TSMFMediaTypeMap
|
|
{
|
|
BYTE guid[16];
|
|
const char* name;
|
|
int type;
|
|
} TSMFMediaTypeMap;
|
|
|
|
static const TSMFMediaTypeMap tsmf_major_type_map[] = {
|
|
/* 73646976-0000-0010-8000-00AA00389B71 */
|
|
{ { 0x76, 0x69, 0x64, 0x73, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B,
|
|
0x71 },
|
|
"MEDIATYPE_Video",
|
|
TSMF_MAJOR_TYPE_VIDEO },
|
|
|
|
/* 73647561-0000-0010-8000-00AA00389B71 */
|
|
{ { 0x61, 0x75, 0x64, 0x73, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B,
|
|
0x71 },
|
|
"MEDIATYPE_Audio",
|
|
TSMF_MAJOR_TYPE_AUDIO },
|
|
|
|
{ { 0 }, "Unknown", TSMF_MAJOR_TYPE_UNKNOWN }
|
|
};
|
|
|
|
static const TSMFMediaTypeMap tsmf_sub_type_map[] = {
|
|
/* 31435657-0000-0010-8000-00AA00389B71 */
|
|
{ { 0x57, 0x56, 0x43, 0x31, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B,
|
|
0x71 },
|
|
"MEDIASUBTYPE_WVC1",
|
|
TSMF_SUB_TYPE_WVC1 },
|
|
|
|
/* 00000160-0000-0010-8000-00AA00389B71 */
|
|
{ { 0x60, 0x01, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B,
|
|
0x71 },
|
|
"MEDIASUBTYPE_WMAudioV1", /* V7, V8 has the same GUID */
|
|
TSMF_SUB_TYPE_WMA1 },
|
|
|
|
/* 00000161-0000-0010-8000-00AA00389B71 */
|
|
{ { 0x61, 0x01, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B,
|
|
0x71 },
|
|
"MEDIASUBTYPE_WMAudioV2", /* V7, V8 has the same GUID */
|
|
TSMF_SUB_TYPE_WMA2 },
|
|
|
|
/* 00000162-0000-0010-8000-00AA00389B71 */
|
|
{ { 0x62, 0x01, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B,
|
|
0x71 },
|
|
"MEDIASUBTYPE_WMAudioV9",
|
|
TSMF_SUB_TYPE_WMA9 },
|
|
|
|
/* 00000055-0000-0010-8000-00AA00389B71 */
|
|
{ { 0x55, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B,
|
|
0x71 },
|
|
"MEDIASUBTYPE_MP3",
|
|
TSMF_SUB_TYPE_MP3 },
|
|
|
|
/* E06D802B-DB46-11CF-B4D1-00805F6CBBEA */
|
|
{ { 0x2B, 0x80, 0x6D, 0xE0, 0x46, 0xDB, 0xCF, 0x11, 0xB4, 0xD1, 0x00, 0x80, 0x5F, 0x6C, 0xBB,
|
|
0xEA },
|
|
"MEDIASUBTYPE_MPEG2_AUDIO",
|
|
TSMF_SUB_TYPE_MP2A },
|
|
|
|
/* E06D8026-DB46-11CF-B4D1-00805F6CBBEA */
|
|
{ { 0x26, 0x80, 0x6D, 0xE0, 0x46, 0xDB, 0xCF, 0x11, 0xB4, 0xD1, 0x00, 0x80, 0x5F, 0x6C, 0xBB,
|
|
0xEA },
|
|
"MEDIASUBTYPE_MPEG2_VIDEO",
|
|
TSMF_SUB_TYPE_MP2V },
|
|
|
|
/* 31564D57-0000-0010-8000-00AA00389B71 */
|
|
{ { 0x57, 0x4D, 0x56, 0x31, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B,
|
|
0x71 },
|
|
"MEDIASUBTYPE_WMV1",
|
|
TSMF_SUB_TYPE_WMV1 },
|
|
|
|
/* 32564D57-0000-0010-8000-00AA00389B71 */
|
|
{ { 0x57, 0x4D, 0x56, 0x32, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B,
|
|
0x71 },
|
|
"MEDIASUBTYPE_WMV2",
|
|
TSMF_SUB_TYPE_WMV2 },
|
|
|
|
/* 33564D57-0000-0010-8000-00AA00389B71 */
|
|
{ { 0x57, 0x4D, 0x56, 0x33, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B,
|
|
0x71 },
|
|
"MEDIASUBTYPE_WMV3",
|
|
TSMF_SUB_TYPE_WMV3 },
|
|
|
|
/* 00001610-0000-0010-8000-00AA00389B71 */
|
|
{ { 0x10, 0x16, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B,
|
|
0x71 },
|
|
"MEDIASUBTYPE_MPEG_HEAAC",
|
|
TSMF_SUB_TYPE_AAC },
|
|
|
|
/* 34363248-0000-0010-8000-00AA00389B71 */
|
|
{ { 0x48, 0x32, 0x36, 0x34, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B,
|
|
0x71 },
|
|
"MEDIASUBTYPE_H264",
|
|
TSMF_SUB_TYPE_H264 },
|
|
|
|
/* 31435641-0000-0010-8000-00AA00389B71 */
|
|
{ { 0x41, 0x56, 0x43, 0x31, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B,
|
|
0x71 },
|
|
"MEDIASUBTYPE_AVC1",
|
|
TSMF_SUB_TYPE_AVC1 },
|
|
|
|
/* 3334504D-0000-0010-8000-00AA00389B71 */
|
|
{ { 0x4D, 0x50, 0x34, 0x33, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B,
|
|
0x71 },
|
|
"MEDIASUBTYPE_MP43",
|
|
TSMF_SUB_TYPE_MP43 },
|
|
|
|
/* 5634504D-0000-0010-8000-00AA00389B71 */
|
|
{ { 0x4D, 0x50, 0x34, 0x56, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B,
|
|
0x71 },
|
|
"MEDIASUBTYPE_MP4S",
|
|
TSMF_SUB_TYPE_MP4S },
|
|
|
|
/* 3234504D-0000-0010-8000-00AA00389B71 */
|
|
{ { 0x4D, 0x50, 0x34, 0x32, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B,
|
|
0x71 },
|
|
"MEDIASUBTYPE_MP42",
|
|
TSMF_SUB_TYPE_MP42 },
|
|
|
|
/* 3253344D-0000-0010-8000-00AA00389B71 */
|
|
{ { 0x4D, 0x34, 0x53, 0x32, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B,
|
|
0x71 },
|
|
"MEDIASUBTYPE_MP42",
|
|
TSMF_SUB_TYPE_M4S2 },
|
|
|
|
/* E436EB81-524F-11CE-9F53-0020AF0BA770 */
|
|
{ { 0x81, 0xEB, 0x36, 0xE4, 0x4F, 0x52, 0xCE, 0x11, 0x9F, 0x53, 0x00, 0x20, 0xAF, 0x0B, 0xA7,
|
|
0x70 },
|
|
"MEDIASUBTYPE_MP1V",
|
|
TSMF_SUB_TYPE_MP1V },
|
|
|
|
/* 00000050-0000-0010-8000-00AA00389B71 */
|
|
{ { 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B,
|
|
0x71 },
|
|
"MEDIASUBTYPE_MP1A",
|
|
TSMF_SUB_TYPE_MP1A },
|
|
|
|
/* E06D802C-DB46-11CF-B4D1-00805F6CBBEA */
|
|
{ { 0x2C, 0x80, 0x6D, 0xE0, 0x46, 0xDB, 0xCF, 0x11, 0xB4, 0xD1, 0x00, 0x80, 0x5F, 0x6C, 0xBB,
|
|
0xEA },
|
|
"MEDIASUBTYPE_DOLBY_AC3",
|
|
TSMF_SUB_TYPE_AC3 },
|
|
|
|
/* 32595559-0000-0010-8000-00AA00389B71 */
|
|
{ { 0x59, 0x55, 0x59, 0x32, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B,
|
|
0x71 },
|
|
"MEDIASUBTYPE_YUY2",
|
|
TSMF_SUB_TYPE_YUY2 },
|
|
|
|
/* Opencodec IDS */
|
|
{ { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B,
|
|
0x71 },
|
|
"MEDIASUBTYPE_FLAC",
|
|
TSMF_SUB_TYPE_FLAC },
|
|
|
|
{ { 0x61, 0x34, 0x70, 0x6D, 0x7A, 0x76, 0x4D, 0x49, 0xB4, 0x78, 0xF2, 0x9D, 0x25, 0xDC, 0x90,
|
|
0x37 },
|
|
"MEDIASUBTYPE_OGG",
|
|
TSMF_SUB_TYPE_OGG },
|
|
|
|
{ { 0x4D, 0x34, 0x53, 0x32, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B,
|
|
0x71 },
|
|
"MEDIASUBTYPE_H263",
|
|
TSMF_SUB_TYPE_H263 },
|
|
|
|
/* WebMMF codec IDS */
|
|
{ { 0x56, 0x50, 0x38, 0x30, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B,
|
|
0x71 },
|
|
"MEDIASUBTYPE_VP8",
|
|
TSMF_SUB_TYPE_VP8 },
|
|
|
|
{ { 0x0B, 0xD1, 0x2F, 0x8D, 0x41, 0x58, 0x6B, 0x4A, 0x89, 0x05, 0x58, 0x8F, 0xEC, 0x1A, 0xDE,
|
|
0xD9 },
|
|
"MEDIASUBTYPE_OGG",
|
|
TSMF_SUB_TYPE_OGG },
|
|
|
|
{ { 0 }, "Unknown", TSMF_SUB_TYPE_UNKNOWN }
|
|
|
|
};
|
|
|
|
static const TSMFMediaTypeMap tsmf_format_type_map[] = {
|
|
/* AED4AB2D-7326-43CB-9464-C879CAB9C43D */
|
|
{ { 0x2D, 0xAB, 0xD4, 0xAE, 0x26, 0x73, 0xCB, 0x43, 0x94, 0x64, 0xC8, 0x79, 0xCA, 0xB9, 0xC4,
|
|
0x3D },
|
|
"FORMAT_MFVideoFormat",
|
|
TSMF_FORMAT_TYPE_MFVIDEOFORMAT },
|
|
|
|
/* 05589F81-C356-11CE-BF01-00AA0055595A */
|
|
{ { 0x81, 0x9F, 0x58, 0x05, 0x56, 0xC3, 0xCE, 0x11, 0xBF, 0x01, 0x00, 0xAA, 0x00, 0x55, 0x59,
|
|
0x5A },
|
|
"FORMAT_WaveFormatEx",
|
|
TSMF_FORMAT_TYPE_WAVEFORMATEX },
|
|
|
|
/* E06D80E3-DB46-11CF-B4D1-00805F6CBBEA */
|
|
{ { 0xE3, 0x80, 0x6D, 0xE0, 0x46, 0xDB, 0xCF, 0x11, 0xB4, 0xD1, 0x00, 0x80, 0x5F, 0x6C, 0xBB,
|
|
0xEA },
|
|
"FORMAT_MPEG2_VIDEO",
|
|
TSMF_FORMAT_TYPE_MPEG2VIDEOINFO },
|
|
|
|
/* F72A76A0-EB0A-11D0-ACE4-0000C0CC16BA */
|
|
{ { 0xA0, 0x76, 0x2A, 0xF7, 0x0A, 0xEB, 0xD0, 0x11, 0xAC, 0xE4, 0x00, 0x00, 0xC0, 0xCC, 0x16,
|
|
0xBA },
|
|
"FORMAT_VideoInfo2",
|
|
TSMF_FORMAT_TYPE_VIDEOINFO2 },
|
|
|
|
/* 05589F82-C356-11CE-BF01-00AA0055595A */
|
|
{ { 0x82, 0x9F, 0x58, 0x05, 0x56, 0xC3, 0xCE, 0x11, 0xBF, 0x01, 0x00, 0xAA, 0x00, 0x55, 0x59,
|
|
0x5A },
|
|
"FORMAT_MPEG1_VIDEO",
|
|
TSMF_FORMAT_TYPE_MPEG1VIDEOINFO },
|
|
|
|
{ { 0 }, "Unknown", TSMF_FORMAT_TYPE_UNKNOWN }
|
|
};
|
|
|
|
static void tsmf_print_guid(const BYTE* guid)
|
|
{
|
|
#ifdef WITH_DEBUG_TSMF
|
|
char guidString[37];
|
|
|
|
snprintf(guidString, sizeof(guidString),
|
|
"%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "-%02" PRIX8 "%02" PRIX8 "-%02" PRIX8
|
|
"%02" PRIX8 "-%02" PRIX8 "%02" PRIX8 "-%02" PRIX8 "%02" PRIX8 "%02" PRIX8 "%02" PRIX8
|
|
"%02" PRIX8 "%02" PRIX8 "",
|
|
guid[3], guid[2], guid[1], guid[0], guid[5], guid[4], guid[7], guid[6], guid[8],
|
|
guid[9], guid[10], guid[11], guid[12], guid[13], guid[14], guid[15]);
|
|
|
|
WLog_INFO(TAG, "%s", guidString);
|
|
#endif
|
|
}
|
|
|
|
/* http://msdn.microsoft.com/en-us/library/dd318229.aspx */
|
|
static UINT32 tsmf_codec_parse_BITMAPINFOHEADER(TS_AM_MEDIA_TYPE* mediatype, wStream* s,
|
|
BOOL bypass)
|
|
{
|
|
UINT32 biSize;
|
|
UINT32 biWidth;
|
|
UINT32 biHeight;
|
|
|
|
if (Stream_GetRemainingLength(s) < 40)
|
|
return 0;
|
|
Stream_Read_UINT32(s, biSize);
|
|
Stream_Read_UINT32(s, biWidth);
|
|
Stream_Read_UINT32(s, biHeight);
|
|
Stream_Seek(s, 28);
|
|
|
|
if (mediatype->Width == 0)
|
|
mediatype->Width = biWidth;
|
|
|
|
if (mediatype->Height == 0)
|
|
mediatype->Height = biHeight;
|
|
|
|
/* Assume there will be no color table for video? */
|
|
if ((biSize < 40) || (Stream_GetRemainingLength(s) < (biSize - 40)))
|
|
return 0;
|
|
|
|
if (bypass && biSize > 40)
|
|
Stream_Seek(s, biSize - 40);
|
|
|
|
return (bypass ? biSize : 40);
|
|
}
|
|
|
|
/* http://msdn.microsoft.com/en-us/library/dd407326.aspx */
|
|
static UINT32 tsmf_codec_parse_VIDEOINFOHEADER2(TS_AM_MEDIA_TYPE* mediatype, wStream* s)
|
|
{
|
|
UINT64 AvgTimePerFrame;
|
|
|
|
/* VIDEOINFOHEADER2.rcSource, RECT(LONG left, LONG top, LONG right, LONG bottom) */
|
|
if (Stream_GetRemainingLength(s) < 72)
|
|
return 0;
|
|
|
|
Stream_Seek_UINT32(s);
|
|
Stream_Seek_UINT32(s);
|
|
Stream_Read_UINT32(s, mediatype->Width);
|
|
Stream_Read_UINT32(s, mediatype->Height);
|
|
/* VIDEOINFOHEADER2.rcTarget */
|
|
Stream_Seek(s, 16);
|
|
/* VIDEOINFOHEADER2.dwBitRate */
|
|
Stream_Read_UINT32(s, mediatype->BitRate);
|
|
/* VIDEOINFOHEADER2.dwBitErrorRate */
|
|
Stream_Seek_UINT32(s);
|
|
/* VIDEOINFOHEADER2.AvgTimePerFrame */
|
|
Stream_Read_UINT64(s, AvgTimePerFrame);
|
|
mediatype->SamplesPerSecond.Numerator = 1000000;
|
|
mediatype->SamplesPerSecond.Denominator = (int)(AvgTimePerFrame / 10LL);
|
|
/* Remaining fields before bmiHeader */
|
|
Stream_Seek(s, 24);
|
|
return 72;
|
|
}
|
|
|
|
/* http://msdn.microsoft.com/en-us/library/dd390700.aspx */
|
|
static UINT32 tsmf_codec_parse_VIDEOINFOHEADER(TS_AM_MEDIA_TYPE* mediatype, wStream* s)
|
|
{
|
|
/*
|
|
typedef struct tagVIDEOINFOHEADER {
|
|
RECT rcSource; //16
|
|
RECT rcTarget; //16 32
|
|
DWORD dwBitRate; //4 36
|
|
DWORD dwBitErrorRate; //4 40
|
|
REFERENCE_TIME AvgTimePerFrame; //8 48
|
|
BITMAPINFOHEADER bmiHeader;
|
|
} VIDEOINFOHEADER;
|
|
*/
|
|
UINT64 AvgTimePerFrame;
|
|
|
|
if (Stream_GetRemainingLength(s) < 48)
|
|
return 0;
|
|
|
|
/* VIDEOINFOHEADER.rcSource, RECT(LONG left, LONG top, LONG right, LONG bottom) */
|
|
Stream_Seek_UINT32(s);
|
|
Stream_Seek_UINT32(s);
|
|
Stream_Read_UINT32(s, mediatype->Width);
|
|
Stream_Read_UINT32(s, mediatype->Height);
|
|
/* VIDEOINFOHEADER.rcTarget */
|
|
Stream_Seek(s, 16);
|
|
/* VIDEOINFOHEADER.dwBitRate */
|
|
Stream_Read_UINT32(s, mediatype->BitRate);
|
|
/* VIDEOINFOHEADER.dwBitErrorRate */
|
|
Stream_Seek_UINT32(s);
|
|
/* VIDEOINFOHEADER.AvgTimePerFrame */
|
|
Stream_Read_UINT64(s, AvgTimePerFrame);
|
|
mediatype->SamplesPerSecond.Numerator = 1000000;
|
|
mediatype->SamplesPerSecond.Denominator = (int)(AvgTimePerFrame / 10LL);
|
|
return 48;
|
|
}
|
|
|
|
static BOOL tsmf_read_format_type(TS_AM_MEDIA_TYPE* mediatype, wStream* s, UINT32 cbFormat)
|
|
{
|
|
UINT32 i, j;
|
|
|
|
switch (mediatype->FormatType)
|
|
{
|
|
case TSMF_FORMAT_TYPE_MFVIDEOFORMAT:
|
|
/* http://msdn.microsoft.com/en-us/library/aa473808.aspx */
|
|
if (Stream_GetRemainingLength(s) < 176)
|
|
return FALSE;
|
|
|
|
Stream_Seek(s, 8); /* dwSize and ? */
|
|
Stream_Read_UINT32(s, mediatype->Width); /* videoInfo.dwWidth */
|
|
Stream_Read_UINT32(s, mediatype->Height); /* videoInfo.dwHeight */
|
|
Stream_Seek(s, 32);
|
|
/* videoInfo.FramesPerSecond */
|
|
Stream_Read_UINT32(s, mediatype->SamplesPerSecond.Numerator);
|
|
Stream_Read_UINT32(s, mediatype->SamplesPerSecond.Denominator);
|
|
Stream_Seek(s, 80);
|
|
Stream_Read_UINT32(s, mediatype->BitRate); /* compressedInfo.AvgBitrate */
|
|
Stream_Seek(s, 36);
|
|
|
|
if (cbFormat > 176)
|
|
{
|
|
mediatype->ExtraDataSize = cbFormat - 176;
|
|
mediatype->ExtraData = Stream_Pointer(s);
|
|
}
|
|
break;
|
|
|
|
case TSMF_FORMAT_TYPE_WAVEFORMATEX:
|
|
/* http://msdn.microsoft.com/en-us/library/dd757720.aspx */
|
|
if (Stream_GetRemainingLength(s) < 18)
|
|
return FALSE;
|
|
|
|
Stream_Seek_UINT16(s);
|
|
Stream_Read_UINT16(s, mediatype->Channels);
|
|
Stream_Read_UINT32(s, mediatype->SamplesPerSecond.Numerator);
|
|
mediatype->SamplesPerSecond.Denominator = 1;
|
|
Stream_Read_UINT32(s, mediatype->BitRate);
|
|
mediatype->BitRate *= 8;
|
|
Stream_Read_UINT16(s, mediatype->BlockAlign);
|
|
Stream_Read_UINT16(s, mediatype->BitsPerSample);
|
|
Stream_Read_UINT16(s, mediatype->ExtraDataSize);
|
|
|
|
if (mediatype->ExtraDataSize > 0)
|
|
{
|
|
if (Stream_GetRemainingLength(s) < mediatype->ExtraDataSize)
|
|
return FALSE;
|
|
mediatype->ExtraData = Stream_Pointer(s);
|
|
}
|
|
break;
|
|
|
|
case TSMF_FORMAT_TYPE_MPEG1VIDEOINFO:
|
|
/* http://msdn.microsoft.com/en-us/library/dd390700.aspx */
|
|
i = tsmf_codec_parse_VIDEOINFOHEADER(mediatype, s);
|
|
if (!i)
|
|
return FALSE;
|
|
j = tsmf_codec_parse_BITMAPINFOHEADER(mediatype, s, TRUE);
|
|
if (!j)
|
|
return FALSE;
|
|
i += j;
|
|
|
|
if (cbFormat > i)
|
|
{
|
|
mediatype->ExtraDataSize = cbFormat - i;
|
|
if (Stream_GetRemainingLength(s) < mediatype->ExtraDataSize)
|
|
return FALSE;
|
|
mediatype->ExtraData = Stream_Pointer(s);
|
|
}
|
|
break;
|
|
|
|
case TSMF_FORMAT_TYPE_MPEG2VIDEOINFO:
|
|
/* http://msdn.microsoft.com/en-us/library/dd390707.aspx */
|
|
i = tsmf_codec_parse_VIDEOINFOHEADER2(mediatype, s);
|
|
if (!i)
|
|
return FALSE;
|
|
j = tsmf_codec_parse_BITMAPINFOHEADER(mediatype, s, TRUE);
|
|
if (!j)
|
|
return FALSE;
|
|
i += j;
|
|
|
|
if (cbFormat > i)
|
|
{
|
|
mediatype->ExtraDataSize = cbFormat - i;
|
|
if (Stream_GetRemainingLength(s) < mediatype->ExtraDataSize)
|
|
return FALSE;
|
|
mediatype->ExtraData = Stream_Pointer(s);
|
|
}
|
|
break;
|
|
|
|
case TSMF_FORMAT_TYPE_VIDEOINFO2:
|
|
i = tsmf_codec_parse_VIDEOINFOHEADER2(mediatype, s);
|
|
if (!i)
|
|
return FALSE;
|
|
j = tsmf_codec_parse_BITMAPINFOHEADER(mediatype, s, FALSE);
|
|
if (!j)
|
|
return FALSE;
|
|
i += j;
|
|
|
|
if (cbFormat > i)
|
|
{
|
|
mediatype->ExtraDataSize = cbFormat - i;
|
|
if (Stream_GetRemainingLength(s) < mediatype->ExtraDataSize)
|
|
return FALSE;
|
|
mediatype->ExtraData = Stream_Pointer(s);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
WLog_INFO(TAG, "unhandled format type 0x%x", mediatype->FormatType);
|
|
break;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL tsmf_codec_parse_media_type(TS_AM_MEDIA_TYPE* mediatype, wStream* s)
|
|
{
|
|
UINT32 cbFormat;
|
|
BOOL ret = TRUE;
|
|
int i;
|
|
|
|
ZeroMemory(mediatype, sizeof(TS_AM_MEDIA_TYPE));
|
|
|
|
/* MajorType */
|
|
DEBUG_TSMF("MediaMajorType:");
|
|
if (Stream_GetRemainingLength(s) < 16)
|
|
return FALSE;
|
|
tsmf_print_guid(Stream_Pointer(s));
|
|
|
|
for (i = 0; tsmf_major_type_map[i].type != TSMF_MAJOR_TYPE_UNKNOWN; i++)
|
|
{
|
|
if (memcmp(tsmf_major_type_map[i].guid, Stream_Pointer(s), 16) == 0)
|
|
break;
|
|
}
|
|
|
|
mediatype->MajorType = tsmf_major_type_map[i].type;
|
|
if (mediatype->MajorType == TSMF_MAJOR_TYPE_UNKNOWN)
|
|
ret = FALSE;
|
|
|
|
DEBUG_TSMF("MediaMajorType %s", tsmf_major_type_map[i].name);
|
|
Stream_Seek(s, 16);
|
|
|
|
/* SubType */
|
|
DEBUG_TSMF("MediaSubType:");
|
|
if (Stream_GetRemainingLength(s) < 16)
|
|
return FALSE;
|
|
tsmf_print_guid(Stream_Pointer(s));
|
|
|
|
for (i = 0; tsmf_sub_type_map[i].type != TSMF_SUB_TYPE_UNKNOWN; i++)
|
|
{
|
|
if (memcmp(tsmf_sub_type_map[i].guid, Stream_Pointer(s), 16) == 0)
|
|
break;
|
|
}
|
|
|
|
mediatype->SubType = tsmf_sub_type_map[i].type;
|
|
if (mediatype->SubType == TSMF_SUB_TYPE_UNKNOWN)
|
|
ret = FALSE;
|
|
|
|
DEBUG_TSMF("MediaSubType %s", tsmf_sub_type_map[i].name);
|
|
Stream_Seek(s, 16);
|
|
|
|
/* bFixedSizeSamples, bTemporalCompression, SampleSize */
|
|
if (Stream_GetRemainingLength(s) < 12)
|
|
return FALSE;
|
|
Stream_Seek(s, 12);
|
|
|
|
/* FormatType */
|
|
DEBUG_TSMF("FormatType:");
|
|
if (Stream_GetRemainingLength(s) < 16)
|
|
return FALSE;
|
|
tsmf_print_guid(Stream_Pointer(s));
|
|
|
|
for (i = 0; tsmf_format_type_map[i].type != TSMF_FORMAT_TYPE_UNKNOWN; i++)
|
|
{
|
|
if (memcmp(tsmf_format_type_map[i].guid, Stream_Pointer(s), 16) == 0)
|
|
break;
|
|
}
|
|
|
|
mediatype->FormatType = tsmf_format_type_map[i].type;
|
|
if (mediatype->FormatType == TSMF_FORMAT_TYPE_UNKNOWN)
|
|
ret = FALSE;
|
|
|
|
DEBUG_TSMF("FormatType %s", tsmf_format_type_map[i].name);
|
|
Stream_Seek(s, 16);
|
|
|
|
/* cbFormat */
|
|
if (Stream_GetRemainingLength(s) < 4)
|
|
return FALSE;
|
|
Stream_Read_UINT32(s, cbFormat);
|
|
DEBUG_TSMF("cbFormat %" PRIu32 "", cbFormat);
|
|
#ifdef WITH_DEBUG_TSMF
|
|
winpr_HexDump(TAG, WLOG_DEBUG, Stream_Pointer(s), cbFormat);
|
|
#endif
|
|
|
|
ret = tsmf_read_format_type(mediatype, s, cbFormat);
|
|
|
|
if (mediatype->SamplesPerSecond.Numerator == 0)
|
|
mediatype->SamplesPerSecond.Numerator = 1;
|
|
|
|
if (mediatype->SamplesPerSecond.Denominator == 0)
|
|
mediatype->SamplesPerSecond.Denominator = 1;
|
|
|
|
return ret;
|
|
}
|
|
|
|
BOOL tsmf_codec_check_media_type(const char* decoder_name, wStream* s)
|
|
{
|
|
BYTE* m;
|
|
BOOL ret = FALSE;
|
|
TS_AM_MEDIA_TYPE mediatype;
|
|
|
|
static BOOL decoderAvailable = FALSE;
|
|
static BOOL firstRun = TRUE;
|
|
|
|
if (firstRun)
|
|
{
|
|
firstRun = FALSE;
|
|
if (tsmf_check_decoder_available(decoder_name))
|
|
decoderAvailable = TRUE;
|
|
}
|
|
|
|
Stream_GetPointer(s, m);
|
|
if (decoderAvailable)
|
|
ret = tsmf_codec_parse_media_type(&mediatype, s);
|
|
Stream_SetPointer(s, m);
|
|
|
|
if (ret)
|
|
{
|
|
ITSMFDecoder* decoder = tsmf_load_decoder(decoder_name, &mediatype);
|
|
|
|
if (!decoder)
|
|
{
|
|
WLog_WARN(TAG, "Format not supported by decoder %s", decoder_name);
|
|
ret = FALSE;
|
|
}
|
|
else
|
|
{
|
|
decoder->Free(decoder);
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|