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