]> git.vomp.tv Git - vompclient-marten.git/blob - demuxer.cc
Remove a couple of log lines
[vompclient-marten.git] / demuxer.cc
1 /*
2     Copyright 2005-2007 Mark Calderbank
3     Copyright 2007 Marten Richter (AC3 support)
4
5     This file is part of VOMP.
6
7     VOMP is free software; you can redistribute it and/or modify
8     it under the terms of the GNU General Public License as published by
9     the Free Software Foundation; either version 2 of the License, or
10     (at your option) any later version.
11
12     VOMP is distributed in the hope that it will be useful,
13     but WITHOUT ANY WARRANTY; without even the implied warranty of
14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15     GNU General Public License for more details.
16
17     You should have received a copy of the GNU General Public License
18     along with VOMP; if not, write to the Free Software
19     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
20 */
21
22 #include "demuxer.h"
23
24 #include "callback.h"
25 #include "log.h"
26
27 #define DEMUXER_SEQ_HEAD 0x000001B3
28 #define DEMUXER_PIC_HEAD 0x00000101
29 #define SEEK_THRESHOLD 150000 // About 1.5 seconds
30
31 // Statics
32 const int Demuxer::FrameRates[9] = { 0, 23, 24, 25, 29, 30, 50, 59, 60 };
33 const ULLONG PESPacket::PTS_INVALID = (1LL << 33);
34 Demuxer* Demuxer::instance = NULL;
35
36 // PESPacket methods
37 PESPacket::PESPacket()
38 {
39   data[0] = 0x00;
40   data[1] = 0x00;
41   data[2] = 0x01;
42   init(0);
43 }
44
45 void PESPacket::init(UCHAR type, UCHAR sub)
46 {
47   length = 0; 
48   size = 6;
49   data[3] = type;
50   data[4] = data[5] = 0;
51   packetType = type;
52   substream = sub;
53   seq_header = 1; // Unknown seq_header status
54 }
55
56 void PESPacket::truncate()
57 {
58   init(packetType,substream);
59 }
60
61 int PESPacket::write(UCHAR *buf, int len)
62 {
63   if (length + len > 0xFFFA) return 0;
64   memcpy(data+length+6, buf, len);
65   length += len;
66   size += len;
67   data[4] = (length >> 8);
68   data[5] = (length & 0xFF);
69   // We have added data - reset seq_header indicator if necessary
70   if (seq_header == 0) seq_header = 1; // Reset to 'unknown'
71   return 1;
72 }
73
74 ULLONG PESPacket::getPTS()
75 {
76   if ( ( (packetType >= Demuxer::PESTYPE_AUD0 &&
77           packetType <= Demuxer::PESTYPE_AUDMAX)
78          ||
79          (packetType >= Demuxer::PESTYPE_VID0 &&
80           packetType <= Demuxer::PESTYPE_VIDMAX)
81        ) && size >= 14 && data[7] & 0x80)
82   {
83     return ( (ULLONG)(data[ 9] & 0x0E) << 29) |
84            ( (ULLONG)(data[10])        << 22 ) |
85            ( (ULLONG)(data[11] & 0xFE) << 14 ) |
86            ( (ULLONG)(data[12])        <<  7 ) |
87            ( (ULLONG)(data[13] & 0xFE) >>  1 );
88   }
89   else return PTS_INVALID;
90 }
91
92 UCHAR PESPacket::operator[] (UINT index)
93 {
94   if (index >= size)
95     return 0;
96   else
97     return data[index];
98 }
99
100 UINT PESPacket::findPictureHeader()
101 {
102   if (size < 12) return 0;
103   UINT pattern = ( ((UINT)data[ 8] << 24) |
104                    ((UINT)data[ 9] << 16) |
105                    ((UINT)data[10] <<  8) |
106                     (UINT)data[11]  );
107   UINT pos = 11;
108   while (pattern != DEMUXER_PIC_HEAD)
109   {
110     if (++pos >= size) return 0;
111     pattern = (pattern << 8) | data[pos];
112   }
113   return pos-3;
114 }
115
116 UINT PESPacket::findSeqHeader()
117 {
118   if (seq_header != 1) return seq_header;
119   if (size < 12) return 0;
120   UINT pattern = ( ((UINT)data[ 8] << 24) |
121                    ((UINT)data[ 9] << 16) |
122                    ((UINT)data[10] <<  8) |
123                     (UINT)data[11]  );
124   UINT pos = 11;
125   while (pattern != DEMUXER_SEQ_HEAD)
126   {
127     if (++pos >= size)
128     {
129       seq_header = 0;
130       return 0;
131     }
132     pattern = (pattern << 8) | data[pos];
133   }
134   seq_header = pos - 3;
135   return seq_header;
136 }
137
138 // Demuxer methods
139 Demuxer::Demuxer()
140 {
141   if (instance) return;
142   instance = this;
143   initted = false;
144   callback = NULL;
145   arcnt = 0;
146   vid_seeking = aud_seeking = false;
147   video_pts = audio_pts = 0;
148   ispre_1_3_19 = false;
149 }
150
151 Demuxer::~Demuxer()
152 {
153   shutdown();
154   instance = NULL;
155 }
156
157 Demuxer* Demuxer::getInstance()
158 {
159   return instance;
160 }
161
162 int Demuxer::init(Callback* tcallback, DrainTarget* audio, DrainTarget* video, ULONG demuxMemoryV, ULONG demuxMemoryA)
163 {
164   if (!initted)
165   {
166     if ( !videostream.init(video, demuxMemoryV) ||
167          !audiostream.init(audio, demuxMemoryA))
168     {
169       Log::getInstance()->log("Demuxer", Log::CRIT,
170                               "Failed to initialize demuxer");
171       shutdown();
172       return 0;
173     }
174   }
175
176   reset();
177   initted = true;
178   callback = tcallback;
179   return 1;
180 }
181
182 void Demuxer::reset()
183 {
184   Log::getInstance()->log("Demuxer", Log::DEBUG, "Reset called");
185   flush();
186   video_current = audio_current = -1;
187   horizontal_size = vertical_size = 0;
188   aspect_ratio = (enum AspectRatio) 0;
189   frame_rate = bit_rate = 0;
190   ispre_1_3_19 = false;
191
192   for (int i = 0; i <= (PESTYPE_AUDMAX - PESTYPE_AUD0); i++)
193   {
194     avail_mpaudchan[i] = false;
195   }
196   for (int i = 0; i <= (PESTYPE_SUBSTREAM_AC3MAX - PESTYPE_SUBSTREAM_AC30); i++)
197   {
198     avail_ac3audchan[i] = false;
199   }
200 }
201
202 int Demuxer::shutdown()
203 {
204   videostream.shutdown();
205   audiostream.shutdown();
206   initted = false;
207   return 1;
208 }
209
210 void Demuxer::flush()
211 {
212   Log::getInstance()->log("Demuxer", Log::DEBUG, "Flush called");
213
214   videostream.flush();
215   audiostream.flush();
216 }
217
218 void Demuxer::flushAudio()
219 {
220   audiostream.flush();
221 }
222
223 void Demuxer::seek()
224 {
225   vid_seeking = aud_seeking = true;
226   video_pts = audio_pts = 0;
227 }
228
229 void Demuxer::setAudioStream(int id)
230 {
231   audio_current = id;
232 }
233
234 void Demuxer::setVideoStream(int id)
235 {
236   video_current = id;
237 }
238
239 void Demuxer::setAspectRatio(enum AspectRatio ar)
240 {
241   if (aspect_ratio != ar)
242   {
243     Log::getInstance()->log("Demux", Log::DEBUG,
244                             "Aspect ratio difference signalled");
245     if (++arcnt > 3) // avoid changing aspect ratio if glitch in signal
246     {
247       arcnt = 0;
248       aspect_ratio = ar;
249       if (callback) callback->call(this);
250     }
251   }
252   else
253     arcnt = 0;
254 }
255
256 bool Demuxer::writeAudio()
257 {
258   return audiostream.drain();
259 }
260
261 bool Demuxer::writeVideo()
262 {
263   return videostream.drain();
264 }
265
266 bool Demuxer::submitPacket(PESPacket& packet)
267 {
268   UINT sent = 0;
269   UCHAR packet_type = packet.getPacketType();
270
271   if (packet_type >= PESTYPE_VID0 && packet_type <= PESTYPE_VIDMAX)
272   {
273     if (video_current == -1) video_current = packet_type;
274     if (video_current == packet_type && !vid_seeking)
275       sent = videostream.put(packet.getData(), packet.getSize(), MPTYPE_VIDEO);
276     else
277       sent = packet.getSize();
278   }
279   else if (packet_type >= PESTYPE_AUD0 && packet_type <= PESTYPE_AUDMAX)
280   {
281     if (audio_current == -1) audio_current = packet_type;
282     avail_mpaudchan[packet_type - PESTYPE_AUD0] = true;
283     if (audio_current == packet_type && !aud_seeking)
284       sent = audiostream.put(packet.getData(), packet.getSize(), MPTYPE_MPEG_AUDIO);
285     else
286       sent = packet.getSize();
287   }
288   else if (packet_type == PESTYPE_PRIVATE_1 &&
289            packet.getSubstream() >= PESTYPE_SUBSTREAM_AC30 &&
290            packet.getSubstream() <= PESTYPE_SUBSTREAM_AC3MAX)
291   {
292     avail_ac3audchan[packet.getSubstream() - PESTYPE_SUBSTREAM_AC30] = true;
293     if (packet.getSubstream() == audio_current)
294     {
295       sent = audiostream.put(packet.getData(), packet.getSize(), (ispre_1_3_19)? MPTYPE_AC3_PRE13 : MPTYPE_AC3);
296     }
297     else
298     {
299       sent = packet.getSize();
300     }
301   }
302   else
303   {
304     sent = packet.getSize();
305   }
306
307   if (sent < packet.getSize()) // Stream is full.
308     return false;
309   else
310     return true;
311 }
312
313 void Demuxer::parsePacketDetails(PESPacket& packet)
314 {
315   if (packet.getPacketType() >= PESTYPE_AUD0 &&
316       packet.getPacketType() <= PESTYPE_AUDMAX)
317   {
318     // Extract audio PTS if it exists
319     if (packet.hasPTS())
320     {
321       audio_pts = packet.getPTS();
322       // We continue to seek on the audio if the video PTS that we
323       // are trying to match is ahead of the audio PTS by at most
324       // SEEK_THRESHOLD. We consider the possibility of PTS wrap.
325       if (aud_seeking && !vid_seeking &&
326           !( (video_pts_seek > audio_pts &&
327               video_pts_seek - audio_pts < SEEK_THRESHOLD)
328               ||
329              (video_pts_seek < audio_pts &&
330               video_pts_seek + (1LL<<33) - audio_pts < SEEK_THRESHOLD) ))
331       {
332         aud_seeking = 0;
333         Log::getInstance()->log("Demuxer", Log::DEBUG,
334             "Leaving  audio sync: Audio PTS = %llu", audio_pts);
335       }
336     }
337   }
338   else if (packet.getPacketType() == PESTYPE_PRIVATE_1) // Private stream
339   {
340     //Inspired by vdr's device.c
341     int payload_begin = packet[8]+9;
342     unsigned char substream_id = packet[payload_begin];
343     unsigned char substream_type = substream_id & 0xF0;
344     unsigned char substream_index = substream_id & 0x1F;
345 pre_1_3_19_Recording: //This is for old recordings stuff and live TV
346     if (ispre_1_3_19)
347     {
348       substream_id = PESTYPE_PRIVATE_1;
349       substream_type = 0x80;
350       substream_index = 0;
351     }
352     switch (substream_type)
353     {
354       case 0x20://SPU
355       case 0x30://SPU
356         break;
357       case 0xA0: //LPCM //not supported yet, is there any LPCM transmissio out there?
358         break;
359       case 0x80: //ac3, currently only one ac3 track per recording supported
360         packet.setSubstream(substream_type+substream_index);
361
362         // Extract audio PTS if it exists
363         if (packet.hasPTS())
364         {
365           audio_pts = packet.getPTS();
366           // We continue to seek on the audio if the video PTS that we
367           // are trying to match is ahead of the audio PTS by at most
368           // SEEK_THRESHOLD. We consider the possibility of PTS wrap.
369           if (aud_seeking && !vid_seeking &&
370               !( (video_pts_seek > audio_pts &&
371                   video_pts_seek - audio_pts < SEEK_THRESHOLD)
372               ||
373               (video_pts_seek < audio_pts &&
374                     video_pts_seek + (1LL<<33) - audio_pts < SEEK_THRESHOLD) ))
375           {
376             aud_seeking = 0;
377             Log::getInstance()->log("Demuxer", Log::DEBUG, "Leaving  audio sync: Audio PTS = %llu", audio_pts);
378           }
379         }
380         break;
381       default:
382         if (!ispre_1_3_19)
383         {
384           ispre_1_3_19=true; //switching to compat mode and live tv mode
385           goto pre_1_3_19_Recording;
386         }
387         else
388         {
389           packet.setSubstream(0);
390         }
391         break;
392     }
393   }
394   else if (packet.getPacketType() >= PESTYPE_VID0 &&
395            packet.getPacketType() <= PESTYPE_VIDMAX)
396   {
397     // Extract video PTS if it exists
398     if (packet.hasPTS()) video_pts = packet.getPTS();
399
400     // If there is a sequence header, extract information
401     UINT pos = packet.findSeqHeader();
402     if (pos > 1)
403     {
404       pos += 4;
405       if (pos+6 >= packet.getSize()) return;
406       horizontal_size = ((int)packet[pos] << 4) | ((int)packet[pos+1] >> 4);
407       vertical_size = (((int)packet[pos+1] & 0xf) << 8) | (int)packet[pos+2];
408       setAspectRatio((enum AspectRatio)(packet[pos+3] >> 4));
409       frame_rate = packet[pos+3] & 0x0f;
410       if (frame_rate >= 1 && frame_rate <= 8)
411         frame_rate = FrameRates[frame_rate];
412       else
413         frame_rate = 0;
414       bit_rate = ((int)packet[pos+4] << 10) |
415                  ((int)packet[pos+5] << 2) |
416                  ((int)packet[pos+6] >> 6);
417       if (vid_seeking)
418       {
419         vid_seeking = 0;
420         video_pts_seek = video_pts;
421         Log::getInstance()->log("Demuxer", Log::DEBUG,
422             "Entering audio sync: Video PTS = %llu", video_pts);
423         Log::getInstance()->log("Demuxer", Log::DEBUG,
424             "Entering audio sync: Audio PTS = %llu", audio_pts);
425       }
426       return;
427     }
428   }
429 }
430
431 UINT Demuxer::stripAudio(UCHAR* buf, UINT len)
432 {
433   UINT read_pos = 0, write_pos = 0;
434   UINT pattern, packet_length;
435   if (len < 4) return 0;
436   pattern = (buf[0] << 16) | (buf[1] << 8) | (buf[2]);
437   while (read_pos + 7 <= len)
438   {
439     pattern = ((pattern & 0xFFFFFF) << 8) | buf[read_pos+3];
440     if (pattern < (0x100|PESTYPE_VID0) || pattern > (0x100|PESTYPE_VIDMAX))
441       read_pos++;
442     else
443     {
444       packet_length = ((buf[read_pos+4] << 8) | (buf[read_pos+5])) + 6;
445       if (read_pos + packet_length > len)
446         read_pos = len;
447       else
448       {
449         if (read_pos != write_pos)
450           memmove(buf+write_pos, buf+read_pos, packet_length);
451         read_pos += packet_length;
452         write_pos += packet_length;
453         pattern = (buf[read_pos] << 16) | (buf[read_pos+1] << 8)
454                                         | (buf[read_pos+2]);
455       }
456     }
457   }
458   return write_pos;
459 }
460
461 bool Demuxer::scanForVideo(UCHAR* buf, UINT len)
462 {
463   UINT pos = 3;
464   UINT pattern;
465   if (len < 4) return false;
466   pattern = (buf[0] << 16) | (buf[1] << 8) | (buf[2]);
467   while (pos < len)
468   {
469     pattern = ((pattern & 0xFFFFFF) << 8) | buf[pos++];
470     if (pattern >= (0x100|PESTYPE_VID0) && pattern <= (0x100|PESTYPE_VIDMAX))
471       return true;
472   }
473   return false;
474 }
475
476 bool* Demuxer::getmpAudioChannels()
477 {
478   return avail_mpaudchan;
479 }
480
481 bool* Demuxer::getac3AudioChannels()
482 {
483   return avail_ac3audchan;
484 }
485
486 int Demuxer::getselAudioChannel()
487 {
488   return audio_current;
489 }
490
491 void Demuxer::setAudioChannel(int aud_channel)
492 {
493   audio_current = aud_channel;
494 }