src/subtitles/CCDecoder.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 "ccdecoder.h"
  24
  25 CCDecoder::CCDecoder(CString fn, CString rawfn) : m_fn(fn), m_rawfn(rawfn)
  26 {
  27         m_sts.CreateDefaultStyle(ANSI_CHARSET);
  28
  29         m_time = 0;
  30         m_fEndOfCaption = false;
  31         memset(m_buff, 0, sizeof(m_buff));
  32         memset(m_disp, 0, sizeof(m_disp));
  33         m_cursor = CPoint(0, 0);
  34
  35         if(!m_rawfn.IsEmpty())
  36                 _tremove(m_rawfn);
  37 }
  38
  39 CCDecoder::~CCDecoder()
  40 {
  41         if(!m_sts.IsEmpty() && !m_fn.IsEmpty())
  42         {
  43                 m_sts.Sort();
  44                 m_sts.SaveAs(m_fn, EXTSRT, -1, CTextFile::ASCII);
  45                 m_sts.SaveAs(m_fn.Left(m_fn.ReverseFind('.')+1) + _T("utf8.srt"), EXTSRT, -1, CTextFile::UTF8);
  46                 m_sts.SaveAs(m_fn.Left(m_fn.ReverseFind('.')+1) + _T("utf16le.srt"), EXTSRT, -1, CTextFile::LE16);
  47                 m_sts.SaveAs(m_fn.Left(m_fn.ReverseFind('.')+1) + _T("utf16be.srt"), EXTSRT, -1, CTextFile::BE16);
  48         }
  49 }
  50
  51 void CCDecoder::MoveCursor(int x, int y)
  52 {
  53         m_cursor = CPoint(x, y);
  54         if(m_cursor.x < 0) m_cursor.x = 0;
  55         if(m_cursor.y < 0) m_cursor.y = 0;
  56         if(m_cursor.x >= 32) m_cursor.x = 0, m_cursor.y++;
  57         if(m_cursor.y >= 16) m_cursor.y = 0;
  58 }
  59
  60 void CCDecoder::OffsetCursor(int x, int y)
  61 {
  62         MoveCursor(m_cursor.x + x, m_cursor.y + y);
  63 }
  64
  65 void CCDecoder::PutChar(WCHAR c)
  66 {
  67         m_buff[m_cursor.y][m_cursor.x] = c;
  68         OffsetCursor(1, 0);
  69 }
  70
  71 void CCDecoder::SaveDisp(__int64 time)
  72 {
  73         CStringW str;
  74
  75         for(int row = 0; row < 16; row++)
  76         {
  77                 bool fNonEmptyRow = false;
  78
  79                 for(int col = 0; col < 32; col++)
  80                 {
  81                         if(m_disp[row][col])
  82                         {
  83                                 CStringW str2(&m_disp[row][col]);
  84                                 if(fNonEmptyRow) str += ' ';
  85                                 str += str2;
  86                                 col += str2.GetLength();
  87                                 fNonEmptyRow = true;
  88                         }
  89                 }
  90
  91                 if(fNonEmptyRow) str += '\n';
  92         }
  93
  94         if(str.IsEmpty()) return;
  95
  96         m_sts.Add(str, true, (int)m_time, (int)time);
  97 }
  98
  99 void CCDecoder::DecodeCC(BYTE* buff, int len, __int64 time)
 100 {
 101         if(!m_rawfn.IsEmpty())
 102         {
 103                 if(FILE* f = _tfopen(m_rawfn, _T("at")))
 104                 {
 105                         _ftprintf(f, _T("%02d:%02d:%02d.%03d\n"),
 106                                 (int)(time/1000/60/60),
 107                                 (int)((time/1000/60)%60),
 108                                 (int)((time/1000)%60),
 109                                 (int)(time%1000));
 110
 111                         for(int i = 0; i < len; i++)
 112                         {
 113                                 _ftprintf(f, _T("%02x"), buff[i]);
 114                                 if(i < len-1) _ftprintf(f, _T(" "));
 115                                 if(i > 0 && (i&15)==15) _ftprintf(f, _T("\n"));
 116                         }
 117                         if(len > 0) _ftprintf(f, _T("\n\n"));
 118                         fclose(f);
 119                 }
 120         }
 121
 122         for(int i = 0; i < len; i++)
 123         {
 124                 BYTE c = buff[i]&0x7f;
 125                 if(c >= 0x20)
 126                 {
 127                         static WCHAR charmap[0x60] =
 128                         {
 129                                 ' ','!','"','#','$','%','&','\'','(',')',0xE1,'+',',','-','.','/',
 130                                 '0','1','2','3','4','5','6','7','8','9',':',';','<','=','>',0x3F,
 131                                 '@','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O',
 132                                 'P','Q','R','S','T','U','V','W','X','Y','Z','[',0xE9,']',0xED,0xF3,
 133                                 0xFA,'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o',
 134                                 'p','q','r','s','t','u','v','w','x','y','z',0xE7,0xF7,'N','n',0x3F
 135                         };
 136
 137                         PutChar(charmap[c - 0x20]);
 138                 }
 139                 else if(buff[i] != 0x80 && i < len-1)
 140                 {
 141                         // codes and special characters are supposed to be doubled
 142                         if(i < len-3 && buff[i] == buff[i+2] && buff[i+1] == buff[i+3])
 143                                 i += 2;
 144
 145                         c = buff[i+1]&0x7f;
 146                         if(buff[i] == 0x91 && c >= 0x20 && c < 0x30) // formating
 147                         {
 148                                 // TODO
 149                         }
 150                         else if(buff[i] == 0x91 && c == 0x39) // transparent space
 151                         {
 152                                 OffsetCursor(1, 0);
 153                         }
 154                         else if(buff[i] == 0x91 && c >= 0x30 && c < 0x40) // special characters
 155                         {
 156                                 static WCHAR charmap[0x10] =
 157                                 {
 158                                         0x00ae, // (r)egistered
 159                                         0x00b0, // degree
 160                                         0x00bd, // 1/2
 161                                         0x00bf, // inverted question mark
 162                                         0x2122, // trade mark
 163                                         0x00a2, // cent
 164                                         0x00a3, // pound
 165                                         0x266a, // music
 166                                         0x00e0, // a`
 167                                         0x00ff, // transparent space, handled above
 168                                         0x00e8, // e`
 169                                         0x00e2, // a^
 170                                         0x00ea, // e^
 171                                         0x00ee, // i^
 172                                         0x00f4, // o^
 173                                         0x00fb, // u^
 174                                 };
 175
 176                                 PutChar(charmap[c - 0x30]);
 177                         }
 178                         else if(buff[i] == 0x92 && c >= 0x20 && c < 0x40) // extended characters
 179                         {
 180                                 static WCHAR charmap[0x20] =
 181                                 {
 182                                         0x00c0, // A'
 183                                         0x00c9, // E'
 184                                         0x00d3, // O'
 185                                         0x00da, // U'
 186                                         0x00dc, // U:
 187                                         0x00fc, // u:
 188                                         0x2018, // `
 189                                         0x00a1, // inverted !
 190                                         0x002a, // *
 191                                         0x2019, // '
 192                                         0x002d, // -
 193                                         0x00a9, // (c)opyright
 194                                         0x2120, // SM
 195                                         0x00b7, // . (dot in the middle)
 196                                         0x201c, // inverted "
 197                                         0x201d, // "
 198
 199                                         0x00c1, // A`
 200                                         0x00c2, // A^
 201                                         0x00c7, // C,
 202                                         0x00c8, // E`
 203                                         0x00ca, // E^
 204                                         0x00cb, // E:
 205                                         0x00eb, // e:
 206                                         0x00ce, // I^
 207                                         0x00cf, // I:
 208                                         0x00ef, // i:
 209                                         0x00d4, // O^
 210                                         0x00d9, // U`
 211                                         0x00f9, // u`
 212                                         0x00db, // U^
 213                                         0x00ab, // <<
 214                                         0x00bb, // >>
 215                                 };
 216
 217                                 PutChar(charmap[c - 0x20]);
 218                         }
 219                         else if(buff[i] == 0x13 && c >= 0x20 && c < 0x40) // more extended characters
 220                         {
 221                                 static WCHAR charmap[0x20] =
 222                                 {
 223                                         0x00c3, // A~
 224                                         0x00e3, // a~
 225                                         0x00cd, // I'
 226                                         0x00cc, // I`
 227                                         0x00ec, // i`
 228                                         0x00d2, // O`
 229                                         0x00f2, // o`
 230                                         0x00d5, // O~
 231                                         0x00f5, // o~
 232                                         0x007b, // {
 233                                         0x007d, // }
 234                                         0x005c, // /* \ */
 235                                         0x005e, // ^
 236                                         0x005f, // _
 237                                         0x00a6, // |
 238                                         0x007e, // ~
 239
 240                                         0x00c4, // A:
 241                                         0x00e4, // a:
 242                                         0x00d6, // O:
 243                                         0x00f6, // o:
 244                                         0x00df, // B (ss in german)
 245                                         0x00a5, // Y=
 246                                         0x00a4, // ox
 247                                         0x007c, // |
 248                                         0x00c5, // Ao
 249                                         0x00e5, // ao
 250                                         0x00d8, // O/
 251                                         0x00f8, // o/
 252                                         0x250c, // |-
 253                                         0x2510, // -|
 254                                         0x2514, // |_
 255                                         0x2518, // _|
 256                                 };
 257
 258                                 PutChar(charmap[c - 0x20]);
 259                         }
 260                         else if(buff[i] == 0x94 && buff[i+1] == 0xae) // Erase Non-displayed [buffer] Memory
 261                         {
 262                                 memset(m_buff, 0, sizeof(m_buff));
 263                         }
 264                         else if(buff[i] == 0x94 && buff[i+1] == 0x20) // Resume Caption Loading
 265                         {
 266                                 memset(m_buff, 0, sizeof(m_buff));
 267                         }
 268                         else if(buff[i] == 0x94 && buff[i+1] == 0x2f) // End Of Caption
 269                         {
 270                                 if(memcmp(m_disp, m_buff, sizeof(m_disp)) != 0)
 271                                 {
 272                                         if(m_fEndOfCaption)
 273                                                 SaveDisp(time + (i/2)*1000/30);
 274
 275                                         m_fEndOfCaption = true;
 276                                         memcpy(m_disp, m_buff, sizeof(m_disp));
 277                                         m_time = time + (i/2)*1000/30;
 278                                 }
 279                         }
 280                         else if(buff[i] == 0x94 && buff[i+1] == 0x2c) // Erase Displayed Memory
 281                         {
 282                                 if(m_fEndOfCaption)
 283                                 {
 284                                         m_fEndOfCaption = false;
 285                                         SaveDisp(time + (i/2)*1000/30);
 286                                 }
 287
 288                                 memset(m_disp, 0, sizeof(m_disp));
 289                         }
 290                         else if(buff[i] == 0x97 && (buff[i+1] == 0xa1 || buff[i+1] == 0xa2 || buff[i+1] == 0x23)) // Tab Over
 291                         {
 292                                 OffsetCursor(buff[i+1]&3, 0);
 293                         }
 294                         else if(buff[i] == 0x91 || buff[i] == 0x92 || buff[i] == 0x15 || buff[i] == 0x16
 295                                 || buff[i] == 0x97 || buff[i] == 0x10 || buff[i] == 0x13 || buff[i] == 0x94) // curpos, color, underline
 296                         {
 297                                 int row = 0;
 298                                 switch(buff[i])
 299                                 {
 300                                 default:
 301                                 case 0x91: row = 0; break;
 302                                 case 0x92: row = 2; break;
 303                                 case 0x15: row = 4; break;
 304                                 case 0x16: row = 6; break;
 305                                 case 0x97: row = 8; break;
 306                                 case 0x10: row = 10; break;
 307                                 case 0x13: row = 12; break;
 308                                 case 0x94: row = 14; break;
 309                                 }
 310                                 if(buff[i+1]&0x20) row++;
 311
 312                                 int col = buff[i+1]&0xe;
 313                                 if(col == 0 || (col > 0 && !(buff[i+1]&0x10))) col = 0;
 314                                 else col <<= 1;
 315
 316                                 MoveCursor(col, row);
 317                         }
 318                         else
 319                         {
 320                                 int iiii = 0;
 321                         }
 322
 323                         i++;
 324                 }
 325         }
 326 }
 327
 328 void CCDecoder::ExtractCC(BYTE* buff, int len, __int64 time)
 329 {
 330         for(int i = 0; i < len-9; i++)
 331         {
 332                 if(*(DWORD*)&buff[i] == 0xb2010000 && *(DWORD*)&buff[i+4] == 0xf8014343)
 333                 {
 334                         i += 8;
 335                         int nBytes = buff[i++]&0x3f;
 336                         if(nBytes > 0)
 337                         {
 338                                 nBytes = (nBytes+1)&~1;
 339
 340                                 BYTE* pData1 = new BYTE[nBytes];
 341                                 BYTE* pData2 = new BYTE[nBytes];
 342
 343                                 if(pData1 && pData2)
 344                                 {
 345                                         int nBytes1 = 0, nBytes2 = 0;
 346
 347                                         for(int j = 0; j < nBytes && i < 0x800;)
 348                                         {
 349                                                 if(buff[i++] == 0xff)
 350                                                 {
 351                                                         pData1[nBytes1++] = buff[i++];
 352                                                         pData1[nBytes1++] = buff[i++];
 353                                                 }
 354                                                 else i+=2;
 355
 356                                                 j++;
 357
 358                                                 if(j >= nBytes) break;
 359
 360                                                 if(buff[i++] == 0xff)
 361                                                 {
 362                                                         pData2[nBytes2++] = buff[i++];
 363                                                         pData2[nBytes2++] = buff[i++];
 364                                                 }
 365                                                 else i+=2;
 366
 367                                                 j++;
 368                                         }
 369
 370                                         if(nBytes1 > 0)
 371                                                 DecodeCC(pData1, nBytes1, time);
 372
 373                                         if(nBytes2 > 0)
 374                                                 DecodeCC(pData2, nBytes2, time);
 375                                 }
 376
 377                                 if(pData1) delete [] pData1;
 378                                 if(pData2) delete [] pData2;
 379                         }
 380
 381                         break;
 382                 }
 383         }
 384 }