3 * Copyright (c) 2006 SmartJog S.A., Baptiste Coudurier <baptiste dot coudurier at smartjog dot com>
5 * This file is part of FFmpeg.
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.
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.
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
22 #include "libavutil/fifo.h"
26 #include "audiointerleave.h"
28 #define GXF_AUDIO_PACKET_SIZE 65536
30 typedef struct GXFStreamContext
{
31 AudioInterleaveContext aic
;
44 int b_per_i_or_p
; ///< number of B frames per I frame or P frame
46 unsigned order
; ///< interleaving order
49 typedef struct GXFContext
{
51 uint16_t audio_tracks
;
53 int64_t creation_time
;
54 uint32_t umf_start_offset
;
55 uint32_t umf_track_offset
;
56 uint32_t umf_media_offset
;
58 uint16_t umf_track_size
;
59 uint16_t umf_media_size
;
62 GXFStreamContext timecode_track
;
63 unsigned *flt_entries
; ///< offsets of packets /1024, starts after 2nd video field
64 unsigned flt_entries_nb
;
65 uint64_t *map_offsets
; ///< offset of map packets
66 unsigned map_offsets_nb
;
67 unsigned packet_count
;
73 { 480, 1 }, /* NTSC */
74 { 512, 1 }, /* NTSC + VBI */
76 { 608, 2 }, /* PAL + VBI */
81 static const AVCodecTag gxf_media_types
[] = {
82 { CODEC_ID_MJPEG
, 3 }, /* NTSC */
83 { CODEC_ID_MJPEG
, 4 }, /* PAL */
84 { CODEC_ID_PCM_S24LE
, 9 },
85 { CODEC_ID_PCM_S16LE
, 10 },
86 { CODEC_ID_MPEG2VIDEO
, 11 }, /* NTSC */
87 { CODEC_ID_MPEG2VIDEO
, 12 }, /* PAL */
88 { CODEC_ID_DVVIDEO
, 13 }, /* NTSC */
89 { CODEC_ID_DVVIDEO
, 14 }, /* PAL */
90 { CODEC_ID_DVVIDEO
, 15 }, /* 50M NTSC */
91 { CODEC_ID_DVVIDEO
, 16 }, /* 50M PAL */
92 { CODEC_ID_AC3
, 17 },
93 //{ CODEC_ID_NONE, , 18 }, /* Non compressed 24 bit audio */
94 { CODEC_ID_MPEG2VIDEO
, 20 }, /* MPEG HD */
95 { CODEC_ID_MPEG1VIDEO
, 22 }, /* NTSC */
96 { CODEC_ID_MPEG1VIDEO
, 23 }, /* PAL */
100 #define SERVER_PATH "EXT:/PDR/default/"
101 #define ES_NAME_PATTERN "EXT:/PDR/default/ES."
103 static int gxf_find_lines_index(AVStream
*st
)
105 GXFStreamContext
*sc
= st
->priv_data
;
108 for (i
= 0; i
< 6; ++i
) {
109 if (st
->codec
->height
== gxf_lines_tab
[i
].height
) {
110 sc
->lines_index
= gxf_lines_tab
[i
].index
;
117 static void gxf_write_padding(ByteIOContext
*pb
, int64_t to_pad
)
119 for (; to_pad
> 0; to_pad
--) {
124 static int64_t updatePacketSize(ByteIOContext
*pb
, int64_t pos
)
129 size
= url_ftell(pb
) - pos
;
131 gxf_write_padding(pb
, 4 - size
% 4);
132 size
= url_ftell(pb
) - pos
;
134 curpos
= url_ftell(pb
);
135 url_fseek(pb
, pos
+ 6, SEEK_SET
);
137 url_fseek(pb
, curpos
, SEEK_SET
);
141 static int64_t updateSize(ByteIOContext
*pb
, int64_t pos
)
145 curpos
= url_ftell(pb
);
146 url_fseek(pb
, pos
, SEEK_SET
);
147 put_be16(pb
, curpos
- pos
- 2);
148 url_fseek(pb
, curpos
, SEEK_SET
);
152 static void gxf_write_packet_header(ByteIOContext
*pb
, GXFPktType type
)
154 put_be32(pb
, 0); /* packet leader for synchro */
156 put_byte(pb
, type
); /* map packet */
157 put_be32(pb
, 0); /* size */
158 put_be32(pb
, 0); /* reserved */
159 put_byte(pb
, 0xE1); /* trailer 1 */
160 put_byte(pb
, 0xE2); /* trailer 2 */
163 static int gxf_write_mpeg_auxiliary(ByteIOContext
*pb
, AVStream
*st
)
165 GXFStreamContext
*sc
= st
->priv_data
;
167 int size
, starting_line
;
170 sc
->p_per_gop
= sc
->pframes
/ sc
->iframes
;
171 if (sc
->pframes
% sc
->iframes
)
174 sc
->b_per_i_or_p
= sc
->bframes
/ sc
->pframes
;
175 if (sc
->bframes
% sc
->pframes
)
178 if (sc
->p_per_gop
> 9)
179 sc
->p_per_gop
= 9; /* ensure value won't take more than one char */
180 if (sc
->b_per_i_or_p
> 9)
181 sc
->b_per_i_or_p
= 9; /* ensure value won't take more than one char */
183 if (st
->codec
->height
== 512 || st
->codec
->height
== 608)
184 starting_line
= 7; // VBI
185 else if (st
->codec
->height
== 480)
188 starting_line
= 23; // default PAL
190 size
= snprintf(buffer
, 1024, "Ver 1\nBr %.6f\nIpg 1\nPpi %d\nBpiop %d\n"
191 "Pix 0\nCf %d\nCg %d\nSl %d\nnl16 %d\nVi 1\nf1 1\n",
192 (float)st
->codec
->bit_rate
, sc
->p_per_gop
, sc
->b_per_i_or_p
,
193 st
->codec
->pix_fmt
== PIX_FMT_YUV422P
? 2 : 1, sc
->first_gop_closed
== 1,
194 starting_line
, st
->codec
->height
/ 16);
195 put_byte(pb
, TRACK_MPG_AUX
);
196 put_byte(pb
, size
+ 1);
197 put_buffer(pb
, (uint8_t *)buffer
, size
+ 1);
201 static int gxf_write_timecode_auxiliary(ByteIOContext
*pb
, GXFStreamContext
*sc
)
203 put_byte(pb
, 0); /* fields */
204 put_byte(pb
, 0); /* seconds */
205 put_byte(pb
, 0); /* minutes */
206 put_byte(pb
, 0); /* flags + hours */
212 static int gxf_write_track_description(AVFormatContext
*s
, GXFStreamContext
*sc
, int index
)
214 ByteIOContext
*pb
= s
->pb
;
216 int mpeg
= sc
->track_type
== 4 || sc
->track_type
== 9;
218 /* track description section */
219 put_byte(pb
, sc
->media_type
+ 0x80);
220 put_byte(pb
, index
+ 0xC0);
223 put_be16(pb
, 0); /* size */
225 /* media file name */
226 put_byte(pb
, TRACK_NAME
);
227 put_byte(pb
, strlen(ES_NAME_PATTERN
) + 3);
228 put_tag(pb
, ES_NAME_PATTERN
);
229 put_be16(pb
, sc
->media_info
);
233 /* auxiliary information */
234 put_byte(pb
, TRACK_AUX
);
236 if (sc
->track_type
== 3)
237 gxf_write_timecode_auxiliary(pb
, sc
);
242 /* file system version */
243 put_byte(pb
, TRACK_VER
);
248 gxf_write_mpeg_auxiliary(pb
, s
->streams
[index
]);
251 put_byte(pb
, TRACK_FPS
);
253 put_be32(pb
, sc
->frame_rate_index
);
255 /* lines per frame */
256 put_byte(pb
, TRACK_LINES
);
258 put_be32(pb
, sc
->lines_index
);
260 /* fields per frame */
261 put_byte(pb
, TRACK_FPF
);
263 put_be32(pb
, sc
->fields
);
265 return updateSize(pb
, pos
);
268 static int gxf_write_material_data_section(AVFormatContext
*s
)
270 GXFContext
*gxf
= s
->priv_data
;
271 ByteIOContext
*pb
= s
->pb
;
273 const char *filename
= strrchr(s
->filename
, '/');
276 put_be16(pb
, 0); /* size */
282 filename
= s
->filename
;
283 put_byte(pb
, MAT_NAME
);
284 put_byte(pb
, strlen(SERVER_PATH
) + strlen(filename
) + 1);
285 put_tag(pb
, SERVER_PATH
);
286 put_tag(pb
, filename
);
290 put_byte(pb
, MAT_FIRST_FIELD
);
295 put_byte(pb
, MAT_LAST_FIELD
);
297 put_be32(pb
, gxf
->nb_fields
);
300 put_byte(pb
, MAT_MARK_IN
);
304 put_byte(pb
, MAT_MARK_OUT
);
306 put_be32(pb
, gxf
->nb_fields
);
309 put_byte(pb
, MAT_SIZE
);
311 put_be32(pb
, url_fsize(pb
) / 1024);
313 return updateSize(pb
, pos
);
316 static int gxf_write_track_description_section(AVFormatContext
*s
)
318 GXFContext
*gxf
= s
->priv_data
;
319 ByteIOContext
*pb
= s
->pb
;
324 put_be16(pb
, 0); /* size */
325 for (i
= 0; i
< s
->nb_streams
; ++i
)
326 gxf_write_track_description(s
, s
->streams
[i
]->priv_data
, i
);
328 gxf_write_track_description(s
, &gxf
->timecode_track
, s
->nb_streams
);
330 return updateSize(pb
, pos
);
333 static int gxf_write_map_packet(AVFormatContext
*s
, int rewrite
)
335 GXFContext
*gxf
= s
->priv_data
;
336 ByteIOContext
*pb
= s
->pb
;
337 int64_t pos
= url_ftell(pb
);
340 if (!(gxf
->map_offsets_nb
% 30)) {
341 gxf
->map_offsets
= av_realloc(gxf
->map_offsets
,
342 (gxf
->map_offsets_nb
+30)*sizeof(*gxf
->map_offsets
));
343 if (!gxf
->map_offsets
) {
344 av_log(s
, AV_LOG_ERROR
, "could not realloc map offsets\n");
348 gxf
->map_offsets
[gxf
->map_offsets_nb
++] = pos
; // do not increment here
351 gxf_write_packet_header(pb
, PKT_MAP
);
354 put_byte(pb
, 0xE0); /* version */
355 put_byte(pb
, 0xFF); /* reserved */
357 gxf_write_material_data_section(s
);
358 gxf_write_track_description_section(s
);
360 return updatePacketSize(pb
, pos
);
363 static int gxf_write_flt_packet(AVFormatContext
*s
)
365 GXFContext
*gxf
= s
->priv_data
;
366 ByteIOContext
*pb
= s
->pb
;
367 int64_t pos
= url_ftell(pb
);
368 int fields_per_flt
= (gxf
->nb_fields
+1) / 1000 + 1;
369 int flt_entries
= gxf
->nb_fields
/ fields_per_flt
- 1;
372 gxf_write_packet_header(pb
, PKT_FLT
);
374 put_le32(pb
, fields_per_flt
); /* number of fields */
375 put_le32(pb
, flt_entries
); /* number of active flt entries */
377 if (gxf
->flt_entries
) {
378 for (i
= 0; i
< flt_entries
; i
++)
379 put_le32(pb
, gxf
->flt_entries
[(i
*fields_per_flt
)>>1]);
382 for (; i
< 1000; i
++)
385 return updatePacketSize(pb
, pos
);
388 static int gxf_write_umf_material_description(AVFormatContext
*s
)
390 GXFContext
*gxf
= s
->priv_data
;
391 ByteIOContext
*pb
= s
->pb
;
392 int timecode_base
= gxf
->time_base
.den
== 60000 ? 60 : 50;
396 gxf
->nb_fields
/ (timecode_base
* 3600) % 24 << 24 | // hours
397 gxf
->nb_fields
/ (timecode_base
* 60) % 60 << 16 | // minutes
398 gxf
->nb_fields
/ timecode_base
% 60 << 8 | // seconds
399 gxf
->nb_fields
% timecode_base
; // fields
401 put_le32(pb
, gxf
->flags
);
402 put_le32(pb
, gxf
->nb_fields
); /* length of the longest track */
403 put_le32(pb
, gxf
->nb_fields
); /* length of the shortest track */
404 put_le32(pb
, 0); /* mark in */
405 put_le32(pb
, gxf
->nb_fields
); /* mark out */
406 put_le32(pb
, 0); /* timecode mark in */
407 put_le32(pb
, timecode
); /* timecode mark out */
408 put_le64(pb
, s
->timestamp
); /* modification time */
409 put_le64(pb
, s
->timestamp
); /* creation time */
410 put_le16(pb
, 0); /* reserved */
411 put_le16(pb
, 0); /* reserved */
412 put_le16(pb
, gxf
->audio_tracks
);
413 put_le16(pb
, 1); /* timecode track count */
414 put_le16(pb
, 0); /* reserved */
415 put_le16(pb
, gxf
->mpeg_tracks
);
419 static int gxf_write_umf_payload(AVFormatContext
*s
)
421 GXFContext
*gxf
= s
->priv_data
;
422 ByteIOContext
*pb
= s
->pb
;
424 put_le32(pb
, gxf
->umf_length
); /* total length of the umf data */
425 put_le32(pb
, 3); /* version */
426 put_le32(pb
, s
->nb_streams
+1);
427 put_le32(pb
, gxf
->umf_track_offset
); /* umf track section offset */
428 put_le32(pb
, gxf
->umf_track_size
);
429 put_le32(pb
, s
->nb_streams
+1);
430 put_le32(pb
, gxf
->umf_media_offset
);
431 put_le32(pb
, gxf
->umf_media_size
);
432 put_le32(pb
, gxf
->umf_length
); /* user data offset */
433 put_le32(pb
, 0); /* user data size */
434 put_le32(pb
, 0); /* reserved */
435 put_le32(pb
, 0); /* reserved */
439 static int gxf_write_umf_track_description(AVFormatContext
*s
)
441 ByteIOContext
*pb
= s
->pb
;
442 GXFContext
*gxf
= s
->priv_data
;
443 int64_t pos
= url_ftell(pb
);
446 gxf
->umf_track_offset
= pos
- gxf
->umf_start_offset
;
447 for (i
= 0; i
< s
->nb_streams
; ++i
) {
448 GXFStreamContext
*sc
= s
->streams
[i
]->priv_data
;
449 put_le16(pb
, sc
->media_info
);
453 put_le16(pb
, gxf
->timecode_track
.media_info
);
456 return url_ftell(pb
) - pos
;
459 static int gxf_write_umf_media_mpeg(ByteIOContext
*pb
, AVStream
*st
)
461 GXFStreamContext
*sc
= st
->priv_data
;
463 if (st
->codec
->pix_fmt
== PIX_FMT_YUV422P
)
466 put_le32(pb
, 1); /* default to 420 */
467 put_le32(pb
, sc
->first_gop_closed
== 1); /* closed = 1, open = 0, unknown = 255 */
468 put_le32(pb
, 3); /* top = 1, bottom = 2, frame = 3, unknown = 0 */
469 put_le32(pb
, 1); /* I picture per GOP */
470 put_le32(pb
, sc
->p_per_gop
);
471 put_le32(pb
, sc
->b_per_i_or_p
);
472 if (st
->codec
->codec_id
== CODEC_ID_MPEG2VIDEO
)
474 else if (st
->codec
->codec_id
== CODEC_ID_MPEG1VIDEO
)
478 put_le32(pb
, 0); /* reserved */
482 static int gxf_write_umf_media_timecode(ByteIOContext
*pb
, GXFStreamContext
*sc
)
484 put_le32(pb
, 1); /* non drop frame */
485 put_le32(pb
, 0); /* reserved */
486 put_le32(pb
, 0); /* reserved */
487 put_le32(pb
, 0); /* reserved */
488 put_le32(pb
, 0); /* reserved */
489 put_le32(pb
, 0); /* reserved */
490 put_le32(pb
, 0); /* reserved */
491 put_le32(pb
, 0); /* reserved */
495 static int gxf_write_umf_media_dv(ByteIOContext
*pb
, GXFStreamContext
*sc
)
499 for (i
= 0; i
< 8; i
++) {
505 static int gxf_write_umf_media_audio(ByteIOContext
*pb
, GXFStreamContext
*sc
)
507 put_le64(pb
, av_dbl2int(1)); /* sound level to begin to */
508 put_le64(pb
, av_dbl2int(1)); /* sound level to begin to */
509 put_le32(pb
, 0); /* number of fields over which to ramp up sound level */
510 put_le32(pb
, 0); /* number of fields over which to ramp down sound level */
511 put_le32(pb
, 0); /* reserved */
512 put_le32(pb
, 0); /* reserved */
517 static int gxf_write_umf_media_mjpeg(ByteIOContext
*pb
, GXFStreamContext
*sc
)
519 put_be64(pb
, 0); /* FIXME FLOAT max chroma quant level */
520 put_be64(pb
, 0); /* FIXME FLOAT max luma quant level */
521 put_be64(pb
, 0); /* FIXME FLOAT min chroma quant level */
522 put_be64(pb
, 0); /* FIXME FLOAT min luma quant level */
527 static int gxf_write_umf_media_description(AVFormatContext
*s
)
529 GXFContext
*gxf
= s
->priv_data
;
530 ByteIOContext
*pb
= s
->pb
;
535 gxf
->umf_media_offset
= pos
- gxf
->umf_start_offset
;
536 for (i
= 0; i
<= s
->nb_streams
; ++i
) {
537 GXFStreamContext
*sc
;
538 int64_t startpos
, curpos
;
540 if (i
== s
->nb_streams
)
541 sc
= &gxf
->timecode_track
;
543 sc
= s
->streams
[i
]->priv_data
;
545 startpos
= url_ftell(pb
);
546 put_le16(pb
, 0); /* length */
547 put_le16(pb
, sc
->media_info
);
548 put_le16(pb
, 0); /* reserved */
549 put_le16(pb
, 0); /* reserved */
550 put_le32(pb
, gxf
->nb_fields
);
551 put_le32(pb
, 0); /* attributes rw, ro */
552 put_le32(pb
, 0); /* mark in */
553 put_le32(pb
, gxf
->nb_fields
); /* mark out */
554 put_buffer(pb
, ES_NAME_PATTERN
, sizeof(ES_NAME_PATTERN
));
555 put_be16(pb
, sc
->media_info
);
556 for (j
= sizeof(ES_NAME_PATTERN
)+2; j
< 88; j
++)
558 put_le32(pb
, sc
->track_type
);
559 put_le32(pb
, sc
->sample_rate
);
560 put_le32(pb
, sc
->sample_size
);
561 put_le32(pb
, 0); /* reserved */
563 if (sc
== &gxf
->timecode_track
)
564 gxf_write_umf_media_timecode(pb
, sc
); /* 8 0bytes */
566 AVStream
*st
= s
->streams
[i
];
567 switch (st
->codec
->codec_id
) {
568 case CODEC_ID_MPEG2VIDEO
:
569 gxf_write_umf_media_mpeg(pb
, st
);
571 case CODEC_ID_PCM_S16LE
:
572 gxf_write_umf_media_audio(pb
, sc
);
574 case CODEC_ID_DVVIDEO
:
575 gxf_write_umf_media_dv(pb
, sc
);
580 curpos
= url_ftell(pb
);
581 url_fseek(pb
, startpos
, SEEK_SET
);
582 put_le16(pb
, curpos
- startpos
);
583 url_fseek(pb
, curpos
, SEEK_SET
);
585 return url_ftell(pb
) - pos
;
588 static int gxf_write_umf_packet(AVFormatContext
*s
)
590 GXFContext
*gxf
= s
->priv_data
;
591 ByteIOContext
*pb
= s
->pb
;
592 int64_t pos
= url_ftell(pb
);
594 gxf_write_packet_header(pb
, PKT_UMF
);
597 put_byte(pb
, 3); /* first and last (only) packet */
598 put_be32(pb
, gxf
->umf_length
); /* data length */
600 gxf
->umf_start_offset
= url_ftell(pb
);
601 gxf_write_umf_payload(s
);
602 gxf_write_umf_material_description(s
);
603 gxf
->umf_track_size
= gxf_write_umf_track_description(s
);
604 gxf
->umf_media_size
= gxf_write_umf_media_description(s
);
605 gxf
->umf_length
= url_ftell(pb
) - gxf
->umf_start_offset
;
606 return updatePacketSize(pb
, pos
);
609 static const int GXF_samples_per_frame
[] = { 32768, 0 };
611 static void gxf_init_timecode_track(GXFStreamContext
*sc
, GXFStreamContext
*vsc
)
616 sc
->media_type
= vsc
->sample_rate
== 60 ? 7 : 8;
617 sc
->sample_rate
= vsc
->sample_rate
;
618 sc
->media_info
= ('T'<<8) | '0';
620 sc
->frame_rate_index
= vsc
->frame_rate_index
;
621 sc
->lines_index
= vsc
->lines_index
;
622 sc
->sample_size
= 16;
623 sc
->fields
= vsc
->fields
;
626 static int gxf_write_header(AVFormatContext
*s
)
628 ByteIOContext
*pb
= s
->pb
;
629 GXFContext
*gxf
= s
->priv_data
;
630 GXFStreamContext
*vsc
= NULL
;
631 uint8_t tracks
[255] = {0};
632 int i
, media_info
= 0;
634 if (url_is_streamed(pb
)) {
635 av_log(s
, AV_LOG_ERROR
, "gxf muxer does not support streamed output, patch welcome");
639 gxf
->flags
|= 0x00080000; /* material is simple clip */
640 for (i
= 0; i
< s
->nb_streams
; ++i
) {
641 AVStream
*st
= s
->streams
[i
];
642 GXFStreamContext
*sc
= av_mallocz(sizeof(*sc
));
644 return AVERROR(ENOMEM
);
647 sc
->media_type
= codec_get_tag(gxf_media_types
, st
->codec
->codec_id
);
648 if (st
->codec
->codec_type
== CODEC_TYPE_AUDIO
) {
649 if (st
->codec
->codec_id
!= CODEC_ID_PCM_S16LE
) {
650 av_log(s
, AV_LOG_ERROR
, "only 16 BIT PCM LE allowed for now\n");
653 if (st
->codec
->sample_rate
!= 48000) {
654 av_log(s
, AV_LOG_ERROR
, "only 48000hz sampling rate is allowed\n");
657 if (st
->codec
->channels
!= 1) {
658 av_log(s
, AV_LOG_ERROR
, "only mono tracks are allowed\n");
662 sc
->sample_rate
= st
->codec
->sample_rate
;
663 av_set_pts_info(st
, 64, 1, sc
->sample_rate
);
664 sc
->sample_size
= 16;
665 sc
->frame_rate_index
= -2;
666 sc
->lines_index
= -2;
669 gxf
->flags
|= 0x04000000; /* audio is 16 bit pcm */
671 } else if (st
->codec
->codec_type
== CODEC_TYPE_VIDEO
) {
673 av_log(s
, AV_LOG_ERROR
, "video stream must be the first track\n");
676 /* FIXME check from time_base ? */
677 if (st
->codec
->height
== 480 || st
->codec
->height
== 512) { /* NTSC or NTSC+VBI */
678 sc
->frame_rate_index
= 5;
679 sc
->sample_rate
= 60;
680 gxf
->flags
|= 0x00000080;
681 gxf
->time_base
= (AVRational
){ 1001, 60000 };
682 } else { /* assume PAL */
683 sc
->frame_rate_index
= 6;
685 sc
->sample_rate
= 50;
686 gxf
->flags
|= 0x00000040;
687 gxf
->time_base
= (AVRational
){ 1, 50 };
689 av_set_pts_info(st
, 64, gxf
->time_base
.num
, gxf
->time_base
.den
);
690 if (gxf_find_lines_index(st
) < 0)
691 sc
->lines_index
= -1;
692 sc
->sample_size
= st
->codec
->bit_rate
;
693 sc
->fields
= 2; /* interlaced */
697 switch (st
->codec
->codec_id
) {
700 gxf
->flags
|= 0x00004000;
703 case CODEC_ID_MPEG1VIDEO
:
708 case CODEC_ID_MPEG2VIDEO
:
709 sc
->first_gop_closed
= -1;
712 gxf
->flags
|= 0x00008000;
715 case CODEC_ID_DVVIDEO
:
716 if (st
->codec
->pix_fmt
== PIX_FMT_YUV422P
) {
719 gxf
->flags
|= 0x00002000;
723 gxf
->flags
|= 0x00001000;
728 av_log(s
, AV_LOG_ERROR
, "video codec not supported\n");
732 /* FIXME first 10 audio tracks are 0 to 9 next 22 are A to V */
733 sc
->media_info
= media_info
<<8 | ('0'+tracks
[media_info
]++);
734 sc
->order
= s
->nb_streams
- st
->index
;
737 if (ff_audio_interleave_init(s
, GXF_samples_per_frame
, (AVRational
){ 1, 48000 }) < 0)
740 gxf_init_timecode_track(&gxf
->timecode_track
, vsc
);
741 gxf
->flags
|= 0x200000; // time code track is non-drop frame
743 gxf_write_map_packet(s
, 0);
744 gxf_write_flt_packet(s
);
745 gxf_write_umf_packet(s
);
747 gxf
->packet_count
= 3;
749 put_flush_packet(pb
);
753 static int gxf_write_eos_packet(ByteIOContext
*pb
)
755 int64_t pos
= url_ftell(pb
);
757 gxf_write_packet_header(pb
, PKT_EOS
);
758 return updatePacketSize(pb
, pos
);
761 static int gxf_write_trailer(AVFormatContext
*s
)
763 GXFContext
*gxf
= s
->priv_data
;
764 ByteIOContext
*pb
= s
->pb
;
768 ff_audio_interleave_close(s
);
770 gxf_write_eos_packet(pb
);
772 url_fseek(pb
, 0, SEEK_SET
);
773 /* overwrite map, flt and umf packets with new values */
774 gxf_write_map_packet(s
, 1);
775 gxf_write_flt_packet(s
);
776 gxf_write_umf_packet(s
);
777 put_flush_packet(pb
);
778 /* update duration in all map packets */
779 for (i
= 1; i
< gxf
->map_offsets_nb
; i
++) {
780 url_fseek(pb
, gxf
->map_offsets
[i
], SEEK_SET
);
781 gxf_write_map_packet(s
, 1);
782 put_flush_packet(pb
);
785 url_fseek(pb
, end
, SEEK_SET
);
787 av_freep(&gxf
->flt_entries
);
788 av_freep(&gxf
->map_offsets
);
793 static int gxf_parse_mpeg_frame(GXFStreamContext
*sc
, const uint8_t *buf
, int size
)
797 for(i
=0; i
<size
-4 && c
!=0x100; i
++){
799 if(c
== 0x1B8 && sc
->first_gop_closed
== -1) /* GOP start code */
800 sc
->first_gop_closed
= (buf
[i
+4]>>6)&1;
802 return (buf
[i
+1]>>3)&7;
805 static int gxf_write_media_preamble(AVFormatContext
*s
, AVPacket
*pkt
, int size
)
807 GXFContext
*gxf
= s
->priv_data
;
808 ByteIOContext
*pb
= s
->pb
;
809 AVStream
*st
= s
->streams
[pkt
->stream_index
];
810 GXFStreamContext
*sc
= st
->priv_data
;
812 /* If the video is frame-encoded, the frame numbers shall be represented by
813 * even field numbers.
814 * see SMPTE360M-2004 6.4.2.1.3 Media field number */
815 if (st
->codec
->codec_type
== CODEC_TYPE_VIDEO
) {
816 field_nb
= gxf
->nb_fields
;
818 field_nb
= av_rescale_rnd(pkt
->dts
, gxf
->time_base
.den
,
819 (int64_t)48000*gxf
->time_base
.num
, AV_ROUND_UP
);
822 put_byte(pb
, sc
->media_type
);
823 put_byte(pb
, st
->index
);
824 put_be32(pb
, field_nb
);
825 if (st
->codec
->codec_type
== CODEC_TYPE_AUDIO
) {
827 put_be16(pb
, size
/ 2);
828 } else if (st
->codec
->codec_id
== CODEC_ID_MPEG2VIDEO
) {
829 int frame_type
= gxf_parse_mpeg_frame(sc
, pkt
->data
, pkt
->size
);
830 if (frame_type
== FF_I_TYPE
) {
833 } else if (frame_type
== FF_B_TYPE
) {
841 } else if (st
->codec
->codec_id
== CODEC_ID_DVVIDEO
) {
842 put_byte(pb
, size
/ 4096);
846 put_be32(pb
, field_nb
);
847 put_byte(pb
, 1); /* flags */
848 put_byte(pb
, 0); /* reserved */
852 static int gxf_write_packet(AVFormatContext
*s
, AVPacket
*pkt
)
854 GXFContext
*gxf
= s
->priv_data
;
855 ByteIOContext
*pb
= s
->pb
;
856 AVStream
*st
= s
->streams
[pkt
->stream_index
];
857 int64_t pos
= url_ftell(pb
);
860 gxf_write_packet_header(pb
, PKT_MEDIA
);
861 if (st
->codec
->codec_id
== CODEC_ID_MPEG2VIDEO
&& pkt
->size
% 4) /* MPEG-2 frames must be padded */
862 padding
= 4 - pkt
->size
% 4;
863 else if (st
->codec
->codec_type
== CODEC_TYPE_AUDIO
)
864 padding
= GXF_AUDIO_PACKET_SIZE
- pkt
->size
;
865 gxf_write_media_preamble(s
, pkt
, pkt
->size
+ padding
);
866 put_buffer(pb
, pkt
->data
, pkt
->size
);
867 gxf_write_padding(pb
, padding
);
869 if (st
->codec
->codec_type
== CODEC_TYPE_VIDEO
) {
870 if (!(gxf
->flt_entries_nb
% 500)) {
871 gxf
->flt_entries
= av_realloc(gxf
->flt_entries
,
872 (gxf
->flt_entries_nb
+500)*sizeof(*gxf
->flt_entries
));
873 if (!gxf
->flt_entries
) {
874 av_log(s
, AV_LOG_ERROR
, "could not reallocate flt entries\n");
878 gxf
->flt_entries
[gxf
->flt_entries_nb
++] = url_ftell(pb
) / 1024;
879 gxf
->nb_fields
+= 2; // count fields
882 updatePacketSize(pb
, pos
);
885 if (gxf
->packet_count
== 100) {
886 gxf_write_map_packet(s
, 0);
887 gxf
->packet_count
= 0;
890 put_flush_packet(pb
);
895 static int gxf_compare_field_nb(AVFormatContext
*s
, AVPacket
*next
, AVPacket
*cur
)
897 GXFContext
*gxf
= s
->priv_data
;
898 AVPacket
*pkt
[2] = { cur
, next
};
900 GXFStreamContext
*sc
[2];
902 for (i
= 0; i
< 2; i
++) {
903 AVStream
*st
= s
->streams
[pkt
[i
]->stream_index
];
904 sc
[i
] = st
->priv_data
;
905 if (st
->codec
->codec_type
== CODEC_TYPE_AUDIO
) {
906 field_nb
[i
] = av_rescale_rnd(pkt
[i
]->dts
, gxf
->time_base
.den
,
907 (int64_t)48000*gxf
->time_base
.num
, AV_ROUND_UP
);
908 field_nb
[i
] &= ~1; // compare against even field number because audio must be before video
910 field_nb
[i
] = pkt
[i
]->dts
; // dts are field based
913 return field_nb
[1] > field_nb
[0] ||
914 (field_nb
[1] == field_nb
[0] && sc
[1]->order
> sc
[0]->order
);
917 static int gxf_interleave_packet(AVFormatContext
*s
, AVPacket
*out
, AVPacket
*pkt
, int flush
)
919 if (pkt
&& s
->streams
[pkt
->stream_index
]->codec
->codec_type
== CODEC_TYPE_VIDEO
)
920 pkt
->duration
= 2; // enforce 2 fields
921 return ff_audio_rechunk_interleave(s
, out
, pkt
, flush
,
922 av_interleave_packet_per_dts
, gxf_compare_field_nb
);
925 AVOutputFormat gxf_muxer
= {
927 NULL_IF_CONFIG_SMALL("GXF format"),
938 gxf_interleave_packet
,