← Back to branch summary

~ubuntu-branches/ubuntu/edgy/gstreamer0.10-ffmpeg/edgy

« back to all changes in this revision

Viewing changes to gst-libs/ext/ffmpeg/libavformat/rm.c

  • Committer: Bazaar Package Importer
  • Author(s): Sebastian Dröge
  • Date: 2006-04-01 16:13:43 UTC
  • mto: This revision was merged to the branch mainline in revision 5.
  • Revision ID: james.westby@ubuntu.com-20060401161343-n621cgjlujio0otg
Tags: upstream-0.10.1
Import upstream version 0.10.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
gst-libs/ext/ffmpeg/libavformat/rm.c
14
14
 *
15
15
 * You should have received a copy of the GNU Lesser General Public
16
16
 * License along with this library; if not, write to the Free Software
17
 
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
17
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
18
 */
19
19
#include "avformat.h"
20
20
 
21
21
/* in ms */
22
 
#define BUFFER_DURATION 0 
 
22
#define BUFFER_DURATION 0
23
23
 
24
24
typedef struct {
25
25
    int nb_packets;
42
42
    int old_format;
43
43
    int current_stream;
44
44
    int remaining_len;
 
45
    /// Audio descrambling matrix parameters
 
46
    uint8_t *audiobuf; ///< place to store reordered audio data
 
47
    int64_t audiotimestamp; ///< Audio packet timestamp
 
48
    int sub_packet_cnt; // Subpacket counter, used while reading
 
49
    int sub_packet_size, sub_packet_h, coded_framesize; ///< Descrambling parameters from container
 
50
    int audio_stream_num; ///< Stream number for audio packets
 
51
    int audio_pkt_cnt; ///< Output packet counter
 
52
    int audio_framesize; /// Audio frame size from container
45
53
} RMContext;
46
54
 
47
55
#ifdef CONFIG_MUXERS
61
69
    }
62
70
}
63
71
 
64
 
static void rv10_write_header(AVFormatContext *ctx, 
 
72
static void rv10_write_header(AVFormatContext *ctx,
65
73
                              int data_size, int index_pos)
66
74
{
67
75
    RMContext *rm = ctx->priv_data;
120
128
    if (url_is_streamed(s))
121
129
        flags |= 4; /* live broadcast */
122
130
    put_be16(s, flags);
123
 
    
 
131
 
124
132
    /* comments */
125
133
 
126
134
    put_tag(s,"CONT");
127
 
    size = strlen(ctx->title) + strlen(ctx->author) + strlen(ctx->copyright) + 
 
135
    size = strlen(ctx->title) + strlen(ctx->author) + strlen(ctx->copyright) +
128
136
        strlen(ctx->comment) + 4 * 2 + 10;
129
137
    put_be32(s,size);
130
138
    put_be16(s,0);
132
140
    put_str(s, ctx->author);
133
141
    put_str(s, ctx->copyright);
134
142
    put_str(s, ctx->comment);
135
 
    
 
143
 
136
144
    for(i=0;i<ctx->nb_streams;i++) {
137
145
        int codec_data_size;
138
146
 
139
147
        stream = &rm->streams[i];
140
 
        
 
148
 
141
149
        if (stream->enc->codec_type == CODEC_TYPE_AUDIO) {
142
150
            desc = "The Audio Stream";
143
151
            mimetype = "audio/x-pn-realaudio";
158
166
        put_be32(s, stream->bit_rate); /* avg bit rate */
159
167
        put_be32(s, stream->packet_max_size);        /* max packet size */
160
168
        if (stream->nb_packets > 0)
161
 
            packet_avg_size = stream->packet_total_size / 
 
169
            packet_avg_size = stream->packet_total_size /
162
170
                stream->nb_packets;
163
171
        else
164
172
            packet_avg_size = 0;
173
181
        put_str8(s, desc);
174
182
        put_str8(s, mimetype);
175
183
        put_be32(s, codec_data_size);
176
 
        
 
184
 
177
185
        if (stream->enc->codec_type == CODEC_TYPE_AUDIO) {
178
186
            int coded_frame_size, fscode, sample_rate;
179
187
            sample_rate = stream->enc->sample_rate;
180
 
            coded_frame_size = (stream->enc->bit_rate * 
 
188
            coded_frame_size = (stream->enc->bit_rate *
181
189
                                stream->enc->frame_size) / (8 * sample_rate);
182
190
            /* audio codec info */
183
191
            put_tag(s, ".ra");
216
224
            put_be32(s, 0x249f0); /* unknown */
217
225
            put_be16(s, 0x01);
218
226
            /* frame length : seems to be very important */
219
 
            put_be16(s, coded_frame_size); 
 
227
            put_be16(s, coded_frame_size);
220
228
            put_be32(s, 0); /* unknown */
221
229
            put_be16(s, stream->enc->sample_rate); /* sample rate */
222
230
            put_be32(s, 0x10); /* unknown */
245
253
               versions seems to add a diffential DC coding as in
246
254
               MPEG... nothing new under the sun */
247
255
            if(stream->enc->codec_id == CODEC_ID_RV10)
248
 
                put_be32(s,0x10000000); 
 
256
                put_be32(s,0x10000000);
249
257
            else
250
 
                put_be32(s,0x20103001); 
251
 
            //put_be32(s,0x10003000); 
 
258
                put_be32(s,0x20103001);
 
259
            //put_be32(s,0x10003000);
252
260
        }
253
261
    }
254
262
 
259
267
    data_offset_ptr[1] = data_pos >> 16;
260
268
    data_offset_ptr[2] = data_pos >> 8;
261
269
    data_offset_ptr[3] = data_pos;
262
 
    
 
270
 
263
271
    /* data stream */
264
272
    put_tag(s,"DATA");
265
273
    put_be32(s,data_size + 10 + 8);
269
277
    put_be32(s,0); /* next data header */
270
278
}
271
279
 
272
 
static void write_packet_header(AVFormatContext *ctx, StreamInfo *stream, 
 
280
static void write_packet_header(AVFormatContext *ctx, StreamInfo *stream,
273
281
                                int length, int key_frame)
274
282
{
275
283
    int timestamp;
342
350
 
343
351
    /* XXX: suppress this malloc */
344
352
    buf1= (uint8_t*) av_malloc( size * sizeof(uint8_t) );
345
 
    
 
353
 
346
354
    write_packet_header(s, stream, size, !!(flags & PKT_FLAG_KEY));
347
 
    
 
355
 
348
356
    /* for AC3, the words seems to be reversed */
349
357
    for(i=0;i<size;i+=2) {
350
358
        buf1[i] = buf[i+1];
371
379
#if 1
372
380
    write_packet_header(s, stream, size + 7, key_frame);
373
381
    /* bit 7: '1' if final packet of a frame converted in several packets */
374
 
    put_byte(pb, 0x81); 
 
382
    put_byte(pb, 0x81);
375
383
    /* bit 7: '1' if I frame. bits 6..0 : sequence number in current
376
384
       frame starting from 1 */
377
385
    if (key_frame) {
378
 
        put_byte(pb, 0x81); 
 
386
        put_byte(pb, 0x81);
379
387
    } else {
380
 
        put_byte(pb, 0x01); 
 
388
        put_byte(pb, 0x01);
381
389
    }
382
390
    put_be16(pb, 0x4000 + (size)); /* total frame size */
383
391
    put_be16(pb, 0x4000 + (size));              /* offset from the start or the end */
384
392
#else
385
393
    /* full frame */
386
394
    write_packet_header(s, size + 6);
387
 
    put_byte(pb, 0xc0); 
 
395
    put_byte(pb, 0xc0);
388
396
    put_be16(pb, 0x4000 + size); /* total frame size */
389
397
    put_be16(pb, 0x4000 + packet_number * 126); /* position in stream */
390
398
#endif
391
 
    put_byte(pb, stream->nb_frames & 0xff); 
392
 
    
 
399
    put_byte(pb, stream->nb_frames & 0xff);
 
400
 
393
401
    put_buffer(pb, buf, size);
394
402
    put_flush_packet(pb);
395
403
 
399
407
 
400
408
static int rm_write_packet(AVFormatContext *s, AVPacket *pkt)
401
409
{
402
 
    if (s->streams[pkt->stream_index]->codec->codec_type == 
 
410
    if (s->streams[pkt->stream_index]->codec->codec_type ==
403
411
        CODEC_TYPE_AUDIO)
404
412
        return rm_write_audio(s, pkt->data, pkt->size, pkt->flags);
405
413
    else
406
414
        return rm_write_video(s, pkt->data, pkt->size, pkt->flags);
407
415
}
408
 
        
 
416
 
409
417
static int rm_write_trailer(AVFormatContext *s)
410
418
{
411
419
    RMContext *rm = s->priv_data;
421
429
        put_tag(pb, "INDX");
422
430
        put_be32(pb, 10 + 10 * s->nb_streams);
423
431
        put_be16(pb, 0);
424
 
        
 
432
 
425
433
        for(i=0;i<s->nb_streams;i++) {
426
434
            put_be32(pb, 0); /* zero indices */
427
435
            put_be16(pb, i); /* stream number */
430
438
        /* undocumented end header */
431
439
        put_be32(pb, 0);
432
440
        put_be32(pb, 0);
433
 
        
 
441
 
434
442
        url_fseek(pb, 0, SEEK_SET);
435
443
        for(i=0;i<s->nb_streams;i++)
436
444
            rm->streams[i].total_frames = rm->streams[i].nb_frames;
475
483
    *q = '\0';
476
484
}
477
485
 
478
 
static void rm_read_audio_stream_info(AVFormatContext *s, AVStream *st, 
 
486
static void rm_read_audio_stream_info(AVFormatContext *s, AVStream *st,
479
487
                                      int read_all)
480
488
{
 
489
    RMContext *rm = s->priv_data;
481
490
    ByteIOContext *pb = &s->pb;
482
 
    char buf[128];
 
491
    char buf[256];
483
492
    uint32_t version;
484
493
    int i;
485
494
 
486
495
    /* ra type header */
487
496
    version = get_be32(pb); /* version */
488
497
    if (((version >> 16) & 0xff) == 3) {
 
498
        int64_t startpos = url_ftell(pb);
489
499
        /* very old version */
490
500
        for(i = 0; i < 14; i++)
491
501
            get_byte(pb);
493
503
        get_str8(pb, s->author, sizeof(s->author));
494
504
        get_str8(pb, s->copyright, sizeof(s->copyright));
495
505
        get_str8(pb, s->comment, sizeof(s->comment));
 
506
        if ((startpos + (version & 0xffff)) >= url_ftell(pb) + 2) {
 
507
        // fourcc (should always be "lpcJ")
496
508
        get_byte(pb);
497
509
        get_str8(pb, buf, sizeof(buf));
 
510
        }
 
511
        // Skip extra header crap (this should never happen)
 
512
        if ((startpos + (version & 0xffff)) > url_ftell(pb))
 
513
            url_fskip(pb, (version & 0xffff) + startpos - url_ftell(pb));
498
514
        st->codec->sample_rate = 8000;
499
515
        st->codec->channels = 1;
500
516
        st->codec->codec_type = CODEC_TYPE_AUDIO;
501
517
        st->codec->codec_id = CODEC_ID_RA_144;
502
518
    } else {
503
 
        int flavor, sub_packet_h, coded_framesize;
 
519
        int flavor, sub_packet_h, coded_framesize, sub_packet_size;
504
520
        /* old version (4) */
505
521
        get_be32(pb); /* .ra4 */
506
522
        get_be32(pb); /* data size */
507
523
        get_be16(pb); /* version2 */
508
524
        get_be32(pb); /* header size */
509
525
        flavor= get_be16(pb); /* add codec info / flavor */
510
 
        coded_framesize= get_be32(pb); /* coded frame size */
511
 
        get_be32(pb); /* ??? */
512
 
        get_be32(pb); /* ??? */
513
 
        get_be32(pb); /* ??? */
514
 
        sub_packet_h= get_be16(pb); /* 1 */ 
 
526
        rm->coded_framesize = coded_framesize = get_be32(pb); /* coded frame size */
 
527
        get_be32(pb); /* ??? */
 
528
        get_be32(pb); /* ??? */
 
529
        get_be32(pb); /* ??? */
 
530
        rm->sub_packet_h = sub_packet_h = get_be16(pb); /* 1 */
515
531
        st->codec->block_align= get_be16(pb); /* frame size */
516
 
        get_be16(pb); /* sub packet size */
 
532
        rm->sub_packet_size = sub_packet_size = get_be16(pb); /* sub packet size */
517
533
        get_be16(pb); /* ??? */
 
534
        if (((version >> 16) & 0xff) == 5) {
 
535
            get_be16(pb); get_be16(pb); get_be16(pb); }
518
536
        st->codec->sample_rate = get_be16(pb);
519
537
        get_be32(pb);
520
538
        st->codec->channels = get_be16(pb);
521
 
        get_str8(pb, buf, sizeof(buf)); /* desc */
522
 
        get_str8(pb, buf, sizeof(buf)); /* desc */
 
539
        if (((version >> 16) & 0xff) == 5) {
 
540
            get_be32(pb);
 
541
            buf[0] = get_byte(pb);
 
542
            buf[1] = get_byte(pb);
 
543
            buf[2] = get_byte(pb);
 
544
            buf[3] = get_byte(pb);
 
545
            buf[4] = 0;
 
546
        } else {
 
547
        get_str8(pb, buf, sizeof(buf)); /* desc */
 
548
        get_str8(pb, buf, sizeof(buf)); /* desc */
 
549
        }
523
550
        st->codec->codec_type = CODEC_TYPE_AUDIO;
524
551
        if (!strcmp(buf, "dnet")) {
525
552
            st->codec->codec_id = CODEC_ID_AC3;
526
553
        } else if (!strcmp(buf, "28_8")) {
527
554
            st->codec->codec_id = CODEC_ID_RA_288;
528
 
            st->codec->extradata_size= 10;
529
 
            st->codec->extradata= av_mallocz(st->codec->extradata_size);
530
 
            /* this is completly braindead and broken, the idiot who added this codec and endianness
531
 
               specific reordering to mplayer and libavcodec/ra288.c should be drowned in a see of cola */
532
 
            //FIXME pass the unpermutated extradata
533
 
            ((uint16_t*)st->codec->extradata)[1]= sub_packet_h;
534
 
            ((uint16_t*)st->codec->extradata)[2]= flavor;
535
 
            ((uint16_t*)st->codec->extradata)[3]= coded_framesize;
 
555
            st->codec->extradata_size= 0;
 
556
            rm->audio_framesize = st->codec->block_align;
 
557
            st->codec->block_align = coded_framesize;
 
558
            rm->audiobuf = av_malloc(rm->audio_framesize * sub_packet_h);
 
559
        } else if (!strcmp(buf, "cook")) {
 
560
            int codecdata_length, i;
 
561
            get_be16(pb); get_byte(pb);
 
562
            if (((version >> 16) & 0xff) == 5)
 
563
                get_byte(pb);
 
564
            codecdata_length = get_be32(pb);
 
565
            st->codec->codec_id = CODEC_ID_COOK;
 
566
            st->codec->extradata_size= codecdata_length;
 
567
            st->codec->extradata= av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
 
568
            for(i = 0; i < codecdata_length; i++)
 
569
                ((uint8_t*)st->codec->extradata)[i] = get_byte(pb);
 
570
            rm->audio_framesize = st->codec->block_align;
 
571
            st->codec->block_align = rm->sub_packet_size;
 
572
            rm->audiobuf = av_malloc(rm->audio_framesize * sub_packet_h);
536
573
        } else {
537
574
            st->codec->codec_id = CODEC_ID_NONE;
538
575
            pstrcpy(st->codec->codec_name, sizeof(st->codec->codec_name),
542
579
            get_byte(pb);
543
580
            get_byte(pb);
544
581
            get_byte(pb);
545
 
            
 
582
 
546
583
            get_str8(pb, s->title, sizeof(s->title));
547
584
            get_str8(pb, s->author, sizeof(s->author));
548
585
            get_str8(pb, s->copyright, sizeof(s->copyright));
590
627
    get_be16(pb);
591
628
    get_be32(pb);
592
629
    get_be32(pb); /* number of headers */
593
 
    
 
630
 
594
631
    for(;;) {
595
632
        if (url_feof(pb))
596
633
            goto fail;
598
635
        tag_size = get_be32(pb);
599
636
        get_be16(pb);
600
637
#if 0
601
 
        printf("tag=%c%c%c%c (%08x) size=%d\n", 
 
638
        printf("tag=%c%c%c%c (%08x) size=%d\n",
602
639
               (tag) & 0xff,
603
640
               (tag >> 8) & 0xff,
604
641
               (tag >> 16) & 0xff,
676
713
                get_be32(pb);
677
714
                fps2= get_be16(pb);
678
715
                get_be16(pb);
679
 
                
 
716
 
680
717
                st->codec->extradata_size= codec_data_size - (url_ftell(pb) - codec_pos);
681
 
                st->codec->extradata= av_malloc(st->codec->extradata_size);
 
718
                st->codec->extradata= av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
682
719
                get_buffer(pb, st->codec->extradata, st->codec->extradata_size);
683
 
                
 
720
 
684
721
//                av_log(NULL, AV_LOG_DEBUG, "fps= %d fps2= %d\n", fps, fps2);
685
722
                st->codec->time_base.den = fps * st->codec->time_base.num;
686
723
                /* modification of h263 codec version (!) */
759
796
            *flags= 0;
760
797
        }else{
761
798
            state= (state<<8) + get_byte(pb);
762
 
            
 
799
 
763
800
            if(state == MKBETAG('I', 'N', 'D', 'X')){
764
801
                len = get_be16(pb) - 6;
765
802
                if(len<0)
766
803
                    continue;
767
804
                goto skip;
768
805
            }
769
 
            
 
806
 
770
807
            if(state > (unsigned)0xFFFF || state < 12)
771
808
                continue;
772
809
            len=state;
777
814
            res= get_byte(pb); /* reserved */
778
815
            *flags = get_byte(pb); /* flags */
779
816
 
780
 
            
 
817
 
781
818
            len -= 12;
782
819
        }
783
820
        for(i=0;i<s->nb_streams;i++) {
793
830
            continue;
794
831
        }
795
832
        *stream_index= i;
796
 
        
 
833
 
797
834
        return len;
798
835
    }
799
836
    return -1;
809
846
    uint8_t *ptr;
810
847
    int flags;
811
848
 
812
 
    if (rm->old_format) {
813
 
        /* just read raw bytes */
814
 
        len = RAW_PACKET_SIZE;
815
 
        len= av_get_packet(pb, pkt, len);
816
 
        pkt->stream_index = 0;
817
 
        if (len <= 0) {
818
 
            return AVERROR_IO;
819
 
        }
820
 
        pkt->size = len;
 
849
    if (rm->audio_pkt_cnt) {
 
850
        // If there are queued audio packet return them first
 
851
        st = s->streams[rm->audio_stream_num];
 
852
        av_new_packet(pkt, st->codec->block_align);
 
853
        memcpy(pkt->data, rm->audiobuf + st->codec->block_align *
 
854
               (rm->sub_packet_h * rm->audio_framesize / st->codec->block_align - rm->audio_pkt_cnt),
 
855
               st->codec->block_align);
 
856
        rm->audio_pkt_cnt--;
 
857
        pkt->flags = 0;
 
858
        pkt->stream_index = rm->audio_stream_num;
 
859
    } else if (rm->old_format) {
821
860
        st = s->streams[0];
 
861
        if (st->codec->codec_id == CODEC_ID_RA_288) {
 
862
            int x, y;
 
863
 
 
864
            for (y = 0; y < rm->sub_packet_h; y++)
 
865
                for (x = 0; x < rm->sub_packet_h/2; x++)
 
866
                    if (get_buffer(pb, rm->audiobuf+x*2*rm->audio_framesize+y*rm->coded_framesize, rm->coded_framesize) <= 0)
 
867
                        return AVERROR_IO;
 
868
            rm->audio_stream_num = 0;
 
869
            rm->audio_pkt_cnt = rm->sub_packet_h * rm->audio_framesize / st->codec->block_align - 1;
 
870
            // Release first audio packet
 
871
            av_new_packet(pkt, st->codec->block_align);
 
872
            memcpy(pkt->data, rm->audiobuf, st->codec->block_align);
 
873
            pkt->flags |= PKT_FLAG_KEY; // Mark first packet as keyframe
 
874
            pkt->stream_index = 0;
 
875
        } else {
 
876
            /* just read raw bytes */
 
877
            len = RAW_PACKET_SIZE;
 
878
            len= av_get_packet(pb, pkt, len);
 
879
            pkt->stream_index = 0;
 
880
            if (len <= 0) {
 
881
                return AVERROR_IO;
 
882
            }
 
883
            pkt->size = len;
 
884
        }
822
885
    } else {
823
886
        int seq=1;
824
887
resync:
850
913
            if(len2 && len2<len)
851
914
                len=len2;
852
915
            rm->remaining_len-= len;
 
916
            av_get_packet(pb, pkt, len);
 
917
        }
 
918
 
 
919
        if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
 
920
            if ((st->codec->codec_id == CODEC_ID_RA_288) ||
 
921
                (st->codec->codec_id == CODEC_ID_COOK)) {
 
922
                int x;
 
923
                int sps = rm->sub_packet_size;
 
924
                int cfs = rm->coded_framesize;
 
925
                int h = rm->sub_packet_h;
 
926
                int y = rm->sub_packet_cnt;
 
927
                int w = rm->audio_framesize;
 
928
 
 
929
                if (flags & 2)
 
930
                    y = rm->sub_packet_cnt = 0;
 
931
                if (!y)
 
932
                    rm->audiotimestamp = timestamp;
 
933
 
 
934
                switch(st->codec->codec_id) {
 
935
                    case CODEC_ID_RA_288:
 
936
                        for (x = 0; x < h/2; x++)
 
937
                            get_buffer(pb, rm->audiobuf+x*2*w+y*cfs, cfs);
 
938
                        break;
 
939
                    case CODEC_ID_COOK:
 
940
                        for (x = 0; x < w/sps; x++)
 
941
                            get_buffer(pb, rm->audiobuf+sps*(h*x+((h+1)/2)*(y&1)+(y>>1)), sps);
 
942
                        break;
 
943
                }
 
944
 
 
945
                if (++(rm->sub_packet_cnt) < h)
 
946
                    goto resync;
 
947
                else {
 
948
                    rm->sub_packet_cnt = 0;
 
949
                    rm->audio_stream_num = i;
 
950
                    rm->audio_pkt_cnt = h * w / st->codec->block_align - 1;
 
951
                    // Release first audio packet
 
952
                    av_new_packet(pkt, st->codec->block_align);
 
953
                    memcpy(pkt->data, rm->audiobuf, st->codec->block_align);
 
954
                    timestamp = rm->audiotimestamp;
 
955
                    flags = 2; // Mark first packet as keyframe
 
956
                }
 
957
            } else
 
958
                av_get_packet(pb, pkt, len);
853
959
        }
854
960
 
855
961
        if(  (st->discard >= AVDISCARD_NONKEY && !(flags&2))
856
962
           || st->discard >= AVDISCARD_ALL){
857
 
            url_fskip(pb, len);
 
963
            av_free_packet(pkt);
858
964
            goto resync;
859
965
        }
860
 
        
861
 
        av_get_packet(pb, pkt, len);
 
966
 
862
967
        pkt->stream_index = i;
863
968
 
864
969
#if 0
896
1001
 
897
1002
static int rm_read_close(AVFormatContext *s)
898
1003
{
 
1004
    RMContext *rm = s->priv_data;
 
1005
 
 
1006
    av_free(rm->audiobuf);
899
1007
    return 0;
900
1008
}
901
1009
 
914
1022
        return 0;
915
1023
}
916
1024
 
917
 
static int64_t rm_read_dts(AVFormatContext *s, int stream_index, 
 
1025
static int64_t rm_read_dts(AVFormatContext *s, int stream_index,
918
1026
                               int64_t *ppos, int64_t pos_limit)
919
1027
{
920
1028
    RMContext *rm = s->priv_data;
922
1030
    int stream_index2, flags, len, h;
923
1031
 
924
1032
    pos = *ppos;
925
 
    
 
1033
 
926
1034
    if(rm->old_format)
927
1035
        return AV_NOPTS_VALUE;
928
1036
 
943
1051
                seq = get_byte(&s->pb); len--;
944
1052
            }
945
1053
        }
946
 
            
 
1054
 
947
1055
        if((flags&2) && (seq&0x7F) == 1){
948
1056
//            av_log(s, AV_LOG_DEBUG, "%d %d-%d %Ld %d\n", flags, stream_index2, stream_index, dts, seq);
949
1057
            av_add_index_entry(st, pos, dts, 0, AVINDEX_KEYFRAME);