comparison matroskadec.c @ 3636:1f8f906eb49e libavformat

matroskadec: return pointer instead of index in matroska_find_track_by_num()

3635:318d5e2f9aed

    return res;
}


static int
matroska_find_track_by_num (MatroskaDemuxContext *matroska,
                            int                   num)
{
    int i;

    for (i = 0; i < matroska->num_tracks; i++)
        if (matroska->tracks[i]->num == num)
            return i;

    return -1;
}


/*
 * Put one packet in an application-supplied AVPacket struct.

        }
        res = 0;
    }

    if (matroska->index_parsed) {
        int i, track, stream;
        for (i=0; i<matroska->num_indexes; i++) {
            MatroskaDemuxIndex *idx = &matroska->index[i];
            track = matroska_find_track_by_num(matroska, idx->track);
            if (track < 0)  continue;
            stream = matroska->tracks[track]->stream->index;
            if (stream >= 0 && stream < matroska->ctx->nb_streams)
                av_add_index_entry(matroska->ctx->streams[stream],
                                   idx->pos, idx->time/AV_TIME_BASE,
                                   0, 0, AVINDEX_KEYFRAME);
        }
    }

static int
matroska_parse_block(MatroskaDemuxContext *matroska, uint8_t *data, int size,
                     int64_t pos, uint64_t cluster_time, uint64_t duration,
                     int is_keyframe)
{
    int res = 0;
    int track;
    AVStream *st;
    AVPacket *pkt;
    uint8_t *origdata = data;
    int16_t block_time;
    uint32_t *lace_size = NULL;

    data += n;
    size -= n;

    /* fetch track from num */
    track = matroska_find_track_by_num(matroska, num);
    if (size <= 3 || track < 0 || track >= matroska->num_tracks) {
        av_log(matroska->ctx, AV_LOG_INFO,
               "Invalid stream %d or size %u\n", track, size);
        av_free(origdata);
        return res;
    }
    st = matroska->tracks[track]->stream;
    if (st->discard >= AVDISCARD_ALL) {
        av_free(origdata);
        return res;
    }
    if (duration == AV_NOPTS_VALUE)
        duration = matroska->tracks[track]->default_duration / matroska->time_scale;

    /* block_time (relative to cluster time) */
    block_time = AV_RB16(data);
    data += 2;
    flags = *data++;

        for (n = 0; n < laces; n++) {
            if (st->codec->codec_id == CODEC_ID_RA_288 ||
                st->codec->codec_id == CODEC_ID_COOK ||
                st->codec->codec_id == CODEC_ID_ATRAC3) {
                MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *)matroska->tracks[track];
                int a = st->codec->block_align;
                int sps = audiotrack->sub_packet_size;
                int cfs = audiotrack->coded_framesize;
                int h = audiotrack->sub_packet_h;
                int y = audiotrack->sub_packet_cnt;

                }
            } else {
                int offset = 0, pkt_size = lace_size[n];
                uint8_t *pkt_data = data;

                if (matroska->tracks[track]->encoding_scope & 1) {
                    offset = matroska_decode_buffer(&pkt_data, &pkt_size,
                                                    matroska->tracks[track]);
                    if (offset < 0)
                        continue;
                }

                pkt = av_mallocz(sizeof(AVPacket));

                    res = AVERROR(ENOMEM);
                    n = laces-1;
                    break;
                }
                if (offset)
                    memcpy (pkt->data, matroska->tracks[track]->encoding_settings, offset);
                memcpy (pkt->data+offset, pkt_data, pkt_size);

                if (pkt_data != data)
                    av_free(pkt_data);

3636:1f8f906eb49e

    return res;
}


static MatroskaTrack *
matroska_find_track_by_num (MatroskaDemuxContext *matroska,
                            int                   num)
{
    int i;

    for (i = 0; i < matroska->num_tracks; i++)
        if (matroska->tracks[i]->num == num)
            return matroska->tracks[i];

    av_log(matroska->ctx, AV_LOG_ERROR, "Invalid track number %d\n", num);
    return NULL;
}


/*
 * Put one packet in an application-supplied AVPacket struct.

        }
        res = 0;
    }

    if (matroska->index_parsed) {
        int i;
        for (i=0; i<matroska->num_indexes; i++) {
            MatroskaDemuxIndex *idx = &matroska->index[i];
            MatroskaTrack *track = matroska_find_track_by_num(matroska,
                                                              idx->track);
            if (track && track->stream)
                av_add_index_entry(track->stream,
                                   idx->pos, idx->time/AV_TIME_BASE,
                                   0, 0, AVINDEX_KEYFRAME);
        }
    }

static int
matroska_parse_block(MatroskaDemuxContext *matroska, uint8_t *data, int size,
                     int64_t pos, uint64_t cluster_time, uint64_t duration,
                     int is_keyframe)
{
    MatroskaTrack *track;
    int res = 0;
    AVStream *st;
    AVPacket *pkt;
    uint8_t *origdata = data;
    int16_t block_time;
    uint32_t *lace_size = NULL;

    data += n;
    size -= n;

    /* fetch track from num */
    track = matroska_find_track_by_num(matroska, num);
    if (size <= 3 || !track || !track->stream) {
        av_log(matroska->ctx, AV_LOG_INFO,
               "Invalid stream %"PRIu64" or size %u\n", num, size);
        av_free(origdata);
        return res;
    }
    st = track->stream;
    if (st->discard >= AVDISCARD_ALL) {
        av_free(origdata);
        return res;
    }
    if (duration == AV_NOPTS_VALUE)
        duration = track->default_duration / matroska->time_scale;

    /* block_time (relative to cluster time) */
    block_time = AV_RB16(data);
    data += 2;
    flags = *data++;

        for (n = 0; n < laces; n++) {
            if (st->codec->codec_id == CODEC_ID_RA_288 ||
                st->codec->codec_id == CODEC_ID_COOK ||
                st->codec->codec_id == CODEC_ID_ATRAC3) {
                MatroskaAudioTrack *audiotrack = (MatroskaAudioTrack *)track;
                int a = st->codec->block_align;
                int sps = audiotrack->sub_packet_size;
                int cfs = audiotrack->coded_framesize;
                int h = audiotrack->sub_packet_h;
                int y = audiotrack->sub_packet_cnt;

                }
            } else {
                int offset = 0, pkt_size = lace_size[n];
                uint8_t *pkt_data = data;

                if (track->encoding_scope & 1) {
                    offset = matroska_decode_buffer(&pkt_data, &pkt_size,
                                                    track);
                    if (offset < 0)
                        continue;
                }

                pkt = av_mallocz(sizeof(AVPacket));

                    res = AVERROR(ENOMEM);
                    n = laces-1;
                    break;
                }
                if (offset)
                    memcpy (pkt->data, track->encoding_settings, offset);
                memcpy (pkt->data+offset, pkt_data, pkt_size);

                if (pkt_data != data)
                    av_free(pkt_data);