+void eDVBChannel::pvrEvent(int event)
+{
+ switch (event)
+ {
+ case eFilePushThread::evtEOF:
+ eDebug("eDVBChannel: End of file!");
+ m_event(this, evtEOF);
+ break;
+ case eFilePushThread::evtUser: /* start */
+ eDebug("SOF");
+ m_event(this, evtSOF);
+ break;
+ }
+}
+
+void eDVBChannel::cueSheetEvent(int event)
+{
+ /* we might end up here if playing failed or stopped, but the client hasn't (yet) noted. */
+ if (!m_pvr_thread)
+ return;
+ switch (event)
+ {
+ case eCueSheet::evtSeek:
+ eDebug("seek.");
+ flushPVR(m_cue->m_decoding_demux);
+ break;
+ case eCueSheet::evtSkipmode:
+ {
+ {
+ m_cue->m_lock.WrLock();
+ m_cue->m_seek_requests.push_back(std::pair<int, pts_t>(1, 0)); /* resync */
+ m_cue->m_lock.Unlock();
+ eRdLocker l(m_cue->m_lock);
+ if (m_cue->m_skipmode_ratio)
+ {
+ int bitrate = m_tstools.calcBitrate(); /* in bits/s */
+ eDebug("skipmode ratio is %lld:90000, bitrate is %d bit/s", m_cue->m_skipmode_ratio, bitrate);
+ /* i agree that this might look a bit like black magic. */
+ m_skipmode_n = 512*1024; /* must be 1 iframe at least. */
+ m_skipmode_m = bitrate / 8 / 90000 * m_cue->m_skipmode_ratio / 8;
+ m_skipmode_frames = m_cue->m_skipmode_ratio / 90000;
+ m_skipmode_frames_remainder = 0;
+
+ if (m_cue->m_skipmode_ratio < 0)
+ m_skipmode_m -= m_skipmode_n;
+
+ eDebug("resolved to: %d %d", m_skipmode_m, m_skipmode_n);
+
+ if (abs(m_skipmode_m) < abs(m_skipmode_n))
+ {
+ eWarning("something is wrong with this calculation");
+ m_skipmode_frames = m_skipmode_n = m_skipmode_m = 0;
+ }
+ } else
+ {
+ eDebug("skipmode ratio is 0, normal play");
+ m_skipmode_frames = m_skipmode_n = m_skipmode_m = 0;
+ }
+ }
+ m_pvr_thread->setIFrameSearch(m_skipmode_n != 0);
+ if (m_cue->m_skipmode_ratio != 0)
+ m_pvr_thread->setTimebaseChange(0x10000 * 9000 / (m_cue->m_skipmode_ratio / 10)); /* negative values are also ok */
+ else
+ m_pvr_thread->setTimebaseChange(0); /* normal playback */
+ eDebug("flush pvr");
+ flushPVR(m_cue->m_decoding_demux);
+ eDebug("done");
+ break;
+ }
+ case eCueSheet::evtSpanChanged:
+ {
+ m_source_span.clear();
+ for (std::list<std::pair<pts_t, pts_t> >::const_iterator i(m_cue->m_spans.begin()); i != m_cue->m_spans.end(); ++i)
+ {
+ off_t offset_in, offset_out;
+ pts_t pts_in = i->first, pts_out = i->second;
+ if (m_tstools.getOffset(offset_in, pts_in, -1) || m_tstools.getOffset(offset_out, pts_out, 1))
+ {
+ eDebug("span translation failed.\n");
+ continue;
+ }
+ eDebug("source span: %llx .. %llx, translated to %llx..%llx", pts_in, pts_out, offset_in, offset_out);
+ m_source_span.push_back(std::pair<off_t, off_t>(offset_in, offset_out));
+ }
+ break;
+ }
+ }
+}
+
+ /* align toward zero */
+static inline long long align(long long x, int align)
+{
+ int sign = x < 0;
+
+ if (sign)
+ x = -x;
+
+ x -= x % align;
+
+ if (sign)
+ x = -x;
+
+ return x;
+}
+
+ /* align toward zero */
+static inline long long align_with_len(long long x, int align, size_t &len)
+{
+ int sign = x < 0;
+
+ if (sign)
+ x = -x;
+
+ x -= x % align;
+ len += x % align;
+
+ if (sign)
+ x = -x;
+
+ return x;
+}
+
+ /* remember, this gets called from another thread. */
+void eDVBChannel::getNextSourceSpan(off_t current_offset, size_t bytes_read, off_t &start, size_t &size)
+{
+ const int blocksize = 188;
+ unsigned int max = align(10*1024*1024, blocksize);
+ current_offset = align(current_offset, blocksize);
+
+ if (!m_cue)
+ {
+ eDebug("no cue sheet. forcing normal play");
+ start = current_offset;
+ size = max;
+ return;
+ }
+
+ if (m_skipmode_n)
+ {
+ eDebug("skipmode %d:%d (x%d)", m_skipmode_m, m_skipmode_n, m_skipmode_frames);
+ max = align(m_skipmode_n, blocksize);
+ }
+
+ eDebug("getNextSourceSpan, current offset is %08llx, m_skipmode_m = %d!", current_offset, m_skipmode_m);
+ int frame_skip_success = 0;
+
+ if (m_skipmode_m)
+ {
+ int frames_to_skip = m_skipmode_frames + m_skipmode_frames_remainder;
+ eDebug("we are at %llx, and we try to skip %d+%d frames from here", current_offset, m_skipmode_frames, m_skipmode_frames_remainder);
+ size_t iframe_len;
+ off_t iframe_start = current_offset;
+ int frames_skipped = frames_to_skip;
+ if (!m_tstools.findNextPicture(iframe_start, iframe_len, frames_skipped))
+ {
+ m_skipmode_frames_remainder = frames_to_skip - frames_skipped;
+ eDebug("successfully skipped %d (out of %d, rem now %d) frames.", frames_skipped, frames_to_skip, m_skipmode_frames_remainder);
+ current_offset = align_with_len(iframe_start, blocksize, iframe_len);
+ max = align(iframe_len + 187, blocksize);
+ frame_skip_success = 1;
+ } else
+ {
+ m_skipmode_frames_remainder = 0;
+ eDebug("frame skipping failed, reverting to byte-skipping");
+ }
+ }
+
+ if (!frame_skip_success)
+ {
+ current_offset += align(m_skipmode_m, blocksize);
+
+ if (m_skipmode_m)
+ {
+ eDebug("we are at %llx, and we try to find the iframe here:", current_offset);
+ size_t iframe_len;
+ off_t iframe_start = current_offset;
+
+ int direction = (m_skipmode_m < 0) ? -1 : +1;
+ if (m_tstools.findFrame(iframe_start, iframe_len, direction))
+ eDebug("failed");
+ else
+ {
+ current_offset = align_with_len(iframe_start, blocksize, iframe_len);
+ max = align(iframe_len, blocksize);
+ }
+ }
+ }
+
+ m_cue->m_lock.RdLock();
+
+ while (!m_cue->m_seek_requests.empty())
+ {
+ std::pair<int, pts_t> seek = m_cue->m_seek_requests.front();
+ m_cue->m_lock.Unlock();
+ m_cue->m_lock.WrLock();
+ m_cue->m_seek_requests.pop_front();
+ m_cue->m_lock.Unlock();
+ m_cue->m_lock.RdLock();
+ int relative = seek.first;
+ pts_t pts = seek.second;
+
+ pts_t now = 0;
+ if (relative)
+ {
+ if (!m_cue->m_decoder)
+ {
+ eDebug("no decoder - can't seek relative");
+ continue;
+ }
+ if (m_cue->m_decoder->getPTS(0, now))
+ {
+ eDebug("decoder getPTS failed, can't seek relative");
+ continue;
+ }
+ if (!m_cue->m_decoding_demux)
+ {
+ eDebug("getNextSourceSpan, no decoding demux. couldn't seek to %llx... ignore request!", pts);
+ start = current_offset;
+ size = max;
+ continue;
+ }
+ if (getCurrentPosition(m_cue->m_decoding_demux, now, 1))
+ {
+ eDebug("seekTo: getCurrentPosition failed!");
+ continue;
+ }
+ } else if (pts < 0) /* seek relative to end */
+ {
+ pts_t len;
+ if (!getLength(len))
+ {
+ eDebug("seeking relative to end. len=%lld, seek = %lld", len, pts);
+ pts += len;
+ } else
+ {
+ eWarning("getLength failed - can't seek relative to end!");
+ continue;
+ }
+ }
+
+ if (relative == 1) /* pts relative */
+ {
+ pts += now;
+ if (pts < 0)
+ pts = 0;
+ }
+
+ if (relative != 2)
+ if (pts < 0)
+ pts = 0;
+
+ if (relative == 2) /* AP relative */
+ {
+ eDebug("AP relative seeking: %lld, at %lld", pts, now);
+ pts_t nextap;
+ if (m_tstools.getNextAccessPoint(nextap, now, pts))
+ {
+ pts = now - 90000; /* approx. 1s */
+ eDebug("AP relative seeking failed!");
+ } else
+ {
+ pts = nextap;
+ eDebug("next ap is %llx\n", pts);
+ }
+ }
+
+ off_t offset = 0;
+ if (m_tstools.getOffset(offset, pts, -1))
+ {
+ eDebug("get offset for pts=%lld failed!", pts);
+ continue;
+ }
+
+ eDebug("ok, resolved skip (rel: %d, diff %lld), now at %08llx", relative, pts, offset);
+ current_offset = align(offset, blocksize); /* in case tstools return non-aligned offset */
+ }
+
+ m_cue->m_lock.Unlock();
+
+ for (std::list<std::pair<off_t, off_t> >::const_iterator i(m_source_span.begin()); i != m_source_span.end(); ++i)
+ {
+ long long aligned_start = align(i->first, blocksize);
+ long long aligned_end = align(i->second, blocksize);
+
+ if ((current_offset >= aligned_start) && (current_offset < aligned_end))
+ {
+ start = current_offset;
+ /* max can not exceed max(size_t). aligned_end - current_offset, however, can. */
+ if ((aligned_end - current_offset) > max)
+ size = max;
+ else
+ size = aligned_end - current_offset;
+ eDebug("HIT, %lld < %lld < %lld, size: %d", i->first, current_offset, i->second, size);
+ return;
+ }
+ if (current_offset < aligned_start)
+ {
+ /* ok, our current offset is in an 'out' zone. */
+ if ((m_skipmode_m >= 0) || (i == m_source_span.begin()))
+ {
+ /* in normal playback, just start at the next zone. */
+ start = i->first;
+
+ /* size is not 64bit! */
+ if ((i->second - i->first) > max)
+ size = max;
+ else
+ size = aligned_end - aligned_start;
+
+ eDebug("skip");
+ if (m_skipmode_m < 0)
+ {
+ eDebug("reached SOF");
+ /* reached SOF */
+ m_skipmode_m = 0;
+ m_pvr_thread->sendEvent(eFilePushThread::evtUser);
+ }
+ } else
+ {
+ /* when skipping reverse, however, choose the zone before. */
+ --i;
+ eDebug("skip to previous block, which is %llx..%llx", i->first, i->second);
+ size_t len;
+
+ aligned_start = align(i->first, blocksize);
+ aligned_end = align(i->second, blocksize);
+
+ if ((aligned_end - aligned_start) > max)
+ len = max;
+ else
+ len = aligned_end - aligned_start;
+
+ start = aligned_end - len;
+ eDebug("skipping to %llx, %d", start, len);
+ }
+
+ eDebug("result: %llx, %x (%llx %llx)", start, size, aligned_start, aligned_end);
+ return;
+ }
+ }
+
+ if ((current_offset < -m_skipmode_m) && (m_skipmode_m < 0))
+ {
+ eDebug("reached SOF");
+ m_skipmode_m = 0;
+ m_pvr_thread->sendEvent(eFilePushThread::evtUser);
+ }
+
+ if (m_source_span.empty())
+ {
+ start = current_offset;
+ size = max;
+ eDebug("NO CUESHEET. (%08llx, %d)", start, size);
+ } else
+ {
+ start = current_offset;
+ size = 0;
+ }
+ return;
+}
+