FFmpeg
dhav.c
Go to the documentation of this file.
1 /*
2  * DHAV demuxer
3  *
4  * Copyright (c) 2018 Paul B Mahol
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 #include "libavutil/parseutils.h"
24 #include "avio_internal.h"
25 #include "avformat.h"
26 #include "internal.h"
27 
28 typedef struct DHAVContext {
29  unsigned type;
30  unsigned subtype;
31  unsigned channel;
32  unsigned frame_subnumber;
33  unsigned frame_number;
34  unsigned date;
35  unsigned timestamp;
36  int width, height;
42  int64_t last_good_pos;
43  int64_t duration;
44 
47 } DHAVContext;
48 
49 typedef struct DHAVStream {
50  int64_t last_timestamp;
51  int64_t last_time;
52  int64_t pts;
53 } DHAVStream;
54 
55 static int dhav_probe(const AVProbeData *p)
56 {
57  if (!memcmp(p->buf, "DAHUA", 5))
58  return AVPROBE_SCORE_MAX;
59 
60  if (memcmp(p->buf, "DHAV", 4))
61  return 0;
62 
63  if (p->buf[4] == 0xf0 ||
64  p->buf[4] == 0xf1 ||
65  p->buf[4] == 0xfc ||
66  p->buf[4] == 0xfd)
67  return AVPROBE_SCORE_MAX;
68  return 0;
69 }
70 
71 static const uint32_t sample_rates[] = {
72  8000, 4000, 8000, 11025, 16000,
73  20000, 22050, 32000, 44100, 48000,
74  96000, 192000, 64000,
75 };
76 
77 static int parse_ext(AVFormatContext *s, int length)
78 {
79  DHAVContext *dhav = s->priv_data;
80  int index, ret = 0;
81 
82  while (length > 0) {
83  int type = avio_r8(s->pb);
84 
85  switch (type) {
86  case 0x80:
87  ret = avio_skip(s->pb, 1);
88  dhav->width = 8 * avio_r8(s->pb);
89  dhav->height = 8 * avio_r8(s->pb);
90  length -= 4;
91  break;
92  case 0x81:
93  ret = avio_skip(s->pb, 1);
94  dhav->video_codec = avio_r8(s->pb);
95  dhav->frame_rate = avio_r8(s->pb);
96  length -= 4;
97  break;
98  case 0x82:
99  ret = avio_skip(s->pb, 3);
100  dhav->width = avio_rl16(s->pb);
101  dhav->height = avio_rl16(s->pb);
102  length -= 8;
103  break;
104  case 0x83:
105  dhav->audio_channels = avio_r8(s->pb);
106  dhav->audio_codec = avio_r8(s->pb);
107  index = avio_r8(s->pb);
108  if (index < FF_ARRAY_ELEMS(sample_rates)) {
109  dhav->sample_rate = sample_rates[index];
110  } else {
111  dhav->sample_rate = 8000;
112  }
113  length -= 4;
114  break;
115  case 0x88:
116  ret = avio_skip(s->pb, 7);
117  length -= 8;
118  break;
119  case 0x8c:
120  ret = avio_skip(s->pb, 1);
121  dhav->audio_channels = avio_r8(s->pb);
122  dhav->audio_codec = avio_r8(s->pb);
123  index = avio_r8(s->pb);
124  if (index < FF_ARRAY_ELEMS(sample_rates)) {
125  dhav->sample_rate = sample_rates[index];
126  } else {
127  dhav->sample_rate = 8000;
128  }
129  ret = avio_skip(s->pb, 3);
130  length -= 8;
131  break;
132  case 0x91:
133  case 0x92:
134  case 0x93:
135  case 0x95:
136  case 0x9a:
137  case 0x9b: // sample aspect ratio
138  case 0xb3:
139  ret = avio_skip(s->pb, 7);
140  length -= 8;
141  break;
142  case 0x84:
143  case 0x85:
144  case 0x8b:
145  case 0x94:
146  case 0x96:
147  case 0xa0:
148  case 0xb2:
149  case 0xb4:
150  ret = avio_skip(s->pb, 3);
151  length -= 4;
152  break;
153  default:
154  av_log(s, AV_LOG_INFO, "Unknown type: %X, skipping rest of header.\n", type);
155  ret = avio_skip(s->pb, length - 1);
156  length = 0;
157  }
158 
159  if (ret < 0)
160  return ret;
161  }
162 
163  return 0;
164 }
165 
167 {
168  DHAVContext *dhav = s->priv_data;
169  int frame_length, ext_length;
170  int64_t start, end;
171  int ret;
172 
173  if (avio_feof(s->pb))
174  return AVERROR_EOF;
175 
176  if (avio_rl32(s->pb) != MKTAG('D','H','A','V')) {
177  dhav->last_good_pos += 0x8000;
178  avio_seek(s->pb, dhav->last_good_pos, SEEK_SET);
179 
180  while (avio_rl32(s->pb) != MKTAG('D','H','A','V')) {
181  if (avio_feof(s->pb))
182  return AVERROR_EOF;
183  dhav->last_good_pos += 0x8000;
184  ret = avio_skip(s->pb, 0x8000 - 4);
185  if (ret < 0)
186  return ret;
187  }
188  }
189 
190  start = avio_tell(s->pb) - 4;
191  dhav->last_good_pos = start;
192  dhav->type = avio_r8(s->pb);
193  dhav->subtype = avio_r8(s->pb);
194  dhav->channel = avio_r8(s->pb);
195  dhav->frame_subnumber = avio_r8(s->pb);
196  dhav->frame_number = avio_rl32(s->pb);
197  frame_length = avio_rl32(s->pb);
198  dhav->date = avio_rl32(s->pb);
199 
200  if (frame_length < 24)
201  return AVERROR_INVALIDDATA;
202  if (dhav->type == 0xf1) {
203  ret = avio_skip(s->pb, frame_length - 20);
204  return ret < 0 ? ret : 0;
205  }
206 
207  dhav->timestamp = avio_rl16(s->pb);
208  ext_length = avio_r8(s->pb);
209  avio_skip(s->pb, 1); // checksum
210 
211  ret = parse_ext(s, ext_length);
212  if (ret < 0)
213  return ret;
214 
215  end = avio_tell(s->pb);
216 
217  return frame_length - 8 - (end - start);
218 }
219 
220 static void get_timeinfo(unsigned date, struct tm *timeinfo)
221 {
222  int year, month, day, hour, min, sec;
223 
224  sec = date & 0x3F;
225  min = (date >> 6) & 0x3F;
226  hour = (date >> 12) & 0x1F;
227  day = (date >> 17) & 0x1F;
228  month = (date >> 22) & 0x0F;
229  year = ((date >> 26) & 0x3F) + 2000;
230 
231  timeinfo->tm_year = year - 1900;
232  timeinfo->tm_mon = month - 1;
233  timeinfo->tm_mday = day;
234  timeinfo->tm_hour = hour;
235  timeinfo->tm_min = min;
236  timeinfo->tm_sec = sec;
237 }
238 
240 {
241  DHAVContext *dhav = s->priv_data;
242  int64_t start_pos = avio_tell(s->pb);
243  int64_t start = 0, end = 0;
244  struct tm timeinfo;
245 
246  if (!s->pb->seekable)
247  return 0;
248 
249  avio_seek(s->pb, avio_size(s->pb) - 8, SEEK_SET);
250  if (avio_rl32(s->pb) == MKTAG('d','h','a','v')) {
251  int seek_back = avio_rl32(s->pb);
252 
253  avio_seek(s->pb, -seek_back, SEEK_CUR);
254  read_chunk(s);
255  get_timeinfo(dhav->date, &timeinfo);
256  end = av_timegm(&timeinfo) * 1000LL;
257  } else {
258  avio_seek(s->pb, start_pos, SEEK_SET);
259  return 0;
260  }
261 
262  avio_seek(s->pb, start_pos, SEEK_SET);
263 
264  read_chunk(s);
265  get_timeinfo(dhav->date, &timeinfo);
266  start = av_timegm(&timeinfo) * 1000LL;
267 
268  avio_seek(s->pb, start_pos, SEEK_SET);
269 
270  return end - start;
271 }
272 
274 {
275  DHAVContext *dhav = s->priv_data;
276  uint8_t signature[5];
277 
278  ffio_ensure_seekback(s->pb, 5);
279  avio_read(s->pb, signature, sizeof(signature));
280  if (!memcmp(signature, "DAHUA", 5)) {
281  avio_skip(s->pb, 0x400 - 5);
282  dhav->last_good_pos = avio_tell(s->pb);
283  } else {
284  if (!memcmp(signature, "DHAV", 4)) {
285  avio_seek(s->pb, -5, SEEK_CUR);
286  dhav->last_good_pos = avio_tell(s->pb);
287  } else if (s->pb->seekable) {
288  avio_seek(s->pb, avio_size(s->pb) - 8, SEEK_SET);
289  while (avio_rl32(s->pb) == MKTAG('d','h','a','v')) {
290  int seek_back;
291 
292  seek_back = avio_rl32(s->pb) + 8;
293  dhav->last_good_pos = avio_tell(s->pb);
294  avio_seek(s->pb, -seek_back, SEEK_CUR);
295  }
296  avio_seek(s->pb, dhav->last_good_pos, SEEK_SET);
297  }
298  }
299 
300  dhav->duration = get_duration(s);
301  dhav->last_good_pos = avio_tell(s->pb);
303  dhav->video_stream_index = -1;
304  dhav->audio_stream_index = -1;
305 
306  return 0;
307 }
308 
309 static int64_t get_pts(AVFormatContext *s, int stream_index)
310 {
311  DHAVStream *dst = s->streams[stream_index]->priv_data;
312  DHAVContext *dhav = s->priv_data;
313  struct tm timeinfo;
314  time_t t;
315 
316  get_timeinfo(dhav->date, &timeinfo);
317 
318  t = av_timegm(&timeinfo);
319  if (dst->last_time == t) {
320  int64_t diff = dhav->timestamp - dst->last_timestamp;
321 
322  if (diff < 0)
323  diff += 65535;
324  dst->pts += diff;
325  } else {
326  dst->pts = t * 1000LL;
327  }
328 
329  dst->last_time = t;
330  dst->last_timestamp = dhav->timestamp;
331 
332  return dst->pts;
333 }
334 
336 {
337  DHAVContext *dhav = s->priv_data;
338  int size, ret, stream_index;
339 
340 retry:
341  while ((ret = read_chunk(s)) == 0)
342  ;
343 
344  if (ret < 0)
345  return ret;
346 
347  if (dhav->type == 0xfd && dhav->video_stream_index == -1) {
349  DHAVStream *dst;
350 
351  if (!st)
352  return AVERROR(ENOMEM);
353 
355  switch (dhav->video_codec) {
356  case 0x1: st->codecpar->codec_id = AV_CODEC_ID_MPEG4; break;
357  case 0x3: st->codecpar->codec_id = AV_CODEC_ID_MJPEG; break;
358  case 0x2:
359  case 0x4:
360  case 0x8: st->codecpar->codec_id = AV_CODEC_ID_H264; break;
361  case 0xc: st->codecpar->codec_id = AV_CODEC_ID_HEVC; break;
362  default: avpriv_request_sample(s, "Unknown video codec %X\n", dhav->video_codec);
363  }
364  st->duration = dhav->duration;
365  st->codecpar->width = dhav->width;
366  st->codecpar->height = dhav->height;
367  st->avg_frame_rate.num = dhav->frame_rate;
368  st->avg_frame_rate.den = 1;
369  st->priv_data = dst = av_mallocz(sizeof(DHAVStream));
370  if (!st->priv_data)
371  return AVERROR(ENOMEM);
372  dst->last_time = AV_NOPTS_VALUE;
373  dhav->video_stream_index = st->index;
374 
375  avpriv_set_pts_info(st, 64, 1, 1000);
376  } else if (dhav->type == 0xf0 && dhav->audio_stream_index == -1) {
378  DHAVStream *dst;
379 
380  if (!st)
381  return AVERROR(ENOMEM);
382 
384  switch (dhav->audio_codec) {
385  case 0x07: st->codecpar->codec_id = AV_CODEC_ID_PCM_S8; break;
386  case 0x0c: st->codecpar->codec_id = AV_CODEC_ID_PCM_S16LE; break;
387  case 0x10: st->codecpar->codec_id = AV_CODEC_ID_PCM_S16LE; break;
388  case 0x0a: st->codecpar->codec_id = AV_CODEC_ID_PCM_MULAW; break;
389  case 0x16: st->codecpar->codec_id = AV_CODEC_ID_PCM_MULAW; break;
390  case 0x0e: st->codecpar->codec_id = AV_CODEC_ID_PCM_ALAW; break;
391  case 0x1a: st->codecpar->codec_id = AV_CODEC_ID_AAC; break;
392  case 0x1f: st->codecpar->codec_id = AV_CODEC_ID_MP2; break;
393  case 0x21: st->codecpar->codec_id = AV_CODEC_ID_MP3; break;
394  case 0x0d: st->codecpar->codec_id = AV_CODEC_ID_ADPCM_MS; break;
395  default: avpriv_request_sample(s, "Unknown audio codec %X\n", dhav->audio_codec);
396  }
397  st->duration = dhav->duration;
398  st->codecpar->channels = dhav->audio_channels;
399  st->codecpar->sample_rate = dhav->sample_rate;
400  st->priv_data = dst = av_mallocz(sizeof(DHAVStream));
401  if (!st->priv_data)
402  return AVERROR(ENOMEM);
403  dst->last_time = AV_NOPTS_VALUE;
404  dhav->audio_stream_index = st->index;
405 
406  avpriv_set_pts_info(st, 64, 1, 1000);
407  }
408 
409  stream_index = dhav->type == 0xf0 ? dhav->audio_stream_index : dhav->video_stream_index;
410  if (stream_index < 0) {
411  avio_skip(s->pb, ret);
412  if (avio_rl32(s->pb) == MKTAG('d','h','a','v'))
413  avio_skip(s->pb, 4);
414  goto retry;
415  }
416 
417  size = ret;
418  ret = av_get_packet(s->pb, pkt, size);
419  if (ret < 0)
420  return ret;
421  pkt->stream_index = stream_index;
422  if (dhav->type != 0xfc)
423  pkt->flags |= AV_PKT_FLAG_KEY;
424  pkt->duration = 1;
425  if (pkt->stream_index >= 0)
426  pkt->pts = get_pts(s, pkt->stream_index);
427  pkt->pos = dhav->last_good_pos;
428  if (avio_rl32(s->pb) == MKTAG('d','h','a','v'))
429  avio_skip(s->pb, 4);
430 
431  return ret;
432 }
433 
434 static int dhav_read_seek(AVFormatContext *s, int stream_index,
435  int64_t timestamp, int flags)
436 {
437  DHAVContext *dhav = s->priv_data;
438  AVStream *st = s->streams[stream_index];
439  int index = av_index_search_timestamp(st, timestamp, flags);
440  int64_t pts;
441 
442  if (index < 0)
443  return -1;
444  if (avio_seek(s->pb, st->index_entries[index].pos, SEEK_SET) < 0)
445  return -1;
446 
447  pts = st->index_entries[index].timestamp;
448 
449  for (int n = 0; n < s->nb_streams; n++) {
450  AVStream *st = s->streams[n];
451  DHAVStream *dst = st->priv_data;
452 
453  dst->pts = pts;
454  dst->last_time = AV_NOPTS_VALUE;
455  }
456  dhav->last_good_pos = avio_tell(s->pb);
457 
458  return 0;
459 }
460 
462  .name = "dhav",
463  .long_name = NULL_IF_CONFIG_SMALL("Video DAV"),
464  .priv_data_size = sizeof(DHAVContext),
469  .extensions = "dav",
471 };
time_t av_timegm(struct tm *tm)
Convert the decomposed UTC time in tm to a time_t value.
Definition: parseutils.c:568
#define NULL
Definition: coverity.c:32
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:334
int64_t last_time
Definition: dhav.c:51
int64_t pos
byte position in stream, -1 if unknown
Definition: avcodec.h:1553
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:4943
int64_t pos
Definition: avformat.h:805
#define avpriv_request_sample(...)
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:153
static int read_chunk(AVFormatContext *s)
Definition: dhav.c:166
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:4036
int num
Numerator.
Definition: rational.h:59
int index
stream index in AVFormatContext
Definition: avformat.h:877
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:241
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: avformat.h:1105
GLint GLenum type
Definition: opengl_enc.c:104
void * priv_data
Definition: avformat.h:891
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:329
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
static AVPacket pkt
static const uint32_t sample_rates[]
Definition: dhav.c:71
int ctx_flags
Flags signalling stream properties.
Definition: avformat.h:1402
#define AVFMT_TS_NONSTRICT
Format does not require strictly increasing timestamps, but they must still be monotonic.
Definition: avformat.h:472
Format I/O context.
Definition: avformat.h:1353
unsigned channel
Definition: dhav.c:31
static const char signature[]
Definition: ipmovie.c:615
uint8_t
int width
Video only.
Definition: avcodec.h:4102
#define AVFMTCTX_NOHEADER
signal that no header is present (streams are added dynamically)
Definition: avformat.h:1297
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1551
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4524
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1421
unsigned date
Definition: dhav.c:34
#define AVERROR_EOF
End of file.
Definition: error.h:55
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:308
ptrdiff_t size
Definition: opengl_enc.c:100
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
static void seek_back(AVFormatContext *s, AVIOContext *pb, int64_t pos)
Definition: mpegts.c:3006
#define av_log(a,...)
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:645
static int dhav_read_header(AVFormatContext *s)
Definition: dhav.c:273
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1565
unsigned subtype
Definition: dhav.c:30
int64_t last_timestamp
Definition: dhav.c:50
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)
Get the index for a specific timestamp.
Definition: utils.c:2166
#define AVFMT_TS_DISCONT
Format allows timestamp discontinuities.
Definition: avformat.h:464
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:767
unsigned type
Definition: dhav.c:29
int64_t timestamp
Timestamp in AVStream.time_base units, preferably the time from which on correctly decoded frames are...
Definition: avformat.h:806
int64_t pts
Definition: dhav.c:52
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
int audio_channels
Definition: dhav.c:39
static int dhav_probe(const AVProbeData *p)
Definition: dhav.c:55
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: avcodec.h:578
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:4032
GLsizei GLsizei * length
Definition: opengl_enc.c:114
int video_codec
Definition: dhav.c:37
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:949
AVInputFormat ff_dhav_demuxer
Definition: dhav.c:461
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1539
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:636
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:443
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1409
unsigned timestamp
Definition: dhav.c:35
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:260
static void get_timeinfo(unsigned date, struct tm *timeinfo)
Definition: dhav.c:220
static int dhav_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: dhav.c:335
int64_t duration
Definition: dhav.c:43
#define s(width, name)
Definition: cbs_vp9.c:257
int n
Definition: avisynth_c.h:760
int video_stream_index
Definition: dhav.c:45
int width
Definition: dhav.c:36
#define FF_ARRAY_ELEMS(a)
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:527
Stream structure.
Definition: avformat.h:876
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
AVIOContext * pb
I/O context.
Definition: avformat.h:1395
static int dhav_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: dhav.c:434
unsigned frame_number
Definition: dhav.c:33
int64_t last_good_pos
Definition: dhav.c:42
int sample_rate
Definition: dhav.c:41
int index
Definition: gxfenc.c:89
#define AVFMT_GENERIC_INDEX
Use generic index building code.
Definition: avformat.h:463
This structure contains the data a format has to probe a file.
Definition: avformat.h:441
misc parsing utilities
static int64_t pts
#define flags(name, subs,...)
Definition: cbs_av1.c:564
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
static int64_t get_pts(AVFormatContext *s, int stream_index)
Definition: dhav.c:309
int ffio_ensure_seekback(AVIOContext *s, int64_t buf_size)
Ensures that the requested seekback buffer size will be available.
Definition: aviobuf.c:1002
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:925
int sample_rate
Audio only.
Definition: avcodec.h:4146
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:453
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:751
Main libavformat public API header.
int den
Denominator.
Definition: rational.h:60
int audio_stream_index
Definition: dhav.c:46
unsigned frame_subnumber
Definition: dhav.c:32
static av_always_inline int diff(const uint32_t a, const uint32_t b)
#define AVFMT_NO_BYTE_SEEK
Format does not allow seeking by bytes.
Definition: avformat.h:470
void * priv_data
Format private data.
Definition: avformat.h:1381
int audio_codec
Definition: dhav.c:40
int height
Definition: dhav.c:36
int channels
Audio only.
Definition: avcodec.h:4142
void INT64 start
Definition: avisynth_c.h:766
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:650
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1023
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:356
int stream_index
Definition: avcodec.h:1535
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
#define MKTAG(a, b, c, d)
Definition: common.h:366
int frame_rate
Definition: dhav.c:38
float min
This structure stores compressed data.
Definition: avcodec.h:1510
static int parse_ext(AVFormatContext *s, int length)
Definition: dhav.c:77
static int64_t get_duration(AVFormatContext *s)
Definition: dhav.c:239
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1526
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248