| /* | |
| * GXF muxer. | |
| * Copyright (c) 2006 SmartJog S.A., Baptiste Coudurier <baptiste dot coudurier at smartjog dot com> | |
| * | |
| * This file is part of FFmpeg. | |
| * | |
| * FFmpeg is free software; you can redistribute it and/or | |
| * modify it under the terms of the GNU Lesser General Public | |
| * License as published by the Free Software Foundation; either | |
| * version 2.1 of the License, or (at your option) any later version. | |
| * | |
| * FFmpeg is distributed in the hope that it will be useful, | |
| * 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 | |
| * License along with FFmpeg; if not, write to the Free Software | |
| * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
| */ | |
| #include "libavutil/avassert.h" | |
| #include "libavutil/intfloat.h" | |
| #include "libavutil/mathematics.h" | |
| #include "avformat.h" | |
| #include "avio_internal.h" | |
| #include "internal.h" | |
| #include "gxf.h" | |
| #include "mux.h" | |
| #define GXF_SAMPLES_PER_FRAME 32768 | |
| #define GXF_AUDIO_PACKET_SIZE 65536 | |
| #define GXF_TIMECODE(c, d, h, m, s, f) \ | |
| ((c) << 30 | (d) << 29 | (h) << 24 | (m) << 16 | (s) << 8 | (f)) | |
| typedef struct GXFTimecode{ | |
| int hh; | |
| int mm; | |
| int ss; | |
| int ff; | |
| int color; | |
| int drop; | |
| } GXFTimecode; | |
| typedef struct GXFStreamContext { | |
| int64_t pkt_cnt; | |
| uint32_t track_type; | |
| uint32_t sample_size; | |
| uint32_t sample_rate; | |
| uint16_t media_type; | |
| uint16_t media_info; | |
| int frame_rate_index; | |
| int lines_index; | |
| int fields; | |
| int iframes; | |
| int pframes; | |
| int bframes; | |
| int p_per_gop; | |
| int b_per_i_or_p; ///< number of B-frames per I-frame or P-frame | |
| int first_gop_closed; | |
| unsigned order; ///< interleaving order | |
| } GXFStreamContext; | |
| typedef struct GXFContext { | |
| AVClass *av_class; | |
| uint32_t nb_fields; | |
| uint16_t audio_tracks; | |
| uint16_t mpeg_tracks; | |
| int64_t creation_time; | |
| uint32_t umf_start_offset; | |
| uint32_t umf_track_offset; | |
| uint32_t umf_media_offset; | |
| uint32_t umf_length; | |
| uint16_t umf_track_size; | |
| uint16_t umf_media_size; | |
| AVRational time_base; | |
| int flags; | |
| GXFStreamContext timecode_track; | |
| unsigned *flt_entries; ///< offsets of packets /1024, starts after 2nd video field | |
| unsigned flt_entries_nb; | |
| uint64_t *map_offsets; ///< offset of map packets | |
| unsigned map_offsets_nb; | |
| unsigned packet_count; | |
| GXFTimecode tc; | |
| } GXFContext; | |
| static const struct { | |
| int height, index; | |
| } gxf_lines_tab[] = { | |
| { 480, 1 }, /* NTSC */ | |
| { 512, 1 }, /* NTSC + VBI */ | |
| { 576, 2 }, /* PAL */ | |
| { 608, 2 }, /* PAL + VBI */ | |
| { 1080, 4 }, | |
| { 720, 6 }, | |
| }; | |
| static const AVCodecTag gxf_media_types[] = { | |
| { AV_CODEC_ID_MJPEG , 3 }, /* NTSC */ | |
| { AV_CODEC_ID_MJPEG , 4 }, /* PAL */ | |
| { AV_CODEC_ID_PCM_S24LE , 9 }, | |
| { AV_CODEC_ID_PCM_S16LE , 10 }, | |
| { AV_CODEC_ID_MPEG2VIDEO, 11 }, /* NTSC */ | |
| { AV_CODEC_ID_MPEG2VIDEO, 12 }, /* PAL */ | |
| { AV_CODEC_ID_DVVIDEO , 13 }, /* NTSC */ | |
| { AV_CODEC_ID_DVVIDEO , 14 }, /* PAL */ | |
| { AV_CODEC_ID_DVVIDEO , 15 }, /* 50M NTSC */ | |
| { AV_CODEC_ID_DVVIDEO , 16 }, /* 50M PAL */ | |
| { AV_CODEC_ID_AC3 , 17 }, | |
| //{ AV_CODEC_ID_NONE, , 18 }, /* Non compressed 24 bit audio */ | |
| { AV_CODEC_ID_MPEG2VIDEO, 20 }, /* MPEG HD */ | |
| { AV_CODEC_ID_MPEG1VIDEO, 22 }, /* NTSC */ | |
| { AV_CODEC_ID_MPEG1VIDEO, 23 }, /* PAL */ | |
| { AV_CODEC_ID_NONE, 0 }, | |
| }; | |
| #define SERVER_PATH "EXT:/PDR/default/" | |
| #define ES_NAME_PATTERN "EXT:/PDR/default/ES." | |
| static int gxf_find_lines_index(AVStream *st) | |
| { | |
| GXFStreamContext *sc = st->priv_data; | |
| int i; | |
| for (i = 0; i < 6; ++i) { | |
| if (st->codecpar->height == gxf_lines_tab[i].height) { | |
| sc->lines_index = gxf_lines_tab[i].index; | |
| return 0; | |
| } | |
| } | |
| return -1; | |
| } | |
| static void gxf_write_padding(AVIOContext *pb, int64_t to_pad) | |
| { | |
| ffio_fill(pb, 0, to_pad); | |
| } | |
| static int64_t update_packet_size(AVIOContext *pb, int64_t pos) | |
| { | |
| int64_t curpos; | |
| int size; | |
| size = avio_tell(pb) - pos; | |
| if (size % 4) { | |
| gxf_write_padding(pb, 4 - size % 4); | |
| size = avio_tell(pb) - pos; | |
| } | |
| curpos = avio_tell(pb); | |
| avio_seek(pb, pos + 6, SEEK_SET); | |
| avio_wb32(pb, size); | |
| avio_seek(pb, curpos, SEEK_SET); | |
| return curpos - pos; | |
| } | |
| static int64_t update_size(AVIOContext *pb, int64_t pos) | |
| { | |
| int64_t curpos; | |
| curpos = avio_tell(pb); | |
| avio_seek(pb, pos, SEEK_SET); | |
| avio_wb16(pb, curpos - pos - 2); | |
| avio_seek(pb, curpos, SEEK_SET); | |
| return curpos - pos; | |
| } | |
| static void gxf_write_packet_header(AVIOContext *pb, GXFPktType type) | |
| { | |
| avio_wb32(pb, 0); /* packet leader for synchro */ | |
| avio_w8(pb, 1); | |
| avio_w8(pb, type); /* map packet */ | |
| avio_wb32(pb, 0); /* size */ | |
| avio_wb32(pb, 0); /* reserved */ | |
| avio_w8(pb, 0xE1); /* trailer 1 */ | |
| avio_w8(pb, 0xE2); /* trailer 2 */ | |
| } | |
| static int gxf_write_mpeg_auxiliary(AVIOContext *pb, AVStream *st) | |
| { | |
| GXFStreamContext *sc = st->priv_data; | |
| char buffer[1024]; | |
| int size, starting_line; | |
| if (sc->iframes) { | |
| sc->p_per_gop = sc->pframes / sc->iframes; | |
| if (sc->pframes % sc->iframes) | |
| sc->p_per_gop++; | |
| if (sc->pframes) { | |
| sc->b_per_i_or_p = sc->bframes / sc->pframes; | |
| if (sc->bframes % sc->pframes) | |
| sc->b_per_i_or_p++; | |
| } | |
| if (sc->p_per_gop > 9) | |
| sc->p_per_gop = 9; /* ensure value won't take more than one char */ | |
| if (sc->b_per_i_or_p > 9) | |
| sc->b_per_i_or_p = 9; /* ensure value won't take more than one char */ | |
| } | |
| if (st->codecpar->height == 512 || st->codecpar->height == 608) | |
| starting_line = 7; // VBI | |
| else if (st->codecpar->height == 480) | |
| starting_line = 20; | |
| else | |
| starting_line = 23; // default PAL | |
| size = snprintf(buffer, sizeof(buffer), "Ver 1\nBr %.6f\nIpg 1\nPpi %d\nBpiop %d\n" | |
| "Pix 0\nCf %d\nCg %d\nSl %d\nnl16 %d\nVi 1\nf1 1\n", | |
| (float)st->codecpar->bit_rate, sc->p_per_gop, sc->b_per_i_or_p, | |
| st->codecpar->format == AV_PIX_FMT_YUV422P ? 2 : 1, sc->first_gop_closed == 1, | |
| starting_line, (st->codecpar->height + 15) / 16); | |
| av_assert0(size < sizeof(buffer)); | |
| avio_w8(pb, TRACK_MPG_AUX); | |
| avio_w8(pb, size + 1); | |
| avio_write(pb, (uint8_t *)buffer, size + 1); | |
| return size + 3; | |
| } | |
| static int gxf_write_dv_auxiliary(AVIOContext *pb, AVStream *st) | |
| { | |
| int64_t track_aux_data = 0; | |
| avio_w8(pb, TRACK_AUX); | |
| avio_w8(pb, 8); | |
| if (st->codecpar->format == AV_PIX_FMT_YUV420P) | |
| track_aux_data |= 0x01; /* marks stream as DVCAM instead of DVPRO */ | |
| track_aux_data |= 0x40000000; /* aux data is valid */ | |
| avio_wl64(pb, track_aux_data); | |
| return 8; | |
| } | |
| static int gxf_write_timecode_auxiliary(AVIOContext *pb, GXFContext *gxf) | |
| { | |
| uint32_t timecode = GXF_TIMECODE(gxf->tc.color, gxf->tc.drop, | |
| gxf->tc.hh, gxf->tc.mm, | |
| gxf->tc.ss, gxf->tc.ff); | |
| avio_w8(pb, TRACK_AUX); | |
| avio_w8(pb, 8); | |
| avio_wl32(pb, timecode); | |
| /* reserved */ | |
| avio_wl32(pb, 0); | |
| return 8; | |
| } | |
| static int gxf_write_track_description(AVFormatContext *s, GXFStreamContext *sc, int index) | |
| { | |
| GXFContext *gxf = s->priv_data; | |
| AVIOContext *pb = s->pb; | |
| int64_t pos; | |
| /* track description section */ | |
| avio_w8(pb, sc->media_type + 0x80); | |
| avio_w8(pb, index + 0xC0); | |
| pos = avio_tell(pb); | |
| avio_wb16(pb, 0); /* size */ | |
| /* media file name */ | |
| avio_w8(pb, TRACK_NAME); | |
| avio_w8(pb, strlen(ES_NAME_PATTERN) + 3); | |
| avio_write(pb, ES_NAME_PATTERN, sizeof(ES_NAME_PATTERN) - 1); | |
| avio_wb16(pb, sc->media_info); | |
| avio_w8(pb, 0); | |
| switch (sc->track_type) { | |
| case 3: /* timecode */ | |
| gxf_write_timecode_auxiliary(pb, gxf); | |
| break; | |
| case 4: /* MPEG2 */ | |
| case 9: /* MPEG1 */ | |
| gxf_write_mpeg_auxiliary(pb, s->streams[index]); | |
| break; | |
| case 5: /* DV25 */ | |
| case 6: /* DV50 */ | |
| gxf_write_dv_auxiliary(pb, s->streams[index]); | |
| break; | |
| default: | |
| avio_w8(pb, TRACK_AUX); | |
| avio_w8(pb, 8); | |
| avio_wl64(pb, 0); | |
| } | |
| /* file system version */ | |
| avio_w8(pb, TRACK_VER); | |
| avio_w8(pb, 4); | |
| avio_wb32(pb, 0); | |
| /* frame rate */ | |
| avio_w8(pb, TRACK_FPS); | |
| avio_w8(pb, 4); | |
| avio_wb32(pb, sc->frame_rate_index); | |
| /* lines per frame */ | |
| avio_w8(pb, TRACK_LINES); | |
| avio_w8(pb, 4); | |
| avio_wb32(pb, sc->lines_index); | |
| /* fields per frame */ | |
| avio_w8(pb, TRACK_FPF); | |
| avio_w8(pb, 4); | |
| avio_wb32(pb, sc->fields); | |
| return update_size(pb, pos); | |
| } | |
| static int gxf_write_material_data_section(AVFormatContext *s) | |
| { | |
| GXFContext *gxf = s->priv_data; | |
| AVIOContext *pb = s->pb; | |
| int64_t pos; | |
| int len; | |
| const char *filename = strrchr(s->url, '/'); | |
| pos = avio_tell(pb); | |
| avio_wb16(pb, 0); /* size */ | |
| /* name */ | |
| if (filename) | |
| filename++; | |
| else | |
| filename = s->url; | |
| len = strlen(filename); | |
| avio_w8(pb, MAT_NAME); | |
| avio_w8(pb, strlen(SERVER_PATH) + len + 1); | |
| avio_write(pb, SERVER_PATH, sizeof(SERVER_PATH) - 1); | |
| avio_write(pb, filename, len); | |
| avio_w8(pb, 0); | |
| /* first field */ | |
| avio_w8(pb, MAT_FIRST_FIELD); | |
| avio_w8(pb, 4); | |
| avio_wb32(pb, 0); | |
| /* last field */ | |
| avio_w8(pb, MAT_LAST_FIELD); | |
| avio_w8(pb, 4); | |
| avio_wb32(pb, gxf->nb_fields); | |
| /* reserved */ | |
| avio_w8(pb, MAT_MARK_IN); | |
| avio_w8(pb, 4); | |
| avio_wb32(pb, 0); | |
| avio_w8(pb, MAT_MARK_OUT); | |
| avio_w8(pb, 4); | |
| avio_wb32(pb, gxf->nb_fields); | |
| /* estimated size */ | |
| avio_w8(pb, MAT_SIZE); | |
| avio_w8(pb, 4); | |
| avio_wb32(pb, avio_size(pb) / 1024); | |
| return update_size(pb, pos); | |
| } | |
| static int gxf_write_track_description_section(AVFormatContext *s) | |
| { | |
| GXFContext *gxf = s->priv_data; | |
| AVIOContext *pb = s->pb; | |
| int64_t pos; | |
| int i; | |
| pos = avio_tell(pb); | |
| avio_wb16(pb, 0); /* size */ | |
| for (i = 0; i < s->nb_streams; ++i) | |
| gxf_write_track_description(s, s->streams[i]->priv_data, i); | |
| gxf_write_track_description(s, &gxf->timecode_track, s->nb_streams); | |
| return update_size(pb, pos); | |
| } | |
| static int gxf_write_map_packet(AVFormatContext *s, int rewrite) | |
| { | |
| GXFContext *gxf = s->priv_data; | |
| AVIOContext *pb = s->pb; | |
| int64_t pos = avio_tell(pb); | |
| if (!rewrite) { | |
| if (!(gxf->map_offsets_nb % 30)) { | |
| int err; | |
| if ((err = av_reallocp_array(&gxf->map_offsets, | |
| gxf->map_offsets_nb + 30, | |
| sizeof(*gxf->map_offsets))) < 0) { | |
| gxf->map_offsets_nb = 0; | |
| av_log(s, AV_LOG_ERROR, "could not realloc map offsets\n"); | |
| return err; | |
| } | |
| } | |
| gxf->map_offsets[gxf->map_offsets_nb++] = pos; // do not increment here | |
| } | |
| gxf_write_packet_header(pb, PKT_MAP); | |
| /* preamble */ | |
| avio_w8(pb, 0xE0); /* version */ | |
| avio_w8(pb, 0xFF); /* reserved */ | |
| gxf_write_material_data_section(s); | |
| gxf_write_track_description_section(s); | |
| return update_packet_size(pb, pos); | |
| } | |
| static int gxf_write_flt_packet(AVFormatContext *s) | |
| { | |
| GXFContext *gxf = s->priv_data; | |
| AVIOContext *pb = s->pb; | |
| int64_t pos = avio_tell(pb); | |
| int fields_per_flt = (gxf->nb_fields+1) / 1000 + 1; | |
| int flt_entries = gxf->nb_fields / fields_per_flt; | |
| int i = 0; | |
| gxf_write_packet_header(pb, PKT_FLT); | |
| avio_wl32(pb, fields_per_flt); /* number of fields */ | |
| avio_wl32(pb, flt_entries); /* number of active flt entries */ | |
| if (gxf->flt_entries) { | |
| for (i = 0; i < flt_entries; i++) | |
| avio_wl32(pb, gxf->flt_entries[(i*fields_per_flt)>>1]); | |
| } | |
| ffio_fill(pb, 0, (1000 - i) * 4); | |
| return update_packet_size(pb, pos); | |
| } | |
| static int gxf_write_umf_material_description(AVFormatContext *s) | |
| { | |
| GXFContext *gxf = s->priv_data; | |
| AVIOContext *pb = s->pb; | |
| int timecode_base = gxf->time_base.den == 60000 ? 60 : 50; | |
| int64_t timestamp = 0; | |
| uint64_t nb_fields; | |
| uint32_t timecode_in; // timecode at mark in | |
| uint32_t timecode_out; // timecode at mark out | |
| ff_parse_creation_time_metadata(s, ×tamp, 1); | |
| timecode_in = GXF_TIMECODE(gxf->tc.color, gxf->tc.drop, | |
| gxf->tc.hh, gxf->tc.mm, | |
| gxf->tc.ss, gxf->tc.ff); | |
| nb_fields = gxf->nb_fields + | |
| gxf->tc.hh * (timecode_base * 3600) + | |
| gxf->tc.mm * (timecode_base * 60) + | |
| gxf->tc.ss * timecode_base + | |
| gxf->tc.ff; | |
| timecode_out = GXF_TIMECODE(gxf->tc.color, gxf->tc.drop, | |
| nb_fields / (timecode_base * 3600) % 24, | |
| nb_fields / (timecode_base * 60) % 60, | |
| nb_fields / timecode_base % 60, | |
| nb_fields % timecode_base); | |
| avio_wl32(pb, gxf->flags); | |
| avio_wl32(pb, gxf->nb_fields); /* length of the longest track */ | |
| avio_wl32(pb, gxf->nb_fields); /* length of the shortest track */ | |
| avio_wl32(pb, 0); /* mark in */ | |
| avio_wl32(pb, gxf->nb_fields); /* mark out */ | |
| avio_wl32(pb, timecode_in); /* timecode mark in */ | |
| avio_wl32(pb, timecode_out); /* timecode mark out */ | |
| avio_wl64(pb, timestamp); /* modification time */ | |
| avio_wl64(pb, timestamp); /* creation time */ | |
| avio_wl16(pb, 0); /* reserved */ | |
| avio_wl16(pb, 0); /* reserved */ | |
| avio_wl16(pb, gxf->audio_tracks); | |
| avio_wl16(pb, 1); /* timecode track count */ | |
| avio_wl16(pb, 0); /* reserved */ | |
| avio_wl16(pb, gxf->mpeg_tracks); | |
| return 48; | |
| } | |
| static int gxf_write_umf_payload(AVFormatContext *s) | |
| { | |
| GXFContext *gxf = s->priv_data; | |
| AVIOContext *pb = s->pb; | |
| avio_wl32(pb, gxf->umf_length); /* total length of the umf data */ | |
| avio_wl32(pb, 3); /* version */ | |
| avio_wl32(pb, s->nb_streams+1); | |
| avio_wl32(pb, gxf->umf_track_offset); /* umf track section offset */ | |
| avio_wl32(pb, gxf->umf_track_size); | |
| avio_wl32(pb, s->nb_streams+1); | |
| avio_wl32(pb, gxf->umf_media_offset); | |
| avio_wl32(pb, gxf->umf_media_size); | |
| avio_wl32(pb, gxf->umf_length); /* user data offset */ | |
| avio_wl32(pb, 0); /* user data size */ | |
| avio_wl32(pb, 0); /* reserved */ | |
| avio_wl32(pb, 0); /* reserved */ | |
| return 48; | |
| } | |
| static int gxf_write_umf_track_description(AVFormatContext *s) | |
| { | |
| AVIOContext *pb = s->pb; | |
| GXFContext *gxf = s->priv_data; | |
| int64_t pos = avio_tell(pb); | |
| int i; | |
| gxf->umf_track_offset = pos - gxf->umf_start_offset; | |
| for (i = 0; i < s->nb_streams; ++i) { | |
| GXFStreamContext *sc = s->streams[i]->priv_data; | |
| avio_wl16(pb, sc->media_info); | |
| avio_wl16(pb, 1); | |
| } | |
| avio_wl16(pb, gxf->timecode_track.media_info); | |
| avio_wl16(pb, 1); | |
| return avio_tell(pb) - pos; | |
| } | |
| static int gxf_write_umf_media_mpeg(AVIOContext *pb, AVStream *st) | |
| { | |
| GXFStreamContext *sc = st->priv_data; | |
| if (st->codecpar->format == AV_PIX_FMT_YUV422P) | |
| avio_wl32(pb, 2); | |
| else | |
| avio_wl32(pb, 1); /* default to 420 */ | |
| avio_wl32(pb, sc->first_gop_closed == 1); /* closed = 1, open = 0, unknown = 255 */ | |
| avio_wl32(pb, 3); /* top = 1, bottom = 2, frame = 3, unknown = 0 */ | |
| avio_wl32(pb, 1); /* I picture per GOP */ | |
| avio_wl32(pb, sc->p_per_gop); | |
| avio_wl32(pb, sc->b_per_i_or_p); | |
| if (st->codecpar->codec_id == AV_CODEC_ID_MPEG2VIDEO) | |
| avio_wl32(pb, 2); | |
| else if (st->codecpar->codec_id == AV_CODEC_ID_MPEG1VIDEO) | |
| avio_wl32(pb, 1); | |
| else | |
| avio_wl32(pb, 0); | |
| avio_wl32(pb, 0); /* reserved */ | |
| return 32; | |
| } | |
| static int gxf_write_umf_media_timecode(AVIOContext *pb, int drop) | |
| { | |
| avio_wl32(pb, drop); /* drop frame */ | |
| ffio_fill(pb, 0, 7 * 4); /* reserved */ | |
| return 32; | |
| } | |
| static int gxf_write_umf_media_dv(AVIOContext *pb, GXFStreamContext *sc, AVStream *st) | |
| { | |
| int dv_umf_data = 0; | |
| if (st->codecpar->format == AV_PIX_FMT_YUV420P) | |
| dv_umf_data |= 0x20; /* marks as DVCAM instead of DVPRO */ | |
| avio_wl32(pb, dv_umf_data); | |
| ffio_fill(pb, 0, 7 * 4); | |
| return 32; | |
| } | |
| static int gxf_write_umf_media_audio(AVIOContext *pb, GXFStreamContext *sc) | |
| { | |
| avio_wl64(pb, av_double2int(1)); /* sound level to begin to */ | |
| avio_wl64(pb, av_double2int(1)); /* sound level to begin to */ | |
| avio_wl32(pb, 0); /* number of fields over which to ramp up sound level */ | |
| avio_wl32(pb, 0); /* number of fields over which to ramp down sound level */ | |
| avio_wl32(pb, 0); /* reserved */ | |
| avio_wl32(pb, 0); /* reserved */ | |
| return 32; | |
| } | |
| static int gxf_write_umf_media_description(AVFormatContext *s) | |
| { | |
| GXFContext *gxf = s->priv_data; | |
| AVIOContext *pb = s->pb; | |
| int64_t pos; | |
| pos = avio_tell(pb); | |
| gxf->umf_media_offset = pos - gxf->umf_start_offset; | |
| for (unsigned i = 0; i <= s->nb_streams; ++i) { | |
| GXFStreamContext *sc; | |
| int64_t startpos, curpos; | |
| if (i == s->nb_streams) | |
| sc = &gxf->timecode_track; | |
| else | |
| sc = s->streams[i]->priv_data; | |
| startpos = avio_tell(pb); | |
| avio_wl16(pb, 0); /* length */ | |
| avio_wl16(pb, sc->media_info); | |
| avio_wl16(pb, 0); /* reserved */ | |
| avio_wl16(pb, 0); /* reserved */ | |
| avio_wl32(pb, gxf->nb_fields); | |
| avio_wl32(pb, 0); /* attributes rw, ro */ | |
| avio_wl32(pb, 0); /* mark in */ | |
| avio_wl32(pb, gxf->nb_fields); /* mark out */ | |
| avio_write(pb, ES_NAME_PATTERN, strlen(ES_NAME_PATTERN)); | |
| avio_wb16(pb, sc->media_info); | |
| ffio_fill(pb, 0, 88 - (strlen(ES_NAME_PATTERN) + 2)); | |
| avio_wl32(pb, sc->track_type); | |
| avio_wl32(pb, sc->sample_rate); | |
| avio_wl32(pb, sc->sample_size); | |
| avio_wl32(pb, 0); /* reserved */ | |
| if (sc == &gxf->timecode_track) | |
| gxf_write_umf_media_timecode(pb, gxf->tc.drop); | |
| else { | |
| AVStream *st = s->streams[i]; | |
| switch (st->codecpar->codec_id) { | |
| case AV_CODEC_ID_MPEG1VIDEO: | |
| case AV_CODEC_ID_MPEG2VIDEO: | |
| gxf_write_umf_media_mpeg(pb, st); | |
| break; | |
| case AV_CODEC_ID_PCM_S16LE: | |
| gxf_write_umf_media_audio(pb, sc); | |
| break; | |
| case AV_CODEC_ID_DVVIDEO: | |
| gxf_write_umf_media_dv(pb, sc, st); | |
| break; | |
| } | |
| } | |
| curpos = avio_tell(pb); | |
| avio_seek(pb, startpos, SEEK_SET); | |
| avio_wl16(pb, curpos - startpos); | |
| avio_seek(pb, curpos, SEEK_SET); | |
| } | |
| return avio_tell(pb) - pos; | |
| } | |
| static int gxf_write_umf_packet(AVFormatContext *s) | |
| { | |
| GXFContext *gxf = s->priv_data; | |
| AVIOContext *pb = s->pb; | |
| int64_t pos = avio_tell(pb); | |
| gxf_write_packet_header(pb, PKT_UMF); | |
| /* preamble */ | |
| avio_w8(pb, 3); /* first and last (only) packet */ | |
| avio_wb32(pb, gxf->umf_length); /* data length */ | |
| gxf->umf_start_offset = avio_tell(pb); | |
| gxf_write_umf_payload(s); | |
| gxf_write_umf_material_description(s); | |
| gxf->umf_track_size = gxf_write_umf_track_description(s); | |
| gxf->umf_media_size = gxf_write_umf_media_description(s); | |
| gxf->umf_length = avio_tell(pb) - gxf->umf_start_offset; | |
| return update_packet_size(pb, pos); | |
| } | |
| static void gxf_init_timecode_track(GXFStreamContext *sc, GXFStreamContext *vsc) | |
| { | |
| if (!vsc) | |
| return; | |
| sc->media_type = vsc->sample_rate == 60 ? 7 : 8; | |
| sc->sample_rate = vsc->sample_rate; | |
| sc->media_info = ('T'<<8) | '0'; | |
| sc->track_type = 3; | |
| sc->frame_rate_index = vsc->frame_rate_index; | |
| sc->lines_index = vsc->lines_index; | |
| sc->sample_size = 16; | |
| sc->fields = vsc->fields; | |
| } | |
| static int gxf_init_timecode(AVFormatContext *s, GXFTimecode *tc, const char *tcstr, int fields) | |
| { | |
| char c; | |
| if (sscanf(tcstr, "%d:%d:%d%c%d", &tc->hh, &tc->mm, &tc->ss, &c, &tc->ff) != 5) { | |
| av_log(s, AV_LOG_ERROR, "unable to parse timecode, " | |
| "syntax: hh:mm:ss[:;.]ff\n"); | |
| return -1; | |
| } | |
| tc->color = 0; | |
| tc->drop = c != ':'; | |
| if (fields == 2) | |
| tc->ff = tc->ff * 2; | |
| return 0; | |
| } | |
| static int gxf_write_header(AVFormatContext *s) | |
| { | |
| AVIOContext *pb = s->pb; | |
| GXFContext *gxf = s->priv_data; | |
| GXFStreamContext *vsc = NULL; | |
| uint8_t tracks[255] = {0}; | |
| int i, media_info = 0; | |
| int ret; | |
| AVDictionaryEntry *tcr = av_dict_get(s->metadata, "timecode", NULL, 0); | |
| if (!(pb->seekable & AVIO_SEEKABLE_NORMAL)) { | |
| av_log(s, AV_LOG_ERROR, "gxf muxer does not support streamed output, patch welcome\n"); | |
| return AVERROR_PATCHWELCOME; | |
| } | |
| gxf->flags |= 0x00080000; /* material is simple clip */ | |
| for (i = 0; i < s->nb_streams; ++i) { | |
| AVStream *st = s->streams[i]; | |
| GXFStreamContext *sc = av_mallocz(sizeof(*sc)); | |
| if (!sc) | |
| return AVERROR(ENOMEM); | |
| st->priv_data = sc; | |
| sc->media_type = ff_codec_get_tag(gxf_media_types, st->codecpar->codec_id); | |
| if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) { | |
| if (st->codecpar->codec_id != AV_CODEC_ID_PCM_S16LE) { | |
| av_log(s, AV_LOG_ERROR, "only 16 BIT PCM LE allowed for now\n"); | |
| return AVERROR(EINVAL); | |
| } | |
| if (st->codecpar->sample_rate != 48000) { | |
| av_log(s, AV_LOG_ERROR, "only 48000hz sampling rate is allowed\n"); | |
| return AVERROR(EINVAL); | |
| } | |
| if (st->codecpar->ch_layout.nb_channels != 1) { | |
| av_log(s, AV_LOG_ERROR, "only mono tracks are allowed\n"); | |
| return AVERROR(EINVAL); | |
| } | |
| ret = ff_stream_add_bitstream_filter(st, "pcm_rechunk", "n="AV_STRINGIFY(GXF_SAMPLES_PER_FRAME)); | |
| if (ret < 0) | |
| return ret; | |
| sc->track_type = 2; | |
| sc->sample_rate = st->codecpar->sample_rate; | |
| avpriv_set_pts_info(st, 64, 1, sc->sample_rate); | |
| sc->sample_size = 16; | |
| sc->frame_rate_index = -2; | |
| sc->lines_index = -2; | |
| sc->fields = -2; | |
| gxf->audio_tracks++; | |
| gxf->flags |= 0x04000000; /* audio is 16 bit pcm */ | |
| media_info = 'A'; | |
| } else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) { | |
| if (i != 0) { | |
| av_log(s, AV_LOG_ERROR, "video stream must be the first track\n"); | |
| return AVERROR(EINVAL); | |
| } | |
| /* FIXME check from time_base ? */ | |
| if (st->codecpar->height == 480 || st->codecpar->height == 512) { /* NTSC or NTSC+VBI */ | |
| sc->frame_rate_index = 5; | |
| sc->sample_rate = 60; | |
| gxf->flags |= 0x00000080; | |
| gxf->time_base = (AVRational){ 1001, 60000 }; | |
| } else if (st->codecpar->height == 576 || st->codecpar->height == 608) { /* PAL or PAL+VBI */ | |
| sc->frame_rate_index = 6; | |
| sc->media_type++; | |
| sc->sample_rate = 50; | |
| gxf->flags |= 0x00000040; | |
| gxf->time_base = (AVRational){ 1, 50 }; | |
| } else { | |
| av_log(s, AV_LOG_ERROR, "unsupported video resolution, " | |
| "gxf muxer only accepts PAL or NTSC resolutions currently\n"); | |
| return AVERROR(EINVAL); | |
| } | |
| if (!tcr) | |
| tcr = av_dict_get(st->metadata, "timecode", NULL, 0); | |
| avpriv_set_pts_info(st, 64, gxf->time_base.num, gxf->time_base.den); | |
| if (gxf_find_lines_index(st) < 0) | |
| sc->lines_index = -1; | |
| sc->sample_size = st->codecpar->bit_rate; | |
| sc->fields = 2; /* interlaced */ | |
| vsc = sc; | |
| switch (st->codecpar->codec_id) { | |
| case AV_CODEC_ID_MJPEG: | |
| sc->track_type = 1; | |
| gxf->flags |= 0x00004000; | |
| media_info = 'J'; | |
| break; | |
| case AV_CODEC_ID_MPEG1VIDEO: | |
| sc->track_type = 9; | |
| gxf->mpeg_tracks++; | |
| media_info = 'L'; | |
| break; | |
| case AV_CODEC_ID_MPEG2VIDEO: | |
| sc->first_gop_closed = -1; | |
| sc->track_type = 4; | |
| gxf->mpeg_tracks++; | |
| gxf->flags |= 0x00008000; | |
| media_info = 'M'; | |
| break; | |
| case AV_CODEC_ID_DVVIDEO: | |
| if (st->codecpar->format == AV_PIX_FMT_YUV422P) { | |
| sc->media_type += 2; | |
| sc->track_type = 6; | |
| gxf->flags |= 0x00002000; | |
| media_info = 'E'; | |
| } else { | |
| sc->track_type = 5; | |
| gxf->flags |= 0x00001000; | |
| media_info = 'D'; | |
| } | |
| break; | |
| default: | |
| av_log(s, AV_LOG_ERROR, "video codec not supported\n"); | |
| return -1; | |
| } | |
| } | |
| /* FIXME first 10 audio tracks are 0 to 9 next 22 are A to V */ | |
| sc->media_info = media_info<<8 | ('0'+tracks[media_info]++); | |
| sc->order = s->nb_streams - st->index; | |
| } | |
| if (tcr && vsc) | |
| gxf_init_timecode(s, &gxf->tc, tcr->value, vsc->fields); | |
| gxf_init_timecode_track(&gxf->timecode_track, vsc); | |
| gxf->flags |= 0x200000; // time code track is non-drop frame | |
| if ((ret = gxf_write_map_packet(s, 0)) < 0) | |
| return ret; | |
| gxf_write_flt_packet(s); | |
| gxf_write_umf_packet(s); | |
| gxf->packet_count = 3; | |
| return 0; | |
| } | |
| static int gxf_write_eos_packet(AVIOContext *pb) | |
| { | |
| int64_t pos = avio_tell(pb); | |
| gxf_write_packet_header(pb, PKT_EOS); | |
| return update_packet_size(pb, pos); | |
| } | |
| static int gxf_write_trailer(AVFormatContext *s) | |
| { | |
| GXFContext *gxf = s->priv_data; | |
| AVIOContext *pb = s->pb; | |
| int64_t end; | |
| int i; | |
| int ret; | |
| gxf_write_eos_packet(pb); | |
| end = avio_tell(pb); | |
| avio_seek(pb, 0, SEEK_SET); | |
| /* overwrite map, flt and umf packets with new values */ | |
| if ((ret = gxf_write_map_packet(s, 1)) < 0) | |
| return ret; | |
| gxf_write_flt_packet(s); | |
| gxf_write_umf_packet(s); | |
| /* update duration in all map packets */ | |
| for (i = 1; i < gxf->map_offsets_nb; i++) { | |
| avio_seek(pb, gxf->map_offsets[i], SEEK_SET); | |
| if ((ret = gxf_write_map_packet(s, 1)) < 0) | |
| return ret; | |
| } | |
| avio_seek(pb, end, SEEK_SET); | |
| return 0; | |
| } | |
| static void gxf_deinit(AVFormatContext *s) | |
| { | |
| GXFContext *gxf = s->priv_data; | |
| av_freep(&gxf->flt_entries); | |
| av_freep(&gxf->map_offsets); | |
| } | |
| static int gxf_parse_mpeg_frame(GXFStreamContext *sc, const uint8_t *buf, int size) | |
| { | |
| uint32_t c=-1; | |
| int i; | |
| for(i=0; i<size-4 && c!=0x100; i++){ | |
| c = (c<<8) + buf[i]; | |
| if(c == 0x1B8 && sc->first_gop_closed == -1) /* GOP start code */ | |
| sc->first_gop_closed= (buf[i+4]>>6)&1; | |
| } | |
| return (buf[i+1]>>3)&7; | |
| } | |
| static int gxf_write_media_preamble(AVFormatContext *s, AVPacket *pkt, int size) | |
| { | |
| GXFContext *gxf = s->priv_data; | |
| AVIOContext *pb = s->pb; | |
| AVStream *st = s->streams[pkt->stream_index]; | |
| GXFStreamContext *sc = st->priv_data; | |
| unsigned field_nb; | |
| /* If the video is frame-encoded, the frame numbers shall be represented by | |
| * even field numbers. | |
| * see SMPTE360M-2004 6.4.2.1.3 Media field number */ | |
| if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) { | |
| field_nb = gxf->nb_fields; | |
| } else { | |
| field_nb = av_rescale_rnd(pkt->dts, gxf->time_base.den, | |
| (int64_t)48000*gxf->time_base.num, AV_ROUND_UP); | |
| } | |
| avio_w8(pb, sc->media_type); | |
| avio_w8(pb, st->index); | |
| avio_wb32(pb, field_nb); | |
| if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) { | |
| avio_wb16(pb, 0); | |
| avio_wb16(pb, size / 2); | |
| } else if (st->codecpar->codec_id == AV_CODEC_ID_MPEG2VIDEO) { | |
| int frame_type = gxf_parse_mpeg_frame(sc, pkt->data, pkt->size); | |
| if (frame_type == AV_PICTURE_TYPE_I) { | |
| avio_w8(pb, 0x0d); | |
| sc->iframes++; | |
| } else if (frame_type == AV_PICTURE_TYPE_B) { | |
| avio_w8(pb, 0x0f); | |
| sc->bframes++; | |
| } else { | |
| avio_w8(pb, 0x0e); | |
| sc->pframes++; | |
| } | |
| avio_wb24(pb, size); | |
| } else if (st->codecpar->codec_id == AV_CODEC_ID_DVVIDEO) { | |
| avio_w8(pb, size / 4096); | |
| avio_wb24(pb, 0); | |
| } else | |
| avio_wb32(pb, size); | |
| avio_wb32(pb, field_nb); | |
| avio_w8(pb, 1); /* flags */ | |
| avio_w8(pb, 0); /* reserved */ | |
| return 16; | |
| } | |
| static int gxf_write_packet(AVFormatContext *s, AVPacket *pkt) | |
| { | |
| GXFContext *gxf = s->priv_data; | |
| AVIOContext *pb = s->pb; | |
| AVStream *st = s->streams[pkt->stream_index]; | |
| int64_t pos = avio_tell(pb); | |
| int padding = 0; | |
| unsigned packet_start_offset = avio_tell(pb) / 1024; | |
| int ret; | |
| gxf_write_packet_header(pb, PKT_MEDIA); | |
| if (st->codecpar->codec_id == AV_CODEC_ID_MPEG2VIDEO && pkt->size % 4) /* MPEG-2 frames must be padded */ | |
| padding = 4 - pkt->size % 4; | |
| else if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) | |
| padding = GXF_AUDIO_PACKET_SIZE - pkt->size; | |
| gxf_write_media_preamble(s, pkt, pkt->size + padding); | |
| avio_write(pb, pkt->data, pkt->size); | |
| gxf_write_padding(pb, padding); | |
| if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) { | |
| if (!(gxf->flt_entries_nb % 500)) { | |
| int err; | |
| if ((err = av_reallocp_array(&gxf->flt_entries, | |
| gxf->flt_entries_nb + 500, | |
| sizeof(*gxf->flt_entries))) < 0) { | |
| gxf->flt_entries_nb = 0; | |
| gxf->nb_fields = 0; | |
| av_log(s, AV_LOG_ERROR, "could not reallocate flt entries\n"); | |
| return err; | |
| } | |
| } | |
| gxf->flt_entries[gxf->flt_entries_nb++] = packet_start_offset; | |
| gxf->nb_fields += 2; // count fields | |
| } | |
| update_packet_size(pb, pos); | |
| gxf->packet_count++; | |
| if (gxf->packet_count == 100) { | |
| if ((ret = gxf_write_map_packet(s, 0)) < 0) | |
| return ret; | |
| gxf->packet_count = 0; | |
| } | |
| return 0; | |
| } | |
| static int gxf_compare_field_nb(AVFormatContext *s, const AVPacket *next, | |
| const AVPacket *cur) | |
| { | |
| GXFContext *gxf = s->priv_data; | |
| const AVPacket *pkt[2] = { cur, next }; | |
| int i, field_nb[2]; | |
| GXFStreamContext *sc[2]; | |
| for (i = 0; i < 2; i++) { | |
| AVStream *st = s->streams[pkt[i]->stream_index]; | |
| sc[i] = st->priv_data; | |
| if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) { | |
| field_nb[i] = av_rescale_rnd(pkt[i]->dts, gxf->time_base.den, | |
| (int64_t)48000*gxf->time_base.num, AV_ROUND_UP); | |
| field_nb[i] &= ~1; // compare against even field number because audio must be before video | |
| } else | |
| field_nb[i] = pkt[i]->dts; // dts are field based | |
| } | |
| return field_nb[1] > field_nb[0] || | |
| (field_nb[1] == field_nb[0] && sc[1]->order > sc[0]->order); | |
| } | |
| static int gxf_interleave_packet(AVFormatContext *s, AVPacket *pkt, | |
| int flush, int has_packet) | |
| { | |
| int ret; | |
| if (has_packet) { | |
| AVStream *st = s->streams[pkt->stream_index]; | |
| GXFStreamContext *sc = st->priv_data; | |
| if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) | |
| pkt->pts = pkt->dts = sc->pkt_cnt * 2; // enforce 2 fields | |
| else | |
| pkt->pts = pkt->dts = sc->pkt_cnt * GXF_SAMPLES_PER_FRAME; | |
| sc->pkt_cnt++; | |
| if ((ret = ff_interleave_add_packet(s, pkt, gxf_compare_field_nb)) < 0) | |
| return ret; | |
| } | |
| return ff_interleave_packet_per_dts(s, pkt, flush, 0); | |
| } | |
| const FFOutputFormat ff_gxf_muxer = { | |
| .p.name = "gxf", | |
| .p.long_name = NULL_IF_CONFIG_SMALL("GXF (General eXchange Format)"), | |
| .p.extensions = "gxf", | |
| .priv_data_size = sizeof(GXFContext), | |
| .p.audio_codec = AV_CODEC_ID_PCM_S16LE, | |
| .p.video_codec = AV_CODEC_ID_MPEG2VIDEO, | |
| .write_header = gxf_write_header, | |
| .write_packet = gxf_write_packet, | |
| .write_trailer = gxf_write_trailer, | |
| .deinit = gxf_deinit, | |
| .interleave_packet = gxf_interleave_packet, | |
| }; |