FFmpeg
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
rpl.c
Go to the documentation of this file.
1 /*
2  * ARMovie/RPL demuxer
3  * Copyright (c) 2007 Christian Ohm, 2008 Eli Friedman
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 "libavutil/avstring.h"
23 #include "libavutil/dict.h"
24 #include "avformat.h"
25 #include "internal.h"
26 #include <stdlib.h>
27 
28 #define RPL_SIGNATURE "ARMovie\x0A"
29 #define RPL_SIGNATURE_SIZE 8
30 
31 /** 256 is arbitrary, but should be big enough for any reasonable file. */
32 #define RPL_LINE_LENGTH 256
33 
34 static int rpl_probe(AVProbeData *p)
35 {
36  if (memcmp(p->buf, RPL_SIGNATURE, RPL_SIGNATURE_SIZE))
37  return 0;
38 
39  return AVPROBE_SCORE_MAX;
40 }
41 
42 typedef struct RPLContext {
43  // RPL header data
45 
46  // Stream position data
47  uint32_t chunk_number;
48  uint32_t chunk_part;
49  uint32_t frame_in_part;
50 } RPLContext;
51 
52 static int read_line(AVIOContext * pb, char* line, int bufsize)
53 {
54  int i;
55  for (i = 0; i < bufsize - 1; i++) {
56  int b = avio_r8(pb);
57  if (b == 0)
58  break;
59  if (b == '\n') {
60  line[i] = '\0';
61  return url_feof(pb) ? -1 : 0;
62  }
63  line[i] = b;
64  }
65  line[i] = '\0';
66  return -1;
67 }
68 
69 static int32_t read_int(const char* line, const char** endptr, int* error)
70 {
71  unsigned long result = 0;
72  for (; *line>='0' && *line<='9'; line++) {
73  if (result > (0x7FFFFFFF - 9) / 10)
74  *error = -1;
75  result = 10 * result + *line - '0';
76  }
77  *endptr = line;
78  return result;
79 }
80 
81 static int32_t read_line_and_int(AVIOContext * pb, int* error)
82 {
83  char line[RPL_LINE_LENGTH];
84  const char *endptr;
85  *error |= read_line(pb, line, sizeof(line));
86  return read_int(line, &endptr, error);
87 }
88 
89 /** Parsing for fps, which can be a fraction. Unfortunately,
90  * the spec for the header leaves out a lot of details,
91  * so this is mostly guessing.
92  */
93 static AVRational read_fps(const char* line, int* error)
94 {
95  int64_t num, den = 1;
96  AVRational result;
97  num = read_int(line, &line, error);
98  if (*line == '.')
99  line++;
100  for (; *line>='0' && *line<='9'; line++) {
101  // Truncate any numerator too large to fit into an int64_t
102  if (num > (INT64_MAX - 9) / 10 || den > INT64_MAX / 10)
103  break;
104  num = 10 * num + *line - '0';
105  den *= 10;
106  }
107  if (!num)
108  *error = -1;
109  av_reduce(&result.num, &result.den, num, den, 0x7FFFFFFF);
110  return result;
111 }
112 
114 {
115  AVIOContext *pb = s->pb;
116  RPLContext *rpl = s->priv_data;
117  AVStream *vst = NULL, *ast = NULL;
118  int total_audio_size;
119  int error = 0;
120 
121  uint32_t i;
122 
123  int32_t audio_format, chunk_catalog_offset, number_of_chunks;
124  AVRational fps;
125 
126  char line[RPL_LINE_LENGTH];
127 
128  // The header for RPL/ARMovie files is 21 lines of text
129  // containing the various header fields. The fields are always
130  // in the same order, and other text besides the first
131  // number usually isn't important.
132  // (The spec says that there exists some significance
133  // for the text in a few cases; samples needed.)
134  error |= read_line(pb, line, sizeof(line)); // ARMovie
135  error |= read_line(pb, line, sizeof(line)); // movie name
136  av_dict_set(&s->metadata, "title" , line, 0);
137  error |= read_line(pb, line, sizeof(line)); // date/copyright
138  av_dict_set(&s->metadata, "copyright", line, 0);
139  error |= read_line(pb, line, sizeof(line)); // author and other
140  av_dict_set(&s->metadata, "author" , line, 0);
141 
142  // video headers
143  vst = avformat_new_stream(s, NULL);
144  if (!vst)
145  return AVERROR(ENOMEM);
147  vst->codec->codec_tag = read_line_and_int(pb, &error); // video format
148  vst->codec->width = read_line_and_int(pb, &error); // video width
149  vst->codec->height = read_line_and_int(pb, &error); // video height
150  vst->codec->bits_per_coded_sample = read_line_and_int(pb, &error); // video bits per sample
151  error |= read_line(pb, line, sizeof(line)); // video frames per second
152  fps = read_fps(line, &error);
153  avpriv_set_pts_info(vst, 32, fps.den, fps.num);
154 
155  // Figure out the video codec
156  switch (vst->codec->codec_tag) {
157 #if 0
158  case 122:
159  vst->codec->codec_id = AV_CODEC_ID_ESCAPE122;
160  break;
161 #endif
162  case 124:
164  // The header is wrong here, at least sometimes
165  vst->codec->bits_per_coded_sample = 16;
166  break;
167  case 130:
169  break;
170  default:
172  "RPL video format %i not supported yet!\n",
173  vst->codec->codec_tag);
175  }
176 
177  // Audio headers
178 
179  // ARMovie supports multiple audio tracks; I don't have any
180  // samples, though. This code will ignore additional tracks.
181  audio_format = read_line_and_int(pb, &error); // audio format ID
182  if (audio_format) {
183  ast = avformat_new_stream(s, NULL);
184  if (!ast)
185  return AVERROR(ENOMEM);
186  ast->codec->codec_type = AVMEDIA_TYPE_AUDIO;
187  ast->codec->codec_tag = audio_format;
188  ast->codec->sample_rate = read_line_and_int(pb, &error); // audio bitrate
189  ast->codec->channels = read_line_and_int(pb, &error); // number of audio channels
190  ast->codec->bits_per_coded_sample = read_line_and_int(pb, &error); // audio bits per sample
191  // At least one sample uses 0 for ADPCM, which is really 4 bits
192  // per sample.
193  if (ast->codec->bits_per_coded_sample == 0)
194  ast->codec->bits_per_coded_sample = 4;
195 
196  ast->codec->bit_rate = ast->codec->sample_rate *
197  ast->codec->bits_per_coded_sample *
198  ast->codec->channels;
199 
200  ast->codec->codec_id = AV_CODEC_ID_NONE;
201  switch (audio_format) {
202  case 1:
203  if (ast->codec->bits_per_coded_sample == 16) {
204  // 16-bit audio is always signed
205  ast->codec->codec_id = AV_CODEC_ID_PCM_S16LE;
206  break;
207  }
208  // There are some other formats listed as legal per the spec;
209  // samples needed.
210  break;
211  case 101:
212  if (ast->codec->bits_per_coded_sample == 8) {
213  // The samples with this kind of audio that I have
214  // are all unsigned.
215  ast->codec->codec_id = AV_CODEC_ID_PCM_U8;
216  break;
217  } else if (ast->codec->bits_per_coded_sample == 4) {
218  ast->codec->codec_id = AV_CODEC_ID_ADPCM_IMA_EA_SEAD;
219  break;
220  }
221  break;
222  }
223  if (ast->codec->codec_id == AV_CODEC_ID_NONE) {
225  "RPL audio format %i not supported yet!\n",
226  audio_format);
227  }
228  avpriv_set_pts_info(ast, 32, 1, ast->codec->bit_rate);
229  } else {
230  for (i = 0; i < 3; i++)
231  error |= read_line(pb, line, sizeof(line));
232  }
233 
234  rpl->frames_per_chunk = read_line_and_int(pb, &error); // video frames per chunk
235  if (rpl->frames_per_chunk > 1 && vst->codec->codec_tag != 124)
237  "Don't know how to split frames for video format %i. "
238  "Video stream will be broken!\n", vst->codec->codec_tag);
239 
240  number_of_chunks = read_line_and_int(pb, &error); // number of chunks in the file
241  // The number in the header is actually the index of the last chunk.
242  number_of_chunks++;
243 
244  error |= read_line(pb, line, sizeof(line)); // "even" chunk size in bytes
245  error |= read_line(pb, line, sizeof(line)); // "odd" chunk size in bytes
246  chunk_catalog_offset = // offset of the "chunk catalog"
247  read_line_and_int(pb, &error); // (file index)
248  error |= read_line(pb, line, sizeof(line)); // offset to "helpful" sprite
249  error |= read_line(pb, line, sizeof(line)); // size of "helpful" sprite
250  error |= read_line(pb, line, sizeof(line)); // offset to key frame list
251 
252  // Read the index
253  avio_seek(pb, chunk_catalog_offset, SEEK_SET);
254  total_audio_size = 0;
255  for (i = 0; !error && i < number_of_chunks; i++) {
256  int64_t offset, video_size, audio_size;
257  error |= read_line(pb, line, sizeof(line));
258  if (3 != sscanf(line, "%"PRId64" , %"PRId64" ; %"PRId64,
259  &offset, &video_size, &audio_size))
260  error = -1;
261  av_add_index_entry(vst, offset, i * rpl->frames_per_chunk,
262  video_size, rpl->frames_per_chunk, 0);
263  if (ast)
264  av_add_index_entry(ast, offset + video_size, total_audio_size,
265  audio_size, audio_size * 8, 0);
266  total_audio_size += audio_size * 8;
267  }
268 
269  if (error) return AVERROR(EIO);
270 
271  return 0;
272 }
273 
275 {
276  RPLContext *rpl = s->priv_data;
277  AVIOContext *pb = s->pb;
278  AVStream* stream;
279  AVIndexEntry* index_entry;
280  uint32_t ret;
281 
282  if (rpl->chunk_part == s->nb_streams) {
283  rpl->chunk_number++;
284  rpl->chunk_part = 0;
285  }
286 
287  stream = s->streams[rpl->chunk_part];
288 
289  if (rpl->chunk_number >= stream->nb_index_entries)
290  return AVERROR_EOF;
291 
292  index_entry = &stream->index_entries[rpl->chunk_number];
293 
294  if (rpl->frame_in_part == 0)
295  if (avio_seek(pb, index_entry->pos, SEEK_SET) < 0)
296  return AVERROR(EIO);
297 
298  if (stream->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
299  stream->codec->codec_tag == 124) {
300  // We have to split Escape 124 frames because there are
301  // multiple frames per chunk in Escape 124 samples.
302  uint32_t frame_size;
303 
304  avio_skip(pb, 4); /* flags */
305  frame_size = avio_rl32(pb);
306  if (avio_seek(pb, -8, SEEK_CUR) < 0)
307  return AVERROR(EIO);
308 
309  ret = av_get_packet(pb, pkt, frame_size);
310  if (ret != frame_size) {
311  av_free_packet(pkt);
312  return AVERROR(EIO);
313  }
314  pkt->duration = 1;
315  pkt->pts = index_entry->timestamp + rpl->frame_in_part;
316  pkt->stream_index = rpl->chunk_part;
317 
318  rpl->frame_in_part++;
319  if (rpl->frame_in_part == rpl->frames_per_chunk) {
320  rpl->frame_in_part = 0;
321  rpl->chunk_part++;
322  }
323  } else {
324  ret = av_get_packet(pb, pkt, index_entry->size);
325  if (ret != index_entry->size) {
326  av_free_packet(pkt);
327  return AVERROR(EIO);
328  }
329 
330  if (stream->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
331  // frames_per_chunk should always be one here; the header
332  // parsing will warn if it isn't.
333  pkt->duration = rpl->frames_per_chunk;
334  } else {
335  // All the audio codecs supported in this container
336  // (at least so far) are constant-bitrate.
337  pkt->duration = ret * 8;
338  }
339  pkt->pts = index_entry->timestamp;
340  pkt->stream_index = rpl->chunk_part;
341  rpl->chunk_part++;
342  }
343 
344  // None of the Escape formats have keyframes, and the ADPCM
345  // format used doesn't have keyframes.
346  if (rpl->chunk_number == 0 && rpl->frame_in_part == 0)
347  pkt->flags |= AV_PKT_FLAG_KEY;
348 
349  return ret;
350 }
351 
353  .name = "rpl",
354  .long_name = NULL_IF_CONFIG_SMALL("RPL / ARMovie"),
355  .priv_data_size = sizeof(RPLContext),
359 };