matroska_parse_block(MatroskaDemuxContext *matroska, uint8_t *data, int size,

                     int64_t pos, uint64_t cluster_time, uint64_t duration,

                     int is_keyframe, int is_bframe)

{

    int res = 0;

    int track;

    AVStream *st;

    AVPacket *pkt;

    uint8_t *origdata = data;

    int16_t block_time;

    uint32_t *lace_size = NULL;

    int n, flags, laces = 0;

    uint64_t num;



    /* first byte(s): tracknum */

    if ((n = matroska_ebmlnum_uint(data, size, &num)) < 0) {

        av_log(matroska->ctx, AV_LOG_ERROR, "EBML block data error\n");

        av_free(origdata);

        return res;

    }

    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;

    }

    if (matroska->tracks[track]->stream_index < 0)

        return res;

    st = matroska->ctx->streams[matroska->tracks[track]->stream_index];

    if (st->discard >= AVDISCARD_ALL) {

        av_free(origdata);

        return res;

    }

    if (duration == AV_NOPTS_VALUE)

        duration = matroska->tracks[track]->default_duration;



    /* block_time (relative to cluster time) */

    block_time = AV_RB16(data);

    data += 2;

    flags = *data++;

    size -= 3;

    if (is_keyframe == -1)

        is_keyframe = flags & 1 ? PKT_FLAG_KEY : 0;



    if (matroska->skip_to_keyframe) {

        if (!is_keyframe || st != matroska->skip_to_stream)

            return res;

        matroska->skip_to_keyframe = 0;

    }



    switch ((flags & 0x06) >> 1) {

        case 0x0: /* no lacing */

            laces = 1;

            lace_size = av_mallocz(sizeof(int));

            lace_size[0] = size;

            break;



        case 0x1: /* xiph lacing */

        case 0x2: /* fixed-size lacing */

        case 0x3: /* EBML lacing */

            if (size == 0) {

                res = -1;

                break;

            }

            laces = (*data) + 1;

            data += 1;

            size -= 1;

            lace_size = av_mallocz(laces * sizeof(int));



            switch ((flags & 0x06) >> 1) {

                case 0x1: /* xiph lacing */ {

                    uint8_t temp;

                    uint32_t total = 0;

                    for (n = 0; res == 0 && n < laces - 1; n++) {

                        while (1) {

                            if (size == 0) {

                                res = -1;

                                break;

                            }

                            temp = *data;

                            lace_size[n] += temp;

                            data += 1;

                            size -= 1;

                            if (temp != 0xff)

                                break;

                        }

                        total += lace_size[n];

                    }

                    lace_size[n] = size - total;

                    break;

                }



                case 0x2: /* fixed-size lacing */

                    for (n = 0; n < laces; n++)

                        lace_size[n] = size / laces;

                    break;



                case 0x3: /* EBML lacing */ {

                    uint32_t total;

                    n = matroska_ebmlnum_uint(data, size, &num);

                    if (n < 0) {

                        av_log(matroska->ctx, AV_LOG_INFO,

                               "EBML block data error\n");

                        break;

                    }

                    data += n;

                    size -= n;

                    total = lace_size[0] = num;

                    for (n = 1; res == 0 && n < laces - 1; n++) {

                        int64_t snum;

                        int r;

                        r = matroska_ebmlnum_sint (data, size, &snum);

                        if (r < 0) {

                            av_log(matroska->ctx, AV_LOG_INFO,

                                   "EBML block data error\n");

                            break;

                        }

                        data += r;

                        size -= r;

                        lace_size[n] = lace_size[n - 1] + snum;

                        total += lace_size[n];

                    }

                    lace_size[n] = size - total;

                    break;

                }

            }

            break;

    }



    if (res == 0) {

        int real_v = matroska->tracks[track]->flags & MATROSKA_TRACK_REAL_V;

        uint64_t timecode = AV_NOPTS_VALUE;



        if (cluster_time != (uint64_t)-1 && cluster_time + block_time >= 0)

            timecode = cluster_time + block_time;



        for (n = 0; n < laces; n++) {

            int slice, slices = 1;



            if (real_v) {

                slices = *data++ + 1;

                lace_size[n]--;

            }



            for (slice=0; slice<slices; slice++) {

                int slice_size, slice_offset = 0;

                if (real_v)

                    slice_offset = rv_offset(data, slice, slices);

                if (slice+1 == slices)

                    slice_size = lace_size[n] - slice_offset;

                else

                    slice_size = rv_offset(data, slice+1, slices) - slice_offset;



                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;

                    int w = audiotrack->frame_size;

                    int x;



                    if (!audiotrack->pkt_cnt) {

                        if (st->codec->codec_id == CODEC_ID_RA_288)

                            for (x=0; x<h/2; x++)

                                memcpy(audiotrack->buf+x*2*w+y*cfs,

                                       data+x*cfs, cfs);

                        else

                            for (x=0; x<w/sps; x++)

                                memcpy(audiotrack->buf+sps*(h*x+((h+1)/2)*(y&1)+(y>>1)), data+x*sps, sps);



                        if (++audiotrack->sub_packet_cnt >= h) {

                            audiotrack->sub_packet_cnt = 0;

                            audiotrack->pkt_cnt = h*w / a;

                        }

                    }

                    while (audiotrack->pkt_cnt) {

                        pkt = av_mallocz(sizeof(AVPacket));

                        av_new_packet(pkt, a);

                        memcpy(pkt->data, audiotrack->buf

                               + a * (h*w / a - audiotrack->pkt_cnt--), a);

                        pkt->pos = pos;

                        pkt->stream_index = matroska->tracks[track]->stream_index;

                        matroska_queue_packet(matroska, pkt);

                    }

                } else {

                    int offset = 0;



                    if (st->codec->codec_id == CODEC_ID_TEXT

                        && ((MatroskaSubtitleTrack *)(matroska->tracks[track]))->ass) {

                        int i;

                        for (i=0; i<8 && data[slice_offset+offset]; offset++)

                            if (data[slice_offset+offset] == ',')

                                i++;

                    }



                    pkt = av_mallocz(sizeof(AVPacket));

                    /* XXX: prevent data copy... */

                    if (av_new_packet(pkt, slice_size-offset) < 0) {

                        res = AVERROR(ENOMEM);

                        n = laces-1;

                        break;

                    }

                    memcpy (pkt->data, data+slice_offset+offset, slice_size-offset);



                    if (n == 0)

                        pkt->flags = is_keyframe;

                    pkt->stream_index = matroska->tracks[track]->stream_index;



                    pkt->pts = timecode;

                    pkt->pos = pos;

                    pkt->duration = duration;



                    matroska_queue_packet(matroska, pkt);

                }



                if (timecode != AV_NOPTS_VALUE)

                    timecode = duration ? timecode + duration : AV_NOPTS_VALUE;

            }

            data += lace_size[n];

        }

    }



    av_free(lace_size);

    av_free(origdata);

    return res;

}

matroska_parse_block(MatroskaDemuxContext *matroska, uint8_t *data, int size,

                     int64_t pos, uint64_t cluster_time, uint64_t duration,

                     int is_keyframe, int is_bframe)

{

    int res = 0;

    int track;

    AVStream *st;

    AVPacket *pkt;

    uint8_t *origdata = data;

    int16_t block_time;

    uint32_t *lace_size = NULL;

    int n, flags, laces = 0;

    uint64_t num;



    

    if ((n = matroska_ebmlnum_uint(data, size, &num)) < 0) {

        av_log(matroska->ctx, AV_LOG_ERROR, "EBML block data error\n");

        av_free(origdata);

        return res;

    }

    data += n;

    size -= n;



    

    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;

    }

    if (matroska->tracks[track]->stream_index < 0)

        return res;

    st = matroska->ctx->streams[matroska->tracks[track]->stream_index];

    if (st->discard >= AVDISCARD_ALL) {

        av_free(origdata);

        return res;

    }

    if (duration == AV_NOPTS_VALUE)

        duration = matroska->tracks[track]->default_duration;



    

    block_time = AV_RB16(data);

    data += 2;

    flags = *data++;

    size -= 3;

    if (is_keyframe == -1)

        is_keyframe = flags & 1 ? PKT_FLAG_KEY : 0;



    if (matroska->skip_to_keyframe) {

        if (!is_keyframe || st != matroska->skip_to_stream)

            return res;

        matroska->skip_to_keyframe = 0;

    }



    switch ((flags & 0x06) >> 1) {

        case 0x0: 

            laces = 1;

            lace_size = av_mallocz(sizeof(int));

            lace_size[0] = size;

            break;



        case 0x1: 

        case 0x2: 

        case 0x3: 

            if (size == 0) {

                res = -1;

                break;

            }

            laces = (*data) + 1;

            data += 1;

            size -= 1;

            lace_size = av_mallocz(laces * sizeof(int));



            switch ((flags & 0x06) >> 1) {

                case 0x1:  {

                    uint8_t temp;

                    uint32_t total = 0;

                    for (n = 0; res == 0 && n < laces - 1; n++) {

                        while (1) {

                            if (size == 0) {

                                res = -1;

                                break;

                            }

                            temp = *data;

                            lace_size[n] += temp;

                            data += 1;

                            size -= 1;

                            if (temp != 0xff)

                                break;

                        }

                        total += lace_size[n];

                    }

                    lace_size[n] = size - total;

                    break;

                }



                case 0x2: 

                    for (n = 0; n < laces; n++)

                        lace_size[n] = size / laces;

                    break;



                case 0x3:  {

                    uint32_t total;

                    n = matroska_ebmlnum_uint(data, size, &num);

                    if (n < 0) {

                        av_log(matroska->ctx, AV_LOG_INFO,

                               "EBML block data error\n");

                        break;

                    }

                    data += n;

                    size -= n;

                    total = lace_size[0] = num;

                    for (n = 1; res == 0 && n < laces - 1; n++) {

                        int64_t snum;

                        int r;

                        r = matroska_ebmlnum_sint (data, size, &snum);

                        if (r < 0) {

                            av_log(matroska->ctx, AV_LOG_INFO,

                                   "EBML block data error\n");

                            break;

                        }

                        data += r;

                        size -= r;

                        lace_size[n] = lace_size[n - 1] + snum;

                        total += lace_size[n];

                    }

                    lace_size[n] = size - total;

                    break;

                }

            }

            break;

    }



    if (res == 0) {

        int real_v = matroska->tracks[track]->flags & MATROSKA_TRACK_REAL_V;

        uint64_t timecode = AV_NOPTS_VALUE;



        if (cluster_time != (uint64_t)-1 && cluster_time + block_time >= 0)

            timecode = cluster_time + block_time;



        for (n = 0; n < laces; n++) {

            int slice, slices = 1;



            if (real_v) {

                slices = *data++ + 1;

                lace_size[n]--;

            }



            for (slice=0; slice<slices; slice++) {

                int slice_size, slice_offset = 0;

                if (real_v)

                    slice_offset = rv_offset(data, slice, slices);

                if (slice+1 == slices)

                    slice_size = lace_size[n] - slice_offset;

                else

                    slice_size = rv_offset(data, slice+1, slices) - slice_offset;



                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;

                    int w = audiotrack->frame_size;

                    int x;



                    if (!audiotrack->pkt_cnt) {

                        if (st->codec->codec_id == CODEC_ID_RA_288)

                            for (x=0; x<h/2; x++)

                                memcpy(audiotrack->buf+x*2*w+y*cfs,

                                       data+x*cfs, cfs);

                        else

                            for (x=0; x<w/sps; x++)

                                memcpy(audiotrack->buf+sps*(h*x+((h+1)/2)*(y&1)+(y>>1)), data+x*sps, sps);



                        if (++audiotrack->sub_packet_cnt >= h) {

                            audiotrack->sub_packet_cnt = 0;

                            audiotrack->pkt_cnt = h*w / a;

                        }

                    }

                    while (audiotrack->pkt_cnt) {

                        pkt = av_mallocz(sizeof(AVPacket));

                        av_new_packet(pkt, a);

                        memcpy(pkt->data, audiotrack->buf

                               + a * (h*w / a - audiotrack->pkt_cnt--), a);

                        pkt->pos = pos;

                        pkt->stream_index = matroska->tracks[track]->stream_index;

                        matroska_queue_packet(matroska, pkt);

                    }

                } else {

                    int offset = 0;



                    if (st->codec->codec_id == CODEC_ID_TEXT

                        && ((MatroskaSubtitleTrack *)(matroska->tracks[track]))->ass) {

                        int i;

                        for (i=0; i<8 && data[slice_offset+offset]; offset++)

                            if (data[slice_offset+offset] == ',')

                                i++;

                    }



                    pkt = av_mallocz(sizeof(AVPacket));

                    

                    if (av_new_packet(pkt, slice_size-offset) < 0) {

                        res = AVERROR(ENOMEM);

                        n = laces-1;

                        break;

                    }

                    memcpy (pkt->data, data+slice_offset+offset, slice_size-offset);



                    if (n == 0)

                        pkt->flags = is_keyframe;

                    pkt->stream_index = matroska->tracks[track]->stream_index;



                    pkt->pts = timecode;

                    pkt->pos = pos;

                    pkt->duration = duration;



                    matroska_queue_packet(matroska, pkt);

                }



                if (timecode != AV_NOPTS_VALUE)

                    timecode = duration ? timecode + duration : AV_NOPTS_VALUE;

            }

            data += lace_size[n];

        }

    }



    av_free(lace_size);

    av_free(origdata);

    return res;

}

FUNC_0(MatroskaDemuxContext *VAR_0, uint8_t *VAR_1, int VAR_2,

                     int64_t VAR_3, uint64_t VAR_4, uint64_t VAR_5,

                     int VAR_6, int VAR_7)

{

    int VAR_8 = 0;

    int VAR_9;

    AVStream *st;

    AVPacket *pkt;

    uint8_t *origdata = VAR_1;

    int16_t block_time;

    uint32_t *lace_size = NULL;

    int VAR_10, VAR_11, VAR_12 = 0;

    uint64_t num;



    

    if ((VAR_10 = matroska_ebmlnum_uint(VAR_1, VAR_2, &num)) < 0) {

        av_log(VAR_0->ctx, AV_LOG_ERROR, "EBML block VAR_1 error\VAR_10");

        av_free(origdata);

        return VAR_8;

    }

    VAR_1 += VAR_10;

    VAR_2 -= VAR_10;



    

    VAR_9 = matroska_find_track_by_num(VAR_0, num);

    if (VAR_2 <= 3 || VAR_9 < 0 || VAR_9 >= VAR_0->num_tracks) {

        av_log(VAR_0->ctx, AV_LOG_INFO,

               "Invalid stream %d or VAR_2 %u\VAR_10", VAR_9, VAR_2);

        av_free(origdata);

        return VAR_8;

    }

    if (VAR_0->tracks[VAR_9]->stream_index < 0)

        return VAR_8;

    st = VAR_0->ctx->streams[VAR_0->tracks[VAR_9]->stream_index];

    if (st->discard >= AVDISCARD_ALL) {

        av_free(origdata);

        return VAR_8;

    }

    if (VAR_5 == AV_NOPTS_VALUE)

        VAR_5 = VAR_0->tracks[VAR_9]->default_duration;



    

    block_time = AV_RB16(VAR_1);

    VAR_1 += 2;

    VAR_11 = *VAR_1++;

    VAR_2 -= 3;

    if (VAR_6 == -1)

        VAR_6 = VAR_11 & 1 ? PKT_FLAG_KEY : 0;



    if (VAR_0->skip_to_keyframe) {

        if (!VAR_6 || st != VAR_0->skip_to_stream)

            return VAR_8;

        VAR_0->skip_to_keyframe = 0;

    }



    switch ((VAR_11 & 0x06) >> 1) {

        case 0x0: 

            VAR_12 = 1;

            lace_size = av_mallocz(sizeof(int));

            lace_size[0] = VAR_2;

            break;



        case 0x1: 

        case 0x2: 

        case 0x3: 

            if (VAR_2 == 0) {

                VAR_8 = -1;

                break;

            }

            VAR_12 = (*VAR_1) + 1;

            VAR_1 += 1;

            VAR_2 -= 1;

            lace_size = av_mallocz(VAR_12 * sizeof(int));



            switch ((VAR_11 & 0x06) >> 1) {

                case 0x1:  {

                    uint8_t temp;

                    uint32_t total = 0;

                    for (VAR_10 = 0; VAR_8 == 0 && VAR_10 < VAR_12 - 1; VAR_10++) {

                        while (1) {

                            if (VAR_2 == 0) {

                                VAR_8 = -1;

                                break;

                            }

                            temp = *VAR_1;

                            lace_size[VAR_10] += temp;

                            VAR_1 += 1;

                            VAR_2 -= 1;

                            if (temp != 0xff)

                                break;

                        }

                        total += lace_size[VAR_10];

                    }

                    lace_size[VAR_10] = VAR_2 - total;

                    break;

                }



                case 0x2: 

                    for (VAR_10 = 0; VAR_10 < VAR_12; VAR_10++)

                        lace_size[VAR_10] = VAR_2 / VAR_12;

                    break;



                case 0x3:  {

                    uint32_t total;

                    VAR_10 = matroska_ebmlnum_uint(VAR_1, VAR_2, &num);

                    if (VAR_10 < 0) {

                        av_log(VAR_0->ctx, AV_LOG_INFO,

                               "EBML block VAR_1 error\VAR_10");

                        break;

                    }

                    VAR_1 += VAR_10;

                    VAR_2 -= VAR_10;

                    total = lace_size[0] = num;

                    for (VAR_10 = 1; VAR_8 == 0 && VAR_10 < VAR_12 - 1; VAR_10++) {

                        int64_t snum;

                        int VAR_13;

                        VAR_13 = matroska_ebmlnum_sint (VAR_1, VAR_2, &snum);

                        if (VAR_13 < 0) {

                            av_log(VAR_0->ctx, AV_LOG_INFO,

                                   "EBML block VAR_1 error\VAR_10");

                            break;

                        }

                        VAR_1 += VAR_13;

                        VAR_2 -= VAR_13;

                        lace_size[VAR_10] = lace_size[VAR_10 - 1] + snum;

                        total += lace_size[VAR_10];

                    }

                    lace_size[VAR_10] = VAR_2 - total;

                    break;

                }

            }

            break;

    }



    if (VAR_8 == 0) {

        int VAR_14 = VAR_0->tracks[VAR_9]->VAR_11 & MATROSKA_TRACK_REAL_V;

        uint64_t timecode = AV_NOPTS_VALUE;



        if (VAR_4 != (uint64_t)-1 && VAR_4 + block_time >= 0)

            timecode = VAR_4 + block_time;



        for (VAR_10 = 0; VAR_10 < VAR_12; VAR_10++) {

            int VAR_15, VAR_16 = 1;



            if (VAR_14) {

                VAR_16 = *VAR_1++ + 1;

                lace_size[VAR_10]--;

            }



            for (VAR_15=0; VAR_15<VAR_16; VAR_15++) {

                int VAR_17, VAR_18 = 0;

                if (VAR_14)

                    VAR_18 = rv_offset(VAR_1, VAR_15, VAR_16);

                if (VAR_15+1 == VAR_16)

                    VAR_17 = lace_size[VAR_10] - VAR_18;

                else

                    VAR_17 = rv_offset(VAR_1, VAR_15+1, VAR_16) - VAR_18;



                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 *)VAR_0->tracks[VAR_9];

                    int VAR_19 = st->codec->block_align;

                    int VAR_20 = audiotrack->sub_packet_size;

                    int VAR_21 = audiotrack->coded_framesize;

                    int VAR_22 = audiotrack->sub_packet_h;

                    int VAR_23 = audiotrack->sub_packet_cnt;

                    int VAR_24 = audiotrack->frame_size;

                    int VAR_25;



                    if (!audiotrack->pkt_cnt) {

                        if (st->codec->codec_id == CODEC_ID_RA_288)

                            for (VAR_25=0; VAR_25<VAR_22/2; VAR_25++)

                                memcpy(audiotrack->buf+VAR_25*2*VAR_24+VAR_23*VAR_21,

                                       VAR_1+VAR_25*VAR_21, VAR_21);

                        else

                            for (VAR_25=0; VAR_25<VAR_24/VAR_20; VAR_25++)

                                memcpy(audiotrack->buf+VAR_20*(VAR_22*VAR_25+((VAR_22+1)/2)*(VAR_23&1)+(VAR_23>>1)), VAR_1+VAR_25*VAR_20, VAR_20);



                        if (++audiotrack->sub_packet_cnt >= VAR_22) {

                            audiotrack->sub_packet_cnt = 0;

                            audiotrack->pkt_cnt = VAR_22*VAR_24 / VAR_19;

                        }

                    }

                    while (audiotrack->pkt_cnt) {

                        pkt = av_mallocz(sizeof(AVPacket));

                        av_new_packet(pkt, VAR_19);

                        memcpy(pkt->VAR_1, audiotrack->buf

                               + VAR_19 * (VAR_22*VAR_24 / VAR_19 - audiotrack->pkt_cnt--), VAR_19);

                        pkt->VAR_3 = VAR_3;

                        pkt->stream_index = VAR_0->tracks[VAR_9]->stream_index;

                        matroska_queue_packet(VAR_0, pkt);

                    }

                } else {

                    int VAR_26 = 0;



                    if (st->codec->codec_id == CODEC_ID_TEXT

                        && ((MatroskaSubtitleTrack *)(VAR_0->tracks[VAR_9]))->ass) {

                        int VAR_27;

                        for (VAR_27=0; VAR_27<8 && VAR_1[VAR_18+VAR_26]; VAR_26++)

                            if (VAR_1[VAR_18+VAR_26] == ',')

                                VAR_27++;

                    }



                    pkt = av_mallocz(sizeof(AVPacket));

                    

                    if (av_new_packet(pkt, VAR_17-VAR_26) < 0) {

                        VAR_8 = AVERROR(ENOMEM);

                        VAR_10 = VAR_12-1;

                        break;

                    }

                    memcpy (pkt->VAR_1, VAR_1+VAR_18+VAR_26, VAR_17-VAR_26);



                    if (VAR_10 == 0)

                        pkt->VAR_11 = VAR_6;

                    pkt->stream_index = VAR_0->tracks[VAR_9]->stream_index;



                    pkt->pts = timecode;

                    pkt->VAR_3 = VAR_3;

                    pkt->VAR_5 = VAR_5;



                    matroska_queue_packet(VAR_0, pkt);

                }



                if (timecode != AV_NOPTS_VALUE)

                    timecode = VAR_5 ? timecode + VAR_5 : AV_NOPTS_VALUE;

            }

            VAR_1 += lace_size[VAR_10];

        }

    }



    av_free(lace_size);

    av_free(origdata);

    return VAR_8;

}

FUNC_0(MatroskaDemuxContext *VAR_0, uint8_t *VAR_1, int VAR_2,
int64_t VAR_3, uint64_t VAR_4, uint64_t VAR_5,
int VAR_6, int VAR_7)
{ int VAR_8 = 0; int VAR_9; AVStream *st; AVPacket *pkt; uint8_t *origdata = VAR_1; int16_t block_time; uint32_t *lace_size = NULL; int VAR_10, VAR_11, VAR_12 = 0; uint64_t num; if ((VAR_10 = matroska_ebmlnum_uint(VAR_1, VAR_2, &num)) < 0) { av_log(VAR_0->ctx, AV_LOG_ERROR, "EBML block VAR_1 error\VAR_10"); av_free(origdata); return VAR_8; } VAR_1 += VAR_10; VAR_2 -= VAR_10; VAR_9 = matroska_find_track_by_num(VAR_0, num); if (VAR_2 <= 3 || VAR_9 < 0 || VAR_9 >= VAR_0->num_tracks) { av_log(VAR_0->ctx, AV_LOG_INFO,
"Invalid stream %d or VAR_2 %u\VAR_10", VAR_9, VAR_2); av_free(origdata); return VAR_8; } if (VAR_0->tracks[VAR_9]->stream_index < 0)
return VAR_8; st = VAR_0->ctx->streams[VAR_0->tracks[VAR_9]->stream_index]; if (st->discard >= AVDISCARD_ALL) { av_free(origdata); return VAR_8; } if (VAR_5 == AV_NOPTS_VALUE)
VAR_5 = VAR_0->tracks[VAR_9]->default_duration; block_time = AV_RB16(VAR_1); VAR_1 += 2; VAR_11 = *VAR_1++; VAR_2 -= 3; if (VAR_6 == -1)
VAR_6 = VAR_11 & 1 ? PKT_FLAG_KEY : 0; if (VAR_0->skip_to_keyframe) { if (!VAR_6 || st != VAR_0->skip_to_stream)
return VAR_8; VAR_0->skip_to_keyframe = 0; } switch ((VAR_11 & 0x06) >> 1) { case 0x0:
VAR_12 = 1; lace_size = av_mallocz(sizeof(int)); lace_size[0] = VAR_2; break; case 0x1:
case 0x2:
case 0x3:
if (VAR_2 == 0) { VAR_8 = -1; break; } VAR_12 = (*VAR_1) + 1; VAR_1 += 1; VAR_2 -= 1; lace_size = av_mallocz(VAR_12 * sizeof(int)); switch ((VAR_11 & 0x06) >> 1) { case 0x1:  { uint8_t temp; uint32_t total = 0; for (VAR_10 = 0; VAR_8 == 0 && VAR_10 < VAR_12 - 1; VAR_10++) { while (1) { if (VAR_2 == 0) { VAR_8 = -1; break; } temp = *VAR_1; lace_size[VAR_10] += temp; VAR_1 += 1; VAR_2 -= 1; if (temp != 0xff)
break; } total += lace_size[VAR_10]; } lace_size[VAR_10] = VAR_2 - total; break; } case 0x2:
for (VAR_10 = 0; VAR_10 < VAR_12; VAR_10++) lace_size[VAR_10] = VAR_2 / VAR_12; break; case 0x3:  { uint32_t total; VAR_10 = matroska_ebmlnum_uint(VAR_1, VAR_2, &num); if (VAR_10 < 0) { av_log(VAR_0->ctx, AV_LOG_INFO,
"EBML block VAR_1 error\VAR_10"); break; } VAR_1 += VAR_10; VAR_2 -= VAR_10; total = lace_size[0] = num; for (VAR_10 = 1; VAR_8 == 0 && VAR_10 < VAR_12 - 1; VAR_10++) { int64_t snum; int VAR_13; VAR_13 = matroska_ebmlnum_sint (VAR_1, VAR_2, &snum); if (VAR_13 < 0) { av_log(VAR_0->ctx, AV_LOG_INFO,
"EBML block VAR_1 error\VAR_10"); break; } VAR_1 += VAR_13; VAR_2 -= VAR_13; lace_size[VAR_10] = lace_size[VAR_10 - 1] + snum; total += lace_size[VAR_10]; } lace_size[VAR_10] = VAR_2 - total; break; } } break; } if (VAR_8 == 0) { int VAR_14 = VAR_0->tracks[VAR_9]->VAR_11 & MATROSKA_TRACK_REAL_V; uint64_t timecode = AV_NOPTS_VALUE; if (VAR_4 != (uint64_t)-1 && VAR_4 + block_time >= 0)
timecode = VAR_4 + block_time; for (VAR_10 = 0; VAR_10 < VAR_12; VAR_10++) { int VAR_15, VAR_16 = 1; if (VAR_14) { VAR_16 = *VAR_1++ + 1; lace_size[VAR_10]--; } for (VAR_15=0; VAR_15<VAR_16; VAR_15++) { int VAR_17, VAR_18 = 0; if (VAR_14)
VAR_18 = rv_offset(VAR_1, VAR_15, VAR_16); if (VAR_15+1 == VAR_16)
VAR_17 = lace_size[VAR_10] - VAR_18; else
VAR_17 = rv_offset(VAR_1, VAR_15+1, VAR_16) - VAR_18; 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 *)VAR_0->tracks[VAR_9]; int VAR_19 = st->codec->block_align; int VAR_20 = audiotrack->sub_packet_size; int VAR_21 = audiotrack->coded_framesize; int VAR_22 = audiotrack->sub_packet_h; int VAR_23 = audiotrack->sub_packet_cnt; int VAR_24 = audiotrack->frame_size; int VAR_25; if (!audiotrack->pkt_cnt) { if (st->codec->codec_id == CODEC_ID_RA_288)
for (VAR_25=0; VAR_25<VAR_22/2; VAR_25++) memcpy(audiotrack->buf+VAR_25*2*VAR_24+VAR_23*VAR_21,
VAR_1+VAR_25*VAR_21, VAR_21); else
for (VAR_25=0; VAR_25<VAR_24/VAR_20; VAR_25++) memcpy(audiotrack->buf+VAR_20*(VAR_22*VAR_25+((VAR_22+1)/2)*(VAR_23&1)+(VAR_23>>1)), VAR_1+VAR_25*VAR_20, VAR_20); if (++audiotrack->sub_packet_cnt >= VAR_22) { audiotrack->sub_packet_cnt = 0; audiotrack->pkt_cnt = VAR_22*VAR_24 / VAR_19; } } while (audiotrack->pkt_cnt) { pkt = av_mallocz(sizeof(AVPacket)); av_new_packet(pkt, VAR_19); memcpy(pkt->VAR_1, audiotrack->buf
+ VAR_19 * (VAR_22*VAR_24 / VAR_19 - audiotrack->pkt_cnt--), VAR_19); pkt->VAR_3 = VAR_3; pkt->stream_index = VAR_0->tracks[VAR_9]->stream_index; matroska_queue_packet(VAR_0, pkt); } } else { int VAR_26 = 0; if (st->codec->codec_id == CODEC_ID_TEXT
&& ((MatroskaSubtitleTrack *)(VAR_0->tracks[VAR_9]))->ass) { int VAR_27; for (VAR_27=0; VAR_27<8 && VAR_1[VAR_18+VAR_26]; VAR_26++) if (VAR_1[VAR_18+VAR_26] == ',')
VAR_27++; } pkt = av_mallocz(sizeof(AVPacket)); if (av_new_packet(pkt, VAR_17-VAR_26) < 0) { VAR_8 = AVERROR(ENOMEM); VAR_10 = VAR_12-1; break; } memcpy (pkt->VAR_1, VAR_1+VAR_18+VAR_26, VAR_17-VAR_26); if (VAR_10 == 0)
pkt->VAR_11 = VAR_6; pkt->stream_index = VAR_0->tracks[VAR_9]->stream_index; pkt->pts = timecode; pkt->VAR_3 = VAR_3; pkt->VAR_5 = VAR_5; matroska_queue_packet(VAR_0, pkt); } if (timecode != AV_NOPTS_VALUE)
timecode = VAR_5 ? timecode + VAR_5 : AV_NOPTS_VALUE; } VAR_1 += lace_size[VAR_10]; } } av_free(lace_size); av_free(origdata); return VAR_8; }