FFmpeg
xmv.c
Go to the documentation of this file.
1 /*
2  * Microsoft XMV demuxer
3  * Copyright (c) 2011 Sven Hesse <drmccoy@drmccoy.de>
4  * Copyright (c) 2011 Matthew Hoops <clone2727@gmail.com>
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * Microsoft XMV demuxer
26  */
27 
28 #include <inttypes.h>
29 
30 #include "libavutil/intreadwrite.h"
31 
32 #include "avformat.h"
33 #include "internal.h"
34 #include "riff.h"
35 #include "libavutil/avassert.h"
36 
37 /** The min size of an XMV header. */
38 #define XMV_MIN_HEADER_SIZE 36
39 
40 /** Audio flag: ADPCM'd 5.1 stream, front left / right channels */
41 #define XMV_AUDIO_ADPCM51_FRONTLEFTRIGHT 1
42 /** Audio flag: ADPCM'd 5.1 stream, front center / low frequency channels */
43 #define XMV_AUDIO_ADPCM51_FRONTCENTERLOW 2
44 /** Audio flag: ADPCM'd 5.1 stream, rear left / right channels */
45 #define XMV_AUDIO_ADPCM51_REARLEFTRIGHT 4
46 
47 /** Audio flag: Any of the ADPCM'd 5.1 stream flags. */
48 #define XMV_AUDIO_ADPCM51 (XMV_AUDIO_ADPCM51_FRONTLEFTRIGHT | \
49  XMV_AUDIO_ADPCM51_FRONTCENTERLOW | \
50  XMV_AUDIO_ADPCM51_REARLEFTRIGHT)
51 
52 #define XMV_BLOCK_ALIGN_SIZE 36
53 
54 /** A video packet with an XMV file. */
55 typedef struct XMVVideoPacket {
56  int created;
57  int stream_index; ///< The decoder stream index for this video packet.
58 
59  uint32_t data_size; ///< The size of the remaining video data.
60  uint64_t data_offset; ///< The offset of the video data within the file.
61 
62  uint32_t current_frame; ///< The current frame within this video packet.
63  uint32_t frame_count; ///< The amount of frames within this video packet.
64 
65  int has_extradata; ///< Does the video packet contain extra data?
66  uint8_t extradata[4]; ///< The extra data
67 
68  int64_t last_pts; ///< PTS of the last video frame.
69  int64_t pts; ///< PTS of the most current video frame.
71 
72 /** An audio packet with an XMV file. */
73 typedef struct XMVAudioPacket {
74  int created;
75  int stream_index; ///< The decoder stream index for this audio packet.
76 
77  /* Stream format properties. */
78  uint16_t compression; ///< The type of compression.
79  uint16_t channels; ///< Number of channels.
80  int32_t sample_rate; ///< Sampling rate.
81  uint16_t bits_per_sample; ///< Bits per compressed sample.
82  uint64_t bit_rate; ///< Bits of compressed data per second.
83  uint16_t flags; ///< Flags
84  unsigned block_align; ///< Bytes per compressed block.
85  uint16_t block_samples; ///< Decompressed samples per compressed block.
86 
87  enum AVCodecID codec_id; ///< The codec ID of the compression scheme.
88 
89  uint32_t data_size; ///< The size of the remaining audio data.
90  uint64_t data_offset; ///< The offset of the audio data within the file.
91 
92  uint32_t frame_size; ///< Number of bytes to put into an audio frame.
93 
94  uint64_t block_count; ///< Running counter of decompressed audio block.
96 
97 /** Context for demuxing an XMV file. */
98 typedef struct XMVDemuxContext {
99  uint16_t audio_track_count; ///< Number of audio track in this file.
100 
101  uint32_t this_packet_size; ///< Size of the current packet.
102  uint32_t next_packet_size; ///< Size of the next packet.
103 
104  uint64_t this_packet_offset; ///< Offset of the current packet.
105  uint64_t next_packet_offset; ///< Offset of the next packet.
106 
107  uint16_t current_stream; ///< The index of the stream currently handling.
108  uint16_t stream_count; ///< The number of streams in this file.
109 
110  uint32_t video_duration;
111  uint32_t video_width;
112  uint32_t video_height;
113 
114  XMVVideoPacket video; ///< The video packet contained in each packet.
115  XMVAudioPacket *audio; ///< The audio packets contained in each packet.
117 
118 static int xmv_probe(const AVProbeData *p)
119 {
120  uint32_t file_version;
121 
122  if (p->buf_size < XMV_MIN_HEADER_SIZE)
123  return 0;
124 
125  file_version = AV_RL32(p->buf + 16);
126  if ((file_version == 0) || (file_version > 4))
127  return 0;
128 
129  if (!memcmp(p->buf + 12, "xobX", 4))
130  return AVPROBE_SCORE_MAX;
131 
132  return 0;
133 }
134 
136 {
137  XMVDemuxContext *xmv = s->priv_data;
138 
139  av_freep(&xmv->audio);
140 
141  return 0;
142 }
143 
145 {
146  XMVDemuxContext *xmv = s->priv_data;
147  AVIOContext *pb = s->pb;
148 
149  uint32_t file_version;
150  uint32_t this_packet_size;
151  uint16_t audio_track;
152  int ret;
153 
154  s->ctx_flags |= AVFMTCTX_NOHEADER;
155 
156  avio_skip(pb, 4); /* Next packet size */
157 
158  this_packet_size = avio_rl32(pb);
159 
160  avio_skip(pb, 4); /* Max packet size */
161  avio_skip(pb, 4); /* "xobX" */
162 
163  file_version = avio_rl32(pb);
164  if ((file_version != 4) && (file_version != 2))
165  avpriv_request_sample(s, "Uncommon version %"PRIu32"", file_version);
166 
167  /* Video tracks */
168 
169  xmv->video_width = avio_rl32(pb);
170  xmv->video_height = avio_rl32(pb);
171  xmv->video_duration = avio_rl32(pb);
172 
173  /* Audio tracks */
174 
175  xmv->audio_track_count = avio_rl16(pb);
176 
177  avio_skip(pb, 2); /* Unknown (padding?) */
178 
180  if (!xmv->audio) {
181  ret = AVERROR(ENOMEM);
182  goto fail;
183  }
184 
185  for (audio_track = 0; audio_track < xmv->audio_track_count; audio_track++) {
186  XMVAudioPacket *packet = &xmv->audio[audio_track];
187 
188  packet->compression = avio_rl16(pb);
189  packet->channels = avio_rl16(pb);
190  packet->sample_rate = avio_rl32(pb);
191  packet->bits_per_sample = avio_rl16(pb);
192  packet->flags = avio_rl16(pb);
193 
194  packet->bit_rate = (uint64_t)packet->bits_per_sample *
195  packet->sample_rate *
196  packet->channels;
197  packet->block_align = XMV_BLOCK_ALIGN_SIZE * packet->channels;
198  packet->block_samples = 64;
199  packet->codec_id = ff_wav_codec_get_id(packet->compression,
200  packet->bits_per_sample);
201 
202  packet->stream_index = -1;
203 
204  packet->frame_size = 0;
205  packet->block_count = 0;
206 
207  /* TODO: ADPCM'd 5.1 sound is encoded in three separate streams.
208  * Those need to be interleaved to a proper 5.1 stream. */
209  if (packet->flags & XMV_AUDIO_ADPCM51)
210  av_log(s, AV_LOG_WARNING, "Unsupported 5.1 ADPCM audio stream "
211  "(0x%04X)\n", packet->flags);
212 
213  if (!packet->channels || packet->sample_rate <= 0 ||
214  packet->channels >= UINT16_MAX / XMV_BLOCK_ALIGN_SIZE) {
215  av_log(s, AV_LOG_ERROR, "Invalid parameters for audio track %"PRIu16".\n",
216  audio_track);
218  goto fail;
219  }
220  }
221 
222 
223  /* Initialize the packet context */
224 
225  xmv->next_packet_offset = avio_tell(pb);
226  xmv->next_packet_size = this_packet_size - xmv->next_packet_offset;
227  xmv->stream_count = xmv->audio_track_count + 1;
228 
229  return 0;
230 
231 fail:
232  xmv_read_close(s);
233  return ret;
234 }
235 
236 static void xmv_read_extradata(uint8_t *extradata, AVIOContext *pb)
237 {
238  /* Read the XMV extradata */
239 
240  uint32_t data = avio_rl32(pb);
241 
242  int mspel_bit = !!(data & 0x01);
243  int loop_filter = !!(data & 0x02);
244  int abt_flag = !!(data & 0x04);
245  int j_type_bit = !!(data & 0x08);
246  int top_left_mv_flag = !!(data & 0x10);
247  int per_mb_rl_bit = !!(data & 0x20);
248  int slice_count = (data >> 6) & 7;
249 
250  /* Write it back as standard WMV2 extradata */
251 
252  data = 0;
253 
254  data |= mspel_bit << 15;
255  data |= loop_filter << 14;
256  data |= abt_flag << 13;
257  data |= j_type_bit << 12;
258  data |= top_left_mv_flag << 11;
259  data |= per_mb_rl_bit << 10;
260  data |= slice_count << 7;
261 
262  AV_WB32(extradata, data);
263 }
264 
266 {
267  XMVDemuxContext *xmv = s->priv_data;
268  AVIOContext *pb = s->pb;
269  int ret;
270 
271  uint8_t data[8];
272  uint16_t audio_track;
273  uint64_t data_offset;
274 
275  /* Next packet size */
276  xmv->next_packet_size = avio_rl32(pb);
277 
278  /* Packet video header */
279 
280  if (avio_read(pb, data, 8) != 8)
281  return AVERROR(EIO);
282 
283  xmv->video.data_size = AV_RL32(data) & 0x007FFFFF;
284 
285  xmv->video.current_frame = 0;
286  xmv->video.frame_count = (AV_RL32(data) >> 23) & 0xFF;
287 
288  xmv->video.has_extradata = (data[3] & 0x80) != 0;
289 
290  if (!xmv->video.created) {
292  if (!vst)
293  return AVERROR(ENOMEM);
294 
295  avpriv_set_pts_info(vst, 32, 1, 1000);
296 
299  vst->codecpar->codec_tag = MKBETAG('W', 'M', 'V', '2');
300  vst->codecpar->width = xmv->video_width;
301  vst->codecpar->height = xmv->video_height;
302 
303  vst->duration = xmv->video_duration;
304 
305  xmv->video.stream_index = vst->index;
306 
307  xmv->video.created = 1;
308  }
309 
310  /* Adding the audio data sizes and the video data size keeps you 4 bytes
311  * short for every audio track. But as playing around with XMV files with
312  * ADPCM audio showed, taking the extra 4 bytes from the audio data gives
313  * you either completely distorted audio or click (when skipping the
314  * remaining 68 bytes of the ADPCM block). Subtracting 4 bytes for every
315  * audio track from the video data works at least for the audio. Probably
316  * some alignment thing?
317  * The video data has (always?) lots of padding, so it should work out...
318  */
319  xmv->video.data_size -= xmv->audio_track_count * 4;
320 
321  xmv->current_stream = 0;
322  if (!xmv->video.frame_count) {
323  xmv->video.frame_count = 1;
324  xmv->current_stream = xmv->stream_count > 1;
325  }
326 
327  /* Packet audio header */
328 
329  for (audio_track = 0; audio_track < xmv->audio_track_count; audio_track++) {
330  XMVAudioPacket *packet = &xmv->audio[audio_track];
331 
332  if (avio_read(pb, data, 4) != 4)
333  return AVERROR(EIO);
334 
335  if (!packet->created) {
337  if (!ast)
338  return AVERROR(ENOMEM);
339 
341  ast->codecpar->codec_id = packet->codec_id;
342  ast->codecpar->codec_tag = packet->compression;
343  ast->codecpar->channels = packet->channels;
344  ast->codecpar->sample_rate = packet->sample_rate;
346  ast->codecpar->bit_rate = packet->bit_rate;
347  ast->codecpar->block_align = 36 * packet->channels;
348 
349  avpriv_set_pts_info(ast, 32, packet->block_samples, packet->sample_rate);
350 
351  packet->stream_index = ast->index;
352 
353  ast->duration = xmv->video_duration;
354 
355  packet->created = 1;
356  }
357 
358  packet->data_size = AV_RL32(data) & 0x007FFFFF;
359  if ((packet->data_size == 0) && (audio_track != 0))
360  /* This happens when I create an XMV with several identical audio
361  * streams. From the size calculations, duplicating the previous
362  * stream's size works out, but the track data itself is silent.
363  * Maybe this should also redirect the offset to the previous track?
364  */
365  packet->data_size = xmv->audio[audio_track - 1].data_size;
366 
367  /* Carve up the audio data in frame_count slices */
368  packet->frame_size = packet->data_size / xmv->video.frame_count;
369  packet->frame_size -= packet->frame_size % packet->block_align;
370  }
371 
372  /* Packet data offsets */
373 
374  data_offset = avio_tell(pb);
375 
376  xmv->video.data_offset = data_offset;
377  data_offset += xmv->video.data_size;
378 
379  for (audio_track = 0; audio_track < xmv->audio_track_count; audio_track++) {
380  xmv->audio[audio_track].data_offset = data_offset;
381  data_offset += xmv->audio[audio_track].data_size;
382  }
383 
384  /* Video frames header */
385 
386  /* Read new video extra data */
387  if (xmv->video.data_size > 0) {
388  if (xmv->video.has_extradata) {
390 
391  xmv->video.data_size -= 4;
392  xmv->video.data_offset += 4;
393 
394  if (xmv->video.stream_index >= 0) {
395  AVStream *vst = s->streams[xmv->video.stream_index];
396 
397  av_assert0(xmv->video.stream_index < s->nb_streams);
398 
399  if (vst->codecpar->extradata_size < 4) {
400  if ((ret = ff_alloc_extradata(vst->codecpar, 4)) < 0)
401  return ret;
402  }
403 
404  memcpy(vst->codecpar->extradata, xmv->video.extradata, 4);
405  }
406  }
407  }
408 
409  return 0;
410 }
411 
413 {
414  XMVDemuxContext *xmv = s->priv_data;
415  AVIOContext *pb = s->pb;
416  int result;
417 
418  if (xmv->this_packet_offset == xmv->next_packet_offset)
419  return AVERROR_EOF;
420 
421  /* Seek to it */
423  if (avio_seek(pb, xmv->this_packet_offset, SEEK_SET) != xmv->this_packet_offset)
424  return AVERROR(EIO);
425 
426  /* Update the size */
428  if (xmv->this_packet_size < (12 + xmv->audio_track_count * 4))
429  return AVERROR(EIO);
430 
431  /* Process the header */
433  if (result)
434  return result;
435 
436  /* Update the offset */
438 
439  return 0;
440 }
441 
443  AVPacket *pkt, uint32_t stream)
444 {
445  XMVDemuxContext *xmv = s->priv_data;
446  AVIOContext *pb = s->pb;
447  XMVAudioPacket *audio = &xmv->audio[stream];
448 
449  uint32_t data_size;
450  uint32_t block_count;
451  int result;
452 
453  /* Seek to it */
454  if (avio_seek(pb, audio->data_offset, SEEK_SET) != audio->data_offset)
455  return AVERROR(EIO);
456 
457  if ((xmv->video.current_frame + 1) < xmv->video.frame_count)
458  /* Not the last frame, get at most frame_size bytes. */
459  data_size = FFMIN(audio->frame_size, audio->data_size);
460  else
461  /* Last frame, get the rest. */
462  data_size = audio->data_size;
463 
464  /* Read the packet */
465  result = av_get_packet(pb, pkt, data_size);
466  if (result <= 0)
467  return result;
468 
469  pkt->stream_index = audio->stream_index;
470 
471  /* Calculate the PTS */
472 
473  block_count = data_size / audio->block_align;
474 
475  pkt->duration = block_count;
476  pkt->pts = audio->block_count;
478 
479  audio->block_count += block_count;
480 
481  /* Advance offset */
482  audio->data_size -= data_size;
483  audio->data_offset += data_size;
484 
485  return 0;
486 }
487 
489  AVPacket *pkt)
490 {
491  XMVDemuxContext *xmv = s->priv_data;
492  AVIOContext *pb = s->pb;
493  XMVVideoPacket *video = &xmv->video;
494 
495  int result;
496  uint32_t frame_header;
497  uint32_t frame_size, frame_timestamp;
498  uint8_t *data, *end;
499 
500  /* Seek to it */
501  if (avio_seek(pb, video->data_offset, SEEK_SET) != video->data_offset)
502  return AVERROR(EIO);
503 
504  /* Read the frame header */
505  frame_header = avio_rl32(pb);
506 
507  frame_size = (frame_header & 0x1FFFF) * 4 + 4;
508  frame_timestamp = (frame_header >> 17);
509 
510  if ((frame_size + 4) > video->data_size)
511  return AVERROR(EIO);
512 
513  /* Get the packet data */
515  if (result != frame_size)
516  return result;
517 
518  /* Contrary to normal WMV2 video, the bit stream in XMV's
519  * WMV2 is little-endian.
520  * TODO: This manual swap is of course suboptimal.
521  */
522  for (data = pkt->data, end = pkt->data + frame_size; data < end; data += 4)
524 
525  pkt->stream_index = video->stream_index;
526 
527  /* Calculate the PTS */
528 
529  video->last_pts = frame_timestamp + video->pts;
530 
531  pkt->duration = 0;
532  pkt->pts = video->last_pts;
534 
535  video->pts += frame_timestamp;
536 
537  /* Keyframe? */
538  pkt->flags = (pkt->data[0] & 0x80) ? 0 : AV_PKT_FLAG_KEY;
539 
540  /* Advance offset */
541  video->data_size -= frame_size + 4;
542  video->data_offset += frame_size + 4;
543 
544  return 0;
545 }
546 
548  AVPacket *pkt)
549 {
550  XMVDemuxContext *xmv = s->priv_data;
551  int result;
552 
553  if (xmv->video.current_frame == xmv->video.frame_count) {
554  /* No frames left in this packet, so we fetch a new one */
555 
557  if (result)
558  return result;
559  }
560 
561  if (xmv->current_stream == 0) {
562  /* Fetch a video frame */
563 
565  } else {
566  /* Fetch an audio frame */
567 
569  }
570  if (result) {
571  xmv->current_stream = 0;
572  xmv->video.current_frame = xmv->video.frame_count;
573  return result;
574  }
575 
576 
577  /* Increase our counters */
578  if (++xmv->current_stream >= xmv->stream_count) {
579  xmv->current_stream = 0;
580  xmv->video.current_frame += 1;
581  }
582 
583  return 0;
584 }
585 
587  .name = "xmv",
588  .long_name = NULL_IF_CONFIG_SMALL("Microsoft XMV"),
589  .extensions = "xmv",
590  .priv_data_size = sizeof(XMVDemuxContext),
595 };
XMVDemuxContext::video_height
uint32_t video_height
Definition: xmv.c:112
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
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:4526
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:55
XMVDemuxContext::audio
XMVAudioPacket * audio
The audio packets contained in each packet.
Definition: xmv.c:115
XMVAudioPacket::flags
uint16_t flags
Flags.
Definition: xmv.c:83
XMVDemuxContext::video_duration
uint32_t video_duration
Definition: xmv.c:110
end
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:92
ff_wav_codec_get_id
enum AVCodecID ff_wav_codec_get_id(unsigned int tag, int bps)
Definition: riffdec.c:192
AVPacket::data
uint8_t * data
Definition: packet.h:355
data
const char data[16]
Definition: mxf.c:91
XMVAudioPacket::frame_size
uint32_t frame_size
Number of bytes to put into an audio frame.
Definition: xmv.c:92
XMVDemuxContext::next_packet_size
uint32_t next_packet_size
Size of the next packet.
Definition: xmv.c:102
av_mallocz_array
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:190
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:373
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:64
AVProbeData::buf_size
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:444
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:388
xmv_fetch_new_packet
static int xmv_fetch_new_packet(AVFormatContext *s)
Definition: xmv.c:412
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:453
XMVVideoPacket
A video packet with an XMV file.
Definition: xmv.c:55
AVCodecParameters::channels
int channels
Audio only.
Definition: codec_par.h:166
XMVAudioPacket::created
int created
Definition: xmv.c:74
xmv_read_packet
static int xmv_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: xmv.c:547
fail
#define fail()
Definition: checkasm.h:123
XMVAudioPacket::block_align
unsigned block_align
Bytes per compressed block.
Definition: xmv.c:84
XMVVideoPacket::created
int created
Definition: xmv.c:56
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
xmv_read_header
static int xmv_read_header(AVFormatContext *s)
Definition: xmv.c:144
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:914
XMVAudioPacket::bits_per_sample
uint16_t bits_per_sample
Bits per compressed sample.
Definition: xmv.c:81
avio_rl16
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:731
XMVVideoPacket::data_size
uint32_t data_size
The size of the remaining video data.
Definition: xmv.c:59
avassert.h
XMVAudioPacket::bit_rate
uint64_t bit_rate
Bits of compressed data per second.
Definition: xmv.c:82
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
AVInputFormat
Definition: avformat.h:636
XMVAudioPacket
An audio packet with an XMV file.
Definition: xmv.c:73
xmv_process_packet_header
static int xmv_process_packet_header(AVFormatContext *s)
Definition: xmv.c:265
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:257
XMVDemuxContext::this_packet_offset
uint64_t this_packet_offset
Offset of the current packet.
Definition: xmv.c:104
XMVDemuxContext::current_stream
uint16_t current_stream
The index of the stream currently handling.
Definition: xmv.c:107
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:641
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:443
frame_size
int frame_size
Definition: mxfenc.c:2137
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:126
XMVDemuxContext::next_packet_offset
uint64_t next_packet_offset
Offset of the next packet.
Definition: xmv.c:105
XMVVideoPacket::current_frame
uint32_t current_frame
The current frame within this video packet.
Definition: xmv.c:62
AV_CODEC_ID_WMV2
@ AV_CODEC_ID_WMV2
Definition: codec_id.h:67
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
XMVVideoPacket::has_extradata
int has_extradata
Does the video packet contain extra data?
Definition: xmv.c:65
xmv_fetch_audio_packet
static int xmv_fetch_audio_packet(AVFormatContext *s, AVPacket *pkt, uint32_t stream)
Definition: xmv.c:442
int32_t
int32_t
Definition: audio_convert.c:194
XMVDemuxContext::this_packet_size
uint32_t this_packet_size
Size of the current packet.
Definition: xmv.c:101
AVFormatContext
Format I/O context.
Definition: avformat.h:1335
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1012
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:527
result
and forward the result(frame or status change) to the corresponding input. If nothing is possible
XMVAudioPacket::channels
uint16_t channels
Number of channels.
Definition: xmv.c:79
NULL
#define NULL
Definition: coverity.c:32
read_probe
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
AVFMTCTX_NOHEADER
#define AVFMTCTX_NOHEADER
signal that no header is present (streams are added dynamically)
Definition: avformat.h:1284
XMVAudioPacket::data_size
uint32_t data_size
The size of the remaining audio data.
Definition: xmv.c:89
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:441
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:170
XMV_BLOCK_ALIGN_SIZE
#define XMV_BLOCK_ALIGN_SIZE
Definition: xmv.c:52
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:46
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:78
AV_WB32
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
avio_rl32
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:747
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
XMVAudioPacket::sample_rate
int32_t sample_rate
Sampling rate.
Definition: xmv.c:80
XMVAudioPacket::block_samples
uint16_t block_samples
Decompressed samples per compressed block.
Definition: xmv.c:85
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:188
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:4948
XMVDemuxContext::audio_track_count
uint16_t audio_track_count
Number of audio track in this file.
Definition: xmv.c:99
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
MKBETAG
#define MKBETAG(a, b, c, d)
Definition: common.h:407
XMV_AUDIO_ADPCM51
#define XMV_AUDIO_ADPCM51
Audio flag: Any of the ADPCM'd 5.1 stream flags.
Definition: xmv.c:48
XMV_MIN_HEADER_SIZE
#define XMV_MIN_HEADER_SIZE
The min size of an XMV header.
Definition: xmv.c:38
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:354
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
XMVDemuxContext::video_width
uint32_t video_width
Definition: xmv.c:111
XMVVideoPacket::stream_index
int stream_index
The decoder stream index for this video packet.
Definition: xmv.c:57
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:361
XMVVideoPacket::last_pts
int64_t last_pts
PTS of the last video frame.
Definition: xmv.c:68
XMVVideoPacket::data_offset
uint64_t data_offset
The offset of the video data within the file.
Definition: xmv.c:60
loop_filter
static void loop_filter(const H264Context *h, H264SliceContext *sl, int start_x, int end_x)
Definition: h264_slice.c:2452
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:348
AVCodecParameters::height
int height
Definition: codec_par.h:127
AVCodecParameters::block_align
int block_align
Audio only.
Definition: codec_par.h:177
uint8_t
uint8_t
Definition: audio_convert.c:194
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:307
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:865
ff_xmv_demuxer
AVInputFormat ff_xmv_demuxer
Definition: xmv.c:586
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:241
xmv_read_close
static int xmv_read_close(AVFormatContext *s)
Definition: xmv.c:135
avformat.h
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:88
XMVAudioPacket::stream_index
int stream_index
The decoder stream index for this audio packet.
Definition: xmv.c:75
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:866
frame_header
Definition: truemotion1.c:87
frame_header
static int FUNC() frame_header(CodedBitstreamContext *ctx, RWContext *rw, JPEGRawFrameHeader *current)
Definition: cbs_jpeg_syntax_template.c:19
pkt
static AVPacket pkt
Definition: demuxing_decoding.c:54
XMVDemuxContext
Context for demuxing an XMV file.
Definition: xmv.c:98
xmv_read_extradata
static void xmv_read_extradata(uint8_t *extradata, AVIOContext *pb)
Definition: xmv.c:236
XMVAudioPacket::codec_id
enum AVCodecID codec_id
The codec ID of the compression scheme.
Definition: xmv.c:87
xmv_fetch_video_packet
static int xmv_fetch_video_packet(AVFormatContext *s, AVPacket *pkt)
Definition: xmv.c:488
video
A Quick Description Of Rate Distortion Theory We want to encode a video
Definition: rate_distortion.txt:3
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:625
XMVDemuxContext::video
XMVVideoPacket video
The video packet contained in each packet.
Definition: xmv.c:114
AVPacket::stream_index
int stream_index
Definition: packet.h:357
XMVAudioPacket::data_offset
uint64_t data_offset
The offset of the audio data within the file.
Definition: xmv.c:90
XMVDemuxContext::stream_count
uint16_t stream_count
The number of streams in this file.
Definition: xmv.c:108
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:329
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
XMVAudioPacket::compression
uint16_t compression
The type of compression.
Definition: xmv.c:78
AVCodecParameters::bits_per_coded_sample
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:102
XMVVideoPacket::extradata
uint8_t extradata[4]
The extra data.
Definition: xmv.c:66
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:39
XMVVideoPacket::frame_count
uint32_t frame_count
The amount of frames within this video packet.
Definition: xmv.c:63
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:332
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
riff.h
XMVVideoPacket::pts
int64_t pts
PTS of the most current video frame.
Definition: xmv.c:69
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
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
XMVAudioPacket::block_count
uint64_t block_count
Running counter of decompressed audio block.
Definition: xmv.c:94
xmv_probe
static int xmv_probe(const AVProbeData *p)
Definition: xmv.c:118
ff_alloc_extradata
int ff_alloc_extradata(AVCodecParameters *par, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0.
Definition: utils.c:3328