demuxer.cc

   1 /*
   2     Copyright 2005 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
  23 const int Demuxer::FrameRates[9] = { 0, 23, 24, 25, 29, 30, 50, 59, 60 };
  24
  25 Demuxer* Demuxer::instance = NULL;
  26
  27 Demuxer::Demuxer()
  28 {
  29   if (instance) return;
  30   instance = this;
  31   initted = 0;
  32   callback = NULL;
  33   arcnt = 0;
  34 }
  35
  36 Demuxer::~Demuxer()
  37 {
  38   shutdown();
  39   instance = NULL;
  40 }
  41
  42 Demuxer* Demuxer::getInstance()
  43 {
  44   return instance;
  45 }
  46
  47 int Demuxer::init(Callback* tcallback)
  48 {
  49   if (!initted)
  50   {
  51     if ( !videostream.init(demuxMemoryV) ||
  52          !audiostream.init(demuxMemoryA) ||
  53          !(local_frame = (UCHAR *) malloc(0x10000)))
  54     {
  55     //  printf("failed to initialize demuxer\n");
  56       shutdown();
  57       return 0;
  58     }
  59   }
  60
  61   reset();
  62   initted = 1;
  63   callback = tcallback;
  64   return 1;
  65 }
  66
  67 void Demuxer::reset()
  68 {
  69   flush();
  70   video_current = audio_current = -1;
  71   horizontal_size = vertical_size = 0;
  72   aspect_ratio = (enum AspectRatio) 0;
  73   frame_rate = bit_rate = 0;
  74 }
  75
  76 int Demuxer::shutdown()
  77 {
  78   videostream.shutdown();
  79   audiostream.shutdown();
  80   free(local_frame);
  81   initted = 0;
  82   return 1;
  83 }
  84
  85 void Demuxer::flush()
  86 {
  87   videostream.flush();
  88   audiostream.flush();
  89   state_frametype = state_framepos = 0;
  90   seek();
  91 }
  92
  93 void Demuxer::flushAudio()
  94 {
  95   audiostream.flush();
  96 }
  97
  98 void Demuxer::seek()
  99 {
 100   seeking = 1;
 101 }
 102
 103 void Demuxer::setAudioStream(int id)
 104 {
 105   audio_current = id;
 106 }
 107
 108 void Demuxer::setVideoStream(int id)
 109 {
 110   video_current = id;
 111 }
 112
 113 void Demuxer::setAspectRatio(enum AspectRatio ar)
 114 {
 115   if (aspect_ratio != ar)
 116   {
 117     Log::getInstance()->log("Demux", Log::DEBUG, "Aspect ratio difference signalled");
 118     if (++arcnt > 3) // avoid changing aspect ratio if glitch in signal
 119     {
 120       arcnt = 0;
 121       aspect_ratio = ar;
 122       callback->call(this);
 123     }
 124   }
 125   else
 126     arcnt = 0;
 127 }
 128
 129 int Demuxer::writeAudio(int fd)
 130 {
 131   return audiostream.drain(fd);
 132 }
 133
 134 int Demuxer::writeVideo(int fd)
 135 {
 136   return videostream.drain(fd);
 137 }
 138
 139 int Demuxer::scan(UCHAR *buf, int len)
 140 {
 141   // Temporarily, just look for the lowest audio stream and return it
 142   int ret = 0;
 143   UCHAR byte;
 144   int zeros = 0;
 145   while (len > 1)
 146   {
 147     // We are searching for a string of bytes (0,0,1).
 148     byte = *(buf++); --len;
 149
 150     if (byte == 0)
 151     {
 152       ++zeros; continue;
 153     }
 154     if (zeros < 2 || byte != 1)
 155     {
 156       zeros = 0; continue;
 157     }
 158     zeros = 0;
 159     // We have found the pattern (0,0,1).
 160     // Check the next byte for the sub-frame type.
 161     byte = *(buf++); --len;
 162     if (byte >= 0xc0 && byte <= 0xdf) // Audio
 163       if (ret == 0 || ret > byte) ret = byte;
 164   }
 165   return ret;
 166 }
 167
 168 int Demuxer::put(UCHAR* buf, int len)
 169 {
 170   int ret = 0;    // return number of bytes consumed
 171   int parsed = 0; // number of bytes parsed by sub-function
 172   int full;       // sub-function sets this to tell us to exit early
 173   inbuf = buf;    // Initialize buffer pointer
 174
 175   while (len)
 176   {
 177     full = 0;
 178
 179     if (state_frametype == 0) // Search for frame
 180     {
 181       parsed = parse_find_frame(len);
 182     }
 183     else if ((state_frametype >= FRAMETYPE_VID0) && (state_frametype <= FRAMETYPE_VIDMAX))
 184     {
 185       parsed = parse_video_frame(len, &full);
 186     }
 187     else if ((state_frametype >= FRAMETYPE_AUD0) && (state_frametype <= FRAMETYPE_AUDMAX))
 188     {
 189       parsed = parse_audio_frame(len, &full);
 190     }
 191     else if (state_frametype == FRAMETYPE_PRIVATE_1)
 192     {
 193       parsed = parse_private1_frame(len, &full);
 194     }
 195
 196     ret += parsed; len -= parsed;
 197     if (full) // We have to exit early.
 198       break; // out of while loop
 199   }
 200   //Log::getInstance()->log("Demuxer", Log::DEBUG, "Put %d; took %d", ret + len, ret);
 201   return ret;
 202 }
 203
 204 int Demuxer::parse_find_frame(int len)
 205 {
 206   int ret = 0; // return number of bytes parsed
 207   UCHAR byte;
 208
 209   // In this function, state_framepos represents
 210   // the number of fixed header bytes found so far.
 211   if (state_framepos > 3 || state_framepos < 0)
 212   {
 213     // ERROR!
 214     state_framepos = 0;
 215   }
 216
 217   while (len)
 218   {
 219     byte = *inbuf++;
 220     ++ret; --len;
 221     switch (state_framepos)
 222     {
 223       case 0:
 224       case 1:
 225         if (byte == 0)
 226           ++state_framepos;
 227         else
 228           state_framepos = 0;
 229         break;
 230       case 2:
 231         if (byte == 1)
 232           ++state_framepos;
 233         else if (byte != 0)
 234           state_framepos = 0;
 235         break;
 236       default:
 237         state_framepos = 0; // Set initial state for the new frame
 238
 239         if (byte == 0)
 240         {
 241           state_framepos = 1; // Count this as a first header byte!
 242         }
 243         else if (  ((byte >= FRAMETYPE_VID0) && (byte <= FRAMETYPE_VIDMAX))
 244                 || ((byte >= FRAMETYPE_AUD0) && (byte <= FRAMETYPE_AUDMAX))
 245                 || byte==FRAMETYPE_PRIVATE_1 )
 246         {
 247           state_frametype = byte;
 248           return ret;
 249         }
 250
 251         // Not a recognised frame type. Go back to Old Kent Road.
 252         break;
 253     }
 254   }
 255   return ret;
 256 }
 257
 258 int Demuxer::parse_video_frame(int len, int* full)
 259 {
 260   int ret = 0; // return number of bytes consumed
 261   int bytes_remaining;
 262
 263   switch(state_framepos)
 264   {
 265     case 0: // Brand new video frame. Set initial states.
 266       state_stream_fill = 0; state_vid_parsed = 0;
 267       // Create a local copy of the frame header
 268       local_frame[0] = local_frame[1] = 0; local_frame[2] = 1;
 269       local_frame[3] = state_frametype;
 270       // If no video stream has been set, use this one.
 271       if (video_current == -1) video_current = state_frametype;
 272       // Get MSB of frame length and copy to local frame.
 273       frame_length = *inbuf << 8;
 274       local_frame[4] = *inbuf;
 275       ++inbuf; ++state_framepos; ++ret; --len;
 276       if (len == 0) return ret;
 277       // FALL THROUGH TO NEXT BYTE IN STREAM
 278     case 1: // Get LSB of frame length and copy to local frame.
 279       frame_length += *inbuf;
 280       local_frame[5] = *inbuf;
 281       ++inbuf; ++state_framepos; ++ret; --len;
 282       if (len == 0) return ret;
 283   }
 284   // We are in the frame data
 285   bytes_remaining = 2 + frame_length - state_framepos;
 286   if (video_current != state_frametype)
 287   {
 288     // We don't want this frame. Throw it away.
 289     if (len >= bytes_remaining)
 290     {
 291       inbuf += bytes_remaining;
 292       ret += bytes_remaining;
 293       state_frametype = state_framepos = 0;
 294       return ret;
 295     }
 296     else
 297     {
 298       inbuf += len; ret += len;
 299       state_framepos += len;
 300       return ret;
 301     }
 302   } // No fall through here
 303
 304   if (bytes_remaining)   // There is data yet to copy to local_frame
 305   {
 306     if (len > bytes_remaining) len = bytes_remaining;
 307     memcpy(local_frame + state_framepos + 4, inbuf, len);
 308     inbuf += len; ret += len; state_framepos += len;
 309     if (len < bytes_remaining)   // Not all arrived yet
 310       return ret;
 311     parse_video_details(local_frame+6, frame_length);
 312   }
 313
 314   if (!seeking)
 315   {
 316   // We have the whole frame in local_frame. Send it to the stream.
 317   // We still support streams that might not consume all the data.
 318     state_stream_fill += videostream.put(local_frame,
 319                     6 + frame_length - state_stream_fill);
 320     if (state_stream_fill < frame_length + 6)   // stream is full!
 321     {
 322       *full = 1; return ret;
 323     }
 324   }
 325   state_frametype = state_framepos = 0;
 326   return ret;
 327 }
 328
 329 int Demuxer::parse_audio_frame(int len, int* full)
 330 {
 331   int ret = 0; // return number of bytes consumed
 332   int bytes_remaining;
 333
 334   switch(state_framepos)
 335   {
 336     case 0: // Brand new audio frame. Set initial states.
 337       state_stream_fill = 0;
 338       // Create a local copy of the frame header
 339       local_frame[0] = local_frame[1] = 0; local_frame[2] = 1;
 340       local_frame[3] = state_frametype;
 341       // If no audio stream has been set, use this one.
 342       if (audio_current == -1) audio_current = state_frametype;
 343       // Get MSB of frame length and copy to local frame.
 344       frame_length = *inbuf << 8;
 345       local_frame[4] = *inbuf;
 346       ++inbuf; ++state_framepos; ++ret; --len;
 347       if (len == 0) return ret;
 348       // FALL THROUGH TO NEXT BYTE IN STREAM
 349     case 1: // Get LSB of frame length and copy to local frame.
 350       frame_length += *inbuf;
 351       local_frame[5] = *inbuf;
 352       ++inbuf; ++state_framepos; ++ret; --len;
 353       if (len == 0) return ret;
 354   }
 355   // We are in the frame data
 356   bytes_remaining = 2 + frame_length - state_framepos;
 357   if (audio_current != state_frametype)
 358   {
 359     // We don't want this frame. Throw it away.
 360     if (len >= bytes_remaining)
 361     {
 362       inbuf += bytes_remaining;
 363       ret += bytes_remaining;
 364       state_frametype = state_framepos = 0;
 365       return ret;
 366     }
 367     else
 368     {
 369       inbuf += len; ret += len;
 370       state_framepos += len;
 371       return ret;
 372     }
 373   } // No fall through is allowed here
 374
 375   if (bytes_remaining)   // There is data yet to copy to local_frame
 376   {
 377     if (len > bytes_remaining) len = bytes_remaining;
 378     memcpy(local_frame + state_framepos + 4, inbuf, len);
 379     inbuf += len; ret += len; state_framepos += len;
 380     if (len < bytes_remaining)   // Not all arrived yet
 381       return ret;
 382   }
 383
 384   // We have the whole frame in local_frame. Send it to the stream.
 385   // We still support streams that might not consume all the data.
 386   state_stream_fill += audiostream.put(local_frame,
 387                   6 + frame_length - state_stream_fill);
 388   if (state_stream_fill < frame_length + 6)   // stream is full!
 389   {
 390     *full = 1; return ret;
 391   }
 392   state_frametype = state_framepos = 0;
 393   return ret;
 394 }
 395
 396 int Demuxer::parse_private1_frame(int len, int* full)
 397 {
 398   int ret = 0; // return number of bytes consumed
 399   int bytes_remaining;
 400
 401   switch(state_framepos)
 402   {
 403     case 0: // Brand new frame. Set initial states.
 404       // Get MSB of frame length and copy to local frame.
 405       frame_length = *inbuf << 8;
 406       ++inbuf; ++state_framepos; ++ret; --len;
 407       if (len == 0) return ret;
 408       // FALL THROUGH TO NEXT BYTE IN STREAM
 409     case 1: // Get LSB of frame length and copy to local frame.
 410       frame_length += *inbuf;
 411       local_frame[5] = *inbuf;
 412       ++inbuf; ++state_framepos; ++ret; --len;
 413       if (len == 0) return ret;
 414   }
 415   // We are in the frame data
 416   bytes_remaining = 2 + frame_length - state_framepos;
 417   // Temporary - just discard the frame.
 418   if (len >= bytes_remaining)
 419   {
 420     inbuf += bytes_remaining;
 421     ret += bytes_remaining;
 422     state_frametype = state_framepos = 0;
 423     return ret;
 424   }
 425   else
 426   {
 427     inbuf += len; ret += len;
 428     state_framepos += len;
 429     return ret;
 430   }
 431 }
 432
 433 void Demuxer::parse_video_details(UCHAR* buf, int len)
 434 {
 435   // Extract video PTS if it exists
 436   if ( buf[1] & 0x80 ) // PTS_DTS_flags indicate that PTS is present
 437   {
 438     video_pts = ( (ULLONG)(buf[3] & 0x0E) << 29 ) |
 439                 ( (ULLONG)(buf[4])        << 22 ) |
 440                 ( (ULLONG)(buf[5] & 0xFE) << 14 ) |
 441                 ( (ULLONG)(buf[6])        <<  7 ) |
 442                 ( (ULLONG)(buf[7] & 0xFE) >>  1 );
 443   }
 444   // Now, scan for a GOP header and extract video information
 445   UCHAR byte;
 446   int zeros = 0;
 447   while (len >= 8) // 8 is length of a GOP header
 448   {
 449     // We are searching for a string of bytes (0,0,1).
 450     byte = *(buf++); --len;
 451
 452     if (byte == 0)
 453     {
 454       ++zeros; continue;
 455     }
 456     if (zeros < 2 || byte != 1)
 457     {
 458       zeros = 0; continue;
 459     }
 460     zeros = 0;
 461     // We have found the pattern (0,0,1).
 462     // Check the next byte for the sub-frame type.
 463     byte = *(buf++); --len;
 464     switch (byte)
 465     {
 466       case 0x00: // Picture header
 467                  // 10 bits: temporal reference
 468                  //  3 bits: coding type (I/P/B)
 469                  //  ...
 470         if (len < 2) return;
 471         if ( (buf[1] & 0x38) == 0x08 ) // I-frame
 472           seeking = 0;
 473         buf += 4; // Minimum length of picture header
 474         len -= 4;
 475         break;
 476       case 0xb3: // Sequence header
 477                  // 12 bits: Horizontal size
 478                  // 12 bits: Vertical size
 479                  //  4 bits: Aspect ratio
 480                  //  4 bits: Frame rate code
 481                  // 18 bits: Bit rate value
 482                  // ...
 483         if (len < 7) return;
 484         horizontal_size = ((int)buf[0] << 4) | ((int)buf[1] >> 4);
 485         vertical_size = (((int)buf[1] & 0xf) << 8) | (int)buf[2];
 486         setAspectRatio((enum AspectRatio)(buf[3] >> 4));
 487         frame_rate = buf[3] & 0x0f;
 488         if (frame_rate >= 1 && frame_rate <= 8)
 489           frame_rate = FrameRates[frame_rate];
 490         else
 491           frame_rate = 0;
 492         bit_rate = ((int)buf[4] << 10) |
 493                    ((int)buf[5] << 2) |
 494                    ((int)buf[6] >> 6);
 495         seeking = 0;
 496         buf += 8; // Minimum length of sequence header
 497         len -= 8;
 498         break;
 499       case 0xb8: // Group header
 500                  // We're not going to bother parsing anything.
 501         seeking = 0;
 502         buf += 4; // Minimum length of group header
 503         len -= 4;
 504         break;
 505     }
 506   }
 507 }
 508
 509 int Demuxer::findVideoPTS(UCHAR* buf, int len, ULLONG* dest)
 510 {
 511   UINT LoPattern = 0x100 | FRAMETYPE_VID0,
 512        HiPattern = 0x100 | FRAMETYPE_VIDMAX;
 513
 514   while (len >= 14)
 515   {
 516     UINT pattern = *(UINT*)buf;
 517     buf++; len--;
 518     if (pattern < LoPattern || pattern > HiPattern) continue;
 519
 520     UINT framelength = ((UINT)buf[3] << 8) | buf[4];
 521     buf += 5; len -= 5;
 522
 523     if ( buf[1] & 0x80 ) // PTS_DTS_flags indicate that PTS is present
 524     {
 525       *dest = ( (ULLONG)(buf[3] & 0x0E) << 29 ) |
 526               ( (ULLONG)(buf[4])        << 22 ) |
 527               ( (ULLONG)(buf[5] & 0xFE) << 14 ) |
 528               ( (ULLONG)(buf[6])        <<  7 ) |
 529               ( (ULLONG)(buf[7] & 0xFE) >>  1 );
 530       return 1;
 531     }
 532
 533     buf += framelength; len -= framelength;
 534   }
 535   // No PTS found.
 536   return 0;
 537 }