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 
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.
70 } XMVVideoPacket;
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.
95 } XMVAudioPacket;
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.
116 } XMVDemuxContext;
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 
135  static int xmv_read_close(AVFormatContext *s)
136 {
137  XMVDemuxContext *xmv = s->priv_data;
138 
139  av_freep(&xmv->audio);
140 
141  return 0;
142 }
143 
144  static int xmv_read_header(AVFormatContext *s)
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 
153  s->ctx_flags |= AVFMTCTX_NOHEADER;
154 
155  avio_skip(pb, 4); /* Next packet size */
156 
157  this_packet_size = avio_rl32(pb);
158 
159  avio_skip(pb, 4); /* Max packet size */
160  avio_skip(pb, 4); /* "xobX" */
161 
162  file_version = avio_rl32(pb);
163  if ((file_version != 4) && (file_version != 2))
164  avpriv_request_sample(s, "Uncommon version %"PRIu32"", file_version);
165 
166  /* Video tracks */
167 
168  xmv->video_width = avio_rl32(pb);
169  xmv->video_height = avio_rl32(pb);
170  xmv->video_duration = avio_rl32(pb);
171 
172  /* Audio tracks */
173 
174  xmv->audio_track_count = avio_rl16(pb);
175 
176  avio_skip(pb, 2); /* Unknown (padding?) */
177 
178  xmv->audio = av_calloc(xmv->audio_track_count, sizeof(*xmv->audio));
179  if (!xmv->audio)
180  return AVERROR(ENOMEM);
181 
182  for (audio_track = 0; audio_track < xmv->audio_track_count; audio_track++) {
183  XMVAudioPacket *packet = &xmv->audio[audio_track];
184 
185  packet->compression = avio_rl16(pb);
186  packet->channels = avio_rl16(pb);
187  packet->sample_rate = avio_rl32(pb);
188  packet->bits_per_sample = avio_rl16(pb);
189  packet->flags = avio_rl16(pb);
190 
191  packet->bit_rate = (uint64_t)packet->bits_per_sample *
192  packet->sample_rate *
193  packet->channels;
194  packet->block_align = XMV_BLOCK_ALIGN_SIZE * packet->channels;
195  packet->block_samples = 64;
196  packet->codec_id = ff_wav_codec_get_id(packet->compression,
197  packet->bits_per_sample);
198 
199  packet->stream_index = -1;
200 
201  packet->frame_size = 0;
202  packet->block_count = 0;
203 
204  /* TODO: ADPCM'd 5.1 sound is encoded in three separate streams.
205  * Those need to be interleaved to a proper 5.1 stream. */
206  if (packet->flags & XMV_AUDIO_ADPCM51)
207  av_log(s, AV_LOG_WARNING, "Unsupported 5.1 ADPCM audio stream "
208  "(0x%04X)\n", packet->flags);
209 
210  if (!packet->channels || packet->sample_rate <= 0 ||
211  packet->channels >= UINT16_MAX / XMV_BLOCK_ALIGN_SIZE) {
212  av_log(s, AV_LOG_ERROR, "Invalid parameters for audio track %"PRIu16".\n",
213  audio_track);
214  return AVERROR_INVALIDDATA;
215  }
216  }
217 
218 
219  /* Initialize the packet context */
220 
221  xmv->next_packet_offset = avio_tell(pb);
222  xmv->next_packet_size = this_packet_size - xmv->next_packet_offset;
223  xmv->stream_count = xmv->audio_track_count + 1;
224 
225  return 0;
226 }
227 
228  static void xmv_read_extradata(uint8_t *extradata, AVIOContext *pb)
229 {
230  /* Read the XMV extradata */
231 
232  uint32_t data = avio_rl32(pb);
233 
234  int mspel_bit = !!(data & 0x01);
235  int loop_filter = !!(data & 0x02);
236  int abt_flag = !!(data & 0x04);
237  int j_type_bit = !!(data & 0x08);
238  int top_left_mv_flag = !!(data & 0x10);
239  int per_mb_rl_bit = !!(data & 0x20);
240  int slice_count = (data >> 6) & 7;
241 
242  /* Write it back as standard WMV2 extradata */
243 
244  data = 0;
245 
246  data |= mspel_bit << 15;
247  data |= loop_filter << 14;
248  data |= abt_flag << 13;
249  data |= j_type_bit << 12;
250  data |= top_left_mv_flag << 11;
251  data |= per_mb_rl_bit << 10;
252  data |= slice_count << 7;
253 
254  AV_WB32(extradata, data);
255 }
256 
257  static int xmv_process_packet_header(AVFormatContext *s)
258 {
259  XMVDemuxContext *xmv = s->priv_data;
260  AVIOContext *pb = s->pb;
261  int ret;
262 
263  uint8_t data[8];
264  uint16_t audio_track;
265  uint64_t data_offset;
266 
267  /* Next packet size */
268  xmv->next_packet_size = avio_rl32(pb);
269 
270  /* Packet video header */
271 
272  if (avio_read(pb, data, 8) != 8)
273  return AVERROR(EIO);
274 
275  xmv->video.data_size = AV_RL32(data) & 0x007FFFFF;
276 
277  xmv->video.current_frame = 0;
278  xmv->video.frame_count = (AV_RL32(data) >> 23) & 0xFF;
279 
280  xmv->video.has_extradata = (data[3] & 0x80) != 0;
281 
282  if (!xmv->video.created) {
283  AVStream *vst = avformat_new_stream(s, NULL);
284  if (!vst)
285  return AVERROR(ENOMEM);
286 
287  avpriv_set_pts_info(vst, 32, 1, 1000);
288 
289  vst->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
290  vst->codecpar->codec_id = AV_CODEC_ID_WMV2;
291  vst->codecpar->codec_tag = MKBETAG('W', 'M', 'V', '2');
292  vst->codecpar->width = xmv->video_width;
293  vst->codecpar->height = xmv->video_height;
294 
295  vst->duration = xmv->video_duration;
296 
297  xmv->video.stream_index = vst->index;
298 
299  xmv->video.created = 1;
300  }
301 
302  /* Adding the audio data sizes and the video data size keeps you 4 bytes
303  * short for every audio track. But as playing around with XMV files with
304  * ADPCM audio showed, taking the extra 4 bytes from the audio data gives
305  * you either completely distorted audio or click (when skipping the
306  * remaining 68 bytes of the ADPCM block). Subtracting 4 bytes for every
307  * audio track from the video data works at least for the audio. Probably
308  * some alignment thing?
309  * The video data has (always?) lots of padding, so it should work out...
310  */
311  xmv->video.data_size -= xmv->audio_track_count * 4;
312 
313  xmv->current_stream = 0;
314  if (!xmv->video.frame_count) {
315  xmv->video.frame_count = 1;
316  xmv->current_stream = xmv->stream_count > 1;
317  }
318 
319  /* Packet audio header */
320 
321  for (audio_track = 0; audio_track < xmv->audio_track_count; audio_track++) {
322  XMVAudioPacket *packet = &xmv->audio[audio_track];
323 
324  if (avio_read(pb, data, 4) != 4)
325  return AVERROR(EIO);
326 
327  if (!packet->created) {
328  AVStream *ast = avformat_new_stream(s, NULL);
329  if (!ast)
330  return AVERROR(ENOMEM);
331 
332  ast->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
333  ast->codecpar->codec_id = packet->codec_id;
334  ast->codecpar->codec_tag = packet->compression;
335  ast->codecpar->ch_layout.nb_channels = packet->channels;
336  ast->codecpar->sample_rate = packet->sample_rate;
337  ast->codecpar->bits_per_coded_sample = packet->bits_per_sample;
338  ast->codecpar->bit_rate = packet->bit_rate;
339  ast->codecpar->block_align = 36 * packet->channels;
340 
341  avpriv_set_pts_info(ast, 32, packet->block_samples, packet->sample_rate);
342 
343  packet->stream_index = ast->index;
344 
345  ast->duration = xmv->video_duration;
346 
347  packet->created = 1;
348  }
349 
350  packet->data_size = AV_RL32(data) & 0x007FFFFF;
351  if ((packet->data_size == 0) && (audio_track != 0))
352  /* This happens when I create an XMV with several identical audio
353  * streams. From the size calculations, duplicating the previous
354  * stream's size works out, but the track data itself is silent.
355  * Maybe this should also redirect the offset to the previous track?
356  */
357  packet->data_size = xmv->audio[audio_track - 1].data_size;
358 
359  /* Carve up the audio data in frame_count slices */
360  packet->frame_size = packet->data_size / xmv->video.frame_count;
361  packet->frame_size -= packet->frame_size % packet->block_align;
362  }
363 
364  /* Packet data offsets */
365 
366  data_offset = avio_tell(pb);
367 
368  xmv->video.data_offset = data_offset;
369  data_offset += xmv->video.data_size;
370 
371  for (audio_track = 0; audio_track < xmv->audio_track_count; audio_track++) {
372  xmv->audio[audio_track].data_offset = data_offset;
373  data_offset += xmv->audio[audio_track].data_size;
374  }
375 
376  /* Video frames header */
377 
378  /* Read new video extra data */
379  if (xmv->video.data_size > 0) {
380  if (xmv->video.has_extradata) {
381  xmv_read_extradata(xmv->video.extradata, pb);
382 
383  xmv->video.data_size -= 4;
384  xmv->video.data_offset += 4;
385 
386  if (xmv->video.stream_index >= 0) {
387  AVStream *vst = s->streams[xmv->video.stream_index];
388 
389  av_assert0(xmv->video.stream_index < s->nb_streams);
390 
391  if (vst->codecpar->extradata_size < 4) {
392  if ((ret = ff_alloc_extradata(vst->codecpar, 4)) < 0)
393  return ret;
394  }
395 
396  memcpy(vst->codecpar->extradata, xmv->video.extradata, 4);
397  }
398  }
399  }
400 
401  return 0;
402 }
403 
404  static int xmv_fetch_new_packet(AVFormatContext *s)
405 {
406  XMVDemuxContext *xmv = s->priv_data;
407  AVIOContext *pb = s->pb;
408  int result;
409 
410  if (xmv->this_packet_offset == xmv->next_packet_offset)
411  return AVERROR_EOF;
412 
413  /* Seek to it */
414  xmv->this_packet_offset = xmv->next_packet_offset;
415  if (avio_seek(pb, xmv->this_packet_offset, SEEK_SET) != xmv->this_packet_offset)
416  return AVERROR(EIO);
417 
418  /* Update the size */
419  xmv->this_packet_size = xmv->next_packet_size;
420  if (xmv->this_packet_size < (12 + xmv->audio_track_count * 4))
421  return AVERROR(EIO);
422 
423  /* Process the header */
424  result = xmv_process_packet_header(s);
425  if (result)
426  return result;
427 
428  /* Update the offset */
429  xmv->next_packet_offset = xmv->this_packet_offset + xmv->this_packet_size;
430 
431  return 0;
432 }
433 
434  static int xmv_fetch_audio_packet(AVFormatContext *s,
435  AVPacket *pkt, uint32_t stream)
436 {
437  XMVDemuxContext *xmv = s->priv_data;
438  AVIOContext *pb = s->pb;
439  XMVAudioPacket *audio = &xmv->audio[stream];
440 
441  uint32_t data_size;
442  uint32_t block_count;
443  int result;
444 
445  /* Seek to it */
446  if (avio_seek(pb, audio->data_offset, SEEK_SET) != audio->data_offset)
447  return AVERROR(EIO);
448 
449  if ((xmv->video.current_frame + 1) < xmv->video.frame_count)
450  /* Not the last frame, get at most frame_size bytes. */
451  data_size = FFMIN(audio->frame_size, audio->data_size);
452  else
453  /* Last frame, get the rest. */
454  data_size = audio->data_size;
455 
456  /* Read the packet */
457  result = av_get_packet(pb, pkt, data_size);
458  if (result <= 0)
459  return result;
460 
461  pkt->stream_index = audio->stream_index;
462 
463  /* Calculate the PTS */
464 
465  block_count = data_size / audio->block_align;
466 
467  pkt->duration = block_count;
468  pkt->pts = audio->block_count;
469  pkt->dts = AV_NOPTS_VALUE;
470 
471  audio->block_count += block_count;
472 
473  /* Advance offset */
474  audio->data_size -= data_size;
475  audio->data_offset += data_size;
476 
477  return 0;
478 }
479 
480  static int xmv_fetch_video_packet(AVFormatContext *s,
481  AVPacket *pkt)
482 {
483  XMVDemuxContext *xmv = s->priv_data;
484  AVIOContext *pb = s->pb;
485  XMVVideoPacket *video = &xmv->video;
486 
487  int result;
488  uint32_t frame_header;
489  uint32_t frame_size, frame_timestamp;
490  uint8_t *data, *end;
491 
492  /* Seek to it */
493  if (avio_seek(pb, video->data_offset, SEEK_SET) != video->data_offset)
494  return AVERROR(EIO);
495 
496  /* Read the frame header */
497  frame_header = avio_rl32(pb);
498 
499  frame_size = (frame_header & 0x1FFFF) * 4 + 4;
500  frame_timestamp = (frame_header >> 17);
501 
502  if ((frame_size + 4) > video->data_size)
503  return AVERROR(EIO);
504 
505  /* Get the packet data */
506  result = av_get_packet(pb, pkt, frame_size);
507  if (result != frame_size)
508  return result;
509 
510  /* Contrary to normal WMV2 video, the bit stream in XMV's
511  * WMV2 is little-endian.
512  * TODO: This manual swap is of course suboptimal.
513  */
514  for (data = pkt->data, end = pkt->data + frame_size; data < end; data += 4)
515  AV_WB32(data, AV_RL32(data));
516 
517  pkt->stream_index = video->stream_index;
518 
519  /* Calculate the PTS */
520 
521  video->last_pts = frame_timestamp + video->pts;
522 
523  pkt->duration = 0;
524  pkt->pts = video->last_pts;
525  pkt->dts = AV_NOPTS_VALUE;
526 
527  video->pts += frame_timestamp;
528 
529  /* Keyframe? */
530  pkt->flags = (pkt->data[0] & 0x80) ? 0 : AV_PKT_FLAG_KEY;
531 
532  /* Advance offset */
533  video->data_size -= frame_size + 4;
534  video->data_offset += frame_size + 4;
535 
536  return 0;
537 }
538 
539  static int xmv_read_packet(AVFormatContext *s,
540  AVPacket *pkt)
541 {
542  XMVDemuxContext *xmv = s->priv_data;
543  int result;
544 
545  if (xmv->video.current_frame == xmv->video.frame_count) {
546  /* No frames left in this packet, so we fetch a new one */
547 
548  result = xmv_fetch_new_packet(s);
549  if (result)
550  return result;
551  }
552 
553  if (xmv->current_stream == 0) {
554  /* Fetch a video frame */
555 
556  result = xmv_fetch_video_packet(s, pkt);
557  } else {
558  /* Fetch an audio frame */
559 
560  result = xmv_fetch_audio_packet(s, pkt, xmv->current_stream - 1);
561  }
562  if (result) {
563  xmv->current_stream = 0;
564  xmv->video.current_frame = xmv->video.frame_count;
565  return result;
566  }
567 
568 
569  /* Increase our counters */
570  if (++xmv->current_stream >= xmv->stream_count) {
571  xmv->current_stream = 0;
572  xmv->video.current_frame += 1;
573  }
574 
575  return 0;
576 }
577 
578  const AVInputFormat ff_xmv_demuxer = {
579  .name = "xmv",
580  .long_name = NULL_IF_CONFIG_SMALL("Microsoft XMV"),
581  .extensions = "xmv",
582  .priv_data_size = sizeof(XMVDemuxContext),
583  .flags_internal = FF_FMT_INIT_CLEANUP,
584  .read_probe = xmv_probe,
585  .read_header = xmv_read_header,
586  .read_packet = xmv_read_packet,
587  .read_close = xmv_read_close,
588 };
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:186
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:75
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: options.c:237
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:57
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
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
ff_wav_codec_get_id
enum AVCodecID ff_wav_codec_get_id(unsigned int tag, int bps)
Definition: riffdec.c:199
AVPacket::data
uint8_t * data
Definition: packet.h:374
data
const char data[16]
Definition: mxf.c:143
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
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:392
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:65
AVProbeData::buf_size
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:456
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:300
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:429
xmv_fetch_new_packet
static int xmv_fetch_new_packet(AVFormatContext *s)
Definition: xmv.c:404
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:465
XMVVideoPacket
A video packet with an XMV file.
Definition: xmv.c:55
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:697
XMVAudioPacket::created
int created
Definition: xmv.c:74
xmv_read_packet
static int xmv_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: xmv.c:539
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:143
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:505
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:998
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:743
XMVVideoPacket::data_size
uint32_t data_size
The size of the remaining video data.
Definition: xmv.c:59
avassert.h
pkt
AVPacket * pkt
Definition: movenc.c:59
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:180
AVInputFormat
Definition: avformat.h:656
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:257
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:256
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:661
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:455
frame_size
int frame_size
Definition: mxfenc.c:2201
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:127
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:68
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:434
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:1213
internal.h
ff_xmv_demuxer
const AVInputFormat ff_xmv_demuxer
Definition: xmv.c:578
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1108
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:532
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:1164
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:453
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:212
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:177
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:47
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:79
AV_WB32
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
avio_rl32
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:759
AVIOContext
Bytestream IO Context.
Definition: avio.h:162
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:117
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: macros.h:56
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:373
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:380
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:2556
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:367
AVCodecParameters::height
int height
Definition: codec_par.h:128
AVCodecParameters::block_align
int block_align
Audio only.
Definition: codec_par.h:184
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:272
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:102
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:948
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:260
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:92
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:956
frame_header
Definition: truemotion1.c:88
frame_header
static int FUNC() frame_header(CodedBitstreamContext *ctx, RWContext *rw, JPEGRawFrameHeader *current)
Definition: cbs_jpeg_syntax_template.c:19
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:228
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:480
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:641
XMVDemuxContext::video
XMVVideoPacket video
The video packet contained in each packet.
Definition: xmv.c:114
AVPacket::stream_index
int stream_index
Definition: packet.h:376
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:347
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:103
XMVVideoPacket::extradata
uint8_t extradata[4]
The extra data.
Definition: xmv.c:66
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
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:61
AVPacket
This structure stores compressed data.
Definition: packet.h:351
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
riff.h
XMVVideoPacket::pts
int64_t pts
PTS of the most current video frame.
Definition: xmv.c:69
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:90
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: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:238
Generated on Wed Aug 24 2022 21:42:21 for FFmpeg by   doxygen 1.8.17

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