demuxer.cc

   1 /*
   2     Copyright 2005-2006 Mark Calderbank
   3
   4     This file is part of VOMP.
   5
   6     VOMP is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     VOMP is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with VOMP; if not, write to the Free Software
  18     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19 */
  20
  21 #include "demuxer.h"
  22 #ifndef WIN32
  23 #include <endian.h>
  24 #else
  25 #define __LITTLE_ENDIAN 1234
  26 #define __BIG_ENDIAN  4321
  27 #define __BYTE_ORDER __LITTLE_ENDIAN
  28 #endif
  29
  30 #if __BYTE_ORDER == __BIG_ENDIAN
  31 #define DEMUXER_SEQ_HEAD 0x000001B3
  32 #else
  33 #define DEMUXER_SEQ_HEAD 0xB3010000
  34 #endif
  35
  36 #define DEMUXER_PIC_HEAD 0x00000101
  37
  38 #define SEEK_THRESHOLD 150000 // About 1.5 seconds
  39
  40 const int Demuxer::FrameRates[9] = { 0, 23, 24, 25, 29, 30, 50, 59, 60 };
  41 const ULLONG Demuxer::PESPacket::PTS_INVALID = (1LL << 33);
  42
  43 Demuxer* Demuxer::instance = NULL;
  44
  45 Demuxer::Demuxer()
  46 {
  47   if (instance) return;
  48   instance = this;
  49   initted = false;
  50   callback = NULL;
  51   arcnt = 0;
  52   vid_seeking = aud_seeking = false;
  53   video_pts = audio_pts = 0;
  54   ispre_1_3_19 = false;
  55 }
  56
  57 Demuxer::~Demuxer()
  58 {
  59   shutdown();
  60   instance = NULL;
  61 }
  62
  63 Demuxer* Demuxer::getInstance()
  64 {
  65   return instance;
  66 }
  67
  68 int Demuxer::init(Callback* tcallback, DrainTarget* audio, DrainTarget* video, ULONG demuxMemoryV, ULONG demuxMemoryA)
  69 {
  70   if (!initted)
  71   {
  72     if ( !videostream.init(video, demuxMemoryV) ||
  73          !audiostream.init(audio, demuxMemoryA))
  74     {
  75       Log::getInstance()->log("Demuxer", Log::CRIT,
  76                               "Failed to initialize demuxer");
  77       shutdown();
  78       return 0;
  79     }
  80   }
  81
  82   reset();
  83   initted = true;
  84   callback = tcallback;
  85   return 1;
  86 }
  87
  88 void Demuxer::reset()
  89 {
  90   flush();
  91   video_current = audio_current = -1;
  92   horizontal_size = vertical_size = 0;
  93   aspect_ratio = (enum AspectRatio) 0;
  94   frame_rate = bit_rate = 0;
  95   ispre_1_3_19 = false;
  96
  97   for (int i = 0; i <= (PESTYPE_AUDMAX - PESTYPE_AUD0); i++)
  98   {
  99     avail_mpaudchan[i] = false;
 100   }
 101   for (int i = 0; i <= (PESTYPE_SUBSTREAM_AC3MAX - PESTYPE_SUBSTREAM_AC30); i++)
 102   {
 103     avail_ac3audchan[i] = false;
 104   }
 105 }
 106
 107 int Demuxer::shutdown()
 108 {
 109   videostream.shutdown();
 110   audiostream.shutdown();
 111   initted = false;
 112   return 1;
 113 }
 114
 115 void Demuxer::flush()
 116 {
 117   videostream.flush();
 118   audiostream.flush();
 119 }
 120
 121 void Demuxer::flushAudio()
 122 {
 123   audiostream.flush();
 124 }
 125
 126 void Demuxer::seek()
 127 {
 128   vid_seeking = aud_seeking = true;
 129   video_pts = audio_pts = 0;
 130 }
 131
 132 void Demuxer::setAudioStream(int id)
 133 {
 134   audio_current = id;
 135 }
 136
 137 void Demuxer::setVideoStream(int id)
 138 {
 139   video_current = id;
 140 }
 141
 142 void Demuxer::setAspectRatio(enum AspectRatio ar)
 143 {
 144   if (aspect_ratio != ar)
 145   {
 146     Log::getInstance()->log("Demux", Log::DEBUG,
 147                             "Aspect ratio difference signalled");
 148     if (++arcnt > 3) // avoid changing aspect ratio if glitch in signal
 149     {
 150       arcnt = 0;
 151       aspect_ratio = ar;
 152       if (callback) callback->call(this);
 153     }
 154   }
 155   else
 156     arcnt = 0;
 157 }
 158
 159 bool Demuxer::writeAudio()
 160 {
 161   return audiostream.drain();
 162 }
 163
 164 bool Demuxer::writeVideo()
 165 {
 166   return videostream.drain();
 167 }
 168
 169 Demuxer::PESPacket::PESPacket()
 170 {
 171   data[0] = 0x00;
 172   data[1] = 0x00;
 173   data[2] = 0x01;
 174   init(0);
 175 }
 176
 177 void Demuxer::PESPacket::init(UCHAR type)
 178 {
 179   length = submitted = 0;
 180   size = 6; closed = false;
 181   data[3] = type;
 182   data[4] = data[5] = 0;
 183   packetType = type;
 184   pts = PTS_INVALID;
 185   seq_header = false;
 186 }
 187
 188 void Demuxer::PESPacket::truncate()
 189 {
 190   init(packetType);
 191 }
 192
 193 int Demuxer::PESPacket::write(UCHAR *buf, int len)
 194 {
 195   if (closed) return 0;
 196   if (length + len > 0xFFFA) return 0;
 197   memcpy(data+length+6, buf, len);
 198   length += len;
 199   size += len;
 200   data[4] = (length >> 8);
 201   data[5] = (length & 0xFF);
 202   return 1;
 203 }
 204
 205 int Demuxer::PESPacket::submit()
 206 {
 207   if (submitted >= size) return 0;
 208   if (!closed) parseDetails();
 209
 210   closed = true;
 211   Demuxer* dx = Demuxer::getInstance();
 212   int sent = 0;
 213   if (packetType >= PESTYPE_VID0 && packetType <= PESTYPE_VIDMAX)
 214   {
 215     if (dx->video_current == -1) dx->video_current = packetType;
 216     if (dx->video_current == packetType && !dx->vid_seeking)
 217       sent = dx->videostream.put(data+submitted, size-submitted, MPTYPE_VIDEO);
 218     else
 219       sent = size-submitted;
 220   }
 221   else if (packetType >= PESTYPE_AUD0 && packetType <= PESTYPE_AUDMAX)
 222   {
 223     if (dx->audio_current == -1) dx->audio_current = packetType;
 224
 225     dx->avail_mpaudchan[packetType-PESTYPE_AUD0]=true;
 226
 227     if (dx->audio_current == packetType && !dx->aud_seeking)
 228       sent = dx->audiostream.put(data+submitted, size-submitted, MPTYPE_MPEG_AUDIO);
 229     else
 230       sent = size-submitted;
 231   }
 232   else if (packetType == PESTYPE_PRIVATE_1)
 233   {
 234     if (substream >= PESTYPE_SUBSTREAM_AC30 && substream <= PESTYPE_SUBSTREAM_AC3MAX)
 235     {
 236       dx->avail_ac3audchan[substream-PESTYPE_SUBSTREAM_AC30]=true;
 237       if (substream == dx->audio_current)
 238       {
 239         sent = dx->audiostream.put(data+submitted,size-submitted,(dx->ispre_1_3_19)?MPTYPE_AC3_PRE13:MPTYPE_AC3);
 240       }
 241       else
 242       {
 243         sent = size-submitted;
 244       }
 245     }
 246   }
 247   else
 248   {
 249     sent = size-submitted;
 250   }
 251
 252   submitted += sent;
 253   if (submitted < size) // Stream is full.
 254     return 0;
 255   else
 256     return 1;
 257 }
 258
 259 void Demuxer::PESPacket::parseDetails()
 260 {
 261   Demuxer* dx = Demuxer::getInstance();
 262   if (packetType >= PESTYPE_AUD0 && packetType <= PESTYPE_AUDMAX)
 263   {
 264     // Extract audio PTS if it exists
 265     if ( size >= 14 && (data[7] & 0x80) ) // PTS_DTS_flags indicate PTS
 266     {
 267       dx->audio_pts = pts = ( (ULLONG)(data[9] & 0x0E)  << 29 ) |
 268                             ( (ULLONG)(data[10])        << 22 ) |
 269                             ( (ULLONG)(data[11] & 0xFE) << 14 ) |
 270                             ( (ULLONG)(data[12])        <<  7 ) |
 271                             ( (ULLONG)(data[13] & 0xFE) >>  1 );
 272
 273       // We continue to seek on the audio if the video PTS that we
 274       // are trying to match is ahead of the audio PTS by at most
 275       // SEEK_THRESHOLD. We consider the possibility of PTS wrap.
 276       if (dx->aud_seeking && !dx->vid_seeking &&
 277           !( (dx->video_pts_seek > dx->audio_pts &&
 278               dx->video_pts_seek - dx->audio_pts < SEEK_THRESHOLD)
 279               ||
 280              (dx->video_pts_seek < dx->audio_pts &&
 281               dx->video_pts_seek + (1LL<<33) -
 282                                    dx->audio_pts < SEEK_THRESHOLD) ))
 283       {
 284         dx->aud_seeking = 0;
 285         Log::getInstance()->log("Demuxer", Log::DEBUG,
 286             "Leaving  audio sync: Audio PTS = %llu", dx->audio_pts);
 287       }
 288     }
 289   }
 290   else if (packetType == PESTYPE_PRIVATE_1) //Private Stream
 291   {
 292     //Inspired by vdr's device.c
 293     int payload_begin = data[8]+9;
 294     unsigned char substream_id = data[payload_begin];
 295     unsigned char substream_type = substream_id & 0xF0;
 296     unsigned char substream_index = substream_id & 0x1F;
 297 pre_1_3_19_Recording: //This is for old recordings stuff
 298     if (dx->ispre_1_3_19)
 299     {
 300       substream_id = PESTYPE_PRIVATE_1;
 301       substream_type = 0x80;
 302       substream_index = 0;
 303     }
 304     switch (substream_type)
 305     {
 306       case 0x20://SPU
 307       case 0x30://SPU
 308         break;
 309       case 0xA0: //LPCM //not supported yet, is there any LPCM transmissio out there?
 310         break;
 311       case 0x80: //ac3, currently only one ac3 track per recording supported
 312         substream=substream_type+substream_index;
 313
 314         // Extract audio PTS if it exists
 315         if ( size >= 14 && (data[7] & 0x80) ) // PTS_DTS_flags indicate PTS
 316         {
 317           dx->audio_pts = pts = ( (ULLONG)(data[9] & 0x0E)  << 29 ) |
 318                         ( (ULLONG)(data[10])        << 22 ) |
 319                         ( (ULLONG)(data[11] & 0xFE) << 14 ) |
 320                         ( (ULLONG)(data[12])        <<  7 ) |
 321                         ( (ULLONG)(data[13] & 0xFE) >>  1 );
 322           // We continue to seek on the audio if the video PTS that we
 323           // are trying to match is ahead of the audio PTS by at most
 324           // SEEK_THRESHOLD. We consider the possibility of PTS wrap.
 325           if (dx->aud_seeking && !dx->vid_seeking &&
 326               !( (dx->video_pts_seek > dx->audio_pts &&
 327               dx->video_pts_seek - dx->audio_pts < SEEK_THRESHOLD)
 328               ||
 329               (dx->video_pts_seek < dx->audio_pts &&
 330                     dx->video_pts_seek + (1LL<<33) -
 331                     dx->audio_pts < SEEK_THRESHOLD) ))
 332           {
 333             dx->aud_seeking = 0;
 334             Log::getInstance()->log("Demuxer", Log::DEBUG, "Leaving  audio sync: Audio PTS = %llu", dx->audio_pts);
 335           }
 336         }
 337         break;
 338       default:
 339         if (!dx->ispre_1_3_19)
 340         {
 341           dx->ispre_1_3_19=true; //switching to compat mode
 342           goto pre_1_3_19_Recording;
 343         }
 344         else
 345         {
 346           substream=0;
 347         }
 348         break;
 349     }
 350   }
 351   else if (packetType >= PESTYPE_VID0 && packetType <= PESTYPE_VIDMAX)
 352   {
 353     // Extract video PTS if it exists
 354     if ( size >= 14 && (data[7] & 0x80) ) // PTS_DTS_flags indicate PTS
 355     {
 356       dx->video_pts = pts = ( (ULLONG)(data[9] & 0x0E)  << 29 ) |
 357                             ( (ULLONG)(data[10])        << 22 ) |
 358                             ( (ULLONG)(data[11] & 0xFE) << 14 ) |
 359                             ( (ULLONG)(data[12])        <<  7 ) |
 360                             ( (ULLONG)(data[13] & 0xFE) >>  1 );
 361     }
 362
 363     // Now, scan for a sequence header and extract information
 364     UINT pos = 9; // Start searching from byte 9
 365     while (pos < size - 5)
 366     {
 367       UINT pattern = *(UINT*)(data+pos);
 368       if (pattern == DEMUXER_SEQ_HEAD)
 369       {
 370         seq_header = true;
 371         pos += 4;
 372         if (pos+6 >= size) return;
 373         dx->horizontal_size = ((int)data[pos] << 4) | ((int)data[pos+1] >> 4);
 374         dx->vertical_size = (((int)data[pos+1] & 0xf) << 8) | (int)data[pos+2];
 375         dx->setAspectRatio((enum AspectRatio)(data[pos+3] >> 4));
 376         dx->frame_rate = data[pos+3] & 0x0f;
 377         if (dx->frame_rate >= 1 && dx->frame_rate <= 8)
 378           dx->frame_rate = FrameRates[dx->frame_rate];
 379         else
 380           dx->frame_rate = 0;
 381         dx->bit_rate = ((int)data[pos+4] << 10) |
 382                    ((int)data[pos+5] << 2) |
 383                    ((int)data[pos+6] >> 6);
 384         if (dx->vid_seeking)
 385         {
 386           dx->vid_seeking = 0;
 387           dx->video_pts_seek = dx->video_pts;
 388           Log::getInstance()->log("Demuxer", Log::DEBUG,
 389               "Entering audio sync: Video PTS = %llu", dx->video_pts);
 390           Log::getInstance()->log("Demuxer", Log::DEBUG,
 391               "Entering audio sync: Audio PTS = %llu", dx->audio_pts);
 392         }
 393         return;
 394       }
 395       else pos++;
 396     }
 397   }
 398 }
 399
 400 UINT Demuxer::PESPacket::findPictureHeader()
 401 {
 402   if (size < 12) return 0;
 403   UINT pattern = *(UINT*)(data+8);
 404   UINT pos = 11;
 405   while (pattern != DEMUXER_PIC_HEAD)
 406   {
 407     if (++pos >= size) return 0;
 408     pattern = (pattern << 8) | data[pos];
 409   }
 410   return pos-3;
 411 }
 412
 413 UINT Demuxer::stripAudio(UCHAR* buf, UINT len)
 414 {
 415   UINT read_pos = 0, write_pos = 0;
 416   UINT pattern, packet_length;
 417   if (len < 4) return 0;
 418   pattern = (buf[0] << 16) | (buf[1] << 8) | (buf[2]);
 419   while (read_pos + 7 <= len)
 420   {
 421     pattern = ((pattern & 0xFFFFFF) << 8) | buf[read_pos+3];
 422     if (pattern < (0x100|PESTYPE_VID0) || pattern > (0x100|PESTYPE_VIDMAX))
 423       read_pos++;
 424     else
 425     {
 426       packet_length = ((buf[read_pos+4] << 8) | (buf[read_pos+5])) + 6;
 427       if (read_pos + packet_length > len)
 428         read_pos = len;
 429       else
 430       {
 431         if (read_pos != write_pos)
 432           memmove(buf+write_pos, buf+read_pos, packet_length);
 433         read_pos += packet_length;
 434         write_pos += packet_length;
 435         pattern = (buf[read_pos] << 16) | (buf[read_pos+1] << 8)
 436                                         | (buf[read_pos+2]);
 437       }
 438     }
 439   }
 440   return write_pos;
 441 }
 442
 443 bool Demuxer::scanForVideo(UCHAR* buf, UINT len)
 444 {
 445   UINT pos = 3;
 446   UINT pattern;
 447   if (len < 4) return false;
 448   pattern = (buf[0] << 16) | (buf[1] << 8) | (buf[2]);
 449   while (pos < len)
 450   {
 451     pattern = ((pattern & 0xFFFFFF) << 8) | buf[pos++];
 452     if (pattern >= (0x100|PESTYPE_VID0) && pattern <= (0x100|PESTYPE_VIDMAX))
 453       return true;
 454   }
 455   return false;
 456 }
 457
 458 bool* Demuxer::getmpAudioChannels()
 459 {
 460   return avail_mpaudchan;
 461 }
 462
 463 bool* Demuxer::getac3AudioChannels()
 464 {
 465   return avail_ac3audchan;
 466 }
 467
 468 int Demuxer::getselAudioChannel()
 469 {
 470   return audio_current;
 471 }
 472
 473 void Demuxer::setAudioChannel(int aud_channel)
 474 {
 475   audio_current = aud_channel;
 476 }