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