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->channels = 2;
285  c->ast[i]->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
286  c->ast[i]->codecpar->bit_rate = 2 * dv_audio_frequency[freq] * 16;
287  c->ast[i]->start_time = 0;
288  }
289  c->ach = i;
290 
291  return (c->sys->audio_min_samples[freq] + smpls) * 4; /* 2ch, 2bytes */
292 }
293 
294 static int dv_extract_video_info(DVDemuxContext *c, const uint8_t *frame)
295 {
296  const uint8_t *vsc_pack;
297  AVCodecParameters *par;
298  int apt, is16_9;
299 
300  par = c->vst->codecpar;
301 
302  avpriv_set_pts_info(c->vst, 64, c->sys->time_base.num,
303  c->sys->time_base.den);
304  c->vst->avg_frame_rate = av_inv_q(c->vst->time_base);
305 
306  /* finding out SAR is a little bit messy */
308  apt = frame[4] & 0x07;
309  is16_9 = (vsc_pack && ((vsc_pack[2] & 0x07) == 0x02 ||
310  (!apt && (vsc_pack[2] & 0x07) == 0x07)));
311  c->vst->sample_aspect_ratio = c->sys->sar[is16_9];
312  par->bit_rate = av_rescale_q(c->sys->frame_size,
313  (AVRational) { 8, 1 },
314  c->sys->time_base);
315  return c->sys->frame_size;
316 }
317 
318 static int dv_extract_timecode(DVDemuxContext* c, const uint8_t* frame, char *tc)
319 {
320  const uint8_t *tc_pack;
321 
322  // For PAL systems, drop frame bit is replaced by an arbitrary
323  // bit so its value should not be considered. Drop frame timecode
324  // is only relevant for NTSC systems.
325  int prevent_df = c->sys->ltc_divisor == 25 || c->sys->ltc_divisor == 50;
326 
327  tc_pack = dv_extract_pack(frame, dv_timecode);
328  if (!tc_pack)
329  return 0;
330  av_timecode_make_smpte_tc_string2(tc, av_inv_q(c->sys->time_base), AV_RB32(tc_pack + 1), prevent_df, 1);
331  return 1;
332 }
333 
334 /* The following 3 functions constitute our interface to the world */
335 
337 {
338  c->vst = avformat_new_stream(s, NULL);
339  if (!c->vst)
340  return AVERROR(ENOMEM);
341 
342  c->fctx = s;
343  c->vst->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
344  c->vst->codecpar->codec_id = AV_CODEC_ID_DVVIDEO;
345  c->vst->codecpar->bit_rate = 25000000;
346  c->vst->start_time = 0;
347 
348  /* Audio streams are added later as they are encountered. */
349  s->ctx_flags |= AVFMTCTX_NOHEADER;
350 
351  return 0;
352 }
353 
355 {
356  DVDemuxContext *c;
357 
358  c = av_mallocz(sizeof(DVDemuxContext));
359  if (!c)
360  return NULL;
361 
362  if (dv_init_demux(s, c)) {
363  av_free(c);
364  return NULL;
365  }
366 
367  return c;
368 }
369 
371 {
372  int size = -1;
373  int i;
374 
375  for (i = 0; i < c->ach; i++) {
376  if (c->ast[i] && c->audio_pkt[i].size) {
377  pkt->size = c->audio_pkt[i].size;
378  pkt->data = c->audio_pkt[i].data;
379  pkt->stream_index = c->audio_pkt[i].stream_index;
380  pkt->flags = c->audio_pkt[i].flags;
381  pkt->pts = c->audio_pkt[i].pts;
382  pkt->duration = c->audio_pkt[i].duration;
383  pkt->pos = c->audio_pkt[i].pos;
384 
385  c->audio_pkt[i].size = 0;
386  size = pkt->size;
387  break;
388  }
389  }
390 
391  return size;
392 }
393 
395  uint8_t *buf, int buf_size, int64_t pos)
396 {
397  int size, i;
398  uint8_t *ppcm[5] = { 0 };
399 
400  if (buf_size < DV_PROFILE_BYTES ||
401  !(c->sys = av_dv_frame_profile(c->sys, buf, buf_size)) ||
402  buf_size < c->sys->frame_size) {
403  return -1; /* Broken frame, or not enough data */
404  }
405 
406  /* Queueing audio packet */
407  /* FIXME: in case of no audio/bad audio we have to do something */
409  for (i = 0; i < c->ach; i++) {
410  c->audio_pkt[i].pos = pos;
411  c->audio_pkt[i].size = size;
412  c->audio_pkt[i].pts = (c->sys->height == 720) ? (c->frames & ~1) : c->frames;
413  c->audio_pkt[i].duration = 1;
414  ppcm[i] = c->audio_buf[i];
415  }
416  if (c->ach)
417  dv_extract_audio(buf, ppcm, c->sys);
418 
419  /* We work with 720p frames split in half, thus even frames have
420  * channels 0,1 and odd 2,3. */
421  if (c->sys->height == 720) {
422  if (buf[1] & 0x0C) {
423  c->audio_pkt[2].size = c->audio_pkt[3].size = 0;
424  } else {
425  c->audio_pkt[0].size = c->audio_pkt[1].size = 0;
426  }
427  }
428 
429  /* Now it's time to return video packet */
431  pkt->data = buf;
432  pkt->pos = pos;
433  pkt->size = size;
435  pkt->stream_index = c->vst->index;
436  pkt->pts = c->frames;
437 
438  c->frames++;
439 
440  return size;
441 }
442 
444  int64_t timestamp, int flags)
445 {
446  // FIXME: sys may be wrong if last dv_read_packet() failed (buffer is junk)
447  FFFormatContext *const si = ffformatcontext(s);
448  const int frame_size = c->sys->frame_size;
449  int64_t offset;
450  int64_t size = avio_size(s->pb) - si->data_offset;
451  int64_t max_offset = ((size - 1) / frame_size) * frame_size;
452 
453  offset = frame_size * timestamp;
454 
455  if (size >= 0 && offset > max_offset)
456  offset = max_offset;
457  else if (offset < 0)
458  offset = 0;
459 
460  return offset + si->data_offset;
461 }
462 
464 {
465  c->frames = frame_offset;
466  c->audio_pkt[0].size = c->audio_pkt[1].size = 0;
467  c->audio_pkt[2].size = c->audio_pkt[3].size = 0;
468 }
469 
470 /************************************************************
471  * Implementation of the easiest DV storage of all -- raw DV.
472  ************************************************************/
473 
474 typedef struct RawDVContext {
476  uint8_t buf[DV_MAX_FRAME_SIZE];
478 
480  int ret;
481  char timecode[AV_TIMECODE_STR_SIZE];
482  int64_t pos = avio_tell(s->pb);
483 
484  // Read 3 DIF blocks: Header block and 2 Subcode blocks.
485 #define PARTIAL_FRAME_SIZE (3 * 80)
486  uint8_t partial_frame[PARTIAL_FRAME_SIZE];
487  RawDVContext *c = s->priv_data;
488 
489  ret = avio_read(s->pb, partial_frame, PARTIAL_FRAME_SIZE);
490  if (ret < 0)
491  goto finish;
492 
493  if (ret < PARTIAL_FRAME_SIZE) {
494  ret = -1;
495  goto finish;
496  }
497 
498  ret = dv_extract_timecode(&c->dv_demux, partial_frame, timecode);
499  if (ret)
500  av_dict_set(&s->metadata, "timecode", timecode, 0);
501  else
502  av_log(s, AV_LOG_ERROR, "Detected timecode is invalid\n");
503 
504 finish:
505  avio_seek(s->pb, pos, SEEK_SET);
506  return ret;
507 }
508 
510 {
511  unsigned state, marker_pos = 0;
512  RawDVContext *c = s->priv_data;
513  int ret;
514 
515  if ((ret = dv_init_demux(s, &c->dv_demux)) < 0)
516  return ret;
517 
518  state = avio_rb32(s->pb);
519  while ((state & 0xffffff7f) != 0x1f07003f) {
520  if (avio_feof(s->pb)) {
521  av_log(s, AV_LOG_ERROR, "Cannot find DV header.\n");
522  return AVERROR_INVALIDDATA;
523  }
524  if (state == 0x003f0700 || state == 0xff3f0700)
525  marker_pos = avio_tell(s->pb);
526  if (state == 0xff3f0701 && avio_tell(s->pb) - marker_pos == 80) {
527  avio_seek(s->pb, -163, SEEK_CUR);
528  state = avio_rb32(s->pb);
529  break;
530  }
531  state = (state << 8) | avio_r8(s->pb);
532  }
533  AV_WB32(c->buf, state);
534 
535  if (avio_read(s->pb, c->buf + 4, DV_PROFILE_BYTES - 4) != DV_PROFILE_BYTES - 4 ||
536  avio_seek(s->pb, -DV_PROFILE_BYTES, SEEK_CUR) < 0) {
537  return AVERROR(EIO);
538  }
539 
540  c->dv_demux.sys = av_dv_frame_profile(c->dv_demux.sys,
541  c->buf,
543  if (!c->dv_demux.sys) {
545  "Can't determine profile of DV input stream.\n");
546  return AVERROR_INVALIDDATA;
547  }
548 
549  s->bit_rate = av_rescale_q(c->dv_demux.sys->frame_size,
550  (AVRational) { 8, 1 },
551  c->dv_demux.sys->time_base);
552 
553  if (s->pb->seekable & AVIO_SEEKABLE_NORMAL)
555 
556  return 0;
557 }
558 
560 {
561  int size;
562  RawDVContext *c = s->priv_data;
563 
564  size = avpriv_dv_get_packet(&c->dv_demux, pkt);
565 
566  if (size < 0) {
567  int ret;
568  int64_t pos = avio_tell(s->pb);
569  if (!c->dv_demux.sys)
570  return AVERROR(EIO);
571  size = c->dv_demux.sys->frame_size;
572  ret = avio_read(s->pb, c->buf, size);
573  if (ret < 0) {
574  return ret;
575  } else if (ret == 0) {
576  return AVERROR(EIO);
577  }
578 
579  size = avpriv_dv_produce_packet(&c->dv_demux, pkt, c->buf, size, pos);
580  }
581 
582  return size;
583 }
584 
585 static int dv_read_seek(AVFormatContext *s, int stream_index,
586  int64_t timestamp, int flags)
587 {
588  RawDVContext *r = s->priv_data;
589  DVDemuxContext *c = &r->dv_demux;
590  int64_t offset = dv_frame_offset(s, c, timestamp, flags);
591 
592  if (avio_seek(s->pb, offset, SEEK_SET) < 0)
593  return -1;
594 
595  ff_dv_offset_reset(c, offset / c->sys->frame_size);
596  return 0;
597 }
598 
599 static int dv_probe(const AVProbeData *p)
600 {
601  unsigned marker_pos = 0;
602  int i;
603  int matches = 0;
604  int firstmatch = 0;
605  int secondary_matches = 0;
606 
607  if (p->buf_size < 5)
608  return 0;
609 
610  for (i = 0; i < p->buf_size-4; i++) {
611  unsigned state = AV_RB32(p->buf+i);
612  if ((state & 0x0007f840) == 0x00070000) {
613  // any section header, also with seq/chan num != 0,
614  // should appear around every 12000 bytes, at least 10 per frame
615  if ((state & 0xff07ff7f) == 0x1f07003f) {
616  secondary_matches++;
617  if ((state & 0xffffff7f) == 0x1f07003f) {
618  matches++;
619  if (!i)
620  firstmatch = 1;
621  }
622  }
623  if (state == 0x003f0700 || state == 0xff3f0700)
624  marker_pos = i;
625  if (state == 0xff3f0701 && i - marker_pos == 80)
626  matches++;
627  }
628  }
629 
630  if (matches && p->buf_size / matches < 1024 * 1024) {
631  if (matches > 4 || firstmatch ||
632  (secondary_matches >= 10 &&
633  p->buf_size / secondary_matches < 24000))
634  // not max to avoid dv in mov to match
635  return AVPROBE_SCORE_MAX * 3 / 4;
636  return AVPROBE_SCORE_MAX / 4;
637  }
638  return 0;
639 }
640 
642  .name = "dv",
643  .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
644  .priv_data_size = sizeof(RawDVContext),
645  .read_probe = dv_probe,
649  .extensions = "dv,dif",
650 };
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:314
dv_probe
static int dv_probe(const AVProbeData *p)
Definition: dv.c:599
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:318
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: utils.c:724
DVPacket::pts
int64_t pts
Definition: dv.c:45
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
ffformatcontext
static av_always_inline FFFormatContext * ffformatcontext(AVFormatContext *s)
Definition: internal.h:186
DVPacket
For DV, one packet corresponds exactly to one frame.
Definition: iec61883.c:52
AVPacket::data
uint8_t * data
Definition: packet.h:373
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:391
mathematics.h
AVProbeData::buf_size
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:449
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:479
avio_size
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:338
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:425
state
static struct @319 state
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:458
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:394
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:621
read_seek
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:149
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:486
dv_profile.h
AV_CH_LAYOUT_STEREO
#define AV_CH_LAYOUT_STEREO
Definition: channel_layout.h:91
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:443
dv_read_header
static int dv_read_header(AVFormatContext *s)
Definition: dv.c:509
avassert.h
DVDemuxContext::vst
AVStream * vst
Definition: dv.c:57
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:773
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:638
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:257
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:643
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:448
frame_size
int frame_size
Definition: mxfenc.c:2205
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:93
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:141
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:559
if
if(ret)
Definition: filter_design.txt:179
FFFormatContext
Definition: internal.h:72
AVFormatContext
Format I/O context.
Definition: avformat.h:1109
internal.h
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:527
avpriv_dv_get_packet
int avpriv_dv_get_packet(DVDemuxContext *c, AVPacket *pkt)
Definition: dv.c:370
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:1060
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:446
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:463
dv_extract_video_info
static int dv_extract_video_info(DVDemuxContext *c, const uint8_t *frame)
Definition: dv.c:294
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:374
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
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:298
size
int size
Definition: twinvq_data.h:10344
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:616
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:474
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:379
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:641
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:366
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:136
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:263
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:857
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:246
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:53
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:336
dv_read_seek
static int dv_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: dv.c:585
avpriv_dv_init_demux
DVDemuxContext * avpriv_dv_init_demux(AVFormatContext *s)
Definition: dv.c:354
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:40
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:625
RawDVContext::dv_demux
DVDemuxContext dv_demux
Definition: dv.c:477
AVDVProfile
Definition: dv_profile.h:38
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: utils.c:1146
AVPacket::stream_index
int stream_index
Definition: packet.h:375
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:83
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:34
DVDemuxContext::ast
AVStream * ast[4]
Definition: dv.c:58
AVPacket
This structure stores compressed data.
Definition: packet.h:350
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:393
d
d
Definition: ffmpeg_filter.c:156
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:89
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
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:478
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:360