← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/libav/oneiric

« back to all changes in this revision

Viewing changes to libavformat/mxfenc.c

  • Committer: Bazaar Package Importer
  • Author(s): Reinhard Tartler
  • Date: 2011-04-19 15:04:55 UTC
  • mfrom: (1.2.1 upstream)
  • mto: (1.3.4 sid)
  • mto: This revision was merged to the branch mainline in revision 3.
  • Revision ID: james.westby@ubuntu.com-20110419150455-c1nac6gjm3t2aa4n
Tags: 4:0.7~b1-1
* New upstream version
* bump SONAME and SHLIBS
* configure flags --disable-stripping was removed upstream
* the MAINTAINERS file was removed upstream
* remove patch disable-configuration-warning.patch
* drop avfilter confflags, it is enable by default in 0.7
* libfaad wrapper has been removed upstream
* also update the *contents* of the lintian overrides

Show diffs side-by-side

added added

removed removed

Lines of Context:
libavformat/mxfenc.c
3
3
 * Copyright (c) 2008 GUCAS, Zhentan Feng <spyfeng at gmail dot com>
4
4
 * Copyright (c) 2008 Baptiste Coudurier <baptiste dot coudurier at gmail dot com>
5
5
 *
6
 
 * This file is part of FFmpeg.
 
6
 * This file is part of Libav.
7
7
 *
8
 
 * FFmpeg is free software; you can redistribute it and/or
 
8
 * Libav is free software; you can redistribute it and/or
9
9
 * modify it under the terms of the GNU Lesser General Public
10
10
 * License as published by the Free Software Foundation; either
11
11
 * version 2.1 of the License, or (at your option) any later version.
12
12
 *
13
 
 * FFmpeg is distributed in the hope that it will be useful,
 
13
 * Libav is distributed in the hope that it will be useful,
14
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
16
 * Lesser General Public License for more details.
17
17
 *
18
18
 * You should have received a copy of the GNU Lesser General Public
19
 
 * License along with FFmpeg; if not, write to the Free Software
 
19
 * License along with Libav; if not, write to the Free Software
20
20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21
21
 */
22
22
 
44
44
static const int NTSC_samples_per_frame[] = { 1602, 1601, 1602, 1601, 1602, 0 };
45
45
static const int PAL_samples_per_frame[]  = { 1920, 0 };
46
46
 
47
 
AVOutputFormat mxf_d10_muxer;
 
47
extern AVOutputFormat ff_mxf_d10_muxer;
48
48
 
49
49
#define EDIT_UNITS_PER_BODY 250
50
50
#define KAG_SIZE 512
58
58
    uint8_t flags;
59
59
    uint64_t offset;
60
60
    unsigned slice_offset; ///< offset of audio slice
 
61
    uint16_t temporal_ref;
61
62
} MXFIndexEntry;
62
63
 
63
64
typedef struct {
76
77
    UID container_ul;
77
78
    UID element_ul;
78
79
    UID codec_ul;
79
 
    void (*write_desc)();
 
80
    void (*write_desc)(AVFormatContext *, AVStream *);
80
81
} MXFContainerEssenceEntry;
81
82
 
82
83
static const struct {
304
305
    { 0x3D0A, {0x06,0x0E,0x2B,0x34,0x01,0x01,0x01,0x05,0x04,0x02,0x03,0x02,0x01,0x00,0x00,0x00}}, /* Block Align */
305
306
};
306
307
 
307
 
static void mxf_write_uuid(ByteIOContext *pb, enum MXFMetadataSetType type, int value)
 
308
static void mxf_write_uuid(AVIOContext *pb, enum MXFMetadataSetType type, int value)
308
309
{
309
 
    put_buffer(pb, uuid_base, 12);
310
 
    put_be16(pb, type);
311
 
    put_be16(pb, value);
 
310
    avio_write(pb, uuid_base, 12);
 
311
    avio_wb16(pb, type);
 
312
    avio_wb16(pb, value);
312
313
}
313
314
 
314
315
static void mxf_write_umid(AVFormatContext *s, int type)
315
316
{
316
317
    MXFContext *mxf = s->priv_data;
317
 
    put_buffer(s->pb, umid_ul, 13);
318
 
    put_be24(s->pb, mxf->instance_number);
319
 
    put_buffer(s->pb, mxf->umid, 15);
320
 
    put_byte(s->pb, type);
 
318
    avio_write(s->pb, umid_ul, 13);
 
319
    avio_wb24(s->pb, mxf->instance_number);
 
320
    avio_write(s->pb, mxf->umid, 15);
 
321
    avio_w8(s->pb, type);
321
322
}
322
323
 
323
 
static void mxf_write_refs_count(ByteIOContext *pb, int ref_count)
 
324
static void mxf_write_refs_count(AVIOContext *pb, int ref_count)
324
325
{
325
 
    put_be32(pb, ref_count);
326
 
    put_be32(pb, 16);
 
326
    avio_wb32(pb, ref_count);
 
327
    avio_wb32(pb, 16);
327
328
}
328
329
 
329
330
static int klv_ber_length(uint64_t len)
334
335
        return (av_log2(len) >> 3) + 2;
335
336
}
336
337
 
337
 
static int klv_encode_ber_length(ByteIOContext *pb, uint64_t len)
 
338
static int klv_encode_ber_length(AVIOContext *pb, uint64_t len)
338
339
{
339
340
    // Determine the best BER size
340
341
    int size;
341
342
    if (len < 128) {
342
343
        //short form
343
 
        put_byte(pb, len);
 
344
        avio_w8(pb, len);
344
345
        return 1;
345
346
    }
346
347
 
347
348
    size = (av_log2(len) >> 3) + 1;
348
349
 
349
350
    // long form
350
 
    put_byte(pb, 0x80 + size);
 
351
    avio_w8(pb, 0x80 + size);
351
352
    while(size) {
352
353
        size--;
353
 
        put_byte(pb, len >> 8 * size & 0xff);
 
354
        avio_w8(pb, len >> 8 * size & 0xff);
354
355
    }
355
356
    return 0;
356
357
}
357
358
 
358
 
static void klv_encode_ber4_length(ByteIOContext *pb, int len)
 
359
static void klv_encode_ber4_length(AVIOContext *pb, int len)
359
360
{
360
 
    put_byte(pb, 0x80 + 3);
361
 
    put_be24(pb, len);
 
361
    avio_w8(pb, 0x80 + 3);
 
362
    avio_wb24(pb, len);
362
363
}
363
364
 
364
365
/*
375
376
 
376
377
static void mxf_write_primer_pack(AVFormatContext *s)
377
378
{
378
 
    ByteIOContext *pb = s->pb;
 
379
    AVIOContext *pb = s->pb;
379
380
    int local_tag_number, i = 0;
380
381
 
381
382
    local_tag_number = FF_ARRAY_ELEMS(mxf_local_tag_batch);
382
383
 
383
 
    put_buffer(pb, primer_pack_key, 16);
 
384
    avio_write(pb, primer_pack_key, 16);
384
385
    klv_encode_ber_length(pb, local_tag_number * 18 + 8);
385
386
 
386
 
    put_be32(pb, local_tag_number); // local_tag num
387
 
    put_be32(pb, 18); // item size, always 18 according to the specs
 
387
    avio_wb32(pb, local_tag_number); // local_tag num
 
388
    avio_wb32(pb, 18); // item size, always 18 according to the specs
388
389
 
389
390
    for (i = 0; i < local_tag_number; i++) {
390
 
        put_be16(pb, mxf_local_tag_batch[i].local_tag);
391
 
        put_buffer(pb, mxf_local_tag_batch[i].uid, 16);
 
391
        avio_wb16(pb, mxf_local_tag_batch[i].local_tag);
 
392
        avio_write(pb, mxf_local_tag_batch[i].uid, 16);
392
393
    }
393
394
}
394
395
 
395
 
static void mxf_write_local_tag(ByteIOContext *pb, int size, int tag)
 
396
static void mxf_write_local_tag(AVIOContext *pb, int size, int tag)
396
397
{
397
 
    put_be16(pb, tag);
398
 
    put_be16(pb, size);
 
398
    avio_wb16(pb, tag);
 
399
    avio_wb16(pb, size);
399
400
}
400
401
 
401
 
static void mxf_write_metadata_key(ByteIOContext *pb, unsigned int value)
 
402
static void mxf_write_metadata_key(AVIOContext *pb, unsigned int value)
402
403
{
403
 
    put_buffer(pb, header_metadata_key, 13);
404
 
    put_be24(pb, value);
 
404
    avio_write(pb, header_metadata_key, 13);
 
405
    avio_wb24(pb, value);
405
406
}
406
407
 
407
408
static void mxf_free(AVFormatContext *s)
428
429
static void mxf_write_essence_container_refs(AVFormatContext *s)
429
430
{
430
431
    MXFContext *c = s->priv_data;
431
 
    ByteIOContext *pb = s->pb;
 
432
    AVIOContext *pb = s->pb;
432
433
    int i;
433
434
 
434
435
    mxf_write_refs_count(pb, c->essence_container_count);
435
436
    av_log(s,AV_LOG_DEBUG, "essence container count:%d\n", c->essence_container_count);
436
437
    for (i = 0; i < c->essence_container_count; i++) {
437
438
        MXFStreamContext *sc = s->streams[i]->priv_data;
438
 
        put_buffer(pb, mxf_essence_container_uls[sc->index].container_ul, 16);
 
439
        avio_write(pb, mxf_essence_container_uls[sc->index].container_ul, 16);
439
440
    }
440
441
}
441
442
 
442
443
static void mxf_write_preface(AVFormatContext *s)
443
444
{
444
445
    MXFContext *mxf = s->priv_data;
445
 
    ByteIOContext *pb = s->pb;
 
446
    AVIOContext *pb = s->pb;
446
447
 
447
448
    mxf_write_metadata_key(pb, 0x012f00);
448
449
    PRINT_KEY(s, "preface key", pb->buf_ptr - 16);
455
456
 
456
457
    // last modified date
457
458
    mxf_write_local_tag(pb, 8, 0x3B02);
458
 
    put_be64(pb, mxf->timestamp);
 
459
    avio_wb64(pb, mxf->timestamp);
459
460
 
460
461
    // write version
461
462
    mxf_write_local_tag(pb, 2, 0x3B05);
462
 
    put_be16(pb, 258); // v1.2
 
463
    avio_wb16(pb, 258); // v1.2
463
464
 
464
465
    // write identification_refs
465
466
    mxf_write_local_tag(pb, 16 + 8, 0x3B06);
472
473
 
473
474
    // operational pattern
474
475
    mxf_write_local_tag(pb, 16, 0x3B09);
475
 
    put_buffer(pb, op1a_ul, 16);
 
476
    avio_write(pb, op1a_ul, 16);
476
477
 
477
478
    // write essence_container_refs
478
479
    mxf_write_local_tag(pb, 8 + 16 * mxf->essence_container_count, 0x3B0A);
480
481
 
481
482
    // write dm_scheme_refs
482
483
    mxf_write_local_tag(pb, 8, 0x3B0B);
483
 
    put_be64(pb, 0);
 
484
    avio_wb64(pb, 0);
484
485
}
485
486
 
486
487
/*
487
488
 * Write a local tag containing an ascii string as utf-16
488
489
 */
489
 
static void mxf_write_local_tag_utf16(ByteIOContext *pb, int tag, const char *value)
 
490
static void mxf_write_local_tag_utf16(AVIOContext *pb, int tag, const char *value)
490
491
{
491
492
    int i, size = strlen(value);
492
493
    mxf_write_local_tag(pb, size*2, tag);
493
494
    for (i = 0; i < size; i++)
494
 
        put_be16(pb, value[i]);
 
495
        avio_wb16(pb, value[i]);
495
496
}
496
497
 
497
498
static void mxf_write_identification(AVFormatContext *s)
498
499
{
499
500
    MXFContext *mxf = s->priv_data;
500
 
    ByteIOContext *pb = s->pb;
501
 
    const char *company = "FFmpeg";
 
501
    AVIOContext *pb = s->pb;
 
502
    const char *company = "Libav";
502
503
    const char *product = "OP1a Muxer";
503
504
    const char *version;
504
505
    int length;
530
531
 
531
532
    // modification date
532
533
    mxf_write_local_tag(pb, 8, 0x3C06);
533
 
    put_be64(pb, mxf->timestamp);
 
534
    avio_wb64(pb, mxf->timestamp);
534
535
}
535
536
 
536
537
static void mxf_write_content_storage(AVFormatContext *s)
537
538
{
538
 
    ByteIOContext *pb = s->pb;
 
539
    AVIOContext *pb = s->pb;
539
540
 
540
541
    mxf_write_metadata_key(pb, 0x011800);
541
542
    PRINT_KEY(s, "content storage key", pb->buf_ptr - 16);
561
562
static void mxf_write_track(AVFormatContext *s, AVStream *st, enum MXFMetadataSetType type)
562
563
{
563
564
    MXFContext *mxf = s->priv_data;
564
 
    ByteIOContext *pb = s->pb;
 
565
    AVIOContext *pb = s->pb;
565
566
    MXFStreamContext *sc = st->priv_data;
566
567
 
567
568
    mxf_write_metadata_key(pb, 0x013b00);
575
576
 
576
577
    // write track id
577
578
    mxf_write_local_tag(pb, 4, 0x4801);
578
 
    put_be32(pb, st->index+2);
 
579
    avio_wb32(pb, st->index+2);
579
580
 
580
581
    // write track number
581
582
    mxf_write_local_tag(pb, 4, 0x4804);
582
583
    if (type == MaterialPackage)
583
 
        put_be32(pb, 0); // track number of material package is 0
 
584
        avio_wb32(pb, 0); // track number of material package is 0
584
585
    else
585
 
        put_buffer(pb, sc->track_essence_element_key + 12, 4);
 
586
        avio_write(pb, sc->track_essence_element_key + 12, 4);
586
587
 
587
588
    mxf_write_local_tag(pb, 8, 0x4B01);
588
 
    put_be32(pb, mxf->time_base.den);
589
 
    put_be32(pb, mxf->time_base.num);
 
589
    avio_wb32(pb, mxf->time_base.den);
 
590
    avio_wb32(pb, mxf->time_base.num);
590
591
 
591
592
    // write origin
592
593
    mxf_write_local_tag(pb, 8, 0x4B02);
593
 
    put_be64(pb, 0);
 
594
    avio_wb64(pb, 0);
594
595
 
595
596
    // write sequence refs
596
597
    mxf_write_local_tag(pb, 16, 0x4803);
602
603
static void mxf_write_common_fields(AVFormatContext *s, AVStream *st)
603
604
{
604
605
    MXFContext *mxf = s->priv_data;
605
 
    ByteIOContext *pb = s->pb;
 
606
    AVIOContext *pb = s->pb;
606
607
 
607
608
    // find data define uls
608
609
    mxf_write_local_tag(pb, 16, 0x0201);
609
610
    if (st == mxf->timecode_track)
610
 
        put_buffer(pb, smpte_12m_timecode_track_data_ul, 16);
 
611
        avio_write(pb, smpte_12m_timecode_track_data_ul, 16);
611
612
    else {
612
613
        const MXFCodecUL *data_def_ul = mxf_get_data_definition_ul(st->codec->codec_type);
613
 
        put_buffer(pb, data_def_ul->uid, 16);
 
614
        avio_write(pb, data_def_ul->uid, 16);
614
615
    }
615
616
 
616
617
    // write duration
617
618
    mxf_write_local_tag(pb, 8, 0x0202);
618
 
    put_be64(pb, mxf->duration);
 
619
    avio_wb64(pb, mxf->duration);
619
620
}
620
621
 
621
622
static void mxf_write_sequence(AVFormatContext *s, AVStream *st, enum MXFMetadataSetType type)
622
623
{
623
624
    MXFContext *mxf = s->priv_data;
624
 
    ByteIOContext *pb = s->pb;
 
625
    AVIOContext *pb = s->pb;
625
626
    enum MXFMetadataSetType component;
626
627
 
627
628
    mxf_write_metadata_key(pb, 0x010f00);
649
650
static void mxf_write_timecode_component(AVFormatContext *s, AVStream *st, enum MXFMetadataSetType type)
650
651
{
651
652
    MXFContext *mxf = s->priv_data;
652
 
    ByteIOContext *pb = s->pb;
 
653
    AVIOContext *pb = s->pb;
653
654
 
654
655
    mxf_write_metadata_key(pb, 0x011400);
655
656
    klv_encode_ber_length(pb, 75);
663
664
 
664
665
    // Start Time Code
665
666
    mxf_write_local_tag(pb, 8, 0x1501);
666
 
    put_be64(pb, mxf->timecode_start);
 
667
    avio_wb64(pb, mxf->timecode_start);
667
668
 
668
669
    // Rounded Time Code Base
669
670
    mxf_write_local_tag(pb, 2, 0x1502);
670
 
    put_be16(pb, mxf->timecode_base);
 
671
    avio_wb16(pb, mxf->timecode_base);
671
672
 
672
673
    // Drop Frame
673
674
    mxf_write_local_tag(pb, 1, 0x1503);
674
 
    put_byte(pb, mxf->timecode_drop_frame);
 
675
    avio_w8(pb, mxf->timecode_drop_frame);
675
676
}
676
677
 
677
678
static void mxf_write_structural_component(AVFormatContext *s, AVStream *st, enum MXFMetadataSetType type)
678
679
{
679
 
    ByteIOContext *pb = s->pb;
 
680
    AVIOContext *pb = s->pb;
680
681
    int i;
681
682
 
682
683
    mxf_write_metadata_key(pb, 0x011100);
692
693
 
693
694
    // write start_position
694
695
    mxf_write_local_tag(pb, 8, 0x1201);
695
 
    put_be64(pb, 0);
 
696
    avio_wb64(pb, 0);
696
697
 
697
698
    // write source package uid, end of the reference
698
699
    mxf_write_local_tag(pb, 32, 0x1101);
699
700
    if (type == SourcePackage) {
700
701
        for (i = 0; i < 4; i++)
701
 
            put_be64(pb, 0);
 
702
            avio_wb64(pb, 0);
702
703
    } else
703
704
        mxf_write_umid(s, 1);
704
705
 
705
706
    // write source track id
706
707
    mxf_write_local_tag(pb, 4, 0x1102);
707
708
    if (type == SourcePackage)
708
 
        put_be32(pb, 0);
 
709
        avio_wb32(pb, 0);
709
710
    else
710
 
        put_be32(pb, st->index+2);
 
711
        avio_wb32(pb, st->index+2);
711
712
}
712
713
 
713
714
static void mxf_write_multi_descriptor(AVFormatContext *s)
714
715
{
715
716
    MXFContext *mxf = s->priv_data;
716
 
    ByteIOContext *pb = s->pb;
 
717
    AVIOContext *pb = s->pb;
717
718
    const uint8_t *ul;
718
719
    int i;
719
720
 
727
728
 
728
729
    // write sample rate
729
730
    mxf_write_local_tag(pb, 8, 0x3001);
730
 
    put_be32(pb, mxf->time_base.den);
731
 
    put_be32(pb, mxf->time_base.num);
 
731
    avio_wb32(pb, mxf->time_base.den);
 
732
    avio_wb32(pb, mxf->time_base.num);
732
733
 
733
734
    // write essence container ul
734
735
    mxf_write_local_tag(pb, 16, 0x3004);
738
739
        MXFStreamContext *sc = s->streams[0]->priv_data;
739
740
        ul = mxf_essence_container_uls[sc->index].container_ul;
740
741
    }
741
 
    put_buffer(pb, ul, 16);
 
742
    avio_write(pb, ul, 16);
742
743
 
743
744
    // write sub descriptor refs
744
745
    mxf_write_local_tag(pb, s->nb_streams * 16 + 8, 0x3F01);
751
752
{
752
753
    MXFContext *mxf = s->priv_data;
753
754
    MXFStreamContext *sc = st->priv_data;
754
 
    ByteIOContext *pb = s->pb;
 
755
    AVIOContext *pb = s->pb;
755
756
 
756
 
    put_buffer(pb, key, 16);
 
757
    avio_write(pb, key, 16);
757
758
    klv_encode_ber4_length(pb, size+20+8+12+20);
758
759
 
759
760
    mxf_write_local_tag(pb, 16, 0x3C0A);
760
761
    mxf_write_uuid(pb, SubDescriptor, st->index);
761
762
 
762
763
    mxf_write_local_tag(pb, 4, 0x3006);
763
 
    put_be32(pb, st->index+2);
 
764
    avio_wb32(pb, st->index+2);
764
765
 
765
766
    mxf_write_local_tag(pb, 8, 0x3001);
766
 
    put_be32(pb, mxf->time_base.den);
767
 
    put_be32(pb, mxf->time_base.num);
 
767
    avio_wb32(pb, mxf->time_base.den);
 
768
    avio_wb32(pb, mxf->time_base.num);
768
769
 
769
770
    mxf_write_local_tag(pb, 16, 0x3004);
770
 
    put_buffer(pb, mxf_essence_container_uls[sc->index].container_ul, 16);
 
771
    avio_write(pb, mxf_essence_container_uls[sc->index].container_ul, 16);
771
772
}
772
773
 
773
774
static const UID mxf_mpegvideo_descriptor_key = { 0x06,0x0E,0x2B,0x34,0x02,0x53,0x01,0x01,0x0d,0x01,0x01,0x01,0x01,0x01,0x51,0x00 };
779
780
static void mxf_write_cdci_common(AVFormatContext *s, AVStream *st, const UID key, unsigned size)
780
781
{
781
782
    MXFStreamContext *sc = st->priv_data;
782
 
    ByteIOContext *pb = s->pb;
 
783
    AVIOContext *pb = s->pb;
783
784
    int stored_height = (st->codec->height+15)/16*16;
784
785
    int display_height;
785
786
    int f1, f2;
787
788
    mxf_write_generic_desc(s, st, key, size+8+8+8+8+8+8+5+16+sc->interlaced*4+12+20);
788
789
 
789
790
    mxf_write_local_tag(pb, 4, 0x3203);
790
 
    put_be32(pb, st->codec->width);
 
791
    avio_wb32(pb, st->codec->width);
791
792
 
792
793
    mxf_write_local_tag(pb, 4, 0x3202);
793
 
    put_be32(pb, stored_height>>sc->interlaced);
 
794
    avio_wb32(pb, stored_height>>sc->interlaced);
794
795
 
795
796
    mxf_write_local_tag(pb, 4, 0x3209);
796
 
    put_be32(pb, st->codec->width);
 
797
    avio_wb32(pb, st->codec->width);
797
798
 
798
799
    if (st->codec->height == 608) // PAL + VBI
799
800
        display_height = 576;
803
804
        display_height = st->codec->height;
804
805
 
805
806
    mxf_write_local_tag(pb, 4, 0x3208);
806
 
    put_be32(pb, display_height>>sc->interlaced);
 
807
    avio_wb32(pb, display_height>>sc->interlaced);
807
808
 
808
809
    // component depth
809
810
    mxf_write_local_tag(pb, 4, 0x3301);
810
 
    put_be32(pb, 8);
 
811
    avio_wb32(pb, 8);
811
812
 
812
813
    // horizontal subsampling
813
814
    mxf_write_local_tag(pb, 4, 0x3302);
814
 
    put_be32(pb, 2);
 
815
    avio_wb32(pb, 2);
815
816
 
816
817
    // frame layout
817
818
    mxf_write_local_tag(pb, 1, 0x320C);
818
 
    put_byte(pb, sc->interlaced);
 
819
    avio_w8(pb, sc->interlaced);
819
820
 
820
821
    // video line map
821
822
    switch (st->codec->height) {
834
835
    }
835
836
 
836
837
    mxf_write_local_tag(pb, 12+sc->interlaced*4, 0x320D);
837
 
    put_be32(pb, sc->interlaced ? 2 : 1);
838
 
    put_be32(pb, 4);
839
 
    put_be32(pb, f1);
 
838
    avio_wb32(pb, sc->interlaced ? 2 : 1);
 
839
    avio_wb32(pb, 4);
 
840
    avio_wb32(pb, f1);
840
841
    if (sc->interlaced)
841
 
        put_be32(pb, f2);
 
842
        avio_wb32(pb, f2);
842
843
 
843
844
    mxf_write_local_tag(pb, 8, 0x320E);
844
 
    put_be32(pb, sc->aspect_ratio.num);
845
 
    put_be32(pb, sc->aspect_ratio.den);
 
845
    avio_wb32(pb, sc->aspect_ratio.num);
 
846
    avio_wb32(pb, sc->aspect_ratio.den);
846
847
 
847
848
    mxf_write_local_tag(pb, 16, 0x3201);
848
 
    put_buffer(pb, *sc->codec_ul, 16);
 
849
    avio_write(pb, *sc->codec_ul, 16);
849
850
}
850
851
 
851
852
static void mxf_write_cdci_desc(AVFormatContext *s, AVStream *st)
855
856
 
856
857
static void mxf_write_mpegvideo_desc(AVFormatContext *s, AVStream *st)
857
858
{
858
 
    ByteIOContext *pb = s->pb;
 
859
    AVIOContext *pb = s->pb;
859
860
    int profile_and_level = (st->codec->profile<<4) | st->codec->level;
860
861
 
861
862
    mxf_write_cdci_common(s, st, mxf_mpegvideo_descriptor_key, 8+5);
862
863
 
863
864
    // bit rate
864
865
    mxf_write_local_tag(pb, 4, 0x8000);
865
 
    put_be32(pb, st->codec->bit_rate);
 
866
    avio_wb32(pb, st->codec->bit_rate);
866
867
 
867
868
    // profile and level
868
869
    mxf_write_local_tag(pb, 1, 0x8007);
869
870
    if (!st->codec->profile)
870
871
        profile_and_level |= 0x80; // escape bit
871
 
    put_byte(pb, profile_and_level);
 
872
    avio_w8(pb, profile_and_level);
872
873
}
873
874
 
874
875
static void mxf_write_generic_sound_common(AVFormatContext *s, AVStream *st, const UID key, unsigned size)
875
876
{
876
 
    ByteIOContext *pb = s->pb;
 
877
    AVIOContext *pb = s->pb;
877
878
 
878
879
    mxf_write_generic_desc(s, st, key, size+5+12+8+8);
879
880
 
880
881
    // audio locked
881
882
    mxf_write_local_tag(pb, 1, 0x3D02);
882
 
    put_byte(pb, 1);
 
883
    avio_w8(pb, 1);
883
884
 
884
885
    // write audio sampling rate
885
886
    mxf_write_local_tag(pb, 8, 0x3D03);
886
 
    put_be32(pb, st->codec->sample_rate);
887
 
    put_be32(pb, 1);
 
887
    avio_wb32(pb, st->codec->sample_rate);
 
888
    avio_wb32(pb, 1);
888
889
 
889
890
    mxf_write_local_tag(pb, 4, 0x3D07);
890
 
    put_be32(pb, st->codec->channels);
 
891
    avio_wb32(pb, st->codec->channels);
891
892
 
892
893
    mxf_write_local_tag(pb, 4, 0x3D01);
893
 
    put_be32(pb, av_get_bits_per_sample(st->codec->codec_id));
 
894
    avio_wb32(pb, av_get_bits_per_sample(st->codec->codec_id));
894
895
}
895
896
 
896
897
static void mxf_write_wav_common(AVFormatContext *s, AVStream *st, const UID key, unsigned size)
897
898
{
898
 
    ByteIOContext *pb = s->pb;
 
899
    AVIOContext *pb = s->pb;
899
900
 
900
901
    mxf_write_generic_sound_common(s, st, key, size+6+8);
901
902
 
902
903
    mxf_write_local_tag(pb, 2, 0x3D0A);
903
 
    put_be16(pb, st->codec->block_align);
 
904
    avio_wb16(pb, st->codec->block_align);
904
905
 
905
906
    // avg bytes per sec
906
907
    mxf_write_local_tag(pb, 4, 0x3D09);
907
 
    put_be32(pb, st->codec->block_align*st->codec->sample_rate);
 
908
    avio_wb32(pb, st->codec->block_align*st->codec->sample_rate);
908
909
}
909
910
 
910
911
static void mxf_write_wav_desc(AVFormatContext *s, AVStream *st)
925
926
static void mxf_write_package(AVFormatContext *s, enum MXFMetadataSetType type)
926
927
{
927
928
    MXFContext *mxf = s->priv_data;
928
 
    ByteIOContext *pb = s->pb;
 
929
    AVIOContext *pb = s->pb;
929
930
    int i, track_count = s->nb_streams+1;
930
931
 
931
932
    if (type == MaterialPackage) {
951
952
 
952
953
    // package creation date
953
954
    mxf_write_local_tag(pb, 8, 0x4405);
954
 
    put_be64(pb, mxf->timestamp);
 
955
    avio_wb64(pb, mxf->timestamp);
955
956
 
956
957
    // package modified date
957
958
    mxf_write_local_tag(pb, 8, 0x4404);
958
 
    put_be64(pb, mxf->timestamp);
 
959
    avio_wb64(pb, mxf->timestamp);
959
960
 
960
961
    // write track refs
961
962
    mxf_write_local_tag(pb, track_count*16 + 8, 0x4403);
995
996
 
996
997
static int mxf_write_essence_container_data(AVFormatContext *s)
997
998
{
998
 
    ByteIOContext *pb = s->pb;
 
999
    AVIOContext *pb = s->pb;
999
1000
 
1000
1001
    mxf_write_metadata_key(pb, 0x012300);
1001
1002
    klv_encode_ber_length(pb, 72);
1007
1008
    mxf_write_umid(s, 1);
1008
1009
 
1009
1010
    mxf_write_local_tag(pb, 4, 0x3F07); // BodySID
1010
 
    put_be32(pb, 1);
 
1011
    avio_wb32(pb, 1);
1011
1012
 
1012
1013
    mxf_write_local_tag(pb, 4, 0x3F06); // IndexSID
1013
 
    put_be32(pb, 2);
 
1014
    avio_wb32(pb, 2);
1014
1015
 
1015
1016
    return 0;
1016
1017
}
1038
1039
static void mxf_write_index_table_segment(AVFormatContext *s)
1039
1040
{
1040
1041
    MXFContext *mxf = s->priv_data;
1041
 
    ByteIOContext *pb = s->pb;
1042
 
    int i, j;
1043
 
    int temporal_reordering = 0;
 
1042
    AVIOContext *pb = s->pb;
 
1043
    int i, j, temporal_reordering = 0;
1044
1044
    int key_index = mxf->last_key_index;
1045
1045
 
1046
1046
    av_log(s, AV_LOG_DEBUG, "edit units count %d\n", mxf->edit_units_count);
1048
1048
    if (!mxf->edit_units_count && !mxf->edit_unit_byte_count)
1049
1049
        return;
1050
1050
 
1051
 
    put_buffer(pb, index_table_segment_key, 16);
 
1051
    avio_write(pb, index_table_segment_key, 16);
1052
1052
 
1053
1053
    if (mxf->edit_unit_byte_count) {
1054
1054
        klv_encode_ber_length(pb, 80);
1063
1063
 
1064
1064
    // index edit rate
1065
1065
    mxf_write_local_tag(pb, 8, 0x3F0B);
1066
 
    put_be32(pb, mxf->time_base.den);
1067
 
    put_be32(pb, mxf->time_base.num);
 
1066
    avio_wb32(pb, mxf->time_base.den);
 
1067
    avio_wb32(pb, mxf->time_base.num);
1068
1068
 
1069
1069
    // index start position
1070
1070
    mxf_write_local_tag(pb, 8, 0x3F0C);
1071
 
    put_be64(pb, mxf->last_indexed_edit_unit);
 
1071
    avio_wb64(pb, mxf->last_indexed_edit_unit);
1072
1072
 
1073
1073
    // index duration
1074
1074
    mxf_write_local_tag(pb, 8, 0x3F0D);
1075
1075
    if (mxf->edit_unit_byte_count)
1076
 
        put_be64(pb, 0); // index table covers whole container
 
1076
        avio_wb64(pb, 0); // index table covers whole container
1077
1077
    else
1078
 
        put_be64(pb, mxf->edit_units_count);
 
1078
        avio_wb64(pb, mxf->edit_units_count);
1079
1079
 
1080
1080
    // edit unit byte count
1081
1081
    mxf_write_local_tag(pb, 4, 0x3F05);
1082
 
    put_be32(pb, mxf->edit_unit_byte_count);
 
1082
    avio_wb32(pb, mxf->edit_unit_byte_count);
1083
1083
 
1084
1084
    // index sid
1085
1085
    mxf_write_local_tag(pb, 4, 0x3F06);
1086
 
    put_be32(pb, 2);
 
1086
    avio_wb32(pb, 2);
1087
1087
 
1088
1088
    // body sid
1089
1089
    mxf_write_local_tag(pb, 4, 0x3F07);
1090
 
    put_be32(pb, 1);
 
1090
    avio_wb32(pb, 1);
1091
1091
 
1092
1092
    if (!mxf->edit_unit_byte_count) {
1093
1093
        // real slice count - 1
1094
1094
        mxf_write_local_tag(pb, 1, 0x3F08);
1095
 
        put_byte(pb, mxf->slice_count);
 
1095
        avio_w8(pb, mxf->slice_count);
1096
1096
 
1097
1097
        // delta entry array
1098
1098
        mxf_write_local_tag(pb, 8 + (s->nb_streams+1)*6, 0x3F09);
1099
 
        put_be32(pb, s->nb_streams+1); // num of entries
1100
 
        put_be32(pb, 6);               // size of one entry
 
1099
        avio_wb32(pb, s->nb_streams+1); // num of entries
 
1100
        avio_wb32(pb, 6);               // size of one entry
1101
1101
        // write system item delta entry
1102
 
        put_byte(pb, 0);
1103
 
        put_byte(pb, 0); // slice entry
1104
 
        put_be32(pb, 0); // element delta
 
1102
        avio_w8(pb, 0);
 
1103
        avio_w8(pb, 0); // slice entry
 
1104
        avio_wb32(pb, 0); // element delta
1105
1105
        for (i = 0; i < s->nb_streams; i++) {
1106
1106
            AVStream *st = s->streams[i];
1107
1107
            MXFStreamContext *sc = st->priv_data;
1108
 
            put_byte(pb, sc->temporal_reordering);
 
1108
            avio_w8(pb, sc->temporal_reordering);
1109
1109
            if (sc->temporal_reordering)
1110
1110
                temporal_reordering = 1;
1111
1111
            if (i == 0) { // video track
1112
 
                put_byte(pb, 0); // slice number
1113
 
                put_be32(pb, KAG_SIZE); // system item size including klv fill
 
1112
                avio_w8(pb, 0); // slice number
 
1113
                avio_wb32(pb, KAG_SIZE); // system item size including klv fill
1114
1114
            } else { // audio track
1115
1115
                unsigned audio_frame_size = sc->aic.samples[0]*sc->aic.sample_size;
1116
1116
                audio_frame_size += klv_fill_size(audio_frame_size);
1117
 
                put_byte(pb, 1);
1118
 
                put_be32(pb, (i-1)*audio_frame_size); // element delta
 
1117
                avio_w8(pb, 1);
 
1118
                avio_wb32(pb, (i-1)*audio_frame_size); // element delta
1119
1119
            }
1120
1120
        }
1121
1121
 
1122
1122
        mxf_write_local_tag(pb, 8 + mxf->edit_units_count*(11+mxf->slice_count*4), 0x3F0A);
1123
 
        put_be32(pb, mxf->edit_units_count);  // num of entries
1124
 
        put_be32(pb, 11+mxf->slice_count*4);  // size of one entry
 
1123
        avio_wb32(pb, mxf->edit_units_count);  // num of entries
 
1124
        avio_wb32(pb, 11+mxf->slice_count*4);  // size of one entry
 
1125
 
1125
1126
        for (i = 0; i < mxf->edit_units_count; i++) {
1126
1127
            int temporal_offset = 0;
1127
 
            if (temporal_reordering) {
1128
 
                for (j = i+1; j < mxf->edit_units_count; j++) {
1129
 
                    temporal_offset++;
1130
 
                    if (mxf->index_entries[j].flags & 0x10) { // backward prediction
1131
 
                        // next is not b, so is reordered
1132
 
                        if (!(mxf->index_entries[i+1].flags & 0x10)) {
1133
 
                            if ((mxf->index_entries[i].flags & 0x11) == 0) // I frame
1134
 
                                temporal_offset = 0;
1135
 
                            else
1136
 
                                temporal_offset = -temporal_offset;
1137
 
                        }
1138
 
                        break;
1139
 
                    }
1140
 
                }
1141
 
            }
1142
 
            put_byte(pb, temporal_offset);
1143
1128
 
1144
1129
            if (!(mxf->index_entries[i].flags & 0x33)) { // I frame
1145
 
                if (mxf->index_entries[i].flags & 0x40 && // seq header
1146
 
                    (!temporal_reordering || !temporal_offset))
1147
 
                    mxf->index_entries[i].flags |= 0x80; // random access
1148
1130
                mxf->last_key_index = key_index;
1149
1131
                key_index = i;
1150
1132
            }
 
1133
 
 
1134
            if (temporal_reordering) {
 
1135
                int pic_num_in_gop = i - key_index;
 
1136
                if (pic_num_in_gop != mxf->index_entries[i].temporal_ref) {
 
1137
                    for (j = key_index; j < mxf->edit_units_count; j++) {
 
1138
                        if (pic_num_in_gop == mxf->index_entries[j].temporal_ref)
 
1139
                            break;
 
1140
                    }
 
1141
                    if (j == mxf->edit_units_count)
 
1142
                        av_log(s, AV_LOG_WARNING, "missing frames\n");
 
1143
                    temporal_offset = j - key_index - pic_num_in_gop;
 
1144
                }
 
1145
            }
 
1146
            avio_w8(pb, temporal_offset);
 
1147
 
1151
1148
            if ((mxf->index_entries[i].flags & 0x30) == 0x30) { // back and forward prediction
1152
 
                put_byte(pb, mxf->last_key_index - i);
 
1149
                avio_w8(pb, mxf->last_key_index - i);
1153
1150
            } else {
1154
 
                put_byte(pb, key_index - i); // key frame offset
 
1151
                avio_w8(pb, key_index - i); // key frame offset
1155
1152
                if ((mxf->index_entries[i].flags & 0x20) == 0x20) // only forward
1156
1153
                    mxf->last_key_index = key_index;
1157
1154
            }
1158
 
            put_byte(pb, mxf->index_entries[i].flags);
 
1155
 
 
1156
            if (!(mxf->index_entries[i].flags & 0x33) && // I frame
 
1157
                mxf->index_entries[i].flags & 0x40 && !temporal_offset)
 
1158
                mxf->index_entries[i].flags |= 0x80; // random access
 
1159
            avio_w8(pb, mxf->index_entries[i].flags);
1159
1160
            // stream offset
1160
 
            put_be64(pb, mxf->index_entries[i].offset);
 
1161
            avio_wb64(pb, mxf->index_entries[i].offset);
1161
1162
            if (s->nb_streams > 1)
1162
 
                put_be32(pb, mxf->index_entries[i].slice_offset);
 
1163
                avio_wb32(pb, mxf->index_entries[i].slice_offset);
1163
1164
        }
1164
1165
 
1165
1166
        mxf->last_key_index = key_index - mxf->edit_units_count;
1170
1171
 
1171
1172
static void mxf_write_klv_fill(AVFormatContext *s)
1172
1173
{
1173
 
    unsigned pad = klv_fill_size(url_ftell(s->pb));
 
1174
    unsigned pad = klv_fill_size(avio_tell(s->pb));
1174
1175
    if (pad) {
1175
 
        put_buffer(s->pb, klv_fill_key, 16);
 
1176
        avio_write(s->pb, klv_fill_key, 16);
1176
1177
        pad -= 16 + 4;
1177
1178
        klv_encode_ber4_length(s->pb, pad);
1178
1179
        for (; pad; pad--)
1179
 
            put_byte(s->pb, 0);
1180
 
        assert(!(url_ftell(s->pb) & (KAG_SIZE-1)));
 
1180
            avio_w8(s->pb, 0);
 
1181
        assert(!(avio_tell(s->pb) & (KAG_SIZE-1)));
1181
1182
    }
1182
1183
}
1183
1184
 
1186
1187
                                const uint8_t *key, int write_metadata)
1187
1188
{
1188
1189
    MXFContext *mxf = s->priv_data;
1189
 
    ByteIOContext *pb = s->pb;
 
1190
    AVIOContext *pb = s->pb;
1190
1191
    int64_t header_byte_count_offset;
1191
1192
    unsigned index_byte_count = 0;
1192
 
    uint64_t partition_offset = url_ftell(pb);
 
1193
    uint64_t partition_offset = avio_tell(pb);
1193
1194
 
1194
1195
    if (!mxf->edit_unit_byte_count && mxf->edit_units_count)
1195
1196
        index_byte_count = 85 + 12+(s->nb_streams+1)*6 +
1212
1213
    }
1213
1214
 
1214
1215
    // write klv
1215
 
    put_buffer(pb, key, 16);
 
1216
    avio_write(pb, key, 16);
1216
1217
    klv_encode_ber_length(pb, 88 + 16 * mxf->essence_container_count);
1217
1218
 
1218
1219
    // write partition value
1219
 
    put_be16(pb, 1); // majorVersion
1220
 
    put_be16(pb, 2); // minorVersion
1221
 
    put_be32(pb, KAG_SIZE); // KAGSize
 
1220
    avio_wb16(pb, 1); // majorVersion
 
1221
    avio_wb16(pb, 2); // minorVersion
 
1222
    avio_wb32(pb, KAG_SIZE); // KAGSize
1222
1223
 
1223
 
    put_be64(pb, partition_offset); // ThisPartition
 
1224
    avio_wb64(pb, partition_offset); // ThisPartition
1224
1225
 
1225
1226
    if (!memcmp(key, body_partition_key, 16) && mxf->body_partitions_count > 1)
1226
 
        put_be64(pb, mxf->body_partition_offset[mxf->body_partitions_count-2]); // PreviousPartition
 
1227
        avio_wb64(pb, mxf->body_partition_offset[mxf->body_partitions_count-2]); // PreviousPartition
1227
1228
    else if (!memcmp(key, footer_partition_key, 16) && mxf->body_partitions_count)
1228
 
        put_be64(pb, mxf->body_partition_offset[mxf->body_partitions_count-1]); // PreviousPartition
 
1229
        avio_wb64(pb, mxf->body_partition_offset[mxf->body_partitions_count-1]); // PreviousPartition
1229
1230
    else
1230
 
        put_be64(pb, 0);
 
1231
        avio_wb64(pb, 0);
1231
1232
 
1232
 
    put_be64(pb, mxf->footer_partition_offset); // footerPartition
 
1233
    avio_wb64(pb, mxf->footer_partition_offset); // footerPartition
1233
1234
 
1234
1235
    // set offset
1235
 
    header_byte_count_offset = url_ftell(pb);
1236
 
    put_be64(pb, 0); // headerByteCount, update later
 
1236
    header_byte_count_offset = avio_tell(pb);
 
1237
    avio_wb64(pb, 0); // headerByteCount, update later
1237
1238
 
1238
1239
    // indexTable
1239
 
    put_be64(pb, index_byte_count); // indexByteCount
1240
 
    put_be32(pb, index_byte_count ? indexsid : 0); // indexSID
 
1240
    avio_wb64(pb, index_byte_count); // indexByteCount
 
1241
    avio_wb32(pb, index_byte_count ? indexsid : 0); // indexSID
1241
1242
 
1242
1243
    // BodyOffset
1243
1244
    if (bodysid && mxf->edit_units_count && mxf->body_partitions_count) {
1244
 
        put_be64(pb, mxf->body_offset);
 
1245
        avio_wb64(pb, mxf->body_offset);
1245
1246
    } else
1246
 
        put_be64(pb, 0);
 
1247
        avio_wb64(pb, 0);
1247
1248
 
1248
 
    put_be32(pb, bodysid); // bodySID
 
1249
    avio_wb32(pb, bodysid); // bodySID
1249
1250
 
1250
1251
    // operational pattern
1251
 
    put_buffer(pb, op1a_ul, 16);
 
1252
    avio_write(pb, op1a_ul, 16);
1252
1253
 
1253
1254
    // essence container
1254
1255
    mxf_write_essence_container_refs(s);
1259
1260
        unsigned header_byte_count;
1260
1261
 
1261
1262
        mxf_write_klv_fill(s);
1262
 
        start = url_ftell(s->pb);
 
1263
        start = avio_tell(s->pb);
1263
1264
        mxf_write_primer_pack(s);
1264
1265
        mxf_write_header_metadata_sets(s);
1265
 
        pos = url_ftell(s->pb);
 
1266
        pos = avio_tell(s->pb);
1266
1267
        header_byte_count = pos - start + klv_fill_size(pos);
1267
1268
 
1268
1269
        // update header_byte_count
1269
 
        url_fseek(pb, header_byte_count_offset, SEEK_SET);
1270
 
        put_be64(pb, header_byte_count);
1271
 
        url_fseek(pb, pos, SEEK_SET);
 
1270
        avio_seek(pb, header_byte_count_offset, SEEK_SET);
 
1271
        avio_wb64(pb, header_byte_count);
 
1272
        avio_seek(pb, pos, SEEK_SET);
1272
1273
    }
1273
1274
 
1274
 
    put_flush_packet(pb);
 
1275
    avio_flush(pb);
1275
1276
}
1276
1277
 
1277
1278
static const UID mxf_mpeg2_codec_uls[] = {
1303
1304
    return NULL;
1304
1305
}
1305
1306
 
1306
 
static int mxf_parse_mpeg2_frame(AVFormatContext *s, AVStream *st, AVPacket *pkt, int *flags)
 
1307
static int mxf_parse_mpeg2_frame(AVFormatContext *s, AVStream *st,
 
1308
                                 AVPacket *pkt, MXFIndexEntry *e)
1307
1309
{
1308
1310
    MXFStreamContext *sc = st->priv_data;
1309
1311
    MXFContext *mxf = s->priv_data;
1310
1312
    uint32_t c = -1;
1311
1313
    int i;
1312
1314
 
1313
 
    *flags = 0;
1314
 
 
1315
1315
    for(i = 0; i < pkt->size - 4; i++) {
1316
1316
        c = (c<<8) + pkt->data[i];
1317
1317
        if (c == 0x1b5) {
1325
1325
        } else if (c == 0x1b8) { // gop
1326
1326
            if (pkt->data[i+4]>>6 & 0x01) { // closed
1327
1327
                sc->closed_gop = 1;
1328
 
                if (*flags & 0x40) // sequence header present
1329
 
                    *flags |= 0x80; // random access
 
1328
                if (e->flags & 0x40) // sequence header present
 
1329
                    e->flags |= 0x80; // random access
1330
1330
            }
1331
1331
            if (!mxf->header_written) {
1332
1332
                unsigned hours   =  (pkt->data[i+1]>>2) & 0x1f;
1344
1344
                       hours, minutes, seconds, mxf->timecode_drop_frame ? ';':':', frames);
1345
1345
            }
1346
1346
        } else if (c == 0x1b3) { // seq
1347
 
            *flags |= 0x40;
 
1347
            e->flags |= 0x40;
1348
1348
            switch ((pkt->data[i+4]>>4) & 0xf) {
1349
1349
            case 2:  sc->aspect_ratio = (AVRational){  4,  3}; break;
1350
1350
            case 3:  sc->aspect_ratio = (AVRational){ 16,  9}; break;
1355
1355
            }
1356
1356
        } else if (c == 0x100) { // pic
1357
1357
            int pict_type = (pkt->data[i+2]>>3) & 0x07;
 
1358
            e->temporal_ref = (pkt->data[i+1]<<2) | (pkt->data[i+2]>>6);
1358
1359
            if (pict_type == 2) { // P frame
1359
 
                *flags |= 0x22;
 
1360
                e->flags |= 0x22;
1360
1361
                sc->closed_gop = 0; // reset closed gop, don't matter anymore
1361
1362
            } else if (pict_type == 3) { // B frame
1362
1363
                if (sc->closed_gop)
1363
 
                    *flags |= 0x13; // only backward prediction
 
1364
                    e->flags |= 0x13; // only backward prediction
1364
1365
                else
1365
 
                    *flags |= 0x33;
 
1366
                    e->flags |= 0x33;
1366
1367
                sc->temporal_reordering = -1;
1367
1368
            } else if (!pict_type) {
1368
1369
                av_log(s, AV_LOG_ERROR, "error parsing mpeg2 frame\n");
1370
1371
            }
1371
1372
        }
1372
1373
    }
1373
 
    if (s->oformat != &mxf_d10_muxer)
 
1374
    if (s->oformat != &ff_mxf_d10_muxer)
1374
1375
        sc->codec_ul = mxf_get_mpeg2_codec_ul(st->codec);
1375
1376
    return !!sc->codec_ul;
1376
1377
}
1378
1379
static uint64_t mxf_parse_timestamp(time_t timestamp)
1379
1380
{
1380
1381
    struct tm *time = gmtime(&timestamp);
 
1382
    if (!time)
 
1383
        return 0;
1381
1384
    return (uint64_t)(time->tm_year+1900) << 48 |
1382
1385
           (uint64_t)(time->tm_mon+1)     << 40 |
1383
1386
           (uint64_t) time->tm_mday       << 32 |
1389
1392
static void mxf_gen_umid(AVFormatContext *s)
1390
1393
{
1391
1394
    MXFContext *mxf = s->priv_data;
1392
 
    uint32_t seed = ff_random_get_seed();
 
1395
    uint32_t seed = av_get_random_seed();
1393
1396
    uint64_t umid = seed + 0x5294713400000000LL;
1394
1397
 
1395
1398
    AV_WB64(mxf->umid  , umid);
1433
1436
                return -1;
1434
1437
            }
1435
1438
            av_set_pts_info(st, 64, mxf->time_base.num, mxf->time_base.den);
1436
 
            if (s->oformat == &mxf_d10_muxer) {
 
1439
            if (s->oformat == &ff_mxf_d10_muxer) {
1437
1440
                if (st->codec->bit_rate == 50000000)
1438
1441
                    if (mxf->time_base.den == 25) sc->index = 3;
1439
1442
                    else                          sc->index = 5;
1461
1464
                return -1;
1462
1465
            }
1463
1466
            av_set_pts_info(st, 64, 1, st->codec->sample_rate);
1464
 
            if (s->oformat == &mxf_d10_muxer) {
 
1467
            if (s->oformat == &ff_mxf_d10_muxer) {
1465
1468
                if (st->index != 1) {
1466
1469
                    av_log(s, AV_LOG_ERROR, "MXF D-10 only support one audio track\n");
1467
1470
                    return -1;
1495
1498
        present[sc->index]++;
1496
1499
    }
1497
1500
 
1498
 
    if (s->oformat == &mxf_d10_muxer) {
 
1501
    if (s->oformat == &ff_mxf_d10_muxer) {
1499
1502
        mxf->essence_container_count = 1;
1500
1503
    }
1501
1504
 
1554
1557
static void mxf_write_system_item(AVFormatContext *s)
1555
1558
{
1556
1559
    MXFContext *mxf = s->priv_data;
1557
 
    ByteIOContext *pb = s->pb;
 
1560
    AVIOContext *pb = s->pb;
1558
1561
    unsigned frame;
1559
1562
    uint32_t time_code;
1560
1563
 
1561
1564
    frame = mxf->timecode_start + mxf->last_indexed_edit_unit + mxf->edit_units_count;
1562
1565
 
1563
1566
    // write system metadata pack
1564
 
    put_buffer(pb, system_metadata_pack_key, 16);
 
1567
    avio_write(pb, system_metadata_pack_key, 16);
1565
1568
    klv_encode_ber4_length(pb, 57);
1566
 
    put_byte(pb, 0x5c); // UL, user date/time stamp, picture and sound item present
1567
 
    put_byte(pb, 0x04); // content package rate
1568
 
    put_byte(pb, 0x00); // content package type
1569
 
    put_be16(pb, 0x00); // channel handle
1570
 
    put_be16(pb, frame); // continuity count
 
1569
    avio_w8(pb, 0x5c); // UL, user date/time stamp, picture and sound item present
 
1570
    avio_w8(pb, 0x04); // content package rate
 
1571
    avio_w8(pb, 0x00); // content package type
 
1572
    avio_wb16(pb, 0x00); // channel handle
 
1573
    avio_wb16(pb, frame); // continuity count
1571
1574
    if (mxf->essence_container_count > 1)
1572
 
        put_buffer(pb, multiple_desc_ul, 16);
 
1575
        avio_write(pb, multiple_desc_ul, 16);
1573
1576
    else {
1574
1577
        MXFStreamContext *sc = s->streams[0]->priv_data;
1575
 
        put_buffer(pb, mxf_essence_container_uls[sc->index].container_ul, 16);
 
1578
        avio_write(pb, mxf_essence_container_uls[sc->index].container_ul, 16);
1576
1579
    }
1577
 
    put_byte(pb, 0);
1578
 
    put_be64(pb, 0);
1579
 
    put_be64(pb, 0); // creation date/time stamp
 
1580
    avio_w8(pb, 0);
 
1581
    avio_wb64(pb, 0);
 
1582
    avio_wb64(pb, 0); // creation date/time stamp
1580
1583
 
1581
 
    put_byte(pb, 0x81); // SMPTE 12M time code
 
1584
    avio_w8(pb, 0x81); // SMPTE 12M time code
1582
1585
    time_code = ff_framenum_to_12m_time_code(frame, mxf->timecode_drop_frame, mxf->timecode_base);
1583
 
    put_be32(pb, time_code);
1584
 
    put_be32(pb, 0); // binary group data
1585
 
    put_be64(pb, 0);
 
1586
    avio_wb32(pb, time_code);
 
1587
    avio_wb32(pb, 0); // binary group data
 
1588
    avio_wb64(pb, 0);
1586
1589
 
1587
1590
    // write system metadata package set
1588
 
    put_buffer(pb, system_metadata_package_set_key, 16);
 
1591
    avio_write(pb, system_metadata_package_set_key, 16);
1589
1592
    klv_encode_ber4_length(pb, 35);
1590
 
    put_byte(pb, 0x83); // UMID
1591
 
    put_be16(pb, 0x20);
 
1593
    avio_w8(pb, 0x83); // UMID
 
1594
    avio_wb16(pb, 0x20);
1592
1595
    mxf_write_umid(s, 1);
1593
1596
}
1594
1597
 
1595
1598
static void mxf_write_d10_video_packet(AVFormatContext *s, AVStream *st, AVPacket *pkt)
1596
1599
{
1597
1600
    MXFContext *mxf = s->priv_data;
1598
 
    ByteIOContext *pb = s->pb;
 
1601
    AVIOContext *pb = s->pb;
1599
1602
    int packet_size = (uint64_t)st->codec->bit_rate*mxf->time_base.num /
1600
1603
        (8*mxf->time_base.den); // frame size
1601
1604
    int pad;
1604
1607
    packet_size += klv_fill_size(packet_size);
1605
1608
 
1606
1609
    klv_encode_ber4_length(pb, pkt->size);
1607
 
    put_buffer(pb, pkt->data, pkt->size);
 
1610
    avio_write(pb, pkt->data, pkt->size);
1608
1611
 
1609
1612
    // ensure CBR muxing by padding to correct video frame size
1610
1613
    pad = packet_size - pkt->size - 16 - 4;
1611
1614
    if (pad > 20) {
1612
 
        put_buffer(s->pb, klv_fill_key, 16);
 
1615
        avio_write(s->pb, klv_fill_key, 16);
1613
1616
        pad -= 16 + 4;
1614
1617
        klv_encode_ber4_length(s->pb, pad);
1615
1618
        for (; pad; pad--)
1616
 
            put_byte(s->pb, 0);
1617
 
        assert(!(url_ftell(s->pb) & (KAG_SIZE-1)));
 
1619
            avio_w8(s->pb, 0);
 
1620
        assert(!(avio_tell(s->pb) & (KAG_SIZE-1)));
1618
1621
    } else {
1619
1622
        av_log(s, AV_LOG_WARNING, "cannot fill d-10 video packet\n");
1620
1623
        for (; pad > 0; pad--)
1621
 
            put_byte(s->pb, 0);
 
1624
            avio_w8(s->pb, 0);
1622
1625
    }
1623
1626
}
1624
1627
 
1625
1628
static void mxf_write_d10_audio_packet(AVFormatContext *s, AVStream *st, AVPacket *pkt)
1626
1629
{
1627
1630
    MXFContext *mxf = s->priv_data;
1628
 
    ByteIOContext *pb = s->pb;
 
1631
    AVIOContext *pb = s->pb;
1629
1632
    int frame_size = pkt->size / st->codec->block_align;
1630
1633
    uint8_t *samples = pkt->data;
1631
1634
    uint8_t *end = pkt->data + pkt->size;
1633
1636
 
1634
1637
    klv_encode_ber4_length(pb, 4 + frame_size*4*8);
1635
1638
 
1636
 
    put_byte(pb, (frame_size == 1920 ? 0 : (mxf->edit_units_count-1) % 5 + 1));
1637
 
    put_le16(pb, frame_size);
1638
 
    put_byte(pb, (1<<st->codec->channels)-1);
 
1639
    avio_w8(pb, (frame_size == 1920 ? 0 : (mxf->edit_units_count-1) % 5 + 1));
 
1640
    avio_wl16(pb, frame_size);
 
1641
    avio_w8(pb, (1<<st->codec->channels)-1);
1639
1642
 
1640
1643
    while (samples < end) {
1641
1644
        for (i = 0; i < st->codec->channels; i++) {
1647
1650
                sample = AV_RL16(samples)<<12;
1648
1651
                samples += 2;
1649
1652
            }
1650
 
            put_le32(pb, sample | i);
 
1653
            avio_wl32(pb, sample | i);
1651
1654
        }
1652
1655
        for (; i < 8; i++)
1653
 
            put_le32(pb, i);
 
1656
            avio_wl32(pb, i);
1654
1657
    }
1655
1658
}
1656
1659
 
1657
1660
static int mxf_write_packet(AVFormatContext *s, AVPacket *pkt)
1658
1661
{
1659
1662
    MXFContext *mxf = s->priv_data;
1660
 
    ByteIOContext *pb = s->pb;
 
1663
    AVIOContext *pb = s->pb;
1661
1664
    AVStream *st = s->streams[pkt->stream_index];
1662
1665
    MXFStreamContext *sc = st->priv_data;
1663
 
    int flags = 0;
 
1666
    MXFIndexEntry ie = {0};
1664
1667
 
1665
1668
    if (!mxf->edit_unit_byte_count && !(mxf->edit_units_count % EDIT_UNITS_PER_BODY)) {
1666
1669
        mxf->index_entries = av_realloc(mxf->index_entries,
1672
1675
    }
1673
1676
 
1674
1677
    if (st->codec->codec_id == CODEC_ID_MPEG2VIDEO) {
1675
 
        if (!mxf_parse_mpeg2_frame(s, st, pkt, &flags)) {
 
1678
        if (!mxf_parse_mpeg2_frame(s, st, pkt, &ie)) {
1676
1679
            av_log(s, AV_LOG_ERROR, "could not get mpeg2 profile and level\n");
1677
1680
            return -1;
1678
1681
        }
1692
1695
    if (st->index == 0) {
1693
1696
        if (!mxf->edit_unit_byte_count &&
1694
1697
            (!mxf->edit_units_count || mxf->edit_units_count > EDIT_UNITS_PER_BODY) &&
1695
 
            !(flags & 0x33)) { // I frame, Gop start
 
1698
            !(ie.flags & 0x33)) { // I frame, Gop start
1696
1699
            mxf_write_klv_fill(s);
1697
1700
            mxf_write_partition(s, 1, 2, body_partition_key, 0);
1698
1701
 
1705
1708
 
1706
1709
        if (!mxf->edit_unit_byte_count) {
1707
1710
            mxf->index_entries[mxf->edit_units_count].offset = mxf->body_offset;
1708
 
            mxf->index_entries[mxf->edit_units_count].flags = flags;
 
1711
            mxf->index_entries[mxf->edit_units_count].flags = ie.flags;
 
1712
            mxf->index_entries[mxf->edit_units_count].temporal_ref = ie.temporal_ref;
1709
1713
            mxf->body_offset += KAG_SIZE; // size of system element
1710
1714
        }
1711
1715
        mxf->edit_units_count++;
1715
1719
    }
1716
1720
 
1717
1721
    mxf_write_klv_fill(s);
1718
 
    put_buffer(pb, sc->track_essence_element_key, 16); // write key
1719
 
    if (s->oformat == &mxf_d10_muxer) {
 
1722
    avio_write(pb, sc->track_essence_element_key, 16); // write key
 
1723
    if (s->oformat == &ff_mxf_d10_muxer) {
1720
1724
        if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1721
1725
            mxf_write_d10_video_packet(s, st, pkt);
1722
1726
        else
1723
1727
            mxf_write_d10_audio_packet(s, st, pkt);
1724
1728
    } else {
1725
1729
        klv_encode_ber4_length(pb, pkt->size); // write length
1726
 
        put_buffer(pb, pkt->data, pkt->size);
 
1730
        avio_write(pb, pkt->data, pkt->size);
1727
1731
        mxf->body_offset += 16+4+pkt->size + klv_fill_size(16+4+pkt->size);
1728
1732
    }
1729
1733
 
1730
 
    put_flush_packet(pb);
 
1734
    avio_flush(pb);
1731
1735
 
1732
1736
    return 0;
1733
1737
}
1735
1739
static void mxf_write_random_index_pack(AVFormatContext *s)
1736
1740
{
1737
1741
    MXFContext *mxf = s->priv_data;
1738
 
    ByteIOContext *pb = s->pb;
1739
 
    uint64_t pos = url_ftell(pb);
 
1742
    AVIOContext *pb = s->pb;
 
1743
    uint64_t pos = avio_tell(pb);
1740
1744
    int i;
1741
1745
 
1742
 
    put_buffer(pb, random_index_pack_key, 16);
 
1746
    avio_write(pb, random_index_pack_key, 16);
1743
1747
    klv_encode_ber_length(pb, 28 + 12*mxf->body_partitions_count);
1744
1748
 
1745
1749
    if (mxf->edit_unit_byte_count)
1746
 
        put_be32(pb, 1); // BodySID of header partition
 
1750
        avio_wb32(pb, 1); // BodySID of header partition
1747
1751
    else
1748
 
        put_be32(pb, 0);
1749
 
    put_be64(pb, 0); // offset of header partition
 
1752
        avio_wb32(pb, 0);
 
1753
    avio_wb64(pb, 0); // offset of header partition
1750
1754
 
1751
1755
    for (i = 0; i < mxf->body_partitions_count; i++) {
1752
 
        put_be32(pb, 1); // BodySID
1753
 
        put_be64(pb, mxf->body_partition_offset[i]);
 
1756
        avio_wb32(pb, 1); // BodySID
 
1757
        avio_wb64(pb, mxf->body_partition_offset[i]);
1754
1758
    }
1755
1759
 
1756
 
    put_be32(pb, 0); // BodySID of footer partition
1757
 
    put_be64(pb, mxf->footer_partition_offset);
 
1760
    avio_wb32(pb, 0); // BodySID of footer partition
 
1761
    avio_wb64(pb, mxf->footer_partition_offset);
1758
1762
 
1759
 
    put_be32(pb, url_ftell(pb) - pos + 4);
 
1763
    avio_wb32(pb, avio_tell(pb) - pos + 4);
1760
1764
}
1761
1765
 
1762
1766
static int mxf_write_footer(AVFormatContext *s)
1763
1767
{
1764
1768
    MXFContext *mxf = s->priv_data;
1765
 
    ByteIOContext *pb = s->pb;
 
1769
    AVIOContext *pb = s->pb;
1766
1770
 
1767
1771
    mxf->duration = mxf->last_indexed_edit_unit + mxf->edit_units_count;
1768
1772
 
1769
1773
    mxf_write_klv_fill(s);
1770
 
    mxf->footer_partition_offset = url_ftell(pb);
 
1774
    mxf->footer_partition_offset = avio_tell(pb);
1771
1775
    if (mxf->edit_unit_byte_count) { // no need to repeat index
1772
1776
        mxf_write_partition(s, 0, 0, footer_partition_key, 0);
1773
1777
    } else {
1780
1784
    mxf_write_klv_fill(s);
1781
1785
    mxf_write_random_index_pack(s);
1782
1786
 
1783
 
    if (!url_is_streamed(s->pb)) {
1784
 
        url_fseek(pb, 0, SEEK_SET);
 
1787
    if (s->pb->seekable) {
 
1788
        avio_seek(pb, 0, SEEK_SET);
1785
1789
        if (mxf->edit_unit_byte_count) {
1786
1790
            mxf_write_partition(s, 1, 2, header_closed_partition_key, 1);
1787
1791
            mxf_write_klv_fill(s);
1791
1795
        }
1792
1796
    }
1793
1797
 
1794
 
    put_flush_packet(pb);
 
1798
    avio_flush(pb);
1795
1799
 
1796
1800
    ff_audio_interleave_close(s);
1797
1801
 
1875
1879
                               mxf_interleave_get_packet, mxf_compare_timestamps);
1876
1880
}
1877
1881
 
1878
 
AVOutputFormat mxf_muxer = {
 
1882
AVOutputFormat ff_mxf_muxer = {
1879
1883
    "mxf",
1880
1884
    NULL_IF_CONFIG_SMALL("Material eXchange Format"),
1881
1885
    "application/mxf",
1891
1895
    mxf_interleave,
1892
1896
};
1893
1897
 
1894
 
AVOutputFormat mxf_d10_muxer = {
 
1898
AVOutputFormat ff_mxf_d10_muxer = {
1895
1899
    "mxf_d10",
1896
1900
    NULL_IF_CONFIG_SMALL("Material eXchange Format, D-10 Mapping"),
1897
1901
    "application/mxf",