2 Copyright 2005 Mark Calderbank
4 This file is part of VOMP.
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.
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.
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
23 const int Demuxer::FrameRates[9] = { 0, 23, 24, 25, 29, 30, 50, 59, 60 };
25 Demuxer* Demuxer::instance = NULL;
42 Demuxer* Demuxer::getInstance()
47 int Demuxer::init(Callback* tcallback)
51 if ( !videostream.init(demuxMemoryV) ||
52 !audiostream.init(demuxMemoryA) ||
53 !(local_frame = (UCHAR *) malloc(0x10000)))
55 Log::getInstance()->log("Demuxer", Log::CRIT, "Failed to initialize demuxer");
60 videostream.setDrainTarget(Video::getInstance());
61 audiostream.setDrainTarget(Audio::getInstance());
74 video_current = audio_current = -1;
75 horizontal_size = vertical_size = 0;
76 aspect_ratio = (enum AspectRatio) 0;
77 frame_rate = bit_rate = 0;
80 int Demuxer::shutdown()
82 videostream.shutdown();
83 audiostream.shutdown();
93 state_frametype = state_framepos = 0;
97 void Demuxer::flushAudio()
107 void Demuxer::setAudioStream(int id)
112 void Demuxer::setVideoStream(int id)
117 void Demuxer::setAspectRatio(enum AspectRatio ar)
119 if (aspect_ratio != ar)
121 Log::getInstance()->log("Demux", Log::DEBUG, "Aspect ratio difference signalled");
122 if (++arcnt > 3) // avoid changing aspect ratio if glitch in signal
126 callback->call(this);
133 int Demuxer::writeAudio(int fd)
135 return audiostream.drain(fd);
138 int Demuxer::writeVideo(int fd)
140 return videostream.drain(fd);
143 int Demuxer::writeAudio(DrainTarget* dt)
145 return audiostream.drain(dt);
148 int Demuxer::writeVideo(DrainTarget* dt)
150 return videostream.drain(dt);
155 int Demuxer::scan(UCHAR *buf, int len)
157 // Temporarily, just look for the lowest audio stream and return it
163 // We are searching for a string of bytes (0,0,1).
164 byte = *(buf++); --len;
170 if (zeros < 2 || byte != 1)
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;
184 int Demuxer::put(UCHAR* buf, int len)
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
195 if (state_frametype == 0) // Search for frame
197 parsed = parse_find_frame(len);
199 else if ((state_frametype >= FRAMETYPE_VID0) && (state_frametype <= FRAMETYPE_VIDMAX))
201 parsed = parse_video_frame(len, &full);
203 else if ((state_frametype >= FRAMETYPE_AUD0) && (state_frametype <= FRAMETYPE_AUDMAX))
205 parsed = parse_audio_frame(len, &full);
207 else if (state_frametype == FRAMETYPE_PRIVATE_1)
209 parsed = parse_private1_frame(len, &full);
212 ret += parsed; len -= parsed;
213 if (full) // We have to exit early.
214 break; // out of while loop
216 //Log::getInstance()->log("Demuxer", Log::DEBUG, "Put %d; took %d", ret + len, ret);
220 int Demuxer::parse_find_frame(int len)
222 int ret = 0; // return number of bytes parsed
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)
237 switch (state_framepos)
253 state_framepos = 0; // Set initial state for the new frame
257 state_framepos = 1; // Count this as a first header byte!
259 else if ( ((byte >= FRAMETYPE_VID0) && (byte <= FRAMETYPE_VIDMAX))
260 || ((byte >= FRAMETYPE_AUD0) && (byte <= FRAMETYPE_AUDMAX))
261 || byte==FRAMETYPE_PRIVATE_1 )
263 state_frametype = byte;
267 // Not a recognised frame type. Go back to Old Kent Road.
274 int Demuxer::parse_video_frame(int len, int* full)
276 int ret = 0; // return number of bytes consumed
279 switch(state_framepos)
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;
300 // We are in the frame data
301 bytes_remaining = 2 + frame_length - state_framepos;
302 if (video_current != state_frametype)
304 // We don't want this frame. Throw it away.
305 if (len >= bytes_remaining)
307 inbuf += bytes_remaining;
308 ret += bytes_remaining;
309 state_frametype = state_framepos = 0;
314 inbuf += len; ret += len;
315 state_framepos += len;
318 } // No fall through here
320 if (bytes_remaining) // There is data yet to copy to local_frame
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
327 parse_video_details(local_frame+6, frame_length);
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!
338 *full = 1; return ret;
341 state_frametype = state_framepos = 0;
345 int Demuxer::parse_audio_frame(int len, int* full)
347 int ret = 0; // return number of bytes consumed
350 switch(state_framepos)
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;
371 // We are in the frame data
372 bytes_remaining = 2 + frame_length - state_framepos;
373 if (audio_current != state_frametype)
375 // We don't want this frame. Throw it away.
376 if (len >= bytes_remaining)
378 inbuf += bytes_remaining;
379 ret += bytes_remaining;
380 state_frametype = state_framepos = 0;
385 inbuf += len; ret += len;
386 state_framepos += len;
389 } // No fall through is allowed here
391 if (bytes_remaining) // There is data yet to copy to local_frame
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
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!
406 *full = 1; return ret;
408 state_frametype = state_framepos = 0;
412 int Demuxer::parse_private1_frame(int len, int* full)
414 int ret = 0; // return number of bytes consumed
417 switch(state_framepos)
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;
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)
436 inbuf += bytes_remaining;
437 ret += bytes_remaining;
438 state_frametype = state_framepos = 0;
443 inbuf += len; ret += len;
444 state_framepos += len;
449 void Demuxer::parse_video_details(UCHAR* buf, int len)
451 // Extract video PTS if it exists
452 if ( buf[1] & 0x80 ) // PTS_DTS_flags indicate that PTS is present
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 );
460 // Now, scan for a GOP header and extract video information
463 while (len >= 8) // 8 is length of a GOP header
465 // We are searching for a string of bytes (0,0,1).
466 byte = *(buf++); --len;
472 if (zeros < 2 || byte != 1)
477 // We have found the pattern (0,0,1).
478 // Check the next byte for the sub-frame type.
479 byte = *(buf++); --len;
482 case 0x00: // Picture header
483 // 10 bits: temporal reference
484 // 3 bits: coding type (I/P/B)
487 if ( (buf[1] & 0x38) == 0x08 ) // I-frame
489 buf += 4; // Minimum length of picture header
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
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];
508 bit_rate = ((int)buf[4] << 10) |
512 buf += 8; // Minimum length of sequence header
515 case 0xb8: // Group header
516 // We're not going to bother parsing anything.
518 buf += 4; // Minimum length of group header
525 int Demuxer::findVideoPTS(UCHAR* buf, int len, ULLONG* dest)
527 UINT LoPattern = 0x100 | FRAMETYPE_VID0,
528 HiPattern = 0x100 | FRAMETYPE_VIDMAX;
532 UINT pattern = *(UINT*)buf;
534 if (pattern < LoPattern || pattern > HiPattern) continue;
536 UINT framelength = ((UINT)buf[3] << 8) | buf[4];
539 if ( buf[1] & 0x80 ) // PTS_DTS_flags indicate that PTS is present
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 );
549 buf += framelength; len -= framelength;