src/subtitles/RealTextParser.cpp

   1 #include "StdAfx.h"
   2 #include "RealTextParser.h"
   3
   4 CRealTextParser::CRealTextParser(void):
   5         m_bIgnoreFont(false),
   6         m_bIgnoreFontSize(false),
   7         m_bIgnoreFontColor(false),
   8         m_bIgnoreFontWeight(false),
   9         m_bIgnoreFontFace(false),
  10         m_iMinFontSize(14),
  11         m_iMaxFontSize(25),
  12         m_iDefaultSubtitleDurationInMillisecs(4000),
  13         m_bTryToIgnoreErrors(true)
  14 {
  15 }
  16
  17 CRealTextParser::~CRealTextParser(void)
  18 {
  19 }
  20
  21 bool CRealTextParser::ParseRealText(wstring p_szFile)
  22 {
  23         vector<int> vStartTimecodes;
  24         vector<int> vEndTimecodes;
  25         bool bPrevEndTimeMissing(false);
  26         list<Tag> listTags;
  27         list<Tag> listPreviousOpenTags;
  28
  29         while (p_szFile.length() > 0)
  30         {
  31                 if (p_szFile.at(0) == '<')
  32                 {
  33                         Tag oTag;
  34                         if (!ExtractTag(p_szFile, oTag))
  35                                 return false;
  36
  37                         if (oTag.m_bComment)
  38                                 continue;
  39
  40                         if (oTag.m_szName == L"time")
  41                         {
  42                                 int iStartTimecode = GetTimecode(oTag.m_mapAttributes[L"begin"]);
  43                                 int iEndTimecode = GetTimecode(oTag.m_mapAttributes[L"end"]);
  44
  45 //                              FilterReduntantTags(listTags);
  46                                 wstring szLine = RenderTags(listTags);
  47
  48                                 if (bPrevEndTimeMissing)
  49                                 {
  50                                         pair<int, int> pairTimecodes(vStartTimecodes.back(), iStartTimecode);
  51
  52                                         // Fix issues where the next time code isn't valid end time code for the previous subtitle
  53                                         if (pairTimecodes.first >= pairTimecodes.second)
  54                                         {
  55                                                 pairTimecodes.second = pairTimecodes.first + m_iDefaultSubtitleDurationInMillisecs;
  56                                         }
  57
  58                                         if (szLine.length() > 0)
  59                                                 m_RealText.m_mapLines[pairTimecodes] = szLine;
  60
  61                                         bPrevEndTimeMissing = false;
  62                                 }
  63                                 else if (vStartTimecodes.size() > 0 && vEndTimecodes.size() > 0)
  64                                 {
  65                                         pair<int, int> pairTimecodes(vStartTimecodes.back(), vEndTimecodes.back());
  66
  67                                         if (szLine.length() > 0)
  68                                                 m_RealText.m_mapLines[pairTimecodes] = szLine;
  69
  70                                 }
  71
  72                                 vStartTimecodes.push_back(iStartTimecode);
  73                                 if (iEndTimecode <= 0)
  74                                 {
  75                                         bPrevEndTimeMissing = true;
  76                                 }
  77                                 else
  78                                 {
  79                                         vEndTimecodes.push_back(iEndTimecode);
  80                                 }
  81                         }
  82                         else if (oTag.m_szName == L"b" || oTag.m_szName == L"i" || oTag.m_szName == L"font")
  83                         {
  84                                 if (oTag.m_bOpen)
  85                                         listPreviousOpenTags.push_back(oTag);
  86
  87                                 if (oTag.m_bClose)
  88                                         PopTag(listPreviousOpenTags, oTag.m_szName);
  89
  90                                 listTags.push_back(oTag);
  91                         }
  92                         else if (oTag.m_szName == L"clear")
  93                         {
  94                                 listTags.clear();
  95
  96                                 // set existing tags
  97                                 listTags.insert(listTags.end(), listPreviousOpenTags.begin(), listPreviousOpenTags.end());
  98                         }
  99                         else if (oTag.m_szName == L"window")
 100                         {
 101                                 if (oTag.m_bOpen)
 102                                         m_RealText.m_WindowTag = oTag;
 103
 104                                 // Ignore close
 105                         }
 106                         else if (oTag.m_szName == L"center")
 107                         {
 108                                 m_RealText.m_bCenter = true;
 109                         }
 110                         else if (oTag.m_szName == L"required")
 111                         {
 112                                 // Ignore
 113                         }
 114                         else if (oTag.m_szName == L"")
 115                         {
 116                                 // Ignore
 117                         }
 118                         else
 119                         {
 120                                 // assume formating tag (handled later)
 121                                 listTags.push_back(oTag);
 122                         }
 123                 }
 124                 else
 125                 {
 126                         Tag oTextTag;
 127                         if (!ExtractTextTag(p_szFile, oTextTag))
 128                                 return false;
 129
 130                         listTags.push_back(oTextTag);
 131                 }
 132         }
 133
 134         // Handle final line
 135 //      FilterReduntantTags(listTags);
 136         wstring szLine = RenderTags(listTags);
 137
 138         if (bPrevEndTimeMissing)
 139         {
 140                 pair<int, int> pairTimecodes(vStartTimecodes.back(), vStartTimecodes.back() + m_iDefaultSubtitleDurationInMillisecs);
 141
 142                 if (szLine.length() > 0)
 143                         m_RealText.m_mapLines[pairTimecodes] = szLine;
 144
 145                 bPrevEndTimeMissing = false;
 146         }
 147         else if (vStartTimecodes.size() > 0 && vEndTimecodes.size() > 0)
 148         {
 149                 pair<int, int> pairTimecodes(vStartTimecodes.back(), vEndTimecodes.back());
 150
 151                 if (szLine.length() > 0)
 152                         m_RealText.m_mapLines[pairTimecodes] = szLine;
 153
 154         }
 155
 156         return true;
 157 }
 158
 159 const CRealTextParser::Subtitles& CRealTextParser::GetParsedSubtitles()
 160 {
 161         return m_RealText;
 162 }
 163
 164 bool CRealTextParser::ExtractTag(wstring& p_rszLine, Tag& p_rTag)
 165 {
 166         if (p_rszLine.length() < 2 || p_rszLine.at(0) != '<')
 167         {
 168                 if (m_bTryToIgnoreErrors)
 169                 {
 170                         size_t iTempPos = p_rszLine.find_first_of('<');
 171
 172                         if (iTempPos != wstring::npos)
 173                         {
 174                                 p_rszLine = p_rszLine.substr(iTempPos);
 175
 176                                 if (p_rszLine.length() < 2)
 177                                         return false;
 178                         }
 179
 180                 }
 181                 else
 182                 {
 183                         return false;
 184                 }
 185         }
 186
 187         unsigned int iPos = 1;
 188
 189         // skip comments
 190         if (p_rszLine.at(iPos) == '!')
 191         {
 192                 p_rTag.m_bComment = true;
 193
 194                 wstring szComment;
 195                 GetString(p_rszLine, iPos, szComment, L">");
 196                 p_rTag.m_szName = szComment;
 197
 198                 ++iPos; // Skip >
 199                 p_rszLine = p_rszLine.substr(iPos);
 200                 return true;
 201         }
 202         else
 203         {
 204                 p_rTag.m_bComment = false;
 205         }
 206
 207         if (!SkipSpaces(p_rszLine, iPos))
 208                 return false;
 209
 210         if (p_rszLine.at(iPos) == '/')
 211         {
 212                 p_rTag.m_bOpen = false;
 213                 p_rTag.m_bClose = true;
 214                 ++iPos;
 215         }
 216         else
 217         {
 218                 p_rTag.m_bOpen = true;
 219                 p_rTag.m_bClose = false;
 220         }
 221
 222         if (!GetString(p_rszLine, iPos, p_rTag.m_szName, L"\r\n\t />"))
 223                 return false;
 224
 225         p_rTag.m_szName = StringToLower(p_rTag.m_szName);
 226
 227         if (!GetAttributes(p_rszLine, iPos, p_rTag.m_mapAttributes))
 228                 return false;
 229
 230         if (p_rszLine.at(iPos) == '/')
 231         {
 232                 ++iPos;
 233                 p_rTag.m_bClose = true;
 234         }
 235
 236         if (p_rszLine.at(iPos) == '>')
 237         {
 238                 ++iPos;
 239                 p_rszLine = p_rszLine.substr(iPos);
 240                 return true;
 241         }
 242         else
 243         {
 244                 if (m_bTryToIgnoreErrors)
 245                 {
 246                         size_t iTempPos = p_rszLine.find_first_of('>');
 247
 248                         if (iTempPos != wstring::npos)
 249                         {
 250                                 if (iTempPos - 1 >= p_rszLine.length())
 251                                         return false;
 252
 253                                 p_rszLine = p_rszLine.substr(iTempPos + 1);
 254                                 return true;
 255                         }
 256                         else
 257                         {
 258                                 return false;
 259                         }
 260
 261                 }
 262                 else
 263                 {
 264                         return false;
 265                 }
 266         }
 267 }
 268
 269 bool CRealTextParser::ExtractTextTag(wstring& p_rszLine, Tag& p_rTag)
 270 {
 271         p_rTag.m_bText = true;
 272         return ExtractString(p_rszLine, p_rTag.m_szName);
 273 }
 274
 275 bool CRealTextParser::ExtractString(wstring& p_rszLine, wstring& p_rszString)
 276 {
 277         if (p_rszLine.length() == 0 || p_rszLine.at(0) == '<')
 278         {
 279                 if (m_bTryToIgnoreErrors)
 280                 {
 281                         p_rszString = L"";
 282                         return true;
 283                 }
 284                 else
 285                 {
 286                         return false;
 287                 }
 288         }
 289
 290         unsigned int iPos = 0;
 291
 292         if (!SkipSpaces(p_rszLine, iPos))
 293                 return false;
 294
 295         if (!GetString(p_rszLine, iPos, p_rszString, L"<"))
 296                 return false;
 297
 298         p_rszLine = p_rszLine.substr(iPos);
 299         return true;
 300 }
 301
 302 bool CRealTextParser::SkipSpaces(wstring& p_rszLine, unsigned int& p_riPos)
 303 {
 304         while (p_rszLine.length() > p_riPos && iswspace(p_rszLine.at(p_riPos)))
 305         {
 306                 ++p_riPos;
 307         }
 308
 309         return p_rszLine.length() > p_riPos;
 310 }
 311
 312 bool CRealTextParser::GetString(wstring& p_rszLine, unsigned int& p_riPos, wstring& p_rszString, const wstring& p_crszEndChars)
 313 {
 314         while (p_rszLine.length() > p_riPos && p_crszEndChars.find(p_rszLine.at(p_riPos)) == wstring::npos)
 315         {
 316                 p_rszString += p_rszLine.at(p_riPos);
 317                 ++p_riPos;
 318         }
 319
 320         return p_rszLine.length() > p_riPos;
 321 }
 322
 323 bool CRealTextParser::GetAttributes(wstring& p_rszLine, unsigned int& p_riPos, map<wstring, wstring>& p_rmapAttributes)
 324 {
 325         if (!SkipSpaces(p_rszLine, p_riPos))
 326                 return false;
 327
 328         while (p_riPos>p_rszLine.length() && p_rszLine.at(p_riPos) != '/' && p_rszLine.at(p_riPos) != '>')
 329         {
 330                 wstring szName;
 331                 if (!GetString(p_rszLine, p_riPos, szName, L"\r\n\t ="))
 332                         return false;
 333
 334                 if (!SkipSpaces(p_rszLine, p_riPos))
 335                         return false;
 336
 337                 if (p_rszLine.at(p_riPos) != '=')
 338                 {
 339                         if (m_bTryToIgnoreErrors)
 340                         {
 341                                 p_riPos = p_rszLine.find_first_of('=', p_riPos);
 342                                 if (p_riPos == wstring::npos)
 343                                         return false;
 344                         }
 345                         else
 346                         {
 347                                 return false;
 348                         }
 349                 }
 350
 351                 ++p_riPos;
 352
 353                 if (!SkipSpaces(p_rszLine, p_riPos))
 354                         return false;
 355
 356                 bool bUsesQuotes(false);
 357                 if (p_rszLine.at(p_riPos) == '\'' || p_rszLine.at(p_riPos) == '\"')
 358                 {
 359                         ++p_riPos;
 360                         bUsesQuotes = true;
 361                 }
 362
 363                 if (!SkipSpaces(p_rszLine, p_riPos))
 364                         return false;
 365
 366                 wstring szValue;
 367                 if (bUsesQuotes)
 368                 {
 369                         if (!GetString(p_rszLine, p_riPos, szValue, L"\"\'/>"))
 370                                 return false;
 371                 }
 372                 else
 373                 {
 374                         if (!GetString(p_rszLine, p_riPos, szValue, L" \t/>"))
 375                                 return false;
 376                 }
 377
 378                 p_rmapAttributes[StringToLower(szName)] = szValue;
 379
 380                 if (!SkipSpaces(p_rszLine, p_riPos))
 381                         return false;
 382
 383                 if (p_rszLine.at(p_riPos) == '\'' || p_rszLine.at(p_riPos) == '\"')
 384                         ++p_riPos;
 385
 386                 if (!SkipSpaces(p_rszLine, p_riPos))
 387                         return false;
 388         }
 389
 390         return p_rszLine.length() > p_riPos;
 391 }
 392
 393 int CRealTextParser::GetTimecode(const wstring& p_crszTimecode)
 394 {
 395         int iTimecode(0);
 396         int iMultiplier(1);
 397
 398         // Exception: if the timecode doesn't contain any separators, assume the time code is in seconds (and change multiplier to reflect that)
 399         if (p_crszTimecode.find_first_of('.') == wstring::npos && p_crszTimecode.find_first_of(':') == wstring::npos)
 400                 iMultiplier = 1000;
 401
 402         wstring szCurrentPart;
 403
 404         for (int i = p_crszTimecode.length() - 1; i >= 0; --i)
 405         {
 406                 if (p_crszTimecode.at(i) == '.' || p_crszTimecode.at(i) == ':')
 407                 {
 408                         if (iMultiplier == 1)
 409                         {
 410                                 while (szCurrentPart.length() < 3)
 411                                         szCurrentPart += L"0";
 412                         }
 413
 414                         iTimecode += iMultiplier * ::_wtoi(szCurrentPart.c_str());
 415
 416                         if (iMultiplier == 1)
 417                         {
 418                                 iMultiplier = 1000;
 419                         }
 420                         else
 421                         {
 422                                 iMultiplier *= 60;
 423                         }
 424
 425                         szCurrentPart = L"";
 426                 }
 427                 else
 428                 {
 429                         szCurrentPart = p_crszTimecode.substr(i, 1) + szCurrentPart;
 430                 }
 431         }
 432
 433         iTimecode += iMultiplier * ::_wtoi(szCurrentPart.c_str());
 434
 435         return iTimecode;
 436 }
 437
 438 wstring CRealTextParser::FormatTimecode(int iTimecode,
 439                                                                                 int iMillisecondPrecision/* = 3*/,
 440                                                                                 bool p_bPadZeroes/* = true*/,
 441                                                                                 const wstring& p_crszSeparator/* = ":"*/,
 442                                                                                 const wstring& p_crszMillisecondSeparator/* = "."*/)
 443 {
 444         wostringstream ossTimecode;
 445
 446         int iHours = iTimecode / 1000 / 60 / 60;
 447
 448         ossTimecode << iHours;
 449
 450         int iMinutes = (iTimecode / 1000 / 60) % 60;
 451
 452         ossTimecode << p_crszSeparator;
 453         ossTimecode << iMinutes;
 454
 455         int iSeconds = (iTimecode / 1000) % 60;
 456
 457         ossTimecode << p_crszSeparator;
 458         ossTimecode << iSeconds;
 459
 460         int iMilliSeconds = iTimecode % 1000;
 461
 462         if (iMillisecondPrecision < 3)
 463                 iMilliSeconds /= 10 * (3 - iMillisecondPrecision);
 464
 465         ossTimecode << p_crszMillisecondSeparator;
 466         ossTimecode << iMilliSeconds;
 467
 468         return ossTimecode.str();
 469 }
 470
 471 wstring CRealTextParser::StringToLower(const wstring& p_crszString)
 472 {
 473         wstring szLowercaseString;
 474         for(unsigned int i=0; i < p_crszString.length(); ++i)
 475         {
 476                 szLowercaseString += towlower(p_crszString.at(i));
 477         }
 478         return szLowercaseString;
 479 }
 480
 481 wstring CRealTextParser::RenderTags(const list<Tag>& p_crlTags)
 482 {
 483         bool bEmpty(true);
 484         wstring szString;
 485
 486         for (list<Tag>::const_iterator iter = p_crlTags.begin(); iter != p_crlTags.end(); ++iter)
 487         {
 488                 Tag oTag(*iter);
 489
 490                 if (oTag.m_szName == L"br")
 491                 {
 492                         szString += L"\n";
 493                 }
 494                 else if (oTag.m_szName == L"b")
 495                 {
 496                         if (!m_bIgnoreFontWeight)
 497                         {
 498                                 if (oTag.m_bOpen)
 499                                 {
 500                                         szString += L"<b>";
 501                                 }
 502                                 else if (oTag.m_bClose)
 503                                 {
 504                                         szString += L"</b>";
 505                                 }
 506                         }
 507                 }
 508                 else if (oTag.m_szName == L"i")
 509                 {
 510                         if (!m_bIgnoreFontWeight)
 511                         {
 512                                 if (oTag.m_bOpen)
 513                                 {
 514                                         szString += L"<i>";
 515                                 }
 516                                 else if (oTag.m_bClose)
 517                                 {
 518                                         szString += L"</i>";
 519                                 }
 520                         }
 521                 }
 522                 else if (oTag.m_szName == L"font")
 523                 {
 524                         if (!m_bIgnoreFont)
 525                         {
 526                                 if (oTag.m_bOpen)
 527                                 {
 528                                         szString += L"<font";
 529                                         for (map<wstring, wstring>:: iterator i = oTag.m_mapAttributes.begin(); i != oTag.m_mapAttributes.end(); ++i)
 530                                         {
 531                                                 if (m_bIgnoreFontSize && i->first == L"size")
 532                                                         continue;
 533
 534                                                 if (m_bIgnoreFontColor && i->first == L"color")
 535                                                         continue;
 536
 537                                                 if (m_bIgnoreFontFace && i->first == L"face")
 538                                                         continue;
 539
 540                                                 if (i->first == L"size" && i->second.length() > 0 && ::iswdigit(i->second.at(0)))
 541                                                 {
 542                                                         int iSize = ::_wtoi(i->second.c_str());
 543
 544                                                         if (iSize > 0 && iSize < m_iMinFontSize)
 545                                                                 continue;
 546
 547                                                         if (iSize > m_iMaxFontSize)
 548                                                                 continue;
 549                                                 }
 550
 551                                                 szString += L" ";
 552                                                 szString += i->first;
 553                                                 szString += L"=\"";
 554                                                 szString += i->second;
 555                                                 szString += L"\"";
 556                                         }
 557                                         szString += L">";
 558                                 }
 559
 560                                 if (oTag.m_bClose)
 561                                 {
 562                                         szString += L"</font>";
 563                                 }
 564                         }
 565                 }
 566                 else if (oTag.m_bText)
 567                 {
 568                         szString += oTag.m_szName;
 569
 570                         if (!oTag.m_szName.empty())
 571                                 bEmpty = false;
 572                 }
 573                 else
 574                 {
 575 //                      AfxMessageBox(CString(_T("Unknown RealText-tag: ")) + oTag.m_szName.c_str());
 576                 }
 577         }
 578
 579         if (bEmpty)
 580                 return L"";
 581         else
 582                 return szString;
 583 }
 584
 585 bool CRealTextParser::OutputSRT(wostream& p_rOutput)
 586 {
 587         int iCounter(1);
 588         for (map<pair<int, int>, wstring>::const_iterator i = m_RealText.m_mapLines.begin();
 589                 i != m_RealText.m_mapLines.end();
 590                 ++i)
 591         {
 592                 p_rOutput << iCounter++;
 593                 p_rOutput << endl;
 594
 595                 p_rOutput << FormatTimecode(i->first.first);
 596                 p_rOutput << L" --> ";
 597                 p_rOutput << FormatTimecode(i->first.second);
 598                 p_rOutput << endl;
 599
 600                 p_rOutput << i->second;
 601                 p_rOutput << endl;
 602                 p_rOutput << endl;
 603         }
 604
 605         return true;
 606 }
 607
 608 void CRealTextParser::PopTag(list<Tag>& p_rlistTags, const wstring& p_crszTagName)
 609 {
 610         for (list<Tag>::reverse_iterator riter = p_rlistTags.rbegin(); riter != p_rlistTags.rend(); ++riter)
 611         {
 612                 if (riter->m_szName == p_crszTagName)
 613                 {
 614                         p_rlistTags.erase((++riter).base());
 615                         return;
 616                 }
 617         }
 618 }
 619
 620 void CRealTextParser::FilterReduntantTags(list<Tag>& p_rlistTags)
 621 {
 622         list<Tag>::iterator iterPrev;
 623         for (list<Tag>::iterator iterCurrent = p_rlistTags.begin(); iterCurrent != p_rlistTags.end(); ++iterCurrent)
 624         {
 625                 if (iterCurrent != p_rlistTags.begin())
 626                 {
 627                         if (iterPrev->m_szName == L"font" && iterCurrent->m_szName == L"font" &&
 628                                 iterPrev->m_bOpen && iterCurrent->m_bOpen)
 629                         {
 630                                 p_rlistTags.erase(iterPrev);
 631                         }
 632                 }
 633                 iterPrev = iterCurrent;
 634         }
 635 }