2006-09-15 19:14:24 +00:00
|
|
|
/*
|
|
|
|
* General DV muxer/demuxer
|
|
|
|
* Copyright (c) 2003 Roman Shaposhnik
|
|
|
|
*
|
|
|
|
* Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
|
|
|
|
* of DV technical info.
|
|
|
|
*
|
|
|
|
* Raw DV format
|
2009-01-19 15:46:40 +00:00
|
|
|
* Copyright (c) 2002 Fabrice Bellard
|
2006-09-15 19:14:24 +00:00
|
|
|
*
|
|
|
|
* 50 Mbps (DVCPRO50) support
|
|
|
|
* Copyright (c) 2006 Daniel Maas <dmaas@maasdigital.com>
|
|
|
|
*
|
2006-10-07 15:30:46 +00:00
|
|
|
* This file is part of FFmpeg.
|
|
|
|
*
|
|
|
|
* FFmpeg is free software; you can redistribute it and/or
|
2006-09-15 19:14:24 +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.
|
2006-09-15 19:14:24 +00:00
|
|
|
*
|
2006-10-07 15:30:46 +00:00
|
|
|
* FFmpeg is distributed in the hope that it will be useful,
|
2006-09-15 19:14:24 +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-09-15 19:14:24 +00:00
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
*/
|
|
|
|
#include <time.h>
|
2010-04-20 14:41:55 +00:00
|
|
|
|
2021-01-29 17:02:51 +00:00
|
|
|
#include "libavutil/time_internal.h"
|
2006-09-15 19:14:24 +00:00
|
|
|
#include "avformat.h"
|
2010-04-20 14:41:55 +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"
|
2006-09-15 19:14:24 +00:00
|
|
|
#include "dv.h"
|
2016-06-29 09:14:57 +00:00
|
|
|
#include "libavutil/avassert.h"
|
2008-05-09 11:56:36 +00:00
|
|
|
#include "libavutil/fifo.h"
|
2011-06-04 11:58:23 +00:00
|
|
|
#include "libavutil/mathematics.h"
|
2011-07-06 13:08:28 +00:00
|
|
|
#include "libavutil/intreadwrite.h"
|
|
|
|
#include "libavutil/opt.h"
|
2012-01-16 12:43:42 +00:00
|
|
|
#include "libavutil/timecode.h"
|
2006-09-15 19:14:24 +00:00
|
|
|
|
2016-04-27 17:45:23 +00:00
|
|
|
#define MAX_AUDIO_FRAME_SIZE 192000 // 1 second of 48khz 32-bit audio
|
2012-08-15 07:11:31 +00:00
|
|
|
|
2006-09-15 19:14:24 +00:00
|
|
|
struct DVMuxContext {
|
2011-07-06 13:08:28 +00:00
|
|
|
AVClass *av_class;
|
2014-07-05 09:09:15 +00:00
|
|
|
const AVDVProfile* sys; /* current DV profile, e.g.: 525/60, 625/50 */
|
2008-10-24 21:37:06 +00:00
|
|
|
int n_ast; /* number of stereo audio streams (up to 2) */
|
2019-11-09 23:56:32 +00:00
|
|
|
AVStream *ast[4]; /* stereo audio streams */
|
2022-01-06 18:25:37 +00:00
|
|
|
AVFifo *audio_data[4]; /* FIFO for storing excessive amounts of PCM */
|
2008-10-24 21:37:06 +00:00
|
|
|
int frames; /* current frame number */
|
2011-07-07 09:25:03 +00:00
|
|
|
int64_t start_time; /* recording start time */
|
2012-12-19 17:48:21 +00:00
|
|
|
int has_audio; /* frame under construction has audio */
|
|
|
|
int has_video; /* frame under construction has video */
|
|
|
|
uint8_t frame_buf[DV_MAX_FRAME_SIZE]; /* frame under construction */
|
2012-01-16 12:43:42 +00:00
|
|
|
AVTimecode tc; /* timecode context */
|
2006-09-15 19:14:24 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static const int dv_aaux_packs_dist[12][9] = {
|
|
|
|
{ 0xff, 0xff, 0xff, 0x50, 0x51, 0x52, 0x53, 0xff, 0xff },
|
|
|
|
{ 0x50, 0x51, 0x52, 0x53, 0xff, 0xff, 0xff, 0xff, 0xff },
|
|
|
|
{ 0xff, 0xff, 0xff, 0x50, 0x51, 0x52, 0x53, 0xff, 0xff },
|
|
|
|
{ 0x50, 0x51, 0x52, 0x53, 0xff, 0xff, 0xff, 0xff, 0xff },
|
|
|
|
{ 0xff, 0xff, 0xff, 0x50, 0x51, 0x52, 0x53, 0xff, 0xff },
|
|
|
|
{ 0x50, 0x51, 0x52, 0x53, 0xff, 0xff, 0xff, 0xff, 0xff },
|
|
|
|
{ 0xff, 0xff, 0xff, 0x50, 0x51, 0x52, 0x53, 0xff, 0xff },
|
|
|
|
{ 0x50, 0x51, 0x52, 0x53, 0xff, 0xff, 0xff, 0xff, 0xff },
|
|
|
|
{ 0xff, 0xff, 0xff, 0x50, 0x51, 0x52, 0x53, 0xff, 0xff },
|
|
|
|
{ 0x50, 0x51, 0x52, 0x53, 0xff, 0xff, 0xff, 0xff, 0xff },
|
|
|
|
{ 0xff, 0xff, 0xff, 0x50, 0x51, 0x52, 0x53, 0xff, 0xff },
|
|
|
|
{ 0x50, 0x51, 0x52, 0x53, 0xff, 0xff, 0xff, 0xff, 0xff },
|
|
|
|
};
|
|
|
|
|
2021-01-29 17:02:51 +00:00
|
|
|
static void brktimegm(time_t secs, struct tm *tm)
|
|
|
|
{
|
|
|
|
tm = gmtime_r(&secs, tm);
|
|
|
|
|
|
|
|
tm->tm_year += 1900; /* unlike gmtime_r we store complete year here */
|
|
|
|
tm->tm_mon += 1; /* unlike gmtime_r tm_mon is from 1 to 12 */
|
|
|
|
}
|
|
|
|
|
2014-07-16 22:54:34 +00:00
|
|
|
static int dv_audio_frame_size(const AVDVProfile* sys, int frame, int sample_rate)
|
2006-09-15 19:14:24 +00:00
|
|
|
{
|
2014-07-16 22:54:34 +00:00
|
|
|
if ((sys->time_base.den == 25 || sys->time_base.den == 50) && sys->time_base.num == 1) {
|
|
|
|
if (sample_rate == 32000) return 1280;
|
|
|
|
else if (sample_rate == 44100) return 1764;
|
|
|
|
else return 1920;
|
|
|
|
}
|
|
|
|
|
|
|
|
av_assert0(sample_rate == 48000);
|
|
|
|
|
2008-10-24 21:41:27 +00:00
|
|
|
return sys->audio_samples_dist[frame % (sizeof(sys->audio_samples_dist) /
|
2006-09-15 19:14:24 +00:00
|
|
|
sizeof(sys->audio_samples_dist[0]))];
|
|
|
|
}
|
|
|
|
|
2019-11-09 23:56:32 +00:00
|
|
|
static int dv_write_pack(enum dv_pack_type pack_id, DVMuxContext *c, uint8_t* buf, int channel, int seq)
|
2006-09-15 19:14:24 +00:00
|
|
|
{
|
|
|
|
struct tm tc;
|
|
|
|
time_t ct;
|
2011-07-06 13:08:28 +00:00
|
|
|
uint32_t timecode;
|
2014-07-16 22:54:34 +00:00
|
|
|
int audio_type = 0;
|
2006-09-15 19:14:24 +00:00
|
|
|
|
|
|
|
buf[0] = (uint8_t)pack_id;
|
|
|
|
switch (pack_id) {
|
|
|
|
case dv_timecode:
|
2012-01-16 12:43:42 +00:00
|
|
|
timecode = av_timecode_get_smpte_from_framenum(&c->tc, c->frames);
|
2011-07-06 13:08:28 +00:00
|
|
|
timecode |= 1<<23 | 1<<15 | 1<<7 | 1<<6; // biphase and binary group flags
|
|
|
|
AV_WB32(buf + 1, timecode);
|
2007-06-24 07:45:19 +00:00
|
|
|
break;
|
2006-09-15 19:14:24 +00:00
|
|
|
case dv_audio_source: /* AAUX source pack */
|
2016-04-10 19:58:15 +00:00
|
|
|
if (c->ast[channel]->codecpar->sample_rate == 44100) {
|
2014-07-16 22:54:34 +00:00
|
|
|
audio_type = 1;
|
2016-04-10 19:58:15 +00:00
|
|
|
} else if (c->ast[channel]->codecpar->sample_rate == 32000)
|
2014-07-16 22:54:34 +00:00
|
|
|
audio_type = 2;
|
2007-06-24 07:45:19 +00:00
|
|
|
buf[1] = (1 << 7) | /* locked mode -- SMPTE only supports locked mode */
|
|
|
|
(1 << 6) | /* reserved -- always 1 */
|
2016-04-10 19:58:15 +00:00
|
|
|
(dv_audio_frame_size(c->sys, c->frames, c->ast[channel]->codecpar->sample_rate) -
|
2014-07-16 22:54:34 +00:00
|
|
|
c->sys->audio_min_samples[audio_type]);
|
2007-06-24 07:45:19 +00:00
|
|
|
/* # of samples */
|
|
|
|
buf[2] = (0 << 7) | /* multi-stereo */
|
|
|
|
(0 << 5) | /* #of audio channels per block: 0 -- 1 channel */
|
|
|
|
(0 << 4) | /* pair bit: 0 -- one pair of channels */
|
2019-11-09 23:56:32 +00:00
|
|
|
(seq >= c->sys->difseg_size/2); /* audio mode (1st or 2nd channel) */
|
2007-06-24 07:45:19 +00:00
|
|
|
buf[3] = (1 << 7) | /* res */
|
|
|
|
(1 << 6) | /* multi-language flag */
|
|
|
|
(c->sys->dsf << 5) | /* system: 60fields/50fields */
|
2019-11-09 23:56:32 +00:00
|
|
|
(DV_PROFILE_IS_HD(c->sys) ? 0x3 : c->sys->video_stype ? 2 : 0); /* stype */
|
2007-06-24 07:45:19 +00:00
|
|
|
buf[4] = (1 << 7) | /* emphasis: 1 -- off */
|
|
|
|
(0 << 6) | /* emphasis time constant: 0 -- reserved */
|
2014-07-16 22:54:34 +00:00
|
|
|
(audio_type << 3) | /* frequency: 0 -- 48kHz, 1 -- 44,1kHz, 2 -- 32kHz */
|
2016-04-27 17:45:23 +00:00
|
|
|
0; /* quantization: 0 -- 16-bit linear, 1 -- 12-bit nonlinear */
|
2014-07-16 22:54:34 +00:00
|
|
|
|
2007-06-24 07:45:19 +00:00
|
|
|
break;
|
2006-09-15 19:14:24 +00:00
|
|
|
case dv_audio_control:
|
2007-06-24 07:45:19 +00:00
|
|
|
buf[1] = (0 << 6) | /* copy protection: 0 -- unrestricted */
|
|
|
|
(1 << 4) | /* input source: 1 -- digital input */
|
|
|
|
(3 << 2) | /* compression: 3 -- no information */
|
|
|
|
0; /* misc. info/SMPTE emphasis off */
|
|
|
|
buf[2] = (1 << 7) | /* recording start point: 1 -- no */
|
|
|
|
(1 << 6) | /* recording end point: 1 -- no */
|
|
|
|
(1 << 3) | /* recording mode: 1 -- original */
|
|
|
|
7;
|
|
|
|
buf[3] = (1 << 7) | /* direction: 1 -- forward */
|
2012-10-06 10:10:34 +00:00
|
|
|
(c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0x20 : /* speed */
|
2008-10-24 21:41:27 +00:00
|
|
|
c->sys->ltc_divisor * 4);
|
2007-06-24 07:45:19 +00:00
|
|
|
buf[4] = (1 << 7) | /* reserved -- always 1 */
|
|
|
|
0x7f; /* genre category */
|
|
|
|
break;
|
2006-09-15 19:14:24 +00:00
|
|
|
case dv_audio_recdate:
|
|
|
|
case dv_video_recdate: /* VAUX recording date */
|
2008-10-07 16:59:18 +00:00
|
|
|
ct = c->start_time + av_rescale_rnd(c->frames, c->sys->time_base.num,
|
2008-10-24 21:41:27 +00:00
|
|
|
c->sys->time_base.den, AV_ROUND_DOWN);
|
2021-01-29 17:02:51 +00:00
|
|
|
brktimegm(ct, &tc);
|
2007-06-24 07:45:19 +00:00
|
|
|
buf[1] = 0xff; /* ds, tm, tens of time zone, units of time zone */
|
|
|
|
/* 0xff is very likely to be "unknown" */
|
|
|
|
buf[2] = (3 << 6) | /* reserved -- always 1 */
|
|
|
|
((tc.tm_mday / 10) << 4) | /* Tens of day */
|
|
|
|
(tc.tm_mday % 10); /* Units of day */
|
|
|
|
buf[3] = /* we set high 4 bits to 0, shouldn't we set them to week? */
|
|
|
|
((tc.tm_mon / 10) << 4) | /* Tens of month */
|
|
|
|
(tc.tm_mon % 10); /* Units of month */
|
|
|
|
buf[4] = (((tc.tm_year % 100) / 10) << 4) | /* Tens of year */
|
|
|
|
(tc.tm_year % 10); /* Units of year */
|
|
|
|
break;
|
2006-09-15 19:14:24 +00:00
|
|
|
case dv_audio_rectime: /* AAUX recording time */
|
|
|
|
case dv_video_rectime: /* VAUX recording time */
|
2008-10-07 16:59:18 +00:00
|
|
|
ct = c->start_time + av_rescale_rnd(c->frames, c->sys->time_base.num,
|
|
|
|
c->sys->time_base.den, AV_ROUND_DOWN);
|
2021-01-29 17:02:51 +00:00
|
|
|
brktimegm(ct, &tc);
|
2007-06-24 07:45:19 +00:00
|
|
|
buf[1] = (3 << 6) | /* reserved -- always 1 */
|
|
|
|
0x3f; /* tens of frame, units of frame: 0x3f - "unknown" ? */
|
|
|
|
buf[2] = (1 << 7) | /* reserved -- always 1 */
|
|
|
|
((tc.tm_sec / 10) << 4) | /* Tens of seconds */
|
|
|
|
(tc.tm_sec % 10); /* Units of seconds */
|
|
|
|
buf[3] = (1 << 7) | /* reserved -- always 1 */
|
|
|
|
((tc.tm_min / 10) << 4) | /* Tens of minutes */
|
|
|
|
(tc.tm_min % 10); /* Units of minutes */
|
|
|
|
buf[4] = (3 << 6) | /* reserved -- always 1 */
|
|
|
|
((tc.tm_hour / 10) << 4) | /* Tens of hours */
|
|
|
|
(tc.tm_hour % 10); /* Units of hours */
|
|
|
|
break;
|
2006-09-15 19:14:24 +00:00
|
|
|
default:
|
2007-06-24 07:45:19 +00:00
|
|
|
buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
|
2006-09-15 19:14:24 +00:00
|
|
|
}
|
|
|
|
return 5;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dv_inject_audio(DVMuxContext *c, int channel, uint8_t* frame_ptr)
|
|
|
|
{
|
|
|
|
int i, j, d, of, size;
|
2016-04-10 19:58:15 +00:00
|
|
|
size = 4 * dv_audio_frame_size(c->sys, c->frames, c->ast[channel]->codecpar->sample_rate);
|
2006-09-15 19:14:24 +00:00
|
|
|
frame_ptr += channel * c->sys->difseg_size * 150 * 80;
|
|
|
|
for (i = 0; i < c->sys->difseg_size; i++) {
|
2007-06-24 07:45:19 +00:00
|
|
|
frame_ptr += 6 * 80; /* skip DIF segment header */
|
|
|
|
for (j = 0; j < 9; j++) {
|
2019-11-09 23:56:32 +00:00
|
|
|
dv_write_pack(dv_aaux_packs_dist[i][j], c, &frame_ptr[3], channel, i);
|
2007-06-24 07:45:19 +00:00
|
|
|
for (d = 8; d < 80; d+=2) {
|
|
|
|
of = c->sys->audio_shuffle[i][j] + (d - 8)/2 * c->sys->audio_stride;
|
|
|
|
if (of*2 >= size)
|
|
|
|
continue;
|
2006-09-15 19:14:24 +00:00
|
|
|
|
2021-12-30 11:57:48 +00:00
|
|
|
// FIXME: maybe we have to admit that DV is a big-endian PCM
|
2022-01-06 18:25:37 +00:00
|
|
|
av_fifo_peek(c->audio_data[channel], frame_ptr + d, 2, of * 2);
|
2021-12-30 11:57:48 +00:00
|
|
|
FFSWAP(uint8_t, frame_ptr[d], frame_ptr[d + 1]);
|
2007-06-24 07:45:19 +00:00
|
|
|
}
|
|
|
|
frame_ptr += 16 * 80; /* 15 Video DIFs + 1 Audio DIF */
|
|
|
|
}
|
2006-09-15 19:14:24 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dv_inject_metadata(DVMuxContext *c, uint8_t* frame)
|
|
|
|
{
|
|
|
|
int j, k;
|
|
|
|
uint8_t* buf;
|
2019-11-09 23:56:32 +00:00
|
|
|
int seq = 0;
|
2006-09-15 19:14:24 +00:00
|
|
|
|
2019-11-09 23:56:32 +00:00
|
|
|
for (buf = frame; buf < frame + c->sys->frame_size; buf += 150 * 80, seq++) {
|
2006-09-15 19:14:24 +00:00
|
|
|
/* DV subcode: 2nd and 3d DIFs */
|
|
|
|
for (j = 80; j < 80 * 3; j += 80) {
|
|
|
|
for (k = 6; k < 6 * 8; k += 8)
|
2019-11-09 23:56:32 +00:00
|
|
|
dv_write_pack(dv_timecode, c, &buf[j+k], 0, seq);
|
2006-09-15 19:14:24 +00:00
|
|
|
|
|
|
|
if (((long)(buf-frame)/(c->sys->frame_size/(c->sys->difseg_size*c->sys->n_difchan))%c->sys->difseg_size) > 5) { /* FIXME: is this really needed ? */
|
2019-11-09 23:56:32 +00:00
|
|
|
dv_write_pack(dv_video_recdate, c, &buf[j+14], 0, seq);
|
|
|
|
dv_write_pack(dv_video_rectime, c, &buf[j+22], 0, seq);
|
|
|
|
dv_write_pack(dv_video_recdate, c, &buf[j+38], 0, seq);
|
|
|
|
dv_write_pack(dv_video_rectime, c, &buf[j+46], 0, seq);
|
2006-09-15 19:14:24 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* DV VAUX: 4th, 5th and 6th 3DIFs */
|
|
|
|
for (j = 80*3 + 3; j < 80*6; j += 80) {
|
2019-11-09 23:56:32 +00:00
|
|
|
dv_write_pack(dv_video_recdate, c, &buf[j+5* 2], 0, seq);
|
|
|
|
dv_write_pack(dv_video_rectime, c, &buf[j+5* 3], 0, seq);
|
|
|
|
dv_write_pack(dv_video_recdate, c, &buf[j+5*11], 0, seq);
|
|
|
|
dv_write_pack(dv_video_rectime, c, &buf[j+5*12], 0, seq);
|
2006-09-15 19:14:24 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The following 3 functions constitute our interface to the world
|
|
|
|
*/
|
|
|
|
|
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
|
|
|
static int dv_assemble_frame(AVFormatContext *s,
|
|
|
|
DVMuxContext *c, AVStream* st,
|
2011-01-24 23:36:16 +00:00
|
|
|
uint8_t* data, int data_size, uint8_t** frame)
|
2006-09-15 19:14:24 +00:00
|
|
|
{
|
|
|
|
int i, reqasize;
|
|
|
|
|
|
|
|
*frame = &c->frame_buf[0];
|
|
|
|
|
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
|
|
|
switch (st->codecpar->codec_type) {
|
2010-03-30 23:30:55 +00:00
|
|
|
case AVMEDIA_TYPE_VIDEO:
|
2007-06-24 07:45:19 +00:00
|
|
|
/* FIXME: we have to have more sensible approach than this one */
|
2022-01-06 18:19:39 +00:00
|
|
|
if (c->has_video) {
|
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
|
|
|
av_log(s, AV_LOG_ERROR, "Can't process DV frame #%d. Insufficient audio data or severe sync problem.\n", c->frames);
|
2022-01-06 18:19:39 +00:00
|
|
|
return AVERROR(EINVAL);
|
|
|
|
}
|
2015-10-18 21:44:25 +00:00
|
|
|
if (data_size != c->sys->frame_size) {
|
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
|
|
|
av_log(s, AV_LOG_ERROR, "Unexpected frame size, %d != %d\n",
|
2015-10-18 21:44:25 +00:00
|
|
|
data_size, c->sys->frame_size);
|
|
|
|
return AVERROR(ENOSYS);
|
|
|
|
}
|
2006-09-15 19:14:24 +00:00
|
|
|
|
2007-06-24 07:45:19 +00:00
|
|
|
memcpy(*frame, data, c->sys->frame_size);
|
|
|
|
c->has_video = 1;
|
|
|
|
break;
|
2010-03-30 23:30:55 +00:00
|
|
|
case AVMEDIA_TYPE_AUDIO:
|
2007-06-24 07:45:19 +00:00
|
|
|
for (i = 0; i < c->n_ast && st != c->ast[i]; i++);
|
2006-09-15 19:14:24 +00:00
|
|
|
|
|
|
|
/* FIXME: we have to have more sensible approach than this one */
|
2022-01-06 18:25:37 +00:00
|
|
|
if (av_fifo_can_write(c->audio_data[i]) < data_size) {
|
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
|
|
|
av_log(s, AV_LOG_ERROR, "Can't process DV frame #%d. Insufficient video data or severe sync problem.\n", c->frames);
|
2022-01-06 18:19:39 +00:00
|
|
|
return AVERROR(EINVAL);
|
|
|
|
}
|
2022-01-06 18:25:37 +00:00
|
|
|
av_fifo_write(c->audio_data[i], data, data_size);
|
2006-09-15 19:14:24 +00:00
|
|
|
|
2016-04-10 19:58:15 +00:00
|
|
|
reqasize = 4 * dv_audio_frame_size(c->sys, c->frames, st->codecpar->sample_rate);
|
2014-07-16 22:54:34 +00:00
|
|
|
|
2008-07-24 17:09:28 +00:00
|
|
|
/* Let us see if we've got enough audio for one DV frame. */
|
2022-01-06 18:25:37 +00:00
|
|
|
c->has_audio |= ((reqasize <= av_fifo_can_read(c->audio_data[i])) << i);
|
2006-09-15 19:14:24 +00:00
|
|
|
|
2007-06-24 07:45:19 +00:00
|
|
|
break;
|
2006-09-15 19:14:24 +00:00
|
|
|
default:
|
2007-06-24 07:45:19 +00:00
|
|
|
break;
|
2006-09-15 19:14:24 +00:00
|
|
|
}
|
|
|
|
|
2008-07-24 17:09:28 +00:00
|
|
|
/* Let us see if we have enough data to construct one DV frame. */
|
2008-10-24 21:41:27 +00:00
|
|
|
if (c->has_video == 1 && c->has_audio + 1 == 1 << c->n_ast) {
|
2006-09-15 19:14:24 +00:00
|
|
|
dv_inject_metadata(c, *frame);
|
2007-05-16 02:02:22 +00:00
|
|
|
c->has_audio = 0;
|
2008-10-24 21:41:27 +00:00
|
|
|
for (i=0; i < c->n_ast; i++) {
|
2007-06-24 07:45:19 +00:00
|
|
|
dv_inject_audio(c, i, *frame);
|
2016-04-10 19:58:15 +00:00
|
|
|
reqasize = 4 * dv_audio_frame_size(c->sys, c->frames, c->ast[i]->codecpar->sample_rate);
|
2022-01-06 18:25:37 +00:00
|
|
|
av_fifo_drain2(c->audio_data[i], reqasize);
|
|
|
|
c->has_audio |= ((reqasize <= av_fifo_can_read(c->audio_data[i])) << i);
|
2006-09-15 19:14:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
c->has_video = 0;
|
2007-05-16 02:02:22 +00:00
|
|
|
|
2006-09-15 19:14:24 +00:00
|
|
|
c->frames++;
|
|
|
|
|
|
|
|
return c->sys->frame_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-01-24 23:36:16 +00:00
|
|
|
static DVMuxContext* dv_init_mux(AVFormatContext* s)
|
2006-09-15 19:14:24 +00:00
|
|
|
{
|
2007-04-08 20:24:16 +00:00
|
|
|
DVMuxContext *c = s->priv_data;
|
2006-09-15 19:14:24 +00:00
|
|
|
AVStream *vst = NULL;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* we support at most 1 video and 2 audio streams */
|
2019-11-09 23:56:32 +00:00
|
|
|
if (s->nb_streams > 5)
|
2006-09-15 19:14:24 +00:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
/* We have to sort out where audio and where video stream is */
|
|
|
|
for (i=0; i<s->nb_streams; i++) {
|
2020-08-27 15:32:48 +00:00
|
|
|
AVStream *st = s->streams[i];
|
|
|
|
switch (st->codecpar->codec_type) {
|
2010-03-30 23:30:55 +00:00
|
|
|
case AVMEDIA_TYPE_VIDEO:
|
2007-06-24 07:45:19 +00:00
|
|
|
if (vst) return NULL;
|
2020-08-27 15:40:02 +00:00
|
|
|
if (st->codecpar->codec_id != AV_CODEC_ID_DVVIDEO)
|
|
|
|
goto bail_out;
|
2020-08-27 15:32:48 +00:00
|
|
|
vst = st;
|
2007-06-24 07:45:19 +00:00
|
|
|
break;
|
2010-03-30 23:30:55 +00:00
|
|
|
case AVMEDIA_TYPE_AUDIO:
|
2007-06-24 07:45:19 +00:00
|
|
|
if (c->n_ast > 1) return NULL;
|
2020-08-27 15:40:02 +00:00
|
|
|
/* Some checks -- DV format is very picky about its incoming streams */
|
|
|
|
if(st->codecpar->codec_id != AV_CODEC_ID_PCM_S16LE ||
|
|
|
|
st->codecpar->channels != 2)
|
|
|
|
goto bail_out;
|
|
|
|
if (st->codecpar->sample_rate != 48000 &&
|
|
|
|
st->codecpar->sample_rate != 44100 &&
|
|
|
|
st->codecpar->sample_rate != 32000 )
|
|
|
|
goto bail_out;
|
2020-08-27 15:32:48 +00:00
|
|
|
c->ast[c->n_ast++] = st;
|
2007-06-24 07:45:19 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
goto bail_out;
|
|
|
|
}
|
2006-09-15 19:14:24 +00:00
|
|
|
}
|
|
|
|
|
2020-08-27 15:40:02 +00:00
|
|
|
if (!vst)
|
2006-09-15 19:14:24 +00:00
|
|
|
goto bail_out;
|
2020-08-27 15:40:02 +00:00
|
|
|
|
2016-04-10 19:58:15 +00:00
|
|
|
c->sys = av_dv_codec_profile2(vst->codecpar->width, vst->codecpar->height,
|
|
|
|
vst->codecpar->format, vst->time_base);
|
2006-09-15 19:14:24 +00:00
|
|
|
if (!c->sys)
|
|
|
|
goto bail_out;
|
|
|
|
|
2014-07-16 22:54:34 +00:00
|
|
|
if ((c->sys->time_base.den != 25 && c->sys->time_base.den != 50) || c->sys->time_base.num != 1) {
|
2016-04-10 19:58:15 +00:00
|
|
|
if (c->ast[0] && c->ast[0]->codecpar->sample_rate != 48000)
|
2014-07-16 22:54:34 +00:00
|
|
|
goto bail_out;
|
2016-04-10 19:58:15 +00:00
|
|
|
if (c->ast[1] && c->ast[1]->codecpar->sample_rate != 48000)
|
2014-07-16 22:54:34 +00:00
|
|
|
goto bail_out;
|
|
|
|
}
|
|
|
|
|
2019-11-09 23:56:32 +00:00
|
|
|
if (((c->n_ast > 1) && (c->sys->n_difchan < 2)) ||
|
|
|
|
((c->n_ast > 2) && (c->sys->n_difchan < 4))) {
|
|
|
|
/* only 2 stereo pairs allowed in 50Mbps mode */
|
2006-09-15 19:14:24 +00:00
|
|
|
goto bail_out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Ok, everything seems to be in working order */
|
2008-10-24 21:41:27 +00:00
|
|
|
c->frames = 0;
|
|
|
|
c->has_audio = 0;
|
|
|
|
c->has_video = 0;
|
2016-02-06 16:57:21 +00:00
|
|
|
ff_parse_creation_time_metadata(s, &c->start_time, 1);
|
2006-09-15 19:14:24 +00:00
|
|
|
|
2008-10-24 21:41:27 +00:00
|
|
|
for (i=0; i < c->n_ast; i++) {
|
2022-01-06 18:25:37 +00:00
|
|
|
if (!c->ast[i])
|
|
|
|
continue;
|
|
|
|
c->audio_data[i] = av_fifo_alloc2(100 * MAX_AUDIO_FRAME_SIZE, 1, 0);
|
|
|
|
if (!c->audio_data[i])
|
2006-09-15 19:14:24 +00:00
|
|
|
goto bail_out;
|
|
|
|
}
|
|
|
|
|
|
|
|
return c;
|
|
|
|
|
|
|
|
bail_out:
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int dv_write_header(AVFormatContext *s)
|
|
|
|
{
|
2012-01-16 12:43:42 +00:00
|
|
|
AVRational rate;
|
2011-07-06 13:08:28 +00:00
|
|
|
DVMuxContext *dvc = s->priv_data;
|
2012-05-30 08:26:53 +00:00
|
|
|
AVDictionaryEntry *tcr = av_dict_get(s->metadata, "timecode", NULL, 0);
|
2011-07-06 13:08:28 +00:00
|
|
|
|
2006-11-08 18:57:02 +00:00
|
|
|
if (!dv_init_mux(s)) {
|
2006-09-15 19:14:24 +00:00
|
|
|
av_log(s, AV_LOG_ERROR, "Can't initialize DV format!\n"
|
|
|
|
"Make sure that you supply exactly two streams:\n"
|
2014-07-16 22:54:34 +00:00
|
|
|
" video: 25fps or 29.97fps, audio: 2ch/48|44|32kHz/PCM\n"
|
2006-09-15 19:14:24 +00:00
|
|
|
" (50Mbps allows an optional second audio stream)\n");
|
|
|
|
return -1;
|
|
|
|
}
|
2012-01-16 12:43:42 +00:00
|
|
|
rate.num = dvc->sys->ltc_divisor;
|
|
|
|
rate.den = 1;
|
2012-05-30 08:26:53 +00:00
|
|
|
if (!tcr) { // no global timecode, look into the streams
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < s->nb_streams; i++) {
|
|
|
|
tcr = av_dict_get(s->streams[i]->metadata, "timecode", NULL, 0);
|
|
|
|
if (tcr)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2013-02-05 21:57:35 +00:00
|
|
|
if (tcr && av_timecode_init_from_string(&dvc->tc, rate, tcr->value, s) >= 0)
|
|
|
|
return 0;
|
2012-01-16 12:43:42 +00:00
|
|
|
return av_timecode_init(&dvc->tc, rate, 0, 0, s);
|
2006-09-15 19:14:24 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int dv_write_packet(struct AVFormatContext *s, AVPacket *pkt)
|
|
|
|
{
|
|
|
|
uint8_t* frame;
|
|
|
|
int fsize;
|
|
|
|
|
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
|
|
|
fsize = dv_assemble_frame(s, s->priv_data, s->streams[pkt->stream_index],
|
2006-09-15 19:14:24 +00:00
|
|
|
pkt->data, pkt->size, &frame);
|
2020-06-12 13:06:25 +00:00
|
|
|
if (fsize < 0) {
|
|
|
|
return fsize;
|
2006-09-15 19:14:24 +00:00
|
|
|
}
|
2020-06-12 13:06:25 +00:00
|
|
|
avio_write(s->pb, frame, fsize);
|
2006-09-15 19:14:24 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We might end up with some extra A/V data without matching counterpart.
|
|
|
|
* E.g. video data without enough audio to write the complete frame.
|
|
|
|
* Currently we simply drop the last frame. I don't know whether this
|
|
|
|
* is the best strategy of all
|
|
|
|
*/
|
2020-01-26 06:40:50 +00:00
|
|
|
static void dv_deinit(AVFormatContext *s)
|
2006-09-15 19:14:24 +00:00
|
|
|
{
|
2020-01-26 06:40:50 +00:00
|
|
|
DVMuxContext *c = s->priv_data;
|
|
|
|
|
|
|
|
for (int i = 0; i < c->n_ast; i++)
|
2022-01-06 18:25:37 +00:00
|
|
|
av_fifo_freep2(&c->audio_data[i]);
|
2006-09-15 19:14:24 +00:00
|
|
|
}
|
|
|
|
|
2021-04-19 17:45:24 +00:00
|
|
|
const AVOutputFormat ff_dv_muxer = {
|
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
|
|
|
.extensions = "dv",
|
|
|
|
.priv_data_size = sizeof(DVMuxContext),
|
2012-08-05 09:11:04 +00:00
|
|
|
.audio_codec = AV_CODEC_ID_PCM_S16LE,
|
|
|
|
.video_codec = AV_CODEC_ID_DVVIDEO,
|
2011-07-16 20:18:12 +00:00
|
|
|
.write_header = dv_write_header,
|
|
|
|
.write_packet = dv_write_packet,
|
2020-01-26 06:40:50 +00:00
|
|
|
.deinit = dv_deinit,
|
2006-09-15 19:14:24 +00:00
|
|
|
};
|