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