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