src/subtitles/SubtitleInputPin.cpp

   1 /*
   2  *      Copyright (C) 2003-2006 Gabest
   3  *      http://www.gabest.org
   4  *
   5  *  This Program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2, or (at your option)
   8  *  any later version.
   9  *
  10  *  This Program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with GNU Make; see the file COPYING.  If not, write to
  17  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  18  *  http://www.gnu.org/copyleft/gpl.html
  19  *
  20  */
  21
  22 #include "stdafx.h"
  23 #include "SubtitleInputPin.h"
  24 #include "VobSubFile.h"
  25 #include "RTS.h"
  26 #include "SSF.h"
  27 #include "RenderedHdmvSubtitle.h"
  28
  29 #include <initguid.h>
  30 #include "..\..\include\moreuuids.h"
  31
  32 // our first format id
  33 #define __GAB1__ "GAB1"
  34
  35 // our tags for __GAB1__ (ushort) + size (ushort)
  36
  37 // "lang" + '0'
  38 #define __GAB1_LANGUAGE__ 0
  39 // (int)start+(int)stop+(char*)line+'0'
  40 #define __GAB1_ENTRY__ 1
  41 // L"lang" + '0'
  42 #define __GAB1_LANGUAGE_UNICODE__ 2
  43 // (int)start+(int)stop+(WCHAR*)line+'0'
  44 #define __GAB1_ENTRY_UNICODE__ 3
  45
  46 // same as __GAB1__, but the size is (uint) and only __GAB1_LANGUAGE_UNICODE__ is valid
  47 #define __GAB2__ "GAB2"
  48
  49 // (BYTE*)
  50 #define __GAB1_RAWTEXTSUBTITLE__ 4
  51
  52 CSubtitleInputPin::CSubtitleInputPin(CBaseFilter* pFilter, CCritSec* pLock, CCritSec* pSubLock, HRESULT* phr)
  53         : CBaseInputPin(NAME("CSubtitleInputPin"), pFilter, pLock, phr, L"Input")
  54         , m_pSubLock(pSubLock)
  55 {
  56         m_bCanReconnectWhenActive = TRUE;
  57 }
  58
  59 HRESULT CSubtitleInputPin::CheckMediaType(const CMediaType* pmt)
  60 {
  61         return pmt->majortype == MEDIATYPE_Text && (pmt->subtype == MEDIASUBTYPE_NULL || pmt->subtype == FOURCCMap((DWORD)0))
  62                 || pmt->majortype == MEDIATYPE_Subtitle && pmt->subtype == MEDIASUBTYPE_UTF8
  63                 || pmt->majortype == MEDIATYPE_Subtitle && (pmt->subtype == MEDIASUBTYPE_SSA || pmt->subtype == MEDIASUBTYPE_ASS || pmt->subtype == MEDIASUBTYPE_ASS2)
  64                 || pmt->majortype == MEDIATYPE_Subtitle && pmt->subtype == MEDIASUBTYPE_SSF
  65                 || pmt->majortype == MEDIATYPE_Subtitle && (pmt->subtype == MEDIASUBTYPE_VOBSUB)
  66         || IsHdmvSub(pmt)
  67                 ? S_OK
  68                 : E_FAIL;
  69 }
  70
  71 HRESULT CSubtitleInputPin::CompleteConnect(IPin* pReceivePin)
  72 {
  73     AMTRACE((TEXT(__FUNCTION__),0));
  74         if(m_mt.majortype == MEDIATYPE_Text)
  75         {
  76         CRenderedTextSubtitle* pRTS = new CRenderedTextSubtitle(m_pSubLock);
  77                 if(!(m_pSubStream = pRTS)) return E_FAIL;
  78                 pRTS->m_name = CString(GetPinName(pReceivePin)) + _T(" (embeded)");
  79                 pRTS->m_dstScreenSize = CSize(384, 288);
  80                 pRTS->CreateDefaultStyle(DEFAULT_CHARSET);
  81         }
  82         else if(m_mt.majortype == MEDIATYPE_Subtitle)
  83         {
  84                 SUBTITLEINFO* psi = (SUBTITLEINFO*)m_mt.pbFormat;
  85                 DWORD                   dwOffset        = 0;
  86                 CString                 name;
  87                 LCID                    lcid = 0;
  88
  89                 if (psi != NULL) {
  90                         dwOffset = psi->dwOffset;
  91
  92                         name = ISO6392ToLanguage(psi->IsoLang);
  93                         lcid = ISO6392ToLcid(psi->IsoLang);
  94
  95                         if(wcslen(psi->TrackName) > 0) {
  96                                 name += (!name.IsEmpty() ? _T(", ") : _T("")) + CString(psi->TrackName);
  97                         }
  98                         if(name.IsEmpty()) {
  99                                 name = _T("Unknown");
 100                         }
 101                 }
 102
 103                 name.Replace(_T("\x19"), _T(""));//CAUTION: VS may show name.Replace(_T(""),_T("")), however there is a character in the first _T("")
 104                 name.Replace(_T("\x18"), _T(""));//CAUTION: VS may show name.Replace(_T(""),_T("")), however there is a character in the first _T("")
 105
 106                 if(m_mt.subtype == MEDIASUBTYPE_UTF8
 107                 /*|| m_mt.subtype == MEDIASUBTYPE_USF*/
 108                 || m_mt.subtype == MEDIASUBTYPE_SSA
 109                 || m_mt.subtype == MEDIASUBTYPE_ASS
 110                 || m_mt.subtype == MEDIASUBTYPE_ASS2)
 111                 {
 112             CRenderedTextSubtitle* pRTS = new CRenderedTextSubtitle(m_pSubLock);
 113                         if(!(m_pSubStream = pRTS)) return E_FAIL;
 114                         pRTS->m_name = name;
 115                         pRTS->m_lcid = lcid;
 116                         pRTS->m_dstScreenSize = CSize(384, 288);
 117                         pRTS->CreateDefaultStyle(DEFAULT_CHARSET);
 118
 119                         if(dwOffset > 0 && m_mt.cbFormat - dwOffset > 0)
 120                         {
 121                                 CMediaType mt = m_mt;
 122                                 if(mt.pbFormat[dwOffset+0] != 0xef
 123                                 && mt.pbFormat[dwOffset+1] != 0xbb
 124                                 && mt.pbFormat[dwOffset+2] != 0xfb)
 125                                 {
 126                                         dwOffset -= 3;
 127                                         mt.pbFormat[dwOffset+0] = 0xef;
 128                                         mt.pbFormat[dwOffset+1] = 0xbb;
 129                                         mt.pbFormat[dwOffset+2] = 0xbf;
 130                                 }
 131
 132                 pRTS->Open(mt.pbFormat + dwOffset, mt.cbFormat - dwOffset, DEFAULT_CHARSET, pRTS->m_name);
 133                         }
 134
 135                 }
 136                 else if(m_mt.subtype == MEDIASUBTYPE_SSF)
 137                 {
 138             ssf::CRenderer* pSSF = new ssf::CRenderer(m_pSubLock);
 139                         if(!(m_pSubStream = pSSF)) return E_FAIL;
 140
 141                         pSSF->Open(ssf::MemoryInputStream(m_mt.pbFormat + dwOffset, m_mt.cbFormat - dwOffset, false, false), name);
 142                 }
 143                 else if(m_mt.subtype == MEDIASUBTYPE_VOBSUB)
 144                 {
 145             CVobSubStream* pVSS = new CVobSubStream(m_pSubLock);
 146                         if(!(m_pSubStream = pVSS)) return E_FAIL;
 147                         pVSS->Open(name, m_mt.pbFormat + dwOffset, m_mt.cbFormat - dwOffset);
 148                 }
 149                 else if (IsHdmvSub(&m_mt))
 150                 {
 151                         if(!(m_pSubStream = DNew CRenderedHdmvSubtitle(m_pSubLock, (m_mt.subtype == MEDIASUBTYPE_DVB_SUBTITLES) ? ST_DVB : ST_HDMV, name, lcid))) {
 152                                 return E_FAIL;
 153                         }
 154                 }
 155         }
 156
 157         AddSubStream(m_pSubStream);
 158
 159     return __super::CompleteConnect(pReceivePin);
 160 }
 161
 162 HRESULT CSubtitleInputPin::BreakConnect()
 163 {
 164         RemoveSubStream(m_pSubStream);
 165         m_pSubStream = NULL;
 166
 167         ASSERT(IsStopped());
 168
 169     return __super::BreakConnect();
 170 }
 171
 172 STDMETHODIMP CSubtitleInputPin::ReceiveConnection(IPin* pConnector, const AM_MEDIA_TYPE* pmt)
 173 {
 174         if(m_Connected)
 175         {
 176                 RemoveSubStream(m_pSubStream);
 177                 m_pSubStream = NULL;
 178
 179         m_Connected->Release();
 180         m_Connected = NULL;
 181         }
 182
 183         return __super::ReceiveConnection(pConnector, pmt);
 184 }
 185
 186 STDMETHODIMP CSubtitleInputPin::NewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
 187 {
 188     DbgLog(( LOG_TRACE, 4, TEXT(__FUNCTION__) ));
 189         CAutoLock cAutoLock(&m_csReceive);
 190
 191         if(m_mt.majortype == MEDIATYPE_Text
 192         || m_mt.majortype == MEDIATYPE_Subtitle
 193                 && (m_mt.subtype == MEDIASUBTYPE_UTF8
 194                 /*|| m_mt.subtype == MEDIASUBTYPE_USF*/
 195                 || m_mt.subtype == MEDIASUBTYPE_SSA
 196                 || m_mt.subtype == MEDIASUBTYPE_ASS
 197                 || m_mt.subtype == MEDIASUBTYPE_ASS2))
 198         {
 199                 CAutoLock cAutoLock(m_pSubLock);
 200                 CRenderedTextSubtitle* pRTS = dynamic_cast<CRenderedTextSubtitle*>(static_cast<ISubStream*>(m_pSubStream));
 201                 pRTS->RemoveAllEntries();
 202         pRTS->CreateSegments();
 203         }
 204         else if(m_mt.majortype == MEDIATYPE_Subtitle && m_mt.subtype == MEDIASUBTYPE_SSF)
 205         {
 206                 CAutoLock cAutoLock(m_pSubLock);
 207                 ssf::CRenderer* pSSF = dynamic_cast<ssf::CRenderer*>(static_cast<ISubStream*>(m_pSubStream));
 208                 // LAME, implement RemoveSubtitles
 209                 DWORD dwOffset = ((SUBTITLEINFO*)m_mt.pbFormat)->dwOffset;
 210                 pSSF->Open(ssf::MemoryInputStream(m_mt.pbFormat + dwOffset, m_mt.cbFormat - dwOffset, false, false), _T(""));
 211                 // pSSF->RemoveSubtitles();
 212         }
 213         else if(m_mt.majortype == MEDIATYPE_Subtitle && (m_mt.subtype == MEDIASUBTYPE_VOBSUB))
 214         {
 215                 CAutoLock cAutoLock(m_pSubLock);
 216                 CVobSubStream* pVSS = dynamic_cast<CVobSubStream*>(static_cast<ISubStream*>(m_pSubStream));
 217                 pVSS->RemoveAll();
 218         }
 219         else if (IsHdmvSub(&m_mt))
 220         {
 221                 CAutoLock cAutoLock(m_pSubLock);
 222                 CRenderedHdmvSubtitle* pHdmvSubtitle = (CRenderedHdmvSubtitle*)(ISubStream*)m_pSubStream;
 223                 pHdmvSubtitle->NewSegment (tStart, tStop, dRate);
 224         }
 225         return __super::NewSegment(tStart, tStop, dRate);
 226 }
 227
 228 interface __declspec(uuid("D3D92BC3-713B-451B-9122-320095D51EA5"))
 229 IMpeg2DemultiplexerTesting :
 230 public IUnknown {
 231         STDMETHOD(GetMpeg2StreamType)(ULONG* plType) = NULL;
 232         STDMETHOD(toto)() = NULL;
 233 };
 234
 235 STDMETHODIMP CSubtitleInputPin::Receive(IMediaSample* pSample)
 236 {
 237     DbgLog(( LOG_TRACE, 4, TEXT(__FUNCTION__) ));
 238         HRESULT hr;
 239
 240         hr = __super::Receive(pSample);
 241     if(FAILED(hr)) return hr;
 242
 243         CAutoLock cAutoLock(&m_csReceive);
 244
 245         REFERENCE_TIME tStart, tStop;
 246     pSample->GetTime(&tStart, &tStop);
 247         tStart += m_tStart;
 248         tStop += m_tStart;
 249
 250         BYTE* pData = NULL;
 251     hr = pSample->GetPointer(&pData);
 252     if(FAILED(hr) || pData == NULL) return hr;
 253
 254         int len = pSample->GetActualDataLength();
 255
 256         bool fInvalidate = false;
 257
 258         if(m_mt.majortype == MEDIATYPE_Text)
 259         {
 260                 CAutoLock cAutoLock(m_pSubLock);
 261                 CRenderedTextSubtitle* pRTS = dynamic_cast<CRenderedTextSubtitle*>(static_cast<ISubStream*>(m_pSubStream));
 262
 263                 if(!strncmp((char*)pData, __GAB1__, strlen(__GAB1__)))
 264                 {
 265                         char* ptr = (char*)&pData[strlen(__GAB1__)+1];
 266                         char* end = (char*)&pData[len];
 267
 268                         while(ptr < end)
 269                         {
 270                                 WORD tag = *((WORD*)(ptr)); ptr += 2;
 271                                 WORD size = *((WORD*)(ptr)); ptr += 2;
 272
 273                                 if(tag == __GAB1_LANGUAGE__)
 274                                 {
 275                                         pRTS->m_name = CString(ptr);
 276                                 }
 277                                 else if(tag == __GAB1_ENTRY__)
 278                                 {
 279                                         pRTS->Add(AToW(&ptr[8]), false, *(int*)ptr, *(int*)(ptr+4));
 280                                         fInvalidate = true;
 281                                 }
 282                                 else if(tag == __GAB1_LANGUAGE_UNICODE__)
 283                                 {
 284                                         pRTS->m_name = (WCHAR*)ptr;
 285                                 }
 286                                 else if(tag == __GAB1_ENTRY_UNICODE__)
 287                                 {
 288                                         pRTS->Add((WCHAR*)(ptr+8), true, *(int*)ptr, *(int*)(ptr+4));
 289                                         fInvalidate = true;
 290                                 }
 291
 292                                 ptr += size;
 293                         }
 294                 }
 295                 else if(!strncmp((char*)pData, __GAB2__, strlen(__GAB2__)))
 296                 {
 297                         char* ptr = (char*)&pData[strlen(__GAB2__)+1];
 298                         char* end = (char*)&pData[len];
 299
 300                         while(ptr < end)
 301                         {
 302                                 WORD tag = *((WORD*)(ptr)); ptr += 2;
 303                                 DWORD size = *((DWORD*)(ptr)); ptr += 4;
 304
 305                                 if(tag == __GAB1_LANGUAGE_UNICODE__)
 306                                 {
 307                                         pRTS->m_name = (WCHAR*)ptr;
 308                                 }
 309                                 else if(tag == __GAB1_RAWTEXTSUBTITLE__)
 310                                 {
 311                                         pRTS->Open((BYTE*)ptr, size, DEFAULT_CHARSET, pRTS->m_name);
 312                                         fInvalidate = true;
 313                                 }
 314
 315                                 ptr += size;
 316                         }
 317                 }
 318                 else if(pData != 0 && len > 1 && *pData != 0)
 319                 {
 320                         CStringA str((char*)pData, len);
 321
 322                         str.Replace("\r\n", "\n");
 323                         str.Trim();
 324
 325                         if(!str.IsEmpty())
 326                         {
 327                                 pRTS->Add(AToW(str), false, (int)(tStart / 10000), (int)(tStop / 10000));
 328                                 fInvalidate = true;
 329                         }
 330                 }
 331         }
 332         else if(m_mt.majortype == MEDIATYPE_Subtitle)
 333         {
 334                 CAutoLock cAutoLock(m_pSubLock);
 335
 336                 if(m_mt.subtype == MEDIASUBTYPE_UTF8)
 337                 {
 338                         CRenderedTextSubtitle* pRTS = dynamic_cast<CRenderedTextSubtitle*>(static_cast<ISubStream*>(m_pSubStream));
 339
 340                         CStringW str = UTF8To16(CStringA((LPCSTR)pData, len)).Trim();
 341                         if(!str.IsEmpty())
 342                         {
 343                                 pRTS->Add(str, true, (int)(tStart / 10000), (int)(tStop / 10000));
 344                                 fInvalidate = true;
 345                         }
 346                 }
 347                 else if(m_mt.subtype == MEDIASUBTYPE_SSA || m_mt.subtype == MEDIASUBTYPE_ASS || m_mt.subtype == MEDIASUBTYPE_ASS2)
 348                 {
 349                         CRenderedTextSubtitle* pRTS = dynamic_cast<CRenderedTextSubtitle*>(static_cast<ISubStream*>(m_pSubStream));
 350
 351                         CStringW str = UTF8To16(CStringA((LPCSTR)pData, len)).Trim();
 352                         if(!str.IsEmpty())
 353                         {
 354                                 STSEntry stse;
 355
 356                                 int fields = m_mt.subtype == MEDIASUBTYPE_ASS2 ? 10 : 9;
 357
 358                                 CAtlList<CStringW> sl;
 359                                 Explode(str, sl, ',', fields);
 360                                 if(sl.GetCount() == fields)
 361                                 {
 362                                         stse.readorder = wcstol(sl.RemoveHead(), NULL, 10);
 363                                         stse.layer = wcstol(sl.RemoveHead(), NULL, 10);
 364                                         stse.style = sl.RemoveHead();
 365                                         stse.actor = sl.RemoveHead();
 366                                         stse.marginRect.left = wcstol(sl.RemoveHead(), NULL, 10);
 367                                         stse.marginRect.right = wcstol(sl.RemoveHead(), NULL, 10);
 368                                         stse.marginRect.top = stse.marginRect.bottom = wcstol(sl.RemoveHead(), NULL, 10);
 369                                         if(fields == 10) stse.marginRect.bottom = wcstol(sl.RemoveHead(), NULL, 10);
 370                                         stse.effect = sl.RemoveHead();
 371                                         stse.str = sl.RemoveHead();
 372                                 }
 373
 374                                 if(!stse.str.IsEmpty())
 375                                 {
 376                                         pRTS->Add(stse.str, true, (int)(tStart / 10000), (int)(tStop / 10000),
 377                                                 stse.style, stse.actor, stse.effect, stse.marginRect, stse.layer, stse.readorder);
 378                                         fInvalidate = true;
 379                                 }
 380                         }
 381                 }
 382                 else if(m_mt.subtype == MEDIASUBTYPE_SSF)
 383                 {
 384                         ssf::CRenderer* pSSF = dynamic_cast<ssf::CRenderer*>(static_cast<ISubStream*>(m_pSubStream));
 385
 386                         CStringW str = UTF8To16(CStringA((LPCSTR)pData, len)).Trim();
 387                         if(!str.IsEmpty())
 388                         {
 389                                 pSSF->Append(tStart, tStop, str);
 390                                 fInvalidate = true;
 391                         }
 392                 }
 393                 else if(m_mt.subtype == MEDIASUBTYPE_VOBSUB)
 394                 {
 395                         CVobSubStream* pVSS = dynamic_cast<CVobSubStream*>(static_cast<ISubStream*>(m_pSubStream));
 396                         pVSS->Add(tStart, tStop, pData, len);
 397                 }
 398                 else if (IsHdmvSub(&m_mt))
 399                 {
 400                         CAutoLock cAutoLock(m_pSubLock);
 401                         CRenderedHdmvSubtitle* pHdmvSubtitle = (CRenderedHdmvSubtitle*)(ISubStream*)m_pSubStream;
 402                         pHdmvSubtitle->ParseSample (pSample);
 403                 }
 404         }
 405
 406         if(fInvalidate)
 407         {
 408                 TRACE(_T("InvalidateSubtitle(%I64d, ..)\n"), tStart);
 409                 // IMPORTANT: m_pSubLock must not be locked when calling this
 410                 InvalidateSubtitle(tStart, m_pSubStream);
 411         }
 412
 413         hr = S_OK;
 414
 415     return hr;
 416 }
 417
 418 bool CSubtitleInputPin::IsHdmvSub(const CMediaType* pmt)
 419 {
 420         return pmt->majortype == MEDIATYPE_Subtitle && (pmt->subtype == MEDIASUBTYPE_HDMVSUB ||                 // Blu ray presentation graphics
 421                         pmt->subtype == MEDIASUBTYPE_DVB_SUBTITLES ||   // DVB subtitles
 422                         (pmt->subtype == MEDIASUBTYPE_NULL && pmt->formattype == FORMAT_SubtitleInfo)) // Workaround : support for Haali PGS
 423                    ? true
 424                    : false;
 425 }