func: int ff_rm_read_mdpr_codecdata(AVFormatContext *s, AVIOContext *pb,
  
                                AVStream *st, RMStream *rst,
  
                                unsigned int codec_data_size, const uint8_t *mime)
  
  {
  
      unsigned int v;
  
      int size;
  
      int64_t codec_pos;
  
      int ret;
  
  
  
      if (codec_data_size > INT_MAX)
  
          return AVERROR_INVALIDDATA;
  
  
  
      avpriv_set_pts_info(st, 64, 1, 1000);
  
      codec_pos = avio_tell(pb);
  
      v = avio_rb32(pb);
  
  
  
      if (v == MKBETAG('M', 'L', 'T', 'I')) {
  
          int number_of_streams = avio_rb16(pb);
  
          int number_of_mdpr;
  
          int i;
  
          for (i = 0; i<number_of_streams; i++)
  
              avio_rb16(pb);
  
          number_of_mdpr = avio_rb16(pb);
  
          if (number_of_mdpr != 1) {
  
              avpriv_request_sample(s, "MLTI with multiple MDPR");
  
          }
  
          avio_rb32(pb);
  
          v = avio_rb32(pb);
  
      }
  
  
  
      if (v == MKTAG(0xfd, 'a', 'r', '.')) {
  
          /* ra type header */
  
          if (rm_read_audio_stream_info(s, pb, st, rst, 0))
  
              return -1;
  
      } else if (v == MKBETAG('L', 'S', 'D', ':')) {
  
          avio_seek(pb, -4, SEEK_CUR);
  
          if ((ret = rm_read_extradata(pb, st->codec, codec_data_size)) < 0)
  
              return ret;
  
  
  
          st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
  
          st->codec->codec_tag  = AV_RL32(st->codec->extradata);
  
          st->codec->codec_id   = ff_codec_get_id(ff_rm_codec_tags,
  
                                                  st->codec->codec_tag);
  
      } else if(mime && !strcmp(mime, "logical-fileinfo")){
  
          int stream_count, rule_count, property_count, i;
  
          ff_free_stream(s, st);
  
          if (avio_rb16(pb) != 0) {
  
              av_log(s, AV_LOG_WARNING, "Unsupported version\n");
  
              goto skip;
  
          }
  
          stream_count = avio_rb16(pb);
  
          avio_skip(pb, 6*stream_count);
  
          rule_count = avio_rb16(pb);
  
          avio_skip(pb, 2*rule_count);
  
          property_count = avio_rb16(pb);
  
          for(i=0; i<property_count; i++){
  
              uint8_t name[128], val[128];
  
              avio_rb32(pb);
  
              if (avio_rb16(pb) != 0) {
  
                  av_log(s, AV_LOG_WARNING, "Unsupported Name value property version\n");
  
                  goto skip; //FIXME skip just this one
  
              }
  
              get_str8(pb, name, sizeof(name));
  
              switch(avio_rb32(pb)) {
  
              case 2: get_strl(pb, val, sizeof(val), avio_rb16(pb));
  
                  av_dict_set(&s->metadata, name, val, 0);
  
                  break;
  
              default: avio_skip(pb, avio_rb16(pb));
  
              }
  
          }
  
      } else {
  
          int fps;
  
          if (avio_rl32(pb) != MKTAG('V', 'I', 'D', 'O')) {
  
          fail1:
  
              av_log(s, AV_LOG_WARNING, "Unsupported stream type %08x\n", v);
  
              goto skip;
  
          }
  
          st->codec->codec_tag = avio_rl32(pb);
  
          st->codec->codec_id  = ff_codec_get_id(ff_rm_codec_tags,
  
                                                 st->codec->codec_tag);
  
          av_dlog(s, "%X %X\n", st->codec->codec_tag, MKTAG('R', 'V', '2', '0'));
  
          if (st->codec->codec_id == AV_CODEC_ID_NONE)
  
              goto fail1;
  
          st->codec->width  = avio_rb16(pb);
  
          st->codec->height = avio_rb16(pb);
  
          avio_skip(pb, 2); // looks like bits per sample
  
          avio_skip(pb, 4); // always zero?
  
          st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
  
          st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
  
          fps = avio_rb32(pb);
  
  
  
          if ((ret = rm_read_extradata(pb, st->codec, codec_data_size - (avio_tell(pb) - codec_pos))) < 0)
  
              return ret;
  
  
  
          if (fps > 0) {
  
              av_reduce(&st->avg_frame_rate.den, &st->avg_frame_rate.num,
  
                        0x10000, fps, (1 << 30) - 1);
  
  #if FF_API_R_FRAME_RATE
  
              st->r_frame_rate = st->avg_frame_rate;
  
  #endif
  
          } else if (s->error_recognition & AV_EF_EXPLODE) {
  
              av_log(s, AV_LOG_ERROR, "Invalid framerate\n");
  
              return AVERROR_INVALIDDATA;
  
          }
  
      }
  
  
  
  skip:
  
      /* skip codec info */
  
      size = avio_tell(pb) - codec_pos;
  
      avio_skip(pb, codec_data_size - size);
  
  
  
      return 0;
  
  }
  