FFmpeg: libavformat/xmv.c Source File

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

AltStyle によって変換されたページ (->オリジナル) /