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     switch (state_frametype)
 179     {
 180       case 0: // Search for frame
 181         parsed = parse_find_frame(len);
 182         break;
 183       case FRAMETYPE_VID0 ... FRAMETYPE_VIDMAX:
 184         parsed = parse_video_frame(len, &full);
 185         break;
 186       case FRAMETYPE_AUD0 ... FRAMETYPE_AUDMAX:
 187         parsed = parse_audio_frame(len, &full);
 188         break;
 189       case FRAMETYPE_PRIVATE_1:
 190         parsed = parse_private1_frame(len, &full);
 191         break;
 192     }
 193     ret += parsed; len -= parsed;
 194     if (full) // We have to exit early.
 195       break; // out of while loop
 196   }
 197   //Log::getInstance()->log("Demuxer", Log::DEBUG, "Put %d; took %d", ret + len, ret);
 198   return ret;
 199 }
 200
 201 int Demuxer::parse_find_frame(int len)
 202 {
 203   int ret = 0; // return number of bytes parsed
 204   UCHAR byte;
 205
 206   // In this function, state_framepos represents
 207   // the number of fixed header bytes found so far.
 208   if (state_framepos > 3 || state_framepos < 0)
 209   {
 210     // ERROR!
 211     state_framepos = 0;
 212   }
 213
 214   while (len)
 215   {
 216     byte = *inbuf++;
 217     ++ret; --len;
 218     switch (state_framepos)
 219     {
 220       case 0:
 221       case 1:
 222         if (byte == 0)
 223           ++state_framepos;
 224         else
 225           state_framepos = 0;
 226         break;
 227       case 2:
 228         if (byte == 1)
 229           ++state_framepos;
 230         else if (byte != 0)
 231           state_framepos = 0;
 232         break;
 233       default:
 234         state_framepos = 0; // Set initial state for the new frame
 235         switch (byte)
 236         {
 237           case 0:
 238             state_framepos = 1; // Count this as a first header byte!
 239             break;
 240           case FRAMETYPE_VID0 ... FRAMETYPE_VIDMAX:
 241           case FRAMETYPE_AUD0 ... FRAMETYPE_AUDMAX:
 242           case FRAMETYPE_PRIVATE_1:
 243             state_frametype = byte;
 244             return ret;
 245         }
 246         // Not a recognised frame type. Go back to Old Kent Road.
 247         break;
 248     }
 249   }
 250   return ret;
 251 }
 252
 253 int Demuxer::parse_video_frame(int len, int* full)
 254 {
 255   int ret = 0; // return number of bytes consumed
 256   int bytes_remaining;
 257
 258   switch(state_framepos)
 259   {
 260     case 0: // Brand new video frame. Set initial states.
 261       state_stream_fill = 0; state_vid_parsed = 0;
 262       // Create a local copy of the frame header
 263       local_frame[0] = local_frame[1] = 0; local_frame[2] = 1;
 264       local_frame[3] = state_frametype;
 265       // If no video stream has been set, use this one.
 266       if (video_current == -1) video_current = state_frametype;
 267       // Get MSB of frame length and copy to local frame.
 268       frame_length = *inbuf << 8;
 269       local_frame[4] = *inbuf;
 270       ++inbuf; ++state_framepos; ++ret; --len;
 271       if (len == 0) return ret;
 272       // FALL THROUGH TO NEXT BYTE IN STREAM
 273     case 1: // Get LSB of frame length and copy to local frame.
 274       frame_length += *inbuf;
 275       local_frame[5] = *inbuf;
 276       ++inbuf; ++state_framepos; ++ret; --len;
 277       if (len == 0) return ret;
 278   }
 279   // We are in the frame data
 280   bytes_remaining = 2 + frame_length - state_framepos;
 281   if (video_current != state_frametype)
 282   {
 283     // We don't want this frame. Throw it away.
 284     if (len >= bytes_remaining)
 285     {
 286       inbuf += bytes_remaining;
 287       ret += bytes_remaining;
 288       state_frametype = state_framepos = 0;
 289       return ret;
 290     }
 291     else
 292     {
 293       inbuf += len; ret += len;
 294       state_framepos += len;
 295       return ret;
 296     }
 297   } // No fall through here
 298
 299   if (bytes_remaining)   // There is data yet to copy to local_frame
 300   {
 301     if (len > bytes_remaining) len = bytes_remaining;
 302     memcpy(local_frame + state_framepos + 4, inbuf, len);
 303     inbuf += len; ret += len; state_framepos += len;
 304     if (len < bytes_remaining)   // Not all arrived yet
 305       return ret;
 306     parse_video_details(local_frame+6, frame_length);
 307   }
 308
 309   if (!seeking)
 310   {
 311   // We have the whole frame in local_frame. Send it to the stream.
 312   // We still support streams that might not consume all the data.
 313     state_stream_fill += videostream.put(local_frame,
 314                     6 + frame_length - state_stream_fill);
 315     if (state_stream_fill < frame_length + 6)   // stream is full!
 316     {
 317       *full = 1; return ret;
 318     }
 319   }
 320   state_frametype = state_framepos = 0;
 321   return ret;
 322 }
 323
 324 int Demuxer::parse_audio_frame(int len, int* full)
 325 {
 326   int ret = 0; // return number of bytes consumed
 327   int bytes_remaining;
 328
 329   switch(state_framepos)
 330   {
 331     case 0: // Brand new audio frame. Set initial states.
 332       state_stream_fill = 0;
 333       // Create a local copy of the frame header
 334       local_frame[0] = local_frame[1] = 0; local_frame[2] = 1;
 335       local_frame[3] = state_frametype;
 336       // If no audio stream has been set, use this one.
 337       if (audio_current == -1) audio_current = state_frametype;
 338       // Get MSB of frame length and copy to local frame.
 339       frame_length = *inbuf << 8;
 340       local_frame[4] = *inbuf;
 341       ++inbuf; ++state_framepos; ++ret; --len;
 342       if (len == 0) return ret;
 343       // FALL THROUGH TO NEXT BYTE IN STREAM
 344     case 1: // Get LSB of frame length and copy to local frame.
 345       frame_length += *inbuf;
 346       local_frame[5] = *inbuf;
 347       ++inbuf; ++state_framepos; ++ret; --len;
 348       if (len == 0) return ret;
 349   }
 350   // We are in the frame data
 351   bytes_remaining = 2 + frame_length - state_framepos;
 352   if (audio_current != state_frametype)
 353   {
 354     // We don't want this frame. Throw it away.
 355     if (len >= bytes_remaining)
 356     {
 357       inbuf += bytes_remaining;
 358       ret += bytes_remaining;
 359       state_frametype = state_framepos = 0;
 360       return ret;
 361     }
 362     else
 363     {
 364       inbuf += len; ret += len;
 365       state_framepos += len;
 366       return ret;
 367     }
 368   } // No fall through is allowed here
 369
 370   if (bytes_remaining)   // There is data yet to copy to local_frame
 371   {
 372     if (len > bytes_remaining) len = bytes_remaining;
 373     memcpy(local_frame + state_framepos + 4, inbuf, len);
 374     inbuf += len; ret += len; state_framepos += len;
 375     if (len < bytes_remaining)   // Not all arrived yet
 376       return ret;
 377   }
 378
 379   // We have the whole frame in local_frame. Send it to the stream.
 380   // We still support streams that might not consume all the data.
 381   state_stream_fill += audiostream.put(local_frame,
 382                   6 + frame_length - state_stream_fill);
 383   if (state_stream_fill < frame_length + 6)   // stream is full!
 384   {
 385     *full = 1; return ret;
 386   }
 387   state_frametype = state_framepos = 0;
 388   return ret;
 389 }
 390
 391 int Demuxer::parse_private1_frame(int len, int* full)
 392 {
 393   int ret = 0; // return number of bytes consumed
 394   int bytes_remaining;
 395
 396   switch(state_framepos)
 397   {
 398     case 0: // Brand new frame. Set initial states.
 399       // Get MSB of frame length and copy to local frame.
 400       frame_length = *inbuf << 8;
 401       ++inbuf; ++state_framepos; ++ret; --len;
 402       if (len == 0) return ret;
 403       // FALL THROUGH TO NEXT BYTE IN STREAM
 404     case 1: // Get LSB of frame length and copy to local frame.
 405       frame_length += *inbuf;
 406       local_frame[5] = *inbuf;
 407       ++inbuf; ++state_framepos; ++ret; --len;
 408       if (len == 0) return ret;
 409   }
 410   // We are in the frame data
 411   bytes_remaining = 2 + frame_length - state_framepos;
 412   // Temporary - just discard the frame.
 413   if (len >= bytes_remaining)
 414   {
 415     inbuf += bytes_remaining;
 416     ret += bytes_remaining;
 417     state_frametype = state_framepos = 0;
 418     return ret;
 419   }
 420   else
 421   {
 422     inbuf += len; ret += len;
 423     state_framepos += len;
 424     return ret;
 425   }
 426 }
 427
 428 void Demuxer::parse_video_details(UCHAR* buf, int len)
 429 {
 430   // Extract video PTS if it exists
 431   if ( buf[1] & 0x80 ) // PTS_DTS_flags indicate that PTS is present
 432   {
 433     video_pts = ( (ULLONG)(buf[3] & 0x0E) << 29 ) |
 434                 ( (ULLONG)(buf[4])        << 22 ) |
 435                 ( (ULLONG)(buf[5] & 0xFE) << 14 ) |
 436                 ( (ULLONG)(buf[6])        <<  7 ) |
 437                 ( (ULLONG)(buf[7] & 0xFE) >>  1 );
 438   }
 439   // Now, scan for a GOP header and extract video information
 440   UCHAR byte;
 441   int zeros = 0;
 442   while (len >= 8) // 8 is length of a GOP header
 443   {
 444     // We are searching for a string of bytes (0,0,1).
 445     byte = *(buf++); --len;
 446
 447     if (byte == 0)
 448     {
 449       ++zeros; continue;
 450     }
 451     if (zeros < 2 || byte != 1)
 452     {
 453       zeros = 0; continue;
 454     }
 455     zeros = 0;
 456     // We have found the pattern (0,0,1).
 457     // Check the next byte for the sub-frame type.
 458     byte = *(buf++); --len;
 459     switch (byte)
 460     {
 461       case 0x00: // Picture header
 462                  // 10 bits: temporal reference
 463                  //  3 bits: coding type (I/P/B)
 464                  //  ...
 465         if (len < 2) return;
 466         if ( (buf[1] & 0x38) == 0x08 ) // I-frame
 467           seeking = 0;
 468         buf += 4; // Minimum length of picture header
 469         len -= 4;
 470         break;
 471       case 0xb3: // Sequence header
 472                  // 12 bits: Horizontal size
 473                  // 12 bits: Vertical size
 474                  //  4 bits: Aspect ratio
 475                  //  4 bits: Frame rate code
 476                  // 18 bits: Bit rate value
 477                  // ...
 478         if (len < 7) return;
 479         horizontal_size = ((int)buf[0] << 4) | ((int)buf[1] >> 4);
 480         vertical_size = (((int)buf[1] & 0xf) << 8) | (int)buf[2];
 481         setAspectRatio((enum AspectRatio)(buf[3] >> 4));
 482         frame_rate = buf[3] & 0x0f;
 483         if (frame_rate >= 1 && frame_rate <= 8)
 484           frame_rate = FrameRates[frame_rate];
 485         else
 486           frame_rate = 0;
 487         bit_rate = ((int)buf[4] << 10) |
 488                    ((int)buf[5] << 2) |
 489                    ((int)buf[6] >> 6);
 490         seeking = 0;
 491         buf += 8; // Minimum length of sequence header
 492         len -= 8;
 493         break;
 494       case 0xb8: // Group header
 495                  // We're not going to bother parsing anything.
 496         seeking = 0;
 497         buf += 4; // Minimum length of group header
 498         len -= 4;
 499         break;
 500     }
 501   }
 502 }
 503
 504 int Demuxer::findVideoPTS(UCHAR* buf, int len, ULLONG* dest)
 505 {
 506   UINT LoPattern = 0x100 | FRAMETYPE_VID0,
 507        HiPattern = 0x100 | FRAMETYPE_VIDMAX;
 508
 509   while (len >= 14)
 510   {
 511     UINT pattern = *(UINT*)buf;
 512     buf++; len--;
 513     if (pattern < LoPattern || pattern > HiPattern) continue;
 514
 515     UINT framelength = ((UINT)buf[3] << 8) | buf[4];
 516     buf += 5; len -= 5;
 517
 518     if ( buf[1] & 0x80 ) // PTS_DTS_flags indicate that PTS is present
 519     {
 520       *dest = ( (ULLONG)(buf[3] & 0x0E) << 29 ) |
 521               ( (ULLONG)(buf[4])        << 22 ) |
 522               ( (ULLONG)(buf[5] & 0xFE) << 14 ) |
 523               ( (ULLONG)(buf[6])        <<  7 ) |
 524               ( (ULLONG)(buf[7] & 0xFE) >>  1 );
 525       return 1;
 526     }
 527
 528     buf += framelength; len -= framelength;
 529   }
 530   // No PTS found.
 531   return 0;
 532 }