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 
43 // Must be kept in sync with AVPacket
44 struct DVPacket {
45  int64_t pts;
46  uint8_t *data;
47  int size;
49  int flags;
50  int64_t pos;
51  int64_t duration;
52 };
53 
55  const AVDVProfile* sys; /* Current DV profile. E.g.: 525/60, 625/50 */
59  struct DVPacket audio_pkt[4];
60  uint8_t audio_buf[4][8192];
61  int ach;
62  int frames;
63 };
64 
65 static inline uint16_t dv_audio_12to16(uint16_t sample)
66 {
67  uint16_t shift, result;
68 
69  sample = (sample < 0x800) ? sample : sample | 0xf000;
70  shift = (sample & 0xf00) >> 8;
71 
72  if (shift < 0x2 || shift > 0xd) {
73  result = sample;
74  } else if (shift < 0x8) {
75  shift--;
76  result = (sample - (256 * shift)) << shift;
77  } else {
78  shift = 0xe - shift;
79  result = ((sample + ((256 * shift) + 1)) << shift) - 1;
80  }
81 
82  return result;
83 }
84 
85 static const uint8_t *dv_extract_pack(const uint8_t *frame, enum dv_pack_type t)
86 {
87  int offs;
88  int c;
89 
90  for (c = 0; c < 10; c++) {
91  switch (t) {
92  case dv_audio_source:
93  if (c&1) offs = (80 * 6 + 80 * 16 * 0 + 3 + c*12000);
94  else offs = (80 * 6 + 80 * 16 * 3 + 3 + c*12000);
95  break;
96  case dv_audio_control:
97  if (c&1) offs = (80 * 6 + 80 * 16 * 1 + 3 + c*12000);
98  else offs = (80 * 6 + 80 * 16 * 4 + 3 + c*12000);
99  break;
100  case dv_video_control:
101  if (c&1) offs = (80 * 3 + 8 + c*12000);
102  else offs = (80 * 5 + 48 + 5 + c*12000);
103  break;
104  case dv_timecode:
105  offs = (80*1 + 3 + 3);
106  break;
107  default:
108  return NULL;
109  }
110  if (frame[offs] == t)
111  break;
112  }
113 
114  return frame[offs] == t ? &frame[offs] : NULL;
115 }
116 
117 static const int dv_audio_frequency[3] = {
118  48000, 44100, 32000,
119 };
120 
121 /*
122  * There's a couple of assumptions being made here:
123  * 1. By default we silence erroneous (0x8000/16-bit 0x800/12-bit) audio samples.
124  * We can pass them upwards when libavcodec will be ready to deal with them.
125  * 2. We don't do software emphasis.
126  * 3. Audio is always returned as 16-bit linear samples: 12-bit nonlinear samples
127  * are converted into 16-bit linear ones.
128  */
129 static int dv_extract_audio(const uint8_t *frame, uint8_t **ppcm,
130  const AVDVProfile *sys)
131 {
132  int size, chan, i, j, d, of, smpls, freq, quant, half_ch;
133  uint16_t lc, rc;
134  const uint8_t *as_pack;
135  uint8_t *pcm, ipcm;
136 
138  if (!as_pack) /* No audio ? */
139  return 0;
140 
141  smpls = as_pack[1] & 0x3f; /* samples in this frame - min. samples */
142  freq = as_pack[4] >> 3 & 0x07; /* 0 - 48kHz, 1 - 44,1kHz, 2 - 32kHz */
143  quant = as_pack[4] & 0x07; /* 0 - 16-bit linear, 1 - 12-bit nonlinear */
144 
145  if (quant > 1)
146  return -1; /* unsupported quantization */
147 
148  if (freq >= FF_ARRAY_ELEMS(dv_audio_frequency))
149  return AVERROR_INVALIDDATA;
150 
151  size = (sys->audio_min_samples[freq] + smpls) * 4; /* 2ch, 2bytes */
152  half_ch = sys->difseg_size / 2;
153 
154  /* We work with 720p frames split in half, thus even frames have
155  * channels 0,1 and odd 2,3. */
156  ipcm = (sys->height == 720 && !(frame[1] & 0x0C)) ? 2 : 0;
157 
158  if (ipcm + sys->n_difchan > (quant == 1 ? 2 : 4)) {
159  av_log(NULL, AV_LOG_ERROR, "too many dv pcm frames\n");
160  return AVERROR_INVALIDDATA;
161  }
162 
163  /* for each DIF channel */
164  for (chan = 0; chan < sys->n_difchan; chan++) {
165  av_assert0(ipcm<4);
166  pcm = ppcm[ipcm++];
167  if (!pcm)
168  break;
169 
170  /* for each DIF segment */
171  for (i = 0; i < sys->difseg_size; i++) {
172  frame += 6 * 80; /* skip DIF segment header */
173  if (quant == 1 && i == half_ch) {
174  /* next stereo channel (12-bit mode only) */
175  av_assert0(ipcm<4);
176  pcm = ppcm[ipcm++];
177  if (!pcm)
178  break;
179  }
180 
181  /* for each AV sequence */
182  for (j = 0; j < 9; j++) {
183  for (d = 8; d < 80; d += 2) {
184  if (quant == 0) { /* 16-bit quantization */
185  of = sys->audio_shuffle[i][j] +
186  (d - 8) / 2 * sys->audio_stride;
187  if (of * 2 >= size)
188  continue;
189 
190  /* FIXME: maybe we have to admit that DV is a
191  * big-endian PCM */
192  pcm[of * 2] = frame[d + 1];
193  pcm[of * 2 + 1] = frame[d];
194 
195  if (pcm[of * 2 + 1] == 0x80 && pcm[of * 2] == 0x00)
196  pcm[of * 2 + 1] = 0;
197  } else { /* 12-bit quantization */
198  lc = ((uint16_t)frame[d] << 4) |
199  ((uint16_t)frame[d + 2] >> 4);
200  rc = ((uint16_t)frame[d + 1] << 4) |
201  ((uint16_t)frame[d + 2] & 0x0f);
202  lc = (lc == 0x800 ? 0 : dv_audio_12to16(lc));
203  rc = (rc == 0x800 ? 0 : dv_audio_12to16(rc));
204 
205  of = sys->audio_shuffle[i % half_ch][j] +
206  (d - 8) / 3 * sys->audio_stride;
207  if (of * 2 >= size)
208  continue;
209 
210  /* FIXME: maybe we have to admit that DV is a
211  * big-endian PCM */
212  pcm[of * 2] = lc & 0xff;
213  pcm[of * 2 + 1] = lc >> 8;
214  of = sys->audio_shuffle[i % half_ch + half_ch][j] +
215  (d - 8) / 3 * sys->audio_stride;
216  /* FIXME: maybe we have to admit that DV is a
217  * big-endian PCM */
218  pcm[of * 2] = rc & 0xff;
219  pcm[of * 2 + 1] = rc >> 8;
220  ++d;
221  }
222  }
223 
224  frame += 16 * 80; /* 15 Video DIFs + 1 Audio DIF */
225  }
226  }
227  }
228 
229  return size;
230 }
231 
232 static int dv_extract_audio_info(DVDemuxContext *c, const uint8_t *frame)
233 {
234  const uint8_t *as_pack;
235  int freq, stype, smpls, quant, i, ach;
236 
238  if (!as_pack || !c->sys) { /* No audio ? */
239  c->ach = 0;
240  return 0;
241  }
242 
243  smpls = as_pack[1] & 0x3f; /* samples in this frame - min. samples */
244  freq = as_pack[4] >> 3 & 0x07; /* 0 - 48kHz, 1 - 44,1kHz, 2 - 32kHz */
245  stype = as_pack[3] & 0x1f; /* 0 - 2CH, 2 - 4CH, 3 - 8CH */
246  quant = as_pack[4] & 0x07; /* 0 - 16-bit linear, 1 - 12-bit nonlinear */
247 
248  if (freq >= FF_ARRAY_ELEMS(dv_audio_frequency)) {
249  av_log(c->fctx, AV_LOG_ERROR,
250  "Unrecognized audio sample rate index (%d)\n", freq);
251  return 0;
252  }
253 
254  if (stype > 3) {
255  av_log(c->fctx, AV_LOG_ERROR, "stype %d is invalid\n", stype);
256  c->ach = 0;
257  return 0;
258  }
259 
260  /* note: ach counts PAIRS of channels (i.e. stereo channels) */
261  ach = ((int[4]) { 1, 0, 2, 4 })[stype];
262  if (ach == 1 && quant && freq == 2)
263  ach = 2;
264 
265  /* Dynamic handling of the audio streams in DV */
266  for (i = 0; i < ach; i++) {
267  if (!c->ast[i]) {
268  c->ast[i] = avformat_new_stream(c->fctx, NULL);
269  if (!c->ast[i])
270  break;
271  avpriv_set_pts_info(c->ast[i], 64, c->sys->time_base.num, c->sys->time_base.den);
272  c->ast[i]->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
273  c->ast[i]->codecpar->codec_id = AV_CODEC_ID_PCM_S16LE;
274 
275  c->audio_pkt[i].size = 0;
276  c->audio_pkt[i].data = c->audio_buf[i];
277  c->audio_pkt[i].stream_index = c->ast[i]->index;
278  c->audio_pkt[i].flags |= AV_PKT_FLAG_KEY;
279  c->audio_pkt[i].pts = AV_NOPTS_VALUE;
280  c->audio_pkt[i].duration = 0;
281  c->audio_pkt[i].pos = -1;
282  }
283  c->ast[i]->codecpar->sample_rate = dv_audio_frequency[freq];
284  c->ast[i]->codecpar->ch_layout = (AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO;
285  c->ast[i]->codecpar->bit_rate = 2 * dv_audio_frequency[freq] * 16;
286  c->ast[i]->start_time = 0;
287  }
288  c->ach = i;
289 
290  return (c->sys->audio_min_samples[freq] + smpls) * 4; /* 2ch, 2bytes */
291 }
292 
293 static int dv_extract_video_info(DVDemuxContext *c, const uint8_t *frame)
294 {
295  const uint8_t *vsc_pack;
296  AVCodecParameters *par;
297  int apt, is16_9;
298 
299  par = c->vst->codecpar;
300 
301  avpriv_set_pts_info(c->vst, 64, c->sys->time_base.num,
302  c->sys->time_base.den);
303  c->vst->avg_frame_rate = av_inv_q(c->vst->time_base);
304 
305  /* finding out SAR is a little bit messy */
307  apt = frame[4] & 0x07;
308  is16_9 = (vsc_pack && ((vsc_pack[2] & 0x07) == 0x02 ||
309  (!apt && (vsc_pack[2] & 0x07) == 0x07)));
310  c->vst->sample_aspect_ratio = c->sys->sar[is16_9];
311  par->bit_rate = av_rescale_q(c->sys->frame_size,
312  (AVRational) { 8, 1 },
313  c->sys->time_base);
314  return c->sys->frame_size;
315 }
316 
317 static int dv_extract_timecode(DVDemuxContext* c, const uint8_t* frame, char *tc)
318 {
319  const uint8_t *tc_pack;
320 
321  // For PAL systems, drop frame bit is replaced by an arbitrary
322  // bit so its value should not be considered. Drop frame timecode
323  // is only relevant for NTSC systems.
324  int prevent_df = c->sys->ltc_divisor == 25 || c->sys->ltc_divisor == 50;
325 
326  tc_pack = dv_extract_pack(frame, dv_timecode);
327  if (!tc_pack)
328  return 0;
329  av_timecode_make_smpte_tc_string2(tc, av_inv_q(c->sys->time_base), AV_RB32(tc_pack + 1), prevent_df, 1);
330  return 1;
331 }
332 
333 /* The following 3 functions constitute our interface to the world */
334 
336 {
337  c->vst = avformat_new_stream(s, NULL);
338  if (!c->vst)
339  return AVERROR(ENOMEM);
340 
341  c->fctx = s;
342  c->vst->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
343  c->vst->codecpar->codec_id = AV_CODEC_ID_DVVIDEO;
344  c->vst->codecpar->bit_rate = 25000000;
345  c->vst->start_time = 0;
346 
347  /* Audio streams are added later as they are encountered. */
348  s->ctx_flags |= AVFMTCTX_NOHEADER;
349 
350  return 0;
351 }
352 
354 {
355  DVDemuxContext *c;
356 
357  c = av_mallocz(sizeof(DVDemuxContext));
358  if (!c)
359  return NULL;
360 
361  if (dv_init_demux(s, c)) {
362  av_free(c);
363  return NULL;
364  }
365 
366  return c;
367 }
368 
370 {
371  int size = -1;
372  int i;
373 
374  for (i = 0; i < c->ach; i++) {
375  if (c->ast[i] && c->audio_pkt[i].size) {
376  pkt->size = c->audio_pkt[i].size;
377  pkt->data = c->audio_pkt[i].data;
378  pkt->stream_index = c->audio_pkt[i].stream_index;
379  pkt->flags = c->audio_pkt[i].flags;
380  pkt->pts = c->audio_pkt[i].pts;
381  pkt->duration = c->audio_pkt[i].duration;
382  pkt->pos = c->audio_pkt[i].pos;
383 
384  c->audio_pkt[i].size = 0;
385  size = pkt->size;
386  break;
387  }
388  }
389 
390  return size;
391 }
392 
394  uint8_t *buf, int buf_size, int64_t pos)
395 {
396  int size, i;
397  uint8_t *ppcm[5] = { 0 };
398 
399  if (buf_size < DV_PROFILE_BYTES ||
400  !(c->sys = av_dv_frame_profile(c->sys, buf, buf_size)) ||
401  buf_size < c->sys->frame_size) {
402  return -1; /* Broken frame, or not enough data */
403  }
404 
405  /* Queueing audio packet */
406  /* FIXME: in case of no audio/bad audio we have to do something */
408  for (i = 0; i < c->ach; i++) {
409  c->audio_pkt[i].pos = pos;
410  c->audio_pkt[i].size = size;
411  c->audio_pkt[i].pts = (c->sys->height == 720) ? (c->frames & ~1) : c->frames;
412  c->audio_pkt[i].duration = 1;
413  ppcm[i] = c->audio_buf[i];
414  }
415  if (c->ach)
416  dv_extract_audio(buf, ppcm, c->sys);
417 
418  /* We work with 720p frames split in half, thus even frames have
419  * channels 0,1 and odd 2,3. */
420  if (c->sys->height == 720) {
421  if (buf[1] & 0x0C) {
422  c->audio_pkt[2].size = c->audio_pkt[3].size = 0;
423  } else {
424  c->audio_pkt[0].size = c->audio_pkt[1].size = 0;
425  }
426  }
427 
428  /* Now it's time to return video packet */
430  pkt->data = buf;
431  pkt->pos = pos;
432  pkt->size = size;
434  pkt->stream_index = c->vst->index;
435  pkt->pts = c->frames;
436 
437  c->frames++;
438 
439  return size;
440 }
441 
443  int64_t timestamp, int flags)
444 {
445  // FIXME: sys may be wrong if last dv_read_packet() failed (buffer is junk)
446  FFFormatContext *const si = ffformatcontext(s);
447  const int frame_size = c->sys->frame_size;
448  int64_t offset;
449  int64_t size = avio_size(s->pb) - si->data_offset;
450  int64_t max_offset = ((size - 1) / frame_size) * frame_size;
451 
452  offset = frame_size * timestamp;
453 
454  if (size >= 0 && offset > max_offset)
455  offset = max_offset;
456  else if (offset < 0)
457  offset = 0;
458 
459  return offset + si->data_offset;
460 }
461 
463 {
464  c->frames = frame_offset;
465  c->audio_pkt[0].size = c->audio_pkt[1].size = 0;
466  c->audio_pkt[2].size = c->audio_pkt[3].size = 0;
467 }
468 
469 /************************************************************
470  * Implementation of the easiest DV storage of all -- raw DV.
471  ************************************************************/
472 
473 typedef struct RawDVContext {
475  uint8_t buf[DV_MAX_FRAME_SIZE];
477 
479  int ret;
480  char timecode[AV_TIMECODE_STR_SIZE];
481  int64_t pos = avio_tell(s->pb);
482 
483  // Read 3 DIF blocks: Header block and 2 Subcode blocks.
484 #define PARTIAL_FRAME_SIZE (3 * 80)
485  uint8_t partial_frame[PARTIAL_FRAME_SIZE];
486  RawDVContext *c = s->priv_data;
487 
488  ret = avio_read(s->pb, partial_frame, PARTIAL_FRAME_SIZE);
489  if (ret < 0)
490  goto finish;
491 
492  if (ret < PARTIAL_FRAME_SIZE) {
493  ret = -1;
494  goto finish;
495  }
496 
497  ret = dv_extract_timecode(&c->dv_demux, partial_frame, timecode);
498  if (ret)
499  av_dict_set(&s->metadata, "timecode", timecode, 0);
500  else
501  av_log(s, AV_LOG_ERROR, "Detected timecode is invalid\n");
502 
503 finish:
504  avio_seek(s->pb, pos, SEEK_SET);
505  return ret;
506 }
507 
509 {
510  unsigned state, marker_pos = 0;
511  RawDVContext *c = s->priv_data;
512  int ret;
513 
514  if ((ret = dv_init_demux(s, &c->dv_demux)) < 0)
515  return ret;
516 
517  state = avio_rb32(s->pb);
518  while ((state & 0xffffff7f) != 0x1f07003f) {
519  if (avio_feof(s->pb)) {
520  av_log(s, AV_LOG_ERROR, "Cannot find DV header.\n");
521  return AVERROR_INVALIDDATA;
522  }
523  if (state == 0x003f0700 || state == 0xff3f0700)
524  marker_pos = avio_tell(s->pb);
525  if (state == 0xff3f0701 && avio_tell(s->pb) - marker_pos == 80) {
526  avio_seek(s->pb, -163, SEEK_CUR);
527  state = avio_rb32(s->pb);
528  break;
529  }
530  state = (state << 8) | avio_r8(s->pb);
531  }
532  AV_WB32(c->buf, state);
533 
534  if (avio_read(s->pb, c->buf + 4, DV_PROFILE_BYTES - 4) != DV_PROFILE_BYTES - 4 ||
535  avio_seek(s->pb, -DV_PROFILE_BYTES, SEEK_CUR) < 0) {
536  return AVERROR(EIO);
537  }
538 
539  c->dv_demux.sys = av_dv_frame_profile(c->dv_demux.sys,
540  c->buf,
542  if (!c->dv_demux.sys) {
544  "Can't determine profile of DV input stream.\n");
545  return AVERROR_INVALIDDATA;
546  }
547 
548  s->bit_rate = av_rescale_q(c->dv_demux.sys->frame_size,
549  (AVRational) { 8, 1 },
550  c->dv_demux.sys->time_base);
551 
552  if (s->pb->seekable & AVIO_SEEKABLE_NORMAL)
554 
555  return 0;
556 }
557 
559 {
560  int size;
561  RawDVContext *c = s->priv_data;
562 
563  size = avpriv_dv_get_packet(&c->dv_demux, pkt);
564 
565  if (size < 0) {
566  int ret;
567  int64_t pos = avio_tell(s->pb);
568  if (!c->dv_demux.sys)
569  return AVERROR(EIO);
570  size = c->dv_demux.sys->frame_size;
571  ret = avio_read(s->pb, c->buf, size);
572  if (ret < 0) {
573  return ret;
574  } else if (ret == 0) {
575  return AVERROR(EIO);
576  }
577 
578  size = avpriv_dv_produce_packet(&c->dv_demux, pkt, c->buf, size, pos);
579  }
580 
581  return size;
582 }
583 
584 static int dv_read_seek(AVFormatContext *s, int stream_index,
585  int64_t timestamp, int flags)
586 {
587  RawDVContext *r = s->priv_data;
588  DVDemuxContext *c = &r->dv_demux;
589  int64_t offset = dv_frame_offset(s, c, timestamp, flags);
590 
591  if (avio_seek(s->pb, offset, SEEK_SET) < 0)
592  return -1;
593 
594  ff_dv_offset_reset(c, offset / c->sys->frame_size);
595  return 0;
596 }
597 
598 static int dv_probe(const AVProbeData *p)
599 {
600  unsigned marker_pos = 0;
601  int i;
602  int matches = 0;
603  int firstmatch = 0;
604  int secondary_matches = 0;
605 
606  if (p->buf_size < 5)
607  return 0;
608 
609  for (i = 0; i < p->buf_size-4; i++) {
610  unsigned state = AV_RB32(p->buf+i);
611  if ((state & 0x0007f840) == 0x00070000) {
612  // any section header, also with seq/chan num != 0,
613  // should appear around every 12000 bytes, at least 10 per frame
614  if ((state & 0xff07ff7f) == 0x1f07003f) {
615  secondary_matches++;
616  if ((state & 0xffffff7f) == 0x1f07003f) {
617  matches++;
618  if (!i)
619  firstmatch = 1;
620  }
621  }
622  if (state == 0x003f0700 || state == 0xff3f0700)
623  marker_pos = i;
624  if (state == 0xff3f0701 && i - marker_pos == 80)
625  matches++;
626  }
627  }
628 
629  if (matches && p->buf_size / matches < 1024 * 1024) {
630  if (matches > 4 || firstmatch ||
631  (secondary_matches >= 10 &&
632  p->buf_size / secondary_matches < 24000))
633  // not max to avoid dv in mov to match
634  return AVPROBE_SCORE_MAX * 3 / 4;
635  return AVPROBE_SCORE_MAX / 4;
636  }
637  return 0;
638 }
639 
641  .name = "dv",
642  .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
643  .priv_data_size = sizeof(RawDVContext),
644  .read_probe = dv_probe,
648  .extensions = "dv,dif",
649 };
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:318
dv_probe
static int dv_probe(const AVProbeData *p)
Definition: dv.c:598
AV_TIMECODE_STR_SIZE
#define AV_TIMECODE_STR_SIZE
Definition: timecode.h:33
dv_extract_timecode
static int dv_extract_timecode(DVDemuxContext *c, const uint8_t *frame, char *tc)
Definition: dv.c:317
r
const char * r
Definition: vf_curves.c:116
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
DVPacket::pos
int64_t pos
Definition: dv.c:50
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: options.c:237
DVPacket::pts
int64_t pts
Definition: dv.c:45
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:53
ffformatcontext
static av_always_inline FFFormatContext * ffformatcontext(AVFormatContext *s)
Definition: internal.h:192
DVPacket
For DV, one packet corresponds exactly to one frame.
Definition: iec61883.c:54
AVPacket::data
uint8_t * data
Definition: packet.h:374
DVPacket::data
uint8_t * data
Definition: dv.c:46
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:392
AV_CHANNEL_LAYOUT_STEREO
#define AV_CHANNEL_LAYOUT_STEREO
Definition: channel_layout.h:354
mathematics.h
AVProbeData::buf_size
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:456
dv_audio_source
@ dv_audio_source
Definition: dv.h:73
DV_PROFILE_BYTES
#define DV_PROFILE_BYTES
Definition: dv_profile.h:29
dv_read_timecode
static int dv_read_timecode(AVFormatContext *s)
Definition: dv.c:478
avio_size
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:352
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:429
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:465
AVDVProfile::difseg_size
int difseg_size
Definition: dv_profile.h:42
avpriv_dv_produce_packet
int avpriv_dv_produce_packet(DVDemuxContext *c, AVPacket *pkt, uint8_t *buf, int buf_size, int64_t pos)
Definition: dv.c:393
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: avformat.c:697
finish
static void finish(void)
Definition: movenc.c:342
DVDemuxContext::sys
const AVDVProfile * sys
Definition: dv.c:55
frame_offset
static void frame_offset(AVFrame *frame, int dir, int is_pal)
Definition: vf_scale.c:627
read_seek
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:151
timecode.h
PARTIAL_FRAME_SIZE
#define PARTIAL_FRAME_SIZE
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:505
dv_profile.h
quant
static int quant(float coef, const float Q, const float rounding)
Quantize one coefficient.
Definition: aacenc_utils.h:59
dv_frame_offset
static int64_t dv_frame_offset(AVFormatContext *s, DVDemuxContext *c, int64_t timestamp, int flags)
Definition: dv.c:442
dv_read_header
static int dv_read_header(AVFormatContext *s)
Definition: dv.c:508
avassert.h
DVDemuxContext::vst
AVStream * vst
Definition: dv.c:57
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:790
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AVInputFormat
Definition: avformat.h:656
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
dv_pack_type
dv_pack_type
Definition: dv.h:69
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:256
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:661
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:455
frame_size
int frame_size
Definition: mxfenc.c:2201
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
FFFormatContext::data_offset
int64_t data_offset
offset of the first packet
Definition: internal.h:109
av_rescale_q
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
dv_audio_control
@ dv_audio_control
Definition: dv.h:74
dv_read_packet
static int dv_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: dv.c:558
if
if(ret)
Definition: filter_design.txt:179
FFFormatContext
Definition: internal.h:72
AVFormatContext
Format I/O context.
Definition: avformat.h:1213
internal.h
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:529
avpriv_dv_get_packet
int avpriv_dv_get_packet(DVDemuxContext *c, AVPacket *pkt)
Definition: dv.c:369
result
and forward the result(frame or status change) to the corresponding input. If nothing is possible
NULL
#define NULL
Definition: coverity.c:32
read_probe
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
AVFMTCTX_NOHEADER
#define AVFMTCTX_NOHEADER
signal that no header is present (streams are added dynamically)
Definition: avformat.h:1164
AVDVProfile::n_difchan
int n_difchan
Definition: dv_profile.h:43
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:453
time.h
dv_audio_12to16
static uint16_t dv_audio_12to16(uint16_t sample)
Definition: dv.c:65
c
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
AV_WB32
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
dv.h
ff_dv_offset_reset
void ff_dv_offset_reset(DVDemuxContext *c, int64_t frame_offset)
Definition: dv.c:462
dv_extract_video_info
static int dv_extract_video_info(DVDemuxContext *c, const uint8_t *frame)
Definition: dv.c:293
DVDemuxContext::frames
int frames
Definition: dv.c:62
AVDVProfile::audio_stride
int audio_stride
Definition: dv_profile.h:52
AVPacket::size
int size
Definition: packet.h:375
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:290
dv_extract_pack
static const uint8_t * dv_extract_pack(const uint8_t *frame, enum dv_pack_type t)
Definition: dv.c:85
sample
#define sample
Definition: flacdsp_template.c:44
av_dv_frame_profile
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:299
size
int size
Definition: twinvq_data.h:10344
state
static struct @327 state
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
AV_RB32
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:96
DVDemuxContext::audio_buf
uint8_t audio_buf[4][8192]
Definition: dv.c:60
AVDVProfile::height
int height
Definition: dv_profile.h:46
DV_MAX_FRAME_SIZE
#define DV_MAX_FRAME_SIZE
largest possible DV frame, in bytes (1080i50)
Definition: dv.h:92
DVDemuxContext::ach
int ach
Definition: dv.c:61
DVDemuxContext
Definition: dv.c:54
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:632
offset
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
Definition: writing_filters.txt:86
RawDVContext
Definition: dv.c:473
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:380
dv_audio_frequency
static const int dv_audio_frequency[3]
Definition: dv.c:117
DVPacket::size
int size
Definition: dv.c:47
DVPacket::stream_index
int stream_index
Definition: dv.c:48
DVDemuxContext::audio_pkt
struct DVPacket audio_pkt[4]
Definition: dv.c:59
ff_dv_demuxer
const AVInputFormat ff_dv_demuxer
Definition: dv.c:640
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:367
av_timecode_make_smpte_tc_string2
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:138
AV_CODEC_ID_DVVIDEO
@ AV_CODEC_ID_DVVIDEO
Definition: codec_id.h:74
dv_video_control
@ dv_video_control
Definition: dv.h:78
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:264
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
dv_timecode
@ dv_timecode
Definition: dv.h:72
ret
ret
Definition: filter_design.txt:187
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
AVStream
Stream structure.
Definition: avformat.h:948
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:260
frame
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
Definition: filter_design.txt:264
DVPacket::flags
int flags
Definition: dv.c:49
DVPacket::buf
uint8_t * buf
actual buffer data
Definition: iec61883.c:55
pos
unsigned int pos
Definition: spdifenc.c:412
avformat.h
dv_init_demux
static int dv_init_demux(AVFormatContext *s, DVDemuxContext *c)
Definition: dv.c:335
dv_read_seek
static int dv_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: dv.c:584
avpriv_dv_init_demux
DVDemuxContext * avpriv_dv_init_demux(AVFormatContext *s)
Definition: dv.c:353
AVDVProfile::audio_min_samples
int audio_min_samples[3]
Definition: dv_profile.h:53
channel_layout.h
DVDemuxContext::fctx
AVFormatContext * fctx
Definition: dv.c:56
AVIO_SEEKABLE_NORMAL
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:41
dv_extract_audio_info
static int dv_extract_audio_info(DVDemuxContext *c, const uint8_t *frame)
Definition: dv.c:232
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:641
RawDVContext::dv_demux
DVDemuxContext dv_demux
Definition: dv.c:476
AVDVProfile
Definition: dv_profile.h:38
AVPacket::stream_index
int stream_index
Definition: packet.h:376
dv_extract_audio
static int dv_extract_audio(const uint8_t *frame, uint8_t **ppcm, const AVDVProfile *sys)
Definition: dv.c:129
shift
static int shift(int a, int b)
Definition: sonic.c:88
tc
#define tc
Definition: regdef.h:69
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVDVProfile::audio_shuffle
const uint8_t(* audio_shuffle)[9]
Definition: dv_profile.h:57
DVPacket::duration
int64_t duration
Definition: dv.c:51
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
DVDemuxContext::ast
AVStream * ast[4]
Definition: dv.c:58
AVPacket
This structure stores compressed data.
Definition: packet.h:351
av_dict_set
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
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:394
d
d
Definition: ffmpeg_filter.c:153
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:90
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
RawDVContext::buf
uint8_t buf[DV_MAX_FRAME_SIZE]
Definition: dv.c:477
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:375