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  uint64_t abytes;
53 };
54 
55 static inline uint16_t dv_audio_12to16(uint16_t sample)
56 {
57  uint16_t shift, result;
58 
59  sample = (sample < 0x800) ? sample : sample | 0xf000;
60  shift = (sample & 0xf00) >> 8;
61 
62  if (shift < 0x2 || shift > 0xd) {
63  result = sample;
64  } else if (shift < 0x8) {
65  shift--;
66  result = (sample - (256 * shift)) << shift;
67  } else {
68  shift = 0xe - shift;
69  result = ((sample + ((256 * shift) + 1)) << shift) - 1;
70  }
71 
72  return result;
73 }
74 
75 static const uint8_t *dv_extract_pack(const uint8_t *frame, enum dv_pack_type t)
76 {
77  int offs;
78  int c;
79 
80  for (c = 0; c < 10; c++) {
81  switch (t) {
82  case dv_audio_source:
83  if (c&1) offs = (80 * 6 + 80 * 16 * 0 + 3 + c*12000);
84  else offs = (80 * 6 + 80 * 16 * 3 + 3 + c*12000);
85  break;
86  case dv_audio_control:
87  if (c&1) offs = (80 * 6 + 80 * 16 * 1 + 3 + c*12000);
88  else offs = (80 * 6 + 80 * 16 * 4 + 3 + c*12000);
89  break;
90  case dv_video_control:
91  if (c&1) offs = (80 * 3 + 8 + c*12000);
92  else offs = (80 * 5 + 48 + 5 + c*12000);
93  break;
94  case dv_timecode:
95  offs = (80*1 + 3 + 3);
96  break;
97  default:
98  return NULL;
99  }
100  if (frame[offs] == t)
101  break;
102  }
103 
104  return frame[offs] == t ? &frame[offs] : NULL;
105 }
106 
107 static const int dv_audio_frequency[3] = {
108  48000, 44100, 32000,
109 };
110 
111 /*
112  * There's a couple of assumptions being made here:
113  * 1. By default we silence erroneous (0x8000/16-bit 0x800/12-bit) audio samples.
114  * We can pass them upwards when libavcodec will be ready to deal with them.
115  * 2. We don't do software emphasis.
116  * 3. Audio is always returned as 16-bit linear samples: 12-bit nonlinear samples
117  * are converted into 16-bit linear ones.
118  */
119 static int dv_extract_audio(const uint8_t *frame, uint8_t **ppcm,
120  const AVDVProfile *sys)
121 {
122  int size, chan, i, j, d, of, smpls, freq, quant, half_ch;
123  uint16_t lc, rc;
124  const uint8_t *as_pack;
125  uint8_t *pcm, ipcm;
126 
127  as_pack = dv_extract_pack(frame, dv_audio_source);
128  if (!as_pack) /* No audio ? */
129  return 0;
130 
131  smpls = as_pack[1] & 0x3f; /* samples in this frame - min. samples */
132  freq = as_pack[4] >> 3 & 0x07; /* 0 - 48kHz, 1 - 44,1kHz, 2 - 32kHz */
133  quant = as_pack[4] & 0x07; /* 0 - 16-bit linear, 1 - 12-bit nonlinear */
134 
135  if (quant > 1)
136  return -1; /* unsupported quantization */
137 
138  if (freq >= FF_ARRAY_ELEMS(dv_audio_frequency))
139  return AVERROR_INVALIDDATA;
140 
141  size = (sys->audio_min_samples[freq] + smpls) * 4; /* 2ch, 2bytes */
142  half_ch = sys->difseg_size / 2;
143 
144  /* We work with 720p frames split in half, thus even frames have
145  * channels 0,1 and odd 2,3. */
146  ipcm = (sys->height == 720 && !(frame[1] & 0x0C)) ? 2 : 0;
147 
148  if (ipcm + sys->n_difchan > (quant == 1 ? 2 : 4)) {
149  av_log(NULL, AV_LOG_ERROR, "too many dv pcm frames\n");
150  return AVERROR_INVALIDDATA;
151  }
152 
153  /* for each DIF channel */
154  for (chan = 0; chan < sys->n_difchan; chan++) {
155  av_assert0(ipcm<4);
156  pcm = ppcm[ipcm++];
157  if (!pcm)
158  break;
159 
160  /* for each DIF segment */
161  for (i = 0; i < sys->difseg_size; i++) {
162  frame += 6 * 80; /* skip DIF segment header */
163  if (quant == 1 && i == half_ch) {
164  /* next stereo channel (12-bit mode only) */
165  av_assert0(ipcm<4);
166  pcm = ppcm[ipcm++];
167  if (!pcm)
168  break;
169  }
170 
171  /* for each AV sequence */
172  for (j = 0; j < 9; j++) {
173  for (d = 8; d < 80; d += 2) {
174  if (quant == 0) { /* 16-bit quantization */
175  of = sys->audio_shuffle[i][j] +
176  (d - 8) / 2 * sys->audio_stride;
177  if (of * 2 >= size)
178  continue;
179 
180  /* FIXME: maybe we have to admit that DV is a
181  * big-endian PCM */
182  pcm[of * 2] = frame[d + 1];
183  pcm[of * 2 + 1] = frame[d];
184 
185  if (pcm[of * 2 + 1] == 0x80 && pcm[of * 2] == 0x00)
186  pcm[of * 2 + 1] = 0;
187  } else { /* 12-bit quantization */
188  lc = ((uint16_t)frame[d] << 4) |
189  ((uint16_t)frame[d + 2] >> 4);
190  rc = ((uint16_t)frame[d + 1] << 4) |
191  ((uint16_t)frame[d + 2] & 0x0f);
192  lc = (lc == 0x800 ? 0 : dv_audio_12to16(lc));
193  rc = (rc == 0x800 ? 0 : dv_audio_12to16(rc));
194 
195  of = sys->audio_shuffle[i % half_ch][j] +
196  (d - 8) / 3 * sys->audio_stride;
197  if (of * 2 >= size)
198  continue;
199 
200  /* FIXME: maybe we have to admit that DV is a
201  * big-endian PCM */
202  pcm[of * 2] = lc & 0xff;
203  pcm[of * 2 + 1] = lc >> 8;
204  of = sys->audio_shuffle[i % half_ch + half_ch][j] +
205  (d - 8) / 3 * sys->audio_stride;
206  /* FIXME: maybe we have to admit that DV is a
207  * big-endian PCM */
208  pcm[of * 2] = rc & 0xff;
209  pcm[of * 2 + 1] = rc >> 8;
210  ++d;
211  }
212  }
213 
214  frame += 16 * 80; /* 15 Video DIFs + 1 Audio DIF */
215  }
216  }
217  }
218 
219  return size;
220 }
221 
223 {
224  const uint8_t *as_pack;
225  int freq, stype, smpls, quant, i, ach;
226 
227  as_pack = dv_extract_pack(frame, dv_audio_source);
228  if (!as_pack || !c->sys) { /* No audio ? */
229  c->ach = 0;
230  return 0;
231  }
232 
233  smpls = as_pack[1] & 0x3f; /* samples in this frame - min. samples */
234  freq = as_pack[4] >> 3 & 0x07; /* 0 - 48kHz, 1 - 44,1kHz, 2 - 32kHz */
235  stype = as_pack[3] & 0x1f; /* 0 - 2CH, 2 - 4CH, 3 - 8CH */
236  quant = as_pack[4] & 0x07; /* 0 - 16-bit linear, 1 - 12-bit nonlinear */
237 
238  if (freq >= FF_ARRAY_ELEMS(dv_audio_frequency)) {
240  "Unrecognized audio sample rate index (%d)\n", freq);
241  return 0;
242  }
243 
244  if (stype > 3) {
245  av_log(c->fctx, AV_LOG_ERROR, "stype %d is invalid\n", stype);
246  c->ach = 0;
247  return 0;
248  }
249 
250  /* note: ach counts PAIRS of channels (i.e. stereo channels) */
251  ach = ((int[4]) { 1, 0, 2, 4 })[stype];
252  if (ach == 1 && quant && freq == 2)
253  ach = 2;
254 
255  /* Dynamic handling of the audio streams in DV */
256  for (i = 0; i < ach; i++) {
257  if (!c->ast[i]) {
258  c->ast[i] = avformat_new_stream(c->fctx, NULL);
259  if (!c->ast[i])
260  break;
261  avpriv_set_pts_info(c->ast[i], 64, 1, 30000);
264 
265  av_init_packet(&c->audio_pkt[i]);
266  c->audio_pkt[i].size = 0;
267  c->audio_pkt[i].data = c->audio_buf[i];
268  c->audio_pkt[i].stream_index = c->ast[i]->index;
270  }
272  c->ast[i]->codecpar->channels = 2;
274  c->ast[i]->codecpar->bit_rate = 2 * dv_audio_frequency[freq] * 16;
275  c->ast[i]->start_time = 0;
276  }
277  c->ach = i;
278 
279  return (c->sys->audio_min_samples[freq] + smpls) * 4; /* 2ch, 2bytes */
280 }
281 
283 {
284  const uint8_t *vsc_pack;
285  AVCodecParameters *par;
286  int apt, is16_9;
287 
288  par = c->vst->codecpar;
289 
291  c->sys->time_base.den);
293 
294  /* finding out SAR is a little bit messy */
295  vsc_pack = dv_extract_pack(frame, dv_video_control);
296  apt = frame[4] & 0x07;
297  is16_9 = (vsc_pack && ((vsc_pack[2] & 0x07) == 0x02 ||
298  (!apt && (vsc_pack[2] & 0x07) == 0x07)));
299  c->vst->sample_aspect_ratio = c->sys->sar[is16_9];
300  par->bit_rate = av_rescale_q(c->sys->frame_size,
301  (AVRational) { 8, 1 },
302  c->sys->time_base);
303  return c->sys->frame_size;
304 }
305 
306 static int dv_extract_timecode(DVDemuxContext* c, const uint8_t* frame, char *tc)
307 {
308  const uint8_t *tc_pack;
309 
310  // For PAL systems, drop frame bit is replaced by an arbitrary
311  // bit so its value should not be considered. Drop frame timecode
312  // is only relevant for NTSC systems.
313  int prevent_df = c->sys->ltc_divisor == 25 || c->sys->ltc_divisor == 50;
314 
315  tc_pack = dv_extract_pack(frame, dv_timecode);
316  if (!tc_pack)
317  return 0;
318  av_timecode_make_smpte_tc_string(tc, AV_RB32(tc_pack + 1), prevent_df);
319  return 1;
320 }
321 
322 /* The following 3 functions constitute our interface to the world */
323 
325 {
326  DVDemuxContext *c;
327 
328  c = av_mallocz(sizeof(DVDemuxContext));
329  if (!c)
330  return NULL;
331 
332  c->vst = avformat_new_stream(s, NULL);
333  if (!c->vst) {
334  av_free(c);
335  return NULL;
336  }
337 
338  c->fctx = s;
341  c->vst->codecpar->bit_rate = 25000000;
342  c->vst->start_time = 0;
343 
344  return c;
345 }
346 
348 {
349  int size = -1;
350  int i;
351 
352  for (i = 0; i < c->ach; i++) {
353  if (c->ast[i] && c->audio_pkt[i].size) {
354  *pkt = c->audio_pkt[i];
355  c->audio_pkt[i].size = 0;
356  size = pkt->size;
357  break;
358  }
359  }
360 
361  return size;
362 }
363 
365  uint8_t *buf, int buf_size, int64_t pos)
366 {
367  int size, i;
368  uint8_t *ppcm[5] = { 0 };
369 
370  if (buf_size < DV_PROFILE_BYTES ||
371  !(c->sys = av_dv_frame_profile(c->sys, buf, buf_size)) ||
372  buf_size < c->sys->frame_size) {
373  return -1; /* Broken frame, or not enough data */
374  }
375 
376  /* Queueing audio packet */
377  /* FIXME: in case of no audio/bad audio we have to do something */
378  size = dv_extract_audio_info(c, buf);
379  for (i = 0; i < c->ach; i++) {
380  c->audio_pkt[i].pos = pos;
381  c->audio_pkt[i].size = size;
382  c->audio_pkt[i].pts = c->abytes * 30000 * 8 /
383  c->ast[i]->codecpar->bit_rate;
384  ppcm[i] = c->audio_buf[i];
385  }
386  if (c->ach)
387  dv_extract_audio(buf, ppcm, c->sys);
388 
389  /* We work with 720p frames split in half, thus even frames have
390  * channels 0,1 and odd 2,3. */
391  if (c->sys->height == 720) {
392  if (buf[1] & 0x0C) {
393  c->audio_pkt[2].size = c->audio_pkt[3].size = 0;
394  } else {
395  c->audio_pkt[0].size = c->audio_pkt[1].size = 0;
396  c->abytes += size;
397  }
398  } else {
399  c->abytes += size;
400  }
401 
402  /* Now it's time to return video packet */
403  size = dv_extract_video_info(c, buf);
404  av_init_packet(pkt);
405  pkt->data = buf;
406  pkt->pos = pos;
407  pkt->size = size;
408  pkt->flags |= AV_PKT_FLAG_KEY;
409  pkt->stream_index = c->vst->index;
410  pkt->pts = c->frames;
411 
412  c->frames++;
413 
414  return size;
415 }
416 
418  int64_t timestamp, int flags)
419 {
420  // FIXME: sys may be wrong if last dv_read_packet() failed (buffer is junk)
421  const int frame_size = c->sys->frame_size;
422  int64_t offset;
423  int64_t size = avio_size(s->pb) - s->internal->data_offset;
424  int64_t max_offset = ((size - 1) / frame_size) * frame_size;
425 
426  offset = frame_size * timestamp;
427 
428  if (size >= 0 && offset > max_offset)
429  offset = max_offset;
430  else if (offset < 0)
431  offset = 0;
432 
433  return offset + s->internal->data_offset;
434 }
435 
436 void ff_dv_offset_reset(DVDemuxContext *c, int64_t frame_offset)
437 {
438  c->frames = frame_offset;
439  if (c->ach) {
440  if (c->sys) {
441  c->abytes = av_rescale_q(c->frames, c->sys->time_base,
442  (AVRational) { 8, c->ast[0]->codecpar->bit_rate });
443  } else
444  av_log(c->fctx, AV_LOG_ERROR, "cannot adjust audio bytes\n");
445  }
446  c->audio_pkt[0].size = c->audio_pkt[1].size = 0;
447  c->audio_pkt[2].size = c->audio_pkt[3].size = 0;
448 }
449 
450 /************************************************************
451  * Implementation of the easiest DV storage of all -- raw DV.
452  ************************************************************/
453 
454 typedef struct RawDVContext {
457 } RawDVContext;
458 
460  int ret;
461  char timecode[AV_TIMECODE_STR_SIZE];
462  int64_t pos = avio_tell(s->pb);
463 
464  // Read 3 DIF blocks: Header block and 2 Subcode blocks.
465  int partial_frame_size = 3 * 80;
466  uint8_t *partial_frame = av_mallocz(sizeof(*partial_frame) *
467  partial_frame_size);
468 
469  RawDVContext *c = s->priv_data;
470  if (!partial_frame)
471  return AVERROR(ENOMEM);
472 
473  ret = avio_read(s->pb, partial_frame, partial_frame_size);
474  if (ret < 0)
475  goto finish;
476 
477  if (ret < partial_frame_size) {
478  ret = -1;
479  goto finish;
480  }
481 
482  ret = dv_extract_timecode(c->dv_demux, partial_frame, timecode);
483  if (ret)
484  av_dict_set(&s->metadata, "timecode", timecode, 0);
485  else
486  av_log(s, AV_LOG_ERROR, "Detected timecode is invalid\n");
487 
488 finish:
489  av_free(partial_frame);
490  avio_seek(s->pb, pos, SEEK_SET);
491  return ret;
492 }
493 
495 {
496  unsigned state, marker_pos = 0;
497  RawDVContext *c = s->priv_data;
498 
500  if (!c->dv_demux)
501  return -1;
502 
503  state = avio_rb32(s->pb);
504  while ((state & 0xffffff7f) != 0x1f07003f) {
505  if (avio_feof(s->pb)) {
506  av_log(s, AV_LOG_ERROR, "Cannot find DV header.\n");
507  return -1;
508  }
509  if (state == 0x003f0700 || state == 0xff3f0700)
510  marker_pos = avio_tell(s->pb);
511  if (state == 0xff3f0701 && avio_tell(s->pb) - marker_pos == 80) {
512  avio_seek(s->pb, -163, SEEK_CUR);
513  state = avio_rb32(s->pb);
514  break;
515  }
516  state = (state << 8) | avio_r8(s->pb);
517  }
518  AV_WB32(c->buf, state);
519 
520  if (avio_read(s->pb, c->buf + 4, DV_PROFILE_BYTES - 4) != DV_PROFILE_BYTES - 4 ||
521  avio_seek(s->pb, -DV_PROFILE_BYTES, SEEK_CUR) < 0)
522  return AVERROR(EIO);
523 
525  c->buf,
527  if (!c->dv_demux->sys) {
528  av_log(s, AV_LOG_ERROR,
529  "Can't determine profile of DV input stream.\n");
530  return -1;
531  }
532 
534  (AVRational) { 8, 1 },
535  c->dv_demux->sys->time_base);
536 
537  if (s->pb->seekable & AVIO_SEEKABLE_NORMAL)
538  dv_read_timecode(s);
539 
540  return 0;
541 }
542 
544 {
545  int size;
546  RawDVContext *c = s->priv_data;
547 
548  size = avpriv_dv_get_packet(c->dv_demux, pkt);
549 
550  if (size < 0) {
551  int ret;
552  int64_t pos = avio_tell(s->pb);
553  if (!c->dv_demux->sys)
554  return AVERROR(EIO);
555  size = c->dv_demux->sys->frame_size;
556  ret = avio_read(s->pb, c->buf, size);
557  if (ret < 0) {
558  return ret;
559  } else if (ret == 0) {
560  return AVERROR(EIO);
561  }
562 
563  size = avpriv_dv_produce_packet(c->dv_demux, pkt, c->buf, size, pos);
564  }
565 
566  return size;
567 }
568 
569 static int dv_read_seek(AVFormatContext *s, int stream_index,
570  int64_t timestamp, int flags)
571 {
572  RawDVContext *r = s->priv_data;
573  DVDemuxContext *c = r->dv_demux;
574  int64_t offset = dv_frame_offset(s, c, timestamp, flags);
575 
576  if (avio_seek(s->pb, offset, SEEK_SET) < 0)
577  return -1;
578 
579  ff_dv_offset_reset(c, offset / c->sys->frame_size);
580  return 0;
581 }
582 
584 {
585  RawDVContext *c = s->priv_data;
586  av_freep(&c->dv_demux);
587  return 0;
588 }
589 
590 static int dv_probe(const AVProbeData *p)
591 {
592  unsigned marker_pos = 0;
593  int i;
594  int matches = 0;
595  int firstmatch = 0;
596  int secondary_matches = 0;
597 
598  if (p->buf_size < 5)
599  return 0;
600 
601  for (i = 0; i < p->buf_size-4; i++) {
602  unsigned state = AV_RB32(p->buf+i);
603  if ((state & 0x0007f840) == 0x00070000) {
604  // any section header, also with seq/chan num != 0,
605  // should appear around every 12000 bytes, at least 10 per frame
606  if ((state & 0xff07ff7f) == 0x1f07003f) {
607  secondary_matches++;
608  if ((state & 0xffffff7f) == 0x1f07003f) {
609  matches++;
610  if (!i)
611  firstmatch = 1;
612  }
613  }
614  if (state == 0x003f0700 || state == 0xff3f0700)
615  marker_pos = i;
616  if (state == 0xff3f0701 && i - marker_pos == 80)
617  matches++;
618  }
619  }
620 
621  if (matches && p->buf_size / matches < 1024 * 1024) {
622  if (matches > 4 || firstmatch ||
623  (secondary_matches >= 10 &&
624  p->buf_size / secondary_matches < 24000))
625  // not max to avoid dv in mov to match
626  return AVPROBE_SCORE_MAX * 3 / 4;
627  return AVPROBE_SCORE_MAX / 4;
628  }
629  return 0;
630 }
631 
633  .name = "dv",
634  .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
635  .priv_data_size = sizeof(RawDVContext),
636  .read_probe = dv_probe,
641  .extensions = "dv,dif",
642 };
#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:339
static int shift(int a, int b)
Definition: sonic.c:82
static int dv_read_timecode(AVFormatContext *s)
Definition: dv.c:459
static const int dv_audio_frequency[3]
Definition: dv.c:107
int64_t pos
byte position in stream, -1 if unknown
Definition: avcodec.h:1497
static int dv_read_header(AVFormatContext *s)
Definition: dv.c:494
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:4892
int64_t data_offset
offset of the first packet
Definition: internal.h:82
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: avcodec.h:3957
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:943
int num
Numerator.
Definition: rational.h:59
int index
stream index in AVFormatContext
Definition: avformat.h:882
int size
Definition: avcodec.h:1478
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:246
AVFormatInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1811
int64_t bit_rate
Total stream bitrate in bit/s, 0 if not available.
Definition: avformat.h:1480
#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:236
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: avcodec.h:3949
static struct @315 state
Format I/O context.
Definition: avformat.h:1358
static int dv_read_close(AVFormatContext *s)
Definition: dv.c:583
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:222
uint64_t abytes
Definition: dv.c:52
dv_pack_type
Definition: dv.h:67
uint8_t
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:803
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:4465
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:87
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:324
uint8_t * data
Definition: avcodec.h:1477
AVPacket audio_pkt[4]
Definition: dv.c:48
AVStream * ast[4]
Definition: dv.c:47
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:145
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:632
int frames
Definition: dv.c:51
AVRational time_base
Definition: dv_profile.h:45
uint64_t channel_layout
Audio only.
Definition: avcodec.h:4059
#define av_log(a,...)
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:650
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: avcodec.h:3986
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1509
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
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
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:176
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1598
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
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
int frame_size
Definition: dv_profile.h:42
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3953
static int dv_probe(const AVProbeData *p)
Definition: dv.c:590
simple assert() macros that are a bit more flexible than ISO C assert().
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:954
static int dv_extract_timecode(DVDemuxContext *c, const uint8_t *frame, char *tc)
Definition: dv.c:306
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1483
const AVDVProfile * sys
Definition: dv.c:44
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:641
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:449
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:448
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:436
static int dv_extract_audio(const uint8_t *frame, uint8_t **ppcm, const AVDVProfile *sys)
Definition: dv.c:119
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
DVDemuxContext * dv_demux
Definition: dv.c:455
#define FF_ARRAY_ELEMS(a)
static int dv_extract_video_info(DVDemuxContext *c, const uint8_t *frame)
Definition: dv.c:282
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:530
if(ret)
Stream structure.
Definition: avformat.h:881
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:75
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
int frame_size
Definition: mxfenc.c:2215
int avpriv_dv_produce_packet(DVDemuxContext *c, AVPacket *pkt, uint8_t *buf, int buf_size, int64_t pos)
Definition: dv.c:364
Definition: dv.h:70
Timecode helpers header.
AVIOContext * pb
I/O context.
Definition: avformat.h:1400
#define DV_MAX_FRAME_SIZE
largest possible DV frame, in bytes (1080i50)
Definition: dv.h:89
void * buf
Definition: avisynth_c.h:766
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:446
static int dv_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: dv.c:569
const uint8_t * quant
char * av_timecode_make_smpte_tc_string(char *buf, uint32_t tcsmpte, int prevent_df)
Get the timecode string from the SMPTE timecode format.
Definition: timecode.c:118
#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: avcodec.h:4067
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:458
Main libavformat public API header.
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base...
Definition: avformat.h:920
static uint16_t dv_audio_12to16(uint16_t sample)
Definition: dv.c:55
uint8_t buf[DV_MAX_FRAME_SIZE]
Definition: dv.c:456
Constants for DV codec.
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:33
int den
Denominator.
Definition: rational.h:60
int avpriv_dv_get_packet(DVDemuxContext *c, AVPacket *pkt)
Definition: dv.c:347
#define av_free(p)
void * priv_data
Format private data.
Definition: avformat.h:1386
static int64_t dv_frame_offset(AVFormatContext *s, DVDemuxContext *c, int64_t timestamp, int flags)
Definition: dv.c:417
AVStream * vst
Definition: dv.c:46
int channels
Audio only.
Definition: avcodec.h:4063
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:543
#define av_freep(p)
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:654
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1028
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:361
int n_difchan
Definition: dv_profile.h:44
int stream_index
Definition: avcodec.h:1479
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:910
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: avcodec.h:1454
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1470
#define AV_TIMECODE_STR_SIZE
Definition: timecode.h:33