Mercurial > libavformat.hg
changeset 1161:b340deaf925b libavformat
new mov_read_packet, mov_read_seek, fix seeking in ni mov, fix demuxing adpcm
| author | bcoudurier |
|---|---|
| date | Sat, 08 Jul 2006 12:14:41 +0000 |
| parents | c10e0dbce7de |
| children | e8c0b166fba9 |
| files | mov.c |
| diffstat | 1 files changed, 229 insertions(+), 429 deletions(-) [+] |
line wrap: on
line diff
--- a/mov.c Sat Jul 08 07:14:00 2006 +0000 +++ b/mov.c Sat Jul 08 12:14:41 2006 +0000 @@ -63,9 +63,6 @@ #undef NDEBUG #include <assert.h> -/* Allows seeking */ -#define MOV_SEEK - /* http://gpac.sourceforge.net/tutorial/mediatypes.htm */ const CodecTag ff_mov_obj_type[] = { { CODEC_ID_MPEG4 , 32 }, @@ -231,6 +228,11 @@ void* clrs; } MOV_ctab_t; +typedef struct MOV_mdat_atom_s { + offset_t offset; + int64_t size; +} MOV_mdat_atom_t; + typedef struct { uint8_t version; uint32_t flags; // 24bit @@ -309,6 +311,7 @@ long current_sample; long left_in_chunk; /* how many samples before next chunk */ MOV_esds_t esds; + AVRational sample_size_v1; } MOVStreamContext; typedef struct MOVContext { @@ -335,6 +338,8 @@ /* NOTE: for recursion save to/ restore from local variable! */ AVPaletteControl palette_control; + MOV_mdat_atom_t *mdat_list; + int mdat_count; } MOVContext; @@ -611,6 +616,10 @@ { if(atom.size == 0) /* wrong one (MP4) */ return 0; + c->mdat_list = av_realloc(c->mdat_list, (c->mdat_count + 1) * sizeof(*c->mdat_list)); + c->mdat_list[c->mdat_count].offset = atom.offset; + c->mdat_list[c->mdat_count].size = atom.size; + c->mdat_count++; c->found_mdat=1; c->mdat_offset = atom.offset; c->mdat_size = atom.size; @@ -1056,6 +1065,7 @@ } else st->codec->palctrl = NULL; } else if(st->codec->codec_type==CODEC_TYPE_AUDIO) { + int bits_per_sample; uint16_t version = get_be16(pb); st->codec->codec_id = id; @@ -1073,16 +1083,15 @@ st->codec->sample_rate = ((get_be32(pb) >> 16)); switch (st->codec->codec_id) { + case CODEC_ID_PCM_S8: + case CODEC_ID_PCM_U8: + if (st->codec->bits_per_sample == 16) + st->codec->codec_id = CODEC_ID_PCM_S16BE; + break; case CODEC_ID_PCM_S16LE: case CODEC_ID_PCM_S16BE: if (st->codec->bits_per_sample == 8) st->codec->codec_id = CODEC_ID_PCM_S8; - st->codec->bit_rate = st->codec->sample_rate * 8; - break; - case CODEC_ID_PCM_U8: - if (st->codec->bits_per_sample == 16) - st->codec->codec_id = CODEC_ID_PCM_S16BE; - st->codec->bit_rate = st->codec->sample_rate * 8; break; case CODEC_ID_AMR_WB: st->codec->sample_rate = 16000; /* should really we ? */ @@ -1096,12 +1105,18 @@ break; } + bits_per_sample = av_get_bits_per_sample(st->codec->codec_id); + if (bits_per_sample) { + st->codec->bits_per_sample = bits_per_sample; + sc->sample_size = (bits_per_sample >> 3) * st->codec->channels; + } + //Read QT version 1 fields. In version 0 theese dont exist dprintf("version =%d mp4=%d\n",version,c->mp4); if(version==1) { - get_be32(pb); /* samples per packet */ + sc->sample_size_v1.den = get_be32(pb); /* samples per packet */ get_be32(pb); /* bytes per packet */ - get_be32(pb); /* bytes per frame */ + sc->sample_size_v1.num = get_be32(pb); /* bytes per frame */ get_be32(pb); /* bytes per sample */ } else if(version==2) { get_be32(pb); /* sizeof struct only */ @@ -1209,47 +1224,25 @@ { AVStream *st = c->fc->streams[c->fc->nb_streams-1]; MOVStreamContext *sc = (MOVStreamContext *)st->priv_data; - unsigned int i, entries; + unsigned int i, entries, sample_size; get_byte(pb); /* version */ get_byte(pb); get_byte(pb); get_byte(pb); /* flags */ - sc->sample_size = get_be32(pb); + sample_size = get_be32(pb); + if (!sc->sample_size) /* do not overwrite value computed in stsd */ + sc->sample_size = sample_size; entries = get_be32(pb); if(entries >= UINT_MAX / sizeof(long)) return -1; sc->sample_count = entries; + if (sample_size) + return 0; + #ifdef DEBUG av_log(NULL, AV_LOG_DEBUG, "sample_size = %ld sample_count = %ld\n", sc->sample_size, sc->sample_count); #endif - if(sc->sample_size) { - /* override sample size for uncompressed sound */ - switch (st->codec->codec_id) { - case CODEC_ID_PCM_S32BE: - case CODEC_ID_PCM_S32LE: - sc->sample_size = 4 * st->codec->channels; - break; - case CODEC_ID_PCM_S24BE: - case CODEC_ID_PCM_S24LE: - sc->sample_size = 3 * st->codec->channels; - break; - case CODEC_ID_PCM_S16BE: - case CODEC_ID_PCM_S16LE: - sc->sample_size = 2 * st->codec->channels; - break; - case CODEC_ID_PCM_MULAW: - case CODEC_ID_PCM_ALAW: - case CODEC_ID_PCM_S8: - case CODEC_ID_PCM_U8: - sc->sample_size = 1 * st->codec->channels; - break; - default: - break; - } - assert(sc->sample_size); - return 0; /* there isn't any table following */ - } sc->sample_sizes = (long*) av_malloc(entries * sizeof(long)); if (!sc->sample_sizes) return -1; @@ -1591,10 +1584,6 @@ static void mov_free_stream_context(MOVStreamContext *sc) { if(sc) { - av_freep(&sc->chunk_offsets); - av_freep(&sc->sample_to_chunk); - av_freep(&sc->sample_sizes); - av_freep(&sc->keyframes); av_freep(&sc->stts_data); av_freep(&sc->ctts_data); av_freep(&sc); @@ -1656,6 +1645,116 @@ return score; } +static void mov_build_index(MOVContext *mov, AVStream *st) +{ + MOVStreamContext *sc = st->priv_data; + offset_t current_offset; + int64_t current_dts = 0; + int stts_index = 0; + int stsc_index = 0; + int stss_index = 0; + int i, j, k; + + if (sc->sample_sizes || st->codec->codec_type == CODEC_TYPE_VIDEO) { + int keyframe, sample_size; + int current_sample = 0; + int stts_sample = 0; + int distance = 0; + + st->nb_frames = sc->sample_count; + for (i = 0; i < sc->chunk_count; i++) { + current_offset = sc->chunk_offsets[i]; + if (stsc_index + 1 < sc->sample_to_chunk_sz && i + 1 == sc->sample_to_chunk[stsc_index + 1].first) + stsc_index++; + for (j = 0; j < sc->sample_to_chunk[stsc_index].count; j++) { + keyframe = !sc->keyframe_count || current_sample + 1 == sc->keyframes[stss_index]; + if (keyframe) { + distance = 0; + if (stss_index + 1 < sc->keyframe_count) + stss_index++; + } + sample_size = sc->sample_size > 0 ? sc->sample_size : sc->sample_sizes[current_sample]; + dprintf("AVIndex stream %d, sample %d, offset %llx, dts %lld, size %d, distance %d, keyframe %d\n", + st->index, current_sample, current_offset, current_dts, sample_size, distance, keyframe); + av_add_index_entry(st, current_offset, current_dts, sample_size, distance, keyframe ? AVINDEX_KEYFRAME : 0); + current_offset += sample_size; + assert(sc->stts_data[stts_index].duration % sc->time_rate == 0); + current_dts += sc->stts_data[stts_index].duration / sc->time_rate; + distance++; + stts_sample++; + if (current_sample + 1 < sc->sample_count) + current_sample++; + if (stts_index + 1 < sc->stts_count && stts_sample == sc->stts_data[stts_index].count) { + stts_sample = 0; + stts_index++; + } + } + } + } else { /* read whole chunk */ + int chunk_samples, chunk_size, chunk_duration; + + for (i = 0; i < sc->chunk_count; i++) { + current_offset = sc->chunk_offsets[i]; + if (stsc_index + 1 < sc->sample_to_chunk_sz && i + 1 == sc->sample_to_chunk[stsc_index + 1].first) + stsc_index++; + chunk_samples = sc->sample_to_chunk[stsc_index].count; + /* get chunk size */ + if (sc->sample_size > 1) + chunk_size = chunk_samples * sc->sample_size; + else if (sc->sample_size_v1.den > 0 && (chunk_samples * sc->sample_size_v1.num % sc->sample_size_v1.den == 0)) + chunk_size = chunk_samples * sc->sample_size_v1.num / sc->sample_size_v1.den; + else { /* workaround to find nearest next chunk offset */ + chunk_size = INT_MAX; + for (j = 0; j < mov->total_streams; j++) { + MOVStreamContext *msc = mov->streams[j]; + + for (k = msc->next_chunk; k < msc->chunk_count; k++) { + if (msc->chunk_offsets[k] > current_offset && msc->chunk_offsets[k] - current_offset < chunk_size) { + chunk_size = msc->chunk_offsets[k] - current_offset; + msc->next_chunk = k; + break; + } + } + } + /* check for last chunk */ + if (chunk_size == INT_MAX) + for (j = 0; j < mov->mdat_count; j++) { + dprintf("mdat %d, offset %llx, size %lld, current offset %llx\n", + j, mov->mdat_list[j].offset, mov->mdat_list[j].size, current_offset); + if (mov->mdat_list[j].offset <= current_offset && mov->mdat_list[j].offset + mov->mdat_list[j].size > current_offset) + chunk_size = mov->mdat_list[j].offset + mov->mdat_list[j].size - current_offset; + } + assert(chunk_size != INT_MAX); + for (j = 0; j < mov->total_streams; j++) { + mov->streams[j]->next_chunk = 0; + } + } + av_add_index_entry(st, current_offset, current_dts, chunk_size, 0, AVINDEX_KEYFRAME); + /* get chunk duration */ + chunk_duration = 0; + while (chunk_samples > 0) { + if (chunk_samples < sc->stts_data[stts_index].count) { + chunk_duration += sc->stts_data[stts_index].duration * chunk_samples; + sc->stts_data[stts_index].count -= chunk_samples; + break; + } else { + chunk_duration += sc->stts_data[stts_index].duration * chunk_samples; + chunk_samples -= sc->stts_data[stts_index].count; + if (stts_index + 1 < sc->stts_count) { + stts_index++; + } + } + } + dprintf("AVIndex stream %d, chunk %d, offset %llx, dts %lld, size %d, duration %d\n", + st->index, i, current_offset, current_dts, chunk_size, chunk_duration); + assert(chunk_duration % sc->time_rate == 0); + current_dts += chunk_duration / sc->time_rate; + } + /* adjust sample count to chunk count */ + sc->sample_count = sc->chunk_count; + } +} + static int mov_read_header(AVFormatContext *s, AVFormatParameters *ap) { MOVContext *mov = (MOVContext *) s->priv_data; @@ -1701,425 +1800,128 @@ s->streams[i]->duration /= sc->time_rate; } sc->ffindex = i; + mov_build_index(mov, s->streams[i]); } + for(i=0; i<mov->total_streams; i++) { + /* dont need those anymore */ + av_freep(&mov->streams[i]->chunk_offsets); + av_freep(&mov->streams[i]->sample_to_chunk); + av_freep(&mov->streams[i]->sample_sizes); + av_freep(&mov->streams[i]->keyframes); + av_freep(&mov->streams[i]->stts_data); + } + av_freep(&mov->mdat_list); return 0; } -/* Yes, this is ugly... I didn't write the specs of QT :p */ -/* XXX:remove useless commented code sometime */ static int mov_read_packet(AVFormatContext *s, AVPacket *pkt) { - MOVContext *mov = (MOVContext *) s->priv_data; - MOVStreamContext *sc; - AVStream *st; - int64_t offset = INT64_MAX; + MOVContext *mov = s->priv_data; + MOVStreamContext *sc = 0; + AVIndexEntry *sample = 0; int64_t best_dts = INT64_MAX; - int i, a, b, m; - int next_sample= -99; - int size; - int idx; - int ret; - size = 0x0FFFFFFF; - - if (mov->partial) { - sc = mov->partial; - idx = sc->sample_to_chunk_index; + int i; - if (idx < 0) return 0; - dprintf("sc[ffid %d]->sample_size = %ld\n", sc->ffindex, sc->sample_size); - //size = sc->sample_sizes[sc->current_sample]; - // that ain't working... - //size = (sc->sample_size)?sc->sample_size:sc->sample_sizes[sc->current_sample]; - size = (sc->sample_size > 1)?sc->sample_size:sc->sample_sizes[sc->current_sample]; - - next_sample= sc->current_sample+1; - - sc->left_in_chunk--; - - if (sc->left_in_chunk <= 0) - mov->partial = 0; - offset = mov->next_chunk_offset; - /* extract the sample */ - - goto readchunk; - } - -again: - sc = 0; - if(offset == INT64_MAX) - best_dts= INT64_MAX; - for(i=0; i<mov->total_streams; i++) { + for (i = 0; i < mov->total_streams; i++) { MOVStreamContext *msc = mov->streams[i]; - if ((msc->next_chunk < msc->chunk_count) && msc->next_chunk >= 0){ - if (msc->sample_to_time_index < msc->stts_count && mov->ni) { - int64_t dts; - int index= msc->sample_to_time_index; - int sample= msc->sample_to_time_sample; - int time= msc->sample_to_time_time; - int duration = msc->stts_data[index].duration; - int count = msc->stts_data[index].count; - if (sample + count <= msc->current_sample) { - sample += count; - time += count*duration; - index ++; - duration = msc->stts_data[index].duration; - } - dts = time + (msc->current_sample - sample) * (int64_t)duration; - dts = av_rescale(dts, AV_TIME_BASE, msc->time_scale); - dprintf("stream: %d dts: %"PRId64" best_dts: %"PRId64" offset: %"PRId64"\n", i, dts, best_dts, offset); - if(dts < best_dts){ - best_dts= dts; - sc = msc; - offset = msc->chunk_offsets[msc->next_chunk]; - } - }else{ - if ((msc->chunk_offsets[msc->next_chunk] < offset)) { - sc = msc; - offset = msc->chunk_offsets[msc->next_chunk]; - } + if (s->streams[i]->discard != AVDISCARD_ALL && msc->current_sample < msc->sample_count) { + AVIndexEntry *current_sample = &s->streams[i]->index_entries[msc->current_sample]; + int64_t dts = av_rescale(current_sample->timestamp * (int64_t)msc->time_rate, AV_TIME_BASE, msc->time_scale); + + dprintf("stream %d, sample %ld, dts %lld\n", i, msc->current_sample, dts); + if (dts < best_dts) { + sample = current_sample; + best_dts = dts; + sc = msc; } } } - if (!sc || offset==INT64_MAX) + if (!sample) return -1; - - sc->next_chunk++; - - if(mov->next_chunk_offset < offset) { /* some meta data */ - url_fskip(&s->pb, (offset - mov->next_chunk_offset)); - mov->next_chunk_offset = offset; - } - - if(s->streams[sc->ffindex]->discard >= AVDISCARD_ALL) { - url_fskip(&s->pb, (offset - mov->next_chunk_offset)); - mov->next_chunk_offset = offset; - offset = INT64_MAX; - goto again; + /* must be done just before reading, to avoid infinite loop on sample */ + sc->current_sample++; + url_fseek(&s->pb, sample->pos, SEEK_SET); + if (av_get_packet(&s->pb, pkt, sample->size) <= 0) { + av_log(s, AV_LOG_ERROR, "stream %d, error reading packet at offset 0x%llx, maybe partial file\n", sc->ffindex, sample->pos); + return -1; } - - idx = sc->sample_to_chunk_index; - if (idx + 1 < sc->sample_to_chunk_sz && sc->next_chunk >= sc->sample_to_chunk[idx + 1].first) - idx++; - sc->sample_to_chunk_index = idx; - /* split chunks into samples */ - if (sc->sample_size == 0 || sc->sample_size > 100) { - if (idx >= 0 && sc->sample_to_chunk[idx].count != 1) { - mov->partial = sc; - /* we'll have to get those samples before next chunk */ - sc->left_in_chunk = sc->sample_to_chunk[idx].count - 1; - } - size = (sc->sample_size > 1)?sc->sample_size:sc->sample_sizes[sc->current_sample]; - next_sample= sc->current_sample+1; - }else{ - int adjusted= 0; - /* get the chunk size... */ - for(i=0; i<mov->total_streams; i++) { - MOVStreamContext *msc = mov->streams[i]; - if ((msc->next_chunk < msc->chunk_count) - && msc->chunk_offsets[msc->next_chunk] - offset < size - && msc->chunk_offsets[msc->next_chunk] > offset) - size = msc->chunk_offsets[msc->next_chunk] - offset; - } - //Make sure that size is according to sample_size (Needed by .mov files - //created on a Minolta Dimage Xi where audio chunks contains waste data in the end) - //needed for 'raw ' - //sample_size is already adjusted in read_stsz - adjusted= sc->sample_to_chunk[idx].count * sc->sample_size; - if (adjusted < size) { - dprintf("adjusted %d, size %d, sample count %ld\n", adjusted, size, sc->sample_to_chunk[idx].count); - size = adjusted; - } - if(idx < sc->sample_to_chunk_sz){ - next_sample= sc->current_sample + sc->sample_to_chunk[idx].count; - }else - next_sample= sc->current_sample; - } - -readchunk: - dprintf("chunk: %"PRId64" -> %"PRId64" (%i)\n", offset, offset + size, size); - if(size == 0x0FFFFFFF) - size = mov->mdat_size + mov->mdat_offset - offset; - if(size < 0) - return -1; - if(size == 0) - return -1; - ret = url_fseek(&s->pb, offset, SEEK_SET); - if (ret < 0) - return ret; - av_get_packet(&s->pb, pkt, size); pkt->stream_index = sc->ffindex; - - // If the keyframes table exists, mark any samples that are in the table as key frames. - // If no table exists, treat very sample as a key frame. - if (sc->keyframe_count) { - a = 0; - b = sc->keyframe_count - 1; - - while (a < b) { - m = (a + b + 1) >> 1; - if (sc->keyframes[m] > sc->current_sample) { - b = m - 1; - } else { - a = m; - } + pkt->dts = sample->timestamp; + if (sc->ctts_data) { + assert(sc->ctts_data[sc->sample_to_ctime_index].duration % sc->time_rate == 0); + pkt->pts = pkt->dts + sc->ctts_data[sc->sample_to_ctime_index].duration / sc->time_rate; + /* update ctts context */ + sc->sample_to_ctime_sample++; + if (sc->sample_to_ctime_index < sc->ctts_count && sc->ctts_data[sc->sample_to_ctime_index].count == sc->sample_to_ctime_sample) { + sc->sample_to_ctime_index++; + sc->sample_to_ctime_sample = 0; } - - if (sc->keyframes[a] == sc->current_sample) - pkt->flags |= PKT_FLAG_KEY; + } else { + pkt->pts = pkt->dts; } - else - pkt->flags |= PKT_FLAG_KEY; - - mov->next_chunk_offset = offset + size; - - /* find the corresponding dts */ - if (sc && sc->sample_to_time_index < sc->stts_count && pkt) { - unsigned int count; - uint64_t dts, pts; - unsigned int duration = sc->stts_data[sc->sample_to_time_index].duration; - count = sc->stts_data[sc->sample_to_time_index].count; - if ((sc->sample_to_time_sample + count) <= sc->current_sample) { - sc->sample_to_time_sample += count; - sc->sample_to_time_time += count*duration; - sc->sample_to_time_index ++; - duration = sc->stts_data[sc->sample_to_time_index].duration; - } - dts = sc->sample_to_time_time + (sc->current_sample - sc->sample_to_time_sample) * (int64_t)duration; - /* find the corresponding pts */ - if (sc->sample_to_ctime_index < sc->ctts_count) { - int duration = sc->ctts_data[sc->sample_to_ctime_index].duration; - int count = sc->ctts_data[sc->sample_to_ctime_index].count; - - if ((sc->sample_to_ctime_sample + count) <= sc->current_sample) { - sc->sample_to_ctime_sample += count; - sc->sample_to_ctime_index ++; - duration = sc->ctts_data[sc->sample_to_ctime_index].duration; - } - pts = dts + duration; - }else - pts = dts; - - st= s->streams[ sc->ffindex ]; - assert(pts % st->time_base.num == 0); - assert(dts % st->time_base.num == 0); - - pkt->pts = pts / st->time_base.num; - pkt->dts = dts / st->time_base.num; - dprintf("stream #%d smp #%ld dts = %"PRId64" pts = %"PRId64" (smp:%ld time:%"PRId64" idx:%d ent:%d count:%d dur:%d)\n" - , pkt->stream_index, sc->current_sample-1, pkt->dts, pkt->pts - , sc->sample_to_time_sample - , sc->sample_to_time_time - , sc->sample_to_time_index - , sc->stts_count - , count - , duration); - } - - assert(next_sample>=0); - sc->current_sample= next_sample; - + pkt->flags |= sample->flags & AVINDEX_KEYFRAME ? PKT_FLAG_KEY : 0; + pkt->pos = sample->pos; + dprintf("stream %d, pts %lld, dts %lld, pos 0x%llx, duration %d\n", pkt->stream_index, pkt->pts, pkt->dts, pkt->pos, pkt->duration); return 0; } -#if defined(MOV_SEEK) -/** - * Seek method based on the one described in the Appendix C of QTFileFormat.pdf - */ -static int mov_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags) +static int mov_seek_stream(AVStream *st, int64_t timestamp, int flags) { - MOVContext* mov = (MOVContext *) s->priv_data; - MOVStreamContext* sc; - int32_t i, a, b, m; - int64_t start_time; - int32_t seek_sample, sample; - int32_t duration; - int32_t count; - int32_t chunk; - int32_t left_in_chunk; - int64_t chunk_file_offset; - int64_t sample_file_offset; - int32_t first_chunk_sample; - int32_t sample_to_chunk_idx; - int sample_to_time_index; - long sample_to_time_sample = 0; - uint64_t sample_to_time_time = 0; - int mov_idx; + MOVStreamContext *sc = st->priv_data; + int sample, time_sample; + int i; - // Find the corresponding mov stream - for (mov_idx = 0; mov_idx < mov->total_streams; mov_idx++) - if (mov->streams[mov_idx]->ffindex == stream_index) - break; - if (mov_idx == mov->total_streams) { - av_log(s, AV_LOG_ERROR, "mov: requested stream was not found in mov streams (idx=%i)\n", stream_index); - return -1; - } - sc = mov->streams[mov_idx]; - - sample_time *= s->streams[stream_index]->time_base.num; - - // Step 1. Find the edit that contains the requested time (elst) - if (sc->edit_count && 0) { - // FIXME should handle edit list - av_log(s, AV_LOG_ERROR, "mov: does not handle seeking in files that contain edit list (c:%d)\n", sc->edit_count); + sample = av_index_search_timestamp(st, timestamp, flags); + dprintf("stream %d, timestamp %lld, sample %d\n", st->index, timestamp, sample); + if (sample < 0) /* not sure what to do */ return -1; - } - - // Step 2. Find the corresponding sample using the Time-to-sample atom (stts) */ - dprintf("Searching for time %li in stream #%i (time_scale=%i)\n", (long)sample_time, mov_idx, sc->time_scale); - start_time = 0; // FIXME use elst atom - sample = 1; // sample are 0 based in table - - for (i = 0; i < sc->stts_count; i++) { - count = sc->stts_data[i].count; - duration = sc->stts_data[i].duration; - if ((start_time + count*duration) > sample_time) { - sample_to_time_time = start_time; - sample_to_time_index = i; - sample_to_time_sample = sample; - sample += (sample_time - start_time) / duration; - break; - } - sample += count; - start_time += count * duration; - } - sample_to_time_time = start_time; - sample_to_time_index = i; - /* NOTE: despite what qt doc say, the dt value (Display Time in qt vocabulary) computed with the stts atom - is a decoding time stamp (dts) not a presentation time stamp. And as usual dts != pts for stream with b frames */ - - dprintf("Found time %li at sample #%u\n", (long)sample_time, sample); - if (sample > sc->sample_count) { - av_log(s, AV_LOG_ERROR, "mov: sample pos is too high, unable to seek (req. sample=%i, sample count=%ld)\n", sample, sc->sample_count); - return -1; - } - - // Step 3. Find the prior sync. sample using the Sync sample atom (stss) - if (sc->keyframe_count) { - a = 0; - b = sc->keyframe_count - 1; - while (a < b) { - m = (a + b + 1) >> 1; - if (sc->keyframes[m] > sample) { - b = m - 1; - } else { - a = m; + sc->current_sample = sample; + dprintf("stream %d, found sample %ld\n", st->index, sc->current_sample); + /* adjust ctts index */ + if (sc->ctts_data) { + time_sample = 0; + for (i = 0; i < sc->ctts_count; i++) { + time_sample += sc->ctts_data[i].count; + if (time_sample >= sc->current_sample) { + sc->sample_to_ctime_index = i; + sc->sample_to_ctime_sample = time_sample - sc->current_sample; + break; } } - // for low latency prob: always use the previous keyframe, just uncomment the next line - // if (a) a--; - seek_sample = sc->keyframes[a]; } - else - seek_sample = sample; // else all samples are key frames - dprintf("Found nearest keyframe at sample #%i \n", seek_sample); + return sample; +} - // Step 4. Find the chunk of the sample using the Sample-to-chunk-atom (stsc) - for (first_chunk_sample = 1, i = 0; i < (sc->sample_to_chunk_sz - 1); i++) { - b = (sc->sample_to_chunk[i + 1].first - sc->sample_to_chunk[i].first) * sc->sample_to_chunk[i].count; - if (seek_sample >= first_chunk_sample && seek_sample < (first_chunk_sample + b)) - break; - first_chunk_sample += b; - } - chunk = sc->sample_to_chunk[i].first + (seek_sample - first_chunk_sample) / sc->sample_to_chunk[i].count; - left_in_chunk = sc->sample_to_chunk[i].count - (seek_sample - first_chunk_sample) % sc->sample_to_chunk[i].count; - first_chunk_sample += ((seek_sample - first_chunk_sample) / sc->sample_to_chunk[i].count) * sc->sample_to_chunk[i].count; - sample_to_chunk_idx = i; - dprintf("Sample was found in chunk #%i at sample offset %i (idx %i)\n", chunk, seek_sample - first_chunk_sample, sample_to_chunk_idx); +static int mov_read_seek(AVFormatContext *s, int stream_index, int64_t sample_time, int flags) +{ + AVStream *st; + int64_t seek_timestamp, timestamp; + int sample; + int i; - // Step 5. Find the offset of the chunk using the chunk offset atom - if (!sc->chunk_offsets) { - av_log(s, AV_LOG_ERROR, "mov: no chunk offset atom, unable to seek\n"); + if (stream_index >= s->nb_streams) return -1; - } - if (chunk > sc->chunk_count) { - av_log(s, AV_LOG_ERROR, "mov: chunk offset atom too short, unable to seek (req. chunk=%i, chunk count=%li)\n", chunk, sc->chunk_count); - return -1; - } - chunk_file_offset = sc->chunk_offsets[chunk - 1]; - dprintf("Chunk file offset is #%"PRIu64"\n", chunk_file_offset); - - // Step 6. Find the byte offset within the chunk using the sample size atom - sample_file_offset = chunk_file_offset; - if (sc->sample_size) - sample_file_offset += (seek_sample - first_chunk_sample) * sc->sample_size; - else { - for (i = 0; i < (seek_sample - first_chunk_sample); i++) { - sample_file_offset += sc->sample_sizes[first_chunk_sample + i - 1]; - } - } - dprintf("Sample file offset is #%"PRIu64"\n", sample_file_offset); - - // Step 6. Update the parser - mov->partial = sc; - mov->next_chunk_offset = sample_file_offset; - // Update current stream state - sc->current_sample = seek_sample - 1; // zero based - sc->left_in_chunk = left_in_chunk; - sc->next_chunk = chunk; // +1 -1 (zero based) - sc->sample_to_chunk_index = sample_to_chunk_idx; - // Update other streams - for (i = 0; i<mov->total_streams; i++) { - MOVStreamContext *msc; - if (i == mov_idx) continue; - // Find the nearest 'next' chunk - msc = mov->streams[i]; - a = 0; - b = msc->chunk_count - 1; - while (a < b) { - m = (a + b + 1) >> 1; - if (msc->chunk_offsets[m] > chunk_file_offset) { - b = m - 1; - } else { - a = m; - } - } - msc->next_chunk = a; - if (msc->chunk_offsets[a] < chunk_file_offset && a < (msc->chunk_count-1)) - msc->next_chunk ++; - dprintf("Nearest next chunk for stream #%i is #%li @%"PRId64"\n", i, msc->next_chunk+1, msc->chunk_offsets[msc->next_chunk]); + st = s->streams[stream_index]; + sample = mov_seek_stream(st, sample_time, flags); + if (sample < 0) + return -1; + + /* adjust seek timestamp to found sample timestamp */ + seek_timestamp = st->index_entries[sample].timestamp; - // Compute sample count and index in the sample_to_chunk table (what a pity) - msc->sample_to_chunk_index = 0; - msc->current_sample = 0; - for(; msc->sample_to_chunk_index < (msc->sample_to_chunk_sz - 1) - && msc->sample_to_chunk[msc->sample_to_chunk_index + 1].first <= (1 + msc->next_chunk); msc->sample_to_chunk_index++) { - msc->current_sample += (msc->sample_to_chunk[msc->sample_to_chunk_index + 1].first - msc->sample_to_chunk[msc->sample_to_chunk_index].first) \ - * msc->sample_to_chunk[msc->sample_to_chunk_index].count; - } - msc->current_sample += (msc->next_chunk - (msc->sample_to_chunk[msc->sample_to_chunk_index].first - 1)) * msc->sample_to_chunk[msc->sample_to_chunk_index].count; - msc->left_in_chunk = msc->sample_to_chunk[msc->sample_to_chunk_index].count - 1; - // Find corresponding position in stts (used later to compute dts) - sample = 0; - start_time = 0; - for (msc->sample_to_time_index = 0; msc->sample_to_time_index < msc->stts_count; msc->sample_to_time_index++) { - count = msc->stts_data[msc->sample_to_time_index].count; - duration = msc->stts_data[msc->sample_to_time_index].duration; - if ((sample + count - 1) > msc->current_sample) { - msc->sample_to_time_time = start_time; - msc->sample_to_time_sample = sample; - break; - } - sample += count; - start_time += count * duration; - } - sample = 0; - for (msc->sample_to_ctime_index = 0; msc->sample_to_ctime_index < msc->ctts_count; msc->sample_to_ctime_index++) { - count = msc->ctts_data[msc->sample_to_ctime_index].count; - duration = msc->ctts_data[msc->sample_to_ctime_index].duration; - if ((sample + count - 1) > msc->current_sample) { - msc->sample_to_ctime_sample = sample; - break; - } - sample += count; - } - dprintf("Next Sample for stream #%i is #%li @%li\n", i, msc->current_sample + 1, msc->sample_to_chunk_index + 1); + for (i = 0; i < s->nb_streams; i++) { + st = s->streams[i]; + if (stream_index == i || st->discard == AVDISCARD_ALL) + continue; + + timestamp = av_rescale_q(seek_timestamp, s->streams[stream_index]->time_base, st->time_base); + mov_seek_stream(st, timestamp, flags); } return 0; } -#endif static int mov_read_close(AVFormatContext *s) { @@ -2142,9 +1944,7 @@ mov_read_header, mov_read_packet, mov_read_close, -#if defined(MOV_SEEK) mov_read_seek, -#endif }; int mov_init(void)