#include <math.h>
#include <time.h>
-#include "libavutil/fifo.h"
+#include "libavutil/random_seed.h"
#include "libavcodec/bytestream.h"
#include "audiointerleave.h"
#include "avformat.h"
typedef struct {
AudioInterleaveContext aic;
UID track_essence_element_key;
- int index; ///< index in mxf_essence_container_uls table
+ int index; ///< index in mxf_essence_container_uls table
const UID *codec_ul;
- int order; ///< interleaving order if dts are equal
- int interlaced; ///< wether picture is interlaced
+ int order; ///< interleaving order if dts are equal
+ int interlaced; ///< wether picture is interlaced
int temporal_reordering;
AVRational aspect_ratio; ///< display aspect ratio
+ int closed_gop; ///< gop is closed, used in mpeg-2 frame parsing
} MXFStreamContext;
typedef struct {
{ CODEC_ID_MPEG2VIDEO, 0 },
{ CODEC_ID_PCM_S24LE, 1 },
{ CODEC_ID_PCM_S16LE, 1 },
- { 0 }
+ { CODEC_ID_NONE }
};
static void mxf_write_wav_desc(AVFormatContext *s, AVStream *st);
int timecode_drop_frame; ///< time code use drop frame method frop mpeg-2 essence gop header
int edit_unit_byte_count; ///< fixed edit unit byte count
uint64_t body_offset;
+ uint32_t instance_number;
+ uint8_t umid[16]; ///< unique material identifier
} MXFContext;
static const uint8_t uuid_base[] = { 0xAD,0xAB,0x44,0x24,0x2f,0x25,0x4d,0xc7,0x92,0xff,0x29,0xbd };
-static const uint8_t umid_base[] = { 0x06,0x0A,0x2B,0x34,0x01,0x01,0x01,0x05,0x01,0x01,0x0D,0x00,0x13,0x00,0x00,0x00 };
+static const uint8_t umid_ul[] = { 0x06,0x0A,0x2B,0x34,0x01,0x01,0x01,0x05,0x01,0x01,0x0D,0x00,0x13 };
/**
* complete key for operation pattern, partitions, and primer pack
*/
-static const uint8_t op1a_ul[] = { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x01,0x01,0x00 };
+static const uint8_t op1a_ul[] = { 0x06,0x0E,0x2B,0x34,0x04,0x01,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x01,0x09,0x00 };
static const uint8_t footer_partition_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x04,0x04,0x00 }; // ClosedComplete
static const uint8_t primer_pack_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x05,0x01,0x01,0x0D,0x01,0x02,0x01,0x01,0x05,0x01,0x00 };
static const uint8_t index_table_segment_key[] = { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x02,0x01,0x01,0x10,0x01,0x00 };
{ 0x3F0A, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x04,0x04,0x02,0x05,0x00,0x00,0x00}}, /* Index Entry Array */
// MPEG video Descriptor
{ 0x8000, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x01,0x06,0x02,0x01,0x0B,0x00,0x00}}, /* BitRate */
+ { 0x8007, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x01,0x06,0x02,0x01,0x0A,0x00,0x00}}, /* ProfileAndLevel */
// Wave Audio Essence Descriptor
{ 0x3D09, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x02,0x03,0x03,0x05,0x00,0x00,0x00}}, /* Average Bytes Per Second */
{ 0x3D0A, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x02,0x03,0x02,0x01,0x00,0x00,0x00}}, /* Block Align */
put_be16(pb, value);
}
-static void mxf_write_umid(ByteIOContext *pb, enum MXFMetadataSetType type, int value)
+static void mxf_write_umid(AVFormatContext *s, int type)
{
- put_buffer(pb, umid_base, 16);
- mxf_write_uuid(pb, type, value);
+ MXFContext *mxf = s->priv_data;
+ put_buffer(s->pb, umid_ul, 13);
+ put_be24(s->pb, mxf->instance_number);
+ put_buffer(s->pb, mxf->umid, 15);
+ put_byte(s->pb, type);
}
static void mxf_write_refs_count(ByteIOContext *pb, int ref_count)
// write version
mxf_write_local_tag(pb, 2, 0x3B05);
- put_be16(pb, 1);
+ put_be16(pb, 258); // v1.2
// write identification_refs
mxf_write_local_tag(pb, 16 + 8, 0x3B06);
// operational pattern
mxf_write_local_tag(pb, 16, 0x3B09);
- if (s->nb_streams > 1) {
- put_buffer(pb, op1a_ul, 14);
- put_be16(pb, 0x0900); // multi track
- } else {
- put_buffer(pb, op1a_ul, 16);
- }
+ put_buffer(pb, op1a_ul, 16);
// write essence_container_refs
mxf_write_local_tag(pb, 8 + 16 * mxf->essence_container_count, 0x3B0A);
// write track id
mxf_write_local_tag(pb, 4, 0x4801);
- put_be32(pb, st->index+1);
+ put_be32(pb, st->index+2);
// write track number
mxf_write_local_tag(pb, 4, 0x4804);
for (i = 0; i < 4; i++)
put_be64(pb, 0);
} else
- mxf_write_umid(pb, SourcePackage, 0);
+ mxf_write_umid(s, 1);
// write source track id
mxf_write_local_tag(pb, 4, 0x1102);
if (type == SourcePackage)
put_be32(pb, 0);
else
- put_be32(pb, st->index+1);
+ put_be32(pb, st->index+2);
}
static void mxf_write_multi_descriptor(AVFormatContext *s)
ByteIOContext *pb = s->pb;
put_buffer(pb, key, 16);
- klv_encode_ber_length(pb, size+20+8+12+20);
+ klv_encode_ber4_length(pb, size+20+8+12+20);
mxf_write_local_tag(pb, 16, 0x3C0A);
mxf_write_uuid(pb, SubDescriptor, st->index);
mxf_write_local_tag(pb, 4, 0x3006);
- put_be32(pb, st->index+1);
+ put_be32(pb, st->index+2);
mxf_write_local_tag(pb, 8, 0x3001);
put_be32(pb, mxf->time_base.den);
static void mxf_write_mpegvideo_desc(AVFormatContext *s, AVStream *st)
{
ByteIOContext *pb = s->pb;
+ int profile_and_level = (st->codec->profile<<4) | st->codec->level;
- mxf_write_cdci_common(s, st, mxf_mpegvideo_descriptor_key, 8);
+ mxf_write_cdci_common(s, st, mxf_mpegvideo_descriptor_key, 8+5);
// bit rate
mxf_write_local_tag(pb, 4, 0x8000);
put_be32(pb, st->codec->bit_rate);
+
+ // profile and level
+ mxf_write_local_tag(pb, 1, 0x8007);
+ if (!st->codec->profile)
+ profile_and_level |= 0x80; // escape bit
+ put_byte(pb, profile_and_level);
}
static void mxf_write_generic_sound_common(AVFormatContext *s, AVStream *st, const UID key, unsigned size)
// write package umid
mxf_write_local_tag(pb, 32, 0x4401);
- mxf_write_umid(pb, type, 0);
+ mxf_write_umid(s, type == SourcePackage);
PRINT_KEY(s, "package umid second part", pb->buf_ptr - 16);
// package creation date
mxf_write_uuid(pb, EssenceContainerData, 0);
mxf_write_local_tag(pb, 32, 0x2701); // Linked Package UID
- mxf_write_umid(pb, SourcePackage, 0);
+ mxf_write_umid(s, 1);
mxf_write_local_tag(pb, 4, 0x3F07); // BodySID
put_be32(pb, 1);
// index edit rate
mxf_write_local_tag(pb, 8, 0x3F0B);
- put_be32(pb, mxf->time_base.num);
put_be32(pb, mxf->time_base.den);
+ put_be32(pb, mxf->time_base.num);
// index start position
mxf_write_local_tag(pb, 8, 0x3F0C);
// index duration
mxf_write_local_tag(pb, 8, 0x3F0D);
- put_be64(pb, mxf->edit_units_count);
+ if (mxf->edit_unit_byte_count)
+ put_be64(pb, 0); // index table covers whole container
+ else
+ put_be64(pb, mxf->edit_units_count);
// edit unit byte count
mxf_write_local_tag(pb, 4, 0x3F05);
put_be32(pb, mxf->edit_units_count); // num of entries
put_be32(pb, 11+mxf->slice_count*4); // size of one entry
for (i = 0; i < mxf->edit_units_count; i++) {
+ int temporal_offset = 0;
if (temporal_reordering) {
- int temporal_offset = 0;
for (j = i+1; j < mxf->edit_units_count; j++) {
temporal_offset++;
if (mxf->index_entries[j].flags & 0x10) { // backward prediction
// next is not b, so is reordered
if (!(mxf->index_entries[i+1].flags & 0x10)) {
- if ((mxf->index_entries[i].flags & 0x11) == 0) // i frame
+ if ((mxf->index_entries[i].flags & 0x11) == 0) // I frame
temporal_offset = 0;
else
temporal_offset = -temporal_offset;
break;
}
}
- put_byte(pb, temporal_offset);
- } else
- put_byte(pb, 0);
+ }
+ put_byte(pb, temporal_offset);
+
if (!(mxf->index_entries[i].flags & 0x33)) { // I frame
+ if (mxf->index_entries[i].flags & 0x40 && // seq header
+ (!temporal_reordering || !temporal_offset))
+ mxf->index_entries[i].flags |= 0x80; // random access
mxf->last_key_index = key_index;
key_index = i;
}
- if (mxf->index_entries[i].flags & 0x10 && // backward prediction
- !(mxf->index_entries[key_index].flags & 0x80)) { // open gop
+ if ((mxf->index_entries[i].flags & 0x30) == 0x30) { // back and forward prediction
put_byte(pb, mxf->last_key_index - i);
} else {
put_byte(pb, key_index - i); // key frame offset
index_byte_count = 85 + 12+(s->nb_streams+1)*6 +
12+mxf->edit_units_count*(11+mxf->slice_count*4);
else if (mxf->edit_unit_byte_count && indexsid)
- index_byte_count = 85;
+ index_byte_count = 80;
if (index_byte_count) {
// add encoded ber length
put_be32(pb, bodysid); // bodySID
// operational pattern
- if (s->nb_streams > 1) {
- put_buffer(pb, op1a_ul, 14);
- put_be16(pb, 0x0900); // multi track
- } else {
- put_buffer(pb, op1a_ul, 16);
- }
+ put_buffer(pb, op1a_ul, 16);
// essence container
mxf_write_essence_container_refs(s);
static const UID *mxf_get_mpeg2_codec_ul(AVCodecContext *avctx)
{
+ int long_gop = avctx->gop_size > 1 || avctx->has_b_frames;
+
if (avctx->profile == 4) { // Main
if (avctx->level == 8) // Main
- return avctx->gop_size ?
- &mxf_mpeg2_codec_uls[1] :
- &mxf_mpeg2_codec_uls[0];
+ return &mxf_mpeg2_codec_uls[0+long_gop];
else if (avctx->level == 4) // High
- return avctx->gop_size ?
- &mxf_mpeg2_codec_uls[5] :
- &mxf_mpeg2_codec_uls[4];
+ return &mxf_mpeg2_codec_uls[4+long_gop];
} else if (avctx->profile == 0) { // 422
if (avctx->level == 5) // Main
- return avctx->gop_size ?
- &mxf_mpeg2_codec_uls[3] :
- &mxf_mpeg2_codec_uls[2];
+ return &mxf_mpeg2_codec_uls[2+long_gop];
else if (avctx->level == 2) // High
- return avctx->gop_size ?
- &mxf_mpeg2_codec_uls[7] :
- &mxf_mpeg2_codec_uls[6];
+ return &mxf_mpeg2_codec_uls[6+long_gop];
}
return NULL;
}
for(i = 0; i < pkt->size - 4; i++) {
c = (c<<8) + pkt->data[i];
- if (c == 0x1B5) {
- if (i + 2 < pkt->size && (pkt->data[i+1] & 0xf0) == 0x10) { // seq ext
+ if (c == 0x1b5) {
+ if ((pkt->data[i+1] & 0xf0) == 0x10) { // seq ext
st->codec->profile = pkt->data[i+1] & 0x07;
st->codec->level = pkt->data[i+2] >> 4;
} else if (i + 5 < pkt->size && (pkt->data[i+1] & 0xf0) == 0x80) { // pict coding ext
break;
}
} else if (c == 0x1b8) { // gop
- if (i + 4 < pkt->size) {
- if (pkt->data[i+4]>>6 & 0x01) // closed
+ if (pkt->data[i+4]>>6 & 0x01) { // closed
+ sc->closed_gop = 1;
+ if (*flags & 0x40) // sequence header present
*flags |= 0x80; // random access
- if (!mxf->header_written) {
- unsigned hours = (pkt->data[i+1]>>2) & 0x1f;
- unsigned minutes = ((pkt->data[i+1] & 0x03) << 4) | (pkt->data[i+2]>>4);
- unsigned seconds = ((pkt->data[i+2] & 0x07) << 3) | (pkt->data[i+3]>>5);
- unsigned frames = ((pkt->data[i+3] & 0x1f) << 1) | (pkt->data[i+4]>>7);
- mxf->timecode_drop_frame = !!(pkt->data[i+1] & 0x80);
- mxf->timecode_start = (hours*3600 + minutes*60 + seconds) *
- mxf->timecode_base + frames;
- if (mxf->timecode_drop_frame) {
- unsigned tminutes = 60 * hours + minutes;
- mxf->timecode_start -= 2 * (tminutes - tminutes / 10);
- }
- av_log(s, AV_LOG_DEBUG, "frame %d %d:%d:%d%c%d\n", mxf->timecode_start,
- hours, minutes, seconds, mxf->timecode_drop_frame ? ';':':', frames);
+ }
+ if (!mxf->header_written) {
+ unsigned hours = (pkt->data[i+1]>>2) & 0x1f;
+ unsigned minutes = ((pkt->data[i+1] & 0x03) << 4) | (pkt->data[i+2]>>4);
+ unsigned seconds = ((pkt->data[i+2] & 0x07) << 3) | (pkt->data[i+3]>>5);
+ unsigned frames = ((pkt->data[i+3] & 0x1f) << 1) | (pkt->data[i+4]>>7);
+ mxf->timecode_drop_frame = !!(pkt->data[i+1] & 0x80);
+ mxf->timecode_start = (hours*3600 + minutes*60 + seconds) *
+ mxf->timecode_base + frames;
+ if (mxf->timecode_drop_frame) {
+ unsigned tminutes = 60 * hours + minutes;
+ mxf->timecode_start -= 2 * (tminutes - tminutes / 10);
}
+ av_log(s, AV_LOG_DEBUG, "frame %d %d:%d:%d%c%d\n", mxf->timecode_start,
+ hours, minutes, seconds, mxf->timecode_drop_frame ? ';':':', frames);
}
} else if (c == 0x1b3) { // seq
*flags |= 0x40;
- if (i + 4 < pkt->size) {
- switch ((pkt->data[i+4]>>4) & 0xf) {
- case 2: sc->aspect_ratio = (AVRational){ 4, 3}; break;
- case 3: sc->aspect_ratio = (AVRational){ 16, 9}; break;
- case 4: sc->aspect_ratio = (AVRational){221,100}; break;
- default:
- av_reduce(&sc->aspect_ratio.num, &sc->aspect_ratio.den,
- st->codec->width, st->codec->height, 1024*1024);
- }
+ switch ((pkt->data[i+4]>>4) & 0xf) {
+ case 2: sc->aspect_ratio = (AVRational){ 4, 3}; break;
+ case 3: sc->aspect_ratio = (AVRational){ 16, 9}; break;
+ case 4: sc->aspect_ratio = (AVRational){221,100}; break;
+ default:
+ av_reduce(&sc->aspect_ratio.num, &sc->aspect_ratio.den,
+ st->codec->width, st->codec->height, 1024*1024);
}
} else if (c == 0x100) { // pic
int pict_type = (pkt->data[i+2]>>3) & 0x07;
if (pict_type == 2) { // P frame
*flags |= 0x22;
- st->codec->gop_size = 1;
+ sc->closed_gop = 0; // reset closed gop, don't matter anymore
} else if (pict_type == 3) { // B frame
- *flags |= 0x33;
+ if (sc->closed_gop)
+ *flags |= 0x13; // only backward prediction
+ else
+ *flags |= 0x33;
sc->temporal_reordering = -1;
} else if (!pict_type) {
av_log(s, AV_LOG_ERROR, "error parsing mpeg2 frame\n");
static uint64_t mxf_parse_timestamp(time_t timestamp)
{
- struct tm *time = localtime(×tamp);
+ struct tm *time = gmtime(×tamp);
return (uint64_t)(time->tm_year+1900) << 48 |
(uint64_t)(time->tm_mon+1) << 40 |
(uint64_t) time->tm_mday << 32 |
time->tm_sec << 8;
}
+static void mxf_gen_umid(AVFormatContext *s)
+{
+ MXFContext *mxf = s->priv_data;
+ uint32_t seed = ff_random_get_seed();
+ uint64_t umid = seed + 0x5294713400000000LL;
+
+ AV_WB64(mxf->umid , umid);
+ AV_WB64(mxf->umid+8, umid>>8);
+
+ mxf->instance_number = seed;
+}
+
static int mxf_write_header(AVFormatContext *s)
{
MXFContext *mxf = s->priv_data;
uint8_t present[FF_ARRAY_ELEMS(mxf_essence_container_uls)] = {0};
const int *samples_per_frame = NULL;
+ if (!s->nb_streams)
+ return -1;
+
for (i = 0; i < s->nb_streams; i++) {
AVStream *st = s->streams[i];
MXFStreamContext *sc = av_mallocz(sizeof(*sc));
sc->codec_ul = &mxf_essence_container_uls[sc->index].codec_ul;
- if (!present[sc->index]) {
- present[sc->index] = 1;
- mxf->essence_container_count++;
- } else
- present[sc->index]++;
-
memcpy(sc->track_essence_element_key, mxf_essence_container_uls[sc->index].element_ul, 15);
sc->track_essence_element_key[15] = present[sc->index];
PRINT_KEY(s, "track essence element key", sc->track_essence_element_key);
+
+ if (!present[sc->index])
+ mxf->essence_container_count++;
+ present[sc->index]++;
}
if (s->oformat == &mxf_d10_muxer) {
mxf->essence_container_count = 1;
}
+ if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT))
+ mxf_gen_umid(s);
+
for (i = 0; i < s->nb_streams; i++) {
MXFStreamContext *sc = s->streams[i]->priv_data;
// update element count
sc->order = AV_RB32(sc->track_essence_element_key+12);
}
- mxf->timestamp = mxf_parse_timestamp(s->timestamp);
+ if (s->timestamp)
+ mxf->timestamp = mxf_parse_timestamp(s->timestamp);
mxf->duration = -1;
mxf->timecode_track = av_mallocz(sizeof(*mxf->timecode_track));
klv_encode_ber4_length(pb, 35);
put_byte(pb, 0x83); // UMID
put_be16(pb, 0x20);
- mxf_write_umid(pb, SourcePackage, 0);
+ mxf_write_umid(s, 1);
}
static void mxf_write_d10_video_packet(AVFormatContext *s, AVStream *st, AVPacket *pkt)
{
MXFContext *mxf = s->priv_data;
ByteIOContext *pb = s->pb;
- int frame_size = (pkt->size<<3) /
- (st->codec->channels*av_get_bits_per_sample(st->codec->codec_id));
+ int frame_size = pkt->size / st->codec->block_align;
uint8_t *samples = pkt->data;
uint8_t *end = pkt->data + pkt->size;
int i;
for (i = 0; i < st->codec->channels; i++) {
uint32_t sample;
if (st->codec->codec_id == CODEC_ID_PCM_S24LE) {
- sample = (AV_RL24(samples)<< 4)|((samples==pkt->data)<<3) | i;
+ sample = AV_RL24(samples)<< 4;
samples += 3;
} else {
- sample = (AV_RL16(samples)<<12)|((samples==pkt->data)<<3) | i;
+ sample = AV_RL16(samples)<<12;
samples += 2;
}
- put_le32(pb, sample);
+ put_le32(pb, sample | i);
}
for (; i < 8; i++)
- put_le32(pb, 0);
+ put_le32(pb, i);
}
}
// purge packet queue
while (pktl) {
AVPacketList *next = pktl->next;
+
+ if(s->streams[pktl->pkt.stream_index]->last_in_packet_buffer == pktl)
+ s->streams[pktl->pkt.stream_index]->last_in_packet_buffer= NULL;
av_free_packet(&pktl->pkt);
av_freep(&pktl);
pktl = next;
last->next = NULL;
else {
s->packet_buffer = NULL;
+ s->packet_buffer_end= NULL;
goto out;
}
pktl = s->packet_buffer;
*out = pktl->pkt;
//av_log(s, AV_LOG_DEBUG, "out st:%d dts:%lld\n", (*out).stream_index, (*out).dts);
s->packet_buffer = pktl->next;
+ if(s->streams[pktl->pkt.stream_index]->last_in_packet_buffer == pktl)
+ s->streams[pktl->pkt.stream_index]->last_in_packet_buffer= NULL;
+ if(!s->packet_buffer)
+ s->packet_buffer_end= NULL;
av_freep(&pktl);
return 1;
} else {
projects / ffmpeg / blobdiff