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