FFmpeg
dv.c
Go to the documentation of this file.
1 /*
2  * General DV demuxer
3  * Copyright (c) 2003 Roman Shaposhnik
4  *
5  * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
6  * of DV technical info.
7  *
8  * Raw DV format
9  * Copyright (c) 2002 Fabrice Bellard
10  *
11  * 50 Mbps (DVCPRO50) and 100 Mbps (DVCPRO HD) support
12  * Copyright (c) 2006 Daniel Maas <dmaas@maasdigital.com>
13  * Funded by BBC Research & Development
14  *
15  * This file is part of FFmpeg.
16  *
17  * FFmpeg is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  *
22  * FFmpeg is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
25  * Lesser General Public License for more details.
26  *
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with FFmpeg; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30  */
31 #include <time.h>
32 #include "avformat.h"
33 #include "internal.h"
34 #include "libavcodec/dv_profile.h"
35 #include "libavcodec/dv.h"
37 #include "libavutil/intreadwrite.h"
38 #include "libavutil/mathematics.h"
39 #include "libavutil/timecode.h"
40 #include "dv.h"
41 #include "libavutil/avassert.h"
42 
44  const AVDVProfile* sys; /* Current DV profile. E.g.: 525/60, 625/50 */
49  uint8_t audio_buf[4][8192];
50  int ach;
51  int frames;
52 };
53 
54 static inline uint16_t dv_audio_12to16(uint16_t sample)
55 {
56  uint16_t shift, result;
57 
58  sample = (sample < 0x800) ? sample : sample | 0xf000;
59  shift = (sample & 0xf00) >> 8;
60 
61  if (shift < 0x2 || shift > 0xd) {
62  result = sample;
63  } else if (shift < 0x8) {
64  shift--;
65  result = (sample - (256 * shift)) << shift;
66  } else {
67  shift = 0xe - shift;
68  result = ((sample + ((256 * shift) + 1)) << shift) - 1;
69  }
70 
71  return result;
72 }
73 
74 static const uint8_t *dv_extract_pack(const uint8_t *frame, enum dv_pack_type t)
75 {
76  int offs;
77  int c;
78 
79  for (c = 0; c < 10; c++) {
80  switch (t) {
81  case dv_audio_source:
82  if (c&1) offs = (80 * 6 + 80 * 16 * 0 + 3 + c*12000);
83  else offs = (80 * 6 + 80 * 16 * 3 + 3 + c*12000);
84  break;
85  case dv_audio_control:
86  if (c&1) offs = (80 * 6 + 80 * 16 * 1 + 3 + c*12000);
87  else offs = (80 * 6 + 80 * 16 * 4 + 3 + c*12000);
88  break;
89  case dv_video_control:
90  if (c&1) offs = (80 * 3 + 8 + c*12000);
91  else offs = (80 * 5 + 48 + 5 + c*12000);
92  break;
93  case dv_timecode:
94  offs = (80*1 + 3 + 3);
95  break;
96  default:
97  return NULL;
98  }
99  if (frame[offs] == t)
100  break;
101  }
102 
103  return frame[offs] == t ? &frame[offs] : NULL;
104 }
105 
106 static const int dv_audio_frequency[3] = {
107  48000, 44100, 32000,
108 };
109 
110 /*
111  * There's a couple of assumptions being made here:
112  * 1. By default we silence erroneous (0x8000/16-bit 0x800/12-bit) audio samples.
113  * We can pass them upwards when libavcodec will be ready to deal with them.
114  * 2. We don't do software emphasis.
115  * 3. Audio is always returned as 16-bit linear samples: 12-bit nonlinear samples
116  * are converted into 16-bit linear ones.
117  */
118 static int dv_extract_audio(const uint8_t *frame, uint8_t **ppcm,
119  const AVDVProfile *sys)
120 {
121  int size, chan, i, j, d, of, smpls, freq, quant, half_ch;
122  uint16_t lc, rc;
123  const uint8_t *as_pack;
124  uint8_t *pcm, ipcm;
125 
126  as_pack = dv_extract_pack(frame, dv_audio_source);
127  if (!as_pack) /* No audio ? */
128  return 0;
129 
130  smpls = as_pack[1] & 0x3f; /* samples in this frame - min. samples */
131  freq = as_pack[4] >> 3 & 0x07; /* 0 - 48kHz, 1 - 44,1kHz, 2 - 32kHz */
132  quant = as_pack[4] & 0x07; /* 0 - 16-bit linear, 1 - 12-bit nonlinear */
133 
134  if (quant > 1)
135  return -1; /* unsupported quantization */
136 
137  if (freq >= FF_ARRAY_ELEMS(dv_audio_frequency))
138  return AVERROR_INVALIDDATA;
139 
140  size = (sys->audio_min_samples[freq] + smpls) * 4; /* 2ch, 2bytes */
141  half_ch = sys->difseg_size / 2;
142 
143  /* We work with 720p frames split in half, thus even frames have
144  * channels 0,1 and odd 2,3. */
145  ipcm = (sys->height == 720 && !(frame[1] & 0x0C)) ? 2 : 0;
146 
147  if (ipcm + sys->n_difchan > (quant == 1 ? 2 : 4)) {
148  av_log(NULL, AV_LOG_ERROR, "too many dv pcm frames\n");
149  return AVERROR_INVALIDDATA;
150  }
151 
152  /* for each DIF channel */
153  for (chan = 0; chan < sys->n_difchan; chan++) {
154  av_assert0(ipcm<4);
155  pcm = ppcm[ipcm++];
156  if (!pcm)
157  break;
158 
159  /* for each DIF segment */
160  for (i = 0; i < sys->difseg_size; i++) {
161  frame += 6 * 80; /* skip DIF segment header */
162  if (quant == 1 && i == half_ch) {
163  /* next stereo channel (12-bit mode only) */
164  av_assert0(ipcm<4);
165  pcm = ppcm[ipcm++];
166  if (!pcm)
167  break;
168  }
169 
170  /* for each AV sequence */
171  for (j = 0; j < 9; j++) {
172  for (d = 8; d < 80; d += 2) {
173  if (quant == 0) { /* 16-bit quantization */
174  of = sys->audio_shuffle[i][j] +
175  (d - 8) / 2 * sys->audio_stride;
176  if (of * 2 >= size)
177  continue;
178 
179  /* FIXME: maybe we have to admit that DV is a
180  * big-endian PCM */
181  pcm[of * 2] = frame[d + 1];
182  pcm[of * 2 + 1] = frame[d];
183 
184  if (pcm[of * 2 + 1] == 0x80 && pcm[of * 2] == 0x00)
185  pcm[of * 2 + 1] = 0;
186  } else { /* 12-bit quantization */
187  lc = ((uint16_t)frame[d] << 4) |
188  ((uint16_t)frame[d + 2] >> 4);
189  rc = ((uint16_t)frame[d + 1] << 4) |
190  ((uint16_t)frame[d + 2] & 0x0f);
191  lc = (lc == 0x800 ? 0 : dv_audio_12to16(lc));
192  rc = (rc == 0x800 ? 0 : dv_audio_12to16(rc));
193 
194  of = sys->audio_shuffle[i % half_ch][j] +
195  (d - 8) / 3 * sys->audio_stride;
196  if (of * 2 >= size)
197  continue;
198 
199  /* FIXME: maybe we have to admit that DV is a
200  * big-endian PCM */
201  pcm[of * 2] = lc & 0xff;
202  pcm[of * 2 + 1] = lc >> 8;
203  of = sys->audio_shuffle[i % half_ch + half_ch][j] +
204  (d - 8) / 3 * sys->audio_stride;
205  /* FIXME: maybe we have to admit that DV is a
206  * big-endian PCM */
207  pcm[of * 2] = rc & 0xff;
208  pcm[of * 2 + 1] = rc >> 8;
209  ++d;
210  }
211  }
212 
213  frame += 16 * 80; /* 15 Video DIFs + 1 Audio DIF */
214  }
215  }
216  }
217 
218  return size;
219 }
220 
222 {
223  const uint8_t *as_pack;
224  int freq, stype, smpls, quant, i, ach;
225 
226  as_pack = dv_extract_pack(frame, dv_audio_source);
227  if (!as_pack || !c->sys) { /* No audio ? */
228  c->ach = 0;
229  return 0;
230  }
231 
232  smpls = as_pack[1] & 0x3f; /* samples in this frame - min. samples */
233  freq = as_pack[4] >> 3 & 0x07; /* 0 - 48kHz, 1 - 44,1kHz, 2 - 32kHz */
234  stype = as_pack[3] & 0x1f; /* 0 - 2CH, 2 - 4CH, 3 - 8CH */
235  quant = as_pack[4] & 0x07; /* 0 - 16-bit linear, 1 - 12-bit nonlinear */
236 
237  if (freq >= FF_ARRAY_ELEMS(dv_audio_frequency)) {
239  "Unrecognized audio sample rate index (%d)\n", freq);
240  return 0;
241  }
242 
243  if (stype > 3) {
244  av_log(c->fctx, AV_LOG_ERROR, "stype %d is invalid\n", stype);
245  c->ach = 0;
246  return 0;
247  }
248 
249  /* note: ach counts PAIRS of channels (i.e. stereo channels) */
250  ach = ((int[4]) { 1, 0, 2, 4 })[stype];
251  if (ach == 1 && quant && freq == 2)
252  ach = 2;
253 
254  /* Dynamic handling of the audio streams in DV */
255  for (i = 0; i < ach; i++) {
256  if (!c->ast[i]) {
257  c->ast[i] = avformat_new_stream(c->fctx, NULL);
258  if (!c->ast[i])
259  break;
260  avpriv_set_pts_info(c->ast[i], 64, c->sys->time_base.num, c->sys->time_base.den);
263 
264  av_init_packet(&c->audio_pkt[i]);
265  c->audio_pkt[i].size = 0;
266  c->audio_pkt[i].data = c->audio_buf[i];
267  c->audio_pkt[i].stream_index = c->ast[i]->index;
269  }
271  c->ast[i]->codecpar->channels = 2;
273  c->ast[i]->codecpar->bit_rate = 2 * dv_audio_frequency[freq] * 16;
274  c->ast[i]->start_time = 0;
275  }
276  c->ach = i;
277 
278  return (c->sys->audio_min_samples[freq] + smpls) * 4; /* 2ch, 2bytes */
279 }
280 
282 {
283  const uint8_t *vsc_pack;
284  AVCodecParameters *par;
285  int apt, is16_9;
286 
287  par = c->vst->codecpar;
288 
290  c->sys->time_base.den);
292 
293  /* finding out SAR is a little bit messy */
294  vsc_pack = dv_extract_pack(frame, dv_video_control);
295  apt = frame[4] & 0x07;
296  is16_9 = (vsc_pack && ((vsc_pack[2] & 0x07) == 0x02 ||
297  (!apt && (vsc_pack[2] & 0x07) == 0x07)));
298  c->vst->sample_aspect_ratio = c->sys->sar[is16_9];
299  par->bit_rate = av_rescale_q(c->sys->frame_size,
300  (AVRational) { 8, 1 },
301  c->sys->time_base);
302  return c->sys->frame_size;
303 }
304 
305 static int dv_extract_timecode(DVDemuxContext* c, const uint8_t* frame, char *tc)
306 {
307  const uint8_t *tc_pack;
308 
309  // For PAL systems, drop frame bit is replaced by an arbitrary
310  // bit so its value should not be considered. Drop frame timecode
311  // is only relevant for NTSC systems.
312  int prevent_df = c->sys->ltc_divisor == 25 || c->sys->ltc_divisor == 50;
313 
314  tc_pack = dv_extract_pack(frame, dv_timecode);
315  if (!tc_pack)
316  return 0;
317  av_timecode_make_smpte_tc_string2(tc, av_inv_q(c->sys->time_base), AV_RB32(tc_pack + 1), prevent_df, 1);
318  return 1;
319 }
320 
321 /* The following 3 functions constitute our interface to the world */
322 
324 {
325  c->vst = avformat_new_stream(s, NULL);
326  if (!c->vst)
327  return AVERROR(ENOMEM);
328 
329  c->fctx = s;
332  c->vst->codecpar->bit_rate = 25000000;
333  c->vst->start_time = 0;
334 
335  return 0;
336 }
337 
339 {
340  DVDemuxContext *c;
341 
342  c = av_mallocz(sizeof(DVDemuxContext));
343  if (!c)
344  return NULL;
345 
346  if (dv_init_demux(s, c)) {
347  av_free(c);
348  return NULL;
349  }
350 
351  return c;
352 }
353 
355 {
356  int size = -1;
357  int i;
358 
359  for (i = 0; i < c->ach; i++) {
360  if (c->ast[i] && c->audio_pkt[i].size) {
361  *pkt = c->audio_pkt[i];
362  c->audio_pkt[i].size = 0;
363  size = pkt->size;
364  break;
365  }
366  }
367 
368  return size;
369 }
370 
372  uint8_t *buf, int buf_size, int64_t pos)
373 {
374  int size, i;
375  uint8_t *ppcm[5] = { 0 };
376 
377  if (buf_size < DV_PROFILE_BYTES ||
378  !(c->sys = av_dv_frame_profile(c->sys, buf, buf_size)) ||
379  buf_size < c->sys->frame_size) {
380  return -1; /* Broken frame, or not enough data */
381  }
382 
383  /* Queueing audio packet */
384  /* FIXME: in case of no audio/bad audio we have to do something */
385  size = dv_extract_audio_info(c, buf);
386  for (i = 0; i < c->ach; i++) {
387  c->audio_pkt[i].pos = pos;
388  c->audio_pkt[i].size = size;
389  c->audio_pkt[i].pts = (c->sys->height == 720) ? (c->frames & ~1) : c->frames;
390  ppcm[i] = c->audio_buf[i];
391  }
392  if (c->ach)
393  dv_extract_audio(buf, ppcm, c->sys);
394 
395  /* We work with 720p frames split in half, thus even frames have
396  * channels 0,1 and odd 2,3. */
397  if (c->sys->height == 720) {
398  if (buf[1] & 0x0C) {
399  c->audio_pkt[2].size = c->audio_pkt[3].size = 0;
400  } else {
401  c->audio_pkt[0].size = c->audio_pkt[1].size = 0;
402  }
403  }
404 
405  /* Now it's time to return video packet */
406  size = dv_extract_video_info(c, buf);
407  av_init_packet(pkt);
408  pkt->data = buf;
409  pkt->pos = pos;
410  pkt->size = size;
411  pkt->flags |= AV_PKT_FLAG_KEY;
412  pkt->stream_index = c->vst->index;
413  pkt->pts = c->frames;
414 
415  c->frames++;
416 
417  return size;
418 }
419 
421  int64_t timestamp, int flags)
422 {
423  // FIXME: sys may be wrong if last dv_read_packet() failed (buffer is junk)
424  const int frame_size = c->sys->frame_size;
425  int64_t offset;
426  int64_t size = avio_size(s->pb) - s->internal->data_offset;
427  int64_t max_offset = ((size - 1) / frame_size) * frame_size;
428 
429  offset = frame_size * timestamp;
430 
431  if (size >= 0 && offset > max_offset)
432  offset = max_offset;
433  else if (offset < 0)
434  offset = 0;
435 
436  return offset + s->internal->data_offset;
437 }
438 
439 void ff_dv_offset_reset(DVDemuxContext *c, int64_t frame_offset)
440 {
441  c->frames = frame_offset;
442  c->audio_pkt[0].size = c->audio_pkt[1].size = 0;
443  c->audio_pkt[2].size = c->audio_pkt[3].size = 0;
444 }
445 
446 /************************************************************
447  * Implementation of the easiest DV storage of all -- raw DV.
448  ************************************************************/
449 
450 typedef struct RawDVContext {
453 } RawDVContext;
454 
456  int ret;
457  char timecode[AV_TIMECODE_STR_SIZE];
458  int64_t pos = avio_tell(s->pb);
459 
460  // Read 3 DIF blocks: Header block and 2 Subcode blocks.
461 #define PARTIAL_FRAME_SIZE (3 * 80)
462  uint8_t partial_frame[PARTIAL_FRAME_SIZE];
463  RawDVContext *c = s->priv_data;
464 
465  ret = avio_read(s->pb, partial_frame, PARTIAL_FRAME_SIZE);
466  if (ret < 0)
467  goto finish;
468 
469  if (ret < PARTIAL_FRAME_SIZE) {
470  ret = -1;
471  goto finish;
472  }
473 
474  ret = dv_extract_timecode(&c->dv_demux, partial_frame, timecode);
475  if (ret)
476  av_dict_set(&s->metadata, "timecode", timecode, 0);
477  else
478  av_log(s, AV_LOG_ERROR, "Detected timecode is invalid\n");
479 
480 finish:
481  avio_seek(s->pb, pos, SEEK_SET);
482  return ret;
483 }
484 
486 {
487  unsigned state, marker_pos = 0;
488  RawDVContext *c = s->priv_data;
489  int ret;
490 
491  if ((ret = dv_init_demux(s, &c->dv_demux)) < 0)
492  return ret;
493 
494  state = avio_rb32(s->pb);
495  while ((state & 0xffffff7f) != 0x1f07003f) {
496  if (avio_feof(s->pb)) {
497  av_log(s, AV_LOG_ERROR, "Cannot find DV header.\n");
498  return AVERROR_INVALIDDATA;
499  }
500  if (state == 0x003f0700 || state == 0xff3f0700)
501  marker_pos = avio_tell(s->pb);
502  if (state == 0xff3f0701 && avio_tell(s->pb) - marker_pos == 80) {
503  avio_seek(s->pb, -163, SEEK_CUR);
504  state = avio_rb32(s->pb);
505  break;
506  }
507  state = (state << 8) | avio_r8(s->pb);
508  }
509  AV_WB32(c->buf, state);
510 
511  if (avio_read(s->pb, c->buf + 4, DV_PROFILE_BYTES - 4) != DV_PROFILE_BYTES - 4 ||
512  avio_seek(s->pb, -DV_PROFILE_BYTES, SEEK_CUR) < 0) {
513  return AVERROR(EIO);
514  }
515 
517  c->buf,
519  if (!c->dv_demux.sys) {
520  av_log(s, AV_LOG_ERROR,
521  "Can't determine profile of DV input stream.\n");
522  return AVERROR_INVALIDDATA;
523  }
524 
526  (AVRational) { 8, 1 },
527  c->dv_demux.sys->time_base);
528 
529  if (s->pb->seekable & AVIO_SEEKABLE_NORMAL)
530  dv_read_timecode(s);
531 
532  return 0;
533 }
534 
536 {
537  int size;
538  RawDVContext *c = s->priv_data;
539 
540  size = avpriv_dv_get_packet(&c->dv_demux, pkt);
541 
542  if (size < 0) {
543  int ret;
544  int64_t pos = avio_tell(s->pb);
545  if (!c->dv_demux.sys)
546  return AVERROR(EIO);
547  size = c->dv_demux.sys->frame_size;
548  ret = avio_read(s->pb, c->buf, size);
549  if (ret < 0) {
550  return ret;
551  } else if (ret == 0) {
552  return AVERROR(EIO);
553  }
554 
555  size = avpriv_dv_produce_packet(&c->dv_demux, pkt, c->buf, size, pos);
556  }
557 
558  return size;
559 }
560 
561 static int dv_read_seek(AVFormatContext *s, int stream_index,
562  int64_t timestamp, int flags)
563 {
564  RawDVContext *r = s->priv_data;
565  DVDemuxContext *c = &r->dv_demux;
566  int64_t offset = dv_frame_offset(s, c, timestamp, flags);
567 
568  if (avio_seek(s->pb, offset, SEEK_SET) < 0)
569  return -1;
570 
571  ff_dv_offset_reset(c, offset / c->sys->frame_size);
572  return 0;
573 }
574 
575 static int dv_probe(const AVProbeData *p)
576 {
577  unsigned marker_pos = 0;
578  int i;
579  int matches = 0;
580  int firstmatch = 0;
581  int secondary_matches = 0;
582 
583  if (p->buf_size < 5)
584  return 0;
585 
586  for (i = 0; i < p->buf_size-4; i++) {
587  unsigned state = AV_RB32(p->buf+i);
588  if ((state & 0x0007f840) == 0x00070000) {
589  // any section header, also with seq/chan num != 0,
590  // should appear around every 12000 bytes, at least 10 per frame
591  if ((state & 0xff07ff7f) == 0x1f07003f) {
592  secondary_matches++;
593  if ((state & 0xffffff7f) == 0x1f07003f) {
594  matches++;
595  if (!i)
596  firstmatch = 1;
597  }
598  }
599  if (state == 0x003f0700 || state == 0xff3f0700)
600  marker_pos = i;
601  if (state == 0xff3f0701 && i - marker_pos == 80)
602  matches++;
603  }
604  }
605 
606  if (matches && p->buf_size / matches < 1024 * 1024) {
607  if (matches > 4 || firstmatch ||
608  (secondary_matches >= 10 &&
609  p->buf_size / secondary_matches < 24000))
610  // not max to avoid dv in mov to match
611  return AVPROBE_SCORE_MAX * 3 / 4;
612  return AVPROBE_SCORE_MAX / 4;
613  }
614  return 0;
615 }
616 
618  .name = "dv",
619  .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
620  .priv_data_size = sizeof(RawDVContext),
621  .read_probe = dv_probe,
625  .extensions = "dv,dif",
626 };
#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:346
static int shift(int a, int b)
Definition: sonic.c:82
#define PARTIAL_FRAME_SIZE
static int dv_read_timecode(AVFormatContext *s)
Definition: dv.c:455
static const int dv_audio_frequency[3]
Definition: dv.c:106
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:383
static int dv_read_header(AVFormatContext *s)
Definition: dv.c:485
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:4893
int64_t data_offset
offset of the first packet
Definition: internal.h:80
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:153
int ltc_divisor
Definition: dv_profile.h:46
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:942
int num
Numerator.
Definition: rational.h:59
int index
stream index in AVFormatContext
Definition: avformat.h:881
int size
Definition: packet.h:364
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:253
AVFormatInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1704
int64_t bit_rate
Total stream bitrate in bit/s, 0 if not available.
Definition: avformat.h:1361
#define tc
Definition: regdef.h:69
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
AVFormatContext * fctx
Definition: dv.c:45
static AVPacket pkt
#define AV_CH_LAYOUT_STEREO
#define sample
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
Format I/O context.
Definition: avformat.h:1239
uint8_t audio_buf[4][8192]
Definition: dv.c:49
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
int ach
Definition: dv.c:50
static int dv_extract_audio_info(DVDemuxContext *c, const uint8_t *frame)
Definition: dv.c:221
dv_pack_type
Definition: dv.h:69
uint8_t
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:785
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 offset
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4477
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:91
static void finish(void)
Definition: movenc.c:345
int difseg_size
Definition: dv_profile.h:43
DVDemuxContext * avpriv_dv_init_demux(AVFormatContext *s)
Definition: dv.c:338
uint8_t * data
Definition: packet.h:363
AVPacket audio_pkt[4]
Definition: dv.c:48
AVStream * ast[4]
Definition: dv.c:47
DVDemuxContext dv_demux
Definition: dv.c:451
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
AVInputFormat ff_dv_demuxer
Definition: dv.c:617
int frames
Definition: dv.c:51
AVRational time_base
Definition: dv_profile.h:45
uint64_t channel_layout
Audio only.
Definition: codec_par.h:162
#define av_log(a,...)
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:637
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:89
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:401
const uint8_t(* audio_shuffle)[9]
Definition: dv_profile.h:58
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
int audio_min_samples[3]
Definition: dv_profile.h:54
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1479
static int dv_init_demux(AVFormatContext *s, DVDemuxContext *c)
Definition: dv.c:323
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:115
const char * r
Definition: vf_curves.c:114
const AVDVProfile * av_dv_frame_profile(const AVDVProfile *sys, const uint8_t *frame, unsigned buf_size)
Get a DV profile for the provided compressed frame.
Definition: dv_profile.c:300
unsigned int pos
Definition: spdifenc.c:410
int frame_size
Definition: dv_profile.h:42
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
static int dv_probe(const AVProbeData *p)
Definition: dv.c:575
simple assert() macros that are a bit more flexible than ISO C assert().
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:953
static int dv_extract_timecode(DVDemuxContext *c, const uint8_t *frame, char *tc)
Definition: dv.c:305
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:369
const AVDVProfile * sys
Definition: dv.c:44
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:628
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:444
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:443
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:260
audio channel layout utility functions
void ff_dv_offset_reset(DVDemuxContext *c, int64_t frame_offset)
Definition: dv.c:439
static int dv_extract_audio(const uint8_t *frame, uint8_t **ppcm, const AVDVProfile *sys)
Definition: dv.c:118
char * av_timecode_make_smpte_tc_string2(char *buf, AVRational rate, uint32_t tcsmpte, int prevent_df, int skip_field)
Get the timecode string from the SMPTE timecode format.
Definition: timecode.c:136
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
#define s(width, name)
Definition: cbs_vp9.c:257
#define FF_ARRAY_ELEMS(a)
static int dv_extract_video_info(DVDemuxContext *c, const uint8_t *frame)
Definition: dv.c:281
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:527
if(ret)
Stream structure.
Definition: avformat.h:880
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
static const uint8_t * dv_extract_pack(const uint8_t *frame, enum dv_pack_type t)
Definition: dv.c:74
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
int frame_size
Definition: mxfenc.c:2165
int avpriv_dv_produce_packet(DVDemuxContext *c, AVPacket *pkt, uint8_t *buf, int buf_size, int64_t pos)
Definition: dv.c:371
Definition: dv.h:72
Timecode helpers header.
AVIOContext * pb
I/O context.
Definition: avformat.h:1281
#define DV_MAX_FRAME_SIZE
largest possible DV frame, in bytes (1080i50)
Definition: dv.h:92
int audio_stride
Definition: dv_profile.h:53
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
AVRational sar[2]
Definition: dv_profile.h:49
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
Rational number (pair of numerator and denominator).
Definition: rational.h:58
#define DV_PROFILE_BYTES
Definition: dv_profile.h:30
This structure contains the data a format has to probe a file.
Definition: avformat.h:441
static int dv_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: dv.c:561
const uint8_t * quant
#define flags(name, subs,...)
Definition: cbs_av1.c:561
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
int sample_rate
Audio only.
Definition: codec_par.h:170
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:453
Main libavformat public API header.
static struct @323 state
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base...
Definition: avformat.h:919
static uint16_t dv_audio_12to16(uint16_t sample)
Definition: dv.c:54
uint8_t buf[DV_MAX_FRAME_SIZE]
Definition: dv.c:452
Constants for DV codec.
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:35
int den
Denominator.
Definition: rational.h:60
int avpriv_dv_get_packet(DVDemuxContext *c, AVPacket *pkt)
Definition: dv.c:354
#define av_free(p)
void * priv_data
Format private data.
Definition: avformat.h:1267
static int64_t dv_frame_offset(AVFormatContext *s, DVDemuxContext *c, int64_t timestamp, int flags)
Definition: dv.c:420
AVStream * vst
Definition: dv.c:46
int channels
Audio only.
Definition: codec_par.h:166
and forward the result(frame or status change) to the corresponding input.If nothing is possible
static int dv_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: dv.c:535
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:652
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1045
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:368
int n_difchan
Definition: dv_profile.h:44
int stream_index
Definition: packet.h:365
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:909
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
This structure stores compressed data.
Definition: packet.h:340
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:356
int i
Definition: input.c:407
#define AV_TIMECODE_STR_SIZE
Definition: timecode.h:33