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