FFmpeg  4.4.5
gxfenc.c
Go to the documentation of this file.
1 /*
2  * GXF muxer.
3  * Copyright (c) 2006 SmartJog S.A., Baptiste Coudurier <baptiste dot coudurier at smartjog dot com>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "libavutil/avassert.h"
23 #include "libavutil/intfloat.h"
24 #include "libavutil/opt.h"
25 #include "libavutil/mathematics.h"
26 #include "libavutil/timecode.h"
27 #include "avformat.h"
28 #include "internal.h"
29 #include "gxf.h"
30 
31 #define GXF_SAMPLES_PER_FRAME 32768
32 #define GXF_AUDIO_PACKET_SIZE 65536
33 
34 #define GXF_TIMECODE(c, d, h, m, s, f) \
35  ((c) << 30 | (d) << 29 | (h) << 24 | (m) << 16 | (s) << 8 | (f))
36 
37 typedef struct GXFTimecode{
38  int hh;
39  int mm;
40  int ss;
41  int ff;
42  int color;
43  int drop;
44 } GXFTimecode;
45 
46 typedef struct GXFStreamContext {
48  uint32_t track_type;
49  uint32_t sample_size;
50  uint32_t sample_rate;
51  uint16_t media_type;
52  uint16_t media_info;
55  int fields;
56  int iframes;
57  int pframes;
58  int bframes;
59  int p_per_gop;
60  int b_per_i_or_p; ///< number of B-frames per I-frame or P-frame
62  unsigned order; ///< interleaving order
64 
65 typedef struct GXFContext {
67  uint32_t nb_fields;
68  uint16_t audio_tracks;
69  uint16_t mpeg_tracks;
71  uint32_t umf_start_offset;
72  uint32_t umf_track_offset;
73  uint32_t umf_media_offset;
74  uint32_t umf_length;
75  uint16_t umf_track_size;
76  uint16_t umf_media_size;
78  int flags;
80  unsigned *flt_entries; ///< offsets of packets /1024, starts after 2nd video field
81  unsigned flt_entries_nb;
82  uint64_t *map_offsets; ///< offset of map packets
83  unsigned map_offsets_nb;
84  unsigned packet_count;
86 } GXFContext;
87 
88 static const struct {
89  int height, index;
90 } gxf_lines_tab[] = {
91  { 480, 1 }, /* NTSC */
92  { 512, 1 }, /* NTSC + VBI */
93  { 576, 2 }, /* PAL */
94  { 608, 2 }, /* PAL + VBI */
95  { 1080, 4 },
96  { 720, 6 },
97 };
98 
99 static const AVCodecTag gxf_media_types[] = {
100  { AV_CODEC_ID_MJPEG , 3 }, /* NTSC */
101  { AV_CODEC_ID_MJPEG , 4 }, /* PAL */
102  { AV_CODEC_ID_PCM_S24LE , 9 },
103  { AV_CODEC_ID_PCM_S16LE , 10 },
104  { AV_CODEC_ID_MPEG2VIDEO, 11 }, /* NTSC */
105  { AV_CODEC_ID_MPEG2VIDEO, 12 }, /* PAL */
106  { AV_CODEC_ID_DVVIDEO , 13 }, /* NTSC */
107  { AV_CODEC_ID_DVVIDEO , 14 }, /* PAL */
108  { AV_CODEC_ID_DVVIDEO , 15 }, /* 50M NTSC */
109  { AV_CODEC_ID_DVVIDEO , 16 }, /* 50M PAL */
110  { AV_CODEC_ID_AC3 , 17 },
111  //{ AV_CODEC_ID_NONE, , 18 }, /* Non compressed 24 bit audio */
112  { AV_CODEC_ID_MPEG2VIDEO, 20 }, /* MPEG HD */
113  { AV_CODEC_ID_MPEG1VIDEO, 22 }, /* NTSC */
114  { AV_CODEC_ID_MPEG1VIDEO, 23 }, /* PAL */
115  { AV_CODEC_ID_NONE, 0 },
116 };
117 
118 #define SERVER_PATH "EXT:/PDR/default/"
119 #define ES_NAME_PATTERN "EXT:/PDR/default/ES."
120 
122 {
123  GXFStreamContext *sc = st->priv_data;
124  int i;
125 
126  for (i = 0; i < 6; ++i) {
127  if (st->codecpar->height == gxf_lines_tab[i].height) {
128  sc->lines_index = gxf_lines_tab[i].index;
129  return 0;
130  }
131  }
132  return -1;
133 }
134 
135 static void gxf_write_padding(AVIOContext *pb, int64_t to_pad)
136 {
137  for (; to_pad > 0; to_pad--) {
138  avio_w8(pb, 0);
139  }
140 }
141 
143 {
144  int64_t curpos;
145  int size;
146 
147  size = avio_tell(pb) - pos;
148  if (size % 4) {
149  gxf_write_padding(pb, 4 - size % 4);
150  size = avio_tell(pb) - pos;
151  }
152  curpos = avio_tell(pb);
153  avio_seek(pb, pos + 6, SEEK_SET);
154  avio_wb32(pb, size);
155  avio_seek(pb, curpos, SEEK_SET);
156  return curpos - pos;
157 }
158 
160 {
161  int64_t curpos;
162 
163  curpos = avio_tell(pb);
164  avio_seek(pb, pos, SEEK_SET);
165  avio_wb16(pb, curpos - pos - 2);
166  avio_seek(pb, curpos, SEEK_SET);
167  return curpos - pos;
168 }
169 
171 {
172  avio_wb32(pb, 0); /* packet leader for synchro */
173  avio_w8(pb, 1);
174  avio_w8(pb, type); /* map packet */
175  avio_wb32(pb, 0); /* size */
176  avio_wb32(pb, 0); /* reserved */
177  avio_w8(pb, 0xE1); /* trailer 1 */
178  avio_w8(pb, 0xE2); /* trailer 2 */
179 }
180 
182 {
183  GXFStreamContext *sc = st->priv_data;
184  char buffer[1024];
185  int size, starting_line;
186 
187  if (sc->iframes) {
188  sc->p_per_gop = sc->pframes / sc->iframes;
189  if (sc->pframes % sc->iframes)
190  sc->p_per_gop++;
191  if (sc->pframes) {
192  sc->b_per_i_or_p = sc->bframes / sc->pframes;
193  if (sc->bframes % sc->pframes)
194  sc->b_per_i_or_p++;
195  }
196  if (sc->p_per_gop > 9)
197  sc->p_per_gop = 9; /* ensure value won't take more than one char */
198  if (sc->b_per_i_or_p > 9)
199  sc->b_per_i_or_p = 9; /* ensure value won't take more than one char */
200  }
201  if (st->codecpar->height == 512 || st->codecpar->height == 608)
202  starting_line = 7; // VBI
203  else if (st->codecpar->height == 480)
204  starting_line = 20;
205  else
206  starting_line = 23; // default PAL
207 
208  size = snprintf(buffer, sizeof(buffer), "Ver 1\nBr %.6f\nIpg 1\nPpi %d\nBpiop %d\n"
209  "Pix 0\nCf %d\nCg %d\nSl %d\nnl16 %d\nVi 1\nf1 1\n",
210  (float)st->codecpar->bit_rate, sc->p_per_gop, sc->b_per_i_or_p,
211  st->codecpar->format == AV_PIX_FMT_YUV422P ? 2 : 1, sc->first_gop_closed == 1,
212  starting_line, (st->codecpar->height + 15) / 16);
213  av_assert0(size < sizeof(buffer));
214  avio_w8(pb, TRACK_MPG_AUX);
215  avio_w8(pb, size + 1);
216  avio_write(pb, (uint8_t *)buffer, size + 1);
217  return size + 3;
218 }
219 
221 {
222  int64_t track_aux_data = 0;
223 
224  avio_w8(pb, TRACK_AUX);
225  avio_w8(pb, 8);
226  if (st->codecpar->format == AV_PIX_FMT_YUV420P)
227  track_aux_data |= 0x01; /* marks stream as DVCAM instead of DVPRO */
228  track_aux_data |= 0x40000000; /* aux data is valid */
229  avio_wl64(pb, track_aux_data);
230  return 8;
231 }
232 
234 {
235  uint32_t timecode = GXF_TIMECODE(gxf->tc.color, gxf->tc.drop,
236  gxf->tc.hh, gxf->tc.mm,
237  gxf->tc.ss, gxf->tc.ff);
238 
239  avio_w8(pb, TRACK_AUX);
240  avio_w8(pb, 8);
241  avio_wl32(pb, timecode);
242  /* reserved */
243  avio_wl32(pb, 0);
244  return 8;
245 }
246 
248 {
249  GXFContext *gxf = s->priv_data;
250  AVIOContext *pb = s->pb;
251  int64_t pos;
252 
253  /* track description section */
254  avio_w8(pb, sc->media_type + 0x80);
255  avio_w8(pb, index + 0xC0);
256 
257  pos = avio_tell(pb);
258  avio_wb16(pb, 0); /* size */
259 
260  /* media file name */
261  avio_w8(pb, TRACK_NAME);
262  avio_w8(pb, strlen(ES_NAME_PATTERN) + 3);
263  avio_write(pb, ES_NAME_PATTERN, sizeof(ES_NAME_PATTERN) - 1);
264  avio_wb16(pb, sc->media_info);
265  avio_w8(pb, 0);
266 
267  switch (sc->track_type) {
268  case 3: /* timecode */
270  break;
271  case 4: /* MPEG2 */
272  case 9: /* MPEG1 */
273  gxf_write_mpeg_auxiliary(pb, s->streams[index]);
274  break;
275  case 5: /* DV25 */
276  case 6: /* DV50 */
277  gxf_write_dv_auxiliary(pb, s->streams[index]);
278  break;
279  default:
280  avio_w8(pb, TRACK_AUX);
281  avio_w8(pb, 8);
282  avio_wl64(pb, 0);
283  }
284 
285  /* file system version */
286  avio_w8(pb, TRACK_VER);
287  avio_w8(pb, 4);
288  avio_wb32(pb, 0);
289 
290  /* frame rate */
291  avio_w8(pb, TRACK_FPS);
292  avio_w8(pb, 4);
293  avio_wb32(pb, sc->frame_rate_index);
294 
295  /* lines per frame */
296  avio_w8(pb, TRACK_LINES);
297  avio_w8(pb, 4);
298  avio_wb32(pb, sc->lines_index);
299 
300  /* fields per frame */
301  avio_w8(pb, TRACK_FPF);
302  avio_w8(pb, 4);
303  avio_wb32(pb, sc->fields);
304 
305  return updateSize(pb, pos);
306 }
307 
309 {
310  GXFContext *gxf = s->priv_data;
311  AVIOContext *pb = s->pb;
312  int64_t pos;
313  int len;
314  const char *filename = strrchr(s->url, '/');
315 
316  pos = avio_tell(pb);
317  avio_wb16(pb, 0); /* size */
318 
319  /* name */
320  if (filename)
321  filename++;
322  else
323  filename = s->url;
324  len = strlen(filename);
325 
326  avio_w8(pb, MAT_NAME);
327  avio_w8(pb, strlen(SERVER_PATH) + len + 1);
328  avio_write(pb, SERVER_PATH, sizeof(SERVER_PATH) - 1);
329  avio_write(pb, filename, len);
330  avio_w8(pb, 0);
331 
332  /* first field */
334  avio_w8(pb, 4);
335  avio_wb32(pb, 0);
336 
337  /* last field */
338  avio_w8(pb, MAT_LAST_FIELD);
339  avio_w8(pb, 4);
340  avio_wb32(pb, gxf->nb_fields);
341 
342  /* reserved */
343  avio_w8(pb, MAT_MARK_IN);
344  avio_w8(pb, 4);
345  avio_wb32(pb, 0);
346 
347  avio_w8(pb, MAT_MARK_OUT);
348  avio_w8(pb, 4);
349  avio_wb32(pb, gxf->nb_fields);
350 
351  /* estimated size */
352  avio_w8(pb, MAT_SIZE);
353  avio_w8(pb, 4);
354  avio_wb32(pb, avio_size(pb) / 1024);
355 
356  return updateSize(pb, pos);
357 }
358 
360 {
361  GXFContext *gxf = s->priv_data;
362  AVIOContext *pb = s->pb;
363  int64_t pos;
364  int i;
365 
366  pos = avio_tell(pb);
367  avio_wb16(pb, 0); /* size */
368  for (i = 0; i < s->nb_streams; ++i)
369  gxf_write_track_description(s, s->streams[i]->priv_data, i);
370 
371  gxf_write_track_description(s, &gxf->timecode_track, s->nb_streams);
372 
373  return updateSize(pb, pos);
374 }
375 
376 static int gxf_write_map_packet(AVFormatContext *s, int rewrite)
377 {
378  GXFContext *gxf = s->priv_data;
379  AVIOContext *pb = s->pb;
380  int64_t pos = avio_tell(pb);
381 
382  if (!rewrite) {
383  if (!(gxf->map_offsets_nb % 30)) {
384  int err;
385  if ((err = av_reallocp_array(&gxf->map_offsets,
386  gxf->map_offsets_nb + 30,
387  sizeof(*gxf->map_offsets))) < 0) {
388  gxf->map_offsets_nb = 0;
389  av_log(s, AV_LOG_ERROR, "could not realloc map offsets\n");
390  return err;
391  }
392  }
393  gxf->map_offsets[gxf->map_offsets_nb++] = pos; // do not increment here
394  }
395 
397 
398  /* preamble */
399  avio_w8(pb, 0xE0); /* version */
400  avio_w8(pb, 0xFF); /* reserved */
401 
404 
405  return updatePacketSize(pb, pos);
406 }
407 
409 {
410  GXFContext *gxf = s->priv_data;
411  AVIOContext *pb = s->pb;
412  int64_t pos = avio_tell(pb);
413  int fields_per_flt = (gxf->nb_fields+1) / 1000 + 1;
414  int flt_entries = gxf->nb_fields / fields_per_flt;
415  int i = 0;
416 
418 
419  avio_wl32(pb, fields_per_flt); /* number of fields */
420  avio_wl32(pb, flt_entries); /* number of active flt entries */
421 
422  if (gxf->flt_entries) {
423  for (i = 0; i < flt_entries; i++)
424  avio_wl32(pb, gxf->flt_entries[(i*fields_per_flt)>>1]);
425  }
426 
427  for (; i < 1000; i++)
428  avio_wl32(pb, 0);
429 
430  return updatePacketSize(pb, pos);
431 }
432 
434 {
435  GXFContext *gxf = s->priv_data;
436  AVIOContext *pb = s->pb;
437  int timecode_base = gxf->time_base.den == 60000 ? 60 : 50;
438  int64_t timestamp = 0;
439  uint64_t nb_fields;
440  uint32_t timecode_in; // timecode at mark in
441  uint32_t timecode_out; // timecode at mark out
442 
443  ff_parse_creation_time_metadata(s, &timestamp, 1);
444 
445  timecode_in = GXF_TIMECODE(gxf->tc.color, gxf->tc.drop,
446  gxf->tc.hh, gxf->tc.mm,
447  gxf->tc.ss, gxf->tc.ff);
448 
449  nb_fields = gxf->nb_fields +
450  gxf->tc.hh * (timecode_base * 3600) +
451  gxf->tc.mm * (timecode_base * 60) +
452  gxf->tc.ss * timecode_base +
453  gxf->tc.ff;
454 
455  timecode_out = GXF_TIMECODE(gxf->tc.color, gxf->tc.drop,
456  nb_fields / (timecode_base * 3600) % 24,
457  nb_fields / (timecode_base * 60) % 60,
458  nb_fields / timecode_base % 60,
459  nb_fields % timecode_base);
460 
461  avio_wl32(pb, gxf->flags);
462  avio_wl32(pb, gxf->nb_fields); /* length of the longest track */
463  avio_wl32(pb, gxf->nb_fields); /* length of the shortest track */
464  avio_wl32(pb, 0); /* mark in */
465  avio_wl32(pb, gxf->nb_fields); /* mark out */
466  avio_wl32(pb, timecode_in); /* timecode mark in */
467  avio_wl32(pb, timecode_out); /* timecode mark out */
468  avio_wl64(pb, timestamp); /* modification time */
469  avio_wl64(pb, timestamp); /* creation time */
470  avio_wl16(pb, 0); /* reserved */
471  avio_wl16(pb, 0); /* reserved */
472  avio_wl16(pb, gxf->audio_tracks);
473  avio_wl16(pb, 1); /* timecode track count */
474  avio_wl16(pb, 0); /* reserved */
475  avio_wl16(pb, gxf->mpeg_tracks);
476  return 48;
477 }
478 
480 {
481  GXFContext *gxf = s->priv_data;
482  AVIOContext *pb = s->pb;
483 
484  avio_wl32(pb, gxf->umf_length); /* total length of the umf data */
485  avio_wl32(pb, 3); /* version */
486  avio_wl32(pb, s->nb_streams+1);
487  avio_wl32(pb, gxf->umf_track_offset); /* umf track section offset */
488  avio_wl32(pb, gxf->umf_track_size);
489  avio_wl32(pb, s->nb_streams+1);
490  avio_wl32(pb, gxf->umf_media_offset);
491  avio_wl32(pb, gxf->umf_media_size);
492  avio_wl32(pb, gxf->umf_length); /* user data offset */
493  avio_wl32(pb, 0); /* user data size */
494  avio_wl32(pb, 0); /* reserved */
495  avio_wl32(pb, 0); /* reserved */
496  return 48;
497 }
498 
500 {
501  AVIOContext *pb = s->pb;
502  GXFContext *gxf = s->priv_data;
503  int64_t pos = avio_tell(pb);
504  int i;
505 
506  gxf->umf_track_offset = pos - gxf->umf_start_offset;
507  for (i = 0; i < s->nb_streams; ++i) {
508  GXFStreamContext *sc = s->streams[i]->priv_data;
509  avio_wl16(pb, sc->media_info);
510  avio_wl16(pb, 1);
511  }
512 
514  avio_wl16(pb, 1);
515 
516  return avio_tell(pb) - pos;
517 }
518 
520 {
521  GXFStreamContext *sc = st->priv_data;
522 
523  if (st->codecpar->format == AV_PIX_FMT_YUV422P)
524  avio_wl32(pb, 2);
525  else
526  avio_wl32(pb, 1); /* default to 420 */
527  avio_wl32(pb, sc->first_gop_closed == 1); /* closed = 1, open = 0, unknown = 255 */
528  avio_wl32(pb, 3); /* top = 1, bottom = 2, frame = 3, unknown = 0 */
529  avio_wl32(pb, 1); /* I picture per GOP */
530  avio_wl32(pb, sc->p_per_gop);
531  avio_wl32(pb, sc->b_per_i_or_p);
533  avio_wl32(pb, 2);
534  else if (st->codecpar->codec_id == AV_CODEC_ID_MPEG1VIDEO)
535  avio_wl32(pb, 1);
536  else
537  avio_wl32(pb, 0);
538  avio_wl32(pb, 0); /* reserved */
539  return 32;
540 }
541 
542 static int gxf_write_umf_media_timecode(AVIOContext *pb, int drop)
543 {
544  avio_wl32(pb, drop); /* drop frame */
545  avio_wl32(pb, 0); /* reserved */
546  avio_wl32(pb, 0); /* reserved */
547  avio_wl32(pb, 0); /* reserved */
548  avio_wl32(pb, 0); /* reserved */
549  avio_wl32(pb, 0); /* reserved */
550  avio_wl32(pb, 0); /* reserved */
551  avio_wl32(pb, 0); /* reserved */
552  return 32;
553 }
554 
556 {
557  int dv_umf_data = 0;
558 
559  if (st->codecpar->format == AV_PIX_FMT_YUV420P)
560  dv_umf_data |= 0x20; /* marks as DVCAM instead of DVPRO */
561  avio_wl32(pb, dv_umf_data);
562  avio_wl32(pb, 0);
563  avio_wl32(pb, 0);
564  avio_wl32(pb, 0);
565  avio_wl32(pb, 0);
566  avio_wl32(pb, 0);
567  avio_wl32(pb, 0);
568  avio_wl32(pb, 0);
569  return 32;
570 }
571 
573 {
574  avio_wl64(pb, av_double2int(1)); /* sound level to begin to */
575  avio_wl64(pb, av_double2int(1)); /* sound level to begin to */
576  avio_wl32(pb, 0); /* number of fields over which to ramp up sound level */
577  avio_wl32(pb, 0); /* number of fields over which to ramp down sound level */
578  avio_wl32(pb, 0); /* reserved */
579  avio_wl32(pb, 0); /* reserved */
580  return 32;
581 }
582 
584 {
585  GXFContext *gxf = s->priv_data;
586  AVIOContext *pb = s->pb;
587  int64_t pos;
588  int i, j;
589 
590  pos = avio_tell(pb);
591  gxf->umf_media_offset = pos - gxf->umf_start_offset;
592  for (i = 0; i <= s->nb_streams; ++i) {
593  GXFStreamContext *sc;
594  int64_t startpos, curpos;
595 
596  if (i == s->nb_streams)
597  sc = &gxf->timecode_track;
598  else
599  sc = s->streams[i]->priv_data;
600 
601  startpos = avio_tell(pb);
602  avio_wl16(pb, 0); /* length */
603  avio_wl16(pb, sc->media_info);
604  avio_wl16(pb, 0); /* reserved */
605  avio_wl16(pb, 0); /* reserved */
606  avio_wl32(pb, gxf->nb_fields);
607  avio_wl32(pb, 0); /* attributes rw, ro */
608  avio_wl32(pb, 0); /* mark in */
609  avio_wl32(pb, gxf->nb_fields); /* mark out */
611  avio_wb16(pb, sc->media_info);
612  for (j = strlen(ES_NAME_PATTERN)+2; j < 88; j++)
613  avio_w8(pb, 0);
614  avio_wl32(pb, sc->track_type);
615  avio_wl32(pb, sc->sample_rate);
616  avio_wl32(pb, sc->sample_size);
617  avio_wl32(pb, 0); /* reserved */
618 
619  if (sc == &gxf->timecode_track)
621  else {
622  AVStream *st = s->streams[i];
623  switch (st->codecpar->codec_id) {
626  gxf_write_umf_media_mpeg(pb, st);
627  break;
630  break;
631  case AV_CODEC_ID_DVVIDEO:
632  gxf_write_umf_media_dv(pb, sc, st);
633  break;
634  }
635  }
636 
637  curpos = avio_tell(pb);
638  avio_seek(pb, startpos, SEEK_SET);
639  avio_wl16(pb, curpos - startpos);
640  avio_seek(pb, curpos, SEEK_SET);
641  }
642  return avio_tell(pb) - pos;
643 }
644 
646 {
647  GXFContext *gxf = s->priv_data;
648  AVIOContext *pb = s->pb;
649  int64_t pos = avio_tell(pb);
650 
652 
653  /* preamble */
654  avio_w8(pb, 3); /* first and last (only) packet */
655  avio_wb32(pb, gxf->umf_length); /* data length */
656 
657  gxf->umf_start_offset = avio_tell(pb);
662  gxf->umf_length = avio_tell(pb) - gxf->umf_start_offset;
663  return updatePacketSize(pb, pos);
664 }
665 
667 {
668  if (!vsc)
669  return;
670 
671  sc->media_type = vsc->sample_rate == 60 ? 7 : 8;
672  sc->sample_rate = vsc->sample_rate;
673  sc->media_info = ('T'<<8) | '0';
674  sc->track_type = 3;
676  sc->lines_index = vsc->lines_index;
677  sc->sample_size = 16;
678  sc->fields = vsc->fields;
679 }
680 
681 static int gxf_init_timecode(AVFormatContext *s, GXFTimecode *tc, const char *tcstr, int fields)
682 {
683  char c;
684 
685  if (sscanf(tcstr, "%d:%d:%d%c%d", &tc->hh, &tc->mm, &tc->ss, &c, &tc->ff) != 5) {
686  av_log(s, AV_LOG_ERROR, "unable to parse timecode, "
687  "syntax: hh:mm:ss[:;.]ff\n");
688  return -1;
689  }
690 
691  tc->color = 0;
692  tc->drop = c != ':';
693 
694  if (fields == 2)
695  tc->ff = tc->ff * 2;
696 
697  return 0;
698 }
699 
701 {
702  AVIOContext *pb = s->pb;
703  GXFContext *gxf = s->priv_data;
704  GXFStreamContext *vsc = NULL;
705  uint8_t tracks[255] = {0};
706  int i, media_info = 0;
707  int ret;
708  AVDictionaryEntry *tcr = av_dict_get(s->metadata, "timecode", NULL, 0);
709 
710  if (!(pb->seekable & AVIO_SEEKABLE_NORMAL)) {
711  av_log(s, AV_LOG_ERROR, "gxf muxer does not support streamed output, patch welcome\n");
712  return -1;
713  }
714 
715  gxf->flags |= 0x00080000; /* material is simple clip */
716  for (i = 0; i < s->nb_streams; ++i) {
717  AVStream *st = s->streams[i];
718  GXFStreamContext *sc = av_mallocz(sizeof(*sc));
719  if (!sc)
720  return AVERROR(ENOMEM);
721  st->priv_data = sc;
722 
724  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
726  av_log(s, AV_LOG_ERROR, "only 16 BIT PCM LE allowed for now\n");
727  return -1;
728  }
729  if (st->codecpar->sample_rate != 48000) {
730  av_log(s, AV_LOG_ERROR, "only 48000hz sampling rate is allowed\n");
731  return -1;
732  }
733  if (st->codecpar->channels != 1) {
734  av_log(s, AV_LOG_ERROR, "only mono tracks are allowed\n");
735  return -1;
736  }
738  if (ret < 0)
739  return ret;
740  sc->track_type = 2;
741  sc->sample_rate = st->codecpar->sample_rate;
742  avpriv_set_pts_info(st, 64, 1, sc->sample_rate);
743  sc->sample_size = 16;
744  sc->frame_rate_index = -2;
745  sc->lines_index = -2;
746  sc->fields = -2;
747  gxf->audio_tracks++;
748  gxf->flags |= 0x04000000; /* audio is 16 bit pcm */
749  media_info = 'A';
750  } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
751  if (i != 0) {
752  av_log(s, AV_LOG_ERROR, "video stream must be the first track\n");
753  return -1;
754  }
755  /* FIXME check from time_base ? */
756  if (st->codecpar->height == 480 || st->codecpar->height == 512) { /* NTSC or NTSC+VBI */
757  sc->frame_rate_index = 5;
758  sc->sample_rate = 60;
759  gxf->flags |= 0x00000080;
760  gxf->time_base = (AVRational){ 1001, 60000 };
761  } else if (st->codecpar->height == 576 || st->codecpar->height == 608) { /* PAL or PAL+VBI */
762  sc->frame_rate_index = 6;
763  sc->media_type++;
764  sc->sample_rate = 50;
765  gxf->flags |= 0x00000040;
766  gxf->time_base = (AVRational){ 1, 50 };
767  } else {
768  av_log(s, AV_LOG_ERROR, "unsupported video resolution, "
769  "gxf muxer only accepts PAL or NTSC resolutions currently\n");
770  return -1;
771  }
772  if (!tcr)
773  tcr = av_dict_get(st->metadata, "timecode", NULL, 0);
774  avpriv_set_pts_info(st, 64, gxf->time_base.num, gxf->time_base.den);
775  if (gxf_find_lines_index(st) < 0)
776  sc->lines_index = -1;
777  sc->sample_size = st->codecpar->bit_rate;
778  sc->fields = 2; /* interlaced */
779 
780  vsc = sc;
781 
782  switch (st->codecpar->codec_id) {
783  case AV_CODEC_ID_MJPEG:
784  sc->track_type = 1;
785  gxf->flags |= 0x00004000;
786  media_info = 'J';
787  break;
789  sc->track_type = 9;
790  gxf->mpeg_tracks++;
791  media_info = 'L';
792  break;
794  sc->first_gop_closed = -1;
795  sc->track_type = 4;
796  gxf->mpeg_tracks++;
797  gxf->flags |= 0x00008000;
798  media_info = 'M';
799  break;
800  case AV_CODEC_ID_DVVIDEO:
801  if (st->codecpar->format == AV_PIX_FMT_YUV422P) {
802  sc->media_type += 2;
803  sc->track_type = 6;
804  gxf->flags |= 0x00002000;
805  media_info = 'E';
806  } else {
807  sc->track_type = 5;
808  gxf->flags |= 0x00001000;
809  media_info = 'D';
810  }
811  break;
812  default:
813  av_log(s, AV_LOG_ERROR, "video codec not supported\n");
814  return -1;
815  }
816  }
817  /* FIXME first 10 audio tracks are 0 to 9 next 22 are A to V */
818  sc->media_info = media_info<<8 | ('0'+tracks[media_info]++);
819  sc->order = s->nb_streams - st->index;
820  }
821 
822  if (tcr && vsc)
823  gxf_init_timecode(s, &gxf->tc, tcr->value, vsc->fields);
824 
826  gxf->flags |= 0x200000; // time code track is non-drop frame
827 
828  if ((ret = gxf_write_map_packet(s, 0)) < 0)
829  return ret;
832 
833  gxf->packet_count = 3;
834 
835  return 0;
836 }
837 
839 {
840  int64_t pos = avio_tell(pb);
841 
843  return updatePacketSize(pb, pos);
844 }
845 
847 {
848  GXFContext *gxf = s->priv_data;
849  AVIOContext *pb = s->pb;
850  int64_t end;
851  int i;
852  int ret;
853 
855  end = avio_tell(pb);
856  avio_seek(pb, 0, SEEK_SET);
857  /* overwrite map, flt and umf packets with new values */
858  if ((ret = gxf_write_map_packet(s, 1)) < 0)
859  return ret;
862  /* update duration in all map packets */
863  for (i = 1; i < gxf->map_offsets_nb; i++) {
864  avio_seek(pb, gxf->map_offsets[i], SEEK_SET);
865  if ((ret = gxf_write_map_packet(s, 1)) < 0)
866  return ret;
867  }
868 
869  avio_seek(pb, end, SEEK_SET);
870 
871  return 0;
872 }
873 
875 {
876  GXFContext *gxf = s->priv_data;
877 
878  av_freep(&gxf->flt_entries);
879  av_freep(&gxf->map_offsets);
880 }
881 
882 static int gxf_parse_mpeg_frame(GXFStreamContext *sc, const uint8_t *buf, int size)
883 {
884  uint32_t c=-1;
885  int i;
886  for(i=0; i<size-4 && c!=0x100; i++){
887  c = (c<<8) + buf[i];
888  if(c == 0x1B8 && sc->first_gop_closed == -1) /* GOP start code */
889  sc->first_gop_closed= (buf[i+4]>>6)&1;
890  }
891  return (buf[i+1]>>3)&7;
892 }
893 
895 {
896  GXFContext *gxf = s->priv_data;
897  AVIOContext *pb = s->pb;
898  AVStream *st = s->streams[pkt->stream_index];
899  GXFStreamContext *sc = st->priv_data;
900  unsigned field_nb;
901  /* If the video is frame-encoded, the frame numbers shall be represented by
902  * even field numbers.
903  * see SMPTE360M-2004 6.4.2.1.3 Media field number */
904  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
905  field_nb = gxf->nb_fields;
906  } else {
907  field_nb = av_rescale_rnd(pkt->dts, gxf->time_base.den,
908  (int64_t)48000*gxf->time_base.num, AV_ROUND_UP);
909  }
910 
911  avio_w8(pb, sc->media_type);
912  avio_w8(pb, st->index);
913  avio_wb32(pb, field_nb);
914  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
915  avio_wb16(pb, 0);
916  avio_wb16(pb, size / 2);
917  } else if (st->codecpar->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
919  if (frame_type == AV_PICTURE_TYPE_I) {
920  avio_w8(pb, 0x0d);
921  sc->iframes++;
922  } else if (frame_type == AV_PICTURE_TYPE_B) {
923  avio_w8(pb, 0x0f);
924  sc->bframes++;
925  } else {
926  avio_w8(pb, 0x0e);
927  sc->pframes++;
928  }
929  avio_wb24(pb, size);
930  } else if (st->codecpar->codec_id == AV_CODEC_ID_DVVIDEO) {
931  avio_w8(pb, size / 4096);
932  avio_wb24(pb, 0);
933  } else
934  avio_wb32(pb, size);
935  avio_wb32(pb, field_nb);
936  avio_w8(pb, 1); /* flags */
937  avio_w8(pb, 0); /* reserved */
938  return 16;
939 }
940 
942 {
943  GXFContext *gxf = s->priv_data;
944  AVIOContext *pb = s->pb;
945  AVStream *st = s->streams[pkt->stream_index];
946  int64_t pos = avio_tell(pb);
947  int padding = 0;
948  unsigned packet_start_offset = avio_tell(pb) / 1024;
949  int ret;
950 
952  if (st->codecpar->codec_id == AV_CODEC_ID_MPEG2VIDEO && pkt->size % 4) /* MPEG-2 frames must be padded */
953  padding = 4 - pkt->size % 4;
954  else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
955  padding = GXF_AUDIO_PACKET_SIZE - pkt->size;
956  gxf_write_media_preamble(s, pkt, pkt->size + padding);
957  avio_write(pb, pkt->data, pkt->size);
958  gxf_write_padding(pb, padding);
959 
960  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
961  if (!(gxf->flt_entries_nb % 500)) {
962  int err;
963  if ((err = av_reallocp_array(&gxf->flt_entries,
964  gxf->flt_entries_nb + 500,
965  sizeof(*gxf->flt_entries))) < 0) {
966  gxf->flt_entries_nb = 0;
967  gxf->nb_fields = 0;
968  av_log(s, AV_LOG_ERROR, "could not reallocate flt entries\n");
969  return err;
970  }
971  }
972  gxf->flt_entries[gxf->flt_entries_nb++] = packet_start_offset;
973  gxf->nb_fields += 2; // count fields
974  }
975 
976  updatePacketSize(pb, pos);
977 
978  gxf->packet_count++;
979  if (gxf->packet_count == 100) {
980  if ((ret = gxf_write_map_packet(s, 0)) < 0)
981  return ret;
982  gxf->packet_count = 0;
983  }
984 
985  return 0;
986 }
987 
989  const AVPacket *cur)
990 {
991  GXFContext *gxf = s->priv_data;
992  const AVPacket *pkt[2] = { cur, next };
993  int i, field_nb[2];
994  GXFStreamContext *sc[2];
995 
996  for (i = 0; i < 2; i++) {
997  AVStream *st = s->streams[pkt[i]->stream_index];
998  sc[i] = st->priv_data;
999  if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1000  field_nb[i] = av_rescale_rnd(pkt[i]->dts, gxf->time_base.den,
1001  (int64_t)48000*gxf->time_base.num, AV_ROUND_UP);
1002  field_nb[i] &= ~1; // compare against even field number because audio must be before video
1003  } else
1004  field_nb[i] = pkt[i]->dts; // dts are field based
1005  }
1006 
1007  return field_nb[1] > field_nb[0] ||
1008  (field_nb[1] == field_nb[0] && sc[1]->order > sc[0]->order);
1009 }
1010 
1012 {
1013  int ret;
1014  if (pkt) {
1015  AVStream *st = s->streams[pkt->stream_index];
1016  GXFStreamContext *sc = st->priv_data;
1018  pkt->pts = pkt->dts = sc->pkt_cnt * 2; // enforce 2 fields
1019  else
1021  sc->pkt_cnt++;
1023  return ret;
1024  }
1026 }
1027 
1029  .name = "gxf",
1030  .long_name = NULL_IF_CONFIG_SMALL("GXF (General eXchange Format)"),
1031  .extensions = "gxf",
1032  .priv_data_size = sizeof(GXFContext),
1033  .audio_codec = AV_CODEC_ID_PCM_S16LE,
1034  .video_codec = AV_CODEC_ID_MPEG2VIDEO,
1038  .deinit = gxf_deinit,
1040 };
static void flush(AVCodecContext *avctx)
uint8_t
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
Main libavformat public API header.
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:253
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
void avio_wl64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:443
void avio_wl32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:375
void avio_wl16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:455
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:203
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:383
void avio_wb16(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:461
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:342
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
void avio_wb24(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:473
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:225
#define s(width, name)
Definition: cbs_vp9.c:257
#define NULL
Definition: coverity.c:32
long long int64_t
Definition: coverity.c:34
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:730
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:346
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:313
@ AV_CODEC_ID_NONE
Definition: codec_id.h:47
@ AV_CODEC_ID_PCM_S24LE
Definition: codec_id.h:325
@ AV_CODEC_ID_DVVIDEO
Definition: codec_id.h:73
@ AV_CODEC_ID_AC3
Definition: codec_id.h:427
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:56
@ AV_CODEC_ID_MPEG1VIDEO
Definition: codec_id.h:50
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:51
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
#define AVERROR(e)
Definition: error.h:43
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
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:58
@ AV_ROUND_UP
Round toward +infinity.
Definition: mathematics.h:83
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate, or free an array through a pointer to a pointer.
Definition: mem.c:206
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:276
#define AV_STRINGIFY(s)
Definition: macros.h:36
GXFPktType
Definition: gxf.h:25
@ PKT_UMF
Definition: gxf.h:30
@ PKT_MAP
Definition: gxf.h:26
@ PKT_MEDIA
Definition: gxf.h:27
@ PKT_EOS
Definition: gxf.h:28
@ PKT_FLT
Definition: gxf.h:29
@ TRACK_MPG_AUX
Definition: gxf.h:46
@ TRACK_VER
Definition: gxf.h:45
@ TRACK_AUX
Definition: gxf.h:44
@ TRACK_FPF
Definition: gxf.h:49
@ TRACK_LINES
Definition: gxf.h:48
@ TRACK_FPS
Definition: gxf.h:47
@ TRACK_NAME
Definition: gxf.h:43
@ MAT_NAME
Definition: gxf.h:34
@ MAT_LAST_FIELD
Definition: gxf.h:36
@ MAT_MARK_IN
Definition: gxf.h:37
@ MAT_FIRST_FIELD
Definition: gxf.h:35
@ MAT_SIZE
Definition: gxf.h:39
@ MAT_MARK_OUT
Definition: gxf.h:38
static const struct @257 gxf_lines_tab[]
#define GXF_SAMPLES_PER_FRAME
Definition: gxfenc.c:31
AVOutputFormat ff_gxf_muxer
Definition: gxfenc.c:1028
static int gxf_write_eos_packet(AVIOContext *pb)
Definition: gxfenc.c:838
static void gxf_deinit(AVFormatContext *s)
Definition: gxfenc.c:874
static int gxf_write_header(AVFormatContext *s)
Definition: gxfenc.c:700
static int gxf_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush)
Definition: gxfenc.c:1011
static const AVCodecTag gxf_media_types[]
Definition: gxfenc.c:99
static int gxf_init_timecode(AVFormatContext *s, GXFTimecode *tc, const char *tcstr, int fields)
Definition: gxfenc.c:681
static int gxf_write_flt_packet(AVFormatContext *s)
Definition: gxfenc.c:408
static int gxf_write_mpeg_auxiliary(AVIOContext *pb, AVStream *st)
Definition: gxfenc.c:181
static int gxf_write_map_packet(AVFormatContext *s, int rewrite)
Definition: gxfenc.c:376
static int gxf_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: gxfenc.c:941
#define GXF_AUDIO_PACKET_SIZE
Definition: gxfenc.c:32
static int gxf_write_umf_media_description(AVFormatContext *s)
Definition: gxfenc.c:583
static int gxf_write_umf_media_timecode(AVIOContext *pb, int drop)
Definition: gxfenc.c:542
static int gxf_write_track_description_section(AVFormatContext *s)
Definition: gxfenc.c:359
#define SERVER_PATH
Definition: gxfenc.c:118
static int gxf_write_umf_packet(AVFormatContext *s)
Definition: gxfenc.c:645
static int gxf_write_media_preamble(AVFormatContext *s, AVPacket *pkt, int size)
Definition: gxfenc.c:894
static int gxf_write_material_data_section(AVFormatContext *s)
Definition: gxfenc.c:308
#define ES_NAME_PATTERN
Definition: gxfenc.c:119
static void gxf_init_timecode_track(GXFStreamContext *sc, GXFStreamContext *vsc)
Definition: gxfenc.c:666
int index
Definition: gxfenc.c:89
static int64_t updatePacketSize(AVIOContext *pb, int64_t pos)
Definition: gxfenc.c:142
static int gxf_write_umf_payload(AVFormatContext *s)
Definition: gxfenc.c:479
static int gxf_write_track_description(AVFormatContext *s, GXFStreamContext *sc, int index)
Definition: gxfenc.c:247
#define GXF_TIMECODE(c, d, h, m, s, f)
Definition: gxfenc.c:34
static int gxf_write_dv_auxiliary(AVIOContext *pb, AVStream *st)
Definition: gxfenc.c:220
static int gxf_find_lines_index(AVStream *st)
Definition: gxfenc.c:121
static int gxf_write_umf_track_description(AVFormatContext *s)
Definition: gxfenc.c:499
static void gxf_write_packet_header(AVIOContext *pb, GXFPktType type)
Definition: gxfenc.c:170
static int gxf_compare_field_nb(AVFormatContext *s, const AVPacket *next, const AVPacket *cur)
Definition: gxfenc.c:988
static int gxf_write_umf_material_description(AVFormatContext *s)
Definition: gxfenc.c:433
int height
Definition: gxfenc.c:89
static void gxf_write_padding(AVIOContext *pb, int64_t to_pad)
Definition: gxfenc.c:135
static int gxf_write_umf_media_mpeg(AVIOContext *pb, AVStream *st)
Definition: gxfenc.c:519
static int64_t updateSize(AVIOContext *pb, int64_t pos)
Definition: gxfenc.c:159
static int gxf_write_umf_media_dv(AVIOContext *pb, GXFStreamContext *sc, AVStream *st)
Definition: gxfenc.c:555
static int gxf_write_umf_media_audio(AVIOContext *pb, GXFStreamContext *sc)
Definition: gxfenc.c:572
static int gxf_parse_mpeg_frame(GXFStreamContext *sc, const uint8_t *buf, int size)
Definition: gxfenc.c:882
static int gxf_write_timecode_auxiliary(AVIOContext *pb, GXFContext *gxf)
Definition: gxfenc.c:233
static int gxf_write_trailer(AVFormatContext *s)
Definition: gxfenc.c:846
cl_device_type type
int i
Definition: input.c:407
static av_always_inline uint64_t av_double2int(double f)
Reinterpret a double as a 64-bit integer.
Definition: intfloat.h:70
frame_type
int ff_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush)
Interleave an AVPacket per dts so it can be muxed.
Definition: mux.c:932
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
Definition: utils.c:3121
int ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt, int(*compare)(AVFormatContext *, const AVPacket *, const AVPacket *))
Add packet to an AVFormatContext's packet_buffer list, determining its interleaved position using com...
Definition: mux.c:830
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4945
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:5704
int ff_stream_add_bitstream_filter(AVStream *st, const char *name, const char *args)
Add a bitstream filter to a stream.
Definition: utils.c:5576
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
static int interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush)
Interleave an AVPacket correctly so it can be muxed.
Definition: mux.c:1087
AVOptions.
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
#define tc
Definition: regdef.h:69
static char buffer[20]
Definition: seek.c:32
#define snprintf
Definition: snprintf.h:34
unsigned int pos
Definition: spdifenc.c:412
Describe the class of an AVClass context structure.
Definition: log.h:67
int channels
Audio only.
Definition: codec_par.h:166
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:89
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
int sample_rate
Audio only.
Definition: codec_par.h:170
char * value
Definition: dict.h:83
Format I/O context.
Definition: avformat.h:1232
Bytestream IO Context.
Definition: avio.h:161
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:260
const char * name
Definition: avformat.h:491
This structure stores compressed data.
Definition: packet.h:346
int stream_index
Definition: packet.h:371
int size
Definition: packet.h:370
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:362
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:368
uint8_t * data
Definition: packet.h:369
Rational number (pair of numerator and denominator).
Definition: rational.h:58
int num
Numerator.
Definition: rational.h:59
int den
Denominator.
Definition: rational.h:60
Stream structure.
Definition: avformat.h:873
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1038
AVDictionary * metadata
Definition: avformat.h:937
void * priv_data
Definition: avformat.h:888
int index
stream index in AVFormatContext
Definition: avformat.h:874
uint16_t umf_media_size
Definition: gxfenc.c:76
AVRational time_base
Definition: gxfenc.c:77
unsigned map_offsets_nb
Definition: gxfenc.c:83
uint16_t umf_track_size
Definition: gxfenc.c:75
uint32_t umf_track_offset
Definition: gxfenc.c:72
uint16_t mpeg_tracks
Definition: gxfenc.c:69
uint32_t nb_fields
Definition: gxfenc.c:67
GXFTimecode tc
Definition: gxfenc.c:85
uint16_t audio_tracks
Definition: gxfenc.c:68
uint32_t umf_media_offset
Definition: gxfenc.c:73
uint32_t umf_length
Definition: gxfenc.c:74
unsigned * flt_entries
offsets of packets /1024, starts after 2nd video field
Definition: gxfenc.c:80
AVClass * av_class
Definition: gxfenc.c:66
GXFStreamContext timecode_track
Definition: gxfenc.c:79
int64_t creation_time
Definition: gxfenc.c:70
uint64_t * map_offsets
offset of map packets
Definition: gxfenc.c:82
uint32_t umf_start_offset
Definition: gxfenc.c:71
unsigned packet_count
Definition: gxfenc.c:84
int flags
Definition: gxfenc.c:78
unsigned flt_entries_nb
Definition: gxfenc.c:81
int64_t pkt_cnt
Definition: gxfenc.c:47
int lines_index
Definition: gxfenc.c:54
int frame_rate_index
Definition: gxfenc.c:53
int first_gop_closed
Definition: gxfenc.c:61
uint16_t media_info
Definition: gxfenc.c:52
uint32_t track_type
Definition: gxfenc.c:48
unsigned order
interleaving order
Definition: gxfenc.c:62
uint16_t media_type
Definition: gxfenc.c:51
uint32_t sample_size
Definition: gxfenc.c:49
uint32_t sample_rate
Definition: gxfenc.c:50
int b_per_i_or_p
number of B-frames per I-frame or P-frame
Definition: gxfenc.c:60
int mm
Definition: gxfenc.c:39
int ss
Definition: gxfenc.c:40
int drop
Definition: gxfenc.c:43
int hh
Definition: gxfenc.c:38
int color
Definition: gxfenc.c:42
int ff
Definition: gxfenc.c:41
#define av_freep(p)
#define av_log(a,...)
FILE * out
Definition: movenc.c:54
AVPacket * pkt
Definition: movenc.c:59
Timecode helpers header.
int size
static int write_trailer(AVFormatContext *s1)
Definition: v4l2enc.c:98
int len
static double c[64]