2005-12-17 18:14:38 +00:00
|
|
|
/*
|
2014-06-11 12:48:30 +00:00
|
|
|
* General DV demuxer
|
2006-02-08 11:43:47 +00:00
|
|
|
* Copyright (c) 2003 Roman Shaposhnik
|
2003-09-29 17:54:07 +00:00
|
|
|
*
|
|
|
|
* Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
|
|
|
|
* of DV technical info.
|
|
|
|
*
|
2002-10-08 17:58:36 +00:00
|
|
|
* Raw DV format
|
2009-01-19 15:46:40 +00:00
|
|
|
* Copyright (c) 2002 Fabrice Bellard
|
2002-10-08 17:58:36 +00:00
|
|
|
*
|
2008-08-28 22:41:00 +00:00
|
|
|
* 50 Mbps (DVCPRO50) and 100 Mbps (DVCPRO HD) support
|
2006-03-06 08:54:33 +00:00
|
|
|
* Copyright (c) 2006 Daniel Maas <dmaas@maasdigital.com>
|
2008-08-28 22:41:00 +00:00
|
|
|
* Funded by BBC Research & Development
|
2006-03-06 08:54:33 +00:00
|
|
|
*
|
2006-10-07 15:30:46 +00:00
|
|
|
* This file is part of FFmpeg.
|
|
|
|
*
|
|
|
|
* FFmpeg is free software; you can redistribute it and/or
|
2002-10-08 17:58:36 +00:00
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
2006-10-07 15:30:46 +00:00
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
2002-10-08 17:58:36 +00:00
|
|
|
*
|
2006-10-07 15:30:46 +00:00
|
|
|
* FFmpeg is distributed in the hope that it will be useful,
|
2002-10-08 17:58:36 +00:00
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
2006-10-07 15:30:46 +00:00
|
|
|
* License along with FFmpeg; if not, write to the Free Software
|
2006-01-12 22:43:26 +00:00
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
2002-10-08 17:58:36 +00:00
|
|
|
*/
|
2003-09-29 17:54:07 +00:00
|
|
|
#include <time.h>
|
2002-10-08 17:58:36 +00:00
|
|
|
#include "avformat.h"
|
2011-11-29 18:28:15 +00:00
|
|
|
#include "internal.h"
|
2012-04-18 15:55:49 +00:00
|
|
|
#include "libavcodec/dv_profile.h"
|
2013-11-10 17:05:39 +00:00
|
|
|
#include "libavcodec/dv.h"
|
2012-04-07 16:59:32 +00:00
|
|
|
#include "libavutil/channel_layout.h"
|
2009-02-22 09:42:56 +00:00
|
|
|
#include "libavutil/intreadwrite.h"
|
2011-06-04 11:58:23 +00:00
|
|
|
#include "libavutil/mathematics.h"
|
2012-01-31 10:44:27 +00:00
|
|
|
#include "libavutil/timecode.h"
|
2003-10-31 22:26:26 +00:00
|
|
|
#include "dv.h"
|
2012-01-25 03:51:06 +00:00
|
|
|
#include "libavutil/avassert.h"
|
2003-10-31 22:26:26 +00:00
|
|
|
|
|
|
|
struct DVDemuxContext {
|
2014-07-05 09:09:15 +00:00
|
|
|
const AVDVProfile* sys; /* Current DV profile. E.g.: 525/60, 625/50 */
|
2008-10-24 21:41:27 +00:00
|
|
|
AVFormatContext* fctx;
|
|
|
|
AVStream* vst;
|
|
|
|
AVStream* ast[4];
|
|
|
|
AVPacket audio_pkt[4];
|
|
|
|
uint8_t audio_buf[4][8192];
|
|
|
|
int ach;
|
|
|
|
int frames;
|
|
|
|
uint64_t abytes;
|
2003-10-31 22:26:26 +00:00
|
|
|
};
|
2002-10-08 17:58:36 +00:00
|
|
|
|
2003-09-29 17:54:07 +00:00
|
|
|
static inline uint16_t dv_audio_12to16(uint16_t sample)
|
|
|
|
{
|
|
|
|
uint16_t shift, result;
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2003-09-29 17:54:07 +00:00
|
|
|
sample = (sample < 0x800) ? sample : sample | 0xf000;
|
2008-10-24 21:41:27 +00:00
|
|
|
shift = (sample & 0xf00) >> 8;
|
2003-09-29 17:54:07 +00:00
|
|
|
|
|
|
|
if (shift < 0x2 || shift > 0xd) {
|
2005-12-22 01:10:11 +00:00
|
|
|
result = sample;
|
2003-09-29 17:54:07 +00:00
|
|
|
} else if (shift < 0x8) {
|
|
|
|
shift--;
|
2005-12-22 01:10:11 +00:00
|
|
|
result = (sample - (256 * shift)) << shift;
|
2003-09-29 17:54:07 +00:00
|
|
|
} else {
|
2013-08-06 00:55:02 +00:00
|
|
|
shift = 0xe - shift;
|
2005-12-22 01:10:11 +00:00
|
|
|
result = ((sample + ((256 * shift) + 1)) << shift) - 1;
|
2003-09-29 17:54:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2014-09-24 16:33:55 +00:00
|
|
|
static const uint8_t *dv_extract_pack(const uint8_t *frame, enum dv_pack_type t)
|
2003-09-29 17:54:07 +00:00
|
|
|
{
|
|
|
|
int offs;
|
2014-07-17 02:25:21 +00:00
|
|
|
int c;
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2014-07-17 02:25:21 +00:00
|
|
|
for (c = 0; c < 10; c++) {
|
|
|
|
switch (t) {
|
|
|
|
case dv_audio_source:
|
|
|
|
if (c&1) offs = (80 * 6 + 80 * 16 * 0 + 3 + c*12000);
|
|
|
|
else offs = (80 * 6 + 80 * 16 * 3 + 3 + c*12000);
|
|
|
|
break;
|
|
|
|
case dv_audio_control:
|
|
|
|
if (c&1) offs = (80 * 6 + 80 * 16 * 1 + 3 + c*12000);
|
|
|
|
else offs = (80 * 6 + 80 * 16 * 4 + 3 + c*12000);
|
|
|
|
break;
|
|
|
|
case dv_video_control:
|
|
|
|
if (c&1) offs = (80 * 3 + 8 + c*12000);
|
|
|
|
else offs = (80 * 5 + 48 + 5 + c*12000);
|
|
|
|
break;
|
|
|
|
case dv_timecode:
|
|
|
|
offs = (80*1 + 3 + 3);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if (frame[offs] == t)
|
|
|
|
break;
|
2005-12-17 18:14:38 +00:00
|
|
|
}
|
2003-09-29 17:54:07 +00:00
|
|
|
|
2008-05-06 09:16:36 +00:00
|
|
|
return frame[offs] == t ? &frame[offs] : NULL;
|
2003-09-29 17:54:07 +00:00
|
|
|
}
|
|
|
|
|
2012-02-10 01:53:05 +00:00
|
|
|
static const int dv_audio_frequency[3] = {
|
|
|
|
48000, 44100, 32000,
|
|
|
|
};
|
|
|
|
|
2005-12-17 18:14:38 +00:00
|
|
|
/*
|
2003-09-29 17:54:07 +00:00
|
|
|
* There's a couple of assumptions being made here:
|
2016-04-27 17:45:23 +00:00
|
|
|
* 1. By default we silence erroneous (0x8000/16-bit 0x800/12-bit) audio samples.
|
2011-10-30 17:02:42 +00:00
|
|
|
* We can pass them upwards when libavcodec will be ready to deal with them.
|
2003-09-29 17:54:07 +00:00
|
|
|
* 2. We don't do software emphasis.
|
2016-04-27 17:45:23 +00:00
|
|
|
* 3. Audio is always returned as 16-bit linear samples: 12-bit nonlinear samples
|
|
|
|
* are converted into 16-bit linear ones.
|
2003-09-29 17:54:07 +00:00
|
|
|
*/
|
2014-09-24 16:33:55 +00:00
|
|
|
static int dv_extract_audio(const uint8_t *frame, uint8_t **ppcm,
|
2014-07-05 09:09:15 +00:00
|
|
|
const AVDVProfile *sys)
|
2003-09-29 17:54:07 +00:00
|
|
|
{
|
2006-03-06 08:54:33 +00:00
|
|
|
int size, chan, i, j, d, of, smpls, freq, quant, half_ch;
|
2003-09-29 17:54:07 +00:00
|
|
|
uint16_t lc, rc;
|
2013-08-06 00:55:02 +00:00
|
|
|
const uint8_t *as_pack;
|
2008-08-28 22:41:00 +00:00
|
|
|
uint8_t *pcm, ipcm;
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2003-09-29 17:54:07 +00:00
|
|
|
as_pack = dv_extract_pack(frame, dv_audio_source);
|
|
|
|
if (!as_pack) /* No audio ? */
|
2005-12-22 01:10:11 +00:00
|
|
|
return 0;
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2013-08-06 00:55:02 +00:00
|
|
|
smpls = as_pack[1] & 0x3f; /* samples in this frame - min. samples */
|
|
|
|
freq = as_pack[4] >> 3 & 0x07; /* 0 - 48kHz, 1 - 44,1kHz, 2 - 32kHz */
|
2016-04-27 17:45:23 +00:00
|
|
|
quant = as_pack[4] & 0x07; /* 0 - 16-bit linear, 1 - 12-bit nonlinear */
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2003-09-29 17:54:07 +00:00
|
|
|
if (quant > 1)
|
2013-08-06 00:55:02 +00:00
|
|
|
return -1; /* unsupported quantization */
|
2003-09-29 17:54:07 +00:00
|
|
|
|
2012-02-10 01:11:55 +00:00
|
|
|
if (freq >= FF_ARRAY_ELEMS(dv_audio_frequency))
|
|
|
|
return AVERROR_INVALIDDATA;
|
|
|
|
|
2013-08-06 00:55:02 +00:00
|
|
|
size = (sys->audio_min_samples[freq] + smpls) * 4; /* 2ch, 2bytes */
|
2008-10-24 21:41:27 +00:00
|
|
|
half_ch = sys->difseg_size / 2;
|
2003-09-29 17:54:07 +00:00
|
|
|
|
2008-10-24 21:37:06 +00:00
|
|
|
/* We work with 720p frames split in half, thus even frames have
|
2008-10-24 21:41:27 +00:00
|
|
|
* channels 0,1 and odd 2,3. */
|
|
|
|
ipcm = (sys->height == 720 && !(frame[1] & 0x0C)) ? 2 : 0;
|
2008-08-28 22:41:00 +00:00
|
|
|
|
2012-11-13 18:37:47 +00:00
|
|
|
if (ipcm + sys->n_difchan > (quant == 1 ? 2 : 4)) {
|
|
|
|
av_log(NULL, AV_LOG_ERROR, "too many dv pcm frames\n");
|
|
|
|
return AVERROR_INVALIDDATA;
|
|
|
|
}
|
|
|
|
|
2006-03-06 08:54:33 +00:00
|
|
|
/* for each DIF channel */
|
|
|
|
for (chan = 0; chan < sys->n_difchan; chan++) {
|
2012-01-25 03:51:06 +00:00
|
|
|
av_assert0(ipcm<4);
|
|
|
|
pcm = ppcm[ipcm++];
|
|
|
|
if (!pcm)
|
|
|
|
break;
|
2012-01-26 23:08:26 +00:00
|
|
|
|
2006-03-06 08:54:33 +00:00
|
|
|
/* for each DIF segment */
|
|
|
|
for (i = 0; i < sys->difseg_size; i++) {
|
|
|
|
frame += 6 * 80; /* skip DIF segment header */
|
|
|
|
if (quant == 1 && i == half_ch) {
|
2016-04-27 17:45:23 +00:00
|
|
|
/* next stereo channel (12-bit mode only) */
|
2012-01-25 03:51:06 +00:00
|
|
|
av_assert0(ipcm<4);
|
2008-08-28 22:41:00 +00:00
|
|
|
pcm = ppcm[ipcm++];
|
|
|
|
if (!pcm)
|
2006-03-06 08:54:33 +00:00
|
|
|
break;
|
|
|
|
}
|
2005-12-22 01:10:11 +00:00
|
|
|
|
2006-03-06 08:54:33 +00:00
|
|
|
/* for each AV sequence */
|
|
|
|
for (j = 0; j < 9; j++) {
|
|
|
|
for (d = 8; d < 80; d += 2) {
|
2016-04-27 17:45:23 +00:00
|
|
|
if (quant == 0) { /* 16-bit quantization */
|
2013-08-06 00:55:02 +00:00
|
|
|
of = sys->audio_shuffle[i][j] +
|
|
|
|
(d - 8) / 2 * sys->audio_stride;
|
|
|
|
if (of * 2 >= size)
|
2006-03-06 08:54:33 +00:00
|
|
|
continue;
|
|
|
|
|
2013-08-06 00:55:02 +00:00
|
|
|
/* FIXME: maybe we have to admit that DV is a
|
|
|
|
* big-endian PCM */
|
|
|
|
pcm[of * 2] = frame[d + 1];
|
|
|
|
pcm[of * 2 + 1] = frame[d];
|
|
|
|
|
|
|
|
if (pcm[of * 2 + 1] == 0x80 && pcm[of * 2] == 0x00)
|
|
|
|
pcm[of * 2 + 1] = 0;
|
2016-04-27 17:45:23 +00:00
|
|
|
} else { /* 12-bit quantization */
|
2013-08-06 00:55:02 +00:00
|
|
|
lc = ((uint16_t)frame[d] << 4) |
|
|
|
|
((uint16_t)frame[d + 2] >> 4);
|
|
|
|
rc = ((uint16_t)frame[d + 1] << 4) |
|
|
|
|
((uint16_t)frame[d + 2] & 0x0f);
|
2006-03-06 08:54:33 +00:00
|
|
|
lc = (lc == 0x800 ? 0 : dv_audio_12to16(lc));
|
|
|
|
rc = (rc == 0x800 ? 0 : dv_audio_12to16(rc));
|
|
|
|
|
2013-08-06 00:55:02 +00:00
|
|
|
of = sys->audio_shuffle[i % half_ch][j] +
|
|
|
|
(d - 8) / 3 * sys->audio_stride;
|
|
|
|
if (of * 2 >= size)
|
2006-03-06 08:54:33 +00:00
|
|
|
continue;
|
|
|
|
|
2013-08-06 00:55:02 +00:00
|
|
|
/* FIXME: maybe we have to admit that DV is a
|
|
|
|
* big-endian PCM */
|
|
|
|
pcm[of * 2] = lc & 0xff;
|
|
|
|
pcm[of * 2 + 1] = lc >> 8;
|
|
|
|
of = sys->audio_shuffle[i % half_ch + half_ch][j] +
|
|
|
|
(d - 8) / 3 * sys->audio_stride;
|
|
|
|
/* FIXME: maybe we have to admit that DV is a
|
|
|
|
* big-endian PCM */
|
|
|
|
pcm[of * 2] = rc & 0xff;
|
|
|
|
pcm[of * 2 + 1] = rc >> 8;
|
2006-03-06 08:54:33 +00:00
|
|
|
++d;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
frame += 16 * 80; /* 15 Video DIFs + 1 Audio DIF */
|
|
|
|
}
|
2003-09-29 17:54:07 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
2014-09-24 16:33:55 +00:00
|
|
|
static int dv_extract_audio_info(DVDemuxContext *c, const uint8_t *frame)
|
2003-09-29 17:54:07 +00:00
|
|
|
{
|
2013-08-06 00:55:02 +00:00
|
|
|
const uint8_t *as_pack;
|
2006-03-06 08:54:33 +00:00
|
|
|
int freq, stype, smpls, quant, i, ach;
|
2003-09-29 17:54:07 +00:00
|
|
|
|
|
|
|
as_pack = dv_extract_pack(frame, dv_audio_source);
|
2006-03-06 08:54:33 +00:00
|
|
|
if (!as_pack || !c->sys) { /* No audio ? */
|
2003-10-31 22:26:26 +00:00
|
|
|
c->ach = 0;
|
2005-12-22 01:10:11 +00:00
|
|
|
return 0;
|
2003-10-31 22:26:26 +00:00
|
|
|
}
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2013-08-06 00:55:02 +00:00
|
|
|
smpls = as_pack[1] & 0x3f; /* samples in this frame - min. samples */
|
|
|
|
freq = as_pack[4] >> 3 & 0x07; /* 0 - 48kHz, 1 - 44,1kHz, 2 - 32kHz */
|
|
|
|
stype = as_pack[3] & 0x1f; /* 0 - 2CH, 2 - 4CH, 3 - 8CH */
|
2016-04-27 17:45:23 +00:00
|
|
|
quant = as_pack[4] & 0x07; /* 0 - 16-bit linear, 1 - 12-bit nonlinear */
|
2006-03-06 08:54:33 +00:00
|
|
|
|
2012-02-10 01:11:55 +00:00
|
|
|
if (freq >= FF_ARRAY_ELEMS(dv_audio_frequency)) {
|
|
|
|
av_log(c->fctx, AV_LOG_ERROR,
|
|
|
|
"Unrecognized audio sample rate index (%d)\n", freq);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-01-24 17:48:23 +00:00
|
|
|
if (stype > 3) {
|
|
|
|
av_log(c->fctx, AV_LOG_ERROR, "stype %d is invalid\n", stype);
|
|
|
|
c->ach = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-03-06 08:54:33 +00:00
|
|
|
/* note: ach counts PAIRS of channels (i.e. stereo channels) */
|
2013-08-06 00:55:02 +00:00
|
|
|
ach = ((int[4]) { 1, 0, 2, 4 })[stype];
|
2008-10-07 16:14:33 +00:00
|
|
|
if (ach == 1 && quant && freq == 2)
|
|
|
|
ach = 2;
|
2004-09-27 22:53:27 +00:00
|
|
|
|
|
|
|
/* Dynamic handling of the audio streams in DV */
|
2008-10-24 21:41:27 +00:00
|
|
|
for (i = 0; i < ach; i++) {
|
2012-10-24 07:12:42 +00:00
|
|
|
if (!c->ast[i]) {
|
|
|
|
c->ast[i] = avformat_new_stream(c->fctx, NULL);
|
|
|
|
if (!c->ast[i])
|
|
|
|
break;
|
|
|
|
avpriv_set_pts_info(c->ast[i], 64, 1, 30000);
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
c->ast[i]->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
|
|
|
|
c->ast[i]->codecpar->codec_id = AV_CODEC_ID_PCM_S16LE;
|
2012-10-24 07:12:42 +00:00
|
|
|
|
|
|
|
av_init_packet(&c->audio_pkt[i]);
|
|
|
|
c->audio_pkt[i].size = 0;
|
|
|
|
c->audio_pkt[i].data = c->audio_buf[i];
|
|
|
|
c->audio_pkt[i].stream_index = c->ast[i]->index;
|
|
|
|
c->audio_pkt[i].flags |= AV_PKT_FLAG_KEY;
|
|
|
|
}
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
c->ast[i]->codecpar->sample_rate = dv_audio_frequency[freq];
|
|
|
|
c->ast[i]->codecpar->channels = 2;
|
|
|
|
c->ast[i]->codecpar->channel_layout = AV_CH_LAYOUT_STEREO;
|
|
|
|
c->ast[i]->codecpar->bit_rate = 2 * dv_audio_frequency[freq] * 16;
|
2013-08-06 00:55:02 +00:00
|
|
|
c->ast[i]->start_time = 0;
|
2003-10-31 22:26:26 +00:00
|
|
|
}
|
2004-09-27 22:53:27 +00:00
|
|
|
c->ach = i;
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2013-08-06 00:55:02 +00:00
|
|
|
return (c->sys->audio_min_samples[freq] + smpls) * 4; /* 2ch, 2bytes */
|
2003-09-29 17:54:07 +00:00
|
|
|
}
|
|
|
|
|
2014-09-24 16:33:55 +00:00
|
|
|
static int dv_extract_video_info(DVDemuxContext *c, const uint8_t *frame)
|
2003-09-29 17:54:07 +00:00
|
|
|
{
|
2013-08-06 00:55:02 +00:00
|
|
|
const uint8_t *vsc_pack;
|
2016-04-10 19:58:15 +00:00
|
|
|
AVCodecParameters *par;
|
2003-10-31 22:26:26 +00:00
|
|
|
int apt, is16_9;
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2016-04-10 19:58:15 +00:00
|
|
|
par = c->vst->codecpar;
|
2016-03-20 18:28:07 +00:00
|
|
|
|
|
|
|
avpriv_set_pts_info(c->vst, 64, c->sys->time_base.num,
|
|
|
|
c->sys->time_base.den);
|
|
|
|
c->vst->avg_frame_rate = av_inv_q(c->vst->time_base);
|
|
|
|
|
|
|
|
/* finding out SAR is a little bit messy */
|
|
|
|
vsc_pack = dv_extract_pack(frame, dv_video_control);
|
|
|
|
apt = frame[4] & 0x07;
|
|
|
|
is16_9 = (vsc_pack && ((vsc_pack[2] & 0x07) == 0x02 ||
|
|
|
|
(!apt && (vsc_pack[2] & 0x07) == 0x07)));
|
|
|
|
c->vst->sample_aspect_ratio = c->sys->sar[is16_9];
|
2016-04-10 19:58:15 +00:00
|
|
|
par->bit_rate = av_rescale_q(c->sys->frame_size,
|
2016-03-20 18:28:07 +00:00
|
|
|
(AVRational) { 8, 1 },
|
|
|
|
c->sys->time_base);
|
2016-03-20 13:24:53 +00:00
|
|
|
return c->sys->frame_size;
|
2003-09-29 17:54:07 +00:00
|
|
|
}
|
|
|
|
|
2014-09-24 16:33:55 +00:00
|
|
|
static int dv_extract_timecode(DVDemuxContext* c, const uint8_t* frame, char *tc)
|
2011-12-22 21:57:02 +00:00
|
|
|
{
|
|
|
|
const uint8_t *tc_pack;
|
|
|
|
|
|
|
|
// For PAL systems, drop frame bit is replaced by an arbitrary
|
|
|
|
// bit so its value should not be considered. Drop frame timecode
|
|
|
|
// is only relevant for NTSC systems.
|
2012-01-31 10:44:27 +00:00
|
|
|
int prevent_df = c->sys->ltc_divisor == 25 || c->sys->ltc_divisor == 50;
|
2011-12-22 21:57:02 +00:00
|
|
|
|
2012-01-31 10:44:27 +00:00
|
|
|
tc_pack = dv_extract_pack(frame, dv_timecode);
|
|
|
|
if (!tc_pack)
|
|
|
|
return 0;
|
|
|
|
av_timecode_make_smpte_tc_string(tc, AV_RB32(tc_pack + 1), prevent_df);
|
2011-12-22 21:57:02 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2013-08-06 00:55:02 +00:00
|
|
|
/* The following 3 functions constitute our interface to the world */
|
2003-09-29 17:54:07 +00:00
|
|
|
|
2013-08-06 00:55:02 +00:00
|
|
|
DVDemuxContext *avpriv_dv_init_demux(AVFormatContext *s)
|
2003-09-29 17:54:07 +00:00
|
|
|
{
|
|
|
|
DVDemuxContext *c;
|
|
|
|
|
|
|
|
c = av_mallocz(sizeof(DVDemuxContext));
|
|
|
|
if (!c)
|
|
|
|
return NULL;
|
|
|
|
|
2011-06-18 09:43:24 +00:00
|
|
|
c->vst = avformat_new_stream(s, NULL);
|
2004-09-27 22:53:27 +00:00
|
|
|
if (!c->vst) {
|
2005-12-17 18:14:38 +00:00
|
|
|
av_free(c);
|
2004-09-27 22:53:27 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
2004-05-21 20:43:21 +00:00
|
|
|
|
2012-03-05 12:57:14 +00:00
|
|
|
c->fctx = s;
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
c->vst->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
|
|
|
|
c->vst->codecpar->codec_id = AV_CODEC_ID_DVVIDEO;
|
|
|
|
c->vst->codecpar->bit_rate = 25000000;
|
2008-10-24 21:41:27 +00:00
|
|
|
c->vst->start_time = 0;
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2003-09-29 17:54:07 +00:00
|
|
|
return c;
|
2002-10-08 17:58:36 +00:00
|
|
|
}
|
|
|
|
|
2011-10-17 06:58:50 +00:00
|
|
|
int avpriv_dv_get_packet(DVDemuxContext *c, AVPacket *pkt)
|
2002-10-08 17:58:36 +00:00
|
|
|
{
|
2003-09-29 17:54:07 +00:00
|
|
|
int size = -1;
|
2003-10-31 22:26:26 +00:00
|
|
|
int i;
|
|
|
|
|
2008-10-24 21:41:27 +00:00
|
|
|
for (i = 0; i < c->ach; i++) {
|
2012-10-24 07:12:42 +00:00
|
|
|
if (c->ast[i] && c->audio_pkt[i].size) {
|
2013-08-06 00:55:02 +00:00
|
|
|
*pkt = c->audio_pkt[i];
|
2012-10-24 07:12:42 +00:00
|
|
|
c->audio_pkt[i].size = 0;
|
2013-08-06 00:55:02 +00:00
|
|
|
size = pkt->size;
|
2012-10-24 07:12:42 +00:00
|
|
|
break;
|
|
|
|
}
|
2003-01-27 09:21:30 +00:00
|
|
|
}
|
2003-09-29 17:54:07 +00:00
|
|
|
|
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
2011-10-17 06:58:50 +00:00
|
|
|
int avpriv_dv_produce_packet(DVDemuxContext *c, AVPacket *pkt,
|
2013-08-06 16:01:03 +00:00
|
|
|
uint8_t *buf, int buf_size, int64_t pos)
|
2003-09-29 17:54:07 +00:00
|
|
|
{
|
2003-10-31 22:26:26 +00:00
|
|
|
int size, i;
|
2013-08-05 20:15:24 +00:00
|
|
|
uint8_t *ppcm[5] = { 0 };
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2006-04-01 23:13:53 +00:00
|
|
|
if (buf_size < DV_PROFILE_BYTES ||
|
2014-07-05 09:09:15 +00:00
|
|
|
!(c->sys = av_dv_frame_profile(c->sys, buf, buf_size)) ||
|
2006-04-01 23:13:53 +00:00
|
|
|
buf_size < c->sys->frame_size) {
|
2012-10-24 07:12:42 +00:00
|
|
|
return -1; /* Broken frame, or not enough data */
|
2006-04-01 23:13:53 +00:00
|
|
|
}
|
2003-09-29 17:54:07 +00:00
|
|
|
|
|
|
|
/* Queueing audio packet */
|
|
|
|
/* FIXME: in case of no audio/bad audio we have to do something */
|
2003-10-31 22:26:26 +00:00
|
|
|
size = dv_extract_audio_info(c, buf);
|
2008-10-24 21:41:27 +00:00
|
|
|
for (i = 0; i < c->ach; i++) {
|
2012-10-30 14:22:13 +00:00
|
|
|
c->audio_pkt[i].pos = pos;
|
2012-10-24 07:12:42 +00:00
|
|
|
c->audio_pkt[i].size = size;
|
2013-08-06 00:55:02 +00:00
|
|
|
c->audio_pkt[i].pts = c->abytes * 30000 * 8 /
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
c->ast[i]->codecpar->bit_rate;
|
2012-10-24 07:12:42 +00:00
|
|
|
ppcm[i] = c->audio_buf[i];
|
2003-10-31 22:26:26 +00:00
|
|
|
}
|
2012-01-24 17:51:40 +00:00
|
|
|
if (c->ach)
|
|
|
|
dv_extract_audio(buf, ppcm, c->sys);
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2008-10-24 21:37:06 +00:00
|
|
|
/* We work with 720p frames split in half, thus even frames have
|
|
|
|
* channels 0,1 and odd 2,3. */
|
2008-08-28 22:41:00 +00:00
|
|
|
if (c->sys->height == 720) {
|
2009-06-19 21:36:21 +00:00
|
|
|
if (buf[1] & 0x0C) {
|
2008-08-28 22:41:00 +00:00
|
|
|
c->audio_pkt[2].size = c->audio_pkt[3].size = 0;
|
2009-06-19 21:36:21 +00:00
|
|
|
} else {
|
2008-08-28 22:41:00 +00:00
|
|
|
c->audio_pkt[0].size = c->audio_pkt[1].size = 0;
|
2013-08-06 00:55:02 +00:00
|
|
|
c->abytes += size;
|
2009-06-19 21:36:21 +00:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
c->abytes += size;
|
2008-08-28 22:41:00 +00:00
|
|
|
}
|
|
|
|
|
2003-09-29 17:54:07 +00:00
|
|
|
/* Now it's time to return video packet */
|
2003-10-31 22:26:26 +00:00
|
|
|
size = dv_extract_video_info(c, buf);
|
2003-02-06 22:34:55 +00:00
|
|
|
av_init_packet(pkt);
|
2008-10-24 21:41:27 +00:00
|
|
|
pkt->data = buf;
|
2011-04-30 09:55:36 +00:00
|
|
|
pkt->pos = pos;
|
2008-10-24 21:41:27 +00:00
|
|
|
pkt->size = size;
|
2010-03-31 12:29:58 +00:00
|
|
|
pkt->flags |= AV_PKT_FLAG_KEY;
|
2012-10-24 07:06:32 +00:00
|
|
|
pkt->stream_index = c->vst->index;
|
2008-10-24 21:41:27 +00:00
|
|
|
pkt->pts = c->frames;
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2004-03-23 05:35:10 +00:00
|
|
|
c->frames++;
|
2003-10-31 22:26:26 +00:00
|
|
|
|
2003-09-29 17:54:07 +00:00
|
|
|
return size;
|
|
|
|
}
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2004-10-12 01:51:04 +00:00
|
|
|
static int64_t dv_frame_offset(AVFormatContext *s, DVDemuxContext *c,
|
2013-08-06 00:55:02 +00:00
|
|
|
int64_t timestamp, int flags)
|
2004-03-23 05:35:10 +00:00
|
|
|
{
|
2004-09-18 00:32:36 +00:00
|
|
|
// FIXME: sys may be wrong if last dv_read_packet() failed (buffer is junk)
|
2016-03-20 15:14:22 +00:00
|
|
|
const int frame_size = c->sys->frame_size;
|
2005-04-26 11:04:34 +00:00
|
|
|
int64_t offset;
|
2015-02-06 13:53:40 +00:00
|
|
|
int64_t size = avio_size(s->pb) - s->internal->data_offset;
|
2016-03-20 15:14:22 +00:00
|
|
|
int64_t max_offset = ((size - 1) / frame_size) * frame_size;
|
2004-09-18 00:32:36 +00:00
|
|
|
|
2016-03-20 15:14:22 +00:00
|
|
|
offset = frame_size * timestamp;
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2013-08-06 00:55:02 +00:00
|
|
|
if (size >= 0 && offset > max_offset)
|
|
|
|
offset = max_offset;
|
|
|
|
else if (offset < 0)
|
|
|
|
offset = 0;
|
2004-03-23 05:35:10 +00:00
|
|
|
|
2015-02-06 13:53:40 +00:00
|
|
|
return offset + s->internal->data_offset;
|
2004-03-23 05:35:10 +00:00
|
|
|
}
|
|
|
|
|
2012-02-15 09:28:39 +00:00
|
|
|
void ff_dv_offset_reset(DVDemuxContext *c, int64_t frame_offset)
|
2004-10-13 00:03:00 +00:00
|
|
|
{
|
2013-08-06 00:55:02 +00:00
|
|
|
c->frames = frame_offset;
|
2012-08-16 02:25:07 +00:00
|
|
|
if (c->ach) {
|
|
|
|
if (c->sys) {
|
2013-08-06 00:55:02 +00:00
|
|
|
c->abytes = av_rescale_q(c->frames, c->sys->time_base,
|
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
|
|
|
(AVRational) { 8, c->ast[0]->codecpar->bit_rate });
|
2013-08-06 16:01:03 +00:00
|
|
|
} else
|
2012-08-16 02:25:07 +00:00
|
|
|
av_log(c->fctx, AV_LOG_ERROR, "cannot adjust audio bytes\n");
|
|
|
|
}
|
2004-10-13 00:03:00 +00:00
|
|
|
c->audio_pkt[0].size = c->audio_pkt[1].size = 0;
|
2008-08-28 22:41:00 +00:00
|
|
|
c->audio_pkt[2].size = c->audio_pkt[3].size = 0;
|
2004-10-13 00:03:00 +00:00
|
|
|
}
|
|
|
|
|
2003-09-29 17:54:07 +00:00
|
|
|
/************************************************************
|
|
|
|
* Implementation of the easiest DV storage of all -- raw DV.
|
|
|
|
************************************************************/
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2003-09-29 17:54:07 +00:00
|
|
|
typedef struct RawDVContext {
|
2013-08-06 00:55:02 +00:00
|
|
|
DVDemuxContext *dv_demux;
|
2006-03-06 08:54:33 +00:00
|
|
|
uint8_t buf[DV_MAX_FRAME_SIZE];
|
2003-09-29 17:54:07 +00:00
|
|
|
} RawDVContext;
|
|
|
|
|
2011-12-22 21:57:02 +00:00
|
|
|
static int dv_read_timecode(AVFormatContext *s) {
|
|
|
|
int ret;
|
2012-01-31 10:44:27 +00:00
|
|
|
char timecode[AV_TIMECODE_STR_SIZE];
|
2011-12-22 21:57:02 +00:00
|
|
|
int64_t pos = avio_tell(s->pb);
|
|
|
|
|
|
|
|
// Read 3 DIF blocks: Header block and 2 Subcode blocks.
|
|
|
|
int partial_frame_size = 3 * 80;
|
|
|
|
uint8_t *partial_frame = av_mallocz(sizeof(*partial_frame) *
|
|
|
|
partial_frame_size);
|
|
|
|
|
|
|
|
RawDVContext *c = s->priv_data;
|
2015-01-23 17:15:43 +00:00
|
|
|
if (!partial_frame)
|
|
|
|
return AVERROR(ENOMEM);
|
|
|
|
|
2011-12-22 21:57:02 +00:00
|
|
|
ret = avio_read(s->pb, partial_frame, partial_frame_size);
|
|
|
|
if (ret < 0)
|
|
|
|
goto finish;
|
|
|
|
|
|
|
|
if (ret < partial_frame_size) {
|
|
|
|
ret = -1;
|
|
|
|
goto finish;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = dv_extract_timecode(c->dv_demux, partial_frame, timecode);
|
|
|
|
if (ret)
|
|
|
|
av_dict_set(&s->metadata, "timecode", timecode, 0);
|
2012-10-22 17:08:26 +00:00
|
|
|
else
|
2012-09-01 10:35:14 +00:00
|
|
|
av_log(s, AV_LOG_ERROR, "Detected timecode is invalid\n");
|
2011-12-22 21:57:02 +00:00
|
|
|
|
|
|
|
finish:
|
|
|
|
av_free(partial_frame);
|
|
|
|
avio_seek(s->pb, pos, SEEK_SET);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-01-12 12:20:36 +00:00
|
|
|
static int dv_read_header(AVFormatContext *s)
|
2003-09-29 17:54:07 +00:00
|
|
|
{
|
2009-06-15 01:41:59 +00:00
|
|
|
unsigned state, marker_pos = 0;
|
2003-09-29 17:54:07 +00:00
|
|
|
RawDVContext *c = s->priv_data;
|
2019-10-11 17:34:17 +00:00
|
|
|
int ret;
|
2006-03-06 08:54:33 +00:00
|
|
|
|
2011-10-17 06:58:50 +00:00
|
|
|
c->dv_demux = avpriv_dv_init_demux(s);
|
2004-09-19 02:05:22 +00:00
|
|
|
if (!c->dv_demux)
|
2019-10-11 17:34:17 +00:00
|
|
|
return AVERROR(ENOMEM);
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2011-02-21 15:43:01 +00:00
|
|
|
state = avio_rb32(s->pb);
|
2009-02-22 09:42:56 +00:00
|
|
|
while ((state & 0xffffff7f) != 0x1f07003f) {
|
2014-08-07 20:12:41 +00:00
|
|
|
if (avio_feof(s->pb)) {
|
2009-02-22 09:42:56 +00:00
|
|
|
av_log(s, AV_LOG_ERROR, "Cannot find DV header.\n");
|
2019-10-11 17:34:17 +00:00
|
|
|
ret = AVERROR_INVALIDDATA;
|
|
|
|
goto fail;
|
2009-02-22 09:42:56 +00:00
|
|
|
}
|
2009-06-15 01:41:59 +00:00
|
|
|
if (state == 0x003f0700 || state == 0xff3f0700)
|
2011-03-03 19:11:45 +00:00
|
|
|
marker_pos = avio_tell(s->pb);
|
|
|
|
if (state == 0xff3f0701 && avio_tell(s->pb) - marker_pos == 80) {
|
2011-02-28 13:57:54 +00:00
|
|
|
avio_seek(s->pb, -163, SEEK_CUR);
|
2011-02-21 15:43:01 +00:00
|
|
|
state = avio_rb32(s->pb);
|
2009-06-15 01:41:59 +00:00
|
|
|
break;
|
|
|
|
}
|
2011-02-21 15:43:01 +00:00
|
|
|
state = (state << 8) | avio_r8(s->pb);
|
2009-02-22 09:42:56 +00:00
|
|
|
}
|
|
|
|
AV_WB32(c->buf, state);
|
|
|
|
|
2012-03-04 18:39:45 +00:00
|
|
|
if (avio_read(s->pb, c->buf + 4, DV_PROFILE_BYTES - 4) != DV_PROFILE_BYTES - 4 ||
|
2019-10-11 17:34:17 +00:00
|
|
|
avio_seek(s->pb, -DV_PROFILE_BYTES, SEEK_CUR) < 0) {
|
|
|
|
ret = AVERROR(EIO);
|
|
|
|
goto fail;
|
|
|
|
}
|
2004-09-19 02:05:22 +00:00
|
|
|
|
2014-07-05 09:09:15 +00:00
|
|
|
c->dv_demux->sys = av_dv_frame_profile(c->dv_demux->sys,
|
|
|
|
c->buf,
|
|
|
|
DV_PROFILE_BYTES);
|
2008-08-28 22:41:00 +00:00
|
|
|
if (!c->dv_demux->sys) {
|
2013-08-06 00:55:02 +00:00
|
|
|
av_log(s, AV_LOG_ERROR,
|
|
|
|
"Can't determine profile of DV input stream.\n");
|
2019-10-11 17:34:17 +00:00
|
|
|
ret = AVERROR_INVALIDDATA;
|
|
|
|
goto fail;
|
2008-08-28 22:41:00 +00:00
|
|
|
}
|
|
|
|
|
2013-08-06 00:55:02 +00:00
|
|
|
s->bit_rate = av_rescale_q(c->dv_demux->sys->frame_size,
|
|
|
|
(AVRational) { 8, 1 },
|
2008-10-07 16:59:18 +00:00
|
|
|
c->dv_demux->sys->time_base);
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2017-03-21 20:02:30 +00:00
|
|
|
if (s->pb->seekable & AVIO_SEEKABLE_NORMAL)
|
2011-12-22 21:57:02 +00:00
|
|
|
dv_read_timecode(s);
|
|
|
|
|
2004-09-19 02:05:22 +00:00
|
|
|
return 0;
|
2019-10-11 17:34:17 +00:00
|
|
|
|
|
|
|
fail:
|
|
|
|
av_freep(&c->dv_demux);
|
|
|
|
|
|
|
|
return ret;
|
2003-09-29 17:54:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int dv_read_packet(AVFormatContext *s, AVPacket *pkt)
|
|
|
|
{
|
|
|
|
int size;
|
2005-12-17 18:14:38 +00:00
|
|
|
RawDVContext *c = s->priv_data;
|
|
|
|
|
2011-10-17 06:58:50 +00:00
|
|
|
size = avpriv_dv_get_packet(c->dv_demux, pkt);
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2003-09-29 17:54:07 +00:00
|
|
|
if (size < 0) {
|
2015-09-01 22:58:13 +00:00
|
|
|
int ret;
|
2011-04-30 09:55:36 +00:00
|
|
|
int64_t pos = avio_tell(s->pb);
|
2009-01-05 17:50:13 +00:00
|
|
|
if (!c->dv_demux->sys)
|
|
|
|
return AVERROR(EIO);
|
2006-03-06 08:54:33 +00:00
|
|
|
size = c->dv_demux->sys->frame_size;
|
2015-09-01 22:58:13 +00:00
|
|
|
ret = avio_read(s->pb, c->buf, size);
|
|
|
|
if (ret < 0) {
|
|
|
|
return ret;
|
|
|
|
} else if (ret == 0) {
|
2007-07-19 15:23:32 +00:00
|
|
|
return AVERROR(EIO);
|
2015-09-01 22:58:13 +00:00
|
|
|
}
|
2003-09-29 17:54:07 +00:00
|
|
|
|
2011-10-20 23:27:28 +00:00
|
|
|
size = avpriv_dv_produce_packet(c->dv_demux, pkt, c->buf, size, pos);
|
2005-12-17 18:14:38 +00:00
|
|
|
}
|
|
|
|
|
2003-09-29 17:54:07 +00:00
|
|
|
return size;
|
2002-10-08 17:58:36 +00:00
|
|
|
}
|
|
|
|
|
2005-12-17 18:14:38 +00:00
|
|
|
static int dv_read_seek(AVFormatContext *s, int stream_index,
|
2013-08-06 00:55:02 +00:00
|
|
|
int64_t timestamp, int flags)
|
2004-03-23 05:35:10 +00:00
|
|
|
{
|
2008-10-24 21:41:27 +00:00
|
|
|
RawDVContext *r = s->priv_data;
|
2004-10-12 01:51:04 +00:00
|
|
|
DVDemuxContext *c = r->dv_demux;
|
2008-10-24 21:41:27 +00:00
|
|
|
int64_t offset = dv_frame_offset(s, c, timestamp, flags);
|
2004-10-12 01:51:04 +00:00
|
|
|
|
2011-09-14 17:24:25 +00:00
|
|
|
if (avio_seek(s->pb, offset, SEEK_SET) < 0)
|
|
|
|
return -1;
|
2005-12-17 18:14:38 +00:00
|
|
|
|
2012-02-15 09:28:39 +00:00
|
|
|
ff_dv_offset_reset(c, offset / c->sys->frame_size);
|
2011-09-14 17:24:25 +00:00
|
|
|
return 0;
|
2004-03-23 05:35:10 +00:00
|
|
|
}
|
|
|
|
|
2002-11-11 09:07:32 +00:00
|
|
|
static int dv_read_close(AVFormatContext *s)
|
2002-10-08 17:58:36 +00:00
|
|
|
{
|
2003-09-29 17:54:07 +00:00
|
|
|
RawDVContext *c = s->priv_data;
|
2014-12-14 23:16:49 +00:00
|
|
|
av_freep(&c->dv_demux);
|
2002-10-08 17:58:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-03-21 00:18:37 +00:00
|
|
|
static int dv_probe(const AVProbeData *p)
|
2009-02-26 08:45:59 +00:00
|
|
|
{
|
2013-11-10 11:20:40 +00:00
|
|
|
unsigned marker_pos = 0;
|
2009-02-26 08:45:59 +00:00
|
|
|
int i;
|
2013-08-06 00:55:02 +00:00
|
|
|
int matches = 0;
|
2013-11-09 16:31:35 +00:00
|
|
|
int firstmatch = 0;
|
2009-09-29 10:12:18 +00:00
|
|
|
int secondary_matches = 0;
|
2009-02-26 08:45:59 +00:00
|
|
|
|
|
|
|
if (p->buf_size < 5)
|
|
|
|
return 0;
|
|
|
|
|
2013-11-09 13:43:51 +00:00
|
|
|
for (i = 0; i < p->buf_size-4; i++) {
|
|
|
|
unsigned state = AV_RB32(p->buf+i);
|
|
|
|
if ((state & 0x0007f840) == 0x00070000) {
|
|
|
|
// any section header, also with seq/chan num != 0,
|
|
|
|
// should appear around every 12000 bytes, at least 10 per frame
|
|
|
|
if ((state & 0xff07ff7f) == 0x1f07003f) {
|
|
|
|
secondary_matches++;
|
2013-11-09 16:31:35 +00:00
|
|
|
if ((state & 0xffffff7f) == 0x1f07003f) {
|
2013-11-09 13:43:51 +00:00
|
|
|
matches++;
|
2013-11-09 16:31:35 +00:00
|
|
|
if (!i)
|
|
|
|
firstmatch = 1;
|
|
|
|
}
|
2013-11-09 13:43:51 +00:00
|
|
|
}
|
|
|
|
if (state == 0x003f0700 || state == 0xff3f0700)
|
|
|
|
marker_pos = i;
|
|
|
|
if (state == 0xff3f0701 && i - marker_pos == 80)
|
|
|
|
matches++;
|
|
|
|
}
|
2009-02-26 08:45:59 +00:00
|
|
|
}
|
|
|
|
|
2013-08-06 00:55:02 +00:00
|
|
|
if (matches && p->buf_size / matches < 1024 * 1024) {
|
2013-11-09 16:31:35 +00:00
|
|
|
if (matches > 4 || firstmatch ||
|
2013-08-06 00:55:02 +00:00
|
|
|
(secondary_matches >= 10 &&
|
|
|
|
p->buf_size / secondary_matches < 24000))
|
|
|
|
// not max to avoid dv in mov to match
|
|
|
|
return AVPROBE_SCORE_MAX * 3 / 4;
|
|
|
|
return AVPROBE_SCORE_MAX / 4;
|
2009-09-14 22:03:07 +00:00
|
|
|
}
|
2009-02-26 08:45:59 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-01-25 22:03:28 +00:00
|
|
|
AVInputFormat ff_dv_demuxer = {
|
2011-07-16 20:18:12 +00:00
|
|
|
.name = "dv",
|
2012-07-24 01:23:48 +00:00
|
|
|
.long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
|
2011-07-16 20:18:12 +00:00
|
|
|
.priv_data_size = sizeof(RawDVContext),
|
|
|
|
.read_probe = dv_probe,
|
|
|
|
.read_header = dv_read_header,
|
|
|
|
.read_packet = dv_read_packet,
|
|
|
|
.read_close = dv_read_close,
|
|
|
|
.read_seek = dv_read_seek,
|
2012-04-06 14:50:48 +00:00
|
|
|
.extensions = "dv,dif",
|
2003-08-28 19:53:47 +00:00
|
|
|
};
|