FFmpeg
rmdec.c
Go to the documentation of this file.
1 /*
2  * "Real" compatible demuxer.
3  * Copyright (c) 2000, 2001 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include <inttypes.h>
23 
24 #include "libavutil/avassert.h"
26 #include "libavutil/internal.h"
27 #include "libavutil/intreadwrite.h"
28 #include "libavutil/dict.h"
29 #include "libavutil/mem.h"
30 #include "avformat.h"
31 #include "avio_internal.h"
32 #include "demux.h"
33 #include "internal.h"
34 #include "rmsipr.h"
35 #include "rm.h"
36 
37 #define DEINT_ID_GENR MKTAG('g', 'e', 'n', 'r') ///< interleaving for Cooker/ATRAC
38 #define DEINT_ID_INT0 MKTAG('I', 'n', 't', '0') ///< no interleaving needed
39 #define DEINT_ID_INT4 MKTAG('I', 'n', 't', '4') ///< interleaving for 28.8
40 #define DEINT_ID_SIPR MKTAG('s', 'i', 'p', 'r') ///< interleaving for Sipro
41 #define DEINT_ID_VBRF MKTAG('v', 'b', 'r', 'f') ///< VBR case for AAC
42 #define DEINT_ID_VBRS MKTAG('v', 'b', 'r', 's') ///< VBR case for AAC
43 
44 struct RMStream {
45  AVPacket pkt; ///< place to store merged video frame / reordered audio data
46  int videobufsize; ///< current assembled frame size
47  int videobufpos; ///< position for the next slice in the video buffer
48  int curpic_num; ///< picture number of current frame
50  int64_t pktpos; ///< first slice position in file
51  /// Audio descrambling matrix parameters
52  int64_t audiotimestamp; ///< Audio packet timestamp
53  int sub_packet_cnt; // Subpacket counter, used while reading
54  int sub_packet_size, sub_packet_h, coded_framesize; ///< Descrambling parameters from container
55  int audio_framesize; ///< Audio frame size from container
56  int sub_packet_lengths[16]; ///< Length of each subpacket
57  int32_t deint_id; ///< deinterleaver used in audio stream
58 };
59 
60 typedef struct RMDemuxContext {
65  int audio_stream_num; ///< Stream number for audio packets
66  int audio_pkt_cnt; ///< Output packet counter
67  int data_end;
69 
70 static inline void get_strl(AVIOContext *pb, char *buf, int buf_size, int len)
71 {
72  int read = avio_get_str(pb, len, buf, buf_size);
73 
74  if (read > 0)
75  avio_skip(pb, len - read);
76 }
77 
78 static void get_str8(AVIOContext *pb, char *buf, int buf_size)
79 {
80  get_strl(pb, buf, buf_size, avio_r8(pb));
81 }
82 
84 {
85  if (size >= 1<<24) {
86  av_log(s, AV_LOG_ERROR, "extradata size %u too large\n", size);
87  return -1;
88  }
89  return ff_get_extradata(s, par, pb, size);
90 }
91 
92 static void rm_read_metadata(AVFormatContext *s, AVIOContext *pb, int wide)
93 {
94  char buf[1024];
95  int i;
96 
97  for (i=0; i<FF_ARRAY_ELEMS(ff_rm_metadata); i++) {
98  int len = wide ? avio_rb16(pb) : avio_r8(pb);
99  if (len > 0) {
100  get_strl(pb, buf, sizeof(buf), len);
101  av_dict_set(&s->metadata, ff_rm_metadata[i], buf, 0);
102  }
103  }
104 }
105 
107 {
108  RMStream *rms = av_mallocz(sizeof(RMStream));
109  if (!rms)
110  return NULL;
111  rms->curpic_num = -1;
112  return rms;
113 }
114 
116 {
117  if (!rms)
118  return;
119 
120  av_packet_unref(&rms->pkt);
121 }
122 
124  AVStream *st, RMStream *ast, int read_all)
125 {
126  FFStream *const sti = ffstream(st);
127  char buf[256];
128  uint32_t version;
129  int ret;
130 
131  /* ra type header */
132  version = avio_rb16(pb); /* version */
133  if (version == 3) {
134  unsigned bytes_per_minute;
135  int header_size = avio_rb16(pb);
136  int64_t startpos = avio_tell(pb);
137  avio_skip(pb, 8);
138  bytes_per_minute = avio_rb16(pb);
139  avio_skip(pb, 4);
140  rm_read_metadata(s, pb, 0);
141  if ((startpos + header_size) >= avio_tell(pb) + 2) {
142  // fourcc (should always be "lpcJ")
143  avio_r8(pb);
144  get_str8(pb, buf, sizeof(buf));
145  }
146  // Skip extra header crap (this should never happen)
147  if ((startpos + header_size) > avio_tell(pb))
148  avio_skip(pb, header_size + startpos - avio_tell(pb));
149  if (bytes_per_minute)
150  st->codecpar->bit_rate = 8LL * bytes_per_minute / 60;
151  st->codecpar->sample_rate = 8000;
155  ast->deint_id = DEINT_ID_INT0;
156  } else {
157  int flavor, sub_packet_h, coded_framesize, sub_packet_size;
158  int codecdata_length;
159  unsigned bytes_per_minute;
160  /* old version (4) */
161  avio_skip(pb, 2); /* unused */
162  avio_rb32(pb); /* .ra4 */
163  avio_rb32(pb); /* data size */
164  avio_rb16(pb); /* version2 */
165  avio_rb32(pb); /* header size */
166  flavor= avio_rb16(pb); /* add codec info / flavor */
167  coded_framesize = avio_rb32(pb); /* coded frame size */
168  if (coded_framesize < 0)
169  return AVERROR_INVALIDDATA;
170  ast->coded_framesize = coded_framesize;
171 
172  avio_rb32(pb); /* ??? */
173  bytes_per_minute = avio_rb32(pb);
174  if (version == 4) {
175  if (bytes_per_minute)
176  st->codecpar->bit_rate = 8LL * bytes_per_minute / 60;
177  }
178  avio_rb32(pb); /* ??? */
179  ast->sub_packet_h = sub_packet_h = avio_rb16(pb); /* 1 */
180  st->codecpar->block_align= avio_rb16(pb); /* frame size */
181  ast->sub_packet_size = sub_packet_size = avio_rb16(pb); /* sub packet size */
182  avio_rb16(pb); /* ??? */
183  if (version == 5) {
184  avio_rb16(pb); avio_rb16(pb); avio_rb16(pb);
185  }
186  st->codecpar->sample_rate = avio_rb16(pb);
187  avio_rb32(pb);
189  if (version == 5) {
190  ast->deint_id = avio_rl32(pb);
191  avio_read(pb, buf, 4);
192  buf[4] = 0;
193  } else {
194  AV_WL32(buf, 0);
195  get_str8(pb, buf, sizeof(buf)); /* desc */
196  ast->deint_id = AV_RL32(buf);
197  get_str8(pb, buf, sizeof(buf)); /* desc */
198  }
200  st->codecpar->codec_tag = AV_RL32(buf);
202  st->codecpar->codec_tag);
203 
204  switch (st->codecpar->codec_id) {
205  case AV_CODEC_ID_AC3:
207  break;
208  case AV_CODEC_ID_RA_288:
209  st->codecpar->extradata_size= 0;
210  av_freep(&st->codecpar->extradata);
212  st->codecpar->block_align = coded_framesize;
213  break;
214  case AV_CODEC_ID_COOK:
216  case AV_CODEC_ID_ATRAC3:
217  case AV_CODEC_ID_SIPR:
218  if (read_all) {
219  codecdata_length = 0;
220  } else {
221  avio_rb16(pb); avio_r8(pb);
222  if (version == 5)
223  avio_r8(pb);
224  codecdata_length = avio_rb32(pb);
225  if((unsigned)codecdata_length > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE){
226  av_log(s, AV_LOG_ERROR, "codecdata_length too large\n");
227  return -1;
228  }
229  }
230 
232  if (st->codecpar->codec_id == AV_CODEC_ID_SIPR) {
233  if (flavor > 3) {
234  av_log(s, AV_LOG_ERROR, "bad SIPR file flavor %d\n",
235  flavor);
236  return -1;
237  }
238  st->codecpar->block_align = ff_sipr_subpk_size[flavor];
240  } else {
241  if(sub_packet_size <= 0){
242  av_log(s, AV_LOG_ERROR, "sub_packet_size is invalid\n");
243  return -1;
244  }
246  }
247  if ((ret = rm_read_extradata(s, pb, st->codecpar, codecdata_length)) < 0)
248  return ret;
249 
250  break;
251  case AV_CODEC_ID_AAC:
252  avio_rb16(pb); avio_r8(pb);
253  if (version == 5)
254  avio_r8(pb);
255  codecdata_length = avio_rb32(pb);
256  if((unsigned)codecdata_length > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE){
257  av_log(s, AV_LOG_ERROR, "codecdata_length too large\n");
258  return -1;
259  }
260  if (codecdata_length >= 1) {
261  avio_r8(pb);
262  if ((ret = rm_read_extradata(s, pb, st->codecpar, codecdata_length - 1)) < 0)
263  return ret;
264  }
265  break;
266  }
267  switch (ast->deint_id) {
268  case DEINT_ID_INT4:
269  if (ast->coded_framesize > ast->audio_framesize ||
270  sub_packet_h <= 1 ||
271  ast->coded_framesize * (uint64_t)sub_packet_h > (2LL + (sub_packet_h & 1)) * ast->audio_framesize)
272  return AVERROR_INVALIDDATA;
273  if (ast->coded_framesize * (uint64_t)sub_packet_h != 2LL*ast->audio_framesize) {
274  avpriv_request_sample(s, "mismatching interleaver parameters");
275  return AVERROR_INVALIDDATA;
276  }
277  break;
278  case DEINT_ID_GENR:
279  if (ast->sub_packet_size <= 0 ||
280  ast->sub_packet_size > ast->audio_framesize)
281  return AVERROR_INVALIDDATA;
282  if (ast->audio_framesize % ast->sub_packet_size)
283  return AVERROR_INVALIDDATA;
284  break;
285  case DEINT_ID_SIPR:
286  case DEINT_ID_INT0:
287  case DEINT_ID_VBRS:
288  case DEINT_ID_VBRF:
289  break;
290  default:
291  av_log(s, AV_LOG_ERROR ,"Unknown interleaver %"PRIX32"\n", ast->deint_id);
292  return AVERROR_INVALIDDATA;
293  }
294  if (ast->deint_id == DEINT_ID_INT4 ||
295  ast->deint_id == DEINT_ID_GENR ||
296  ast->deint_id == DEINT_ID_SIPR) {
297  if (st->codecpar->block_align <= 0 ||
298  ast->audio_framesize * (uint64_t)sub_packet_h > (unsigned)INT_MAX ||
299  ast->audio_framesize * sub_packet_h < st->codecpar->block_align)
300  return AVERROR_INVALIDDATA;
301  if (av_new_packet(&ast->pkt, ast->audio_framesize * sub_packet_h) < 0)
302  return AVERROR(ENOMEM);
303  }
304 
305  if (read_all) {
306  avio_r8(pb);
307  avio_r8(pb);
308  avio_r8(pb);
309  rm_read_metadata(s, pb, 0);
310  }
311  }
312  return 0;
313 }
314 
316  AVStream *st, RMStream *rst,
317  unsigned int codec_data_size, const uint8_t *mime)
318 {
319  unsigned int v;
320  int size;
321  int64_t codec_pos;
322  int ret;
323 
324  if (codec_data_size > INT_MAX)
325  return AVERROR_INVALIDDATA;
326  if (codec_data_size == 0)
327  return 0;
328 
329  // Duplicate tags
332  return AVERROR_INVALIDDATA;
333 
334  avpriv_set_pts_info(st, 64, 1, 1000);
335  codec_pos = avio_tell(pb);
336  v = avio_rb32(pb);
337 
338  if (v == MKTAG(0xfd, 'a', 'r', '.')) {
339  /* ra type header */
340  if (rm_read_audio_stream_info(s, pb, st, rst, 0))
341  return -1;
342  } else if (v == MKBETAG('L', 'S', 'D', ':')) {
343  avio_seek(pb, -4, SEEK_CUR);
344  if ((ret = rm_read_extradata(s, pb, st->codecpar, codec_data_size)) < 0)
345  return ret;
346 
350  st->codecpar->codec_tag);
351  } else if(mime && !strcmp(mime, "logical-fileinfo")){
352  int stream_count, rule_count, property_count, i;
353  ff_remove_stream(s, st);
354  if (avio_rb16(pb) != 0) {
355  av_log(s, AV_LOG_WARNING, "Unsupported version\n");
356  goto skip;
357  }
358  stream_count = avio_rb16(pb);
359  avio_skip(pb, 6*stream_count);
360  rule_count = avio_rb16(pb);
361  avio_skip(pb, 2*rule_count);
362  property_count = avio_rb16(pb);
363  for(i=0; i<property_count; i++){
364  uint8_t name[128], val[128];
365  avio_rb32(pb);
366  if (avio_rb16(pb) != 0) {
367  av_log(s, AV_LOG_WARNING, "Unsupported Name value property version\n");
368  goto skip; //FIXME skip just this one
369  }
370  get_str8(pb, name, sizeof(name));
371  switch(avio_rb32(pb)) {
372  case 2: get_strl(pb, val, sizeof(val), avio_rb16(pb));
373  av_dict_set(&s->metadata, name, val, 0);
374  break;
375  default: avio_skip(pb, avio_rb16(pb));
376  }
377  }
378  } else {
379  int fps;
380  if (avio_rl32(pb) != MKTAG('V', 'I', 'D', 'O')) {
381  fail1:
382  av_log(s, AV_LOG_WARNING, "Unsupported stream type %08x\n", v);
383  goto skip;
384  }
385  st->codecpar->codec_tag = avio_rl32(pb);
387  st->codecpar->codec_tag);
388  av_log(s, AV_LOG_TRACE, "%"PRIX32" %X\n",
389  st->codecpar->codec_tag, MKTAG('R', 'V', '2', '0'));
390  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
391  goto fail1;
392  st->codecpar->width = avio_rb16(pb);
393  st->codecpar->height = avio_rb16(pb);
394  avio_skip(pb, 2); // looks like bits per sample
395  avio_skip(pb, 4); // always zero?
398  fps = avio_rb32(pb);
399 
400  if ((ret = rm_read_extradata(s, pb, st->codecpar, codec_data_size - (avio_tell(pb) - codec_pos))) < 0)
401  return ret;
402 
403  if (fps > 0) {
405  0x10000, fps, (1 << 30) - 1);
406 #if FF_API_R_FRAME_RATE
407  st->r_frame_rate = st->avg_frame_rate;
408 #endif
409  } else if (s->error_recognition & AV_EF_EXPLODE) {
410  av_log(s, AV_LOG_ERROR, "Invalid framerate\n");
411  return AVERROR_INVALIDDATA;
412  }
413  }
414 
415 skip:
416  /* skip codec info */
417  size = avio_tell(pb) - codec_pos;
418  if (codec_data_size >= size) {
419  avio_skip(pb, codec_data_size - size);
420  } else {
421  av_log(s, AV_LOG_WARNING, "codec_data_size %u < size %d\n", codec_data_size, size);
422  }
423 
424  return 0;
425 }
426 
427 /** this function assumes that the demuxer has already seeked to the start
428  * of the INDX chunk, and will bail out if not. */
430 {
431  AVIOContext *pb = s->pb;
432  unsigned int size, ver, n_pkts, str_id, next_off, n, pts;
433  uint64_t pos;
434  AVStream *st;
435 
436  do {
437  if (avio_rl32(pb) != MKTAG('I','N','D','X'))
438  return -1;
439  size = avio_rb32(pb);
440  if (size < 20)
441  return -1;
442  ver = avio_rb16(pb);
443  if (ver != 0 && ver != 2)
444  return AVERROR_INVALIDDATA;
445  n_pkts = avio_rb32(pb);
446  str_id = avio_rb16(pb);
447  next_off = avio_rb32(pb);
448  if (ver == 2)
449  avio_skip(pb, 4);
450  for (n = 0; n < s->nb_streams; n++)
451  if (s->streams[n]->id == str_id) {
452  st = s->streams[n];
453  break;
454  }
455  if (n == s->nb_streams) {
457  "Invalid stream index %d for index at pos %"PRId64"\n",
458  str_id, avio_tell(pb));
459  goto skip;
460  } else if ((avio_size(pb) - avio_tell(pb)) / 14 < n_pkts) {
462  "Nr. of packets in packet index for stream index %d "
463  "exceeds filesize (%"PRId64" at %"PRId64" = %"PRId64")\n",
464  str_id, avio_size(pb), avio_tell(pb),
465  (avio_size(pb) - avio_tell(pb)) / 14);
466  goto skip;
467  }
468 
469  for (n = 0; n < n_pkts; n++) {
470  if (avio_feof(pb))
471  return AVERROR_INVALIDDATA;
472  avio_skip(pb, 2);
473  pts = avio_rb32(pb);
474  pos = (ver == 0) ? avio_rb32(pb) : avio_rb64(pb);
475  avio_skip(pb, 4); /* packet no. */
476 
478  }
479 
480 skip:
481  if (next_off && avio_tell(pb) < next_off &&
482  avio_seek(pb, next_off, SEEK_SET) < 0) {
484  "Non-linear index detected, not supported\n");
485  return -1;
486  }
487  } while (next_off);
488 
489  return 0;
490 }
491 
493 {
494  RMDemuxContext *rm = s->priv_data;
495  AVStream *st;
496 
497  rm->old_format = 1;
498  st = avformat_new_stream(s, NULL);
499  if (!st)
500  return -1;
502  if (!st->priv_data)
503  return AVERROR(ENOMEM);
504  return rm_read_audio_stream_info(s, s->pb, st, st->priv_data, 1);
505 }
506 
508  AVStream *st, char *mime)
509 {
510  int number_of_streams = avio_rb16(pb);
511  int number_of_mdpr;
512  int i, ret;
513  unsigned size2;
514  for (i = 0; i<number_of_streams; i++)
515  avio_rb16(pb);
516  number_of_mdpr = avio_rb16(pb);
517  if (number_of_mdpr != 1) {
518  avpriv_request_sample(s, "MLTI with multiple (%d) MDPR", number_of_mdpr);
519  }
520  for (i = 0; i < number_of_mdpr; i++) {
521  AVStream *st2;
522  if (i > 0) {
523  st2 = avformat_new_stream(s, NULL);
524  if (!st2) {
525  ret = AVERROR(ENOMEM);
526  return ret;
527  }
528  st2->id = st->id + (i<<16);
529  st2->codecpar->bit_rate = st->codecpar->bit_rate;
530  st2->start_time = st->start_time;
531  st2->duration = st->duration;
534  if (!st2->priv_data)
535  return AVERROR(ENOMEM);
536  } else
537  st2 = st;
538 
539  size2 = avio_rb32(pb);
540  ret = ff_rm_read_mdpr_codecdata(s, s->pb, st2, st2->priv_data,
541  size2, NULL);
542  if (ret < 0)
543  return ret;
544  }
545  return 0;
546 }
547 
549 {
550  RMDemuxContext *rm = s->priv_data;
551  AVStream *st;
552  AVIOContext *pb = s->pb;
553  unsigned int tag;
554  int tag_size;
555  int ver;
556  unsigned int start_time, duration;
557  unsigned int data_off = 0;
558  uint64_t indx_off = 0;
559  char buf[128], mime[128];
560  int flags = 0;
561  int ret;
562  unsigned size, v;
563  int64_t codec_pos;
564 
565  tag = avio_rl32(pb);
566  if (tag == MKTAG('.', 'r', 'a', 0xfd)) {
567  /* very old .ra format */
568  return rm_read_header_old(s);
569  } else if (tag != MKTAG('.', 'R', 'M', 'F') && tag != MKTAG('.', 'R', 'M', 'P')) {
570  return AVERROR(EIO);
571  }
572 
573  tag_size = avio_rb32(pb);
574  if (tag_size < 0)
575  return AVERROR_INVALIDDATA;
576  avio_skip(pb, tag_size - 8);
577 
578  for(;;) {
579  if (avio_feof(pb))
580  return AVERROR_INVALIDDATA;
581  tag = avio_rl32(pb);
582  tag_size = avio_rb32(pb);
583  ver = avio_rb16(pb);
584  av_log(s, AV_LOG_TRACE, "tag=%s size=%d\n",
585  av_fourcc2str(tag), tag_size);
586  if ((tag_size < 10 && tag != MKTAG('D', 'A', 'T', 'A')) ||
587  (ver != 0 && ver != 2))
588  return AVERROR_INVALIDDATA;
589  switch(tag) {
590  case MKTAG('P', 'R', 'O', 'P'):
591  /* file header */
592  avio_rb32(pb); /* max bit rate */
593  avio_rb32(pb); /* avg bit rate */
594  avio_rb32(pb); /* max packet size */
595  avio_rb32(pb); /* avg packet size */
596  avio_rb32(pb); /* nb packets */
597  duration = avio_rb32(pb); /* duration */
598  s->duration = av_rescale(duration, AV_TIME_BASE, 1000);
599  avio_rb32(pb); /* preroll */
600  indx_off = (ver == 0) ? avio_rb32(pb) : avio_rb64(pb); /* index offset */
601  data_off = avio_rb32(pb); /* data offset */
602  avio_rb16(pb); /* nb streams */
603  flags = avio_rb16(pb); /* flags */
604  break;
605  case MKTAG('C', 'O', 'N', 'T'):
606  rm_read_metadata(s, pb, 1);
607  break;
608  case MKTAG('M', 'D', 'P', 'R'):
609  st = avformat_new_stream(s, NULL);
610  if (!st)
611  return AVERROR(ENOMEM);
612  st->id = avio_rb16(pb);
613  avio_rb32(pb); /* max bit rate */
614  st->codecpar->bit_rate = avio_rb32(pb); /* bit rate */
615  avio_rb32(pb); /* max packet size */
616  avio_rb32(pb); /* avg packet size */
617  start_time = avio_rb32(pb); /* start time */
618  avio_rb32(pb); /* preroll */
619  duration = avio_rb32(pb); /* duration */
620  st->start_time = start_time;
621  st->duration = duration;
622  if(duration>0)
623  s->duration = AV_NOPTS_VALUE;
624  get_str8(pb, buf, sizeof(buf)); /* desc */
625  get_str8(pb, mime, sizeof(mime)); /* mimetype */
628  if (!st->priv_data)
629  return AVERROR(ENOMEM);
630 
631  size = avio_rb32(pb);
632  codec_pos = avio_tell(pb);
633 
634  ffio_ensure_seekback(pb, 4);
635  v = avio_rb32(pb);
636  if (v == MKBETAG('M', 'L', 'T', 'I')) {
637  ret = rm_read_multi(s, s->pb, st, mime);
638  if (ret < 0)
639  return ret;
640  avio_seek(pb, codec_pos + size, SEEK_SET);
641  } else {
642  avio_skip(pb, -4);
643  ret = ff_rm_read_mdpr_codecdata(s, s->pb, st, st->priv_data,
644  size, mime);
645  if (ret < 0)
646  return ret;
647  }
648 
649  break;
650  case MKTAG('D', 'A', 'T', 'A'):
651  goto header_end;
652  default:
653  /* unknown tag: skip it */
654  avio_skip(pb, tag_size - 10);
655  break;
656  }
657  }
658  header_end:
659  rm->nb_packets = avio_rb32(pb); /* number of packets */
660  if (!rm->nb_packets && (flags & 4))
661  rm->nb_packets = 3600 * 25;
662  if (ver == 2)
663  avio_skip(pb, 12);
664  avio_rb32(pb); /* next data header */
665 
666  if (!data_off)
667  data_off = avio_tell(pb) - (ver == 0 ? 18 : 30);
668  if (indx_off && (pb->seekable & AVIO_SEEKABLE_NORMAL) &&
669  !(s->flags & AVFMT_FLAG_IGNIDX) &&
670  avio_seek(pb, indx_off, SEEK_SET) >= 0) {
671  rm_read_index(s);
672  avio_seek(pb, data_off + (ver == 0 ? 18 : 30), SEEK_SET);
673  }
674 
675  return 0;
676 }
677 
678 static int get_num(AVIOContext *pb, int *len)
679 {
680  int n, n1;
681 
682  n = avio_rb16(pb);
683  (*len)-=2;
684  n &= 0x7FFF;
685  if (n >= 0x4000) {
686  return n - 0x4000;
687  } else {
688  n1 = avio_rb16(pb);
689  (*len)-=2;
690  return (n << 16) | n1;
691  }
692 }
693 
694 /* multiple of 20 bytes for ra144 (ugly) */
695 #define RAW_PACKET_SIZE 1000
696 
697 static int rm_sync(AVFormatContext *s, int64_t *timestamp, int *flags, int *stream_index, int64_t *pos){
698  RMDemuxContext *rm = s->priv_data;
699  AVIOContext *pb = s->pb;
700  AVStream *st;
701  uint32_t state=0xFFFFFFFF;
702 
703  while(!avio_feof(pb)){
704  int len, num, i;
705  int mlti_id;
706  *pos= avio_tell(pb) - 3;
707  if(rm->remaining_len > 0){
708  num= rm->current_stream;
709  mlti_id = 0;
710  len= rm->remaining_len;
711  *timestamp = AV_NOPTS_VALUE;
712  *flags= 0;
713  }else{
714  state= (state<<8) + avio_r8(pb);
715 
716  if(state == MKBETAG('I', 'N', 'D', 'X')){
717  int ver;
718  int n_pkts;
719  int64_t expected_len;
720  len = avio_rb32(pb);
721  ver = avio_rb16(pb);
722  if (ver != 0 && ver != 2)
723  return AVERROR_INVALIDDATA;
724  n_pkts = avio_rb32(pb);
725 
726  if (ver == 0)
727  expected_len = 20 + n_pkts * 14LL;
728  else if (ver == 2)
729  expected_len = 24 + n_pkts * 18LL;
730 
731  if (len == 20 && expected_len <= INT_MAX)
732  /* some files don't add index entries to chunk size... */
733  len = expected_len;
734  else if (len != expected_len)
736  "Index size %d (%d pkts) is wrong, should be %"PRId64".\n",
737  len, n_pkts, expected_len);
738  if(len < 14)
739  continue;
740  len -= 14; // we already read part of the index header
741  goto skip;
742  } else if (state == MKBETAG('D','A','T','A')) {
744  "DATA tag in middle of chunk, file may be broken.\n");
745  }
746 
747  if(state > (unsigned)0xFFFF || state <= 12)
748  continue;
749  len=state - 12;
750  state= 0xFFFFFFFF;
751 
752  num = avio_rb16(pb);
753  *timestamp = avio_rb32(pb);
754  mlti_id = (avio_r8(pb) >> 1) - 1;
755  mlti_id = FFMAX(mlti_id, 0) << 16;
756  *flags = avio_r8(pb); /* flags */
757  }
758  for(i=0;i<s->nb_streams;i++) {
759  st = s->streams[i];
760  if (mlti_id + num == st->id)
761  break;
762  }
763  if (i == s->nb_streams) {
764 skip:
765  /* skip packet if unknown number */
766  avio_skip(pb, len);
767  rm->remaining_len = 0;
768  continue;
769  }
770  *stream_index= i;
771 
772  return len;
773  }
774  return -1;
775 }
776 
778  RMDemuxContext *rm, RMStream *vst,
779  AVPacket *pkt, int len, int *pseq,
780  int64_t *timestamp)
781 {
782  int hdr;
783  int seq = 0, pic_num = 0, len2 = 0, pos = 0; //init to silence compiler warning
784  int type;
785  int ret;
786 
787  hdr = avio_r8(pb); len--;
788  type = hdr >> 6;
789 
790  if(type != 3){ // not frame as a part of packet
791  seq = avio_r8(pb); len--;
792  }
793  if(type != 1){ // not whole frame
794  len2 = get_num(pb, &len);
795  pos = get_num(pb, &len);
796  pic_num = avio_r8(pb); len--;
797  }
798  if(len<0) {
799  av_log(s, AV_LOG_ERROR, "Insufficient data\n");
800  return -1;
801  }
802  rm->remaining_len = len;
803  if(type&1){ // frame, not slice
804  if(type == 3){ // frame as a part of packet
805  len= len2;
806  *timestamp = pos;
807  }
808  if(rm->remaining_len < len) {
809  av_log(s, AV_LOG_ERROR, "Insufficient remaining len\n");
810  return -1;
811  }
812  rm->remaining_len -= len;
813  if ((ret = av_new_packet(pkt, len + 9)) < 0)
814  return ret;
815  pkt->data[0] = 0;
816  AV_WL32(pkt->data + 1, 1);
817  AV_WL32(pkt->data + 5, 0);
818  if ((ret = avio_read(pb, pkt->data + 9, len)) != len) {
820  av_log(s, AV_LOG_ERROR, "Failed to read %d bytes\n", len);
821  return ret < 0 ? ret : AVERROR(EIO);
822  }
823  return 0;
824  }
825  //now we have to deal with single slice
826 
827  *pseq = seq;
828  if((seq & 0x7F) == 1 || vst->curpic_num != pic_num){
829  if (len2 > ffio_limit(pb, len2)) {
830  av_log(s, AV_LOG_ERROR, "Impossibly sized packet\n");
831  return AVERROR_INVALIDDATA;
832  }
833  vst->slices = ((hdr & 0x3F) << 1) + 1;
834  vst->videobufsize = len2 + 8*vst->slices + 1;
835  av_packet_unref(&vst->pkt); //FIXME this should be output.
836  if ((ret = av_new_packet(&vst->pkt, vst->videobufsize)) < 0)
837  return ret;
838  vst->videobufpos = 8*vst->slices + 1;
839  vst->cur_slice = 0;
840  vst->curpic_num = pic_num;
841  vst->pktpos = avio_tell(pb);
842  }
843  if(type == 2)
844  len = FFMIN(len, pos);
845 
846  if(++vst->cur_slice > vst->slices) {
847  av_log(s, AV_LOG_ERROR, "cur slice %d, too large\n", vst->cur_slice);
848  return 1;
849  }
850  if(!vst->pkt.data)
851  return AVERROR(ENOMEM);
852  AV_WL32(vst->pkt.data - 7 + 8*vst->cur_slice, 1);
853  AV_WL32(vst->pkt.data - 3 + 8*vst->cur_slice, vst->videobufpos - 8*vst->slices - 1);
854  if(vst->videobufpos + len > vst->videobufsize) {
855  av_log(s, AV_LOG_ERROR, "outside videobufsize\n");
856  return 1;
857  }
858  if (avio_read(pb, vst->pkt.data + vst->videobufpos, len) != len)
859  return AVERROR(EIO);
860  vst->videobufpos += len;
861  rm->remaining_len-= len;
862 
863  if (type == 2 || vst->videobufpos == vst->videobufsize) {
864  vst->pkt.data[0] = vst->cur_slice-1;
865  av_packet_move_ref(pkt, &vst->pkt);
866  if(vst->slices != vst->cur_slice) //FIXME find out how to set slices correct from the begin
867  memmove(pkt->data + 1 + 8*vst->cur_slice, pkt->data + 1 + 8*vst->slices,
868  vst->videobufpos - 1 - 8*vst->slices);
869  av_shrink_packet(pkt, vst->videobufpos + 8*(vst->cur_slice - vst->slices));
871  pkt->pos = vst->pktpos;
872  vst->slices = 0;
873  return 0;
874  }
875 
876  return 1;
877 }
878 
879 static inline void
881 {
882  uint8_t *ptr;
883  int j;
884 
885  if (st->codecpar->codec_id == AV_CODEC_ID_AC3) {
886  ptr = pkt->data;
887  for (j=0;j<pkt->size;j+=2) {
888  FFSWAP(int, ptr[0], ptr[1]);
889  ptr += 2;
890  }
891  }
892 }
893 
894 static int readfull(AVFormatContext *s, AVIOContext *pb, uint8_t *dst, int n) {
895  int ret = avio_read(pb, dst, n);
896  if (ret != n) {
897  if (ret >= 0) memset(dst + ret, 0, n - ret);
898  else memset(dst , 0, n);
899  av_log(s, AV_LOG_ERROR, "Failed to fully read block\n");
900  }
901  return ret;
902 }
903 
904 int
906  AVStream *st, RMStream *ast, int len, AVPacket *pkt,
907  int *seq, int flags, int64_t timestamp)
908 {
909  RMDemuxContext *rm = s->priv_data;
910  int ret;
911 
912  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
913  rm->current_stream= st->id;
914  ret = rm_assemble_video_frame(s, pb, rm, ast, pkt, len, seq, &timestamp);
915  if(ret)
916  return ret < 0 ? ret : -1; //got partial frame or error
917  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
918  if ((ast->deint_id == DEINT_ID_GENR) ||
919  (ast->deint_id == DEINT_ID_INT4) ||
920  (ast->deint_id == DEINT_ID_SIPR)) {
921  int x;
922  int sps = ast->sub_packet_size;
923  int cfs = ast->coded_framesize;
924  int h = ast->sub_packet_h;
925  int y = ast->sub_packet_cnt;
926  int w = ast->audio_framesize;
927 
928  if (flags & 2)
929  y = ast->sub_packet_cnt = 0;
930  if (!y)
931  ast->audiotimestamp = timestamp;
932 
933  switch (ast->deint_id) {
934  case DEINT_ID_INT4:
935  for (x = 0; x < h/2; x++)
936  readfull(s, pb, ast->pkt.data+x*2*w+y*cfs, cfs);
937  break;
938  case DEINT_ID_GENR:
939  for (x = 0; x < w/sps; x++)
940  readfull(s, pb, ast->pkt.data+sps*(h*x+((h+1)/2)*(y&1)+(y>>1)), sps);
941  break;
942  case DEINT_ID_SIPR:
943  readfull(s, pb, ast->pkt.data + y * w, w);
944  break;
945  }
946 
947  if (++(ast->sub_packet_cnt) < h)
948  return -1;
949  if (ast->deint_id == DEINT_ID_SIPR)
951 
952  ast->sub_packet_cnt = 0;
953  rm->audio_stream_num = st->index;
954  if (st->codecpar->block_align <= 0) {
955  av_log(s, AV_LOG_ERROR, "Invalid block alignment %d\n", st->codecpar->block_align);
956  return AVERROR_INVALIDDATA;
957  }
958  rm->audio_pkt_cnt = h * w / st->codecpar->block_align;
959  } else if ((ast->deint_id == DEINT_ID_VBRF) ||
960  (ast->deint_id == DEINT_ID_VBRS)) {
961  int x;
962  rm->audio_stream_num = st->index;
963  ast->sub_packet_cnt = (avio_rb16(pb) & 0xf0) >> 4;
964  if (ast->sub_packet_cnt) {
965  for (x = 0; x < ast->sub_packet_cnt; x++)
966  ast->sub_packet_lengths[x] = avio_rb16(pb);
967  rm->audio_pkt_cnt = ast->sub_packet_cnt;
968  ast->audiotimestamp = timestamp;
969  } else
970  return -1;
971  } else {
972  ret = av_get_packet(pb, pkt, len);
973  if (ret < 0)
974  return ret;
975  rm_ac3_swap_bytes(st, pkt);
976  }
977  } else {
978  ret = av_get_packet(pb, pkt, len);
979  if (ret < 0)
980  return ret;
981  }
982 
983  pkt->stream_index = st->index;
984 
985  pkt->pts = timestamp;
986  if (flags & 2)
988 
989  return st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO ? rm->audio_pkt_cnt : 0;
990 }
991 
992 int
994  AVStream *st, RMStream *ast, AVPacket *pkt)
995 {
996  RMDemuxContext *rm = s->priv_data;
997  int ret;
998 
999  av_assert0 (rm->audio_pkt_cnt > 0);
1000 
1001  if (ast->deint_id == DEINT_ID_VBRF ||
1002  ast->deint_id == DEINT_ID_VBRS) {
1004  if (ret < 0)
1005  return ret;
1006  } else {
1008  if (ret < 0)
1009  return ret;
1010  memcpy(pkt->data, ast->pkt.data + st->codecpar->block_align * //FIXME avoid this
1011  (ast->sub_packet_h * ast->audio_framesize / st->codecpar->block_align - rm->audio_pkt_cnt),
1012  st->codecpar->block_align);
1013  }
1014  rm->audio_pkt_cnt--;
1015  if ((pkt->pts = ast->audiotimestamp) != AV_NOPTS_VALUE) {
1018  } else
1019  pkt->flags = 0;
1020  pkt->stream_index = st->index;
1021 
1022  return rm->audio_pkt_cnt;
1023 }
1024 
1026 {
1027  RMDemuxContext *rm = s->priv_data;
1028  AVStream *st = NULL; // init to silence compiler warning
1029  int i, res, seq = 1;
1030  int64_t timestamp, pos, len;
1031  int flags;
1032 
1033  for (;;) {
1034  if (rm->audio_pkt_cnt) {
1035  // If there are queued audio packet return them first
1036  st = s->streams[rm->audio_stream_num];
1037  res = ff_rm_retrieve_cache(s, s->pb, st, st->priv_data, pkt);
1038  if(res < 0)
1039  return res;
1040  flags = 0;
1041  } else {
1042  if (rm->old_format) {
1043  RMStream *ast;
1044 
1045  st = s->streams[0];
1046  ast = st->priv_data;
1047  timestamp = AV_NOPTS_VALUE;
1048  len = !ast->audio_framesize ? RAW_PACKET_SIZE :
1049  ast->coded_framesize * (int64_t)ast->sub_packet_h / 2;
1050  if (len > INT_MAX)
1051  return AVERROR_INVALIDDATA;
1052  flags = (seq++ == 1) ? 2 : 0;
1053  pos = avio_tell(s->pb);
1054  } else {
1055  len = rm_sync(s, &timestamp, &flags, &i, &pos);
1056  if (len > 0)
1057  st = s->streams[i];
1058  }
1059 
1060  if (avio_feof(s->pb))
1061  return AVERROR_EOF;
1062  if (len <= 0)
1063  return AVERROR(EIO);
1064 
1065  res = ff_rm_parse_packet (s, s->pb, st, st->priv_data, len, pkt,
1066  &seq, flags, timestamp);
1067  if (res < -1)
1068  return res;
1069  if((flags&2) && (seq&0x7F) == 1)
1070  av_add_index_entry(st, pos, timestamp, 0, 0, AVINDEX_KEYFRAME);
1071  if (res)
1072  continue;
1073  }
1074 
1075  if( (st->discard >= AVDISCARD_NONKEY && !(flags&2))
1076  || st->discard >= AVDISCARD_ALL){
1078  } else
1079  break;
1080  }
1081 
1082  return 0;
1083 }
1084 
1086 {
1087  int i;
1088 
1089  for (i=0;i<s->nb_streams;i++)
1090  ff_rm_free_rmstream(s->streams[i]->priv_data);
1091 
1092  return 0;
1093 }
1094 
1095 static int rm_probe(const AVProbeData *p)
1096 {
1097  /* check file header */
1098  if ((p->buf[0] == '.' && p->buf[1] == 'R' &&
1099  p->buf[2] == 'M' && (p->buf[3] == 'F' || p->buf[3] == 'P') &&
1100  p->buf[4] == 0 && p->buf[5] == 0) ||
1101  (p->buf[0] == '.' && p->buf[1] == 'r' &&
1102  p->buf[2] == 'a' && p->buf[3] == 0xfd))
1103  return AVPROBE_SCORE_MAX;
1104  else
1105  return 0;
1106 }
1107 
1108 static int64_t rm_read_dts(AVFormatContext *s, int stream_index,
1109  int64_t *ppos, int64_t pos_limit)
1110 {
1111  RMDemuxContext *rm = s->priv_data;
1112  int64_t pos, dts;
1113  int stream_index2, flags, len, h;
1114 
1115  pos = *ppos;
1116 
1117  if(rm->old_format)
1118  return AV_NOPTS_VALUE;
1119 
1120  if (avio_seek(s->pb, pos, SEEK_SET) < 0)
1121  return AV_NOPTS_VALUE;
1122 
1123  rm->remaining_len=0;
1124  for(;;){
1125  int seq=1;
1126  AVStream *st;
1127 
1128  len = rm_sync(s, &dts, &flags, &stream_index2, &pos);
1129  if(len<0)
1130  return AV_NOPTS_VALUE;
1131 
1132  st = s->streams[stream_index2];
1133  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1134  h= avio_r8(s->pb); len--;
1135  if(!(h & 0x40)){
1136  seq = avio_r8(s->pb); len--;
1137  }
1138  }
1139 
1140  if((flags&2) && (seq&0x7F) == 1){
1141  av_log(s, AV_LOG_TRACE, "%d %d-%d %"PRId64" %d\n",
1142  flags, stream_index2, stream_index, dts, seq);
1143  av_add_index_entry(st, pos, dts, 0, 0, AVINDEX_KEYFRAME);
1144  if(stream_index2 == stream_index)
1145  break;
1146  }
1147 
1148  avio_skip(s->pb, len);
1149  }
1150  *ppos = pos;
1151  return dts;
1152 }
1153 
1154 static int rm_read_seek(AVFormatContext *s, int stream_index,
1155  int64_t pts, int flags)
1156 {
1157  RMDemuxContext *rm = s->priv_data;
1158 
1159  if (ff_seek_frame_binary(s, stream_index, pts, flags) < 0)
1160  return -1;
1161  rm->audio_pkt_cnt = 0;
1162  return 0;
1163 }
1164 
1165 
1167  .p.name = "rm",
1168  .p.long_name = NULL_IF_CONFIG_SMALL("RealMedia"),
1169  .priv_data_size = sizeof(RMDemuxContext),
1170  .flags_internal = FF_INFMT_FLAG_INIT_CLEANUP,
1171  .read_probe = rm_probe,
1177 };
1178 
1180  .p.name = "rdt",
1181  .p.long_name = NULL_IF_CONFIG_SMALL("RDT demuxer"),
1182  .p.flags = AVFMT_NOFILE,
1183  .priv_data_size = sizeof(RMDemuxContext),
1185 };
1186 
1187 static int ivr_probe(const AVProbeData *p)
1188 {
1189  if (memcmp(p->buf, ".R1M\x0\x1\x1", 7) &&
1190  memcmp(p->buf, ".REC", 4))
1191  return 0;
1192 
1193  return AVPROBE_SCORE_MAX;
1194 }
1195 
1197 {
1198  unsigned tag, type, len, tlen, value;
1199  int i, j, n, count, nb_streams = 0, ret;
1200  uint8_t key[256], val[256];
1201  AVIOContext *pb = s->pb;
1202  AVStream *st;
1203  int64_t pos, offset=0, temp;
1204 
1205  pos = avio_tell(pb);
1206  tag = avio_rl32(pb);
1207  if (tag == MKTAG('.','R','1','M')) {
1208  if (avio_rb16(pb) != 1)
1209  return AVERROR_INVALIDDATA;
1210  if (avio_r8(pb) != 1)
1211  return AVERROR_INVALIDDATA;
1212  len = avio_rb32(pb);
1213  avio_skip(pb, len);
1214  avio_skip(pb, 5);
1215  temp = avio_rb64(pb);
1216  while (!avio_feof(pb) && temp) {
1217  offset = temp;
1218  temp = avio_rb64(pb);
1219  }
1220  if (offset <= 0)
1221  return AVERROR_INVALIDDATA;
1222  avio_skip(pb, offset - avio_tell(pb));
1223  if (avio_r8(pb) != 1)
1224  return AVERROR_INVALIDDATA;
1225  len = avio_rb32(pb);
1226  avio_skip(pb, len);
1227  if (avio_r8(pb) != 2)
1228  return AVERROR_INVALIDDATA;
1229  avio_skip(pb, 16);
1230  pos = avio_tell(pb);
1231  tag = avio_rl32(pb);
1232  }
1233 
1234  if (tag != MKTAG('.','R','E','C'))
1235  return AVERROR_INVALIDDATA;
1236 
1237  if (avio_r8(pb) != 0)
1238  return AVERROR_INVALIDDATA;
1239  count = avio_rb32(pb);
1240  for (i = 0; i < count; i++) {
1241  if (avio_feof(pb))
1242  return AVERROR_INVALIDDATA;
1243 
1244  type = avio_r8(pb);
1245  tlen = avio_rb32(pb);
1246  avio_get_str(pb, tlen, key, sizeof(key));
1247  len = avio_rb32(pb);
1248  if (type == 5) {
1249  avio_get_str(pb, len, val, sizeof(val));
1250  av_log(s, AV_LOG_DEBUG, "%s = '%s'\n", key, val);
1251  } else if (type == 4) {
1252  av_log(s, AV_LOG_DEBUG, "%s = '0x", key);
1253  for (j = 0; j < len; j++) {
1254  if (avio_feof(pb))
1255  return AVERROR_INVALIDDATA;
1256  av_log(s, AV_LOG_DEBUG, "%X", avio_r8(pb));
1257  }
1258  av_log(s, AV_LOG_DEBUG, "'\n");
1259  } else if (len == 4 && type == 3 && !strncmp(key, "StreamCount", tlen)) {
1260  nb_streams = value = avio_rb32(pb);
1261  } else if (len == 4 && type == 3) {
1262  value = avio_rb32(pb);
1263  av_log(s, AV_LOG_DEBUG, "%s = %d\n", key, value);
1264  } else {
1265  av_log(s, AV_LOG_DEBUG, "Skipping unsupported key: %s\n", key);
1266  avio_skip(pb, len);
1267  }
1268  }
1269 
1270  for (n = 0; n < nb_streams; n++) {
1271  if (!(st = avformat_new_stream(s, NULL)) ||
1272  !(st->priv_data = ff_rm_alloc_rmstream()))
1273  return AVERROR(ENOMEM);
1274 
1275  if (avio_r8(pb) != 1)
1276  return AVERROR_INVALIDDATA;
1277 
1278  count = avio_rb32(pb);
1279  for (i = 0; i < count; i++) {
1280  if (avio_feof(pb))
1281  return AVERROR_INVALIDDATA;
1282 
1283  type = avio_r8(pb);
1284  tlen = avio_rb32(pb);
1285  avio_get_str(pb, tlen, key, sizeof(key));
1286  len = avio_rb32(pb);
1287  if (type == 5) {
1288  avio_get_str(pb, len, val, sizeof(val));
1289  av_log(s, AV_LOG_DEBUG, "%s = '%s'\n", key, val);
1290  } else if (type == 4 && !strncmp(key, "OpaqueData", tlen)) {
1291  ret = ffio_ensure_seekback(pb, 4);
1292  if (ret < 0)
1293  return ret;
1294  if (avio_rb32(pb) == MKBETAG('M', 'L', 'T', 'I')) {
1295  ret = rm_read_multi(s, pb, st, NULL);
1296  } else {
1297  if (avio_feof(pb))
1298  return AVERROR_INVALIDDATA;
1299  avio_seek(pb, -4, SEEK_CUR);
1300  ret = ff_rm_read_mdpr_codecdata(s, pb, st, st->priv_data, len, NULL);
1301  }
1302 
1303  if (ret < 0)
1304  return ret;
1305  } else if (type == 4) {
1306  int j;
1307 
1308  av_log(s, AV_LOG_DEBUG, "%s = '0x", key);
1309  for (j = 0; j < len; j++) {
1310  if (avio_feof(pb))
1311  return AVERROR_INVALIDDATA;
1312  av_log(s, AV_LOG_DEBUG, "%X", avio_r8(pb));
1313  }
1314  av_log(s, AV_LOG_DEBUG, "'\n");
1315  } else if (len == 4 && type == 3 && !strncmp(key, "Duration", tlen)) {
1316  st->duration = avio_rb32(pb);
1317  } else if (len == 4 && type == 3) {
1318  value = avio_rb32(pb);
1319  av_log(s, AV_LOG_DEBUG, "%s = %d\n", key, value);
1320  } else {
1321  av_log(s, AV_LOG_DEBUG, "Skipping unsupported key: %s\n", key);
1322  avio_skip(pb, len);
1323  }
1324  }
1325  }
1326 
1327  if (avio_r8(pb) != 6)
1328  return AVERROR_INVALIDDATA;
1329  avio_skip(pb, 12);
1330  avio_seek(pb, avio_rb64(pb) + pos, SEEK_SET);
1331  if (avio_r8(pb) != 8)
1332  return AVERROR_INVALIDDATA;
1333  avio_skip(pb, 8);
1334 
1335  return 0;
1336 }
1337 
1339 {
1340  RMDemuxContext *rm = s->priv_data;
1341  int ret = AVERROR_EOF, opcode;
1342  AVIOContext *pb = s->pb;
1343  unsigned size, index;
1344  int64_t pos, pts;
1345 
1346  if (avio_feof(pb) || rm->data_end)
1347  return AVERROR_EOF;
1348 
1349  pos = avio_tell(pb);
1350 
1351  for (;;) {
1352  if (rm->audio_pkt_cnt) {
1353  // If there are queued audio packet return them first
1354  AVStream *st;
1355 
1356  st = s->streams[rm->audio_stream_num];
1357  ret = ff_rm_retrieve_cache(s, pb, st, st->priv_data, pkt);
1358  if (ret < 0) {
1359  return ret;
1360  }
1361  } else {
1362  if (rm->remaining_len) {
1363  avio_skip(pb, rm->remaining_len);
1364  rm->remaining_len = 0;
1365  }
1366 
1367  if (avio_feof(pb))
1368  return AVERROR_EOF;
1369 
1370  opcode = avio_r8(pb);
1371  if (opcode == 2) {
1372  AVStream *st;
1373  int seq = 1;
1374 
1375  pts = avio_rb32(pb);
1376  index = avio_rb16(pb);
1377  if (index >= s->nb_streams)
1378  return AVERROR_INVALIDDATA;
1379 
1380  avio_skip(pb, 4);
1381  size = avio_rb32(pb);
1382  avio_skip(pb, 4);
1383 
1384  if (size < 1 || size > INT_MAX/4) {
1385  av_log(s, AV_LOG_ERROR, "size %u is invalid\n", size);
1386  return AVERROR_INVALIDDATA;
1387  }
1388 
1389  st = s->streams[index];
1390  ret = ff_rm_parse_packet(s, pb, st, st->priv_data, size, pkt,
1391  &seq, 0, pts);
1392  if (ret < -1) {
1393  return ret;
1394  } else if (ret) {
1395  continue;
1396  }
1397 
1398  pkt->pos = pos;
1399  pkt->pts = pts;
1400  pkt->stream_index = index;
1401  } else if (opcode == 7) {
1402  pos = avio_rb64(pb);
1403  if (!pos) {
1404  rm->data_end = 1;
1405  return AVERROR_EOF;
1406  }
1407  } else {
1408  av_log(s, AV_LOG_ERROR, "Unsupported opcode=%d at %"PRIX64"\n", opcode, avio_tell(pb) - 1);
1409  return AVERROR(EIO);
1410  }
1411  }
1412 
1413  break;
1414  }
1415 
1416  return ret;
1417 }
1418 
1420  .p.name = "ivr",
1421  .p.long_name = NULL_IF_CONFIG_SMALL("IVR (Internet Video Recording)"),
1422  .p.extensions = "ivr",
1423  .priv_data_size = sizeof(RMDemuxContext),
1424  .flags_internal = FF_INFMT_FLAG_INIT_CLEANUP,
1425  .read_probe = ivr_probe,
1429 };
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:429
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:215
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:69
ff_seek_frame_binary
int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
Perform a binary search using av_index_search_timestamp() and FFInputFormat.read_timestamp().
Definition: seek.c:290
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
rm_read_index
static int rm_read_index(AVFormatContext *s)
this function assumes that the demuxer has already seeked to the start of the INDX chunk,...
Definition: rmdec.c:429
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: defs.h:51
AV_CODEC_ID_AC3
@ AV_CODEC_ID_AC3
Definition: codec_id.h:449
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:422
ff_rm_reorder_sipr_data
void ff_rm_reorder_sipr_data(uint8_t *buf, int sub_packet_h, int framesize)
Perform 4-bit block reordering for SIPR data.
Definition: rmsipr.c:41
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
AVFMT_FLAG_IGNIDX
#define AVFMT_FLAG_IGNIDX
Ignore index.
Definition: avformat.h:1453
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)
Add a new stream to a media file.
rm_read_extradata
static int rm_read_extradata(AVFormatContext *s, AVIOContext *pb, AVCodecParameters *par, unsigned size)
Definition: rmdec.c:83
AVStream::priv_data
void * priv_data
Definition: avformat.h:773
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AVStream::discard
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:819
RMStream::deint_id
int32_t deint_id
deinterleaver used in audio stream
Definition: rmdec.c:57
int64_t
long long int64_t
Definition: coverity.c:34
ff_rm_retrieve_cache
int ff_rm_retrieve_cache(AVFormatContext *s, AVIOContext *pb, AVStream *st, RMStream *ast, AVPacket *pkt)
Retrieve one cached packet from the rm-context.
Definition: rmdec.c:993
AV_CODEC_ID_RA_144
@ AV_CODEC_ID_RA_144
Definition: codec_id.h:431
rmsipr.h
w
uint8_t w
Definition: llviddspenc.c:38
AVPacket::data
uint8_t * data
Definition: packet.h:539
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:837
RMStream::videobufpos
int videobufpos
position for the next slice in the video buffer
Definition: rmdec.c:47
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:59
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
DEINT_ID_SIPR
#define DEINT_ID_SIPR
interleaving for Sipro
Definition: rmdec.c:40
RMDemuxContext::data_end
int data_end
Definition: rmdec.c:67
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:321
DEINT_ID_VBRS
#define DEINT_ID_VBRS
VBR case for AAC.
Definition: rmdec.c:42
avio_size
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:323
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:594
RAW_PACKET_SIZE
#define RAW_PACKET_SIZE
Definition: rmdec.c:695
state
static struct @464 state
AVINDEX_KEYFRAME
#define AVINDEX_KEYFRAME
Definition: avformat.h:610
ff_get_extradata
int ff_get_extradata(void *logctx, AVCodecParameters *par, AVIOContext *pb, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0 and f...
Definition: demux_utils.c:338
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:463
ff_remove_stream
void ff_remove_stream(AVFormatContext *s, AVStream *st)
Remove a stream from its AVFormatContext and free it.
Definition: avformat.c:121
RMStream::videobufsize
int videobufsize
current assembled frame size
Definition: rmdec.c:46
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: avformat.c:867
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:358
readfull
static int readfull(AVFormatContext *s, AVIOContext *pb, uint8_t *dst, int n)
Definition: rmdec.c:894
read_seek
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:151
av_shrink_packet
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: packet.c:113
av_add_index_entry
int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp, int size, int distance, int flags)
Add an index entry into a sorted list.
Definition: seek.c:122
read_close
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:143
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:494
val
static double val(void *priv, double ch)
Definition: aeval.c:77
RMStream
Definition: rmdec.c:44
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
pts
static int64_t pts
Definition: transcode_aac.c:644
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:807
av_reduce
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
AVRational::num
int num
Numerator.
Definition: rational.h:59
get_num
static int get_num(AVIOContext *pb, int *len)
Definition: rmdec.c:678
AV_CODEC_ID_ATRAC3
@ AV_CODEC_ID_ATRAC3
Definition: codec_id.h:477
ff_rm_metadata
const char *const ff_rm_metadata[4]
Definition: rm.c:24
AV_CODEC_ID_SIPR
@ AV_CODEC_ID_SIPR
Definition: codec_id.h:487
avassert.h
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:761
AV_LOG_TRACE
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:235
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
get_strl
static void get_strl(AVIOContext *pb, char *buf, int buf_size, int len)
Definition: rmdec.c:70
duration
int64_t duration
Definition: movenc.c:65
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_read_callback.c:42
rm_read_packet
static int rm_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: rmdec.c:1025
rm_read_audio_stream_info
static int rm_read_audio_stream_info(AVFormatContext *s, AVIOContext *pb, AVStream *st, RMStream *ast, int read_all)
Definition: rmdec.c:123
RMStream::slices
int slices
Definition: rmdec.c:49
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
RMStream::audio_framesize
int audio_framesize
Audio frame size from container.
Definition: rmdec.c:55
av_new_packet
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: packet.c:98
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:553
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:453
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:134
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
rm_probe
static int rm_probe(const AVProbeData *p)
Definition: rmdec.c:1095
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:230
nb_streams
static int nb_streams
Definition: ffprobe.c:384
RMStream::pkt
AVPacket pkt
place to store merged video frame / reordered audio data
Definition: rmdec.c:45
RMStream::curpic_num
int curpic_num
picture number of current frame
Definition: rmdec.c:48
key
const char * key
Definition: hwcontext_opencl.c:189
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:203
RMStream::pktpos
int64_t pktpos
first slice position in file
Definition: rmdec.c:50
if
if(ret)
Definition: filter_design.txt:179
FF_INFMT_FLAG_INIT_CLEANUP
#define FF_INFMT_FLAG_INIT_CLEANUP
For an FFInputFormat with this flag set read_close() needs to be called by the caller upon read_heade...
Definition: demux.h:35
ff_rm_parse_packet
int ff_rm_parse_packet(AVFormatContext *s, AVIOContext *pb, AVStream *st, RMStream *ast, int len, AVPacket *pkt, int *seq, int flags, int64_t timestamp)
Parse one rm-stream packet from the input bytestream.
Definition: rmdec.c:905
FFStream::need_parsing
enum AVStreamParseType need_parsing
Definition: internal.h:325
RMStream::cur_slice
int cur_slice
Definition: rmdec.c:49
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:221
AVFormatContext
Format I/O context.
Definition: avformat.h:1300
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:771
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:540
ivr_read_header
static int ivr_read_header(AVFormatContext *s)
Definition: rmdec.c:1196
NULL
#define NULL
Definition: coverity.c:32
ff_rm_codec_tags
const AVCodecTag ff_rm_codec_tags[]
Definition: rm.c:31
RMStream::sub_packet_size
int sub_packet_size
Definition: rmdec.c:54
ivr_read_packet
static int ivr_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: rmdec.c:1338
avio_rb64
uint64_t avio_rb64(AVIOContext *s)
Definition: aviobuf.c:908
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:451
RMDemuxContext
Definition: rmdec.c:60
rm_read_multi
static int rm_read_multi(AVFormatContext *s, AVIOContext *pb, AVStream *st, char *mime)
Definition: rmdec.c:507
RMDemuxContext::remaining_len
int remaining_len
Definition: rmdec.c:64
DEINT_ID_GENR
#define DEINT_ID_GENR
interleaving for Cooker/ATRAC
Definition: rmdec.c:37
RMStream::sub_packet_h
int sub_packet_h
Definition: rmdec.c:54
rm_read_metadata
static void rm_read_metadata(AVFormatContext *s, AVIOContext *pb, int wide)
Definition: rmdec.c:92
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:180
av_packet_move_ref
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: packet.c:486
index
int index
Definition: gxfenc.c:90
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:184
DEINT_ID_INT4
#define DEINT_ID_INT4
interleaving for 28.8
Definition: rmdec.c:39
ivr_probe
static int ivr_probe(const AVProbeData *p)
Definition: rmdec.c:1187
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:73
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:448
RMDemuxContext::current_stream
int current_stream
Definition: rmdec.c:63
avio_rl32
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:730
ff_rm_alloc_rmstream
RMStream * ff_rm_alloc_rmstream(void)
Definition: rmdec.c:106
AVDISCARD_NONKEY
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition: defs.h:220
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
AVPacket::size
int size
Definition: packet.h:540
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:94
ff_codec_get_id
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:133
AVIOContext::seekable
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:261
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:311
FFStream
Definition: internal.h:132
ff_rm_demuxer
const FFInputFormat ff_rm_demuxer
Definition: rmdec.c:1166
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:83
start_time
static int64_t start_time
Definition: ffplay.c:326
avio_get_str
int avio_get_str(AVIOContext *pb, int maxlen, char *buf, int buflen)
Read a string from pb into buf.
Definition: aviobuf.c:866
size
int size
Definition: twinvq_data.h:10344
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
MKBETAG
#define MKBETAG(a, b, c, d)
Definition: macros.h:56
rm_read_header
static int rm_read_header(AVFormatContext *s)
Definition: rmdec.c:548
AVFMT_NOFILE
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:468
AVMEDIA_TYPE_UNKNOWN
@ AVMEDIA_TYPE_UNKNOWN
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:200
FFInputFormat::p
AVInputFormat p
The public AVInputFormat.
Definition: demux.h:46
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:603
RMStream::sub_packet_lengths
int sub_packet_lengths[16]
Length of each subpacket.
Definition: rmdec.c:56
ffio_ensure_seekback
int ffio_ensure_seekback(AVIOContext *s, int64_t buf_size)
Ensures that the requested seekback buffer size will be available.
Definition: aviobuf.c:1023
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:545
version
version
Definition: libkvazaar.c:321
ff_ivr_demuxer
const FFInputFormat ff_ivr_demuxer
Definition: rmdec.c:1419
RMStream::sub_packet_cnt
int sub_packet_cnt
Definition: rmdec.c:53
ffio_limit
int ffio_limit(AVIOContext *s, int size)
Definition: aviobuf.c:1061
AV_CODEC_ID_RA_288
@ AV_CODEC_ID_RA_288
Definition: codec_id.h:432
rm_read_close
static int rm_read_close(AVFormatContext *s)
Definition: rmdec.c:1085
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:532
avio_internal.h
internal.h
AVCodecParameters::height
int height
Definition: codec_par.h:135
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
AVCodecParameters::block_align
int block_align
Audio only.
Definition: codec_par.h:191
DEINT_ID_VBRF
#define DEINT_ID_VBRF
VBR case for AAC.
Definition: rmdec.c:41
rm_sync
static int rm_sync(AVFormatContext *s, int64_t *timestamp, int *flags, int *stream_index, int64_t *pos)
Definition: rmdec.c:697
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
demux.h
len
int len
Definition: vorbis_enc_data.h:426
av_rescale
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
av_get_packet
int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
Allocate and read the payload of a packet and initialize its fields with default values.
Definition: utils.c:91
tag
uint32_t tag
Definition: movenc.c:1876
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:760
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:748
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:231
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
DEINT_ID_INT0
#define DEINT_ID_INT0
no interleaving needed
Definition: rmdec.c:38
RMDemuxContext::old_format
int old_format
Definition: rmdec.c:62
avio_rb16
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:746
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
Definition: cbs_h264_syntax_template.c:260
AVSTREAM_PARSE_HEADERS
@ AVSTREAM_PARSE_HEADERS
Only parse headers, do not repack.
Definition: avformat.h:594
pos
unsigned int pos
Definition: spdifenc.c:414
avformat.h
dict.h
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
rm_ac3_swap_bytes
static void rm_ac3_swap_bytes(AVStream *st, AVPacket *pkt)
Definition: rmdec.c:880
ff_rm_free_rmstream
void ff_rm_free_rmstream(RMStream *rms)
Definition: rmdec.c:115
rm_read_dts
static int64_t rm_read_dts(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit)
Definition: rmdec.c:1108
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:754
RMStream::coded_framesize
int coded_framesize
Descrambling parameters from container.
Definition: rmdec.c:54
get_str8
static void get_str8(AVIOContext *pb, char *buf, int buf_size)
Definition: rmdec.c:78
channel_layout.h
AVIO_SEEKABLE_NORMAL
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:41
ff_sipr_subpk_size
const unsigned char ff_sipr_subpk_size[4]
Definition: rmsipr.c:25
AVRational::den
int den
Denominator.
Definition: rational.h:60
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:612
temp
else temp
Definition: vf_mcdeint.c:263
AVStream::r_frame_rate
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:914
AVSTREAM_PARSE_FULL_RAW
@ AVSTREAM_PARSE_FULL_RAW
full parsing and repack with timestamp and position generation by parser for raw this assumes that ea...
Definition: avformat.h:597
AVPacket::stream_index
int stream_index
Definition: packet.h:541
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:318
rm_read_seek
static int rm_read_seek(AVFormatContext *s, int stream_index, int64_t pts, int flags)
Definition: rmdec.c:1154
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
read_probe
static int read_probe(const AVProbeData *p)
Definition: cdg.c:30
RMStream::audiotimestamp
int64_t audiotimestamp
Audio descrambling matrix parameters.
Definition: rmdec.c:52
mem.h
ff_rm_read_mdpr_codecdata
int ff_rm_read_mdpr_codecdata(AVFormatContext *s, AVIOContext *pb, AVStream *st, RMStream *rst, unsigned int codec_data_size, const uint8_t *mime)
Read the MDPR chunk, which contains stream-specific codec initialization parameters.
Definition: rmdec.c:315
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
rm_assemble_video_frame
static int rm_assemble_video_frame(AVFormatContext *s, AVIOContext *pb, RMDemuxContext *rm, RMStream *vst, AVPacket *pkt, int len, int *pseq, int64_t *timestamp)
Definition: rmdec.c:777
AV_CHANNEL_LAYOUT_MONO
#define AV_CHANNEL_LAYOUT_MONO
Definition: channel_layout.h:386
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
AVPacket
This structure stores compressed data.
Definition: packet.h:516
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:88
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:559
FFInputFormat
Definition: demux.h:42
ff_rdt_demuxer
const FFInputFormat ff_rdt_demuxer
Definition: rmdec.c:1179
int32_t
int32_t
Definition: audioconvert.c:56
AVSTREAM_PARSE_FULL
@ AVSTREAM_PARSE_FULL
full parsing and repack
Definition: avformat.h:593
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:482
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:97
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AV_CODEC_ID_COOK
@ AV_CODEC_ID_COOK
Definition: codec_id.h:466
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
rm.h
h
h
Definition: vp9dsp_template.c:2070
read_timestamp
static int64_t read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit, int64_t(*read_timestamp)(struct AVFormatContext *, int, int64_t *, int64_t))
Definition: seek.c:281
AVStream::start_time
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base.
Definition: avformat.h:797
AVSTREAM_PARSE_TIMESTAMPS
@ AVSTREAM_PARSE_TIMESTAMPS
full parsing and interpolation of timestamps for frames not starting on a packet boundary
Definition: avformat.h:595
rm_read_header_old
static int rm_read_header_old(AVFormatContext *s)
Definition: rmdec.c:492
RMDemuxContext::audio_pkt_cnt
int audio_pkt_cnt
Output packet counter.
Definition: rmdec.c:66
skip
static void BS_FUNC() skip(BSCTX *bc, unsigned int n)
Skip n bits in the buffer.
Definition: bitstream_template.h:375
RMDemuxContext::nb_packets
int nb_packets
Definition: rmdec.c:61
read
static uint32_t BS_FUNC() read(BSCTX *bc, unsigned int n)
Return n bits from the buffer, n has to be in the 0-32 range.
Definition: bitstream_template.h:231
av_fourcc2str
#define av_fourcc2str(fourcc)
Definition: avutil.h:348
RMDemuxContext::audio_stream_num
int audio_stream_num
Stream number for audio packets.
Definition: rmdec.c:65
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:346