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  ast->coded_framesize = coded_framesize = avio_rb32(pb); /* coded frame size */
169  avio_rb32(pb); /* ??? */
170  bytes_per_minute = avio_rb32(pb);
171  if (version == 4) {
172  if (bytes_per_minute)
173  st->codecpar->bit_rate = 8LL * bytes_per_minute / 60;
174  }
175  avio_rb32(pb); /* ??? */
176  ast->sub_packet_h = sub_packet_h = avio_rb16(pb); /* 1 */
177  st->codecpar->block_align= avio_rb16(pb); /* frame size */
178  ast->sub_packet_size = sub_packet_size = avio_rb16(pb); /* sub packet size */
179  avio_rb16(pb); /* ??? */
180  if (version == 5) {
181  avio_rb16(pb); avio_rb16(pb); avio_rb16(pb);
182  }
183  st->codecpar->sample_rate = avio_rb16(pb);
184  avio_rb32(pb);
185  st->codecpar->channels = avio_rb16(pb);
186  if (version == 5) {
187  ast->deint_id = avio_rl32(pb);
188  avio_read(pb, buf, 4);
189  buf[4] = 0;
190  } else {
191  AV_WL32(buf, 0);
192  get_str8(pb, buf, sizeof(buf)); /* desc */
193  ast->deint_id = AV_RL32(buf);
194  get_str8(pb, buf, sizeof(buf)); /* desc */
195  }
197  st->codecpar->codec_tag = AV_RL32(buf);
199  st->codecpar->codec_tag);
200 
201  switch (st->codecpar->codec_id) {
202  case AV_CODEC_ID_AC3:
204  break;
205  case AV_CODEC_ID_RA_288:
206  st->codecpar->extradata_size= 0;
207  av_freep(&st->codecpar->extradata);
210  break;
211  case AV_CODEC_ID_COOK:
213  case AV_CODEC_ID_ATRAC3:
214  case AV_CODEC_ID_SIPR:
215  if (read_all) {
216  codecdata_length = 0;
217  } else {
218  avio_rb16(pb); avio_r8(pb);
219  if (version == 5)
220  avio_r8(pb);
221  codecdata_length = avio_rb32(pb);
222  if(codecdata_length + AV_INPUT_BUFFER_PADDING_SIZE <= (unsigned)codecdata_length){
223  av_log(s, AV_LOG_ERROR, "codecdata_length too large\n");
224  return -1;
225  }
226  }
227 
229  if (st->codecpar->codec_id == AV_CODEC_ID_SIPR) {
230  if (flavor > 3) {
231  av_log(s, AV_LOG_ERROR, "bad SIPR file flavor %d\n",
232  flavor);
233  return -1;
234  }
235  st->codecpar->block_align = ff_sipr_subpk_size[flavor];
237  } else {
238  if(sub_packet_size <= 0){
239  av_log(s, AV_LOG_ERROR, "sub_packet_size is invalid\n");
240  return -1;
241  }
243  }
244  if ((ret = rm_read_extradata(s, pb, st->codecpar, codecdata_length)) < 0)
245  return ret;
246 
247  break;
248  case AV_CODEC_ID_AAC:
249  avio_rb16(pb); avio_r8(pb);
250  if (version == 5)
251  avio_r8(pb);
252  codecdata_length = avio_rb32(pb);
253  if(codecdata_length + AV_INPUT_BUFFER_PADDING_SIZE <= (unsigned)codecdata_length){
254  av_log(s, AV_LOG_ERROR, "codecdata_length too large\n");
255  return -1;
256  }
257  if (codecdata_length >= 1) {
258  avio_r8(pb);
259  if ((ret = rm_read_extradata(s, pb, st->codecpar, codecdata_length - 1)) < 0)
260  return ret;
261  }
262  break;
263  }
264  switch (ast->deint_id) {
265  case DEINT_ID_INT4:
266  if (ast->coded_framesize > ast->audio_framesize ||
267  sub_packet_h <= 1 ||
268  ast->coded_framesize * sub_packet_h > (2 + (sub_packet_h & 1)) * ast->audio_framesize)
269  return AVERROR_INVALIDDATA;
270  if (ast->coded_framesize * sub_packet_h != 2*ast->audio_framesize) {
271  avpriv_request_sample(s, "mismatching interleaver parameters");
272  return AVERROR_INVALIDDATA;
273  }
274  break;
275  case DEINT_ID_GENR:
276  if (ast->sub_packet_size <= 0 ||
277  ast->sub_packet_size > ast->audio_framesize)
278  return AVERROR_INVALIDDATA;
279  if (ast->audio_framesize % ast->sub_packet_size)
280  return AVERROR_INVALIDDATA;
281  break;
282  case DEINT_ID_SIPR:
283  case DEINT_ID_INT0:
284  case DEINT_ID_VBRS:
285  case DEINT_ID_VBRF:
286  break;
287  default:
288  av_log(s, AV_LOG_ERROR ,"Unknown interleaver %"PRIX32"\n", ast->deint_id);
289  return AVERROR_INVALIDDATA;
290  }
291  if (ast->deint_id == DEINT_ID_INT4 ||
292  ast->deint_id == DEINT_ID_GENR ||
293  ast->deint_id == DEINT_ID_SIPR) {
294  if (st->codecpar->block_align <= 0 ||
295  ast->audio_framesize * sub_packet_h > (unsigned)INT_MAX ||
296  ast->audio_framesize * sub_packet_h < st->codecpar->block_align)
297  return AVERROR_INVALIDDATA;
298  if (av_new_packet(&ast->pkt, ast->audio_framesize * sub_packet_h) < 0)
299  return AVERROR(ENOMEM);
300  }
301 
302  if (read_all) {
303  avio_r8(pb);
304  avio_r8(pb);
305  avio_r8(pb);
306  rm_read_metadata(s, pb, 0);
307  }
308  }
309  return 0;
310 }
311 
313  AVStream *st, RMStream *rst,
314  unsigned int codec_data_size, const uint8_t *mime)
315 {
316  unsigned int v;
317  int size;
318  int64_t codec_pos;
319  int ret;
320 
321  if (codec_data_size > INT_MAX)
322  return AVERROR_INVALIDDATA;
323  if (codec_data_size == 0)
324  return 0;
325 
326  avpriv_set_pts_info(st, 64, 1, 1000);
327  codec_pos = avio_tell(pb);
328  v = avio_rb32(pb);
329 
330  if (v == MKTAG(0xfd, 'a', 'r', '.')) {
331  /* ra type header */
332  if (rm_read_audio_stream_info(s, pb, st, rst, 0))
333  return -1;
334  } else if (v == MKBETAG('L', 'S', 'D', ':')) {
335  avio_seek(pb, -4, SEEK_CUR);
336  if ((ret = rm_read_extradata(s, pb, st->codecpar, codec_data_size)) < 0)
337  return ret;
338 
342  st->codecpar->codec_tag);
343  } else if(mime && !strcmp(mime, "logical-fileinfo")){
344  int stream_count, rule_count, property_count, i;
345  ff_free_stream(s, st);
346  if (avio_rb16(pb) != 0) {
347  av_log(s, AV_LOG_WARNING, "Unsupported version\n");
348  goto skip;
349  }
350  stream_count = avio_rb16(pb);
351  avio_skip(pb, 6*stream_count);
352  rule_count = avio_rb16(pb);
353  avio_skip(pb, 2*rule_count);
354  property_count = avio_rb16(pb);
355  for(i=0; i<property_count; i++){
356  uint8_t name[128], val[128];
357  avio_rb32(pb);
358  if (avio_rb16(pb) != 0) {
359  av_log(s, AV_LOG_WARNING, "Unsupported Name value property version\n");
360  goto skip; //FIXME skip just this one
361  }
362  get_str8(pb, name, sizeof(name));
363  switch(avio_rb32(pb)) {
364  case 2: get_strl(pb, val, sizeof(val), avio_rb16(pb));
365  av_dict_set(&s->metadata, name, val, 0);
366  break;
367  default: avio_skip(pb, avio_rb16(pb));
368  }
369  }
370  } else {
371  int fps;
372  if (avio_rl32(pb) != MKTAG('V', 'I', 'D', 'O')) {
373  fail1:
374  av_log(s, AV_LOG_WARNING, "Unsupported stream type %08x\n", v);
375  goto skip;
376  }
377  st->codecpar->codec_tag = avio_rl32(pb);
379  st->codecpar->codec_tag);
380  av_log(s, AV_LOG_TRACE, "%"PRIX32" %X\n",
381  st->codecpar->codec_tag, MKTAG('R', 'V', '2', '0'));
382  if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
383  goto fail1;
384  st->codecpar->width = avio_rb16(pb);
385  st->codecpar->height = avio_rb16(pb);
386  avio_skip(pb, 2); // looks like bits per sample
387  avio_skip(pb, 4); // always zero?
390  fps = avio_rb32(pb);
391 
392  if ((ret = rm_read_extradata(s, pb, st->codecpar, codec_data_size - (avio_tell(pb) - codec_pos))) < 0)
393  return ret;
394 
395  if (fps > 0) {
397  0x10000, fps, (1 << 30) - 1);
398 #if FF_API_R_FRAME_RATE
399  st->r_frame_rate = st->avg_frame_rate;
400 #endif
401  } else if (s->error_recognition & AV_EF_EXPLODE) {
402  av_log(s, AV_LOG_ERROR, "Invalid framerate\n");
403  return AVERROR_INVALIDDATA;
404  }
405  }
406 
407 skip:
408  /* skip codec info */
409  size = avio_tell(pb) - codec_pos;
410  if (codec_data_size >= size) {
411  avio_skip(pb, codec_data_size - size);
412  } else {
413  av_log(s, AV_LOG_WARNING, "codec_data_size %u < size %d\n", codec_data_size, size);
414  }
415 
416  return 0;
417 }
418 
419 /** this function assumes that the demuxer has already seeked to the start
420  * of the INDX chunk, and will bail out if not. */
422 {
423  AVIOContext *pb = s->pb;
424  unsigned int size, n_pkts, str_id, next_off, n, pos, pts;
425  AVStream *st;
426 
427  do {
428  if (avio_rl32(pb) != MKTAG('I','N','D','X'))
429  return -1;
430  size = avio_rb32(pb);
431  if (size < 20)
432  return -1;
433  avio_skip(pb, 2);
434  n_pkts = avio_rb32(pb);
435  str_id = avio_rb16(pb);
436  next_off = avio_rb32(pb);
437  for (n = 0; n < s->nb_streams; n++)
438  if (s->streams[n]->id == str_id) {
439  st = s->streams[n];
440  break;
441  }
442  if (n == s->nb_streams) {
443  av_log(s, AV_LOG_ERROR,
444  "Invalid stream index %d for index at pos %"PRId64"\n",
445  str_id, avio_tell(pb));
446  goto skip;
447  } else if ((avio_size(pb) - avio_tell(pb)) / 14 < n_pkts) {
448  av_log(s, AV_LOG_ERROR,
449  "Nr. of packets in packet index for stream index %d "
450  "exceeds filesize (%"PRId64" at %"PRId64" = %"PRId64")\n",
451  str_id, avio_size(pb), avio_tell(pb),
452  (avio_size(pb) - avio_tell(pb)) / 14);
453  goto skip;
454  }
455 
456  for (n = 0; n < n_pkts; n++) {
457  avio_skip(pb, 2);
458  pts = avio_rb32(pb);
459  pos = avio_rb32(pb);
460  avio_skip(pb, 4); /* packet no. */
461 
462  av_add_index_entry(st, pos, pts, 0, 0, AVINDEX_KEYFRAME);
463  }
464 
465 skip:
466  if (next_off && avio_tell(pb) < next_off &&
467  avio_seek(pb, next_off, SEEK_SET) < 0) {
468  av_log(s, AV_LOG_ERROR,
469  "Non-linear index detected, not supported\n");
470  return -1;
471  }
472  } while (next_off);
473 
474  return 0;
475 }
476 
478 {
479  RMDemuxContext *rm = s->priv_data;
480  AVStream *st;
481 
482  rm->old_format = 1;
483  st = avformat_new_stream(s, NULL);
484  if (!st)
485  return -1;
487  if (!st->priv_data)
488  return AVERROR(ENOMEM);
489  return rm_read_audio_stream_info(s, s->pb, st, st->priv_data, 1);
490 }
491 
493  AVStream *st, char *mime)
494 {
495  int number_of_streams = avio_rb16(pb);
496  int number_of_mdpr;
497  int i, ret;
498  unsigned size2;
499  for (i = 0; i<number_of_streams; i++)
500  avio_rb16(pb);
501  number_of_mdpr = avio_rb16(pb);
502  if (number_of_mdpr != 1) {
503  avpriv_request_sample(s, "MLTI with multiple (%d) MDPR", number_of_mdpr);
504  }
505  for (i = 0; i < number_of_mdpr; i++) {
506  AVStream *st2;
507  if (i > 0) {
508  st2 = avformat_new_stream(s, NULL);
509  if (!st2) {
510  ret = AVERROR(ENOMEM);
511  return ret;
512  }
513  st2->id = st->id + (i<<16);
514  st2->codecpar->bit_rate = st->codecpar->bit_rate;
515  st2->start_time = st->start_time;
516  st2->duration = st->duration;
519  if (!st2->priv_data)
520  return AVERROR(ENOMEM);
521  } else
522  st2 = st;
523 
524  size2 = avio_rb32(pb);
525  ret = ff_rm_read_mdpr_codecdata(s, s->pb, st2, st2->priv_data,
526  size2, NULL);
527  if (ret < 0)
528  return ret;
529  }
530  return 0;
531 }
532 
534 {
535  RMDemuxContext *rm = s->priv_data;
536  AVStream *st;
537  AVIOContext *pb = s->pb;
538  unsigned int tag;
539  int tag_size;
540  unsigned int start_time, duration;
541  unsigned int data_off = 0, indx_off = 0;
542  char buf[128], mime[128];
543  int flags = 0;
544  int ret;
545  unsigned size, v;
546  int64_t codec_pos;
547 
548  tag = avio_rl32(pb);
549  if (tag == MKTAG('.', 'r', 'a', 0xfd)) {
550  /* very old .ra format */
551  return rm_read_header_old(s);
552  } else if (tag != MKTAG('.', 'R', 'M', 'F')) {
553  return AVERROR(EIO);
554  }
555 
556  tag_size = avio_rb32(pb);
557  avio_skip(pb, tag_size - 8);
558 
559  for(;;) {
560  ret = AVERROR_INVALIDDATA;
561  if (avio_feof(pb))
562  goto fail;
563  tag = avio_rl32(pb);
564  tag_size = avio_rb32(pb);
565  avio_rb16(pb);
566  av_log(s, AV_LOG_TRACE, "tag=%s size=%d\n",
567  av_fourcc2str(tag), tag_size);
568  if (tag_size < 10 && tag != MKTAG('D', 'A', 'T', 'A'))
569  goto fail;
570  switch(tag) {
571  case MKTAG('P', 'R', 'O', 'P'):
572  /* file header */
573  avio_rb32(pb); /* max bit rate */
574  avio_rb32(pb); /* avg bit rate */
575  avio_rb32(pb); /* max packet size */
576  avio_rb32(pb); /* avg packet size */
577  avio_rb32(pb); /* nb packets */
578  duration = avio_rb32(pb); /* duration */
579  s->duration = av_rescale(duration, AV_TIME_BASE, 1000);
580  avio_rb32(pb); /* preroll */
581  indx_off = avio_rb32(pb); /* index offset */
582  data_off = avio_rb32(pb); /* data offset */
583  avio_rb16(pb); /* nb streams */
584  flags = avio_rb16(pb); /* flags */
585  break;
586  case MKTAG('C', 'O', 'N', 'T'):
587  rm_read_metadata(s, pb, 1);
588  break;
589  case MKTAG('M', 'D', 'P', 'R'):
590  st = avformat_new_stream(s, NULL);
591  if (!st) {
592  ret = AVERROR(ENOMEM);
593  goto fail;
594  }
595  st->id = avio_rb16(pb);
596  avio_rb32(pb); /* max bit rate */
597  st->codecpar->bit_rate = avio_rb32(pb); /* bit rate */
598  avio_rb32(pb); /* max packet size */
599  avio_rb32(pb); /* avg packet size */
600  start_time = avio_rb32(pb); /* start time */
601  avio_rb32(pb); /* preroll */
602  duration = avio_rb32(pb); /* duration */
603  st->start_time = start_time;
604  st->duration = duration;
605  if(duration>0)
607  get_str8(pb, buf, sizeof(buf)); /* desc */
608  get_str8(pb, mime, sizeof(mime)); /* mimetype */
611  if (!st->priv_data)
612  return AVERROR(ENOMEM);
613 
614  size = avio_rb32(pb);
615  codec_pos = avio_tell(pb);
616 
617  ffio_ensure_seekback(pb, 4);
618  v = avio_rb32(pb);
619  if (v == MKBETAG('M', 'L', 'T', 'I')) {
620  ret = rm_read_multi(s, s->pb, st, mime);
621  if (ret < 0)
622  goto fail;
623  avio_seek(pb, codec_pos + size, SEEK_SET);
624  } else {
625  avio_skip(pb, -4);
626  ret = ff_rm_read_mdpr_codecdata(s, s->pb, st, st->priv_data,
627  size, mime);
628  if (ret < 0)
629  goto fail;
630  }
631 
632  break;
633  case MKTAG('D', 'A', 'T', 'A'):
634  goto header_end;
635  default:
636  /* unknown tag: skip it */
637  avio_skip(pb, tag_size - 10);
638  break;
639  }
640  }
641  header_end:
642  rm->nb_packets = avio_rb32(pb); /* number of packets */
643  if (!rm->nb_packets && (flags & 4))
644  rm->nb_packets = 3600 * 25;
645  avio_rb32(pb); /* next data header */
646 
647  if (!data_off)
648  data_off = avio_tell(pb) - 18;
649  if (indx_off && (pb->seekable & AVIO_SEEKABLE_NORMAL) &&
650  !(s->flags & AVFMT_FLAG_IGNIDX) &&
651  avio_seek(pb, indx_off, SEEK_SET) >= 0) {
652  rm_read_index(s);
653  avio_seek(pb, data_off + 18, SEEK_SET);
654  }
655 
656  return 0;
657 
658 fail:
659  rm_read_close(s);
660  return ret;
661 }
662 
663 static int get_num(AVIOContext *pb, int *len)
664 {
665  int n, n1;
666 
667  n = avio_rb16(pb);
668  (*len)-=2;
669  n &= 0x7FFF;
670  if (n >= 0x4000) {
671  return n - 0x4000;
672  } else {
673  n1 = avio_rb16(pb);
674  (*len)-=2;
675  return (n << 16) | n1;
676  }
677 }
678 
679 /* multiple of 20 bytes for ra144 (ugly) */
680 #define RAW_PACKET_SIZE 1000
681 
682 static int rm_sync(AVFormatContext *s, int64_t *timestamp, int *flags, int *stream_index, int64_t *pos){
683  RMDemuxContext *rm = s->priv_data;
684  AVIOContext *pb = s->pb;
685  AVStream *st;
686  uint32_t state=0xFFFFFFFF;
687 
688  while(!avio_feof(pb)){
689  int len, num, i;
690  int mlti_id;
691  *pos= avio_tell(pb) - 3;
692  if(rm->remaining_len > 0){
693  num= rm->current_stream;
694  mlti_id = 0;
695  len= rm->remaining_len;
696  *timestamp = AV_NOPTS_VALUE;
697  *flags= 0;
698  }else{
699  state= (state<<8) + avio_r8(pb);
700 
701  if(state == MKBETAG('I', 'N', 'D', 'X')){
702  int n_pkts, expected_len;
703  len = avio_rb32(pb);
704  avio_skip(pb, 2);
705  n_pkts = avio_rb32(pb);
706  expected_len = 20 + n_pkts * 14;
707  if (len == 20)
708  /* some files don't add index entries to chunk size... */
709  len = expected_len;
710  else if (len != expected_len)
712  "Index size %d (%d pkts) is wrong, should be %d.\n",
713  len, n_pkts, expected_len);
714  len -= 14; // we already read part of the index header
715  if(len<0)
716  continue;
717  goto skip;
718  } else if (state == MKBETAG('D','A','T','A')) {
720  "DATA tag in middle of chunk, file may be broken.\n");
721  }
722 
723  if(state > (unsigned)0xFFFF || state <= 12)
724  continue;
725  len=state - 12;
726  state= 0xFFFFFFFF;
727 
728  num = avio_rb16(pb);
729  *timestamp = avio_rb32(pb);
730  mlti_id = (avio_r8(pb) >> 1) - 1;
731  mlti_id = FFMAX(mlti_id, 0) << 16;
732  *flags = avio_r8(pb); /* flags */
733  }
734  for(i=0;i<s->nb_streams;i++) {
735  st = s->streams[i];
736  if (mlti_id + num == st->id)
737  break;
738  }
739  if (i == s->nb_streams) {
740 skip:
741  /* skip packet if unknown number */
742  avio_skip(pb, len);
743  rm->remaining_len = 0;
744  continue;
745  }
746  *stream_index= i;
747 
748  return len;
749  }
750  return -1;
751 }
752 
754  RMDemuxContext *rm, RMStream *vst,
755  AVPacket *pkt, int len, int *pseq,
756  int64_t *timestamp)
757 {
758  int hdr;
759  int seq = 0, pic_num = 0, len2 = 0, pos = 0; //init to silence compiler warning
760  int type;
761  int ret;
762 
763  hdr = avio_r8(pb); len--;
764  type = hdr >> 6;
765 
766  if(type != 3){ // not frame as a part of packet
767  seq = avio_r8(pb); len--;
768  }
769  if(type != 1){ // not whole frame
770  len2 = get_num(pb, &len);
771  pos = get_num(pb, &len);
772  pic_num = avio_r8(pb); len--;
773  }
774  if(len<0) {
775  av_log(s, AV_LOG_ERROR, "Insufficient data\n");
776  return -1;
777  }
778  rm->remaining_len = len;
779  if(type&1){ // frame, not slice
780  if(type == 3){ // frame as a part of packet
781  len= len2;
782  *timestamp = pos;
783  }
784  if(rm->remaining_len < len) {
785  av_log(s, AV_LOG_ERROR, "Insufficient remaining len\n");
786  return -1;
787  }
788  rm->remaining_len -= len;
789  if ((ret = av_new_packet(pkt, len + 9)) < 0)
790  return ret;
791  pkt->data[0] = 0;
792  AV_WL32(pkt->data + 1, 1);
793  AV_WL32(pkt->data + 5, 0);
794  if ((ret = avio_read(pb, pkt->data + 9, len)) != len) {
795  av_packet_unref(pkt);
796  av_log(s, AV_LOG_ERROR, "Failed to read %d bytes\n", len);
797  return ret < 0 ? ret : AVERROR(EIO);
798  }
799  return 0;
800  }
801  //now we have to deal with single slice
802 
803  *pseq = seq;
804  if((seq & 0x7F) == 1 || vst->curpic_num != pic_num){
805  if (len2 > ffio_limit(pb, len2)) {
806  av_log(s, AV_LOG_ERROR, "Impossibly sized packet\n");
807  return AVERROR_INVALIDDATA;
808  }
809  vst->slices = ((hdr & 0x3F) << 1) + 1;
810  vst->videobufsize = len2 + 8*vst->slices + 1;
811  av_packet_unref(&vst->pkt); //FIXME this should be output.
812  if ((ret = av_new_packet(&vst->pkt, vst->videobufsize)) < 0)
813  return ret;
814  memset(vst->pkt.data, 0, vst->pkt.size);
815  vst->videobufpos = 8*vst->slices + 1;
816  vst->cur_slice = 0;
817  vst->curpic_num = pic_num;
818  vst->pktpos = avio_tell(pb);
819  }
820  if(type == 2)
821  len = FFMIN(len, pos);
822 
823  if(++vst->cur_slice > vst->slices) {
824  av_log(s, AV_LOG_ERROR, "cur slice %d, too large\n", vst->cur_slice);
825  return 1;
826  }
827  if(!vst->pkt.data)
828  return AVERROR(ENOMEM);
829  AV_WL32(vst->pkt.data - 7 + 8*vst->cur_slice, 1);
830  AV_WL32(vst->pkt.data - 3 + 8*vst->cur_slice, vst->videobufpos - 8*vst->slices - 1);
831  if(vst->videobufpos + len > vst->videobufsize) {
832  av_log(s, AV_LOG_ERROR, "outside videobufsize\n");
833  return 1;
834  }
835  if (avio_read(pb, vst->pkt.data + vst->videobufpos, len) != len)
836  return AVERROR(EIO);
837  vst->videobufpos += len;
838  rm->remaining_len-= len;
839 
840  if (type == 2 || vst->videobufpos == vst->videobufsize) {
841  vst->pkt.data[0] = vst->cur_slice-1;
842  av_packet_move_ref(pkt, &vst->pkt);
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=0, 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  if (offset <= 0)
1195  return AVERROR_INVALIDDATA;
1196  avio_skip(pb, offset - avio_tell(pb));
1197  if (avio_r8(pb) != 1)
1198  return AVERROR_INVALIDDATA;
1199  len = avio_rb32(pb);
1200  avio_skip(pb, len);
1201  if (avio_r8(pb) != 2)
1202  return AVERROR_INVALIDDATA;
1203  avio_skip(pb, 16);
1204  pos = avio_tell(pb);
1205  tag = avio_rl32(pb);
1206  }
1207 
1208  if (tag != MKTAG('.','R','E','C'))
1209  return AVERROR_INVALIDDATA;
1210 
1211  if (avio_r8(pb) != 0)
1212  return AVERROR_INVALIDDATA;
1213  count = avio_rb32(pb);
1214  for (i = 0; i < count; i++) {
1215  if (avio_feof(pb))
1216  return AVERROR_INVALIDDATA;
1217 
1218  type = avio_r8(pb);
1219  tlen = avio_rb32(pb);
1220  avio_get_str(pb, tlen, key, sizeof(key));
1221  len = avio_rb32(pb);
1222  if (type == 5) {
1223  avio_get_str(pb, len, val, sizeof(val));
1224  av_log(s, AV_LOG_DEBUG, "%s = '%s'\n", key, val);
1225  } else if (type == 4) {
1226  av_log(s, AV_LOG_DEBUG, "%s = '0x", key);
1227  for (j = 0; j < len; j++) {
1228  if (avio_feof(pb))
1229  return AVERROR_INVALIDDATA;
1230  av_log(s, AV_LOG_DEBUG, "%X", avio_r8(pb));
1231  }
1232  av_log(s, AV_LOG_DEBUG, "'\n");
1233  } else if (len == 4 && type == 3 && !strncmp(key, "StreamCount", tlen)) {
1234  nb_streams = value = avio_rb32(pb);
1235  } else if (len == 4 && type == 3) {
1236  value = avio_rb32(pb);
1237  av_log(s, AV_LOG_DEBUG, "%s = %d\n", key, value);
1238  } else {
1239  av_log(s, AV_LOG_DEBUG, "Skipping unsupported key: %s\n", key);
1240  avio_skip(pb, len);
1241  }
1242  }
1243 
1244  for (n = 0; n < nb_streams; n++) {
1245  st = avformat_new_stream(s, NULL);
1246  if (!st)
1247  return AVERROR(ENOMEM);
1249  if (!st->priv_data)
1250  return AVERROR(ENOMEM);
1251 
1252  if (avio_r8(pb) != 1)
1253  return AVERROR_INVALIDDATA;
1254 
1255  count = avio_rb32(pb);
1256  for (i = 0; i < count; i++) {
1257  if (avio_feof(pb))
1258  return AVERROR_INVALIDDATA;
1259 
1260  type = avio_r8(pb);
1261  tlen = avio_rb32(pb);
1262  avio_get_str(pb, tlen, key, sizeof(key));
1263  len = avio_rb32(pb);
1264  if (type == 5) {
1265  avio_get_str(pb, len, val, sizeof(val));
1266  av_log(s, AV_LOG_DEBUG, "%s = '%s'\n", key, val);
1267  } else if (type == 4 && !strncmp(key, "OpaqueData", tlen)) {
1268  ret = ffio_ensure_seekback(pb, 4);
1269  if (ret < 0)
1270  return ret;
1271  if (avio_rb32(pb) == MKBETAG('M', 'L', 'T', 'I')) {
1272  ret = rm_read_multi(s, pb, st, NULL);
1273  } else {
1274  if (avio_feof(pb))
1275  return AVERROR_INVALIDDATA;
1276  avio_seek(pb, -4, SEEK_CUR);
1277  ret = ff_rm_read_mdpr_codecdata(s, pb, st, st->priv_data, len, NULL);
1278  }
1279 
1280  if (ret < 0)
1281  return ret;
1282  } else if (type == 4) {
1283  int j;
1284 
1285  av_log(s, AV_LOG_DEBUG, "%s = '0x", key);
1286  for (j = 0; j < len; j++)
1287  av_log(s, AV_LOG_DEBUG, "%X", avio_r8(pb));
1288  av_log(s, AV_LOG_DEBUG, "'\n");
1289  } else if (len == 4 && type == 3 && !strncmp(key, "Duration", tlen)) {
1290  st->duration = avio_rb32(pb);
1291  } else if (len == 4 && type == 3) {
1292  value = avio_rb32(pb);
1293  av_log(s, AV_LOG_DEBUG, "%s = %d\n", key, value);
1294  } else {
1295  av_log(s, AV_LOG_DEBUG, "Skipping unsupported key: %s\n", key);
1296  avio_skip(pb, len);
1297  }
1298  }
1299  }
1300 
1301  if (avio_r8(pb) != 6)
1302  return AVERROR_INVALIDDATA;
1303  avio_skip(pb, 12);
1304  avio_skip(pb, avio_rb64(pb) + pos - avio_tell(s->pb));
1305  if (avio_r8(pb) != 8)
1306  return AVERROR_INVALIDDATA;
1307  avio_skip(pb, 8);
1308 
1309  return 0;
1310 }
1311 
1313 {
1314  RMDemuxContext *rm = s->priv_data;
1315  int ret = AVERROR_EOF, opcode;
1316  AVIOContext *pb = s->pb;
1317  unsigned size, index;
1318  int64_t pos, pts;
1319 
1320  if (avio_feof(pb) || rm->data_end)
1321  return AVERROR_EOF;
1322 
1323  pos = avio_tell(pb);
1324 
1325  for (;;) {
1326  if (rm->audio_pkt_cnt) {
1327  // If there are queued audio packet return them first
1328  AVStream *st;
1329 
1330  st = s->streams[rm->audio_stream_num];
1331  ret = ff_rm_retrieve_cache(s, pb, st, st->priv_data, pkt);
1332  if (ret < 0) {
1333  return ret;
1334  }
1335  } else {
1336  if (rm->remaining_len) {
1337  avio_skip(pb, rm->remaining_len);
1338  rm->remaining_len = 0;
1339  }
1340 
1341  if (avio_feof(pb))
1342  return AVERROR_EOF;
1343 
1344  opcode = avio_r8(pb);
1345  if (opcode == 2) {
1346  AVStream *st;
1347  int seq = 1;
1348 
1349  pts = avio_rb32(pb);
1350  index = avio_rb16(pb);
1351  if (index >= s->nb_streams)
1352  return AVERROR_INVALIDDATA;
1353 
1354  avio_skip(pb, 4);
1355  size = avio_rb32(pb);
1356  avio_skip(pb, 4);
1357 
1358  if (size < 1 || size > INT_MAX/4) {
1359  av_log(s, AV_LOG_ERROR, "size %u is invalid\n", size);
1360  return AVERROR_INVALIDDATA;
1361  }
1362 
1363  st = s->streams[index];
1364  ret = ff_rm_parse_packet(s, pb, st, st->priv_data, size, pkt,
1365  &seq, 0, pts);
1366  if (ret < -1) {
1367  return ret;
1368  } else if (ret) {
1369  continue;
1370  }
1371 
1372  pkt->pos = pos;
1373  pkt->pts = pts;
1374  pkt->stream_index = index;
1375  } else if (opcode == 7) {
1376  pos = avio_rb64(pb);
1377  if (!pos) {
1378  rm->data_end = 1;
1379  return AVERROR_EOF;
1380  }
1381  } else {
1382  av_log(s, AV_LOG_ERROR, "Unsupported opcode=%d at %"PRIX64"\n", opcode, avio_tell(pb) - 1);
1383  return AVERROR(EIO);
1384  }
1385  }
1386 
1387  break;
1388  }
1389 
1390  return ret;
1391 }
1392 
1394  .name = "ivr",
1395  .long_name = NULL_IF_CONFIG_SMALL("IVR (Internet Video Recording)"),
1396  .priv_data_size = sizeof(RMDemuxContext),
1397  .read_probe = ivr_probe,
1401  .extensions = "ivr",
1402 };
static int ivr_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: rmdec.c:1312
static int get_num(AVIOContext *pb, int *len)
Definition: rmdec.c:663
#define NULL
Definition: coverity.c:32
full parsing and interpolation of timestamps for frames not starting on a packet boundary ...
Definition: avformat.h:797
#define RAW_PACKET_SIZE
Definition: rmdec.c:680
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:492
#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:1983
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:3096
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:200
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:383
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:4869
#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:877
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:1070
GLint GLenum type
Definition: opengl_enc.c:104
int cur_slice
Definition: rmdec.c:48
void * priv_data
Definition: avformat.h:891
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:533
discard all
Definition: avcodec.h:236
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:775
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:1351
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:1484
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:1161
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:220
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:790
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:883
enum AVStreamParseType need_parsing
Definition: avformat.h:1094
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:4450
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1419
int64_t duration
Definition: movenc.c:63
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1482
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:1532
#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:421
ptrdiff_t size
Definition: opengl_enc.c:100
uint64_t avio_rb64(AVIOContext *s)
Definition: aviobuf.c:911
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:753
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:799
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:812
#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:1591
static int rm_read_close(AVFormatContext *s)
Definition: rmdec.c:1060
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:759
#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:682
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:949
#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:796
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:1407
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
static struct @322 state
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:4371
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:1666
AVInputFormat ff_ivr_demuxer
Definition: rmdec.c:1393
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:527
int audio_framesize
Definition: rmdec.c:54
Stream structure.
Definition: avformat.h:876
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:1393
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: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:312
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:1153
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:994
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:925
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:795
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:458
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base...
Definition: avformat.h:915
int error_recognition
Error recognition; higher values will detect more errors but may misdetect some more or less valid pa...
Definition: avformat.h:1618
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:3277
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:477
#define MKBETAG(a, b, c, d)
Definition: common.h:407
#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:1002
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:1379
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:1466
#define av_freep(p)
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:650
int64_t audiotimestamp
Audio descrambling matrix parameters.
Definition: rmdec.c:51
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1023
int avio_get_str(AVIOContext *pb, int maxlen, char *buf, int buflen)
Read a string from pb into buf.
Definition: aviobuf.c:869
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:406
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:931
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:1000
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
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:1170
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:2115
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