plm_demux_seek()

plm_packet_t * fl::third_party::plm_demux_seek	(	plm_demux_t *	self,
		double	time,
		int	type,
		int	force_intra )

Definition at line 1374 of file pl_mpeg.hpp.

                                                                                                         {
    if (!plm_demux_has_headers(self)) {
        return NULL;
    }
 
    // Using the current time, current byte position and the average bytes per
    // second for this file, try to jump to a byte position that hopefully has
    // packets containing timestamps within one second before to the desired 
    // seek_time.
 
    // If we hit close to the seek_time scan through all packets to find the
    // last one (just before the seek_time) containing an intra frame.
    // Otherwise we should at least be closer than before. Calculate the bytes
    // per second for the jumped range and jump again.
 
    // The number of retries here is hard-limited to a generous amount. Usually
    // the correct range is found after 1--5 jumps, even for files with very 
    // variable bitrates. If significantly more jumps are needed, there's
    // probably something wrong with the file and we just avoid getting into an
    // infinite loop. 32 retries should be enough for anybody.
 
    double duration = plm_demux_get_duration(self, type);
    long file_size = plm_buffer_get_size(self->buffer);
    long byterate = file_size / duration;
 
    double cur_time = self->last_decoded_pts;
    double scan_span = 1;
 
    if (seek_time > duration) {
        seek_time = duration;
    }
    else if (seek_time < 0) {
        seek_time = 0;
    }
    seek_time += self->start_time;
 
    for (int retry = 0; retry < 32; retry++) {
        int found_packet_with_pts = FALSE;
        int found_packet_in_range = FALSE;
        long last_valid_packet_start = -1;
        double first_packet_time = PLM_PACKET_INVALID_TS;
 
        long cur_pos = plm_buffer_tell(self->buffer);
 
        // Estimate byte offset and jump to it.
        long offset = (seek_time - cur_time - scan_span) * byterate;
        long seek_pos = cur_pos + offset;
        if (seek_pos < 0) {
            seek_pos = 0;
        }
        else if (seek_pos > file_size - 256) {
            seek_pos = file_size - 256;
        }
 
        plm_demux_buffer_seek(self, seek_pos);
 
        // Scan through all packets up to the seek_time to find the last packet
        // containing an intra frame.
        while (plm_buffer_find_start_code(self->buffer, type) != -1) {
            long packet_start = plm_buffer_tell(self->buffer);
            plm_packet_t *packet = plm_demux_decode_packet(self, type);
 
            // Skip packet if it has no PTS
            if (!packet || packet->pts == PLM_PACKET_INVALID_TS) {
                continue;
            }
 
            // Bail scanning through packets if we hit one that is outside
            // seek_time - scan_span.
            // We also adjust the cur_time and byterate values here so the next 
            // iteration can be a bit more precise.
            if (packet->pts > seek_time || packet->pts < seek_time - scan_span) {
                found_packet_with_pts = TRUE;
                byterate = (seek_pos - cur_pos) / (packet->pts - cur_time);
                cur_time = packet->pts;
                break;
            }
 
            // If we are still here, it means this packet is in close range to
            // the seek_time. If this is the first packet for this jump position
            // record the PTS. If we later have to back off, when there was no
            // intra frame in this range, we can lower the seek_time to not scan
            // this range again.
            if (!found_packet_in_range) {
                found_packet_in_range = TRUE;
                first_packet_time = packet->pts;
            }
 
            // Check if this is an intra frame packet. If so, record the buffer
            // position of the start of this packet. We want to jump back to it 
            // later, when we know it's the last intra frame before desired
            // seek time.
            if (force_intra) {
                for (size_t i = 0; i < packet->length - 6; i++) {
                    // Find the START_PICTURE code
                    if (
                        packet->data[i] == 0x00 &&
                        packet->data[i + 1] == 0x00 &&
                        packet->data[i + 2] == 0x01 &&
                        packet->data[i + 3] == 0x00
                    ) {
                        // Bits 11--13 in the picture header contain the frame 
                        // type, where 1=Intra
                        if ((packet->data[i + 5] & 0x38) == 8) {
                            last_valid_packet_start = packet_start;
                        }
                        break;
                    }
                }
            }
 
            // If we don't want intra frames, just use the last PTS found.
            else {
                last_valid_packet_start = packet_start;
            }
        }
 
        // If there was at least one intra frame in the range scanned above,
        // our search is over. Jump back to the packet and decode it again.
        if (last_valid_packet_start != -1) {
            plm_demux_buffer_seek(self, last_valid_packet_start);
            return plm_demux_decode_packet(self, type);
        }
 
        // If we hit the right range, but still found no intra frame, we have
        // to increases the scan_span. This is done exponentially to also handle
        // video files with very few intra frames.
        else if (found_packet_in_range) {
            scan_span *= 2;
            seek_time = first_packet_time;
        }
 
        // If we didn't find any packet with a PTS, it probably means we reached
        // the end of the file. Estimate byterate and cur_time accordingly.
        else if (!found_packet_with_pts) {
            byterate = (seek_pos - cur_pos) / (duration - cur_time);
            cur_time = duration;
        }
    }
 
    return NULL;
}

References fl::third_party::plm_packet_t::data, FALSE, FL_NOEXCEPT, fl::third_party::plm_packet_t::length, NULL, offset(), plm_buffer_find_start_code(), plm_buffer_get_size(), plm_buffer_tell(), plm_demux_buffer_seek(), plm_demux_decode_packet(), plm_demux_get_duration(), plm_demux_has_headers(), PLM_PACKET_INVALID_TS, fl::third_party::plm_packet_t::pts, and TRUE.

Referenced by plm_seek_frame().

Here is the call graph for this function:

Here is the caller graph for this function: