static int mov_read_packet(AVFormatContext *s, AVPacket *pkt)

{

    MOVContext *mov = s->priv_data;

    MOVStreamContext *sc;

    AVIndexEntry *sample;

    AVStream *st = NULL;

    int ret;

    mov->fc = s;

 retry:

    sample = mov_find_next_sample(s, &st);

    if (!sample) {

        mov->found_mdat = 0;

        if (!mov->next_root_atom)

            return AVERROR_EOF;

        avio_seek(s->pb, mov->next_root_atom, SEEK_SET);

        mov->next_root_atom = 0;

        if (mov_read_default(mov, s->pb, (MOVAtom){ AV_RL32("root"), INT64_MAX }) < 0 ||

            avio_feof(s->pb))

            return AVERROR_EOF;

        av_log(s, AV_LOG_TRACE, "read fragments, offset 0x%"PRIx64"\n", avio_tell(s->pb));

        goto retry;

    }

    sc = st->priv_data;

    /* must be done just before reading, to avoid infinite loop on sample */

    sc->current_sample++;



    if (mov->next_root_atom) {

        sample->pos = FFMIN(sample->pos, mov->next_root_atom);

        sample->size = FFMIN(sample->size, (mov->next_root_atom - sample->pos));

    }



    if (st->discard != AVDISCARD_ALL) {

        if (avio_seek(sc->pb, sample->pos, SEEK_SET) != sample->pos) {

            av_log(mov->fc, AV_LOG_ERROR, "stream %d, offset 0x%"PRIx64": partial file\n",

                   sc->ffindex, sample->pos);

            return AVERROR_INVALIDDATA;

        }

        ret = av_get_packet(sc->pb, pkt, sample->size);

        if (ret < 0)

            return ret;

        if (sc->has_palette) {

            uint8_t *pal;



            pal = av_packet_new_side_data(pkt, AV_PKT_DATA_PALETTE, AVPALETTE_SIZE);

            if (!pal) {

                av_log(mov->fc, AV_LOG_ERROR, "Cannot append palette to packet\n");

            } else {

                memcpy(pal, sc->palette, AVPALETTE_SIZE);

                sc->has_palette = 0;

            }

        }

#if CONFIG_DV_DEMUXER

        if (mov->dv_demux && sc->dv_audio_container) {

            avpriv_dv_produce_packet(mov->dv_demux, pkt, pkt->data, pkt->size, pkt->pos);

            av_freep(&pkt->data);

            pkt->size = 0;

            ret = avpriv_dv_get_packet(mov->dv_demux, pkt);

            if (ret < 0)

                return ret;

        }

#endif

    }



    pkt->stream_index = sc->ffindex;

    pkt->dts = sample->timestamp;

    if (sc->ctts_data && sc->ctts_index < sc->ctts_count) {

        pkt->pts = pkt->dts + sc->dts_shift + sc->ctts_data[sc->ctts_index].duration;

        /* update ctts context */

        sc->ctts_sample++;

        if (sc->ctts_index < sc->ctts_count &&

            sc->ctts_data[sc->ctts_index].count == sc->ctts_sample) {

            sc->ctts_index++;

            sc->ctts_sample = 0;

        }

        if (sc->wrong_dts)

            pkt->dts = AV_NOPTS_VALUE;

    } else {

        int64_t next_dts = (sc->current_sample < st->nb_index_entries) ?

            st->index_entries[sc->current_sample].timestamp : st->duration;

        pkt->duration = next_dts - pkt->dts;

        pkt->pts = pkt->dts;

    }

    if (st->discard == AVDISCARD_ALL)

        goto retry;

    pkt->flags |= sample->flags & AVINDEX_KEYFRAME ? AV_PKT_FLAG_KEY : 0;

    pkt->pos = sample->pos;



    return 0;

}

static int mov_read_packet(AVFormatContext *s, AVPacket *pkt)

{

    MOVContext *mov = s->priv_data;

    MOVStreamContext *sc;

    AVIndexEntry *sample;

    AVStream *st = NULL;

    int ret;

    mov->fc = s;

 retry:

    sample = mov_find_next_sample(s, &st);

    if (!sample) {

        mov->found_mdat = 0;

        if (!mov->next_root_atom)

            return AVERROR_EOF;

        avio_seek(s->pb, mov->next_root_atom, SEEK_SET);

        mov->next_root_atom = 0;

        if (mov_read_default(mov, s->pb, (MOVAtom){ AV_RL32("root"), INT64_MAX }) < 0 ||

            avio_feof(s->pb))

            return AVERROR_EOF;

        av_log(s, AV_LOG_TRACE, "read fragments, offset 0x%"PRIx64"\n", avio_tell(s->pb));

        goto retry;

    }

    sc = st->priv_data;

    

    sc->current_sample++;



    if (mov->next_root_atom) {

        sample->pos = FFMIN(sample->pos, mov->next_root_atom);

        sample->size = FFMIN(sample->size, (mov->next_root_atom - sample->pos));

    }



    if (st->discard != AVDISCARD_ALL) {

        if (avio_seek(sc->pb, sample->pos, SEEK_SET) != sample->pos) {

            av_log(mov->fc, AV_LOG_ERROR, "stream %d, offset 0x%"PRIx64": partial file\n",

                   sc->ffindex, sample->pos);

            return AVERROR_INVALIDDATA;

        }

        ret = av_get_packet(sc->pb, pkt, sample->size);

        if (ret < 0)

            return ret;

        if (sc->has_palette) {

            uint8_t *pal;



            pal = av_packet_new_side_data(pkt, AV_PKT_DATA_PALETTE, AVPALETTE_SIZE);

            if (!pal) {

                av_log(mov->fc, AV_LOG_ERROR, "Cannot append palette to packet\n");

            } else {

                memcpy(pal, sc->palette, AVPALETTE_SIZE);

                sc->has_palette = 0;

            }

        }

#if CONFIG_DV_DEMUXER

        if (mov->dv_demux && sc->dv_audio_container) {

            avpriv_dv_produce_packet(mov->dv_demux, pkt, pkt->data, pkt->size, pkt->pos);

            av_freep(&pkt->data);

            pkt->size = 0;

            ret = avpriv_dv_get_packet(mov->dv_demux, pkt);

            if (ret < 0)

                return ret;

        }

#endif

    }



    pkt->stream_index = sc->ffindex;

    pkt->dts = sample->timestamp;

    if (sc->ctts_data && sc->ctts_index < sc->ctts_count) {

        pkt->pts = pkt->dts + sc->dts_shift + sc->ctts_data[sc->ctts_index].duration;

        

        sc->ctts_sample++;

        if (sc->ctts_index < sc->ctts_count &&

            sc->ctts_data[sc->ctts_index].count == sc->ctts_sample) {

            sc->ctts_index++;

            sc->ctts_sample = 0;

        }

        if (sc->wrong_dts)

            pkt->dts = AV_NOPTS_VALUE;

    } else {

        int64_t next_dts = (sc->current_sample < st->nb_index_entries) ?

            st->index_entries[sc->current_sample].timestamp : st->duration;

        pkt->duration = next_dts - pkt->dts;

        pkt->pts = pkt->dts;

    }

    if (st->discard == AVDISCARD_ALL)

        goto retry;

    pkt->flags |= sample->flags & AVINDEX_KEYFRAME ? AV_PKT_FLAG_KEY : 0;

    pkt->pos = sample->pos;



    return 0;

}

static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1)

{

    MOVContext *mov = VAR_0->priv_data;

    MOVStreamContext *sc;

    AVIndexEntry *sample;

    AVStream *st = NULL;

    int VAR_2;

    mov->fc = VAR_0;

 retry:

    sample = mov_find_next_sample(VAR_0, &st);

    if (!sample) {

        mov->found_mdat = 0;

        if (!mov->next_root_atom)

            return AVERROR_EOF;

        avio_seek(VAR_0->pb, mov->next_root_atom, SEEK_SET);

        mov->next_root_atom = 0;

        if (mov_read_default(mov, VAR_0->pb, (MOVAtom){ AV_RL32("root"), INT64_MAX }) < 0 ||

            avio_feof(VAR_0->pb))

            return AVERROR_EOF;

        av_log(VAR_0, AV_LOG_TRACE, "read fragments, offset 0x%"PRIx64"\n", avio_tell(VAR_0->pb));

        goto retry;

    }

    sc = st->priv_data;

    

    sc->current_sample++;



    if (mov->next_root_atom) {

        sample->pos = FFMIN(sample->pos, mov->next_root_atom);

        sample->size = FFMIN(sample->size, (mov->next_root_atom - sample->pos));

    }



    if (st->discard != AVDISCARD_ALL) {

        if (avio_seek(sc->pb, sample->pos, SEEK_SET) != sample->pos) {

            av_log(mov->fc, AV_LOG_ERROR, "stream %d, offset 0x%"PRIx64": partial file\n",

                   sc->ffindex, sample->pos);

            return AVERROR_INVALIDDATA;

        }

        VAR_2 = av_get_packet(sc->pb, VAR_1, sample->size);

        if (VAR_2 < 0)

            return VAR_2;

        if (sc->has_palette) {

            uint8_t *pal;



            pal = av_packet_new_side_data(VAR_1, AV_PKT_DATA_PALETTE, AVPALETTE_SIZE);

            if (!pal) {

                av_log(mov->fc, AV_LOG_ERROR, "Cannot append palette to packet\n");

            } else {

                memcpy(pal, sc->palette, AVPALETTE_SIZE);

                sc->has_palette = 0;

            }

        }

#if CONFIG_DV_DEMUXER

        if (mov->dv_demux && sc->dv_audio_container) {

            avpriv_dv_produce_packet(mov->dv_demux, VAR_1, VAR_1->data, VAR_1->size, VAR_1->pos);

            av_freep(&VAR_1->data);

            VAR_1->size = 0;

            VAR_2 = avpriv_dv_get_packet(mov->dv_demux, VAR_1);

            if (VAR_2 < 0)

                return VAR_2;

        }

#endif

    }



    VAR_1->stream_index = sc->ffindex;

    VAR_1->dts = sample->timestamp;

    if (sc->ctts_data && sc->ctts_index < sc->ctts_count) {

        VAR_1->pts = VAR_1->dts + sc->dts_shift + sc->ctts_data[sc->ctts_index].duration;

        

        sc->ctts_sample++;

        if (sc->ctts_index < sc->ctts_count &&

            sc->ctts_data[sc->ctts_index].count == sc->ctts_sample) {

            sc->ctts_index++;

            sc->ctts_sample = 0;

        }

        if (sc->wrong_dts)

            VAR_1->dts = AV_NOPTS_VALUE;

    } else {

        int64_t next_dts = (sc->current_sample < st->nb_index_entries) ?

            st->index_entries[sc->current_sample].timestamp : st->duration;

        VAR_1->duration = next_dts - VAR_1->dts;

        VAR_1->pts = VAR_1->dts;

    }

    if (st->discard == AVDISCARD_ALL)

        goto retry;

    VAR_1->flags |= sample->flags & AVINDEX_KEYFRAME ? AV_PKT_FLAG_KEY : 0;

    VAR_1->pos = sample->pos;



    return 0;

}

static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1)
{ MOVContext *mov = VAR_0->priv_data; MOVStreamContext *sc; AVIndexEntry *sample; AVStream *st = NULL; int VAR_2; mov->fc = VAR_0; retry:
sample = mov_find_next_sample(VAR_0, &st); if (!sample) { mov->found_mdat = 0; if (!mov->next_root_atom)
return AVERROR_EOF; avio_seek(VAR_0->pb, mov->next_root_atom, SEEK_SET); mov->next_root_atom = 0; if (mov_read_default(mov, VAR_0->pb, (MOVAtom){ AV_RL32("root"), INT64_MAX }) < 0 || avio_feof(VAR_0->pb))
return AVERROR_EOF; av_log(VAR_0, AV_LOG_TRACE, "read fragments, offset 0x%"PRIx64"\n", avio_tell(VAR_0->pb)); goto retry; } sc = st->priv_data; sc->current_sample++; if (mov->next_root_atom) { sample->pos = FFMIN(sample->pos, mov->next_root_atom); sample->size = FFMIN(sample->size, (mov->next_root_atom - sample->pos)); } if (st->discard != AVDISCARD_ALL) { if (avio_seek(sc->pb, sample->pos, SEEK_SET) != sample->pos) { av_log(mov->fc, AV_LOG_ERROR, "stream %d, offset 0x%"PRIx64": partial file\n",
sc->ffindex, sample->pos); return AVERROR_INVALIDDATA; } VAR_2 = av_get_packet(sc->pb, VAR_1, sample->size); if (VAR_2 < 0)
return VAR_2; if (sc->has_palette) { uint8_t *pal; pal = av_packet_new_side_data(VAR_1, AV_PKT_DATA_PALETTE, AVPALETTE_SIZE); if (!pal) { av_log(mov->fc, AV_LOG_ERROR, "Cannot append palette to packet\n"); } else { memcpy(pal, sc->palette, AVPALETTE_SIZE); sc->has_palette = 0; } } #if CONFIG_DV_DEMUXER
if (mov->dv_demux && sc->dv_audio_container) { avpriv_dv_produce_packet(mov->dv_demux, VAR_1, VAR_1->data, VAR_1->size, VAR_1->pos); av_freep(&VAR_1->data); VAR_1->size = 0; VAR_2 = avpriv_dv_get_packet(mov->dv_demux, VAR_1); if (VAR_2 < 0)
return VAR_2; } #endif
} VAR_1->stream_index = sc->ffindex; VAR_1->dts = sample->timestamp; if (sc->ctts_data && sc->ctts_index < sc->ctts_count) { VAR_1->pts = VAR_1->dts + sc->dts_shift + sc->ctts_data[sc->ctts_index].duration; sc->ctts_sample++; if (sc->ctts_index < sc->ctts_count &&
sc->ctts_data[sc->ctts_index].count == sc->ctts_sample) { sc->ctts_index++; sc->ctts_sample = 0; } if (sc->wrong_dts)
VAR_1->dts = AV_NOPTS_VALUE; } else { int64_t next_dts = (sc->current_sample < st->nb_index_entries) ?
st->index_entries[sc->current_sample].timestamp : st->duration; VAR_1->duration = next_dts - VAR_1->dts; VAR_1->pts = VAR_1->dts; } if (st->discard == AVDISCARD_ALL)
goto retry; VAR_1->flags |= sample->flags & AVINDEX_KEYFRAME ? AV_PKT_FLAG_KEY : 0; VAR_1->pos = sample->pos; return 0; }