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