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