X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavformat%2Frmdec.c;h=ff93e515cd19bcaf3678bc2ba55c2f3a8717bd70;hb=08c8e66a996ddbb129f42e0fa121397b65b95aa9;hp=a6e520a7977c12051f5f4fb92c9cd3793438ef75;hpb=6a2d3fc30be6ba28531d9b57952cd93223e7a6c8;p=ffmpeg

diff --git a/libavformat/rmdec.c b/libavformat/rmdec.c
index a6e520a7977..ff93e515cd1 100644
--- a/libavformat/rmdec.c
+++ b/libavformat/rmdec.c
@@ -22,6 +22,7 @@
 #include "libavutil/avstring.h"
 #include "libavutil/intreadwrite.h"
 #include "avformat.h"
+#include "riff.h"
 #include "rm.h"
 
 struct RMStream {
@@ -48,6 +49,38 @@ typedef struct {
     int audio_pkt_cnt; ///< Output packet counter
 } RMDemuxContext;
 
+static const AVCodecTag rm_codec_tags[] = {
+    { CODEC_ID_RV10,   MKTAG('R','V','1','0') },
+    { CODEC_ID_RV20,   MKTAG('R','V','2','0') },
+    { CODEC_ID_RV20,   MKTAG('R','V','T','R') },
+    { CODEC_ID_RV30,   MKTAG('R','V','3','0') },
+    { CODEC_ID_RV40,   MKTAG('R','V','4','0') },
+    { CODEC_ID_AC3,    MKTAG('d','n','e','t') },
+    { CODEC_ID_RA_144, MKTAG('l','p','c','J') },
+    { CODEC_ID_RA_288, MKTAG('2','8','_','8') },
+    { CODEC_ID_COOK,   MKTAG('c','o','o','k') },
+    { CODEC_ID_ATRAC3, MKTAG('a','t','r','c') },
+    { CODEC_ID_SIPR,   MKTAG('s','i','p','r') },
+    { CODEC_ID_AAC,    MKTAG('r','a','a','c') },
+    { CODEC_ID_AAC,    MKTAG('r','a','c','p') },
+    { CODEC_ID_NONE },
+};
+
+static const unsigned char sipr_swaps[38][2] = {
+    {  0, 63 }, {  1, 22 }, {  2, 44 }, {  3, 90 },
+    {  5, 81 }, {  7, 31 }, {  8, 86 }, {  9, 58 },
+    { 10, 36 }, { 12, 68 }, { 13, 39 }, { 14, 73 },
+    { 15, 53 }, { 16, 69 }, { 17, 57 }, { 19, 88 },
+    { 20, 34 }, { 21, 71 }, { 24, 46 }, { 25, 94 },
+    { 26, 54 }, { 28, 75 }, { 29, 50 }, { 32, 70 },
+    { 33, 92 }, { 35, 74 }, { 38, 85 }, { 40, 56 },
+    { 42, 87 }, { 43, 65 }, { 45, 59 }, { 48, 79 },
+    { 49, 93 }, { 51, 89 }, { 55, 95 }, { 61, 76 },
+    { 67, 83 }, { 77, 80 }
+};
+
+static const unsigned char sipr_subpk_size[4] = { 29, 19, 37, 20 };
+
 static inline void get_strl(ByteIOContext *pb, char *buf, int buf_size, int len)
 {
     int i;
@@ -67,6 +100,20 @@ static void get_str8(ByteIOContext *pb, char *buf, int buf_size)
     get_strl(pb, buf, buf_size, get_byte(pb));
 }
 
+static int rm_read_extradata(ByteIOContext *pb, AVCodecContext *avctx, unsigned size)
+{
+    if (size >= 1<<24)
+        return -1;
+    avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
+    if (!avctx->extradata)
+        return AVERROR_NOMEM;
+    avctx->extradata_size = get_buffer(pb, avctx->extradata, size);
+    memset(avctx->extradata + avctx->extradata_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
+    if (avctx->extradata_size != size)
+        return AVERROR(EIO);
+    return 0;
+}
+
 static void rm_read_metadata(AVFormatContext *s, int wide)
 {
     char buf[1024];
@@ -95,28 +142,32 @@ static int rm_read_audio_stream_info(AVFormatContext *s, ByteIOContext *pb,
 {
     char buf[256];
     uint32_t version;
+    int ret;
 
     /* ra type header */
-    version = get_be32(pb); /* version */
-    if (((version >> 16) & 0xff) == 3) {
+    version = get_be16(pb); /* version */
+    if (version == 3) {
+        int header_size = get_be16(pb);
         int64_t startpos = url_ftell(pb);
         url_fskip(pb, 14);
         rm_read_metadata(s, 0);
-        if ((startpos + (version & 0xffff)) >= url_ftell(pb) + 2) {
+        if ((startpos + header_size) >= url_ftell(pb) + 2) {
             // fourcc (should always be "lpcJ")
             get_byte(pb);
             get_str8(pb, buf, sizeof(buf));
         }
         // Skip extra header crap (this should never happen)
-        if ((startpos + (version & 0xffff)) > url_ftell(pb))
-            url_fskip(pb, (version & 0xffff) + startpos - url_ftell(pb));
+        if ((startpos + header_size) > url_ftell(pb))
+            url_fskip(pb, header_size + startpos - url_ftell(pb));
         st->codec->sample_rate = 8000;
         st->codec->channels = 1;
         st->codec->codec_type = CODEC_TYPE_AUDIO;
         st->codec->codec_id = CODEC_ID_RA_144;
     } else {
         int flavor, sub_packet_h, coded_framesize, sub_packet_size;
+        int codecdata_length;
         /* old version (4) */
+        url_fskip(pb, 2); /* unused */
         get_be32(pb); /* .ra4 */
         get_be32(pb); /* data size */
         get_be16(pb); /* version2 */
@@ -130,13 +181,13 @@ static int rm_read_audio_stream_info(AVFormatContext *s, ByteIOContext *pb,
         st->codec->block_align= get_be16(pb); /* frame size */
         ast->sub_packet_size = sub_packet_size = get_be16(pb); /* sub packet size */
         get_be16(pb); /* ??? */
-        if (((version >> 16) & 0xff) == 5) {
+        if (version == 5) {
             get_be16(pb); get_be16(pb); get_be16(pb);
         }
         st->codec->sample_rate = get_be16(pb);
         get_be32(pb);
         st->codec->channels = get_be16(pb);
-        if (((version >> 16) & 0xff) == 5) {
+        if (version == 5) {
             get_be32(pb);
             get_buffer(pb, buf, 4);
             buf[4] = 0;
@@ -145,11 +196,13 @@ static int rm_read_audio_stream_info(AVFormatContext *s, ByteIOContext *pb,
             get_str8(pb, buf, sizeof(buf)); /* desc */
         }
         st->codec->codec_type = CODEC_TYPE_AUDIO;
-        if (!strcmp(buf, "dnet")) {
-            st->codec->codec_id = CODEC_ID_AC3;
+        st->codec->codec_tag  = AV_RL32(buf);
+        st->codec->codec_id   = ff_codec_get_id(rm_codec_tags, st->codec->codec_tag);
+        switch (st->codec->codec_id) {
+        case CODEC_ID_AC3:
             st->need_parsing = AVSTREAM_PARSE_FULL;
-        } else if (!strcmp(buf, "28_8")) {
-            st->codec->codec_id = CODEC_ID_RA_288;
+            break;
+        case CODEC_ID_RA_288:
             st->codec->extradata_size= 0;
             ast->audio_framesize = st->codec->block_align;
             st->codec->block_align = coded_framesize;
@@ -160,10 +213,12 @@ static int rm_read_audio_stream_info(AVFormatContext *s, ByteIOContext *pb,
             }
 
             av_new_packet(&ast->pkt, ast->audio_framesize * sub_packet_h);
-        } else if ((!strcmp(buf, "cook")) || (!strcmp(buf, "atrc")) || (!strcmp(buf, "sipr"))) {
-            int codecdata_length;
+            break;
+        case CODEC_ID_COOK:
+        case CODEC_ID_ATRAC3:
+        case CODEC_ID_SIPR:
             get_be16(pb); get_byte(pb);
-            if (((version >> 16) & 0xff) == 5)
+            if (version == 5)
                 get_byte(pb);
             codecdata_length = get_be32(pb);
             if(codecdata_length + FF_INPUT_BUFFER_PADDING_SIZE <= (unsigned)codecdata_length){
@@ -171,19 +226,27 @@ static int rm_read_audio_stream_info(AVFormatContext *s, ByteIOContext *pb,
                 return -1;
             }
 
-            if(sub_packet_size <= 0){
-                av_log(s, AV_LOG_ERROR, "sub_packet_size is invalid\n");
-                return -1;
-            }
-
             if (!strcmp(buf, "cook")) st->codec->codec_id = CODEC_ID_COOK;
             else if (!strcmp(buf, "sipr")) st->codec->codec_id = CODEC_ID_SIPR;
             else st->codec->codec_id = CODEC_ID_ATRAC3;
-            st->codec->extradata_size= codecdata_length;
-            st->codec->extradata= av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
-            get_buffer(pb, st->codec->extradata, st->codec->extradata_size);
+
             ast->audio_framesize = st->codec->block_align;
-            st->codec->block_align = ast->sub_packet_size;
+            if (st->codec->codec_id == CODEC_ID_SIPR) {
+                if (flavor > 3) {
+                    av_log(s, AV_LOG_ERROR, "bad SIPR file flavor %d\n",
+                           flavor);
+                    return -1;
+                }
+                st->codec->block_align = sipr_subpk_size[flavor];
+            } else {
+                if(sub_packet_size <= 0){
+                    av_log(s, AV_LOG_ERROR, "sub_packet_size is invalid\n");
+                    return -1;
+                }
+                st->codec->block_align = ast->sub_packet_size;
+            }
+            if ((ret = rm_read_extradata(pb, st->codec, codecdata_length)) < 0)
+                return ret;
 
             if(ast->audio_framesize >= UINT_MAX / sub_packet_h){
                 av_log(s, AV_LOG_ERROR, "rm->audio_framesize * sub_packet_h too large\n");
@@ -191,10 +254,10 @@ static int rm_read_audio_stream_info(AVFormatContext *s, ByteIOContext *pb,
             }
 
             av_new_packet(&ast->pkt, ast->audio_framesize * sub_packet_h);
-        } else if (!strcmp(buf, "raac") || !strcmp(buf, "racp")) {
-            int codecdata_length;
+            break;
+        case CODEC_ID_AAC:
             get_be16(pb); get_byte(pb);
-            if (((version >> 16) & 0xff) == 5)
+            if (version == 5)
                 get_byte(pb);
             st->codec->codec_id = CODEC_ID_AAC;
             codecdata_length = get_be32(pb);
@@ -203,13 +266,12 @@ static int rm_read_audio_stream_info(AVFormatContext *s, ByteIOContext *pb,
                 return -1;
             }
             if (codecdata_length >= 1) {
-                st->codec->extradata_size = codecdata_length - 1;
-                st->codec->extradata = av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
                 get_byte(pb);
-                get_buffer(pb, st->codec->extradata, st->codec->extradata_size);
+                if ((ret = rm_read_extradata(pb, st->codec, codecdata_length - 1)) < 0)
+                    return ret;
             }
-        } else {
-            st->codec->codec_id = CODEC_ID_NONE;
+            break;
+        default:
             av_strlcpy(st->codec->codec_name, buf, sizeof(st->codec->codec_name));
         }
         if (read_all) {
@@ -229,6 +291,7 @@ ff_rm_read_mdpr_codecdata (AVFormatContext *s, ByteIOContext *pb,
     unsigned int v;
     int size;
     int64_t codec_pos;
+    int ret;
 
     av_set_pts_info(st, 64, 1, 1000);
     codec_pos = url_ftell(pb);
@@ -245,12 +308,9 @@ ff_rm_read_mdpr_codecdata (AVFormatContext *s, ByteIOContext *pb,
             goto skip;
         }
         st->codec->codec_tag = get_le32(pb);
+        st->codec->codec_id  = ff_codec_get_id(rm_codec_tags, st->codec->codec_tag);
 //        av_log(s, AV_LOG_DEBUG, "%X %X\n", st->codec->codec_tag, MKTAG('R', 'V', '2', '0'));
-        if (   st->codec->codec_tag != MKTAG('R', 'V', '1', '0')
-            && st->codec->codec_tag != MKTAG('R', 'V', '2', '0')
-            && st->codec->codec_tag != MKTAG('R', 'V', '3', '0')
-            && st->codec->codec_tag != MKTAG('R', 'V', '4', '0')
-            && st->codec->codec_tag != MKTAG('R', 'V', 'T', 'R'))
+        if (st->codec->codec_id == CODEC_ID_NONE)
             goto fail1;
         st->codec->width = get_be16(pb);
         st->codec->height = get_be16(pb);
@@ -261,26 +321,20 @@ ff_rm_read_mdpr_codecdata (AVFormatContext *s, ByteIOContext *pb,
         fps2= get_be16(pb);
         get_be16(pb);
 
-        st->codec->extradata_size= codec_data_size - (url_ftell(pb) - codec_pos);
-
-        if(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE <= (unsigned)st->codec->extradata_size){
-            //check is redundant as get_buffer() will catch this
-            av_log(s, AV_LOG_ERROR, "st->codec->extradata_size too large\n");
-            return -1;
-        }
-        st->codec->extradata= av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
-        if (!st->codec->extradata)
-            return AVERROR(ENOMEM);
-        get_buffer(pb, st->codec->extradata, st->codec->extradata_size);
+        if ((ret = rm_read_extradata(pb, st->codec, codec_data_size - (url_ftell(pb) - codec_pos))) < 0)
+            return ret;
 
 //        av_log(s, AV_LOG_DEBUG, "fps= %d fps2= %d\n", fps, fps2);
         st->codec->time_base.den = fps * st->codec->time_base.num;
-        switch(((uint8_t*)st->codec->extradata)[4]>>4){
+        //XXX: do we really need that?
+        switch(st->codec->extradata[4]>>4){
         case 1: st->codec->codec_id = CODEC_ID_RV10; break;
         case 2: st->codec->codec_id = CODEC_ID_RV20; break;
         case 3: st->codec->codec_id = CODEC_ID_RV30; break;
         case 4: st->codec->codec_id = CODEC_ID_RV40; break;
-        default: goto fail1;
+        default:
+            av_log(st->codec, AV_LOG_ERROR, "extra:%02X %02X %02X %02X %02X\n", st->codec->extradata[0], st->codec->extradata[1], st->codec->extradata[2], st->codec->extradata[3], st->codec->extradata[4]);
+            goto fail1;
         }
     }
 
@@ -292,6 +346,49 @@ skip:
     return 0;
 }
 
+/** this function assumes that the demuxer has already seeked to the start
+ * of the INDX chunk, and will bail out if not. */
+static int rm_read_index(AVFormatContext *s)
+{
+    ByteIOContext *pb = s->pb;
+    unsigned int size, n_pkts, str_id, next_off, n, pos, pts;
+    AVStream *st;
+
+    do {
+        if (get_le32(pb) != MKTAG('I','N','D','X'))
+            return -1;
+        size     = get_be32(pb);
+        if (size < 20)
+            return -1;
+        url_fskip(pb, 2);
+        n_pkts   = get_be32(pb);
+        str_id   = get_be16(pb);
+        next_off = get_be32(pb);
+        for (n = 0; n < s->nb_streams; n++)
+            if (s->streams[n]->id == str_id) {
+                st = s->streams[n];
+                break;
+            }
+        if (n == s->nb_streams)
+            goto skip;
+
+        for (n = 0; n < n_pkts; n++) {
+            url_fskip(pb, 2);
+            pts = get_be32(pb);
+            pos = get_be32(pb);
+            url_fskip(pb, 4); /* packet no. */
+
+            av_add_index_entry(st, pos, pts, 0, 0, AVINDEX_KEYFRAME);
+        }
+
+skip:
+        if (next_off && url_ftell(pb) != next_off &&
+            url_fseek(pb, next_off, SEEK_SET) < 0)
+            return -1;
+    } while (next_off);
+
+    return 0;
+}
 
 static int rm_read_header_old(AVFormatContext *s, AVFormatParameters *ap)
 {
@@ -314,6 +411,7 @@ static int rm_read_header(AVFormatContext *s, AVFormatParameters *ap)
     unsigned int tag;
     int tag_size;
     unsigned int start_time, duration;
+    unsigned int data_off = 0, indx_off = 0;
     char buf[128];
     int flags = 0;
 
@@ -357,8 +455,8 @@ static int rm_read_header(AVFormatContext *s, AVFormatParameters *ap)
             get_be32(pb); /* nb packets */
             get_be32(pb); /* duration */
             get_be32(pb); /* preroll */
-            get_be32(pb); /* index offset */
-            get_be32(pb); /* data offset */
+            indx_off = get_be32(pb); /* index offset */
+            data_off = get_be32(pb); /* data offset */
             get_be16(pb); /* nb streams */
             flags = get_be16(pb); /* flags */
             break;
@@ -400,6 +498,14 @@ static int rm_read_header(AVFormatContext *s, AVFormatParameters *ap)
     if (!rm->nb_packets && (flags & 4))
         rm->nb_packets = 3600 * 25;
     get_be32(pb); /* next data header */
+
+    if (!data_off)
+        data_off = url_ftell(pb) - 18;
+    if (indx_off && url_fseek(pb, indx_off, SEEK_SET) >= 0) {
+        rm_read_index(s);
+        url_fseek(pb, data_off + 18, SEEK_SET);
+    }
+
     return 0;
 }
 
@@ -425,11 +531,11 @@ static int get_num(ByteIOContext *pb, int *len)
 static int sync(AVFormatContext *s, int64_t *timestamp, int *flags, int *stream_index, int64_t *pos){
     RMDemuxContext *rm = s->priv_data;
     ByteIOContext *pb = s->pb;
-    int len, num, res, i;
     AVStream *st;
     uint32_t state=0xFFFFFFFF;
 
     while(!url_feof(pb)){
+        int len, num, res, i;
         *pos= url_ftell(pb) - 3;
         if(rm->remaining_len > 0){
             num= rm->current_stream;
@@ -458,18 +564,15 @@ static int sync(AVFormatContext *s, int64_t *timestamp, int *flags, int *stream_
                 goto skip;
             }
 
-            if(state > (unsigned)0xFFFF || state < 12)
+            if(state > (unsigned)0xFFFF || state <= 12)
                 continue;
-            len=state;
+            len=state - 12;
             state= 0xFFFFFFFF;
 
             num = get_be16(pb);
             *timestamp = get_be32(pb);
             res= get_byte(pb); /* reserved */
             *flags = get_byte(pb); /* flags */
-
-
-            len -= 12;
         }
         for(i=0;i<s->nb_streams;i++) {
             st = s->streams[i];
@@ -564,6 +667,7 @@ static int rm_assemble_video_frame(AVFormatContext *s, ByteIOContext *pb,
         pkt->size = vst->videobufpos + 8*(vst->cur_slice - vst->slices);
         pkt->pts = AV_NOPTS_VALUE;
         pkt->pos = vst->pktpos;
+        vst->slices = 0;
         return 0;
     }
 
@@ -585,10 +689,38 @@ rm_ac3_swap_bytes (AVStream *st, AVPacket *pkt)
     }
 }
 
+/**
+ * Perform 4-bit block reordering for SIPR data.
+ * @todo This can be optimized, e.g. use memcpy() if data blocks are aligned
+ */
+static void
+rm_reorder_sipr_data (RMStream *ast)
+{
+    int n, bs = ast->sub_packet_h * ast->audio_framesize * 2 / 96; // nibbles per subpacket
+
+    for (n = 0; n < 38; n++) {
+        int j;
+        int i = bs * sipr_swaps[n][0];
+        int o = bs * sipr_swaps[n][1];
+        uint8_t *buf = ast->pkt.data;
+
+        /* swap 4bit-nibbles of block 'i' with 'o' */
+        for (j = 0; j < bs; j++, i++, o++) {
+            int x = (buf[i >> 1] >> (4 * (i & 1))) & 0xF,
+                y = (buf[o >> 1] >> (4 * (o & 1))) & 0xF;
+
+            buf[o >> 1] = (x << (4 * (o & 1))) |
+                (buf[o >> 1] & (0xF << (4 * !(o & 1))));
+            buf[i >> 1] = (y << (4 * (i & 1))) |
+                (buf[i >> 1] & (0xF << (4 * !(i & 1))));
+        }
+    }
+}
+
 int
 ff_rm_parse_packet (AVFormatContext *s, ByteIOContext *pb,
                     AVStream *st, RMStream *ast, int len, AVPacket *pkt,
-                    int *seq, int *flags, int64_t *timestamp)
+                    int *seq, int flags, int64_t timestamp)
 {
     RMDemuxContext *rm = s->priv_data;
 
@@ -608,10 +740,10 @@ ff_rm_parse_packet (AVFormatContext *s, ByteIOContext *pb,
             int y = ast->sub_packet_cnt;
             int w = ast->audio_framesize;
 
-            if (*flags & 2)
+            if (flags & 2)
                 y = ast->sub_packet_cnt = 0;
             if (!y)
-                ast->audiotimestamp = *timestamp;
+                ast->audiotimestamp = timestamp;
 
             switch(st->codec->codec_id) {
                 case CODEC_ID_RA_288:
@@ -623,20 +755,19 @@ ff_rm_parse_packet (AVFormatContext *s, ByteIOContext *pb,
                     for (x = 0; x < w/sps; x++)
                         get_buffer(pb, ast->pkt.data+sps*(h*x+((h+1)/2)*(y&1)+(y>>1)), sps);
                     break;
+                case CODEC_ID_SIPR:
+                    get_buffer(pb, ast->pkt.data + y * w, w);
+                    break;
             }
 
             if (++(ast->sub_packet_cnt) < h)
                 return -1;
-            else {
-                ast->sub_packet_cnt = 0;
-                rm->audio_stream_num = st->index;
-                rm->audio_pkt_cnt = h * w / st->codec->block_align - 1;
-                // Release first audio packet
-                av_new_packet(pkt, st->codec->block_align);
-                memcpy(pkt->data, ast->pkt.data, st->codec->block_align); //FIXME avoid this
-                *timestamp = ast->audiotimestamp;
-                *flags = 2; // Mark first packet as keyframe
-            }
+            if (st->codec->codec_id == CODEC_ID_SIPR)
+                rm_reorder_sipr_data(ast);
+
+             ast->sub_packet_cnt = 0;
+             rm->audio_stream_num = st->index;
+             rm->audio_pkt_cnt = h * w / st->codec->block_align;
         } else if (st->codec->codec_id == CODEC_ID_AAC) {
             int x;
             rm->audio_stream_num = st->index;
@@ -644,11 +775,10 @@ ff_rm_parse_packet (AVFormatContext *s, ByteIOContext *pb,
             if (ast->sub_packet_cnt) {
                 for (x = 0; x < ast->sub_packet_cnt; x++)
                     ast->sub_packet_lengths[x] = get_be16(pb);
-                // Release first audio packet
-                rm->audio_pkt_cnt = ast->sub_packet_cnt - 1;
-                av_get_packet(pb, pkt, ast->sub_packet_lengths[0]);
-                *flags = 2; // Mark first packet as keyframe
-            }
+                rm->audio_pkt_cnt = ast->sub_packet_cnt;
+                ast->audiotimestamp = timestamp;
+            } else
+                return -1;
         } else {
             av_get_packet(pb, pkt, len);
             rm_ac3_swap_bytes(st, pkt);
@@ -664,15 +794,15 @@ ff_rm_parse_packet (AVFormatContext *s, ByteIOContext *pb,
             int seq= 128*(pkt->data[2]&0x7F) + (pkt->data[3]>>1);
             av_log(s, AV_LOG_DEBUG, "%d %"PRId64" %d\n", *timestamp, *timestamp*512LL/25, seq);
 
-            seq |= (*timestamp&~0x3FFF);
-            if(seq - *timestamp >  0x2000) seq -= 0x4000;
-            if(seq - *timestamp < -0x2000) seq += 0x4000;
+            seq |= (timestamp&~0x3FFF);
+            if(seq - timestamp >  0x2000) seq -= 0x4000;
+            if(seq - timestamp < -0x2000) seq += 0x4000;
         }
     }
 #endif
 
-    pkt->pts= *timestamp;
-    if (*flags & 2)
+    pkt->pts= timestamp;
+    if (flags & 2)
         pkt->flags |= PKT_FLAG_KEY;
 
     return st->codec->codec_type == CODEC_TYPE_AUDIO ? rm->audio_pkt_cnt : 0;
@@ -695,7 +825,11 @@ ff_rm_retrieve_cache (AVFormatContext *s, ByteIOContext *pb,
                st->codec->block_align);
     }
     rm->audio_pkt_cnt--;
-    pkt->flags = 0;
+    if ((pkt->pts = ast->audiotimestamp) != AV_NOPTS_VALUE) {
+        ast->audiotimestamp = AV_NOPTS_VALUE;
+        pkt->flags = PKT_FLAG_KEY;
+    } else
+        pkt->flags = 0;
     pkt->stream_index = st->index;
 
     return rm->audio_pkt_cnt;
@@ -707,36 +841,36 @@ static int rm_read_packet(AVFormatContext *s, AVPacket *pkt)
     AVStream *st;
     int i, len, res, seq = 1;
     int64_t timestamp, pos;
-    int old_flags, flags;
+    int flags;
 
     for (;;) {
-    if (rm->audio_pkt_cnt) {
-        // If there are queued audio packet return them first
-        st = s->streams[rm->audio_stream_num];
-        ff_rm_retrieve_cache(s, s->pb, st, st->priv_data, pkt);
+        if (rm->audio_pkt_cnt) {
+            // If there are queued audio packet return them first
+            st = s->streams[rm->audio_stream_num];
+            ff_rm_retrieve_cache(s, s->pb, st, st->priv_data, pkt);
         } else {
             if (rm->old_format) {
-        RMStream *ast;
+                RMStream *ast;
 
-        st = s->streams[0];
-        ast = st->priv_data;
+                st = s->streams[0];
+                ast = st->priv_data;
                 timestamp = AV_NOPTS_VALUE;
                 len = !ast->audio_framesize ? RAW_PACKET_SIZE :
                     ast->coded_framesize * ast->sub_packet_h / 2;
                 flags = (seq++ == 1) ? 2 : 0;
-    } else {
-        len=sync(s, &timestamp, &flags, &i, &pos);
-        st = s->streams[i];
+            } else {
+                len=sync(s, &timestamp, &flags, &i, &pos);
+                if (len > 0)
+                    st = s->streams[i];
             }
 
             if(len<0 || url_feof(s->pb))
                 return AVERROR(EIO);
 
-        old_flags = flags;
-        res = ff_rm_parse_packet (s, s->pb, st, st->priv_data, len, pkt,
-                                  &seq, &flags, &timestamp);
-        if((old_flags&2) && (seq&0x7F) == 1)
-            av_add_index_entry(st, pos, timestamp, 0, 0, AVINDEX_KEYFRAME);
+            res = ff_rm_parse_packet (s, s->pb, st, st->priv_data, len, pkt,
+                                      &seq, flags, timestamp);
+            if((flags&2) && (seq&0x7F) == 1)
+                av_add_index_entry(st, pos, timestamp, 0, 0, AVINDEX_KEYFRAME);
             if (res)
                 continue;
         }