FFmpeg: libavformat/dvenc.c Source File

FFmpeg

[フレーム]

libavformat

dvenc.c

Go to the documentation of this file.

1 /*

2 * General DV muxer/demuxer

4 *

5 * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth

6 * of DV technical info.

7 *

8 * Raw DV format

10 *

11 * 50 Mbps (DVCPRO50) support

13 *

14 * This file is part of FFmpeg.

15 *

16 * FFmpeg is free software; you can redistribute it and/or

17 * modify it under the terms of the GNU Lesser General Public

18 * License as published by the Free Software Foundation; either

19 * version 2.1 of the License, or (at your option) any later version.

20 *

21 * FFmpeg is distributed in the hope that it will be useful,

22 * but WITHOUT ANY WARRANTY; without even the implied warranty of

23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

24 * Lesser General Public License for more details.

25 *

26 * You should have received a copy of the GNU Lesser General Public

27 * License along with FFmpeg; if not, write to the Free Software

28 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

29 */

30 #include <time.h>

32 #include "libavutil/time_internal.h"

33 #include "avformat.h"

34 #include "internal.h"

35 #include "libavcodec/dv_profile.h"

36 #include "libavcodec/dv.h"

37 #include "dv.h"

38 #include "libavutil/avassert.h"

39 #include "libavutil/fifo.h"

40 #include "libavutil/mathematics.h"

41 #include "libavutil/intreadwrite.h"

42 #include "libavutil/opt.h"

43 #include "libavutil/timecode.h"

45 #define MAX_AUDIO_FRAME_SIZE 192000 // 1 second of 48khz 32-bit audio

47 struct DVMuxContext {

48 AVClass *av_class;

49 const AVDVProfile* sys; /* current DV profile, e.g.: 525/60, 625/50 */

50 int n_ast; /* number of stereo audio streams (up to 2) */

51 AVStream *ast[4]; /* stereo audio streams */

52 AVFifoBuffer *audio_data[4]; /* FIFO for storing excessive amounts of PCM */

53 int frames; /* current frame number */

54 int64_t start_time; /* recording start time */

55 int has_audio; /* frame under construction has audio */

56 int has_video; /* frame under construction has video */

57 uint8_t frame_buf[DV_MAX_FRAME_SIZE]; /* frame under construction */

58 AVTimecode tc; /* timecode context */

59 };

61 static const int dv_aaux_packs_dist[12][9] = {

62 { 0xff, 0xff, 0xff, 0x50, 0x51, 0x52, 0x53, 0xff, 0xff },

63 { 0x50, 0x51, 0x52, 0x53, 0xff, 0xff, 0xff, 0xff, 0xff },

64 { 0xff, 0xff, 0xff, 0x50, 0x51, 0x52, 0x53, 0xff, 0xff },

65 { 0x50, 0x51, 0x52, 0x53, 0xff, 0xff, 0xff, 0xff, 0xff },

66 { 0xff, 0xff, 0xff, 0x50, 0x51, 0x52, 0x53, 0xff, 0xff },

67 { 0x50, 0x51, 0x52, 0x53, 0xff, 0xff, 0xff, 0xff, 0xff },

68 { 0xff, 0xff, 0xff, 0x50, 0x51, 0x52, 0x53, 0xff, 0xff },

69 { 0x50, 0x51, 0x52, 0x53, 0xff, 0xff, 0xff, 0xff, 0xff },

70 { 0xff, 0xff, 0xff, 0x50, 0x51, 0x52, 0x53, 0xff, 0xff },

71 { 0x50, 0x51, 0x52, 0x53, 0xff, 0xff, 0xff, 0xff, 0xff },

72 { 0xff, 0xff, 0xff, 0x50, 0x51, 0x52, 0x53, 0xff, 0xff },

73 { 0x50, 0x51, 0x52, 0x53, 0xff, 0xff, 0xff, 0xff, 0xff },

74 };

76 static void brktimegm(time_t secs, struct tm *tm)

77 {

78 tm = gmtime_r(&secs, tm);

80 tm->tm_year += 1900; /* unlike gmtime_r we store complete year here */

81 tm->tm_mon += 1; /* unlike gmtime_r tm_mon is from 1 to 12 */

82 }

84 static int dv_audio_frame_size(const AVDVProfile* sys, int frame, int sample_rate)

85 {

86 if ((sys->time_base.den == 25 || sys->time_base.den == 50) && sys->time_base.num == 1) {

87 if (sample_rate == 32000) return 1280;

88 else if (sample_rate == 44100) return 1764;

89 else return 1920;

90 }

92 av_assert0(sample_rate == 48000);

94 return sys->audio_samples_dist[frame % (sizeof(sys->audio_samples_dist) /

95 sizeof(sys->audio_samples_dist[0]))];

96 }

98 static int dv_write_pack(enum dv_pack_type pack_id, DVMuxContext *c, uint8_t* buf, int channel, int seq)

99 {

100 struct tm tc;

101 time_t ct;

102 uint32_t timecode;

103 int audio_type = 0;

104

105 buf[0] = (uint8_t)pack_id;

106 switch (pack_id) {

107 case dv_timecode:

108 timecode = av_timecode_get_smpte_from_framenum(&c->tc, c->frames);

109 timecode |= 1<<23 | 1<<15 | 1<<7 | 1<<6; // biphase and binary group flags

110 AV_WB32(buf + 1, timecode);

111 break;

112 case dv_audio_source: /* AAUX source pack */

113 if (c->ast[channel]->codecpar->sample_rate == 44100) {

114 audio_type = 1;

115 } else if (c->ast[channel]->codecpar->sample_rate == 32000)

116 audio_type = 2;

117 buf[1] = (1 << 7) | /* locked mode -- SMPTE only supports locked mode */

118 (1 << 6) | /* reserved -- always 1 */

119 (dv_audio_frame_size(c->sys, c->frames, c->ast[channel]->codecpar->sample_rate) -

120 c->sys->audio_min_samples[audio_type]);

121 /* # of samples */

122 buf[2] = (0 << 7) | /* multi-stereo */

123 (0 << 5) | /* #of audio channels per block: 0 -- 1 channel */

124 (0 << 4) | /* pair bit: 0 -- one pair of channels */

125 (seq >= c->sys->difseg_size/2); /* audio mode (1st or 2nd channel) */

126 buf[3] = (1 << 7) | /* res */

127 (1 << 6) | /* multi-language flag */

128 (c->sys->dsf << 5) | /* system: 60fields/50fields */

129 (DV_PROFILE_IS_HD(c->sys) ? 0x3 : c->sys->video_stype ? 2 : 0); /* stype */

130 buf[4] = (1 << 7) | /* emphasis: 1 -- off */

131 (0 << 6) | /* emphasis time constant: 0 -- reserved */

132 (audio_type << 3) | /* frequency: 0 -- 48kHz, 1 -- 44,1kHz, 2 -- 32kHz */

133 0; /* quantization: 0 -- 16-bit linear, 1 -- 12-bit nonlinear */

134

135 break;

136 case dv_audio_control:

137 buf[1] = (0 << 6) | /* copy protection: 0 -- unrestricted */

138 (1 << 4) | /* input source: 1 -- digital input */

139 (3 << 2) | /* compression: 3 -- no information */

140 0; /* misc. info/SMPTE emphasis off */

141 buf[2] = (1 << 7) | /* recording start point: 1 -- no */

142 (1 << 6) | /* recording end point: 1 -- no */

143 (1 << 3) | /* recording mode: 1 -- original */

144 7;

145 buf[3] = (1 << 7) | /* direction: 1 -- forward */

146 (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0x20 : /* speed */

147 c->sys->ltc_divisor * 4);

148 buf[4] = (1 << 7) | /* reserved -- always 1 */

149 0x7f; /* genre category */

150 break;

151 case dv_audio_recdate:

152 case dv_video_recdate: /* VAUX recording date */

153 ct = c->start_time + av_rescale_rnd(c->frames, c->sys->time_base.num,

154 c->sys->time_base.den, AV_ROUND_DOWN);

155 brktimegm(ct, &tc);

156 buf[1] = 0xff; /* ds, tm, tens of time zone, units of time zone */

157 /* 0xff is very likely to be "unknown" */

158 buf[2] = (3 << 6) | /* reserved -- always 1 */

159 ((tc.tm_mday / 10) << 4) | /* Tens of day */

160 (tc.tm_mday % 10); /* Units of day */

161 buf[3] = /* we set high 4 bits to 0, shouldn't we set them to week? */

162 ((tc.tm_mon / 10) << 4) | /* Tens of month */

163 (tc.tm_mon % 10); /* Units of month */

164 buf[4] = (((tc.tm_year % 100) / 10) << 4) | /* Tens of year */

165 (tc.tm_year % 10); /* Units of year */

166 break;

167 case dv_audio_rectime: /* AAUX recording time */

168 case dv_video_rectime: /* VAUX recording time */

169 ct = c->start_time + av_rescale_rnd(c->frames, c->sys->time_base.num,

170 c->sys->time_base.den, AV_ROUND_DOWN);

171 brktimegm(ct, &tc);

172 buf[1] = (3 << 6) | /* reserved -- always 1 */

173 0x3f; /* tens of frame, units of frame: 0x3f - "unknown" ? */

174 buf[2] = (1 << 7) | /* reserved -- always 1 */

175 ((tc.tm_sec / 10) << 4) | /* Tens of seconds */

176 (tc.tm_sec % 10); /* Units of seconds */

177 buf[3] = (1 << 7) | /* reserved -- always 1 */

178 ((tc.tm_min / 10) << 4) | /* Tens of minutes */

179 (tc.tm_min % 10); /* Units of minutes */

180 buf[4] = (3 << 6) | /* reserved -- always 1 */

181 ((tc.tm_hour / 10) << 4) | /* Tens of hours */

182 (tc.tm_hour % 10); /* Units of hours */

183 break;

184 default:

185 buf[1] = buf[2] = buf[3] = buf[4] = 0xff;

186 }

187 return 5;

188 }

189

190 static void dv_inject_audio(DVMuxContext *c, int channel, uint8_t* frame_ptr)

191 {

192 int i, j, d, of, size;

193 size = 4 * dv_audio_frame_size(c->sys, c->frames, c->ast[channel]->codecpar->sample_rate);

194 frame_ptr += channel * c->sys->difseg_size * 150 * 80;

195 for (i = 0; i < c->sys->difseg_size; i++) {

196 frame_ptr += 6 * 80; /* skip DIF segment header */

197 for (j = 0; j < 9; j++) {

198 dv_write_pack(dv_aaux_packs_dist[i][j], c, &frame_ptr[3], channel, i);

199 for (d = 8; d < 80; d+=2) {

200 of = c->sys->audio_shuffle[i][j] + (d - 8)/2 * c->sys->audio_stride;

201 if (of*2 >= size)

202 continue;

203

204 frame_ptr[d] = *av_fifo_peek2(c->audio_data[channel], of*2+1); // FIXME: maybe we have to admit

205 frame_ptr[d+1] = *av_fifo_peek2(c->audio_data[channel], of*2); // that DV is a big-endian PCM

206 }

207 frame_ptr += 16 * 80; /* 15 Video DIFs + 1 Audio DIF */

208 }

209 }

210 }

211

212 static void dv_inject_metadata(DVMuxContext *c, uint8_t* frame)

213 {

214 int j, k;

215 uint8_t* buf;

216 int seq = 0;

217

218 for (buf = frame; buf < frame + c->sys->frame_size; buf += 150 * 80, seq++) {

219 /* DV subcode: 2nd and 3d DIFs */

220 for (j = 80; j < 80 * 3; j += 80) {

221 for (k = 6; k < 6 * 8; k += 8)

222 dv_write_pack(dv_timecode, c, &buf[j+k], 0, seq);

223

224 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 ? */

225 dv_write_pack(dv_video_recdate, c, &buf[j+14], 0, seq);

226 dv_write_pack(dv_video_rectime, c, &buf[j+22], 0, seq);

227 dv_write_pack(dv_video_recdate, c, &buf[j+38], 0, seq);

228 dv_write_pack(dv_video_rectime, c, &buf[j+46], 0, seq);

229 }

230 }

231

232 /* DV VAUX: 4th, 5th and 6th 3DIFs */

233 for (j = 80*3 + 3; j < 80*6; j += 80) {

234 dv_write_pack(dv_video_recdate, c, &buf[j+5* 2], 0, seq);

235 dv_write_pack(dv_video_rectime, c, &buf[j+5* 3], 0, seq);

236 dv_write_pack(dv_video_recdate, c, &buf[j+5*11], 0, seq);

237 dv_write_pack(dv_video_rectime, c, &buf[j+5*12], 0, seq);

238 }

239 }

240 }

241

242 /*

243 * The following 3 functions constitute our interface to the world

244 */

245

246 static int dv_assemble_frame(AVFormatContext *s,

247 DVMuxContext *c, AVStream* st,

248 uint8_t* data, int data_size, uint8_t** frame)

249 {

250 int i, reqasize;

251

252 *frame = &c->frame_buf[0];

253

254 switch (st->codecpar->codec_type) {

255 case AVMEDIA_TYPE_VIDEO:

256 /* FIXME: we have to have more sensible approach than this one */

257 if (c->has_video)

258 av_log(s, AV_LOG_ERROR, "Can't process DV frame #%d. Insufficient audio data or severe sync problem.\n", c->frames);

259 if (data_size != c->sys->frame_size) {

260 av_log(s, AV_LOG_ERROR, "Unexpected frame size, %d != %d\n",

261 data_size, c->sys->frame_size);

262 return AVERROR(ENOSYS);

263 }

264

265 memcpy(*frame, data, c->sys->frame_size);

266 c->has_video = 1;

267 break;

268 case AVMEDIA_TYPE_AUDIO:

269 for (i = 0; i < c->n_ast && st != c->ast[i]; i++);

270

271 /* FIXME: we have to have more sensible approach than this one */

272 if (av_fifo_size(c->audio_data[i]) + data_size >= 100*MAX_AUDIO_FRAME_SIZE)

273 av_log(s, AV_LOG_ERROR, "Can't process DV frame #%d. Insufficient video data or severe sync problem.\n", c->frames);

274 av_fifo_generic_write(c->audio_data[i], data, data_size, NULL);

275

276 reqasize = 4 * dv_audio_frame_size(c->sys, c->frames, st->codecpar->sample_rate);

277

278 /* Let us see if we've got enough audio for one DV frame. */

279 c->has_audio |= ((reqasize <= av_fifo_size(c->audio_data[i])) << i);

280

281 break;

282 default:

283 break;

284 }

285

286 /* Let us see if we have enough data to construct one DV frame. */

287 if (c->has_video == 1 && c->has_audio + 1 == 1 << c->n_ast) {

288 dv_inject_metadata(c, *frame);

289 c->has_audio = 0;

290 for (i=0; i < c->n_ast; i++) {

291 dv_inject_audio(c, i, *frame);

292 reqasize = 4 * dv_audio_frame_size(c->sys, c->frames, c->ast[i]->codecpar->sample_rate);

293 av_fifo_drain(c->audio_data[i], reqasize);

294 c->has_audio |= ((reqasize <= av_fifo_size(c->audio_data[i])) << i);

295 }

296

297 c->has_video = 0;

298

299 c->frames++;

300

301 return c->sys->frame_size;

302 }

303

304 return 0;

305 }

306

307 static DVMuxContext* dv_init_mux(AVFormatContext* s)

308 {

309 DVMuxContext *c = s->priv_data;

310 AVStream *vst = NULL;

311 int i;

312

313 /* we support at most 1 video and 2 audio streams */

314 if (s->nb_streams > 5)

315 return NULL;

316

317 /* We have to sort out where audio and where video stream is */

318 for (i=0; i<s->nb_streams; i++) {

319 AVStream *st = s->streams[i];

320 switch (st->codecpar->codec_type) {

321 case AVMEDIA_TYPE_VIDEO:

322 if (vst) return NULL;

323 if (st->codecpar->codec_id != AV_CODEC_ID_DVVIDEO)

324 goto bail_out;

325 vst = st;

326 break;

327 case AVMEDIA_TYPE_AUDIO:

328 if (c->n_ast > 1) return NULL;

329 /* Some checks -- DV format is very picky about its incoming streams */

330 if(st->codecpar->codec_id != AV_CODEC_ID_PCM_S16LE ||

331 st->codecpar->channels != 2)

332 goto bail_out;

333 if (st->codecpar->sample_rate != 48000 &&

334 st->codecpar->sample_rate != 44100 &&

335 st->codecpar->sample_rate != 32000 )

336 goto bail_out;

337 c->ast[c->n_ast++] = st;

338 break;

339 default:

340 goto bail_out;

341 }

342 }

343

344 if (!vst)

345 goto bail_out;

346

347 c->sys = av_dv_codec_profile2(vst->codecpar->width, vst->codecpar->height,

348 vst->codecpar->format, vst->time_base);

349 if (!c->sys)

350 goto bail_out;

351

352 if ((c->sys->time_base.den != 25 && c->sys->time_base.den != 50) || c->sys->time_base.num != 1) {

353 if (c->ast[0] && c->ast[0]->codecpar->sample_rate != 48000)

354 goto bail_out;

355 if (c->ast[1] && c->ast[1]->codecpar->sample_rate != 48000)

356 goto bail_out;

357 }

358

359 if (((c->n_ast > 1) && (c->sys->n_difchan < 2)) ||

360 ((c->n_ast > 2) && (c->sys->n_difchan < 4))) {

361 /* only 2 stereo pairs allowed in 50Mbps mode */

362 goto bail_out;

363 }

364

365 /* Ok, everything seems to be in working order */

366 c->frames = 0;

367 c->has_audio = 0;

368 c->has_video = 0;

369 ff_parse_creation_time_metadata(s, &c->start_time, 1);

370

371 for (i=0; i < c->n_ast; i++) {

372 if (c->ast[i] && !(c->audio_data[i]=av_fifo_alloc_array(100, MAX_AUDIO_FRAME_SIZE))) {

373 goto bail_out;

374 }

375 }

376

377 return c;

378

379 bail_out:

380 return NULL;

381 }

382

383 static int dv_write_header(AVFormatContext *s)

384 {

385 AVRational rate;

386 DVMuxContext *dvc = s->priv_data;

387 AVDictionaryEntry *tcr = av_dict_get(s->metadata, "timecode", NULL, 0);

388

389 if (!dv_init_mux(s)) {

390 av_log(s, AV_LOG_ERROR, "Can't initialize DV format!\n"

391 "Make sure that you supply exactly two streams:\n"

392 " video: 25fps or 29.97fps, audio: 2ch/48|44|32kHz/PCM\n"

393 " (50Mbps allows an optional second audio stream)\n");

394 return -1;

395 }

396 rate.num = dvc->sys->ltc_divisor;

397 rate.den = 1;

398 if (!tcr) { // no global timecode, look into the streams

399 int i;

400 for (i = 0; i < s->nb_streams; i++) {

401 tcr = av_dict_get(s->streams[i]->metadata, "timecode", NULL, 0);

402 if (tcr)

403 break;

404 }

405 }

406 if (tcr && av_timecode_init_from_string(&dvc->tc, rate, tcr->value, s) >= 0)

407 return 0;

408 return av_timecode_init(&dvc->tc, rate, 0, 0, s);

409 }

410

411 static int dv_write_packet(struct AVFormatContext *s, AVPacket *pkt)

412 {

413 uint8_t* frame;

414 int fsize;

415

416 fsize = dv_assemble_frame(s, s->priv_data, s->streams[pkt->stream_index],

417 pkt->data, pkt->size, &frame);

418 if (fsize < 0) {

419 return fsize;

420 }

421 avio_write(s->pb, frame, fsize);

422 return 0;

423 }

424

425 /*

426 * We might end up with some extra A/V data without matching counterpart.

427 * E.g. video data without enough audio to write the complete frame.

428 * Currently we simply drop the last frame. I don't know whether this

429 * is the best strategy of all

430 */

431 static void dv_deinit(AVFormatContext *s)

432 {

433 DVMuxContext *c = s->priv_data;

434

435 for (int i = 0; i < c->n_ast; i++)

436 av_fifo_freep(&c->audio_data[i]);

437 }

438

439 const AVOutputFormat ff_dv_muxer = {

440 .name = "dv",

441 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),

442 .extensions = "dv",

443 .priv_data_size = sizeof(DVMuxContext),

444 .audio_codec = AV_CODEC_ID_PCM_S16LE,

445 .video_codec = AV_CODEC_ID_DVVIDEO,

446 .write_header = dv_write_header,

447 .write_packet = dv_write_packet,

448 .deinit = dv_deinit,

449 };

AV_CODEC_ID_PCM_S16LE

@ AV_CODEC_ID_PCM_S16LE

Definition: codec_id.h:314

dv_aaux_packs_dist

static const int dv_aaux_packs_dist[12][9]

Definition: dvenc.c:61

brktimegm

static void brktimegm(time_t secs, struct tm *tm)

Definition: dvenc.c:76

AVOutputFormat::name

const char * name

Definition: avformat.h:504

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

opt.h

DVMuxContext::sys

const AVDVProfile * sys

Definition: dvenc.c:49

DVMuxContext::frames

int frames

Definition: dvenc.c:53

AVCodecParameters::codec_type

enum AVMediaType codec_type

General type of the encoded data.

Definition: codec_par.h:56

ff_dv_muxer

const AVOutputFormat ff_dv_muxer

Definition: dvenc.c:439

dv_audio_frame_size

static int dv_audio_frame_size(const AVDVProfile *sys, int frame, int sample_rate)

Definition: dvenc.c:84

av_fifo_generic_write

int av_fifo_generic_write(AVFifoBuffer *f, void *src, int size, int(*func)(void *, void *, int))

Feed data from a user-supplied callback to an AVFifoBuffer.

Definition: fifo.c:122

DVMuxContext

Definition: dvenc.c:47

DVMuxContext::n_ast

int n_ast

Definition: dvenc.c:50

deinit

static void deinit(AVFormatContext *s)

Definition: chromaprint.c:50

dv_init_mux

static DVMuxContext * dv_init_mux(AVFormatContext *s)

Definition: dvenc.c:307

AVPacket::data

uint8_t * data

Definition: packet.h:373

data

const char data[16]

Definition: mxf.c:143

ff_parse_creation_time_metadata

int ff_parse_creation_time_metadata(AVFormatContext *s, int64_t *timestamp, int return_seconds)

Parse creation_time in AVFormatContext metadata if exists and warn if the parsing fails.

Definition: utils.c:1866

dv_deinit

static void dv_deinit(AVFormatContext *s)

Definition: dvenc.c:431

DVMuxContext::has_video

int has_video

Definition: dvenc.c:56

mathematics.h

dv_audio_source

@ dv_audio_source

Definition: dv.h:73

sample_rate

Definition: ffmpeg_filter.c:153

av_fifo_drain

void av_fifo_drain(AVFifoBuffer *f, int size)

Discard data from the FIFO.

Definition: fifo.c:233

dv_write_packet

static int dv_write_packet(struct AVFormatContext *s, AVPacket *pkt)

Definition: dvenc.c:411

AVFifoBuffer

Definition: fifo.h:31

AVCodecParameters::channels

int channels

Audio only.

Definition: codec_par.h:166

fifo.h

timecode.h

gmtime_r

#define gmtime_r

Definition: time_internal.h:34

dv_profile.h

AVRational::num

int num

Numerator.

Definition: rational.h:59

avassert.h

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

av_timecode_init

int av_timecode_init(AVTimecode *tc, AVRational rate, int flags, int frame_start, void *log_ctx)

Init a timecode struct with the passed parameters.

Definition: timecode.c:219

av_dict_get

AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)

Get a dictionary entry with matching key.

Definition: dict.c:40

dv_pack_type

Definition: dv.h:69

intreadwrite.h

#define s(width, name)

Definition: cbs_vp9.c:257

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

AVCodecParameters::width

int width

Video only.

Definition: codec_par.h:126

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:37

DVMuxContext::has_audio

int has_audio

Definition: dvenc.c:55

AV_PIX_FMT_YUV420P

@ AV_PIX_FMT_YUV420P

planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)

Definition: pixfmt.h:66

fsize

static int64_t fsize(FILE *f)

Definition: audiomatch.c:29

dv_audio_control

@ dv_audio_control

Definition: dv.h:74

time_internal.h

if(ret)

Definition: filter_design.txt:179

AVFormatContext

Format I/O context.

Definition: avformat.h:1200

internal.h

AVStream::codecpar

AVCodecParameters * codecpar

Codec parameters associated with this stream.

Definition: avformat.h:1095

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:66

AVStream::time_base

AVRational time_base

This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.

Definition: avformat.h:965

NULL

#define NULL

Definition: coverity.c:32

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

dv_audio_recdate

@ dv_audio_recdate

Definition: dv.h:75

time.h

MAX_AUDIO_FRAME_SIZE

#define MAX_AUDIO_FRAME_SIZE

Definition: dvenc.c:45

dv_write_pack

static int dv_write_pack(enum dv_pack_type pack_id, DVMuxContext *c, uint8_t *buf, int channel, int seq)

Definition: dvenc.c:98

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

AVCodecParameters::sample_rate

int sample_rate

Audio only.

Definition: codec_par.h:170

AV_WB32

#define AV_WB32(p, v)

Definition: intreadwrite.h:419

av_rescale_rnd

int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd)

Rescale a 64-bit integer with specified rounding.

Definition: mathematics.c:57

dv.h

AVPacket::size

int size

Definition: packet.h:374

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.

Definition: internal.h:117

size

int size

Definition: twinvq_data.h:10344

DV_MAX_FRAME_SIZE

#define DV_MAX_FRAME_SIZE

largest possible DV frame, in bytes (1080i50)

Definition: dv.h:92

avio_write

void avio_write(AVIOContext *s, const unsigned char *buf, int size)

Definition: aviobuf.c:232

av_fifo_peek2

static uint8_t * av_fifo_peek2(const AVFifoBuffer *f, int offs)

Return a pointer to the data stored in a FIFO buffer at a certain offset.

Definition: fifo.h:169

dv_audio_rectime

@ dv_audio_rectime

Definition: dv.h:76

dv_inject_audio

static void dv_inject_audio(DVMuxContext *c, int channel, uint8_t *frame_ptr)

Definition: dvenc.c:190

DVMuxContext::audio_data

AVFifoBuffer * audio_data[4]

Definition: dvenc.c:52

DV_PROFILE_IS_HD

#define DV_PROFILE_IS_HD(p)

Definition: dv.h:84

AVDVProfile::audio_samples_dist

int audio_samples_dist[5]

Definition: dv_profile.h:55

write_packet

static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)

Definition: ffmpeg.c:727

av_timecode_get_smpte_from_framenum

uint32_t av_timecode_get_smpte_from_framenum(const AVTimecode *tc, int framenum)

Convert frame number to SMPTE 12M binary representation.

Definition: timecode.c:52

AVDVProfile::ltc_divisor

int ltc_divisor

Definition: dv_profile.h:45

dv_inject_metadata

static void dv_inject_metadata(DVMuxContext *c, uint8_t *frame)

Definition: dvenc.c:212

AVOutputFormat

Definition: avformat.h:503

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:271

AVCodecParameters::height

int height

Definition: codec_par.h:127

av_fifo_alloc_array

AVFifoBuffer * av_fifo_alloc_array(size_t nmemb, size_t size)

Initialize an AVFifoBuffer.

Definition: fifo.c:49

AV_ROUND_DOWN

@ AV_ROUND_DOWN

Round toward -infinity.

Definition: mathematics.h:82

AV_CODEC_ID_DVVIDEO

@ AV_CODEC_ID_DVVIDEO

Definition: codec_id.h:74

dv_video_recdate

@ dv_video_recdate

Definition: dv.h:79

dv_timecode

@ dv_timecode

Definition: dv.h:72

AVStream

Stream structure.

Definition: avformat.h:935

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

DVMuxContext::ast

AVStream * ast[4]

Definition: dvenc.c:51

avformat.h

DVMuxContext::start_time

int64_t start_time

Definition: dvenc.c:54

dv_write_header

static int dv_write_header(AVFormatContext *s)

Definition: dvenc.c:383

AVRational::den