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 <time.h>
24 
25 #include "libavutil/parseutils.h"
26 #include "avio_internal.h"
27 #include "avformat.h"
28 #include "internal.h"
29 
30 typedef struct DHAVContext {
31  unsigned type;
32  unsigned subtype;
33  unsigned channel;
34  unsigned frame_subnumber;
35  unsigned frame_number;
36  unsigned date;
37  unsigned timestamp;
38  int width, height;
44  int64_t last_good_pos;
45  int64_t duration;
46 
49 } DHAVContext;
50 
51 typedef struct DHAVStream {
53  int64_t last_timestamp;
54  int64_t last_time;
55  int64_t pts;
56 } DHAVStream;
57 
58 static int dhav_probe(const AVProbeData *p)
59 {
60  if (!memcmp(p->buf, "DAHUA", 5))
61  return AVPROBE_SCORE_MAX;
62 
63  if (memcmp(p->buf, "DHAV", 4))
64  return 0;
65 
66  if (p->buf[4] == 0xf0 ||
67  p->buf[4] == 0xf1 ||
68  p->buf[4] == 0xfc ||
69  p->buf[4] == 0xfd)
70  return AVPROBE_SCORE_MAX;
71  return 0;
72 }
73 
74 static const uint32_t sample_rates[] = {
75  8000, 4000, 8000, 11025, 16000,
76  20000, 22050, 32000, 44100, 48000,
77  96000, 192000, 64000,
78 };
79 
80 static int parse_ext(AVFormatContext *s, int length)
81 {
82  DHAVContext *dhav = s->priv_data;
83  int64_t ret = 0;
84 
85  while (length > 0) {
86  int type = avio_r8(s->pb);
87  int index;
88 
89  switch (type) {
90  case 0x80:
91  ret = avio_skip(s->pb, 1);
92  dhav->width = 8 * avio_r8(s->pb);
93  dhav->height = 8 * avio_r8(s->pb);
94  length -= 4;
95  break;
96  case 0x81:
97  ret = avio_skip(s->pb, 1);
98  dhav->video_codec = avio_r8(s->pb);
99  dhav->frame_rate = avio_r8(s->pb);
100  length -= 4;
101  break;
102  case 0x82:
103  ret = avio_skip(s->pb, 3);
104  dhav->width = avio_rl16(s->pb);
105  dhav->height = avio_rl16(s->pb);
106  length -= 8;
107  break;
108  case 0x83:
109  dhav->audio_channels = avio_r8(s->pb);
110  dhav->audio_codec = avio_r8(s->pb);
111  index = avio_r8(s->pb);
113  dhav->sample_rate = sample_rates[index];
114  } else {
115  dhav->sample_rate = 8000;
116  }
117  length -= 4;
118  break;
119  case 0x88:
120  ret = avio_skip(s->pb, 7);
121  length -= 8;
122  break;
123  case 0x8c:
124  ret = avio_skip(s->pb, 1);
125  dhav->audio_channels = avio_r8(s->pb);
126  dhav->audio_codec = avio_r8(s->pb);
127  index = avio_r8(s->pb);
129  dhav->sample_rate = sample_rates[index];
130  } else {
131  dhav->sample_rate = 8000;
132  }
133  ret = avio_skip(s->pb, 3);
134  length -= 8;
135  break;
136  case 0x91:
137  case 0x92:
138  case 0x93:
139  case 0x95:
140  case 0x9a:
141  case 0x9b: // sample aspect ratio
142  case 0xb3:
143  ret = avio_skip(s->pb, 7);
144  length -= 8;
145  break;
146  case 0x84:
147  case 0x85:
148  case 0x8b:
149  case 0x94:
150  case 0x96:
151  case 0xa0:
152  case 0xb2:
153  case 0xb4:
154  ret = avio_skip(s->pb, 3);
155  length -= 4;
156  break;
157  default:
158  av_log(s, AV_LOG_INFO, "Unknown type: %X, skipping rest of header.\n", type);
159  ret = avio_skip(s->pb, length - 1);
160  length = 0;
161  }
162 
163  if (ret < 0)
164  return ret;
165  }
166 
167  return 0;
168 }
169 
171 {
172  DHAVContext *dhav = s->priv_data;
173  int frame_length, ext_length;
174  int64_t start, end, ret;
175 
176  if (avio_feof(s->pb))
177  return AVERROR_EOF;
178 
179  while (avio_r8(s->pb) != 'D' || avio_r8(s->pb) != 'H' || avio_r8(s->pb) != 'A' || avio_r8(s->pb) != 'V') {
180  if (avio_feof(s->pb))
181  return AVERROR_EOF;
182  }
183 
184  start = avio_tell(s->pb) - 4;
185  dhav->last_good_pos = start;
186  dhav->type = avio_r8(s->pb);
187  dhav->subtype = avio_r8(s->pb);
188  dhav->channel = avio_r8(s->pb);
189  dhav->frame_subnumber = avio_r8(s->pb);
190  dhav->frame_number = avio_rl32(s->pb);
191  frame_length = avio_rl32(s->pb);
192  dhav->date = avio_rl32(s->pb);
193 
194  if (frame_length < 24)
195  return AVERROR_INVALIDDATA;
196  if (dhav->type == 0xf1) {
197  ret = avio_skip(s->pb, frame_length - 20);
198  return ret < 0 ? ret : 0;
199  }
200 
201  dhav->timestamp = avio_rl16(s->pb);
202  ext_length = avio_r8(s->pb);
203  avio_skip(s->pb, 1); // checksum
204 
205  ret = parse_ext(s, ext_length);
206  if (ret < 0)
207  return ret;
208 
209  end = avio_tell(s->pb);
210 
211  return frame_length - 8 - (end - start);
212 }
213 
214 static void get_timeinfo(unsigned date, struct tm *timeinfo)
215 {
216  int year, month, day, hour, min, sec;
217 
218  sec = date & 0x3F;
219  min = (date >> 6) & 0x3F;
220  hour = (date >> 12) & 0x1F;
221  day = (date >> 17) & 0x1F;
222  month = (date >> 22) & 0x0F;
223  year = ((date >> 26) & 0x3F) + 2000;
224 
225  timeinfo->tm_year = year - 1900;
226  timeinfo->tm_mon = month - 1;
227  timeinfo->tm_mday = day;
228  timeinfo->tm_hour = hour;
229  timeinfo->tm_min = min;
230  timeinfo->tm_sec = sec;
231 }
232 
234 {
235  DHAVContext *dhav = s->priv_data;
236  int64_t start_pos = avio_tell(s->pb);
237  int64_t start = 0, end = 0;
238  struct tm timeinfo;
239  int max_interations = 100000;
240 
241  if (!s->pb->seekable)
242  return 0;
243 
244  avio_seek(s->pb, avio_size(s->pb) - 8, SEEK_SET);
245  while (avio_tell(s->pb) > 12 && max_interations--) {
246  if (avio_rl32(s->pb) == MKTAG('d','h','a','v')) {
247  int64_t seek_back = avio_rl32(s->pb);
248 
249  avio_seek(s->pb, -seek_back, SEEK_CUR);
250  read_chunk(s);
251  get_timeinfo(dhav->date, &timeinfo);
252  end = av_timegm(&timeinfo) * 1000LL;
253  break;
254  } else {
255  avio_seek(s->pb, -12, SEEK_CUR);
256  }
257  }
258 
259  avio_seek(s->pb, start_pos, SEEK_SET);
260 
261  read_chunk(s);
262  get_timeinfo(dhav->date, &timeinfo);
263  start = av_timegm(&timeinfo) * 1000LL;
264 
265  avio_seek(s->pb, start_pos, SEEK_SET);
266 
267  return end - start;
268 }
269 
271 {
272  DHAVContext *dhav = s->priv_data;
273  uint8_t signature[5];
274 
275  ffio_ensure_seekback(s->pb, 5);
276  avio_read(s->pb, signature, sizeof(signature));
277  if (!memcmp(signature, "DAHUA", 5)) {
278  avio_skip(s->pb, 0x400 - 5);
279  dhav->last_good_pos = avio_tell(s->pb);
280  } else {
281  if (!memcmp(signature, "DHAV", 4)) {
282  avio_seek(s->pb, -5, SEEK_CUR);
283  dhav->last_good_pos = avio_tell(s->pb);
284  } else if (s->pb->seekable) {
285  avio_seek(s->pb, avio_size(s->pb) - 8, SEEK_SET);
286  while (avio_rl32(s->pb) == MKTAG('d','h','a','v')) {
287  int seek_back;
288 
289  seek_back = avio_rl32(s->pb) + 8;
290  if (seek_back < 9)
291  break;
292  dhav->last_good_pos = avio_tell(s->pb);
293  avio_seek(s->pb, -seek_back, SEEK_CUR);
294  }
295  avio_seek(s->pb, dhav->last_good_pos, SEEK_SET);
296  }
297  }
298 
299  dhav->duration = get_duration(s);
300  dhav->last_good_pos = avio_tell(s->pb);
301  s->ctx_flags |= AVFMTCTX_NOHEADER;
302  dhav->video_stream_index = -1;
303  dhav->audio_stream_index = -1;
304 
305  return 0;
306 }
307 
308 static int64_t get_pts(AVFormatContext *s, int stream_index)
309 {
310  DHAVStream *dst = s->streams[stream_index]->priv_data;
311  DHAVContext *dhav = s->priv_data;
312  struct tm timeinfo;
313  time_t t;
314 
315  get_timeinfo(dhav->date, &timeinfo);
316 
317  t = av_timegm(&timeinfo);
318  if (dst->last_time == t) {
319  int64_t diff = dhav->timestamp - dst->last_timestamp;
320 
321  if (diff < 0)
322  diff += 65535;
323  if (diff == 0 && dhav->frame_rate)
324  diff = av_rescale(dhav->frame_number - dst->last_frame_number, 1000, dhav->frame_rate);
325  dst->pts += diff;
326  } else {
327  dst->pts = t * 1000LL;
328  }
329 
330  dst->last_time = t;
331  dst->last_timestamp = dhav->timestamp;
332  dst->last_frame_number = dhav->frame_number;
333 
334  return dst->pts;
335 }
336 
338 {
339  DHAVContext *dhav = s->priv_data;
340  int size, ret, stream_index;
341 
342 retry:
343  while ((ret = read_chunk(s)) == 0)
344  ;
345 
346  if (ret < 0)
347  return ret;
348 
349  if (dhav->type == 0xfd && dhav->video_stream_index == -1) {
351  DHAVStream *dst;
352 
353  if (!st)
354  return AVERROR(ENOMEM);
355 
357  switch (dhav->video_codec) {
358  case 0x1: st->codecpar->codec_id = AV_CODEC_ID_MPEG4; break;
359  case 0x3: st->codecpar->codec_id = AV_CODEC_ID_MJPEG; break;
360  case 0x2:
361  case 0x4:
362  case 0x8: st->codecpar->codec_id = AV_CODEC_ID_H264; break;
363  case 0xc: st->codecpar->codec_id = AV_CODEC_ID_HEVC; break;
364  default: avpriv_request_sample(s, "Unknown video codec %X", dhav->video_codec);
365  }
366  st->duration = dhav->duration;
367  st->codecpar->width = dhav->width;
368  st->codecpar->height = dhav->height;
369  st->avg_frame_rate.num = dhav->frame_rate;
370  st->avg_frame_rate.den = 1;
371  st->priv_data = dst = av_mallocz(sizeof(DHAVStream));
372  if (!st->priv_data)
373  return AVERROR(ENOMEM);
374  dst->last_time = AV_NOPTS_VALUE;
375  dhav->video_stream_index = st->index;
376 
377  avpriv_set_pts_info(st, 64, 1, 1000);
378  } else if (dhav->type == 0xf0 && dhav->audio_stream_index == -1) {
380  DHAVStream *dst;
381 
382  if (!st)
383  return AVERROR(ENOMEM);
384 
386  switch (dhav->audio_codec) {
387  case 0x07: st->codecpar->codec_id = AV_CODEC_ID_PCM_S8; break;
388  case 0x0c: st->codecpar->codec_id = AV_CODEC_ID_PCM_S16LE; break;
389  case 0x10: st->codecpar->codec_id = AV_CODEC_ID_PCM_S16LE; break;
390  case 0x0a: st->codecpar->codec_id = AV_CODEC_ID_PCM_MULAW; break;
391  case 0x16: st->codecpar->codec_id = AV_CODEC_ID_PCM_MULAW; break;
392  case 0x0e: st->codecpar->codec_id = AV_CODEC_ID_PCM_ALAW; break;
393  case 0x1a: st->codecpar->codec_id = AV_CODEC_ID_AAC; break;
394  case 0x1f: st->codecpar->codec_id = AV_CODEC_ID_MP2; break;
395  case 0x21: st->codecpar->codec_id = AV_CODEC_ID_MP3; break;
396  case 0x0d: st->codecpar->codec_id = AV_CODEC_ID_ADPCM_MS; break;
397  default: avpriv_request_sample(s, "Unknown audio codec %X", dhav->audio_codec);
398  }
399  st->duration = dhav->duration;
401  st->codecpar->sample_rate = dhav->sample_rate;
402  st->priv_data = dst = av_mallocz(sizeof(DHAVStream));
403  if (!st->priv_data)
404  return AVERROR(ENOMEM);
405  dst->last_time = AV_NOPTS_VALUE;
406  dhav->audio_stream_index = st->index;
407 
408  avpriv_set_pts_info(st, 64, 1, 1000);
409  }
410 
411  stream_index = dhav->type == 0xf0 ? dhav->audio_stream_index : dhav->video_stream_index;
412  if (stream_index < 0) {
413  avio_skip(s->pb, ret);
414  if (avio_rl32(s->pb) == MKTAG('d','h','a','v'))
415  avio_skip(s->pb, 4);
416  goto retry;
417  }
418 
419  size = ret;
420  ret = av_get_packet(s->pb, pkt, size);
421  if (ret < 0)
422  return ret;
423  pkt->stream_index = stream_index;
424  if (dhav->type != 0xfc)
426  pkt->duration = 1;
427  if (pkt->stream_index >= 0)
429  pkt->pos = dhav->last_good_pos;
430  if (avio_rl32(s->pb) == MKTAG('d','h','a','v'))
431  avio_skip(s->pb, 4);
432 
433  return ret;
434 }
435 
436 static int dhav_read_seek(AVFormatContext *s, int stream_index,
437  int64_t timestamp, int flags)
438 {
439  DHAVContext *dhav = s->priv_data;
440  AVStream *st = s->streams[stream_index];
441  FFStream *const sti = ffstream(st);
442  int index = av_index_search_timestamp(st, timestamp, flags);
443  int64_t pts;
444 
445  if (index < 0)
446  return -1;
448  if (pts < timestamp)
449  return AVERROR(EAGAIN);
450  if (avio_seek(s->pb, sti->index_entries[index].pos, SEEK_SET) < 0)
451  return -1;
452 
453  for (int n = 0; n < s->nb_streams; n++) {
454  AVStream *st = s->streams[n];
455  DHAVStream *dst = st->priv_data;
456 
457  dst->pts = pts;
458  dst->last_time = AV_NOPTS_VALUE;
459  }
460  dhav->last_good_pos = avio_tell(s->pb);
461 
462  return 0;
463 }
464 
466  .name = "dhav",
467  .long_name = NULL_IF_CONFIG_SMALL("Video DAV"),
468  .priv_data_size = sizeof(DHAVContext),
473  .extensions = "dav",
475 };
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:331
AV_CODEC_ID_ADPCM_MS
@ AV_CODEC_ID_ADPCM_MS
Definition: codec_id.h:376
AVFMT_NO_BYTE_SEEK
#define AVFMT_NO_BYTE_SEEK
Format does not allow seeking by bytes.
Definition: avformat.h:488
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
DHAVContext::frame_number
unsigned frame_number
Definition: dhav.c:35
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)
Add a new stream to a media file.
get_pts
static int64_t get_pts(AVFormatContext *s, int stream_index)
Definition: dhav.c:308
AVStream::priv_data
void * priv_data
Definition: avformat.h:866
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
dhav_read_header
static int dhav_read_header(AVFormatContext *s)
Definition: dhav.c:270
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:64
dhav_probe
static int dhav_probe(const AVProbeData *p)
Definition: dhav.c:58
DHAVContext::timestamp
unsigned timestamp
Definition: dhav.c:37
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:930
DHAVStream::last_time
int64_t last_time
Definition: dhav.c:54
get_timeinfo
static void get_timeinfo(unsigned date, struct tm *timeinfo)
Definition: dhav.c:214
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:540
DHAVContext::audio_codec
int audio_codec
Definition: dhav.c:42
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:323
avio_size
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:370
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:577
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:464
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:830
DHAVStream::pts
int64_t pts
Definition: dhav.c:55
ffstream
static av_always_inline FFStream * ffstream(AVStream *st)
Definition: internal.h:423
DHAVContext::sample_rate
int sample_rate
Definition: dhav.c:43
AVFMT_SEEK_TO_PTS
#define AVFMT_SEEK_TO_PTS
Seeking is based on PTS.
Definition: avformat.h:504
read_seek
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:151
DHAVContext::frame_rate
int frame_rate
Definition: dhav.c:40
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:513
AVFMT_GENERIC_INDEX
#define AVFMT_GENERIC_INDEX
Use generic index building code.
Definition: avformat.h:481
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
pts
static int64_t pts
Definition: transcode_aac.c:643
av_timegm
time_t av_timegm(struct tm *tm)
Convert the decomposed UTC time in tm to a time_t value.
Definition: parseutils.c:570
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:444
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:900
avio_rl16
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:761
AVRational::num
int num
Numerator.
Definition: rational.h:59
DHAVContext::date
unsigned date
Definition: dhav.c:36
signature
static const char signature[]
Definition: ipmovie.c:591
DHAVContext::type
unsigned type
Definition: dhav.c:31
AV_CODEC_ID_PCM_S8
@ AV_CODEC_ID_PCM_S8
Definition: codec_id.h:335
pkt
AVPacket * pkt
Definition: movenc.c:59
AVInputFormat
Definition: avformat.h:549
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_read_callback.c:41
s
#define s(width, name)
Definition: cbs_vp9.c:198
DHAVContext
Definition: dhav.c:30
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:554
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:454
read_chunk
static int read_chunk(AVFormatContext *s)
Definition: dhav.c:170
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:121
AV_CODEC_ID_MP2
@ AV_CODEC_ID_MP2
Definition: codec_id.h:443
AVIndexEntry::timestamp
int64_t timestamp
Timestamp in AVStream.time_base units, preferably the time from which on correctly decoded frames are...
Definition: avformat.h:702
dhav_read_seek
static int dhav_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: dhav.c:436
DHAVContext::channel
unsigned channel
Definition: dhav.c:33
AV_CODEC_ID_PCM_MULAW
@ AV_CODEC_ID_PCM_MULAW
Definition: codec_id.h:337
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
AVFormatContext
Format I/O context.
Definition: avformat.h:1202
AV_CODEC_ID_PCM_ALAW
@ AV_CODEC_ID_PCM_ALAW
Definition: codec_id.h:338
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:864
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:550
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:1153
parse_ext
static int parse_ext(AVFormatContext *s, int length)
Definition: dhav.c:80
DHAVContext::audio_stream_index
int audio_stream_index
Definition: dhav.c:48
parseutils.h
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:452
DHAVContext::duration
int64_t duration
Definition: dhav.c:45
seek_back
static void seek_back(AVFormatContext *s, AVIOContext *pb, int64_t pos)
Definition: mpegts.c:3094
time.h
DHAVStream::last_timestamp
int64_t last_timestamp
Definition: dhav.c:53
DHAVContext::height
int height
Definition: dhav.c:38
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:206
index
int index
Definition: gxfenc.c:89
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:171
DHAVContext::video_codec
int video_codec
Definition: dhav.c:39
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:445
sample_rates
static const uint32_t sample_rates[]
Definition: dhav.c:74
avio_rl32
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:777
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:106
FFStream
Definition: internal.h:199
get_duration
static int64_t get_duration(AVFormatContext *s)
Definition: dhav.c:233
size
int size
Definition: twinvq_data.h:10344
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
DHAVStream::last_frame_number
int64_t last_frame_number
Definition: dhav.c:52
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:164
DHAVStream
Definition: dhav.c:51
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:650
ffio_ensure_seekback
int ffio_ensure_seekback(AVIOContext *s, int64_t buf_size)
Ensures that the requested seekback buffer size will be available.
Definition: aviobuf.c:1135
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:528
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
DHAVContext::subtype
unsigned subtype
Definition: dhav.c:32
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:59
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:515
avio_internal.h
AVCodecParameters::height
int height
Definition: codec_par.h:122
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:226
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:254
av_rescale
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
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:103
AVFMT_TS_NONSTRICT
#define AVFMT_TS_NONSTRICT
Format does not require strictly increasing timestamps, but they must still be monotonic.
Definition: avformat.h:492
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:841
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:278
ff_dhav_demuxer
const AVInputFormat ff_dhav_demuxer
Definition: dhav.c:465
avformat.h
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:847
AVRational::den
int den
Denominator.
Definition: rational.h:60
dhav_read_packet
static int dhav_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: dhav.c:337
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:659
AVIndexEntry::pos
int64_t pos
Definition: avformat.h:701
AVPacket::stream_index
int stream_index
Definition: packet.h:524
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:365
FFStream::index_entries
AVIndexEntry * index_entries
Only used if the format does not support seeking natively.
Definition: internal.h:255
DHAVContext::audio_channels
int audio_channels
Definition: dhav.c:41
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
read_probe
static int read_probe(const AVProbeData *p)
Definition: cdg.c:29
AVFMT_TS_DISCONT
#define AVFMT_TS_DISCONT
Format allows timestamp discontinuities.
Definition: avformat.h:482
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
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:499
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:542
DHAVContext::video_stream_index
int video_stream_index
Definition: dhav.c:47
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
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
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
DHAVContext::last_good_pos
int64_t last_good_pos
Definition: dhav.c:44
DHAVContext::width
int width
Definition: dhav.c:38
DHAVContext::frame_subnumber
unsigned frame_subnumber
Definition: dhav.c:34
av_index_search_timestamp
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags)
Get the index for a specific timestamp.
Definition: seek.c:243
min
float min
Definition: vorbis_enc_data.h:429
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:393