2003-08-26 22:23:13 +02:00
/*
2006-10-23 10:57:54 +02:00
* MOV , 3 GP , MP4 muxer
2009-01-19 16:46:40 +01:00
* Copyright ( c ) 2003 Thomas Raivio
* Copyright ( c ) 2004 Gildas Bazin < gbazin at videolan dot org >
2009-03-15 11:53:12 +01:00
* Copyright ( c ) 2009 Baptiste Coudurier < baptiste dot coudurier at gmail dot com >
2003-08-26 22:23:13 +02:00
*
2006-10-07 17:30:46 +02:00
* This file is part of FFmpeg .
*
* FFmpeg is free software ; you can redistribute it and / or
2003-08-26 22:23:13 +02:00
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation ; either
2006-10-07 17:30:46 +02:00
* version 2.1 of the License , or ( at your option ) any later version .
2003-08-26 22:23:13 +02:00
*
2006-10-07 17:30:46 +02:00
* FFmpeg is distributed in the hope that it will be useful ,
2003-08-26 22:23:13 +02:00
* 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
2006-10-07 17:30:46 +02:00
* License along with FFmpeg ; if not , write to the Free Software
2006-01-12 23:43:26 +01:00
* Foundation , Inc . , 51 Franklin Street , Fifth Floor , Boston , MA 02110 - 1301 USA
2003-08-26 22:23:13 +02:00
*/
2009-03-15 11:49:52 +01:00
2010-05-18 21:38:37 +02:00
# include "movenc.h"
2003-08-26 22:23:13 +02:00
# include "avformat.h"
2011-02-24 07:36:02 +01:00
# include "avio_internal.h"
2006-07-12 02:09:34 +02:00
# include "riff.h"
2003-08-26 22:23:13 +02:00
# include "avio.h"
2006-08-01 16:58:15 +02:00
# include "isom.h"
2008-01-11 02:24:55 +01:00
# include "avc.h"
2009-04-13 18:20:26 +02:00
# include "libavcodec/get_bits.h"
2009-04-12 10:35:26 +02:00
# include "libavcodec/put_bits.h"
2012-01-21 01:16:34 +01:00
# include "libavcodec/vc1.h"
2010-05-18 21:47:24 +02:00
# include "internal.h"
# include "libavutil/avstring.h"
2011-11-27 15:04:16 +01:00
# include "libavutil/intfloat.h"
2011-06-04 13:58:23 +02:00
# include "libavutil/mathematics.h"
2011-05-21 13:57:04 +02:00
# include "libavutil/opt.h"
2011-05-22 12:46:29 +02:00
# include "libavutil/dict.h"
2011-05-21 13:58:43 +02:00
# include "rtpenc.h"
2011-12-03 19:32:45 +01:00
# include "mov_chan.h"
2003-08-26 22:23:13 +02:00
2003-09-10 01:03:04 +02:00
# undef NDEBUG
# include <assert.h>
2011-05-21 13:57:04 +02:00
static const AVOption options [ ] = {
2012-08-31 11:52:18 +02:00
{ " movflags " , " MOV muxer flags " , offsetof ( MOVMuxContext , flags ) , AV_OPT_TYPE_FLAGS , { . i64 = 0 } , INT_MIN , INT_MAX , AV_OPT_FLAG_ENCODING_PARAM , " movflags " } ,
2012-08-31 11:45:52 +02:00
{ " rtphint " , " Add RTP hint tracks " , 0 , AV_OPT_TYPE_CONST , { . i64 = FF_MOV_FLAG_RTP_HINT } , INT_MIN , INT_MAX , AV_OPT_FLAG_ENCODING_PARAM , " movflags " } ,
2012-09-05 14:26:01 +02:00
{ " moov_size " , " maximum moov size so it can be placed at the begin " , offsetof ( MOVMuxContext , reserved_moov_size ) , AV_OPT_TYPE_INT , { . i64 = 0 } , 0 , INT_MAX , AV_OPT_FLAG_ENCODING_PARAM , 0 } ,
2012-08-31 11:45:52 +02:00
{ " empty_moov " , " Make the initial moov atom empty (not supported by QuickTime) " , 0 , AV_OPT_TYPE_CONST , { . i64 = FF_MOV_FLAG_EMPTY_MOOV } , INT_MIN , INT_MAX , AV_OPT_FLAG_ENCODING_PARAM , " movflags " } ,
{ " frag_keyframe " , " Fragment at video keyframes " , 0 , AV_OPT_TYPE_CONST , { . i64 = FF_MOV_FLAG_FRAG_KEYFRAME } , INT_MIN , INT_MAX , AV_OPT_FLAG_ENCODING_PARAM , " movflags " } ,
{ " separate_moof " , " Write separate moof/mdat atoms for each track " , 0 , AV_OPT_TYPE_CONST , { . i64 = FF_MOV_FLAG_SEPARATE_MOOF } , INT_MIN , INT_MAX , AV_OPT_FLAG_ENCODING_PARAM , " movflags " } ,
{ " frag_custom " , " Flush fragments on caller requests " , 0 , AV_OPT_TYPE_CONST , { . i64 = FF_MOV_FLAG_FRAG_CUSTOM } , INT_MIN , INT_MAX , AV_OPT_FLAG_ENCODING_PARAM , " movflags " } ,
{ " isml " , " Create a live smooth streaming feed (for pushing to a publishing point) " , 0 , AV_OPT_TYPE_CONST , { . i64 = FF_MOV_FLAG_ISML } , INT_MIN , INT_MAX , AV_OPT_FLAG_ENCODING_PARAM , " movflags " } ,
2012-09-20 10:40:10 +02:00
{ " faststart " , " Run a second pass to put the moov at the beginning of the file " , 0 , AV_OPT_TYPE_CONST , { . i64 = FF_MOV_FLAG_FASTSTART } , INT_MIN , INT_MAX , AV_OPT_FLAG_ENCODING_PARAM , " movflags " } ,
2012-07-21 16:13:48 +02:00
FF_RTP_FLAG_OPTS ( MOVMuxContext , rtp_flags ) ,
2012-09-05 14:26:01 +02:00
{ " skip_iods " , " Skip writing iods atom. " , offsetof ( MOVMuxContext , iods_skip ) , AV_OPT_TYPE_INT , { . i64 = 1 } , 0 , 1 , AV_OPT_FLAG_ENCODING_PARAM } ,
2012-08-31 12:22:31 +02:00
{ " iods_audio_profile " , " iods audio profile atom. " , offsetof ( MOVMuxContext , iods_audio_profile ) , AV_OPT_TYPE_INT , { . i64 = - 1 } , - 1 , 255 , AV_OPT_FLAG_ENCODING_PARAM } ,
{ " iods_video_profile " , " iods video profile atom. " , offsetof ( MOVMuxContext , iods_video_profile ) , AV_OPT_TYPE_INT , { . i64 = - 1 } , - 1 , 255 , AV_OPT_FLAG_ENCODING_PARAM } ,
{ " frag_duration " , " Maximum fragment duration " , offsetof ( MOVMuxContext , max_fragment_duration ) , AV_OPT_TYPE_INT , { . i64 = 0 } , 0 , INT_MAX , AV_OPT_FLAG_ENCODING_PARAM } ,
{ " min_frag_duration " , " Minimum fragment duration " , offsetof ( MOVMuxContext , min_fragment_duration ) , AV_OPT_TYPE_INT , { . i64 = 0 } , 0 , INT_MAX , AV_OPT_FLAG_ENCODING_PARAM } ,
{ " frag_size " , " Maximum fragment size " , offsetof ( MOVMuxContext , max_fragment_size ) , AV_OPT_TYPE_INT , { . i64 = 0 } , 0 , INT_MAX , AV_OPT_FLAG_ENCODING_PARAM } ,
{ " ism_lookahead " , " Number of lookahead entries for ISM files " , offsetof ( MOVMuxContext , ism_lookahead ) , AV_OPT_TYPE_INT , { . i64 = 0 } , 0 , INT_MAX , AV_OPT_FLAG_ENCODING_PARAM } ,
2012-09-29 06:33:32 +02:00
{ " use_editlist " , " use edit list " , offsetof ( MOVMuxContext , use_editlist ) , AV_OPT_TYPE_INT , { . i64 = - 1 } , - 1 , 1 , AV_OPT_FLAG_ENCODING_PARAM } ,
2011-05-21 13:57:04 +02:00
{ NULL } ,
} ;
2011-10-03 19:14:03 +02:00
# define MOV_CLASS(flavor)\
static const AVClass flavor # # _muxer_class = { \
. class_name = # flavor " muxer " , \
. item_name = av_default_item_name , \
. option = options , \
. version = LIBAVUTIL_VERSION_INT , \
2011-05-21 13:57:04 +02:00
} ;
2007-06-12 20:50:50 +02:00
//FIXME support 64 bit variant with wide placeholders
2012-01-30 15:19:15 +01:00
static int64_t update_size ( AVIOContext * pb , int64_t pos )
2003-08-26 22:23:13 +02:00
{
2011-03-03 20:11:45 +01:00
int64_t curpos = avio_tell ( pb ) ;
2011-02-28 14:57:54 +01:00
avio_seek ( pb , pos , SEEK_SET ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , curpos - pos ) ; /* rewrite size */
2011-02-28 14:57:54 +01:00
avio_seek ( pb , curpos , SEEK_SET ) ;
2003-09-10 01:03:04 +02:00
return curpos - pos ;
2003-08-26 22:23:13 +02:00
}
2012-09-29 06:33:32 +02:00
static int supports_edts ( MOVMuxContext * mov )
{
// EDTS with fragments is tricky as we dont know the duration when its written
return ( mov - > use_editlist < 0 & & ! ( mov - > flags & FF_MOV_FLAG_FRAGMENT ) ) | | mov - > use_editlist > 0 ;
}
2012-09-20 10:39:04 +02:00
static int is_co64_required ( const MOVTrack * track )
{
int i ;
for ( i = 0 ; i < track - > entry ; i + + ) {
if ( ! track - > cluster [ i ] . chunkNum )
continue ;
if ( track - > cluster [ i ] . pos + track - > data_offset > UINT32_MAX )
return 1 ;
}
return 0 ;
}
2003-11-03 22:51:07 +01:00
/* Chunk offset atom */
2011-02-20 11:04:12 +01:00
static int mov_write_stco_tag ( AVIOContext * pb , MOVTrack * track )
2003-08-26 22:23:13 +02:00
{
int i ;
2012-09-20 10:39:04 +02:00
int mode64 = is_co64_required ( track ) ; // use 32 bit size variant if possible
2011-03-03 20:11:45 +01:00
int64_t pos = avio_tell ( pb ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* size */
2012-09-20 10:39:04 +02:00
if ( mode64 )
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " co64 " ) ;
2012-09-20 10:39:04 +02:00
else
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " stco " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* version & flags */
2011-11-29 04:03:22 +01:00
avio_wb32 ( pb , track - > chunkCount ) ; /* entry count */
2003-08-26 22:23:13 +02:00
for ( i = 0 ; i < track - > entry ; i + + ) {
2011-11-29 04:03:22 +01:00
if ( ! track - > cluster [ i ] . chunkNum )
continue ;
2006-01-23 15:12:03 +01:00
if ( mode64 = = 1 )
movenc: Buffer the mdat for the initial moov fragment, too
This allows writing QuickTime-compatible fragmented mp4 (with
a non-empty moov atom) to a non-seekable output.
This buffers the mdat for the initial fragment just as it does
for all normal fragments, too. Previously, the resulting
atom structure was mdat,moov, moof,mdat ..., while it now
is moov,mdat, moof,mdat.
Signed-off-by: Martin Storsjö <martin@martin.st>
2012-02-02 11:50:26 +01:00
avio_wb64 ( pb , track - > cluster [ i ] . pos + track - > data_offset ) ;
2006-01-23 15:12:03 +01:00
else
movenc: Buffer the mdat for the initial moov fragment, too
This allows writing QuickTime-compatible fragmented mp4 (with
a non-empty moov atom) to a non-seekable output.
This buffers the mdat for the initial fragment just as it does
for all normal fragments, too. Previously, the resulting
atom structure was mdat,moov, moof,mdat ..., while it now
is moov,mdat, moof,mdat.
Signed-off-by: Martin Storsjö <martin@martin.st>
2012-02-02 11:50:26 +01:00
avio_wb32 ( pb , track - > cluster [ i ] . pos + track - > data_offset ) ;
2003-08-26 22:23:13 +02:00
}
2012-01-30 15:19:15 +01:00
return update_size ( pb , pos ) ;
2003-08-26 22:23:13 +02:00
}
2003-11-03 22:51:07 +01:00
/* Sample size atom */
2011-02-20 11:04:12 +01:00
static int mov_write_stsz_tag ( AVIOContext * pb , MOVTrack * track )
2003-08-26 22:23:13 +02:00
{
2003-09-28 23:09:32 +02:00
int equalChunks = 1 ;
2003-11-03 22:51:07 +01:00
int i , j , entries = 0 , tst = - 1 , oldtst = - 1 ;
2003-08-26 22:23:13 +02:00
2011-03-03 20:11:45 +01:00
int64_t pos = avio_tell ( pb ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " stsz " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* version & flags */
2003-08-26 22:23:13 +02:00
2003-09-28 23:09:32 +02:00
for ( i = 0 ; i < track - > entry ; i + + ) {
2006-06-24 20:09:20 +02:00
tst = track - > cluster [ i ] . size / track - > cluster [ i ] . entries ;
2003-11-03 22:51:07 +01:00
if ( oldtst ! = - 1 & & tst ! = oldtst ) {
equalChunks = 0 ;
2003-09-28 23:09:32 +02:00
}
oldtst = tst ;
2006-06-24 20:09:20 +02:00
entries + = track - > cluster [ i ] . entries ;
2003-09-28 23:09:32 +02:00
}
2012-01-05 12:57:05 +01:00
if ( equalChunks & & track - > entry ) {
int sSize = track - > entry ? track - > cluster [ 0 ] . size / track - > cluster [ 0 ] . entries : 0 ;
2011-02-28 01:29:21 +01:00
sSize = FFMAX ( 1 , sSize ) ; // adpcm mono case could make sSize == 0
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , sSize ) ; // sample size
avio_wb32 ( pb , entries ) ; // sample count
2003-08-26 22:23:13 +02:00
}
2003-09-28 23:09:32 +02:00
else {
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; // sample size
avio_wb32 ( pb , entries ) ; // sample count
2003-09-28 23:09:32 +02:00
for ( i = 0 ; i < track - > entry ; i + + ) {
2008-02-06 19:57:00 +01:00
for ( j = 0 ; j < track - > cluster [ i ] . entries ; j + + ) {
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , track - > cluster [ i ] . size /
2006-06-24 20:09:20 +02:00
track - > cluster [ i ] . entries ) ;
2003-11-03 22:51:07 +01:00
}
2003-08-26 22:23:13 +02:00
}
}
2012-01-30 15:19:15 +01:00
return update_size ( pb , pos ) ;
2003-08-26 22:23:13 +02:00
}
2003-11-03 22:51:07 +01:00
/* Sample to chunk atom */
2011-02-20 11:04:12 +01:00
static int mov_write_stsc_tag ( AVIOContext * pb , MOVTrack * track )
2003-08-26 22:23:13 +02:00
{
2006-01-23 15:12:03 +01:00
int index = 0 , oldval = - 1 , i ;
2008-10-03 12:16:29 +02:00
int64_t entryPos , curpos ;
2003-09-28 23:09:32 +02:00
2011-03-03 20:11:45 +01:00
int64_t pos = avio_tell ( pb ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " stsc " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; // version & flags
2011-03-03 20:11:45 +01:00
entryPos = avio_tell ( pb ) ;
2011-11-29 04:03:22 +01:00
avio_wb32 ( pb , track - > chunkCount ) ; // entry count
2003-09-28 23:09:32 +02:00
for ( i = 0 ; i < track - > entry ; i + + ) {
2012-01-31 01:14:58 +01:00
if ( oldval ! = track - > cluster [ i ] . samples_in_chunk & & track - > cluster [ i ] . chunkNum )
2003-09-28 23:09:32 +02:00
{
2011-11-29 04:03:22 +01:00
avio_wb32 ( pb , track - > cluster [ i ] . chunkNum ) ; // first chunk
2012-01-30 15:19:15 +01:00
avio_wb32 ( pb , track - > cluster [ i ] . samples_in_chunk ) ; // samples per chunk
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0x1 ) ; // sample description index
2012-01-30 15:19:15 +01:00
oldval = track - > cluster [ i ] . samples_in_chunk ;
2003-09-28 23:09:32 +02:00
index + + ;
2003-08-26 22:23:13 +02:00
}
}
2011-03-03 20:11:45 +01:00
curpos = avio_tell ( pb ) ;
2011-02-28 14:57:54 +01:00
avio_seek ( pb , entryPos , SEEK_SET ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , index ) ; // rewrite size
2011-02-28 14:57:54 +01:00
avio_seek ( pb , curpos , SEEK_SET ) ;
2003-08-26 22:23:13 +02:00
2012-01-30 15:19:15 +01:00
return update_size ( pb , pos ) ;
2003-08-26 22:23:13 +02:00
}
2003-11-03 22:51:07 +01:00
/* Sync sample atom */
2011-02-20 11:04:12 +01:00
static int mov_write_stss_tag ( AVIOContext * pb , MOVTrack * track , uint32_t flag )
2003-08-26 22:23:13 +02:00
{
2008-10-03 12:16:29 +02:00
int64_t curpos , entryPos ;
2006-01-23 15:12:03 +01:00
int i , index = 0 ;
2011-03-03 20:11:45 +01:00
int64_t pos = avio_tell ( pb ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; // size
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , flag = = MOV_SYNC_SAMPLE ? " stss " : " stps " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; // version & flags
2011-03-03 20:11:45 +01:00
entryPos = avio_tell ( pb ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , track - > entry ) ; // entry count
2003-09-28 23:09:32 +02:00
for ( i = 0 ; i < track - > entry ; i + + ) {
2009-05-15 08:11:53 +02:00
if ( track - > cluster [ i ] . flags & flag ) {
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , i + 1 ) ;
2003-09-28 23:09:32 +02:00
index + + ;
}
}
2011-03-03 20:11:45 +01:00
curpos = avio_tell ( pb ) ;
2011-02-28 14:57:54 +01:00
avio_seek ( pb , entryPos , SEEK_SET ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , index ) ; // rewrite size
2011-02-28 14:57:54 +01:00
avio_seek ( pb , curpos , SEEK_SET ) ;
2012-01-30 15:19:15 +01:00
return update_size ( pb , pos ) ;
2003-08-26 22:23:13 +02:00
}
2011-02-20 11:04:12 +01:00
static int mov_write_amr_tag ( AVIOContext * pb , MOVTrack * track )
2003-08-26 22:23:13 +02:00
{
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0x11 ) ; /* size */
2011-02-24 07:36:02 +01:00
if ( track - > mode = = MODE_MOV ) ffio_wfourcc ( pb , " samr " ) ;
else ffio_wfourcc ( pb , " damr " ) ;
ffio_wfourcc ( pb , " FFMP " ) ;
2011-02-21 19:28:17 +01:00
avio_w8 ( pb , 0 ) ; /* decoder version */
2006-05-13 23:00:52 +02:00
2011-02-21 19:28:17 +01:00
avio_wb16 ( pb , 0x81FF ) ; /* Mode set (all modes for AMR_NB) */
avio_w8 ( pb , 0x00 ) ; /* Mode change period (no restriction) */
avio_w8 ( pb , 0x01 ) ; /* Frames per sample */
2006-05-13 23:00:52 +02:00
return 0x11 ;
}
2011-02-20 11:04:12 +01:00
static int mov_write_ac3_tag ( AVIOContext * pb , MOVTrack * track )
2008-09-03 21:05:22 +02:00
{
GetBitContext gbc ;
PutBitContext pbc ;
uint8_t buf [ 3 ] ;
int fscod , bsid , bsmod , acmod , lfeon , frmsizecod ;
2012-01-30 15:19:15 +01:00
if ( track - > vos_len < 7 )
2008-09-03 21:05:22 +02:00
return - 1 ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 11 ) ;
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " dac3 " ) ;
2008-09-03 21:05:22 +02:00
2012-01-30 15:19:15 +01:00
init_get_bits ( & gbc , track - > vos_data + 4 , ( track - > vos_len - 4 ) * 8 ) ;
2008-09-03 21:05:22 +02:00
fscod = get_bits ( & gbc , 2 ) ;
frmsizecod = get_bits ( & gbc , 6 ) ;
bsid = get_bits ( & gbc , 5 ) ;
bsmod = get_bits ( & gbc , 3 ) ;
acmod = get_bits ( & gbc , 3 ) ;
if ( acmod = = 2 ) {
skip_bits ( & gbc , 2 ) ; // dsurmod
} else {
if ( ( acmod & 1 ) & & acmod ! = 1 )
skip_bits ( & gbc , 2 ) ; // cmixlev
if ( acmod & 4 )
skip_bits ( & gbc , 2 ) ; // surmixlev
}
lfeon = get_bits1 ( & gbc ) ;
init_put_bits ( & pbc , buf , sizeof ( buf ) ) ;
put_bits ( & pbc , 2 , fscod ) ;
put_bits ( & pbc , 5 , bsid ) ;
put_bits ( & pbc , 3 , bsmod ) ;
put_bits ( & pbc , 3 , acmod ) ;
put_bits ( & pbc , 1 , lfeon ) ;
put_bits ( & pbc , 5 , frmsizecod > > 1 ) ; // bit_rate_code
put_bits ( & pbc , 5 , 0 ) ; // reserved
flush_put_bits ( & pbc ) ;
2011-02-21 19:28:17 +01:00
avio_write ( pb , buf , sizeof ( buf ) ) ;
2008-09-03 21:05:22 +02:00
return 11 ;
}
2008-04-24 15:59:39 +02:00
/**
* This function writes extradata " as is " .
2011-10-05 14:12:42 +02:00
* Extradata must be formatted like a valid atom ( with size and tag ) .
2008-04-24 15:59:39 +02:00
*/
2011-02-20 11:04:12 +01:00
static int mov_write_extradata_tag ( AVIOContext * pb , MOVTrack * track )
2008-04-24 15:59:39 +02:00
{
2011-02-21 19:28:17 +01:00
avio_write ( pb , track - > enc - > extradata , track - > enc - > extradata_size ) ;
2008-04-24 15:59:39 +02:00
return track - > enc - > extradata_size ;
}
2011-02-20 11:04:12 +01:00
static int mov_write_enda_tag ( AVIOContext * pb )
2006-05-13 22:05:02 +02:00
{
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 10 ) ;
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " enda " ) ;
2011-02-21 19:28:17 +01:00
avio_wb16 ( pb , 1 ) ; /* little endian */
2006-05-13 22:05:02 +02:00
return 10 ;
}
2012-10-02 12:18:04 +02:00
static int mov_write_enda_tag_be ( AVIOContext * pb )
{
avio_wb32 ( pb , 10 ) ;
ffio_wfourcc ( pb , " enda " ) ;
avio_wb16 ( pb , 0 ) ; /* big endian */
return 10 ;
}
2012-01-30 15:19:15 +01:00
static void put_descr ( AVIOContext * pb , int tag , unsigned int size )
2006-05-13 20:01:16 +02:00
{
2011-03-30 23:08:16 +02:00
int i = 3 ;
2011-02-21 19:28:17 +01:00
avio_w8 ( pb , tag ) ;
2006-05-13 20:45:29 +02:00
for ( ; i > 0 ; i - - )
2011-02-21 19:28:17 +01:00
avio_w8 ( pb , ( size > > ( 7 * i ) ) | 0x80 ) ;
avio_w8 ( pb , size & 0x7F ) ;
2006-05-13 20:01:16 +02:00
}
2011-04-17 01:19:10 +02:00
static unsigned compute_avg_bitrate ( MOVTrack * track )
{
uint64_t size = 0 ;
int i ;
2012-02-12 12:05:43 +01:00
if ( ! track - > track_duration )
return 0 ;
2011-04-17 01:19:10 +02:00
for ( i = 0 ; i < track - > entry ; i + + )
size + = track - > cluster [ i ] . size ;
2012-01-31 01:14:58 +01:00
return size * 8 * track - > timescale / track - > track_duration ;
2011-04-17 01:19:10 +02:00
}
2011-02-20 11:04:12 +01:00
static int mov_write_esds_tag ( AVIOContext * pb , MOVTrack * track ) // Basic
2006-05-13 20:01:16 +02:00
{
2011-03-03 20:11:45 +01:00
int64_t pos = avio_tell ( pb ) ;
2012-01-30 15:19:15 +01:00
int decoder_specific_info_len = track - > vos_len ? 5 + track - > vos_len : 0 ;
2011-04-17 01:19:10 +02:00
unsigned avg_bitrate ;
2006-05-13 20:01:16 +02:00
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; // size
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " esds " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; // Version
2006-05-13 20:01:16 +02:00
// ES descriptor
2012-01-30 15:19:15 +01:00
put_descr ( pb , 0x03 , 3 + 5 + 13 + decoder_specific_info_len + 5 + 1 ) ;
avio_wb16 ( pb , track - > track_id ) ;
2011-02-21 19:28:17 +01:00
avio_w8 ( pb , 0x00 ) ; // flags (= no flags)
2006-05-13 20:01:16 +02:00
// DecoderConfig descriptor
2012-01-30 15:19:15 +01:00
put_descr ( pb , 0x04 , 13 + decoder_specific_info_len ) ;
2006-05-13 20:01:16 +02:00
// Object type indication
2012-08-05 11:11:04 +02:00
if ( ( track - > enc - > codec_id = = AV_CODEC_ID_MP2 | |
track - > enc - > codec_id = = AV_CODEC_ID_MP3 ) & &
2008-09-03 21:42:09 +02:00
track - > enc - > sample_rate > 24000 )
2011-02-21 19:28:17 +01:00
avio_w8 ( pb , 0x6B ) ; // 11172-3
2008-09-02 22:48:45 +02:00
else
2011-02-21 19:28:17 +01:00
avio_w8 ( pb , ff_codec_get_tag ( ff_mp4_obj_type , track - > enc - > codec_id ) ) ;
2006-05-13 20:01:16 +02:00
// the following fields is made of 6 bits to identify the streamtype (4 for video, 5 for audio)
// plus 1 bit to indicate upstream and 1 bit set to 1 (reserved)
2010-03-31 01:30:55 +02:00
if ( track - > enc - > codec_type = = AVMEDIA_TYPE_AUDIO )
2011-02-21 19:28:17 +01:00
avio_w8 ( pb , 0x15 ) ; // flags (= Audiostream)
2006-05-13 20:01:16 +02:00
else
2011-02-21 19:28:17 +01:00
avio_w8 ( pb , 0x11 ) ; // flags (= Visualstream)
2006-05-13 20:01:16 +02:00
2011-02-21 19:28:17 +01:00
avio_w8 ( pb , track - > enc - > rc_buffer_size > > ( 3 + 16 ) ) ; // Buffersize DB (24 bits)
avio_wb16 ( pb , ( track - > enc - > rc_buffer_size > > 3 ) & 0xFFFF ) ; // Buffersize DB
2006-05-13 20:01:16 +02:00
2011-04-17 01:19:10 +02:00
avg_bitrate = compute_avg_bitrate ( track ) ;
// maxbitrate (FIXME should be max rate in any 1 sec window)
avio_wb32 ( pb , FFMAX3 ( track - > enc - > bit_rate , track - > enc - > rc_max_rate , avg_bitrate ) ) ;
avio_wb32 ( pb , avg_bitrate ) ;
2006-05-13 20:01:16 +02:00
2012-01-30 15:19:15 +01:00
if ( track - > vos_len ) {
2006-05-13 20:01:16 +02:00
// DecoderSpecific info descriptor
2012-01-30 15:19:15 +01:00
put_descr ( pb , 0x05 , track - > vos_len ) ;
avio_write ( pb , track - > vos_data , track - > vos_len ) ;
2006-05-13 20:01:16 +02:00
}
// SL descriptor
2012-01-30 15:19:15 +01:00
put_descr ( pb , 0x06 , 1 ) ;
2011-02-21 19:28:17 +01:00
avio_w8 ( pb , 0x02 ) ;
2012-01-30 15:19:15 +01:00
return update_size ( pb , pos ) ;
2006-05-13 20:01:16 +02:00
}
2012-08-07 23:57:21 +02:00
static int mov_pcm_le_gt16 ( enum AVCodecID codec_id )
2009-11-29 03:27:08 +01:00
{
2012-08-07 22:45:46 +02:00
return codec_id = = AV_CODEC_ID_PCM_S24LE | |
codec_id = = AV_CODEC_ID_PCM_S32LE | |
codec_id = = AV_CODEC_ID_PCM_F32LE | |
codec_id = = AV_CODEC_ID_PCM_F64LE ;
2009-11-29 03:27:08 +01:00
}
2012-10-02 12:18:04 +02:00
static int mov_pcm_be_gt16 ( enum AVCodecID codec_id )
{
return codec_id = = AV_CODEC_ID_PCM_S24BE | |
codec_id = = AV_CODEC_ID_PCM_S32BE | |
codec_id = = AV_CODEC_ID_PCM_F32BE | |
codec_id = = AV_CODEC_ID_PCM_F64BE ;
}
2011-02-20 11:04:12 +01:00
static int mov_write_ms_tag ( AVIOContext * pb , MOVTrack * track )
2011-01-20 22:14:12 +01:00
{
2011-03-03 20:11:45 +01:00
int64_t pos = avio_tell ( pb ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ;
avio_wl32 ( pb , track - > tag ) ; // store it byteswapped
2011-01-27 17:26:20 +01:00
track - > enc - > codec_tag = av_bswap16 ( track - > tag > > 16 ) ;
2011-01-20 22:14:12 +01:00
ff_put_wav_header ( pb , track - > enc ) ;
2012-01-30 15:19:15 +01:00
return update_size ( pb , pos ) ;
2011-01-20 22:14:12 +01:00
}
2012-01-23 13:58:38 +01:00
static int mov_write_wfex_tag ( AVIOContext * pb , MOVTrack * track )
{
int64_t pos = avio_tell ( pb ) ;
avio_wb32 ( pb , 0 ) ;
ffio_wfourcc ( pb , " wfex " ) ;
ff_put_wav_header ( pb , track - > enc ) ;
return update_size ( pb , pos ) ;
}
2011-12-03 19:32:45 +01:00
static int mov_write_chan_tag ( AVIOContext * pb , MOVTrack * track )
{
uint32_t layout_tag , bitmap ;
int64_t pos = avio_tell ( pb ) ;
layout_tag = ff_mov_get_channel_layout_tag ( track - > enc - > codec_id ,
track - > enc - > channel_layout ,
& bitmap ) ;
if ( ! layout_tag ) {
av_log ( track - > enc , AV_LOG_WARNING , " not writing 'chan' tag due to "
" lack of channel information \n " ) ;
return 0 ;
}
avio_wb32 ( pb , 0 ) ; // Size
ffio_wfourcc ( pb , " chan " ) ; // Type
avio_w8 ( pb , 0 ) ; // Version
avio_wb24 ( pb , 0 ) ; // Flags
avio_wb32 ( pb , layout_tag ) ; // mChannelLayoutTag
avio_wb32 ( pb , bitmap ) ; // mChannelBitmap
avio_wb32 ( pb , 0 ) ; // mNumberChannelDescriptions
2012-01-30 15:19:15 +01:00
return update_size ( pb , pos ) ;
2011-12-03 19:32:45 +01:00
}
2011-02-20 11:04:12 +01:00
static int mov_write_wave_tag ( AVIOContext * pb , MOVTrack * track )
2004-02-14 20:08:09 +01:00
{
2011-03-03 20:11:45 +01:00
int64_t pos = avio_tell ( pb ) ;
2004-02-14 20:08:09 +01:00
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " wave " ) ;
2004-02-14 20:08:09 +01:00
2012-08-07 22:45:46 +02:00
if ( track - > enc - > codec_id ! = AV_CODEC_ID_QDM2 ) {
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 12 ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " frma " ) ;
2011-02-21 19:28:17 +01:00
avio_wl32 ( pb , track - > tag ) ;
2012-08-06 00:37:28 +02:00
}
2004-02-14 20:08:09 +01:00
2012-08-05 11:11:04 +02:00
if ( track - > enc - > codec_id = = AV_CODEC_ID_AAC ) {
2006-06-19 13:28:28 +02:00
/* useless atom needed by mplayer, ipod, not needed by quicktime */
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 12 ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " mp4a " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ;
2006-05-13 22:05:02 +02:00
mov_write_esds_tag ( pb , track ) ;
2012-10-02 12:18:04 +02:00
} else if ( mov_pcm_le_gt16 ( track - > enc - > codec_id ) ) {
mov_write_enda_tag ( pb ) ;
} else if ( mov_pcm_be_gt16 ( track - > enc - > codec_id ) ) {
mov_write_enda_tag_be ( pb ) ;
2012-08-05 11:11:04 +02:00
} else if ( track - > enc - > codec_id = = AV_CODEC_ID_AMR_NB ) {
2006-07-06 16:38:50 +02:00
mov_write_amr_tag ( pb , track ) ;
2012-08-05 11:11:04 +02:00
} else if ( track - > enc - > codec_id = = AV_CODEC_ID_AC3 ) {
2008-09-03 21:05:22 +02:00
mov_write_ac3_tag ( pb , track ) ;
2012-08-07 22:45:46 +02:00
} else if ( track - > enc - > codec_id = = AV_CODEC_ID_ALAC | |
track - > enc - > codec_id = = AV_CODEC_ID_QDM2 ) {
2008-04-24 15:59:39 +02:00
mov_write_extradata_tag ( pb , track ) ;
2012-08-05 11:11:04 +02:00
} else if ( track - > enc - > codec_id = = AV_CODEC_ID_ADPCM_MS | |
track - > enc - > codec_id = = AV_CODEC_ID_ADPCM_IMA_WAV ) {
2011-01-20 22:14:12 +01:00
mov_write_ms_tag ( pb , track ) ;
2006-05-13 22:05:02 +02:00
}
2004-02-14 20:08:09 +01:00
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 8 ) ; /* size */
avio_wb32 ( pb , 0 ) ; /* null tag */
2004-02-14 20:08:09 +01:00
2012-01-30 15:19:15 +01:00
return update_size ( pb , pos ) ;
2004-02-14 20:08:09 +01:00
}
2012-01-21 01:16:34 +01:00
static int mov_write_dvc1_structs ( MOVTrack * track , uint8_t * buf )
{
uint8_t * unescaped ;
const uint8_t * start , * next , * end = track - > vos_data + track - > vos_len ;
int unescaped_size , seq_found = 0 ;
int level = 0 , interlace = 0 ;
int packet_seq = track - > vc1_info . packet_seq ;
int packet_entry = track - > vc1_info . packet_entry ;
int slices = track - > vc1_info . slices ;
PutBitContext pbc ;
if ( track - > start_dts = = AV_NOPTS_VALUE ) {
/* No packets written yet, vc1_info isn't authoritative yet. */
/* Assume inline sequence and entry headers. This will be
* overwritten at the end if the file is seekable . */
packet_seq = packet_entry = 1 ;
}
unescaped = av_mallocz ( track - > vos_len + FF_INPUT_BUFFER_PADDING_SIZE ) ;
if ( ! unescaped )
return AVERROR ( ENOMEM ) ;
start = find_next_marker ( track - > vos_data , end ) ;
for ( next = start ; next < end ; start = next ) {
GetBitContext gb ;
int size ;
next = find_next_marker ( start + 4 , end ) ;
size = next - start - 4 ;
if ( size < = 0 )
continue ;
unescaped_size = vc1_unescape_buffer ( start + 4 , size , unescaped ) ;
init_get_bits ( & gb , unescaped , 8 * unescaped_size ) ;
if ( AV_RB32 ( start ) = = VC1_CODE_SEQHDR ) {
int profile = get_bits ( & gb , 2 ) ;
if ( profile ! = PROFILE_ADVANCED ) {
av_free ( unescaped ) ;
return AVERROR ( ENOSYS ) ;
}
seq_found = 1 ;
level = get_bits ( & gb , 3 ) ;
/* chromaformat, frmrtq_postproc, bitrtq_postproc, postprocflag,
* width , height */
skip_bits_long ( & gb , 2 + 3 + 5 + 1 + 2 * 12 ) ;
skip_bits ( & gb , 1 ) ; /* broadcast */
interlace = get_bits1 ( & gb ) ;
skip_bits ( & gb , 4 ) ; /* tfcntrflag, finterpflag, reserved, psf */
}
}
if ( ! seq_found ) {
av_free ( unescaped ) ;
return AVERROR ( ENOSYS ) ;
}
init_put_bits ( & pbc , buf , 7 ) ;
/* VC1DecSpecStruc */
put_bits ( & pbc , 4 , 12 ) ; /* profile - advanced */
put_bits ( & pbc , 3 , level ) ;
put_bits ( & pbc , 1 , 0 ) ; /* reserved */
/* VC1AdvDecSpecStruc */
put_bits ( & pbc , 3 , level ) ;
put_bits ( & pbc , 1 , 0 ) ; /* cbr */
put_bits ( & pbc , 6 , 0 ) ; /* reserved */
put_bits ( & pbc , 1 , ! interlace ) ; /* no interlace */
put_bits ( & pbc , 1 , ! packet_seq ) ; /* no multiple seq */
put_bits ( & pbc , 1 , ! packet_entry ) ; /* no multiple entry */
put_bits ( & pbc , 1 , ! slices ) ; /* no slice code */
put_bits ( & pbc , 1 , 0 ) ; /* no bframe */
put_bits ( & pbc , 1 , 0 ) ; /* reserved */
put_bits32 ( & pbc , track - > enc - > time_base . den ) ; /* framerate */
flush_put_bits ( & pbc ) ;
av_free ( unescaped ) ;
return 0 ;
}
static int mov_write_dvc1_tag ( AVIOContext * pb , MOVTrack * track )
{
uint8_t buf [ 7 ] = { 0 } ;
int ret ;
if ( ( ret = mov_write_dvc1_structs ( track , buf ) ) < 0 )
return ret ;
avio_wb32 ( pb , track - > vos_len + 8 + sizeof ( buf ) ) ;
ffio_wfourcc ( pb , " dvc1 " ) ;
track - > vc1_info . struct_offset = avio_tell ( pb ) ;
avio_write ( pb , buf , sizeof ( buf ) ) ;
avio_write ( pb , track - > vos_data , track - > vos_len ) ;
return 0 ;
}
2011-02-20 11:04:12 +01:00
static int mov_write_glbl_tag ( AVIOContext * pb , MOVTrack * track )
2007-12-19 17:00:08 +01:00
{
2012-01-30 15:19:15 +01:00
avio_wb32 ( pb , track - > vos_len + 8 ) ;
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " glbl " ) ;
2012-01-30 15:19:15 +01:00
avio_write ( pb , track - > vos_data , track - > vos_len ) ;
return 8 + track - > vos_len ;
2007-12-19 17:00:08 +01:00
}
2009-11-29 03:03:24 +01:00
/**
* Compute flags for ' lpcm ' tag .
* See CoreAudioTypes and AudioStreamBasicDescription at Apple .
*/
2012-08-05 11:11:04 +02:00
static int mov_get_lpcm_flags ( enum AVCodecID codec_id )
2009-11-29 03:03:24 +01:00
{
switch ( codec_id ) {
2012-08-05 11:11:04 +02:00
case AV_CODEC_ID_PCM_F32BE :
case AV_CODEC_ID_PCM_F64BE :
2009-11-29 03:03:24 +01:00
return 11 ;
2012-08-05 11:11:04 +02:00
case AV_CODEC_ID_PCM_F32LE :
case AV_CODEC_ID_PCM_F64LE :
2009-11-29 03:03:24 +01:00
return 9 ;
2012-08-05 11:11:04 +02:00
case AV_CODEC_ID_PCM_U8 :
2009-11-29 03:03:24 +01:00
return 10 ;
2012-08-05 11:11:04 +02:00
case AV_CODEC_ID_PCM_S16BE :
case AV_CODEC_ID_PCM_S24BE :
case AV_CODEC_ID_PCM_S32BE :
2009-11-29 03:03:24 +01:00
return 14 ;
2012-08-05 11:11:04 +02:00
case AV_CODEC_ID_PCM_S8 :
case AV_CODEC_ID_PCM_S16LE :
case AV_CODEC_ID_PCM_S24LE :
case AV_CODEC_ID_PCM_S32LE :
2009-11-29 03:03:24 +01:00
return 12 ;
default :
return 0 ;
}
}
2012-02-26 23:17:13 +01:00
static int get_cluster_duration ( MOVTrack * track , int cluster_idx )
{
int64_t next_dts ;
if ( cluster_idx > = track - > entry )
return 0 ;
if ( cluster_idx + 1 = = track - > entry )
next_dts = track - > track_duration + track - > start_dts ;
else
next_dts = track - > cluster [ cluster_idx + 1 ] . dts ;
return next_dts - track - > cluster [ cluster_idx ] . dts ;
}
2012-02-26 22:25:46 +01:00
static int get_samples_per_packet ( MOVTrack * track )
{
int i , first_duration ;
2012-02-28 03:38:58 +01:00
// return track->enc->frame_size;
2012-02-26 22:25:46 +01:00
/* use 1 for raw PCM */
if ( ! track - > audio_vbr )
return 1 ;
/* check to see if duration is constant for all clusters */
if ( ! track - > entry )
return 0 ;
first_duration = get_cluster_duration ( track , 0 ) ;
for ( i = 1 ; i < track - > entry ; i + + ) {
if ( get_cluster_duration ( track , i ) ! = first_duration )
return 0 ;
}
return first_duration ;
}
2011-02-20 11:04:12 +01:00
static int mov_write_audio_tag ( AVIOContext * pb , MOVTrack * track )
2003-08-26 22:23:13 +02:00
{
2011-03-03 20:11:45 +01:00
int64_t pos = avio_tell ( pb ) ;
2009-11-29 03:03:24 +01:00
int version = 0 ;
uint32_t tag = track - > tag ;
if ( track - > mode = = MODE_MOV ) {
2012-01-22 23:23:23 +01:00
if ( track - > timescale > UINT16_MAX ) {
if ( mov_get_lpcm_flags ( track - > enc - > codec_id ) )
tag = AV_RL32 ( " lpcm " ) ;
version = 2 ;
} else if ( track - > audio_vbr | | mov_pcm_le_gt16 ( track - > enc - > codec_id ) | |
2012-10-02 12:18:04 +02:00
mov_pcm_be_gt16 ( track - > enc - > codec_id ) | |
2012-08-07 22:45:46 +02:00
track - > enc - > codec_id = = AV_CODEC_ID_ADPCM_MS | |
track - > enc - > codec_id = = AV_CODEC_ID_ADPCM_IMA_WAV | |
track - > enc - > codec_id = = AV_CODEC_ID_QDM2 ) {
2012-01-22 23:23:23 +01:00
version = 1 ;
}
2009-11-29 03:03:24 +01:00
}
2005-12-17 19:14:38 +01:00
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* size */
avio_wl32 ( pb , tag ) ; // store it byteswapped
avio_wb32 ( pb , 0 ) ; /* Reserved */
avio_wb16 ( pb , 0 ) ; /* Reserved */
avio_wb16 ( pb , 1 ) ; /* Data-reference index, XXX == 1 */
2004-02-14 20:08:09 +01:00
2003-11-03 22:51:07 +01:00
/* SoundDescription */
2011-02-21 19:28:17 +01:00
avio_wb16 ( pb , version ) ; /* Version */
avio_wb16 ( pb , 0 ) ; /* Revision level */
avio_wb32 ( pb , 0 ) ; /* Reserved */
2003-08-26 22:23:13 +02:00
2009-11-29 03:03:24 +01:00
if ( version = = 2 ) {
2011-02-21 19:28:17 +01:00
avio_wb16 ( pb , 3 ) ;
avio_wb16 ( pb , 16 ) ;
avio_wb16 ( pb , 0xfffe ) ;
avio_wb16 ( pb , 0 ) ;
avio_wb32 ( pb , 0x00010000 ) ;
avio_wb32 ( pb , 72 ) ;
2012-01-09 10:05:33 +01:00
avio_wb64 ( pb , av_double2int ( track - > enc - > sample_rate ) ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , track - > enc - > channels ) ;
avio_wb32 ( pb , 0x7F000000 ) ;
avio_wb32 ( pb , av_get_bits_per_sample ( track - > enc - > codec_id ) ) ;
avio_wb32 ( pb , mov_get_lpcm_flags ( track - > enc - > codec_id ) ) ;
2012-01-30 15:19:15 +01:00
avio_wb32 ( pb , track - > sample_size ) ;
2012-02-26 22:25:46 +01:00
avio_wb32 ( pb , get_samples_per_packet ( track ) ) ;
2009-11-29 03:03:24 +01:00
} else {
2012-01-22 23:23:23 +01:00
if ( track - > mode = = MODE_MOV ) {
avio_wb16 ( pb , track - > enc - > channels ) ;
2012-08-07 22:45:46 +02:00
if ( track - > enc - > codec_id = = AV_CODEC_ID_PCM_U8 | |
track - > enc - > codec_id = = AV_CODEC_ID_PCM_S8 )
2012-01-22 23:23:23 +01:00
avio_wb16 ( pb , 8 ) ; /* bits per sample */
else
avio_wb16 ( pb , 16 ) ;
avio_wb16 ( pb , track - > audio_vbr ? - 2 : 0 ) ; /* compression ID */
} else { /* reserved for mp4/3gp */
avio_wb16 ( pb , 2 ) ;
avio_wb16 ( pb , 16 ) ;
avio_wb16 ( pb , 0 ) ;
}
2004-07-28 11:40:59 +02:00
2011-02-21 19:28:17 +01:00
avio_wb16 ( pb , 0 ) ; /* packet size (= 0) */
2012-04-20 22:21:28 +02:00
avio_wb16 ( pb , track - > enc - > sample_rate < = UINT16_MAX ?
track - > enc - > sample_rate : 0 ) ;
2011-02-21 19:28:17 +01:00
avio_wb16 ( pb , 0 ) ; /* Reserved */
2009-11-29 03:03:24 +01:00
}
2003-08-26 22:23:13 +02:00
2012-01-22 23:23:23 +01:00
if ( version = = 1 ) { /* SoundDescription V1 extended info */
2012-10-05 10:33:12 +02:00
if ( mov_pcm_le_gt16 ( track - > enc - > codec_id ) | |
mov_pcm_be_gt16 ( track - > enc - > codec_id ) )
avio_wb32 ( pb , 1 ) ; /* must be 1 for uncompressed formats */
else
avio_wb32 ( pb , track - > enc - > frame_size ) ; /* Samples per packet */
2012-01-31 01:14:58 +01:00
avio_wb32 ( pb , track - > sample_size / track - > enc - > channels ) ; /* Bytes per packet */
avio_wb32 ( pb , track - > sample_size ) ; /* Bytes per frame */
2012-01-22 23:23:23 +01:00
avio_wb32 ( pb , 2 ) ; /* Bytes per sample */
}
2006-05-14 00:25:17 +02:00
if ( track - > mode = = MODE_MOV & &
2012-08-05 11:11:04 +02:00
( track - > enc - > codec_id = = AV_CODEC_ID_AAC | |
track - > enc - > codec_id = = AV_CODEC_ID_AC3 | |
track - > enc - > codec_id = = AV_CODEC_ID_AMR_NB | |
track - > enc - > codec_id = = AV_CODEC_ID_ALAC | |
track - > enc - > codec_id = = AV_CODEC_ID_ADPCM_MS | |
2012-08-07 22:45:46 +02:00
track - > enc - > codec_id = = AV_CODEC_ID_ADPCM_IMA_WAV | |
track - > enc - > codec_id = = AV_CODEC_ID_QDM2 | |
2012-10-02 12:18:04 +02:00
( mov_pcm_le_gt16 ( track - > enc - > codec_id ) & & version = = 1 ) | |
( mov_pcm_be_gt16 ( track - > enc - > codec_id ) & & version = = 1 ) ) )
2006-05-13 22:05:02 +02:00
mov_write_wave_tag ( pb , track ) ;
2008-01-28 14:44:27 +01:00
else if ( track - > tag = = MKTAG ( ' m ' , ' p ' , ' 4 ' , ' a ' ) )
2006-05-13 23:00:52 +02:00
mov_write_esds_tag ( pb , track ) ;
2012-08-05 11:11:04 +02:00
else if ( track - > enc - > codec_id = = AV_CODEC_ID_AMR_NB )
2006-07-06 16:38:50 +02:00
mov_write_amr_tag ( pb , track ) ;
2012-08-05 11:11:04 +02:00
else if ( track - > enc - > codec_id = = AV_CODEC_ID_AC3 )
2008-09-04 20:25:55 +02:00
mov_write_ac3_tag ( pb , track ) ;
2012-08-05 11:11:04 +02:00
else if ( track - > enc - > codec_id = = AV_CODEC_ID_ALAC )
2008-06-11 10:17:38 +02:00
mov_write_extradata_tag ( pb , track ) ;
2012-08-05 11:11:04 +02:00
else if ( track - > enc - > codec_id = = AV_CODEC_ID_WMAPRO )
2012-01-23 13:58:38 +01:00
mov_write_wfex_tag ( pb , track ) ;
2012-01-30 15:19:15 +01:00
else if ( track - > vos_len > 0 )
2007-12-19 17:00:08 +01:00
mov_write_glbl_tag ( pb , track ) ;
2006-05-13 23:00:52 +02:00
2012-05-31 02:51:12 +02:00
if ( track - > mode = = MODE_MOV & & track - > enc - > codec_type = = AVMEDIA_TYPE_AUDIO )
mov_write_chan_tag ( pb , track ) ;
2012-01-30 15:19:15 +01:00
return update_size ( pb , pos ) ;
2003-08-26 22:23:13 +02:00
}
2011-02-20 11:04:12 +01:00
static int mov_write_d263_tag ( AVIOContext * pb )
2003-08-26 22:23:13 +02:00
{
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0xf ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " d263 " ) ;
ffio_wfourcc ( pb , " FFMP " ) ;
2011-02-21 19:28:17 +01:00
avio_w8 ( pb , 0 ) ; /* decoder version */
2006-08-07 17:04:15 +02:00
/* FIXME use AVCodecContext level/profile, when encoder will set values */
2011-02-21 19:28:17 +01:00
avio_w8 ( pb , 0xa ) ; /* level */
avio_w8 ( pb , 0 ) ; /* profile */
2003-08-26 22:23:13 +02:00
return 0xf ;
}
2011-02-20 11:04:12 +01:00
static int mov_write_avcc_tag ( AVIOContext * pb , MOVTrack * track )
2008-01-11 02:04:01 +01:00
{
2011-03-03 20:11:45 +01:00
int64_t pos = avio_tell ( pb ) ;
2008-01-11 02:04:01 +01:00
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ;
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " avcC " ) ;
2012-01-30 15:19:15 +01:00
ff_isom_write_avcc ( pb , track - > vos_data , track - > vos_len ) ;
return update_size ( pb , pos ) ;
2006-03-11 19:18:17 +01:00
}
2007-10-08 13:27:18 +02:00
/* also used by all avid codecs (dv, imx, meridien) and their variants */
2011-02-20 11:04:12 +01:00
static int mov_write_avid_tag ( AVIOContext * pb , MOVTrack * track )
2007-10-08 13:27:18 +02:00
{
int i ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 24 ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " ACLR " ) ;
ffio_wfourcc ( pb , " ACLR " ) ;
ffio_wfourcc ( pb , " 0001 " ) ;
2011-03-23 18:22:05 +01:00
avio_wb32 ( pb , 2 ) ; /* yuv range: full 1 / normal 2 */
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* unknown */
2007-10-08 13:27:18 +02:00
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 24 ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " APRG " ) ;
ffio_wfourcc ( pb , " APRG " ) ;
ffio_wfourcc ( pb , " 0001 " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 1 ) ; /* unknown */
avio_wb32 ( pb , 0 ) ; /* unknown */
2007-10-08 13:27:18 +02:00
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 120 ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " ARES " ) ;
ffio_wfourcc ( pb , " ARES " ) ;
ffio_wfourcc ( pb , " 0001 " ) ;
2012-01-30 15:19:15 +01:00
avio_wb32 ( pb , AV_RB32 ( track - > vos_data + 0x28 ) ) ; /* dnxhd cid, some id ? */
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , track - > enc - > width ) ;
2007-10-08 13:27:18 +02:00
/* values below are based on samples created with quicktime and avid codecs */
2012-01-30 15:19:15 +01:00
if ( track - > vos_data [ 5 ] & 2 ) { // interlaced
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , track - > enc - > height / 2 ) ;
avio_wb32 ( pb , 2 ) ; /* unknown */
avio_wb32 ( pb , 0 ) ; /* unknown */
avio_wb32 ( pb , 4 ) ; /* unknown */
2007-10-08 13:27:18 +02:00
} else {
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , track - > enc - > height ) ;
avio_wb32 ( pb , 1 ) ; /* unknown */
avio_wb32 ( pb , 0 ) ; /* unknown */
2007-12-03 11:44:25 +01:00
if ( track - > enc - > height = = 1080 )
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 5 ) ; /* unknown */
2007-12-03 11:44:25 +01:00
else
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 6 ) ; /* unknown */
2007-10-08 13:27:18 +02:00
}
/* padding */
for ( i = 0 ; i < 10 ; i + + )
2011-02-21 19:28:17 +01:00
avio_wb64 ( pb , 0 ) ;
2007-10-08 13:27:18 +02:00
/* extra padding for stsd needed */
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ;
2007-10-08 13:27:18 +02:00
return 0 ;
}
2009-04-08 00:19:58 +02:00
static int mp4_get_codec_tag ( AVFormatContext * s , MOVTrack * track )
2006-03-08 01:39:23 +01:00
{
2006-05-13 20:01:16 +02:00
int tag = track - > enc - > codec_tag ;
2009-04-08 00:21:43 +02:00
2009-06-23 01:09:34 +02:00
if ( ! ff_codec_get_tag ( ff_mp4_obj_type , track - > enc - > codec_id ) )
2009-04-08 00:21:43 +02:00
return 0 ;
2012-08-05 11:11:04 +02:00
if ( track - > enc - > codec_id = = AV_CODEC_ID_H264 ) tag = MKTAG ( ' a ' , ' v ' , ' c ' , ' 1 ' ) ;
else if ( track - > enc - > codec_id = = AV_CODEC_ID_AC3 ) tag = MKTAG ( ' a ' , ' c ' , ' - ' , ' 3 ' ) ;
else if ( track - > enc - > codec_id = = AV_CODEC_ID_DIRAC ) tag = MKTAG ( ' d ' , ' r ' , ' a ' , ' c ' ) ;
else if ( track - > enc - > codec_id = = AV_CODEC_ID_MOV_TEXT ) tag = MKTAG ( ' t ' , ' x ' , ' 3 ' , ' g ' ) ;
else if ( track - > enc - > codec_id = = AV_CODEC_ID_VC1 ) tag = MKTAG ( ' v ' , ' c ' , ' - ' , ' 1 ' ) ;
2010-03-31 01:30:55 +02:00
else if ( track - > enc - > codec_type = = AVMEDIA_TYPE_VIDEO ) tag = MKTAG ( ' m ' , ' p ' , ' 4 ' , ' v ' ) ;
else if ( track - > enc - > codec_type = = AVMEDIA_TYPE_AUDIO ) tag = MKTAG ( ' m ' , ' p ' , ' 4 ' , ' a ' ) ;
2009-04-08 00:19:58 +02:00
return tag ;
}
2009-04-08 00:34:05 +02:00
static const AVCodecTag codec_ipod_tags [ ] = {
2012-08-05 11:11:04 +02:00
{ AV_CODEC_ID_H264 , MKTAG ( ' a ' , ' v ' , ' c ' , ' 1 ' ) } ,
{ AV_CODEC_ID_MPEG4 , MKTAG ( ' m ' , ' p ' , ' 4 ' , ' v ' ) } ,
{ AV_CODEC_ID_AAC , MKTAG ( ' m ' , ' p ' , ' 4 ' , ' a ' ) } ,
{ AV_CODEC_ID_ALAC , MKTAG ( ' a ' , ' l ' , ' a ' , ' c ' ) } ,
{ AV_CODEC_ID_AC3 , MKTAG ( ' a ' , ' c ' , ' - ' , ' 3 ' ) } ,
{ AV_CODEC_ID_MOV_TEXT , MKTAG ( ' t ' , ' x ' , ' 3 ' , ' g ' ) } ,
{ AV_CODEC_ID_MOV_TEXT , MKTAG ( ' t ' , ' e ' , ' x ' , ' t ' ) } ,
{ AV_CODEC_ID_NONE , 0 } ,
2009-04-08 00:34:05 +02:00
} ;
2009-04-08 00:19:58 +02:00
static int ipod_get_codec_tag ( AVFormatContext * s , MOVTrack * track )
{
int tag = track - > enc - > codec_tag ;
2009-04-08 00:26:47 +02:00
// keep original tag for subs, ipod supports both formats
2010-03-31 01:30:55 +02:00
if ( ! ( track - > enc - > codec_type = = AVMEDIA_TYPE_SUBTITLE & &
2009-04-08 00:21:43 +02:00
( tag = = MKTAG ( ' t ' , ' x ' , ' 3 ' , ' g ' ) | |
2009-04-08 00:28:39 +02:00
tag = = MKTAG ( ' t ' , ' e ' , ' x ' , ' t ' ) ) ) )
2009-06-23 01:09:34 +02:00
tag = ff_codec_get_tag ( codec_ipod_tags , track - > enc - > codec_id ) ;
2009-04-08 00:31:17 +02:00
2010-01-17 16:57:51 +01:00
if ( ! av_match_ext ( s - > filename , " m4a " ) & & ! av_match_ext ( s - > filename , " m4v " ) )
2009-04-08 00:21:43 +02:00
av_log ( s , AV_LOG_WARNING , " Warning, extension is not .m4a nor .m4v "
" Quicktime/Ipod might not play the file \n " ) ;
2009-04-08 00:19:58 +02:00
return tag ;
}
static int mov_get_dv_codec_tag ( AVFormatContext * s , MOVTrack * track )
{
int tag ;
2012-10-21 17:35:54 +02:00
if ( track - > enc - > width = = 720 ) { /* SD */
if ( track - > enc - > height = = 480 ) { /* NTSC */
2012-10-06 12:10:34 +02:00
if ( track - > enc - > pix_fmt = = AV_PIX_FMT_YUV422P ) tag = MKTAG ( ' d ' , ' v ' , ' 5 ' , ' n ' ) ;
2011-03-02 00:54:29 +01:00
else tag = MKTAG ( ' d ' , ' v ' , ' c ' , ' ' ) ;
2012-10-21 17:35:54 +02:00
} else if ( track - > enc - > pix_fmt = = AV_PIX_FMT_YUV422P ) tag = MKTAG ( ' d ' , ' v ' , ' 5 ' , ' p ' ) ;
2012-10-06 12:10:34 +02:00
else if ( track - > enc - > pix_fmt = = AV_PIX_FMT_YUV420P ) tag = MKTAG ( ' d ' , ' v ' , ' c ' , ' p ' ) ;
2011-03-02 00:54:29 +01:00
else tag = MKTAG ( ' d ' , ' v ' , ' p ' , ' p ' ) ;
2012-10-21 17:35:54 +02:00
} else if ( track - > enc - > height = = 720 ) { /* HD 720 line */
2011-03-02 00:54:29 +01:00
if ( track - > enc - > time_base . den = = 50 ) tag = MKTAG ( ' d ' , ' v ' , ' h ' , ' q ' ) ;
else tag = MKTAG ( ' d ' , ' v ' , ' h ' , ' p ' ) ;
2012-10-21 17:35:54 +02:00
} else if ( track - > enc - > height = = 1080 ) { /* HD 1080 line */
2011-03-02 00:54:29 +01:00
if ( track - > enc - > time_base . den = = 25 ) tag = MKTAG ( ' d ' , ' v ' , ' h ' , ' 5 ' ) ;
else tag = MKTAG ( ' d ' , ' v ' , ' h ' , ' 6 ' ) ;
2012-10-21 17:35:54 +02:00
} else {
2011-03-02 00:54:29 +01:00
av_log ( s , AV_LOG_ERROR , " unsupported height for dv codec \n " ) ;
return 0 ;
}
2009-04-08 00:19:58 +02:00
return tag ;
}
2009-04-08 00:34:05 +02:00
static const struct {
2012-10-06 12:10:34 +02:00
enum AVPixelFormat pix_fmt ;
2009-04-08 00:34:05 +02:00
uint32_t tag ;
unsigned bps ;
} mov_pix_fmt_tags [ ] = {
2012-10-08 20:54:00 +02:00
{ AV_PIX_FMT_YUYV422 , MKTAG ( ' y ' , ' u ' , ' v ' , ' 2 ' ) , 0 } ,
2012-10-06 12:10:34 +02:00
{ AV_PIX_FMT_YUYV422 , MKTAG ( ' y ' , ' u ' , ' v ' , ' s ' ) , 0 } ,
{ AV_PIX_FMT_UYVY422 , MKTAG ( ' 2 ' , ' v ' , ' u ' , ' y ' ) , 0 } ,
{ AV_PIX_FMT_RGB555BE , MKTAG ( ' r ' , ' a ' , ' w ' , ' ' ) , 16 } ,
{ AV_PIX_FMT_RGB555LE , MKTAG ( ' L ' , ' 5 ' , ' 5 ' , ' 5 ' ) , 16 } ,
{ AV_PIX_FMT_RGB565LE , MKTAG ( ' L ' , ' 5 ' , ' 6 ' , ' 5 ' ) , 16 } ,
{ AV_PIX_FMT_RGB565BE , MKTAG ( ' B ' , ' 5 ' , ' 6 ' , ' 5 ' ) , 16 } ,
{ AV_PIX_FMT_GRAY16BE , MKTAG ( ' b ' , ' 1 ' , ' 6 ' , ' g ' ) , 16 } ,
{ AV_PIX_FMT_RGB24 , MKTAG ( ' r ' , ' a ' , ' w ' , ' ' ) , 24 } ,
{ AV_PIX_FMT_BGR24 , MKTAG ( ' 2 ' , ' 4 ' , ' B ' , ' G ' ) , 24 } ,
{ AV_PIX_FMT_ARGB , MKTAG ( ' r ' , ' a ' , ' w ' , ' ' ) , 32 } ,
{ AV_PIX_FMT_BGRA , MKTAG ( ' B ' , ' G ' , ' R ' , ' A ' ) , 32 } ,
{ AV_PIX_FMT_RGBA , MKTAG ( ' R ' , ' G ' , ' B ' , ' A ' ) , 32 } ,
{ AV_PIX_FMT_ABGR , MKTAG ( ' A ' , ' B ' , ' G ' , ' R ' ) , 32 } ,
{ AV_PIX_FMT_RGB48BE , MKTAG ( ' b ' , ' 4 ' , ' 8 ' , ' r ' ) , 48 } ,
2009-04-08 00:34:05 +02:00
} ;
2009-04-08 00:19:58 +02:00
static int mov_get_rawvideo_codec_tag ( AVFormatContext * s , MOVTrack * track )
{
int tag = track - > enc - > codec_tag ;
2009-04-08 00:21:43 +02:00
int i ;
for ( i = 0 ; i < FF_ARRAY_ELEMS ( mov_pix_fmt_tags ) ; i + + ) {
2012-10-06 20:19:05 +02:00
if ( track - > enc - > pix_fmt = = mov_pix_fmt_tags [ i ] . pix_fmt ) {
2009-04-08 00:21:43 +02:00
tag = mov_pix_fmt_tags [ i ] . tag ;
track - > enc - > bits_per_coded_sample = mov_pix_fmt_tags [ i ] . bps ;
2012-10-06 20:19:05 +02:00
if ( track - > enc - > codec_tag = = mov_pix_fmt_tags [ i ] . tag )
break ;
2009-04-08 00:21:43 +02:00
}
}
2009-04-08 00:19:58 +02:00
return tag ;
}
static int mov_get_codec_tag ( AVFormatContext * s , MOVTrack * track )
{
int tag = track - > enc - > codec_tag ;
if ( ! tag | | ( track - > enc - > strict_std_compliance > = FF_COMPLIANCE_NORMAL & &
2012-08-05 11:11:04 +02:00
( track - > enc - > codec_id = = AV_CODEC_ID_DVVIDEO | |
track - > enc - > codec_id = = AV_CODEC_ID_RAWVIDEO | |
track - > enc - > codec_id = = AV_CODEC_ID_H263 | |
2009-04-08 00:19:58 +02:00
av_get_bits_per_sample ( track - > enc - > codec_id ) ) ) ) { // pcm audio
2012-08-05 11:11:04 +02:00
if ( track - > enc - > codec_id = = AV_CODEC_ID_DVVIDEO )
2009-04-08 00:19:58 +02:00
tag = mov_get_dv_codec_tag ( s , track ) ;
2012-08-05 11:11:04 +02:00
else if ( track - > enc - > codec_id = = AV_CODEC_ID_RAWVIDEO )
2009-04-08 00:19:58 +02:00
tag = mov_get_rawvideo_codec_tag ( s , track ) ;
2010-03-31 01:30:55 +02:00
else if ( track - > enc - > codec_type = = AVMEDIA_TYPE_VIDEO ) {
2012-02-15 10:28:39 +01:00
tag = ff_codec_get_tag ( ff_codec_movvideo_tags , track - > enc - > codec_id ) ;
2009-04-08 00:31:53 +02:00
if ( ! tag ) { // if no mac fcc found, try with Microsoft tags
2009-06-23 01:09:34 +02:00
tag = ff_codec_get_tag ( ff_codec_bmp_tags , track - > enc - > codec_id ) ;
2009-04-08 00:31:53 +02:00
if ( tag )
2011-08-11 16:33:03 +02:00
av_log ( s , AV_LOG_WARNING , " Using MS style video codec tag, "
2009-04-08 00:31:53 +02:00
" the file may be unplayable! \n " ) ;
}
2010-03-31 01:30:55 +02:00
} else if ( track - > enc - > codec_type = = AVMEDIA_TYPE_AUDIO ) {
2012-02-15 10:28:39 +01:00
tag = ff_codec_get_tag ( ff_codec_movaudio_tags , track - > enc - > codec_id ) ;
2009-04-08 00:31:53 +02:00
if ( ! tag ) { // if no mac fcc found, try with Microsoft tags
2009-06-23 01:09:34 +02:00
int ms_tag = ff_codec_get_tag ( ff_codec_wav_tags , track - > enc - > codec_id ) ;
2009-04-08 00:31:53 +02:00
if ( ms_tag ) {
tag = MKTAG ( ' m ' , ' s ' , ( ( ms_tag > > 8 ) & 0xff ) , ( ms_tag & 0xff ) ) ;
2011-08-11 16:33:03 +02:00
av_log ( s , AV_LOG_WARNING , " Using MS style audio codec tag, "
2009-04-08 00:31:53 +02:00
" the file may be unplayable! \n " ) ;
2008-01-28 16:23:37 +01:00
}
2009-04-08 00:31:53 +02:00
}
2010-03-31 01:30:55 +02:00
} else if ( track - > enc - > codec_type = = AVMEDIA_TYPE_SUBTITLE )
2009-06-23 01:09:34 +02:00
tag = ff_codec_get_tag ( ff_codec_movsubtitle_tags , track - > enc - > codec_id ) ;
2008-01-28 16:22:07 +01:00
}
2009-04-08 00:21:43 +02:00
2006-03-08 01:39:23 +01:00
return tag ;
}
2009-04-08 00:34:05 +02:00
static const AVCodecTag codec_3gp_tags [ ] = {
2012-08-05 11:11:04 +02:00
{ AV_CODEC_ID_H263 , MKTAG ( ' s ' , ' 2 ' , ' 6 ' , ' 3 ' ) } ,
{ AV_CODEC_ID_H264 , MKTAG ( ' a ' , ' v ' , ' c ' , ' 1 ' ) } ,
{ AV_CODEC_ID_MPEG4 , MKTAG ( ' m ' , ' p ' , ' 4 ' , ' v ' ) } ,
{ AV_CODEC_ID_AAC , MKTAG ( ' m ' , ' p ' , ' 4 ' , ' a ' ) } ,
{ AV_CODEC_ID_AMR_NB , MKTAG ( ' s ' , ' a ' , ' m ' , ' r ' ) } ,
{ AV_CODEC_ID_AMR_WB , MKTAG ( ' s ' , ' a ' , ' w ' , ' b ' ) } ,
{ AV_CODEC_ID_MOV_TEXT , MKTAG ( ' t ' , ' x ' , ' 3 ' , ' g ' ) } ,
{ AV_CODEC_ID_NONE , 0 } ,
2009-04-08 00:34:05 +02:00
} ;
2012-09-17 16:16:16 +02:00
static const AVCodecTag codec_f4v_tags [ ] = { // XXX: add GIF/PNG/JPEG?
{ AV_CODEC_ID_MP3 , MKTAG ( ' . ' , ' m ' , ' p ' , ' 3 ' ) } ,
{ AV_CODEC_ID_AAC , MKTAG ( ' m ' , ' p ' , ' 4 ' , ' a ' ) } ,
{ AV_CODEC_ID_H264 , MKTAG ( ' a ' , ' v ' , ' c ' , ' 1 ' ) } ,
{ AV_CODEC_ID_VP6F , MKTAG ( ' V ' , ' P ' , ' 6 ' , ' F ' ) } ,
{ AV_CODEC_ID_NONE , 0 } ,
} ;
2009-04-08 00:19:58 +02:00
static int mov_find_codec_tag ( AVFormatContext * s , MOVTrack * track )
{
2012-04-13 02:02:24 +02:00
int tag ;
2009-04-08 00:19:58 +02:00
2012-01-23 13:58:38 +01:00
if ( track - > mode = = MODE_MP4 | | track - > mode = = MODE_PSP )
tag = mp4_get_codec_tag ( s , track ) ;
else if ( track - > mode = = MODE_ISM ) {
2009-04-08 00:19:58 +02:00
tag = mp4_get_codec_tag ( s , track ) ;
2012-08-05 11:11:04 +02:00
if ( ! tag & & track - > enc - > codec_id = = AV_CODEC_ID_WMAPRO )
2012-01-23 13:58:38 +01:00
tag = MKTAG ( ' w ' , ' m ' , ' a ' , ' ' ) ;
} else if ( track - > mode = = MODE_IPOD )
2009-04-08 00:19:58 +02:00
tag = ipod_get_codec_tag ( s , track ) ;
else if ( track - > mode & MODE_3GP )
2009-06-23 01:09:34 +02:00
tag = ff_codec_get_tag ( codec_3gp_tags , track - > enc - > codec_id ) ;
2012-09-17 16:16:16 +02:00
else if ( track - > mode & MODE_F4V )
tag = ff_codec_get_tag ( codec_f4v_tags , track - > enc - > codec_id ) ;
2009-04-08 00:19:58 +02:00
else
tag = mov_get_codec_tag ( s , track ) ;
return tag ;
}
2008-03-16 14:36:36 +01:00
/** Write uuid atom.
* Needed to make file play in iPods running newest firmware
* goes after avcC atom in moov . trak . mdia . minf . stbl . stsd . avc1
*/
2011-02-20 11:04:12 +01:00
static int mov_write_uuid_tag_ipod ( AVIOContext * pb )
2008-03-16 14:36:36 +01:00
{
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 28 ) ;
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " uuid " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0x6b6840f2 ) ;
avio_wb32 ( pb , 0x5f244fc5 ) ;
avio_wb32 ( pb , 0xba39a51b ) ;
avio_wb32 ( pb , 0xcf0323f3 ) ;
avio_wb32 ( pb , 0x0 ) ;
2008-03-16 14:36:36 +01:00
return 28 ;
}
2011-12-14 03:49:06 +01:00
static const uint16_t fiel_data [ ] = {
0x0000 , 0x0100 , 0x0201 , 0x0206 , 0x0209 , 0x020e
} ;
static int mov_write_fiel_tag ( AVIOContext * pb , MOVTrack * track )
{
unsigned mov_field_order = 0 ;
if ( track - > enc - > field_order < FF_ARRAY_ELEMS ( fiel_data ) )
mov_field_order = fiel_data [ track - > enc - > field_order ] ;
else
return 0 ;
avio_wb32 ( pb , 10 ) ;
ffio_wfourcc ( pb , " fiel " ) ;
avio_wb16 ( pb , mov_field_order ) ;
return 10 ;
}
2011-02-20 11:04:12 +01:00
static int mov_write_subtitle_tag ( AVIOContext * pb , MOVTrack * track )
2009-01-11 11:26:44 +01:00
{
2011-03-03 20:11:45 +01:00
int64_t pos = avio_tell ( pb ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* size */
avio_wl32 ( pb , track - > tag ) ; // store it byteswapped
avio_wb32 ( pb , 0 ) ; /* Reserved */
avio_wb16 ( pb , 0 ) ; /* Reserved */
avio_wb16 ( pb , 1 ) ; /* Data-reference index */
2009-01-11 11:26:44 +01:00
if ( track - > enc - > extradata_size )
2011-02-21 19:28:17 +01:00
avio_write ( pb , track - > enc - > extradata , track - > enc - > extradata_size ) ;
2009-01-11 11:26:44 +01:00
2012-01-30 15:19:15 +01:00
return update_size ( pb , pos ) ;
2009-01-11 11:26:44 +01:00
}
2011-02-20 11:04:12 +01:00
static int mov_write_pasp_tag ( AVIOContext * pb , MOVTrack * track )
2010-07-08 23:57:20 +02:00
{
AVRational sar ;
av_reduce ( & sar . num , & sar . den , track - > enc - > sample_aspect_ratio . num ,
track - > enc - > sample_aspect_ratio . den , INT_MAX ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 16 ) ;
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " pasp " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , sar . num ) ;
avio_wb32 ( pb , sar . den ) ;
2010-07-08 23:57:20 +02:00
return 16 ;
}
2011-02-20 11:04:12 +01:00
static int mov_write_video_tag ( AVIOContext * pb , MOVTrack * track )
2003-08-26 22:23:13 +02:00
{
2011-03-03 20:11:45 +01:00
int64_t pos = avio_tell ( pb ) ;
2011-06-06 14:13:02 +02:00
char compressor_name [ 32 ] = { 0 } ;
2004-04-07 14:47:33 +02:00
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* size */
avio_wl32 ( pb , track - > tag ) ; // store it byteswapped
avio_wb32 ( pb , 0 ) ; /* Reserved */
avio_wb16 ( pb , 0 ) ; /* Reserved */
avio_wb16 ( pb , 1 ) ; /* Data-reference index */
2003-09-28 23:09:32 +02:00
2011-02-21 19:28:17 +01:00
avio_wb16 ( pb , 0 ) ; /* Codec stream version */
avio_wb16 ( pb , 0 ) ; /* Codec stream revision (=0) */
2006-08-07 16:18:43 +02:00
if ( track - > mode = = MODE_MOV ) {
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " FFMP " ) ; /* Vendor */
2012-08-05 11:11:04 +02:00
if ( track - > enc - > codec_id = = AV_CODEC_ID_RAWVIDEO ) {
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* Temporal Quality */
avio_wb32 ( pb , 0x400 ) ; /* Spatial Quality = lossless*/
2006-08-07 16:19:33 +02:00
} else {
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0x200 ) ; /* Temporal Quality = normal */
avio_wb32 ( pb , 0x200 ) ; /* Spatial Quality = normal */
2006-08-07 16:19:33 +02:00
}
2006-08-07 16:18:43 +02:00
} else {
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* Reserved */
avio_wb32 ( pb , 0 ) ; /* Reserved */
avio_wb32 ( pb , 0 ) ; /* Reserved */
2006-08-07 16:18:43 +02:00
}
2011-02-21 19:28:17 +01:00
avio_wb16 ( pb , track - > enc - > width ) ; /* Video width */
avio_wb16 ( pb , track - > height ) ; /* Video height */
avio_wb32 ( pb , 0x00480000 ) ; /* Horizontal resolution 72dpi */
avio_wb32 ( pb , 0x00480000 ) ; /* Vertical resolution 72dpi */
avio_wb32 ( pb , 0 ) ; /* Data size (= 0) */
avio_wb16 ( pb , 1 ) ; /* Frame count (= 1) */
2005-12-17 19:14:38 +01:00
2006-08-07 16:18:43 +02:00
/* FIXME not sure, ISO 14496-1 draft where it shall be set to 0 */
if ( track - > mode = = MODE_MOV & & track - > enc - > codec & & track - > enc - > codec - > name )
2011-05-03 20:19:31 +02:00
av_strlcpy ( compressor_name , track - > enc - > codec - > name , 32 ) ;
2011-02-21 19:28:17 +01:00
avio_w8 ( pb , strlen ( compressor_name ) ) ;
avio_write ( pb , compressor_name , 31 ) ;
2005-12-17 19:14:38 +01:00
2008-09-08 16:24:59 +02:00
if ( track - > mode = = MODE_MOV & & track - > enc - > bits_per_coded_sample )
2011-02-21 19:28:17 +01:00
avio_wb16 ( pb , track - > enc - > bits_per_coded_sample ) ;
2008-01-31 12:31:56 +01:00
else
2011-02-21 19:28:17 +01:00
avio_wb16 ( pb , 0x18 ) ; /* Reserved */
avio_wb16 ( pb , 0xffff ) ; /* Reserved */
2008-01-28 14:44:27 +01:00
if ( track - > tag = = MKTAG ( ' m ' , ' p ' , ' 4 ' , ' v ' ) )
2003-09-28 23:09:32 +02:00
mov_write_esds_tag ( pb , track ) ;
2012-08-05 11:11:04 +02:00
else if ( track - > enc - > codec_id = = AV_CODEC_ID_H263 )
2003-09-28 23:09:32 +02:00
mov_write_d263_tag ( pb ) ;
2012-08-07 22:45:46 +02:00
else if ( track - > enc - > codec_id = = AV_CODEC_ID_AVUI | |
track - > enc - > codec_id = = AV_CODEC_ID_SVQ3 ) {
2012-05-15 07:41:23 +02:00
mov_write_extradata_tag ( pb , track ) ;
2012-07-25 09:26:17 +02:00
avio_wb32 ( pb , 0 ) ;
2012-08-07 22:45:46 +02:00
} else if ( track - > enc - > codec_id = = AV_CODEC_ID_DNXHD )
2008-03-20 19:42:44 +01:00
mov_write_avid_tag ( pb , track ) ;
2012-08-05 11:11:04 +02:00
else if ( track - > enc - > codec_id = = AV_CODEC_ID_H264 ) {
2006-03-11 19:18:17 +01:00
mov_write_avcc_tag ( pb , track ) ;
2008-03-16 14:36:36 +01:00
if ( track - > mode = = MODE_IPOD )
mov_write_uuid_tag_ipod ( pb ) ;
2011-12-14 03:49:06 +01:00
} else if ( track - > enc - > field_order ! = AV_FIELD_UNKNOWN )
mov_write_fiel_tag ( pb , track ) ;
2012-08-05 11:11:04 +02:00
else if ( track - > enc - > codec_id = = AV_CODEC_ID_VC1 & & track - > vos_len > 0 )
2012-01-21 01:16:34 +01:00
mov_write_dvc1_tag ( pb , track ) ;
2012-01-30 15:19:15 +01:00
else if ( track - > vos_len > 0 )
2007-12-19 17:00:08 +01:00
mov_write_glbl_tag ( pb , track ) ;
2003-09-28 23:09:32 +02:00
2011-02-15 11:44:08 +01:00
if ( track - > enc - > sample_aspect_ratio . den & & track - > enc - > sample_aspect_ratio . num & &
2010-07-08 23:57:20 +02:00
track - > enc - > sample_aspect_ratio . den ! = track - > enc - > sample_aspect_ratio . num ) {
mov_write_pasp_tag ( pb , track ) ;
}
2012-01-30 15:19:15 +01:00
return update_size ( pb , pos ) ;
2003-08-26 22:23:13 +02:00
}
2012-03-05 08:51:08 +01:00
static int mov_write_tmcd_tag ( AVIOContext * pb , MOVTrack * track )
{
int64_t pos = avio_tell ( pb ) ;
2012-10-15 14:57:07 +02:00
int frame_duration = av_rescale ( track - > timescale , track - > enc - > time_base . num , track - > enc - > time_base . den ) ;
2012-03-05 08:51:08 +01:00
int nb_frames = ( track - > timescale + frame_duration / 2 ) / frame_duration ;
avio_wb32 ( pb , 0 ) ; /* size */
ffio_wfourcc ( pb , " tmcd " ) ; /* Data format */
avio_wb32 ( pb , 0 ) ; /* Reserved */
avio_wb32 ( pb , 1 ) ; /* Data reference index */
avio_wb32 ( pb , 0 ) ; /* Flags */
avio_wb32 ( pb , track - > timecode_flags ) ; /* Flags (timecode) */
avio_wb32 ( pb , track - > timescale ) ; /* Timescale */
avio_wb32 ( pb , frame_duration ) ; /* Frame duration */
avio_w8 ( pb , nb_frames ) ; /* Number of frames */
avio_wb24 ( pb , 0 ) ; /* Reserved */
/* TODO: source reference string */
return update_size ( pb , pos ) ;
}
2011-02-20 11:04:12 +01:00
static int mov_write_rtp_tag ( AVIOContext * pb , MOVTrack * track )
2010-05-18 21:47:24 +02:00
{
2011-03-03 20:11:45 +01:00
int64_t pos = avio_tell ( pb ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " rtp " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* Reserved */
avio_wb16 ( pb , 0 ) ; /* Reserved */
avio_wb16 ( pb , 1 ) ; /* Data-reference index */
2010-05-18 21:47:24 +02:00
2011-02-21 19:28:17 +01:00
avio_wb16 ( pb , 1 ) ; /* Hint track version */
avio_wb16 ( pb , 1 ) ; /* Highest compatible version */
avio_wb32 ( pb , track - > max_packet_size ) ; /* Max packet size */
2010-05-18 21:47:24 +02:00
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 12 ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " tims " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , track - > timescale ) ;
2010-05-18 21:47:24 +02:00
2012-01-30 15:19:15 +01:00
return update_size ( pb , pos ) ;
2010-05-18 21:47:24 +02:00
}
2011-02-20 11:04:12 +01:00
static int mov_write_stsd_tag ( AVIOContext * pb , MOVTrack * track )
2003-08-26 22:23:13 +02:00
{
2011-03-03 20:11:45 +01:00
int64_t pos = avio_tell ( pb ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " stsd " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* version & flags */
avio_wb32 ( pb , 1 ) ; /* entry count */
2010-03-31 01:30:55 +02:00
if ( track - > enc - > codec_type = = AVMEDIA_TYPE_VIDEO )
2003-09-28 23:09:32 +02:00
mov_write_video_tag ( pb , track ) ;
2010-03-31 01:30:55 +02:00
else if ( track - > enc - > codec_type = = AVMEDIA_TYPE_AUDIO )
2003-09-28 23:09:32 +02:00
mov_write_audio_tag ( pb , track ) ;
2010-03-31 01:30:55 +02:00
else if ( track - > enc - > codec_type = = AVMEDIA_TYPE_SUBTITLE )
2009-01-11 11:26:44 +01:00
mov_write_subtitle_tag ( pb , track ) ;
2010-05-18 21:47:24 +02:00
else if ( track - > enc - > codec_tag = = MKTAG ( ' r ' , ' t ' , ' p ' , ' ' ) )
mov_write_rtp_tag ( pb , track ) ;
2012-03-05 08:51:08 +01:00
else if ( track - > enc - > codec_tag = = MKTAG ( ' t ' , ' m ' , ' c ' , ' d ' ) )
mov_write_tmcd_tag ( pb , track ) ;
2012-01-30 15:19:15 +01:00
return update_size ( pb , pos ) ;
2003-08-26 22:23:13 +02:00
}
2011-02-20 11:04:12 +01:00
static int mov_write_ctts_tag ( AVIOContext * pb , MOVTrack * track )
2006-02-23 00:46:20 +01:00
{
2008-12-11 21:06:56 +01:00
MOVStts * ctts_entries ;
2006-02-23 00:46:20 +01:00
uint32_t entries = 0 ;
uint32_t atom_size ;
int i ;
ctts_entries = av_malloc ( ( track - > entry + 1 ) * sizeof ( * ctts_entries ) ) ; /* worst case */
ctts_entries [ 0 ] . count = 1 ;
2006-06-24 20:09:20 +02:00
ctts_entries [ 0 ] . duration = track - > cluster [ 0 ] . cts ;
2006-02-23 00:46:20 +01:00
for ( i = 1 ; i < track - > entry ; i + + ) {
2006-06-24 20:09:20 +02:00
if ( track - > cluster [ i ] . cts = = ctts_entries [ entries ] . duration ) {
2006-02-23 00:46:20 +01:00
ctts_entries [ entries ] . count + + ; /* compress */
} else {
entries + + ;
2006-06-24 20:09:20 +02:00
ctts_entries [ entries ] . duration = track - > cluster [ i ] . cts ;
2006-02-23 00:46:20 +01:00
ctts_entries [ entries ] . count = 1 ;
}
}
entries + + ; /* last one */
atom_size = 16 + ( entries * 8 ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , atom_size ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " ctts " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* version & flags */
avio_wb32 ( pb , entries ) ; /* entry count */
2006-02-23 00:46:20 +01:00
for ( i = 0 ; i < entries ; i + + ) {
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , ctts_entries [ i ] . count ) ;
avio_wb32 ( pb , ctts_entries [ i ] . duration ) ;
2006-02-23 00:46:20 +01:00
}
av_free ( ctts_entries ) ;
return atom_size ;
}
2003-11-03 22:51:07 +01:00
/* Time to sample atom */
2011-02-20 11:04:12 +01:00
static int mov_write_stts_tag ( AVIOContext * pb , MOVTrack * track )
2003-08-26 22:23:13 +02:00
{
2008-12-11 21:06:56 +01:00
MOVStts * stts_entries ;
2006-11-01 18:27:39 +01:00
uint32_t entries = - 1 ;
uint32_t atom_size ;
int i ;
2010-03-31 01:30:55 +02:00
if ( track - > enc - > codec_type = = AVMEDIA_TYPE_AUDIO & & ! track - > audio_vbr ) {
2006-11-01 18:27:39 +01:00
stts_entries = av_malloc ( sizeof ( * stts_entries ) ) ; /* one entry */
2012-01-30 15:19:15 +01:00
stts_entries [ 0 ] . count = track - > sample_count ;
2006-11-01 18:27:39 +01:00
stts_entries [ 0 ] . duration = 1 ;
entries = 1 ;
} else {
2012-01-05 12:57:05 +01:00
stts_entries = track - > entry ?
av_malloc ( track - > entry * sizeof ( * stts_entries ) ) : /* worst case */
NULL ;
2006-11-01 18:27:39 +01:00
for ( i = 0 ; i < track - > entry ; i + + ) {
2012-02-26 23:17:13 +01:00
int duration = get_cluster_duration ( track , i ) ;
2006-11-01 18:27:39 +01:00
if ( i & & duration = = stts_entries [ entries ] . duration ) {
stts_entries [ entries ] . count + + ; /* compress */
} else {
entries + + ;
stts_entries [ entries ] . duration = duration ;
stts_entries [ entries ] . count = 1 ;
}
}
entries + + ; /* last one */
}
atom_size = 16 + ( entries * 8 ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , atom_size ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " stts " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* version & flags */
avio_wb32 ( pb , entries ) ; /* entry count */
2006-11-01 18:27:39 +01:00
for ( i = 0 ; i < entries ; i + + ) {
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , stts_entries [ i ] . count ) ;
avio_wb32 ( pb , stts_entries [ i ] . duration ) ;
2006-11-01 18:27:39 +01:00
}
av_free ( stts_entries ) ;
return atom_size ;
2003-08-26 22:23:13 +02:00
}
2011-02-20 11:04:12 +01:00
static int mov_write_dref_tag ( AVIOContext * pb )
2003-08-26 22:23:13 +02:00
{
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 28 ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " dref " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* version & flags */
avio_wb32 ( pb , 1 ) ; /* entry count */
2003-08-26 22:23:13 +02:00
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0xc ) ; /* size */
2012-01-14 14:10:19 +01:00
//FIXME add the alis and rsrc atom
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " url " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 1 ) ; /* version & flags */
2003-08-26 22:23:13 +02:00
return 28 ;
}
2011-02-20 11:04:12 +01:00
static int mov_write_stbl_tag ( AVIOContext * pb , MOVTrack * track )
2003-08-26 22:23:13 +02:00
{
2011-03-03 20:11:45 +01:00
int64_t pos = avio_tell ( pb ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " stbl " ) ;
2003-09-10 01:03:04 +02:00
mov_write_stsd_tag ( pb , track ) ;
mov_write_stts_tag ( pb , track ) ;
2010-05-18 21:47:24 +02:00
if ( ( track - > enc - > codec_type = = AVMEDIA_TYPE_VIDEO | |
track - > enc - > codec_tag = = MKTAG ( ' r ' , ' t ' , ' p ' , ' ' ) ) & &
2012-01-30 15:19:15 +01:00
track - > has_keyframes & & track - > has_keyframes < track - > entry )
2009-05-15 08:11:53 +02:00
mov_write_stss_tag ( pb , track , MOV_SYNC_SAMPLE ) ;
if ( track - > mode = = MODE_MOV & & track - > flags & MOV_TRACK_STPS )
mov_write_stss_tag ( pb , track , MOV_PARTIAL_SYNC_SAMPLE ) ;
2010-03-31 01:30:55 +02:00
if ( track - > enc - > codec_type = = AVMEDIA_TYPE_VIDEO & &
2009-05-15 08:11:53 +02:00
track - > flags & MOV_TRACK_CTTS )
2006-02-23 00:46:20 +01:00
mov_write_ctts_tag ( pb , track ) ;
2003-09-10 01:03:04 +02:00
mov_write_stsc_tag ( pb , track ) ;
mov_write_stsz_tag ( pb , track ) ;
mov_write_stco_tag ( pb , track ) ;
2012-01-30 15:19:15 +01:00
return update_size ( pb , pos ) ;
2003-08-26 22:23:13 +02:00
}
2011-02-20 11:04:12 +01:00
static int mov_write_dinf_tag ( AVIOContext * pb )
2003-08-26 22:23:13 +02:00
{
2011-03-03 20:11:45 +01:00
int64_t pos = avio_tell ( pb ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " dinf " ) ;
2003-09-10 01:03:04 +02:00
mov_write_dref_tag ( pb ) ;
2012-01-30 15:19:15 +01:00
return update_size ( pb , pos ) ;
2003-08-26 22:23:13 +02:00
}
2011-02-20 11:04:12 +01:00
static int mov_write_nmhd_tag ( AVIOContext * pb )
2009-01-11 11:26:44 +01:00
{
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 12 ) ;
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " nmhd " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ;
2009-01-11 11:26:44 +01:00
return 12 ;
}
2012-03-05 08:51:08 +01:00
static int mov_write_tcmi_tag ( AVIOContext * pb , MOVTrack * track )
2009-01-11 11:26:44 +01:00
{
2012-03-05 08:51:08 +01:00
int64_t pos = avio_tell ( pb ) ;
const char * font = " Lucida Grande " ;
avio_wb32 ( pb , 0 ) ; /* size */
ffio_wfourcc ( pb , " tcmi " ) ; /* timecode media information atom */
avio_wb32 ( pb , 0 ) ; /* version & flags */
avio_wb16 ( pb , 0 ) ; /* text font */
avio_wb16 ( pb , 0 ) ; /* text face */
avio_wb16 ( pb , 12 ) ; /* text size */
avio_wb16 ( pb , 0 ) ; /* (unknown, not in the QT specs...) */
avio_wb16 ( pb , 0x0000 ) ; /* text color (red) */
avio_wb16 ( pb , 0x0000 ) ; /* text color (green) */
avio_wb16 ( pb , 0x0000 ) ; /* text color (blue) */
avio_wb16 ( pb , 0xffff ) ; /* background color (red) */
avio_wb16 ( pb , 0xffff ) ; /* background color (green) */
avio_wb16 ( pb , 0xffff ) ; /* background color (blue) */
avio_w8 ( pb , strlen ( font ) ) ; /* font len (part of the pascal string) */
avio_write ( pb , font , strlen ( font ) ) ; /* font name */
return update_size ( pb , pos ) ;
}
static int mov_write_gmhd_tag ( AVIOContext * pb , MOVTrack * track )
{
int64_t pos = avio_tell ( pb ) ;
avio_wb32 ( pb , 0 ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " gmhd " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0x18 ) ; /* gmin size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " gmin " ) ; /* generic media info */
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* version & flags */
avio_wb16 ( pb , 0x40 ) ; /* graphics mode = */
avio_wb16 ( pb , 0x8000 ) ; /* opColor (r?) */
avio_wb16 ( pb , 0x8000 ) ; /* opColor (g?) */
avio_wb16 ( pb , 0x8000 ) ; /* opColor (b?) */
avio_wb16 ( pb , 0 ) ; /* balance */
avio_wb16 ( pb , 0 ) ; /* reserved */
2012-05-20 02:10:47 +02:00
/*
* This special text atom is required for
* Apple Quicktime chapters . The contents
* don ' t appear to be documented , so the
* bytes are copied verbatim .
*/
avio_wb32 ( pb , 0x2C ) ; /* size */
ffio_wfourcc ( pb , " text " ) ;
avio_wb16 ( pb , 0x01 ) ;
avio_wb32 ( pb , 0x00 ) ;
avio_wb32 ( pb , 0x00 ) ;
avio_wb32 ( pb , 0x00 ) ;
avio_wb32 ( pb , 0x01 ) ;
avio_wb32 ( pb , 0x00 ) ;
avio_wb32 ( pb , 0x00 ) ;
avio_wb32 ( pb , 0x00 ) ;
avio_wb32 ( pb , 0x00004000 ) ;
avio_wb16 ( pb , 0x0000 ) ;
2012-03-05 08:51:08 +01:00
if ( track - > enc - > codec_tag = = MKTAG ( ' t ' , ' m ' , ' c ' , ' d ' ) ) {
int64_t tmcd_pos = avio_tell ( pb ) ;
avio_wb32 ( pb , 0 ) ; /* size */
ffio_wfourcc ( pb , " tmcd " ) ;
mov_write_tcmi_tag ( pb , track ) ;
update_size ( pb , tmcd_pos ) ;
}
return update_size ( pb , pos ) ;
2009-01-11 11:26:44 +01:00
}
2011-02-20 11:04:12 +01:00
static int mov_write_smhd_tag ( AVIOContext * pb )
2003-08-26 22:23:13 +02:00
{
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 16 ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " smhd " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* version & flags */
avio_wb16 ( pb , 0 ) ; /* reserved (balance, normally = 0) */
avio_wb16 ( pb , 0 ) ; /* reserved */
2003-08-26 22:23:13 +02:00
return 16 ;
}
2011-02-20 11:04:12 +01:00
static int mov_write_vmhd_tag ( AVIOContext * pb )
2003-08-26 22:23:13 +02:00
{
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0x14 ) ; /* size (always 0x14) */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " vmhd " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0x01 ) ; /* version & flags */
avio_wb64 ( pb , 0 ) ; /* reserved (graphics mode = copy) */
2003-08-26 22:23:13 +02:00
return 0x14 ;
}
2011-02-20 11:04:12 +01:00
static int mov_write_hdlr_tag ( AVIOContext * pb , MOVTrack * track )
2003-08-26 22:23:13 +02:00
{
2009-01-11 11:41:43 +01:00
const char * hdlr , * descr = NULL , * hdlr_type = NULL ;
2011-03-03 20:11:45 +01:00
int64_t pos = avio_tell ( pb ) ;
2005-12-17 19:14:38 +01:00
2004-03-28 04:17:06 +02:00
if ( ! track ) { /* no media --> data handler */
2005-12-22 02:10:11 +01:00
hdlr = " dhlr " ;
hdlr_type = " url " ;
descr = " DataHandler " ;
2004-03-28 04:17:06 +02:00
} else {
2005-12-22 02:10:11 +01:00
hdlr = ( track - > mode = = MODE_MOV ) ? " mhlr " : " \0 \0 \0 \0 " ;
2010-03-31 01:30:55 +02:00
if ( track - > enc - > codec_type = = AVMEDIA_TYPE_VIDEO ) {
2005-12-22 02:10:11 +01:00
hdlr_type = " vide " ;
descr = " VideoHandler " ;
2010-03-31 01:30:55 +02:00
} else if ( track - > enc - > codec_type = = AVMEDIA_TYPE_AUDIO ) {
2005-12-22 02:10:11 +01:00
hdlr_type = " soun " ;
descr = " SoundHandler " ;
2010-03-31 01:30:55 +02:00
} else if ( track - > enc - > codec_type = = AVMEDIA_TYPE_SUBTITLE ) {
2009-03-11 09:01:39 +01:00
if ( track - > tag = = MKTAG ( ' t ' , ' x ' , ' 3 ' , ' g ' ) ) hdlr_type = " sbtl " ;
2009-03-11 09:02:59 +01:00
else hdlr_type = " text " ;
2009-01-11 11:26:44 +01:00
descr = " SubtitleHandler " ;
2012-03-05 08:51:08 +01:00
} else if ( track - > enc - > codec_tag = = MKTAG ( ' t ' , ' m ' , ' c ' , ' d ' ) ) {
hdlr_type = " tmcd " ;
descr = " TimeCodeHandler " ;
2010-05-18 21:47:24 +02:00
} else if ( track - > enc - > codec_tag = = MKTAG ( ' r ' , ' t ' , ' p ' , ' ' ) ) {
hdlr_type = " hint " ;
descr = " HintHandler " ;
2012-03-24 21:36:51 +01:00
} else {
hdlr = " dhlr " ;
hdlr_type = " url " ;
descr = " DataHandler " ;
2005-12-22 02:10:11 +01:00
}
2004-03-28 04:17:06 +02:00
}
2005-12-17 19:14:38 +01:00
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " hdlr " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* Version & flags */
avio_write ( pb , hdlr , 4 ) ; /* handler */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , hdlr_type ) ; /* handler type */
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* reserved */
avio_wb32 ( pb , 0 ) ; /* reserved */
avio_wb32 ( pb , 0 ) ; /* reserved */
2009-05-23 09:17:17 +02:00
if ( ! track | | track - > mode = = MODE_MOV )
2011-02-21 19:28:17 +01:00
avio_w8 ( pb , strlen ( descr ) ) ; /* pascal string */
avio_write ( pb , descr , strlen ( descr ) ) ; /* handler description */
2009-05-23 09:17:17 +02:00
if ( track & & track - > mode ! = MODE_MOV )
2011-02-21 19:28:17 +01:00
avio_w8 ( pb , 0 ) ; /* c string */
2012-01-30 15:19:15 +01:00
return update_size ( pb , pos ) ;
2004-03-28 04:17:06 +02:00
}
2011-02-20 11:04:12 +01:00
static int mov_write_hmhd_tag ( AVIOContext * pb )
2010-05-18 21:47:24 +02:00
{
/* This atom must be present, but leaving the values at zero
* seems harmless . */
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 28 ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " hmhd " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* version, flags */
avio_wb16 ( pb , 0 ) ; /* maxPDUsize */
avio_wb16 ( pb , 0 ) ; /* avgPDUsize */
avio_wb32 ( pb , 0 ) ; /* maxbitrate */
avio_wb32 ( pb , 0 ) ; /* avgbitrate */
avio_wb32 ( pb , 0 ) ; /* reserved */
2010-05-18 21:47:24 +02:00
return 28 ;
}
2011-02-20 11:04:12 +01:00
static int mov_write_minf_tag ( AVIOContext * pb , MOVTrack * track )
2004-03-28 04:17:06 +02:00
{
2011-03-03 20:11:45 +01:00
int64_t pos = avio_tell ( pb ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " minf " ) ;
2010-03-31 01:30:55 +02:00
if ( track - > enc - > codec_type = = AVMEDIA_TYPE_VIDEO )
2004-03-28 04:17:06 +02:00
mov_write_vmhd_tag ( pb ) ;
2010-03-31 01:30:55 +02:00
else if ( track - > enc - > codec_type = = AVMEDIA_TYPE_AUDIO )
2004-03-28 04:17:06 +02:00
mov_write_smhd_tag ( pb ) ;
2010-03-31 01:30:55 +02:00
else if ( track - > enc - > codec_type = = AVMEDIA_TYPE_SUBTITLE ) {
2012-03-05 08:51:08 +01:00
if ( track - > tag = = MKTAG ( ' t ' , ' e ' , ' x ' , ' t ' ) ) mov_write_gmhd_tag ( pb , track ) ;
2009-03-11 09:02:59 +01:00
else mov_write_nmhd_tag ( pb ) ;
2012-03-05 08:51:08 +01:00
} else if ( track - > tag = = MKTAG ( ' t ' , ' m ' , ' c ' , ' d ' ) ) {
mov_write_gmhd_tag ( pb , track ) ;
2010-05-18 21:47:24 +02:00
} else if ( track - > tag = = MKTAG ( ' r ' , ' t ' , ' p ' , ' ' ) ) {
mov_write_hmhd_tag ( pb ) ;
2009-01-11 11:26:44 +01:00
}
2004-03-28 04:17:06 +02:00
if ( track - > mode = = MODE_MOV ) /* FIXME: Why do it for MODE_MOV only ? */
mov_write_hdlr_tag ( pb , NULL ) ;
mov_write_dinf_tag ( pb ) ;
mov_write_stbl_tag ( pb , track ) ;
2012-01-30 15:19:15 +01:00
return update_size ( pb , pos ) ;
2003-08-26 22:23:13 +02:00
}
2011-02-20 11:04:12 +01:00
static int mov_write_mdhd_tag ( AVIOContext * pb , MOVTrack * track )
2003-08-26 22:23:13 +02:00
{
2012-01-30 15:19:15 +01:00
int version = track - > track_duration < INT32_MAX ? 0 : 1 ;
2006-03-26 15:34:51 +02:00
2012-02-17 13:40:24 +01:00
if ( track - > mode = = MODE_ISM )
version = 1 ;
2011-02-21 19:28:17 +01:00
( version = = 1 ) ? avio_wb32 ( pb , 44 ) : avio_wb32 ( pb , 32 ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " mdhd " ) ;
2011-02-21 19:28:17 +01:00
avio_w8 ( pb , version ) ;
avio_wb24 ( pb , 0 ) ; /* flags */
2006-03-26 15:34:51 +02:00
if ( version = = 1 ) {
2011-02-21 19:28:17 +01:00
avio_wb64 ( pb , track - > time ) ;
avio_wb64 ( pb , track - > time ) ;
2006-03-26 15:34:51 +02:00
} else {
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , track - > time ) ; /* creation time */
avio_wb32 ( pb , track - > time ) ; /* modification time */
2006-03-26 15:34:51 +02:00
}
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , track - > timescale ) ; /* time scale (sample rate for audio) */
2012-01-27 23:28:19 +01:00
if ( ! track - > entry )
( version = = 1 ) ? avio_wb64 ( pb , UINT64_C ( 0xffffffffffffffff ) ) : avio_wb32 ( pb , 0xffffffff ) ;
else
( version = = 1 ) ? avio_wb64 ( pb , track - > track_duration ) : avio_wb32 ( pb , track - > track_duration ) ; /* duration */
2011-02-21 19:28:17 +01:00
avio_wb16 ( pb , track - > language ) ; /* language */
avio_wb16 ( pb , 0 ) ; /* reserved (quality) */
2007-05-30 02:08:32 +02:00
if ( version ! = 0 & & track - > mode = = MODE_MOV ) {
av_log ( NULL , AV_LOG_ERROR ,
" FATAL error, file duration too long for timebase, this file will not be \n "
2007-05-30 12:04:37 +02:00
" playable with quicktime. Choose a different timebase or a different \n "
2007-05-30 02:08:32 +02:00
" container format \n " ) ;
}
2003-08-26 22:23:13 +02:00
return 32 ;
}
2011-02-20 11:04:12 +01:00
static int mov_write_mdia_tag ( AVIOContext * pb , MOVTrack * track )
2003-08-26 22:23:13 +02:00
{
2011-03-03 20:11:45 +01:00
int64_t pos = avio_tell ( pb ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " mdia " ) ;
2003-09-10 01:03:04 +02:00
mov_write_mdhd_tag ( pb , track ) ;
mov_write_hdlr_tag ( pb , track ) ;
mov_write_minf_tag ( pb , track ) ;
2012-01-30 15:19:15 +01:00
return update_size ( pb , pos ) ;
2003-08-26 22:23:13 +02:00
}
2012-07-13 23:35:54 +02:00
/* transformation matrix
| a b u |
| c d v |
| tx ty w | */
static void write_matrix ( AVIOContext * pb , int16_t a , int16_t b , int16_t c ,
int16_t d , int16_t tx , int16_t ty )
{
avio_wb32 ( pb , a < < 16 ) ; /* 16.16 format */
avio_wb32 ( pb , b < < 16 ) ; /* 16.16 format */
avio_wb32 ( pb , 0 ) ; /* u in 2.30 format */
avio_wb32 ( pb , c < < 16 ) ; /* 16.16 format */
avio_wb32 ( pb , d < < 16 ) ; /* 16.16 format */
avio_wb32 ( pb , 0 ) ; /* v in 2.30 format */
avio_wb32 ( pb , tx < < 16 ) ; /* 16.16 format */
avio_wb32 ( pb , ty < < 16 ) ; /* 16.16 format */
avio_wb32 ( pb , 1 < < 30 ) ; /* w in 2.30 format */
}
2011-02-20 11:04:12 +01:00
static int mov_write_tkhd_tag ( AVIOContext * pb , MOVTrack * track , AVStream * st )
2003-08-26 22:23:13 +02:00
{
2012-01-30 15:19:15 +01:00
int64_t duration = av_rescale_rnd ( track - > track_duration , MOV_TIMESCALE ,
2009-11-29 03:46:49 +01:00
track - > timescale , AV_ROUND_UP ) ;
2006-03-26 15:34:51 +02:00
int version = duration < INT32_MAX ? 0 : 1 ;
2012-07-13 23:35:54 +02:00
int rotation = 0 ;
2006-03-26 15:34:51 +02:00
2012-02-17 13:40:24 +01:00
if ( track - > mode = = MODE_ISM )
version = 1 ;
2011-02-21 19:28:17 +01:00
( version = = 1 ) ? avio_wb32 ( pb , 104 ) : avio_wb32 ( pb , 92 ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " tkhd " ) ;
2011-02-21 19:28:17 +01:00
avio_w8 ( pb , version ) ;
avio_wb24 ( pb , 0xf ) ; /* flags (track enabled) */
2006-03-26 15:34:51 +02:00
if ( version = = 1 ) {
2011-02-21 19:28:17 +01:00
avio_wb64 ( pb , track - > time ) ;
avio_wb64 ( pb , track - > time ) ;
2006-03-26 15:34:51 +02:00
} else {
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , track - > time ) ; /* creation time */
avio_wb32 ( pb , track - > time ) ; /* modification time */
2006-03-26 15:34:51 +02:00
}
2012-01-30 15:19:15 +01:00
avio_wb32 ( pb , track - > track_id ) ; /* track-id */
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* reserved */
2012-01-27 23:28:19 +01:00
if ( ! track - > entry )
( version = = 1 ) ? avio_wb64 ( pb , UINT64_C ( 0xffffffffffffffff ) ) : avio_wb32 ( pb , 0xffffffff ) ;
else
( version = = 1 ) ? avio_wb64 ( pb , duration ) : avio_wb32 ( pb , duration ) ;
2003-08-26 22:23:13 +02:00
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* reserved */
avio_wb32 ( pb , 0 ) ; /* reserved */
2011-09-16 16:06:45 +02:00
avio_wb16 ( pb , 0 ) ; /* layer */
2011-09-19 15:15:56 +02:00
avio_wb16 ( pb , st ? st - > codec - > codec_type : 0 ) ; /* alternate group) */
2003-08-26 22:23:13 +02:00
/* Volume, only for audio */
2010-03-31 01:30:55 +02:00
if ( track - > enc - > codec_type = = AVMEDIA_TYPE_AUDIO )
2011-02-21 19:28:17 +01:00
avio_wb16 ( pb , 0x0100 ) ;
2003-08-26 22:23:13 +02:00
else
2011-02-21 19:28:17 +01:00
avio_wb16 ( pb , 0 ) ;
avio_wb16 ( pb , 0 ) ; /* reserved */
2003-08-26 22:23:13 +02:00
/* Matrix structure */
2012-07-13 23:35:54 +02:00
if ( st & & st - > metadata ) {
AVDictionaryEntry * rot = av_dict_get ( st - > metadata , " rotate " , NULL , 0 ) ;
rotation = ( rot & & rot - > value ) ? atoi ( rot - > value ) : 0 ;
}
if ( rotation = = 90 ) {
write_matrix ( pb , 0 , 1 , - 1 , 0 , track - > enc - > height , 0 ) ;
} else if ( rotation = = 180 ) {
write_matrix ( pb , - 1 , 0 , 0 , - 1 , track - > enc - > width , track - > enc - > height ) ;
} else if ( rotation = = 270 ) {
write_matrix ( pb , 0 , - 1 , 1 , 0 , 0 , track - > enc - > width ) ;
} else {
write_matrix ( pb , 1 , 0 , 0 , 1 , 0 , 0 ) ;
}
2003-08-26 22:23:13 +02:00
/* Track width and height, for visual only */
2010-05-05 10:41:10 +02:00
if ( st & & ( track - > enc - > codec_type = = AVMEDIA_TYPE_VIDEO | |
track - > enc - > codec_type = = AVMEDIA_TYPE_SUBTITLE ) ) {
2011-02-25 16:41:55 +01:00
if ( track - > mode = = MODE_MOV ) {
avio_wb32 ( pb , track - > enc - > width < < 16 ) ;
2011-03-02 00:36:48 +01:00
avio_wb32 ( pb , track - > height < < 16 ) ;
2011-02-25 16:41:55 +01:00
} else {
2011-02-25 16:42:56 +01:00
double sample_aspect_ratio = av_q2d ( st - > sample_aspect_ratio ) ;
if ( ! sample_aspect_ratio | | track - > height ! = track - > enc - > height )
sample_aspect_ratio = 1 ;
avio_wb32 ( pb , sample_aspect_ratio * track - > enc - > width * 0x10000 ) ;
avio_wb32 ( pb , track - > height * 0x10000 ) ;
2011-02-25 16:41:55 +01:00
}
2003-08-26 22:23:13 +02:00
}
else {
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ;
avio_wb32 ( pb , 0 ) ;
2003-08-26 22:23:13 +02:00
}
return 0x5c ;
}
2011-02-25 23:41:00 +01:00
static int mov_write_tapt_tag ( AVIOContext * pb , MOVTrack * track )
2011-02-25 16:41:55 +01:00
{
int32_t width = av_rescale ( track - > enc - > sample_aspect_ratio . num , track - > enc - > width ,
track - > enc - > sample_aspect_ratio . den ) ;
2011-03-03 20:11:45 +01:00
int64_t pos = avio_tell ( pb ) ;
2011-02-25 16:41:55 +01:00
avio_wb32 ( pb , 0 ) ; /* size */
2011-02-25 23:41:00 +01:00
ffio_wfourcc ( pb , " tapt " ) ;
2011-02-25 16:41:55 +01:00
avio_wb32 ( pb , 20 ) ;
2011-02-25 23:41:00 +01:00
ffio_wfourcc ( pb , " clef " ) ;
2011-02-25 16:41:55 +01:00
avio_wb32 ( pb , 0 ) ;
2012-10-29 14:56:57 +01:00
avio_wb32 ( pb , width < < 16 ) ;
avio_wb32 ( pb , track - > enc - > height < < 16 ) ;
avio_wb32 ( pb , 20 ) ;
ffio_wfourcc ( pb , " prof " ) ;
avio_wb32 ( pb , 0 ) ;
2011-02-25 16:41:55 +01:00
avio_wb32 ( pb , width < < 16 ) ;
avio_wb32 ( pb , track - > enc - > height < < 16 ) ;
avio_wb32 ( pb , 20 ) ;
2011-02-25 23:41:00 +01:00
ffio_wfourcc ( pb , " enof " ) ;
2011-02-25 16:41:55 +01:00
avio_wb32 ( pb , 0 ) ;
avio_wb32 ( pb , track - > enc - > width < < 16 ) ;
avio_wb32 ( pb , track - > enc - > height < < 16 ) ;
2012-01-30 15:19:15 +01:00
return update_size ( pb , pos ) ;
2011-12-11 18:07:04 +01:00
}
2011-02-25 16:41:55 +01:00
2005-01-27 15:48:15 +01:00
// This box seems important for the psp playback ... without it the movie seems to hang
2011-02-20 11:04:12 +01:00
static int mov_write_edts_tag ( AVIOContext * pb , MOVTrack * track )
2005-01-27 15:48:15 +01:00
{
2012-01-30 15:19:15 +01:00
int64_t duration = av_rescale_rnd ( track - > track_duration , MOV_TIMESCALE ,
2011-05-02 19:25:28 +02:00
track - > timescale , AV_ROUND_UP ) ;
int version = duration < INT32_MAX ? 0 : 1 ;
int entry_size , entry_count , size ;
int64_t delay , start_ct = track - > cluster [ 0 ] . cts ;
delay = av_rescale_rnd ( track - > cluster [ 0 ] . dts + start_ct , MOV_TIMESCALE ,
track - > timescale , AV_ROUND_DOWN ) ;
version | = delay < INT32_MAX ? 0 : 1 ;
entry_size = ( version = = 1 ) ? 20 : 12 ;
entry_count = 1 + ( delay > 0 ) ;
size = 24 + entry_count * entry_size ;
/* write the atom data */
avio_wb32 ( pb , size ) ;
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " edts " ) ;
2011-05-02 19:25:28 +02:00
avio_wb32 ( pb , size - 8 ) ;
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " elst " ) ;
2011-05-02 19:25:28 +02:00
avio_w8 ( pb , version ) ;
avio_wb24 ( pb , 0 ) ; /* flags */
2005-01-27 15:48:15 +01:00
2011-05-02 19:25:28 +02:00
avio_wb32 ( pb , entry_count ) ;
if ( delay > 0 ) { /* add an empty edit to delay presentation */
if ( version = = 1 ) {
avio_wb64 ( pb , delay ) ;
avio_wb64 ( pb , - 1 ) ;
} else {
avio_wb32 ( pb , delay ) ;
avio_wb32 ( pb , - 1 ) ;
}
avio_wb32 ( pb , 0x00010000 ) ;
2012-09-29 06:31:18 +02:00
} else {
av_assert0 ( track - > cluster [ 0 ] . dts < = 0 ) ;
start_ct = - track - > cluster [ 0 ] . dts ;
duration + = delay ;
2011-05-02 19:25:28 +02:00
}
2005-01-27 15:48:15 +01:00
2011-05-02 19:25:28 +02:00
/* duration */
if ( version = = 1 ) {
avio_wb64 ( pb , duration ) ;
avio_wb64 ( pb , start_ct ) ;
} else {
avio_wb32 ( pb , duration ) ;
avio_wb32 ( pb , start_ct ) ;
}
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0x00010000 ) ;
2011-05-02 19:25:28 +02:00
return size ;
2005-01-27 15:48:15 +01:00
}
2011-02-20 11:04:12 +01:00
static int mov_write_tref_tag ( AVIOContext * pb , MOVTrack * track )
2010-05-05 10:41:10 +02:00
{
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 20 ) ; // size
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " tref " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 12 ) ; // size (subatom)
avio_wl32 ( pb , track - > tref_tag ) ;
avio_wb32 ( pb , track - > tref_id ) ;
2010-05-05 10:41:10 +02:00
return 20 ;
}
2005-01-27 15:48:15 +01:00
// goes at the end of each track! ... Critical for PSP playback ("Incompatible data" without it)
2011-02-20 11:04:12 +01:00
static int mov_write_uuid_tag_psp ( AVIOContext * pb , MOVTrack * mov )
2005-01-27 15:48:15 +01:00
{
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0x34 ) ; /* size ... reports as 28 in mp4box! */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " uuid " ) ;
ffio_wfourcc ( pb , " USMT " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0x21d24fce ) ;
avio_wb32 ( pb , 0xbb88695c ) ;
avio_wb32 ( pb , 0xfac9c740 ) ;
avio_wb32 ( pb , 0x1c ) ; // another size here!
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " MTDT " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0x00010012 ) ;
avio_wb32 ( pb , 0x0a ) ;
avio_wb32 ( pb , 0x55c40000 ) ;
avio_wb32 ( pb , 0x1 ) ;
avio_wb32 ( pb , 0x0 ) ;
2005-01-27 15:48:15 +01:00
return 0x34 ;
}
2011-05-18 15:21:47 +02:00
static int mov_write_udta_sdp ( AVIOContext * pb , AVFormatContext * ctx , int index )
2010-05-18 21:47:24 +02:00
{
char buf [ 1000 ] = " " ;
int len ;
2011-05-18 14:41:38 +02:00
ff_sdp_write_media ( buf , sizeof ( buf ) , ctx - > streams [ 0 ] - > codec , NULL , NULL , 0 , 0 , ctx ) ;
2010-05-18 21:47:24 +02:00
av_strlcatf ( buf , sizeof ( buf ) , " a=control:streamid=%d \r \n " , index ) ;
len = strlen ( buf ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , len + 24 ) ;
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " udta " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , len + 16 ) ;
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " hnti " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , len + 8 ) ;
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " sdp " ) ;
2011-02-21 19:28:17 +01:00
avio_write ( pb , buf , len ) ;
2010-05-18 21:47:24 +02:00
return len + 24 ;
}
2012-01-05 12:57:05 +01:00
static int mov_write_trak_tag ( AVIOContext * pb , MOVMuxContext * mov ,
MOVTrack * track , AVStream * st )
2003-08-26 22:23:13 +02:00
{
2011-03-03 20:11:45 +01:00
int64_t pos = avio_tell ( pb ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " trak " ) ;
2008-08-24 01:43:20 +02:00
mov_write_tkhd_tag ( pb , track , st ) ;
2012-09-29 06:33:32 +02:00
if ( supports_edts ( mov ) )
2011-12-07 05:06:13 +01:00
mov_write_edts_tag ( pb , track ) ; // PSP Movies and several other cases require edts box
2010-05-05 10:41:10 +02:00
if ( track - > tref_tag )
mov_write_tref_tag ( pb , track ) ;
2003-09-10 01:03:04 +02:00
mov_write_mdia_tag ( pb , track ) ;
2005-12-17 19:14:38 +01:00
if ( track - > mode = = MODE_PSP )
2005-01-27 15:48:15 +01:00
mov_write_uuid_tag_psp ( pb , track ) ; // PSP Movies require this uuid box
2010-05-18 21:47:24 +02:00
if ( track - > tag = = MKTAG ( ' r ' , ' t ' , ' p ' , ' ' ) )
2012-01-30 15:19:15 +01:00
mov_write_udta_sdp ( pb , track - > rtp_ctx , track - > track_id ) ;
2011-02-25 16:41:55 +01:00
if ( track - > enc - > codec_type = = AVMEDIA_TYPE_VIDEO & & track - > mode = = MODE_MOV ) {
double sample_aspect_ratio = av_q2d ( st - > sample_aspect_ratio ) ;
2012-02-18 04:07:53 +01:00
if ( st - > sample_aspect_ratio . num & & 1.0 ! = sample_aspect_ratio )
2011-02-25 16:41:55 +01:00
mov_write_tapt_tag ( pb , track ) ;
} ;
2012-01-30 15:19:15 +01:00
return update_size ( pb , pos ) ;
2003-08-26 22:23:13 +02:00
}
2011-02-20 11:04:12 +01:00
static int mov_write_iods_tag ( AVIOContext * pb , MOVMuxContext * mov )
2003-08-26 22:23:13 +02:00
{
2011-10-04 20:44:25 +02:00
int i , has_audio = 0 , has_video = 0 ;
int64_t pos = avio_tell ( pb ) ;
int audio_profile = mov - > iods_audio_profile ;
int video_profile = mov - > iods_video_profile ;
for ( i = 0 ; i < mov - > nb_streams ; i + + ) {
if ( mov - > tracks [ i ] . entry > 0 ) {
has_audio | = mov - > tracks [ i ] . enc - > codec_type = = AVMEDIA_TYPE_AUDIO ;
has_video | = mov - > tracks [ i ] . enc - > codec_type = = AVMEDIA_TYPE_VIDEO ;
}
}
if ( audio_profile < 0 )
audio_profile = 0xFF - has_audio ;
if ( video_profile < 0 )
video_profile = 0xFF - has_video ;
avio_wb32 ( pb , 0x0 ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " iods " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* version & flags */
2012-01-30 15:19:15 +01:00
put_descr ( pb , 0x10 , 7 ) ;
2011-10-04 20:44:25 +02:00
avio_wb16 ( pb , 0x004f ) ;
avio_w8 ( pb , 0xff ) ;
avio_w8 ( pb , 0xff ) ;
avio_w8 ( pb , audio_profile ) ;
avio_w8 ( pb , video_profile ) ;
avio_w8 ( pb , 0xff ) ;
2012-01-30 15:19:15 +01:00
return update_size ( pb , pos ) ;
2003-08-26 22:23:13 +02:00
}
2012-01-05 12:57:05 +01:00
static int mov_write_trex_tag ( AVIOContext * pb , MOVTrack * track )
{
avio_wb32 ( pb , 0x20 ) ; /* size */
ffio_wfourcc ( pb , " trex " ) ;
avio_wb32 ( pb , 0 ) ; /* version & flags */
2012-01-30 15:19:15 +01:00
avio_wb32 ( pb , track - > track_id ) ; /* track ID */
2012-01-05 12:57:05 +01:00
avio_wb32 ( pb , 1 ) ; /* default sample description index */
avio_wb32 ( pb , 0 ) ; /* default sample duration */
avio_wb32 ( pb , 0 ) ; /* default sample size */
avio_wb32 ( pb , 0 ) ; /* default sample flags */
return 0 ;
}
static int mov_write_mvex_tag ( AVIOContext * pb , MOVMuxContext * mov )
{
int64_t pos = avio_tell ( pb ) ;
int i ;
avio_wb32 ( pb , 0x0 ) ; /* size */
ffio_wfourcc ( pb , " mvex " ) ;
for ( i = 0 ; i < mov - > nb_streams ; i + + )
mov_write_trex_tag ( pb , & mov - > tracks [ i ] ) ;
2012-01-30 15:19:15 +01:00
return update_size ( pb , pos ) ;
2012-01-05 12:57:05 +01:00
}
2011-02-20 11:04:12 +01:00
static int mov_write_mvhd_tag ( AVIOContext * pb , MOVMuxContext * mov )
2003-08-26 22:23:13 +02:00
{
2012-01-30 15:19:15 +01:00
int max_track_id = 1 , i ;
int64_t max_track_len_temp , max_track_len = 0 ;
2006-03-26 15:34:51 +02:00
int version ;
2003-08-26 22:23:13 +02:00
2006-06-25 02:10:52 +02:00
for ( i = 0 ; i < mov - > nb_streams ; i + + ) {
2003-08-26 22:23:13 +02:00
if ( mov - > tracks [ i ] . entry > 0 ) {
2012-01-30 15:19:15 +01:00
max_track_len_temp = av_rescale_rnd ( mov - > tracks [ i ] . track_duration ,
MOV_TIMESCALE ,
mov - > tracks [ i ] . timescale ,
AV_ROUND_UP ) ;
if ( max_track_len < max_track_len_temp )
max_track_len = max_track_len_temp ;
if ( max_track_id < mov - > tracks [ i ] . track_id )
max_track_id = mov - > tracks [ i ] . track_id ;
2003-08-26 22:23:13 +02:00
}
}
2006-03-26 15:34:51 +02:00
2012-01-30 15:19:15 +01:00
version = max_track_len < UINT32_MAX ? 0 : 1 ;
2011-02-21 19:28:17 +01:00
( version = = 1 ) ? avio_wb32 ( pb , 120 ) : avio_wb32 ( pb , 108 ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " mvhd " ) ;
2011-02-21 19:28:17 +01:00
avio_w8 ( pb , version ) ;
avio_wb24 ( pb , 0 ) ; /* flags */
2006-03-26 15:34:51 +02:00
if ( version = = 1 ) {
2011-02-21 19:28:17 +01:00
avio_wb64 ( pb , mov - > time ) ;
avio_wb64 ( pb , mov - > time ) ;
2006-03-26 15:34:51 +02:00
} else {
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , mov - > time ) ; /* creation time */
avio_wb32 ( pb , mov - > time ) ; /* modification time */
2006-03-26 15:34:51 +02:00
}
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , MOV_TIMESCALE ) ;
2012-01-30 15:19:15 +01:00
( version = = 1 ) ? avio_wb64 ( pb , max_track_len ) : avio_wb32 ( pb , max_track_len ) ; /* duration of longest track */
2003-08-26 22:23:13 +02:00
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0x00010000 ) ; /* reserved (preferred rate) 1.0 = normal */
avio_wb16 ( pb , 0x0100 ) ; /* reserved (preferred volume) 1.0 = normal */
avio_wb16 ( pb , 0 ) ; /* reserved */
avio_wb32 ( pb , 0 ) ; /* reserved */
avio_wb32 ( pb , 0 ) ; /* reserved */
2003-08-26 22:23:13 +02:00
/* Matrix structure */
2012-07-13 23:35:54 +02:00
write_matrix ( pb , 1 , 0 , 0 , 1 , 0 , 0 ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* reserved (preview time) */
avio_wb32 ( pb , 0 ) ; /* reserved (preview duration) */
avio_wb32 ( pb , 0 ) ; /* reserved (poster time) */
avio_wb32 ( pb , 0 ) ; /* reserved (selection time) */
avio_wb32 ( pb , 0 ) ; /* reserved (selection duration) */
avio_wb32 ( pb , 0 ) ; /* reserved (current time) */
2012-01-30 15:19:15 +01:00
avio_wb32 ( pb , max_track_id + 1 ) ; /* Next track id */
2003-08-26 22:23:13 +02:00
return 0x6c ;
}
2011-02-20 11:04:12 +01:00
static int mov_write_itunes_hdlr_tag ( AVIOContext * pb , MOVMuxContext * mov ,
2004-08-14 16:05:48 +02:00
AVFormatContext * s )
{
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 33 ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " hdlr " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ;
avio_wb32 ( pb , 0 ) ;
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " mdir " ) ;
ffio_wfourcc ( pb , " appl " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ;
avio_wb32 ( pb , 0 ) ;
avio_w8 ( pb , 0 ) ;
2010-04-12 09:24:30 +02:00
return 33 ;
2004-08-14 16:05:48 +02:00
}
/* helper function to write a data tag with the specified string as data */
2011-02-20 11:04:12 +01:00
static int mov_write_string_data_tag ( AVIOContext * pb , const char * data , int lang , int long_style )
2004-08-14 16:05:48 +02:00
{
2006-05-19 00:49:27 +02:00
if ( long_style ) {
2010-04-12 09:24:30 +02:00
int size = 16 + strlen ( data ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , size ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " data " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 1 ) ;
avio_wb32 ( pb , 0 ) ;
avio_write ( pb , data , strlen ( data ) ) ;
2010-04-12 09:24:30 +02:00
return size ;
2006-05-19 00:49:27 +02:00
} else {
2010-03-09 02:53:16 +01:00
if ( ! lang )
lang = ff_mov_iso639_to_lang ( " und " , 1 ) ;
2011-02-21 19:28:17 +01:00
avio_wb16 ( pb , strlen ( data ) ) ; /* string length */
avio_wb16 ( pb , lang ) ;
avio_write ( pb , data , strlen ( data ) ) ;
2006-05-19 00:49:27 +02:00
return strlen ( data ) + 4 ;
2004-08-14 16:05:48 +02:00
}
}
2011-02-20 11:04:12 +01:00
static int mov_write_string_tag ( AVIOContext * pb , const char * name , const char * value , int lang , int long_style ) {
2004-08-14 16:05:48 +02:00
int size = 0 ;
2008-02-06 19:57:00 +01:00
if ( value & & value [ 0 ] ) {
2011-03-03 20:11:45 +01:00
int64_t pos = avio_tell ( pb ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , name ) ;
2009-02-26 14:13:48 +01:00
mov_write_string_data_tag ( pb , value , lang , long_style ) ;
2012-01-30 15:19:15 +01:00
size = update_size ( pb , pos ) ;
2004-08-14 16:05:48 +02:00
}
return size ;
}
2011-02-20 11:04:12 +01:00
static int mov_write_string_metadata ( AVFormatContext * s , AVIOContext * pb ,
2009-02-26 14:06:49 +01:00
const char * name , const char * tag ,
int long_style )
2004-08-14 16:05:48 +02:00
{
2009-02-26 14:13:48 +01:00
int l , lang = 0 , len , len2 ;
2011-05-22 12:46:29 +02:00
AVDictionaryEntry * t , * t2 = NULL ;
2009-02-26 14:13:48 +01:00
char tag2 [ 16 ] ;
2009-02-26 14:06:49 +01:00
2011-05-22 12:46:29 +02:00
if ( ! ( t = av_dict_get ( s - > metadata , tag , NULL , 0 ) ) )
2006-05-19 00:49:27 +02:00
return 0 ;
2009-02-26 14:06:49 +01:00
2009-02-26 14:13:48 +01:00
len = strlen ( t - > key ) ;
snprintf ( tag2 , sizeof ( tag2 ) , " %s- " , tag ) ;
2011-05-22 12:46:29 +02:00
while ( ( t2 = av_dict_get ( s - > metadata , tag2 , t2 , AV_DICT_IGNORE_SUFFIX ) ) ) {
2009-02-26 14:13:48 +01:00
len2 = strlen ( t2 - > key ) ;
if ( len2 = = len + 4 & & ! strcmp ( t - > value , t2 - > value )
2010-03-09 02:21:09 +01:00
& & ( l = ff_mov_iso639_to_lang ( & t2 - > key [ len2 - 3 ] , 1 ) ) > = 0 ) {
2009-02-26 14:13:48 +01:00
lang = l ;
break ;
}
}
return mov_write_string_tag ( pb , name , t - > value , lang , long_style ) ;
2004-08-14 16:05:48 +02:00
}
2012-08-24 21:37:47 +02:00
/* iTunes bpm number */
static int mov_write_tmpo_tag ( AVIOContext * pb , AVFormatContext * s )
{
AVDictionaryEntry * t = av_dict_get ( s - > metadata , " tmpo " , NULL , 0 ) ;
int size = 0 , tmpo = t ? atoi ( t - > value ) : 0 ;
if ( tmpo ) {
size = 26 ;
avio_wb32 ( pb , size ) ;
ffio_wfourcc ( pb , " tmpo " ) ;
avio_wb32 ( pb , size - 8 ) ; /* size */
ffio_wfourcc ( pb , " data " ) ;
avio_wb32 ( pb , 0x15 ) ; //type specifier
avio_wb32 ( pb , 0 ) ;
avio_wb16 ( pb , tmpo ) ; // data
}
return size ;
}
2004-08-14 16:05:48 +02:00
/* iTunes track number */
2011-02-20 11:04:12 +01:00
static int mov_write_trkn_tag ( AVIOContext * pb , MOVMuxContext * mov ,
2004-08-14 16:05:48 +02:00
AVFormatContext * s )
{
2011-05-22 12:46:29 +02:00
AVDictionaryEntry * t = av_dict_get ( s - > metadata , " track " , NULL , 0 ) ;
2009-02-26 14:06:49 +01:00
int size = 0 , track = t ? atoi ( t - > value ) : 0 ;
if ( track ) {
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 32 ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " trkn " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 24 ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " data " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; // 8 bytes empty
avio_wb32 ( pb , 0 ) ;
avio_wb16 ( pb , 0 ) ; // empty
avio_wb16 ( pb , track ) ; // track number
avio_wb16 ( pb , 0 ) ; // total track number
avio_wb16 ( pb , 0 ) ; // empty
2010-04-12 09:24:30 +02:00
size = 32 ;
2004-08-14 16:05:48 +02:00
}
return size ;
}
2012-08-21 03:21:39 +02:00
static int mov_write_int8_metadata ( AVFormatContext * s , AVIOContext * pb ,
const char * name , const char * tag ,
int len )
{
AVDictionaryEntry * t = NULL ;
uint8_t num ;
if ( ! ( t = av_dict_get ( s - > metadata , tag , NULL , 0 ) ) )
return 0 ;
num = t ? atoi ( t - > value ) : 0 ;
avio_wb32 ( pb , len + 8 ) ;
ffio_wfourcc ( pb , name ) ;
if ( len = = 4 ) avio_wb32 ( pb , num ) ;
else avio_w8 ( pb , num ) ;
return len + 8 ;
}
2004-08-14 16:05:48 +02:00
/* iTunes meta data list */
2011-02-20 11:04:12 +01:00
static int mov_write_ilst_tag ( AVIOContext * pb , MOVMuxContext * mov ,
2004-08-14 16:05:48 +02:00
AVFormatContext * s )
{
2011-03-03 20:11:45 +01:00
int64_t pos = avio_tell ( pb ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " ilst " ) ;
2009-02-26 14:06:49 +01:00
mov_write_string_metadata ( s , pb , " \251 nam " , " title " , 1 ) ;
2010-05-23 23:03:14 +02:00
mov_write_string_metadata ( s , pb , " \251 ART " , " artist " , 1 ) ;
2010-01-04 03:52:40 +01:00
mov_write_string_metadata ( s , pb , " aART " , " album_artist " , 1 ) ;
2009-11-23 09:47:40 +01:00
mov_write_string_metadata ( s , pb , " \251 wrt " , " composer " , 1 ) ;
2009-02-26 14:06:49 +01:00
mov_write_string_metadata ( s , pb , " \251 alb " , " album " , 1 ) ;
2010-02-01 12:39:10 +01:00
mov_write_string_metadata ( s , pb , " \251 day " , " date " , 1 ) ;
2009-02-26 14:13:48 +01:00
mov_write_string_tag ( pb , " \251 too " , LIBAVFORMAT_IDENT , 0 , 1 ) ;
2009-02-26 14:06:49 +01:00
mov_write_string_metadata ( s , pb , " \251 cmt " , " comment " , 1 ) ;
mov_write_string_metadata ( s , pb , " \251 gen " , " genre " , 1 ) ;
mov_write_string_metadata ( s , pb , " \251 cpy " , " copyright " , 1 ) ;
2010-01-04 03:52:40 +01:00
mov_write_string_metadata ( s , pb , " \251 grp " , " grouping " , 1 ) ;
mov_write_string_metadata ( s , pb , " \251 lyr " , " lyrics " , 1 ) ;
2009-11-23 09:47:44 +01:00
mov_write_string_metadata ( s , pb , " desc " , " description " , 1 ) ;
mov_write_string_metadata ( s , pb , " ldes " , " synopsis " , 1 ) ;
mov_write_string_metadata ( s , pb , " tvsh " , " show " , 1 ) ;
mov_write_string_metadata ( s , pb , " tven " , " episode_id " , 1 ) ;
mov_write_string_metadata ( s , pb , " tvnn " , " network " , 1 ) ;
2012-08-21 03:21:39 +02:00
mov_write_int8_metadata ( s , pb , " tves " , " episode_sort " , 4 ) ;
mov_write_int8_metadata ( s , pb , " tvsn " , " season_number " , 4 ) ;
mov_write_int8_metadata ( s , pb , " stik " , " media_type " , 1 ) ;
mov_write_int8_metadata ( s , pb , " hdvd " , " hd_video " , 1 ) ;
mov_write_int8_metadata ( s , pb , " pgap " , " gapless_playback " , 1 ) ;
2004-08-14 16:05:48 +02:00
mov_write_trkn_tag ( pb , mov , s ) ;
2012-08-24 21:37:47 +02:00
mov_write_tmpo_tag ( pb , s ) ;
2012-01-30 15:19:15 +01:00
return update_size ( pb , pos ) ;
2004-08-14 16:05:48 +02:00
}
/* iTunes meta data tag */
2011-02-20 11:04:12 +01:00
static int mov_write_meta_tag ( AVIOContext * pb , MOVMuxContext * mov ,
2004-08-14 16:05:48 +02:00
AVFormatContext * s )
{
int size = 0 ;
2011-03-03 20:11:45 +01:00
int64_t pos = avio_tell ( pb ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " meta " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ;
2009-02-26 14:08:22 +01:00
mov_write_itunes_hdlr_tag ( pb , mov , s ) ;
mov_write_ilst_tag ( pb , mov , s ) ;
2012-01-30 15:19:15 +01:00
size = update_size ( pb , pos ) ;
2004-08-14 16:05:48 +02:00
return size ;
}
2005-12-17 19:14:38 +01:00
2008-06-11 11:35:02 +02:00
static int utf8len ( const uint8_t * b )
{
int len = 0 ;
int val ;
while ( * b ) {
GET_UTF8 ( val , * b + + , return - 1 ; )
len + + ;
}
return len ;
}
2011-02-20 11:04:12 +01:00
static int ascii_to_wc ( AVIOContext * pb , const uint8_t * b )
2008-06-11 11:35:02 +02:00
{
int val ;
while ( * b ) {
GET_UTF8 ( val , * b + + , return - 1 ; )
2011-02-21 19:28:17 +01:00
avio_wb16 ( pb , val ) ;
2008-06-11 11:35:02 +02:00
}
2011-02-21 19:28:17 +01:00
avio_wb16 ( pb , 0x00 ) ;
2008-06-11 11:35:02 +02:00
return 0 ;
}
static uint16_t language_code ( const char * str )
{
return ( ( ( str [ 0 ] - 0x60 ) & 0x1F ) < < 10 ) + ( ( ( str [ 1 ] - 0x60 ) & 0x1F ) < < 5 ) + ( ( str [ 2 ] - 0x60 ) & 0x1F ) ;
}
2011-02-20 11:04:12 +01:00
static int mov_write_3gp_udta_tag ( AVIOContext * pb , AVFormatContext * s ,
2008-06-11 11:40:22 +02:00
const char * tag , const char * str )
{
2011-03-03 20:11:45 +01:00
int64_t pos = avio_tell ( pb ) ;
2011-05-22 12:46:29 +02:00
AVDictionaryEntry * t = av_dict_get ( s - > metadata , str , NULL , 0 ) ;
2009-02-26 14:06:49 +01:00
if ( ! t | | ! utf8len ( t - > value ) )
2008-06-11 11:40:22 +02:00
return 0 ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , tag ) ; /* type */
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* version + flags */
2008-06-11 11:40:22 +02:00
if ( ! strcmp ( tag , " yrrc " ) )
2011-02-21 19:28:17 +01:00
avio_wb16 ( pb , atoi ( t - > value ) ) ;
2008-06-11 11:40:22 +02:00
else {
2011-02-21 19:28:17 +01:00
avio_wb16 ( pb , language_code ( " eng " ) ) ; /* language */
avio_write ( pb , t - > value , strlen ( t - > value ) + 1 ) ; /* UTF8 string value */
2009-02-26 14:06:49 +01:00
if ( ! strcmp ( tag , " albm " ) & &
2011-05-22 12:46:29 +02:00
( t = av_dict_get ( s - > metadata , " track " , NULL , 0 ) ) )
2011-02-21 19:28:17 +01:00
avio_w8 ( pb , atoi ( t - > value ) ) ;
2008-06-11 11:40:22 +02:00
}
2012-01-30 15:19:15 +01:00
return update_size ( pb , pos ) ;
2008-06-11 11:40:22 +02:00
}
2011-02-20 11:04:12 +01:00
static int mov_write_chpl_tag ( AVIOContext * pb , AVFormatContext * s )
2010-04-21 08:36:05 +02:00
{
2011-03-03 20:11:45 +01:00
int64_t pos = avio_tell ( pb ) ;
2010-04-21 08:36:05 +02:00
int i , nb_chapters = FFMIN ( s - > nb_chapters , 255 ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; // size
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " chpl " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0x01000000 ) ; // version + flags
avio_wb32 ( pb , 0 ) ; // unknown
avio_w8 ( pb , nb_chapters ) ;
2010-04-21 08:36:05 +02:00
for ( i = 0 ; i < nb_chapters ; i + + ) {
AVChapter * c = s - > chapters [ i ] ;
2011-05-22 12:46:29 +02:00
AVDictionaryEntry * t ;
2011-02-21 19:28:17 +01:00
avio_wb64 ( pb , av_rescale_q ( c - > start , c - > time_base , ( AVRational ) { 1 , 10000000 } ) ) ;
2010-04-21 08:36:05 +02:00
2011-05-22 12:46:29 +02:00
if ( ( t = av_dict_get ( c - > metadata , " title " , NULL , 0 ) ) ) {
2010-04-21 08:36:05 +02:00
int len = FFMIN ( strlen ( t - > value ) , 255 ) ;
2011-02-21 19:28:17 +01:00
avio_w8 ( pb , len ) ;
avio_write ( pb , t - > value , len ) ;
2010-04-21 08:36:05 +02:00
} else
2011-02-21 19:28:17 +01:00
avio_w8 ( pb , 0 ) ;
2010-04-21 08:36:05 +02:00
}
2012-01-30 15:19:15 +01:00
return update_size ( pb , pos ) ;
2010-04-21 08:36:05 +02:00
}
2011-02-20 11:04:12 +01:00
static int mov_write_udta_tag ( AVIOContext * pb , MOVMuxContext * mov ,
2004-02-14 20:08:09 +01:00
AVFormatContext * s )
{
2011-02-20 11:04:12 +01:00
AVIOContext * pb_buf ;
2009-02-26 14:06:49 +01:00
int i , ret , size ;
uint8_t * buf ;
2007-10-24 16:20:15 +02:00
2008-06-09 22:13:44 +02:00
for ( i = 0 ; i < s - > nb_streams ; i + + )
if ( mov - > tracks [ i ] . enc - > flags & CODEC_FLAG_BITEXACT ) {
2009-02-26 14:06:49 +01:00
return 0 ;
2008-06-09 22:13:44 +02:00
}
2011-03-17 08:13:34 +01:00
ret = avio_open_dyn_buf ( & pb_buf ) ;
2009-02-26 14:06:49 +01:00
if ( ret < 0 )
return ret ;
2004-02-14 20:08:09 +01:00
2012-01-14 14:10:17 +01:00
if ( mov - > mode & MODE_3GP ) {
mov_write_3gp_udta_tag ( pb_buf , s , " perf " , " artist " ) ;
mov_write_3gp_udta_tag ( pb_buf , s , " titl " , " title " ) ;
mov_write_3gp_udta_tag ( pb_buf , s , " auth " , " author " ) ;
mov_write_3gp_udta_tag ( pb_buf , s , " gnre " , " genre " ) ;
mov_write_3gp_udta_tag ( pb_buf , s , " dscp " , " comment " ) ;
mov_write_3gp_udta_tag ( pb_buf , s , " albm " , " album " ) ;
mov_write_3gp_udta_tag ( pb_buf , s , " cprt " , " copyright " ) ;
mov_write_3gp_udta_tag ( pb_buf , s , " yrrc " , " date " ) ;
} else if ( mov - > mode = = MODE_MOV ) { // the title field breaks gtkpod with mp4 and my suspicion is that stuff is not valid in mp4
mov_write_string_metadata ( s , pb_buf , " \251 ART " , " artist " , 0 ) ;
mov_write_string_metadata ( s , pb_buf , " \251 nam " , " title " , 0 ) ;
mov_write_string_metadata ( s , pb_buf , " \251 aut " , " author " , 0 ) ;
mov_write_string_metadata ( s , pb_buf , " \251 alb " , " album " , 0 ) ;
mov_write_string_metadata ( s , pb_buf , " \251 day " , " date " , 0 ) ;
mov_write_string_metadata ( s , pb_buf , " \251 swr " , " encoder " , 0 ) ;
2012-07-09 11:40:12 +02:00
// currently ignored by mov.c
2012-01-14 14:10:17 +01:00
mov_write_string_metadata ( s , pb_buf , " \251 des " , " comment " , 0 ) ;
2012-07-09 11:40:12 +02:00
// add support for libquicktime, this atom is also actually read by mov.c
mov_write_string_metadata ( s , pb_buf , " \251 cmt " , " comment " , 0 ) ;
2012-01-14 14:10:17 +01:00
mov_write_string_metadata ( s , pb_buf , " \251 gen " , " genre " , 0 ) ;
mov_write_string_metadata ( s , pb_buf , " \251 cpy " , " copyright " , 0 ) ;
} else {
/* iTunes meta data */
mov_write_meta_tag ( pb_buf , mov , s ) ;
}
2009-02-26 14:06:49 +01:00
2012-01-14 14:10:17 +01:00
if ( s - > nb_chapters )
mov_write_chpl_tag ( pb_buf , s ) ;
2010-04-21 08:36:05 +02:00
2011-03-17 08:16:07 +01:00
if ( ( size = avio_close_dyn_buf ( pb_buf , & buf ) ) > 0 ) {
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , size + 8 ) ;
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " udta " ) ;
2011-02-21 19:28:17 +01:00
avio_write ( pb , buf , size ) ;
2007-10-24 16:20:15 +02:00
}
2010-07-20 07:23:28 +02:00
av_free ( buf ) ;
2007-10-24 16:20:15 +02:00
return 0 ;
2004-02-14 20:08:09 +01:00
}
2011-02-20 11:04:12 +01:00
static void mov_write_psp_udta_tag ( AVIOContext * pb ,
2008-06-11 11:02:01 +02:00
const char * str , const char * lang , int type )
{
int len = utf8len ( str ) + 1 ;
if ( len < = 0 )
2008-06-11 11:06:27 +02:00
return ;
2011-02-21 19:28:17 +01:00
avio_wb16 ( pb , len * 2 + 10 ) ; /* size */
avio_wb32 ( pb , type ) ; /* type */
avio_wb16 ( pb , language_code ( lang ) ) ; /* language */
avio_wb16 ( pb , 0x01 ) ; /* ? */
2008-06-11 11:02:01 +02:00
ascii_to_wc ( pb , str ) ;
}
2011-02-20 11:04:12 +01:00
static int mov_write_uuidusmt_tag ( AVIOContext * pb , AVFormatContext * s )
2006-01-24 09:03:42 +01:00
{
2011-05-22 12:46:29 +02:00
AVDictionaryEntry * title = av_dict_get ( s - > metadata , " title " , NULL , 0 ) ;
2008-10-03 12:16:29 +02:00
int64_t pos , pos2 ;
2006-01-24 09:03:42 +01:00
2009-02-26 14:06:49 +01:00
if ( title ) {
2011-03-03 20:11:45 +01:00
pos = avio_tell ( pb ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* size placeholder*/
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " uuid " ) ;
ffio_wfourcc ( pb , " USMT " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0x21d24fce ) ; /* 96 bit UUID */
avio_wb32 ( pb , 0xbb88695c ) ;
avio_wb32 ( pb , 0xfac9c740 ) ;
2006-01-24 09:03:42 +01:00
2011-03-03 20:11:45 +01:00
pos2 = avio_tell ( pb ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* size placeholder*/
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " MTDT " ) ;
2011-02-21 19:28:17 +01:00
avio_wb16 ( pb , 4 ) ;
2006-01-24 09:03:42 +01:00
2006-05-19 03:53:59 +02:00
// ?
2011-02-21 19:28:17 +01:00
avio_wb16 ( pb , 0x0C ) ; /* size */
avio_wb32 ( pb , 0x0B ) ; /* type */
avio_wb16 ( pb , language_code ( " und " ) ) ; /* language */
avio_wb16 ( pb , 0x0 ) ; /* ? */
avio_wb16 ( pb , 0x021C ) ; /* data */
2006-05-19 03:53:59 +02:00
2008-06-11 11:06:27 +02:00
mov_write_psp_udta_tag ( pb , LIBAVCODEC_IDENT , " eng " , 0x04 ) ;
2009-02-26 14:06:49 +01:00
mov_write_psp_udta_tag ( pb , title - > value , " eng " , 0x01 ) ;
2008-06-11 11:06:27 +02:00
mov_write_psp_udta_tag ( pb , " 2006/04/01 11:11:11 " , " und " , 0x03 ) ;
2012-01-30 15:19:15 +01:00
update_size ( pb , pos2 ) ;
return update_size ( pb , pos ) ;
2006-01-24 09:03:42 +01:00
}
2008-06-11 11:06:27 +02:00
return 0 ;
2006-01-24 09:03:42 +01:00
}
2011-11-29 04:03:22 +01:00
static void build_chunks ( MOVTrack * trk )
{
int i ;
MOVIentry * chunk = & trk - > cluster [ 0 ] ;
2011-11-29 16:50:25 +01:00
uint64_t chunkSize = chunk - > size ;
2011-11-29 04:03:22 +01:00
chunk - > chunkNum = 1 ;
2012-02-23 02:33:21 +01:00
if ( trk - > chunkCount )
return ;
2011-11-29 04:03:22 +01:00
trk - > chunkCount = 1 ;
for ( i = 1 ; i < trk - > entry ; i + + ) {
2012-01-23 12:59:37 +01:00
if ( chunk - > pos + chunkSize = = trk - > cluster [ i ] . pos & &
2012-01-23 20:52:37 +01:00
chunkSize + trk - > cluster [ i ] . size < ( 1 < < 20 ) ) {
2011-11-29 16:50:25 +01:00
chunkSize + = trk - > cluster [ i ] . size ;
2012-01-31 01:14:58 +01:00
chunk - > samples_in_chunk + = trk - > cluster [ i ] . entries ;
2011-11-29 04:03:22 +01:00
} else {
trk - > cluster [ i ] . chunkNum = chunk - > chunkNum + 1 ;
chunk = & trk - > cluster [ i ] ;
2011-11-29 16:50:25 +01:00
chunkSize = chunk - > size ;
2011-11-29 04:03:22 +01:00
trk - > chunkCount + + ;
}
}
}
2011-02-20 11:04:12 +01:00
static int mov_write_moov_tag ( AVIOContext * pb , MOVMuxContext * mov ,
2004-02-14 20:08:09 +01:00
AVFormatContext * s )
2003-08-26 22:23:13 +02:00
{
2006-01-23 15:12:03 +01:00
int i ;
2011-03-03 20:11:45 +01:00
int64_t pos = avio_tell ( pb ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* size placeholder*/
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " moov " ) ;
2003-08-26 22:23:13 +02:00
2006-06-25 02:10:52 +02:00
for ( i = 0 ; i < mov - > nb_streams ; i + + ) {
2012-01-05 12:57:05 +01:00
if ( mov - > tracks [ i ] . entry < = 0 & & ! ( mov - > flags & FF_MOV_FLAG_FRAGMENT ) )
continue ;
2003-11-03 22:51:07 +01:00
mov - > tracks [ i ] . time = mov - > time ;
2012-01-30 15:19:15 +01:00
mov - > tracks [ i ] . track_id = i + 1 ;
2011-11-29 04:03:22 +01:00
2012-02-12 12:05:43 +01:00
if ( mov - > tracks [ i ] . entry )
build_chunks ( & mov - > tracks [ i ] ) ;
2003-08-26 22:23:13 +02:00
}
2010-05-05 10:41:10 +02:00
if ( mov - > chapter_track )
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
mov - > tracks [ i ] . tref_tag = MKTAG ( ' c ' , ' h ' , ' a ' , ' p ' ) ;
2012-01-30 15:19:15 +01:00
mov - > tracks [ i ] . tref_id = mov - > tracks [ mov - > chapter_track ] . track_id ;
2010-05-05 10:41:10 +02:00
}
2010-05-18 21:47:24 +02:00
for ( i = 0 ; i < mov - > nb_streams ; i + + ) {
if ( mov - > tracks [ i ] . tag = = MKTAG ( ' r ' , ' t ' , ' p ' , ' ' ) ) {
mov - > tracks [ i ] . tref_tag = MKTAG ( ' h ' , ' i ' , ' n ' , ' t ' ) ;
mov - > tracks [ i ] . tref_id =
2012-01-30 15:19:15 +01:00
mov - > tracks [ mov - > tracks [ i ] . src_track ] . track_id ;
2010-05-18 21:47:24 +02:00
}
}
2012-03-05 08:51:08 +01:00
for ( i = 0 ; i < mov - > nb_streams ; i + + ) {
if ( mov - > tracks [ i ] . tag = = MKTAG ( ' t ' , ' m ' , ' c ' , ' d ' ) ) {
int src_trk = mov - > tracks [ i ] . src_track ;
mov - > tracks [ src_trk ] . tref_tag = mov - > tracks [ i ] . tag ;
mov - > tracks [ src_trk ] . tref_id = mov - > tracks [ i ] . track_id ;
mov - > tracks [ i ] . track_duration = mov - > tracks [ src_trk ] . track_duration ;
}
}
2010-05-05 10:41:10 +02:00
2003-09-10 01:03:04 +02:00
mov_write_mvhd_tag ( pb , mov ) ;
2011-10-04 20:44:25 +02:00
if ( mov - > mode ! = MODE_MOV & & ! mov - > iods_skip )
mov_write_iods_tag ( pb , mov ) ;
2006-06-25 02:10:52 +02:00
for ( i = 0 ; i < mov - > nb_streams ; i + + ) {
2012-01-05 12:57:05 +01:00
if ( mov - > tracks [ i ] . entry > 0 | | mov - > flags & FF_MOV_FLAG_FRAGMENT ) {
2011-12-06 16:15:35 +01:00
mov_write_trak_tag ( pb , mov , & ( mov - > tracks [ i ] ) , i < s - > nb_streams ? s - > streams [ i ] : NULL ) ;
2003-08-26 22:23:13 +02:00
}
}
2012-01-05 12:57:05 +01:00
if ( mov - > flags & FF_MOV_FLAG_FRAGMENT )
mov_write_mvex_tag ( pb , mov ) ; /* QuickTime requires trak to precede this */
2011-12-06 16:15:35 +01:00
2006-01-24 09:03:42 +01:00
if ( mov - > mode = = MODE_PSP )
mov_write_uuidusmt_tag ( pb , s ) ;
2008-06-11 11:40:22 +02:00
else
2006-11-01 22:09:14 +01:00
mov_write_udta_tag ( pb , mov , s ) ;
2004-02-14 20:08:09 +01:00
2012-01-30 15:19:15 +01:00
return update_size ( pb , pos ) ;
2003-08-26 22:23:13 +02:00
}
2012-01-20 12:02:18 +01:00
static void param_write_int ( AVIOContext * pb , const char * name , int value )
{
avio_printf ( pb , " <param name= \" %s \" value= \" %d \" valuetype= \" data \" /> \n " , name , value ) ;
}
static void param_write_string ( AVIOContext * pb , const char * name , const char * value )
{
avio_printf ( pb , " <param name= \" %s \" value= \" %s \" valuetype= \" data \" /> \n " , name , value ) ;
}
static void param_write_hex ( AVIOContext * pb , const char * name , const uint8_t * value , int len )
{
char buf [ 150 ] ;
len = FFMIN ( sizeof ( buf ) / 2 - 1 , len ) ;
ff_data_to_hex ( buf , value , len , 0 ) ;
buf [ 2 * len ] = ' \0 ' ;
avio_printf ( pb , " <param name= \" %s \" value= \" %s \" valuetype= \" data \" /> \n " , name , buf ) ;
}
static int mov_write_isml_manifest ( AVIOContext * pb , MOVMuxContext * mov )
{
int64_t pos = avio_tell ( pb ) ;
int i ;
const uint8_t uuid [ ] = {
0xa5 , 0xd4 , 0x0b , 0x30 , 0xe8 , 0x14 , 0x11 , 0xdd ,
0xba , 0x2f , 0x08 , 0x00 , 0x20 , 0x0c , 0x9a , 0x66
} ;
avio_wb32 ( pb , 0 ) ;
ffio_wfourcc ( pb , " uuid " ) ;
avio_write ( pb , uuid , sizeof ( uuid ) ) ;
avio_wb32 ( pb , 0 ) ;
avio_printf ( pb , " <?xml version= \" 1.0 \" encoding= \" utf-8 \" ?> \n " ) ;
avio_printf ( pb , " <smil xmlns= \" http://www.w3.org/2001/SMIL20/Language \" > \n " ) ;
avio_printf ( pb , " <head> \n " ) ;
avio_printf ( pb , " <meta name= \" creator \" content= \" %s \" /> \n " ,
LIBAVFORMAT_IDENT ) ;
avio_printf ( pb , " </head> \n " ) ;
avio_printf ( pb , " <body> \n " ) ;
avio_printf ( pb , " <switch> \n " ) ;
for ( i = 0 ; i < mov - > nb_streams ; i + + ) {
MOVTrack * track = & mov - > tracks [ i ] ;
const char * type ;
2012-01-30 15:19:15 +01:00
/* track->track_id is initialized in write_moov, and thus isn't known
2012-01-20 12:02:18 +01:00
* here yet */
int track_id = i + 1 ;
if ( track - > enc - > codec_type = = AVMEDIA_TYPE_VIDEO ) {
type = " video " ;
} else if ( track - > enc - > codec_type = = AVMEDIA_TYPE_AUDIO ) {
type = " audio " ;
} else {
continue ;
}
avio_printf ( pb , " <%s systemBitrate= \" %d \" > \n " , type ,
track - > enc - > bit_rate ) ;
param_write_int ( pb , " systemBitrate " , track - > enc - > bit_rate ) ;
param_write_int ( pb , " trackID " , track_id ) ;
if ( track - > enc - > codec_type = = AVMEDIA_TYPE_VIDEO ) {
2012-08-05 11:11:04 +02:00
if ( track - > enc - > codec_id = = AV_CODEC_ID_H264 ) {
2012-03-22 12:25:58 +01:00
uint8_t * ptr ;
int size = track - > enc - > extradata_size ;
if ( ! ff_avc_write_annexb_extradata ( track - > enc - > extradata , & ptr ,
& size ) ) {
param_write_hex ( pb , " CodecPrivateData " ,
ptr ? ptr : track - > enc - > extradata ,
size ) ;
av_free ( ptr ) ;
}
2012-01-20 12:02:18 +01:00
param_write_string ( pb , " FourCC " , " H264 " ) ;
2012-08-05 11:11:04 +02:00
} else if ( track - > enc - > codec_id = = AV_CODEC_ID_VC1 ) {
2012-01-20 12:02:18 +01:00
param_write_string ( pb , " FourCC " , " WVC1 " ) ;
2012-03-22 12:31:31 +01:00
param_write_hex ( pb , " CodecPrivateData " , track - > enc - > extradata ,
track - > enc - > extradata_size ) ;
2012-01-20 12:02:18 +01:00
}
param_write_int ( pb , " MaxWidth " , track - > enc - > width ) ;
param_write_int ( pb , " MaxHeight " , track - > enc - > height ) ;
param_write_int ( pb , " DisplayWidth " , track - > enc - > width ) ;
param_write_int ( pb , " DisplayHeight " , track - > enc - > height ) ;
} else {
2012-08-05 11:11:04 +02:00
if ( track - > enc - > codec_id = = AV_CODEC_ID_AAC ) {
2012-01-20 12:02:18 +01:00
param_write_string ( pb , " FourCC " , " AACL " ) ;
2012-08-05 11:11:04 +02:00
} else if ( track - > enc - > codec_id = = AV_CODEC_ID_WMAPRO ) {
2012-01-20 12:02:18 +01:00
param_write_string ( pb , " FourCC " , " WMAP " ) ;
}
param_write_hex ( pb , " CodecPrivateData " , track - > enc - > extradata ,
track - > enc - > extradata_size ) ;
param_write_int ( pb , " AudioTag " , ff_codec_get_tag ( ff_codec_wav_tags ,
track - > enc - > codec_id ) ) ;
param_write_int ( pb , " Channels " , track - > enc - > channels ) ;
param_write_int ( pb , " SamplingRate " , track - > enc - > sample_rate ) ;
param_write_int ( pb , " BitsPerSample " , 16 ) ;
param_write_int ( pb , " PacketSize " , track - > enc - > block_align ?
track - > enc - > block_align : 4 ) ;
}
avio_printf ( pb , " </%s> \n " , type ) ;
}
avio_printf ( pb , " </switch> \n " ) ;
avio_printf ( pb , " </body> \n " ) ;
avio_printf ( pb , " </smil> \n " ) ;
2012-01-30 15:19:15 +01:00
return update_size ( pb , pos ) ;
2012-01-20 12:02:18 +01:00
}
2011-12-06 16:15:35 +01:00
static int mov_write_mfhd_tag ( AVIOContext * pb , MOVMuxContext * mov )
{
2012-01-05 12:57:05 +01:00
avio_wb32 ( pb , 16 ) ;
2011-12-06 16:15:35 +01:00
ffio_wfourcc ( pb , " mfhd " ) ;
avio_wb32 ( pb , 0 ) ;
2012-01-05 12:57:05 +01:00
avio_wb32 ( pb , mov - > fragments ) ;
return 0 ;
}
static int mov_write_tfhd_tag ( AVIOContext * pb , MOVTrack * track ,
int64_t moof_offset )
{
int64_t pos = avio_tell ( pb ) ;
2012-02-16 20:48:30 +01:00
uint32_t flags = MOV_TFHD_DEFAULT_SIZE | MOV_TFHD_DEFAULT_DURATION |
MOV_TFHD_BASE_DATA_OFFSET ;
2012-01-05 12:57:05 +01:00
if ( ! track - > entry ) {
2012-02-16 20:48:30 +01:00
flags | = MOV_TFHD_DURATION_IS_EMPTY ;
2012-01-05 12:57:05 +01:00
} else {
2012-02-16 20:48:30 +01:00
flags | = MOV_TFHD_DEFAULT_FLAGS ;
2012-01-05 12:57:05 +01:00
}
2011-12-06 16:15:35 +01:00
2012-01-31 14:23:26 +01:00
/* Don't set a default sample size, the silverlight player refuses
* to play files with that set . Don ' t set a default sample duration ,
* WMP freaks out if it is set . */
2012-01-09 16:58:26 +01:00
if ( track - > mode = = MODE_ISM )
2012-02-16 20:48:30 +01:00
flags & = ~ ( MOV_TFHD_DEFAULT_SIZE | MOV_TFHD_DEFAULT_DURATION ) ;
2012-01-09 16:58:26 +01:00
2012-01-05 12:57:05 +01:00
avio_wb32 ( pb , 0 ) ; /* size placeholder */
ffio_wfourcc ( pb , " tfhd " ) ;
avio_w8 ( pb , 0 ) ; /* version */
avio_wb24 ( pb , flags ) ;
2012-01-30 15:19:15 +01:00
avio_wb32 ( pb , track - > track_id ) ; /* track-id */
2012-02-16 20:48:30 +01:00
if ( flags & MOV_TFHD_BASE_DATA_OFFSET )
2012-01-05 12:57:05 +01:00
avio_wb64 ( pb , moof_offset ) ;
2012-02-16 20:48:30 +01:00
if ( flags & MOV_TFHD_DEFAULT_DURATION ) {
2012-02-26 23:21:07 +01:00
track - > default_duration = get_cluster_duration ( track , 0 ) ;
2012-01-05 12:57:05 +01:00
avio_wb32 ( pb , track - > default_duration ) ;
}
2012-02-16 20:48:30 +01:00
if ( flags & MOV_TFHD_DEFAULT_SIZE ) {
2012-01-05 12:57:05 +01:00
track - > default_size = track - > entry ? track - > cluster [ 0 ] . size : 1 ;
avio_wb32 ( pb , track - > default_size ) ;
} else
track - > default_size = - 1 ;
2012-02-16 20:48:30 +01:00
if ( flags & MOV_TFHD_DEFAULT_FLAGS ) {
2012-01-05 12:57:05 +01:00
track - > default_sample_flags =
track - > enc - > codec_type = = AVMEDIA_TYPE_VIDEO ?
2012-02-16 21:12:12 +01:00
( MOV_FRAG_SAMPLE_FLAG_DEPENDS_YES | MOV_FRAG_SAMPLE_FLAG_IS_NON_SYNC ) :
MOV_FRAG_SAMPLE_FLAG_DEPENDS_NO ;
2012-01-05 12:57:05 +01:00
avio_wb32 ( pb , track - > default_sample_flags ) ;
}
2012-01-30 15:19:15 +01:00
return update_size ( pb , pos ) ;
2011-12-06 16:15:35 +01:00
}
2012-01-05 12:57:05 +01:00
static uint32_t get_sample_flags ( MOVTrack * track , MOVIentry * entry )
2011-12-06 16:15:35 +01:00
{
2012-02-16 21:12:12 +01:00
return entry - > flags & MOV_SYNC_SAMPLE ? MOV_FRAG_SAMPLE_FLAG_DEPENDS_NO :
( MOV_FRAG_SAMPLE_FLAG_DEPENDS_YES | MOV_FRAG_SAMPLE_FLAG_IS_NON_SYNC ) ;
2012-01-05 12:57:05 +01:00
}
static int mov_write_trun_tag ( AVIOContext * pb , MOVTrack * track )
{
int64_t pos = avio_tell ( pb ) ;
2012-02-16 20:58:09 +01:00
uint32_t flags = MOV_TRUN_DATA_OFFSET ;
2011-12-06 16:15:35 +01:00
int i ;
2012-01-05 12:57:05 +01:00
for ( i = 0 ; i < track - > entry ; i + + ) {
2012-02-26 23:17:13 +01:00
if ( get_cluster_duration ( track , i ) ! = track - > default_duration )
2012-02-16 20:58:09 +01:00
flags | = MOV_TRUN_SAMPLE_DURATION ;
2012-01-05 12:57:05 +01:00
if ( track - > cluster [ i ] . size ! = track - > default_size )
2012-02-16 20:58:09 +01:00
flags | = MOV_TRUN_SAMPLE_SIZE ;
2012-01-05 12:57:05 +01:00
if ( i > 0 & & get_sample_flags ( track , & track - > cluster [ i ] ) ! = track - > default_sample_flags )
2012-02-16 20:58:09 +01:00
flags | = MOV_TRUN_SAMPLE_FLAGS ;
2012-01-05 12:57:05 +01:00
}
2012-02-16 20:58:09 +01:00
if ( ! ( flags & MOV_TRUN_SAMPLE_FLAGS ) )
flags | = MOV_TRUN_FIRST_SAMPLE_FLAGS ;
2012-01-05 12:57:05 +01:00
if ( track - > flags & MOV_TRACK_CTTS )
2012-02-16 20:58:09 +01:00
flags | = MOV_TRUN_SAMPLE_CTS ;
2012-01-05 12:57:05 +01:00
avio_wb32 ( pb , 0 ) ; /* size placeholder */
ffio_wfourcc ( pb , " trun " ) ;
avio_w8 ( pb , 0 ) ; /* version */
avio_wb24 ( pb , flags ) ;
avio_wb32 ( pb , track - > entry ) ; /* sample count */
track - > moof_size_offset = avio_tell ( pb ) ;
avio_wb32 ( pb , 0 ) ; /* data offset */
2012-02-16 20:58:09 +01:00
if ( flags & MOV_TRUN_FIRST_SAMPLE_FLAGS )
2012-01-05 12:57:05 +01:00
avio_wb32 ( pb , get_sample_flags ( track , & track - > cluster [ 0 ] ) ) ;
for ( i = 0 ; i < track - > entry ; i + + ) {
2012-02-16 20:58:09 +01:00
if ( flags & MOV_TRUN_SAMPLE_DURATION )
2012-02-26 23:17:13 +01:00
avio_wb32 ( pb , get_cluster_duration ( track , i ) ) ;
2012-02-16 20:58:09 +01:00
if ( flags & MOV_TRUN_SAMPLE_SIZE )
2012-01-05 12:57:05 +01:00
avio_wb32 ( pb , track - > cluster [ i ] . size ) ;
2012-02-16 20:58:09 +01:00
if ( flags & MOV_TRUN_SAMPLE_FLAGS )
2012-01-05 12:57:05 +01:00
avio_wb32 ( pb , get_sample_flags ( track , & track - > cluster [ i ] ) ) ;
2012-02-16 20:58:09 +01:00
if ( flags & MOV_TRUN_SAMPLE_CTS )
2012-01-05 12:57:05 +01:00
avio_wb32 ( pb , track - > cluster [ i ] . cts ) ;
}
2012-01-30 15:19:15 +01:00
return update_size ( pb , pos ) ;
2012-01-05 12:57:05 +01:00
}
2012-01-09 16:58:26 +01:00
static int mov_write_tfxd_tag ( AVIOContext * pb , MOVTrack * track )
{
2011-12-06 16:15:35 +01:00
int64_t pos = avio_tell ( pb ) ;
2012-01-09 16:58:26 +01:00
const uint8_t uuid [ ] = {
0x6d , 0x1d , 0x9b , 0x05 , 0x42 , 0xd5 , 0x44 , 0xe6 ,
0x80 , 0xe2 , 0x14 , 0x1d , 0xaf , 0xf7 , 0x57 , 0xb2
} ;
avio_wb32 ( pb , 0 ) ; /* size placeholder */
ffio_wfourcc ( pb , " uuid " ) ;
avio_write ( pb , uuid , sizeof ( uuid ) ) ;
avio_w8 ( pb , 1 ) ;
avio_wb24 ( pb , 0 ) ;
avio_wb64 ( pb , track - > frag_start ) ;
2012-01-30 15:19:15 +01:00
avio_wb64 ( pb , track - > start_dts + track - > track_duration -
2012-01-09 16:58:26 +01:00
track - > cluster [ 0 ] . dts ) ;
2012-01-30 15:19:15 +01:00
return update_size ( pb , pos ) ;
2012-01-09 16:58:26 +01:00
}
static int mov_write_tfrf_tag ( AVIOContext * pb , MOVMuxContext * mov ,
MOVTrack * track , int entry )
{
int n = track - > nb_frag_info - 1 - entry , i ;
int size = 8 + 16 + 4 + 1 + 16 * n ;
const uint8_t uuid [ ] = {
0xd4 , 0x80 , 0x7e , 0xf2 , 0xca , 0x39 , 0x46 , 0x95 ,
0x8e , 0x54 , 0x26 , 0xcb , 0x9e , 0x46 , 0xa7 , 0x9f
} ;
if ( entry < 0 )
return 0 ;
avio_seek ( pb , track - > frag_info [ entry ] . tfrf_offset , SEEK_SET ) ;
avio_wb32 ( pb , size ) ;
ffio_wfourcc ( pb , " uuid " ) ;
avio_write ( pb , uuid , sizeof ( uuid ) ) ;
avio_w8 ( pb , 1 ) ;
avio_wb24 ( pb , 0 ) ;
avio_w8 ( pb , n ) ;
for ( i = 0 ; i < n ; i + + ) {
int index = entry + 1 + i ;
avio_wb64 ( pb , track - > frag_info [ index ] . time ) ;
avio_wb64 ( pb , track - > frag_info [ index ] . duration ) ;
}
if ( n < mov - > ism_lookahead ) {
int free_size = 16 * ( mov - > ism_lookahead - n ) ;
avio_wb32 ( pb , free_size ) ;
ffio_wfourcc ( pb , " free " ) ;
for ( i = 0 ; i < free_size - 8 ; i + + )
avio_w8 ( pb , 0 ) ;
}
return 0 ;
}
static int mov_write_tfrf_tags ( AVIOContext * pb , MOVMuxContext * mov ,
MOVTrack * track )
{
int64_t pos = avio_tell ( pb ) ;
int i ;
for ( i = 0 ; i < mov - > ism_lookahead ; i + + ) {
/* Update the tfrf tag for the last ism_lookahead fragments,
* nb_frag_info - 1 is the next fragment to be written . */
mov_write_tfrf_tag ( pb , mov , track , track - > nb_frag_info - 2 - i ) ;
}
avio_seek ( pb , pos , SEEK_SET ) ;
return 0 ;
}
static int mov_write_traf_tag ( AVIOContext * pb , MOVMuxContext * mov ,
MOVTrack * track , int64_t moof_offset )
2012-01-05 12:57:05 +01:00
{
int64_t pos = avio_tell ( pb ) ;
avio_wb32 ( pb , 0 ) ; /* size placeholder */
ffio_wfourcc ( pb , " traf " ) ;
mov_write_tfhd_tag ( pb , track , moof_offset ) ;
mov_write_trun_tag ( pb , track ) ;
2012-01-09 16:58:26 +01:00
if ( mov - > mode = = MODE_ISM ) {
mov_write_tfxd_tag ( pb , track ) ;
if ( mov - > ism_lookahead ) {
int i , size = 16 + 4 + 1 + 16 * mov - > ism_lookahead ;
track - > tfrf_offset = avio_tell ( pb ) ;
avio_wb32 ( pb , 8 + size ) ;
ffio_wfourcc ( pb , " free " ) ;
for ( i = 0 ; i < size ; i + + )
avio_w8 ( pb , 0 ) ;
}
}
2012-01-05 12:57:05 +01:00
2012-01-30 15:19:15 +01:00
return update_size ( pb , pos ) ;
2012-01-05 12:57:05 +01:00
}
static int mov_write_moof_tag ( AVIOContext * pb , MOVMuxContext * mov , int tracks )
{
int64_t pos = avio_tell ( pb ) , end ;
int i , moof_size ;
avio_wb32 ( pb , 0 ) ; /* size placeholder */
2011-12-06 16:15:35 +01:00
ffio_wfourcc ( pb , " moof " ) ;
mov_write_mfhd_tag ( pb , mov ) ;
2012-01-05 12:57:05 +01:00
for ( i = 0 ; i < mov - > nb_streams ; i + + ) {
MOVTrack * track = & mov - > tracks [ i ] ;
if ( tracks > = 0 & & i ! = tracks )
continue ;
if ( ! track - > entry )
continue ;
2012-01-09 16:58:26 +01:00
mov_write_traf_tag ( pb , mov , track , pos ) ;
2012-01-05 12:57:05 +01:00
}
end = avio_tell ( pb ) ;
moof_size = end - pos ;
for ( i = 0 ; i < mov - > nb_streams ; i + + ) {
MOVTrack * track = & mov - > tracks [ i ] ;
if ( tracks > = 0 & & i ! = tracks )
continue ;
if ( ! track - > entry )
continue ;
avio_seek ( pb , mov - > tracks [ i ] . moof_size_offset , SEEK_SET ) ;
avio_wb32 ( pb , moof_size + 8 + mov - > tracks [ i ] . data_offset ) ;
2011-12-06 16:15:35 +01:00
}
2012-01-05 12:57:05 +01:00
avio_seek ( pb , end , SEEK_SET ) ;
2012-01-30 15:19:15 +01:00
return update_size ( pb , pos ) ;
2012-01-05 12:57:05 +01:00
}
static int mov_write_tfra_tag ( AVIOContext * pb , MOVTrack * track )
{
int64_t pos = avio_tell ( pb ) ;
int i ;
avio_wb32 ( pb , 0 ) ; /* size placeholder */
ffio_wfourcc ( pb , " tfra " ) ;
avio_w8 ( pb , 1 ) ; /* version */
avio_wb24 ( pb , 0 ) ;
2012-01-30 15:19:15 +01:00
avio_wb32 ( pb , track - > track_id ) ;
2012-01-05 12:57:05 +01:00
avio_wb32 ( pb , 0 ) ; /* length of traf/trun/sample num */
avio_wb32 ( pb , track - > nb_frag_info ) ;
for ( i = 0 ; i < track - > nb_frag_info ; i + + ) {
avio_wb64 ( pb , track - > frag_info [ i ] . time ) ;
avio_wb64 ( pb , track - > frag_info [ i ] . offset ) ;
avio_w8 ( pb , 1 ) ; /* traf number */
avio_w8 ( pb , 1 ) ; /* trun number */
avio_w8 ( pb , 1 ) ; /* sample number */
}
2012-01-30 15:19:15 +01:00
return update_size ( pb , pos ) ;
2012-01-05 12:57:05 +01:00
}
static int mov_write_mfra_tag ( AVIOContext * pb , MOVMuxContext * mov )
{
int64_t pos = avio_tell ( pb ) ;
int i ;
avio_wb32 ( pb , 0 ) ; /* size placeholder */
ffio_wfourcc ( pb , " mfra " ) ;
2012-01-20 12:02:18 +01:00
/* An empty mfra atom is enough to indicate to the publishing point that
* the stream has ended . */
if ( mov - > flags & FF_MOV_FLAG_ISML )
2012-01-30 15:19:15 +01:00
return update_size ( pb , pos ) ;
2012-01-05 12:57:05 +01:00
for ( i = 0 ; i < mov - > nb_streams ; i + + ) {
MOVTrack * track = & mov - > tracks [ i ] ;
if ( track - > nb_frag_info )
mov_write_tfra_tag ( pb , track ) ;
}
avio_wb32 ( pb , 16 ) ;
ffio_wfourcc ( pb , " mfro " ) ;
avio_wb32 ( pb , 0 ) ; /* version + flags */
avio_wb32 ( pb , avio_tell ( pb ) + 4 - pos ) ;
2011-12-06 16:15:35 +01:00
2012-01-30 15:19:15 +01:00
return update_size ( pb , pos ) ;
2011-12-06 16:15:35 +01:00
}
2011-02-20 11:04:12 +01:00
static int mov_write_mdat_tag ( AVIOContext * pb , MOVMuxContext * mov )
2003-08-26 22:23:13 +02:00
{
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 8 ) ; // placeholder for extended size field (64 bit)
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , mov - > mode = = MODE_MOV ? " wide " : " free " ) ;
2006-01-23 15:12:03 +01:00
2011-03-03 20:11:45 +01:00
mov - > mdat_pos = avio_tell ( pb ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* size placeholder*/
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " mdat " ) ;
2003-08-26 22:23:13 +02:00
return 0 ;
}
/* TODO: This needs to be more general */
2011-02-20 11:04:12 +01:00
static int mov_write_ftyp_tag ( AVIOContext * pb , AVFormatContext * s )
2003-08-26 22:23:13 +02:00
{
2009-02-28 17:02:29 +01:00
MOVMuxContext * mov = s - > priv_data ;
2011-03-03 20:11:45 +01:00
int64_t pos = avio_tell ( pb ) ;
2008-06-14 23:07:59 +02:00
int has_h264 = 0 , has_video = 0 ;
2008-06-15 03:38:38 +02:00
int minor = 0x200 ;
2008-06-11 11:33:35 +02:00
int i ;
2004-02-14 20:08:09 +01:00
2008-06-14 23:05:28 +02:00
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
AVStream * st = s - > streams [ i ] ;
2010-03-31 01:30:55 +02:00
if ( st - > codec - > codec_type = = AVMEDIA_TYPE_VIDEO )
2008-06-14 23:07:59 +02:00
has_video = 1 ;
2012-08-05 11:11:04 +02:00
if ( st - > codec - > codec_id = = AV_CODEC_ID_H264 )
2008-06-14 23:05:28 +02:00
has_h264 = 1 ;
}
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0 ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " ftyp " ) ;
2003-11-03 22:51:07 +01:00
2008-06-15 03:38:38 +02:00
if ( mov - > mode = = MODE_3GP ) {
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , has_h264 ? " 3gp6 " : " 3gp4 " ) ;
2008-06-15 03:38:38 +02:00
minor = has_h264 ? 0x100 : 0x200 ;
} else if ( mov - > mode & MODE_3G2 ) {
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , has_h264 ? " 3g2b " : " 3g2a " ) ;
2008-06-15 03:38:38 +02:00
minor = has_h264 ? 0x20000 : 0x10000 ;
} else if ( mov - > mode = = MODE_PSP )
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " MSNV " ) ;
2008-06-11 11:33:35 +02:00
else if ( mov - > mode = = MODE_MP4 )
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " isom " ) ;
2008-06-14 23:07:59 +02:00
else if ( mov - > mode = = MODE_IPOD )
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , has_video ? " M4V " : " M4A " ) ;
2012-01-09 16:58:26 +01:00
else if ( mov - > mode = = MODE_ISM )
ffio_wfourcc ( pb , " isml " ) ;
2012-09-17 16:16:16 +02:00
else if ( mov - > mode = = MODE_F4V )
ffio_wfourcc ( pb , " f4v " ) ;
2008-06-14 23:07:59 +02:00
else
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " qt " ) ;
2003-11-03 22:51:07 +01:00
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , minor ) ;
2003-11-03 22:51:07 +01:00
2008-06-14 23:12:51 +02:00
if ( mov - > mode = = MODE_MOV )
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " qt " ) ;
2012-01-09 16:58:26 +01:00
else if ( mov - > mode = = MODE_ISM ) {
ffio_wfourcc ( pb , " piff " ) ;
ffio_wfourcc ( pb , " iso2 " ) ;
} else {
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " isom " ) ;
ffio_wfourcc ( pb , " iso2 " ) ;
2008-06-14 23:05:28 +02:00
if ( has_h264 )
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " avc1 " ) ;
2008-06-14 23:12:51 +02:00
}
2008-06-13 14:19:01 +02:00
2008-02-06 19:57:00 +01:00
if ( mov - > mode = = MODE_3GP )
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , has_h264 ? " 3gp6 " : " 3gp4 " ) ;
2008-06-12 05:08:41 +02:00
else if ( mov - > mode & MODE_3G2 )
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , has_h264 ? " 3g2b " : " 3g2a " ) ;
2008-02-06 19:57:00 +01:00
else if ( mov - > mode = = MODE_PSP )
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " MSNV " ) ;
2008-06-11 11:33:35 +02:00
else if ( mov - > mode = = MODE_MP4 )
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " mp41 " ) ;
2012-01-30 15:19:15 +01:00
return update_size ( pb , pos ) ;
2003-08-26 22:23:13 +02:00
}
2011-02-20 11:04:12 +01:00
static void mov_write_uuidprof_tag ( AVIOContext * pb , AVFormatContext * s )
2005-01-27 15:48:15 +01:00
{
2012-01-30 15:19:15 +01:00
AVCodecContext * video_codec = s - > streams [ 0 ] - > codec ;
AVCodecContext * audio_codec = s - > streams [ 1 ] - > codec ;
int audio_rate = audio_codec - > sample_rate ;
int frame_rate = ( ( video_codec - > time_base . den ) * ( 0x10000 ) ) / ( video_codec - > time_base . num ) ;
int audio_kbitrate = audio_codec - > bit_rate / 1000 ;
int video_kbitrate = FFMIN ( video_codec - > bit_rate / 1000 , 800 - audio_kbitrate ) ;
2005-01-27 15:48:15 +01:00
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0x94 ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " uuid " ) ;
ffio_wfourcc ( pb , " PROF " ) ;
2005-01-27 15:48:15 +01:00
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0x21d24fce ) ; /* 96 bit UUID */
avio_wb32 ( pb , 0xbb88695c ) ;
avio_wb32 ( pb , 0xfac9c740 ) ;
2005-01-27 15:48:15 +01:00
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0x0 ) ; /* ? */
avio_wb32 ( pb , 0x3 ) ; /* 3 sections ? */
2005-01-27 15:48:15 +01:00
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0x14 ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " FPRF " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0x0 ) ; /* ? */
avio_wb32 ( pb , 0x0 ) ; /* ? */
avio_wb32 ( pb , 0x0 ) ; /* ? */
2005-01-27 15:48:15 +01:00
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0x2c ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " APRF " ) ; /* audio */
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0x0 ) ;
avio_wb32 ( pb , 0x2 ) ; /* TrackID */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " mp4a " ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0x20f ) ;
avio_wb32 ( pb , 0x0 ) ;
avio_wb32 ( pb , audio_kbitrate ) ;
avio_wb32 ( pb , audio_kbitrate ) ;
2012-01-30 15:19:15 +01:00
avio_wb32 ( pb , audio_rate ) ;
avio_wb32 ( pb , audio_codec - > channels ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0x34 ) ; /* size */
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " VPRF " ) ; /* video */
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0x0 ) ;
avio_wb32 ( pb , 0x1 ) ; /* TrackID */
2012-08-05 11:11:04 +02:00
if ( video_codec - > codec_id = = AV_CODEC_ID_H264 ) {
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " avc1 " ) ;
2011-02-21 19:28:17 +01:00
avio_wb16 ( pb , 0x014D ) ;
avio_wb16 ( pb , 0x0015 ) ;
2006-04-04 19:44:59 +02:00
} else {
2011-02-24 07:36:02 +01:00
ffio_wfourcc ( pb , " mp4v " ) ;
2011-02-21 19:28:17 +01:00
avio_wb16 ( pb , 0x0000 ) ;
avio_wb16 ( pb , 0x0103 ) ;
2006-04-04 19:44:59 +02:00
}
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0x0 ) ;
avio_wb32 ( pb , video_kbitrate ) ;
avio_wb32 ( pb , video_kbitrate ) ;
2012-01-30 15:19:15 +01:00
avio_wb32 ( pb , frame_rate ) ;
avio_wb32 ( pb , frame_rate ) ;
avio_wb16 ( pb , video_codec - > width ) ;
avio_wb16 ( pb , video_codec - > height ) ;
2011-02-21 19:28:17 +01:00
avio_wb32 ( pb , 0x010001 ) ; /* ? */
2005-01-27 15:48:15 +01:00
}
2009-05-15 08:11:53 +02:00
static int mov_parse_mpeg2_frame ( AVPacket * pkt , uint32_t * flags )
{
uint32_t c = - 1 ;
int i , closed_gop = 0 ;
for ( i = 0 ; i < pkt - > size - 4 ; i + + ) {
c = ( c < < 8 ) + pkt - > data [ i ] ;
if ( c = = 0x1b8 ) { // gop
closed_gop = pkt - > data [ i + 4 ] > > 6 & 0x01 ;
} else if ( c = = 0x100 ) { // pic
int temp_ref = ( pkt - > data [ i + 1 ] < < 2 ) | ( pkt - > data [ i + 2 ] > > 6 ) ;
if ( ! temp_ref | | closed_gop ) // I picture is not reordered
* flags = MOV_SYNC_SAMPLE ;
else
* flags = MOV_PARTIAL_SYNC_SAMPLE ;
break ;
}
}
return 0 ;
}
2012-01-21 01:16:34 +01:00
static void mov_parse_vc1_frame ( AVPacket * pkt , MOVTrack * trk , int fragment )
{
const uint8_t * start , * next , * end = pkt - > data + pkt - > size ;
int seq = 0 , entry = 0 ;
int key = pkt - > flags & AV_PKT_FLAG_KEY ;
start = find_next_marker ( pkt - > data , end ) ;
for ( next = start ; next < end ; start = next ) {
next = find_next_marker ( start + 4 , end ) ;
switch ( AV_RB32 ( start ) ) {
case VC1_CODE_SEQHDR :
seq = 1 ;
break ;
case VC1_CODE_ENTRYPOINT :
entry = 1 ;
break ;
case VC1_CODE_SLICE :
trk - > vc1_info . slices = 1 ;
break ;
}
}
if ( ! trk - > entry & & ! fragment ) {
/* First packet in first fragment */
trk - > vc1_info . first_packet_seq = seq ;
trk - > vc1_info . first_packet_entry = entry ;
} else if ( ( seq & & ! trk - > vc1_info . packet_seq ) | |
( entry & & ! trk - > vc1_info . packet_entry ) ) {
int i ;
for ( i = 0 ; i < trk - > entry ; i + + )
trk - > cluster [ i ] . flags & = ~ MOV_SYNC_SAMPLE ;
trk - > has_keyframes = 0 ;
if ( seq )
trk - > vc1_info . packet_seq = 1 ;
if ( entry )
trk - > vc1_info . packet_entry = 1 ;
if ( ! fragment ) {
/* First fragment */
if ( ( ! seq | | trk - > vc1_info . first_packet_seq ) & &
( ! entry | | trk - > vc1_info . first_packet_entry ) ) {
/* First packet had the same headers as this one, readd the
* sync sample flag . */
trk - > cluster [ 0 ] . flags | = MOV_SYNC_SAMPLE ;
trk - > has_keyframes = 1 ;
}
}
}
if ( trk - > vc1_info . packet_seq & & trk - > vc1_info . packet_entry )
key = seq & & entry ;
else if ( trk - > vc1_info . packet_seq )
key = seq ;
else if ( trk - > vc1_info . packet_entry )
key = entry ;
if ( key ) {
trk - > cluster [ trk - > entry ] . flags | = MOV_SYNC_SAMPLE ;
trk - > has_keyframes + + ;
}
}
2012-09-20 10:34:28 +02:00
static int get_moov_size ( AVFormatContext * s )
{
int ret ;
uint8_t * buf ;
AVIOContext * moov_buf ;
MOVMuxContext * mov = s - > priv_data ;
if ( ( ret = avio_open_dyn_buf ( & moov_buf ) ) < 0 )
return ret ;
mov_write_moov_tag ( moov_buf , mov , s ) ;
ret = avio_close_dyn_buf ( moov_buf , & buf ) ;
av_free ( buf ) ;
return ret ;
}
2012-01-05 12:57:05 +01:00
static int mov_flush_fragment ( AVFormatContext * s )
{
2011-12-06 16:15:35 +01:00
MOVMuxContext * mov = s - > priv_data ;
2012-01-05 12:57:05 +01:00
int i , first_track = - 1 ;
int64_t mdat_size = 0 ;
2011-12-06 16:15:35 +01:00
2012-01-05 12:57:05 +01:00
if ( ! ( mov - > flags & FF_MOV_FLAG_FRAGMENT ) )
return 0 ;
if ( ! ( mov - > flags & FF_MOV_FLAG_EMPTY_MOOV ) & & mov - > fragments = = 0 ) {
int64_t pos = avio_tell ( s - > pb ) ;
movenc: Buffer the mdat for the initial moov fragment, too
This allows writing QuickTime-compatible fragmented mp4 (with
a non-empty moov atom) to a non-seekable output.
This buffers the mdat for the initial fragment just as it does
for all normal fragments, too. Previously, the resulting
atom structure was mdat,moov, moof,mdat ..., while it now
is moov,mdat, moof,mdat.
Signed-off-by: Martin Storsjö <martin@martin.st>
2012-02-02 11:50:26 +01:00
uint8_t * buf ;
2012-09-20 10:34:28 +02:00
int buf_size , moov_size ;
2012-01-05 12:57:05 +01:00
for ( i = 0 ; i < mov - > nb_streams ; i + + )
if ( ! mov - > tracks [ i ] . entry )
break ;
/* Don't write the initial moov unless all tracks have data */
if ( i < mov - > nb_streams )
return 0 ;
movenc: Buffer the mdat for the initial moov fragment, too
This allows writing QuickTime-compatible fragmented mp4 (with
a non-empty moov atom) to a non-seekable output.
This buffers the mdat for the initial fragment just as it does
for all normal fragments, too. Previously, the resulting
atom structure was mdat,moov, moof,mdat ..., while it now
is moov,mdat, moof,mdat.
Signed-off-by: Martin Storsjö <martin@martin.st>
2012-02-02 11:50:26 +01:00
2012-09-20 10:34:28 +02:00
moov_size = get_moov_size ( s ) ;
movenc: Buffer the mdat for the initial moov fragment, too
This allows writing QuickTime-compatible fragmented mp4 (with
a non-empty moov atom) to a non-seekable output.
This buffers the mdat for the initial fragment just as it does
for all normal fragments, too. Previously, the resulting
atom structure was mdat,moov, moof,mdat ..., while it now
is moov,mdat, moof,mdat.
Signed-off-by: Martin Storsjö <martin@martin.st>
2012-02-02 11:50:26 +01:00
for ( i = 0 ; i < mov - > nb_streams ; i + + )
2012-09-20 10:34:28 +02:00
mov - > tracks [ i ] . data_offset = pos + moov_size + 8 ;
movenc: Buffer the mdat for the initial moov fragment, too
This allows writing QuickTime-compatible fragmented mp4 (with
a non-empty moov atom) to a non-seekable output.
This buffers the mdat for the initial fragment just as it does
for all normal fragments, too. Previously, the resulting
atom structure was mdat,moov, moof,mdat ..., while it now
is moov,mdat, moof,mdat.
Signed-off-by: Martin Storsjö <martin@martin.st>
2012-02-02 11:50:26 +01:00
2012-01-05 12:57:05 +01:00
mov_write_moov_tag ( s - > pb , mov , s ) ;
movenc: Buffer the mdat for the initial moov fragment, too
This allows writing QuickTime-compatible fragmented mp4 (with
a non-empty moov atom) to a non-seekable output.
This buffers the mdat for the initial fragment just as it does
for all normal fragments, too. Previously, the resulting
atom structure was mdat,moov, moof,mdat ..., while it now
is moov,mdat, moof,mdat.
Signed-off-by: Martin Storsjö <martin@martin.st>
2012-02-02 11:50:26 +01:00
buf_size = avio_close_dyn_buf ( mov - > mdat_buf , & buf ) ;
mov - > mdat_buf = NULL ;
avio_wb32 ( s - > pb , buf_size + 8 ) ;
ffio_wfourcc ( s - > pb , " mdat " ) ;
avio_write ( s - > pb , buf , buf_size ) ;
av_free ( buf ) ;
2012-01-05 12:57:05 +01:00
mov - > fragments + + ;
mov - > mdat_size = 0 ;
for ( i = 0 ; i < mov - > nb_streams ; i + + ) {
if ( mov - > tracks [ i ] . entry )
mov - > tracks [ i ] . frag_start + = mov - > tracks [ i ] . start_dts +
2012-01-30 15:19:15 +01:00
mov - > tracks [ i ] . track_duration -
2012-01-05 12:57:05 +01:00
mov - > tracks [ i ] . cluster [ 0 ] . dts ;
mov - > tracks [ i ] . entry = 0 ;
2011-12-06 16:15:35 +01:00
}
2012-01-19 10:17:13 +01:00
avio_flush ( s - > pb ) ;
2012-01-05 12:57:05 +01:00
return 0 ;
2011-12-06 16:15:35 +01:00
}
2012-01-05 12:57:05 +01:00
for ( i = 0 ; i < mov - > nb_streams ; i + + ) {
MOVTrack * track = & mov - > tracks [ i ] ;
if ( mov - > flags & FF_MOV_FLAG_SEPARATE_MOOF )
track - > data_offset = 0 ;
else
track - > data_offset = mdat_size ;
if ( ! track - > mdat_buf )
continue ;
mdat_size + = avio_tell ( track - > mdat_buf ) ;
if ( first_track < 0 )
first_track = i ;
2011-12-06 16:15:35 +01:00
}
2012-01-05 12:57:05 +01:00
if ( ! mdat_size )
return 0 ;
for ( i = 0 ; i < mov - > nb_streams ; i + + ) {
MOVTrack * track = & mov - > tracks [ i ] ;
int buf_size , write_moof = 1 , moof_tracks = - 1 ;
uint8_t * buf ;
int64_t duration = 0 ;
if ( track - > entry )
2012-01-30 15:19:15 +01:00
duration = track - > start_dts + track - > track_duration -
2012-01-05 12:57:05 +01:00
track - > cluster [ 0 ] . dts ;
if ( mov - > flags & FF_MOV_FLAG_SEPARATE_MOOF ) {
if ( ! track - > mdat_buf )
continue ;
mdat_size = avio_tell ( track - > mdat_buf ) ;
moof_tracks = i ;
} else {
write_moof = i = = first_track ;
}
if ( write_moof ) {
MOVFragmentInfo * info ;
2012-01-19 10:17:13 +01:00
avio_flush ( s - > pb ) ;
2012-01-05 12:57:05 +01:00
track - > nb_frag_info + + ;
track - > frag_info = av_realloc ( track - > frag_info ,
sizeof ( * track - > frag_info ) *
track - > nb_frag_info ) ;
info = & track - > frag_info [ track - > nb_frag_info - 1 ] ;
info - > offset = avio_tell ( s - > pb ) ;
info - > time = mov - > tracks [ i ] . frag_start ;
2012-01-09 16:58:26 +01:00
info - > duration = duration ;
mov_write_tfrf_tags ( s - > pb , mov , track ) ;
2012-01-05 12:57:05 +01:00
mov_write_moof_tag ( s - > pb , mov , moof_tracks ) ;
2012-01-09 16:58:26 +01:00
info - > tfrf_offset = track - > tfrf_offset ;
2012-01-05 12:57:05 +01:00
mov - > fragments + + ;
avio_wb32 ( s - > pb , mdat_size + 8 ) ;
ffio_wfourcc ( s - > pb , " mdat " ) ;
}
if ( track - > entry )
track - > frag_start + = duration ;
track - > entry = 0 ;
if ( ! track - > mdat_buf )
continue ;
buf_size = avio_close_dyn_buf ( track - > mdat_buf , & buf ) ;
track - > mdat_buf = NULL ;
avio_write ( s - > pb , buf , buf_size ) ;
av_free ( buf ) ;
}
mov - > mdat_size = 0 ;
2011-12-06 16:15:35 +01:00
2012-01-19 10:17:13 +01:00
avio_flush ( s - > pb ) ;
2011-12-06 16:15:35 +01:00
return 0 ;
}
2012-04-11 12:37:14 +02:00
int ff_mov_write_packet ( AVFormatContext * s , AVPacket * pkt )
2003-08-26 22:23:13 +02:00
{
2009-02-28 17:02:29 +01:00
MOVMuxContext * mov = s - > priv_data ;
2011-02-20 11:04:12 +01:00
AVIOContext * pb = s - > pb ;
2006-05-13 20:01:16 +02:00
MOVTrack * trk = & mov - > tracks [ pkt - > stream_index ] ;
AVCodecContext * enc = trk - > enc ;
2012-01-30 15:19:15 +01:00
unsigned int samples_in_chunk = 0 ;
2004-05-29 04:06:32 +02:00
int size = pkt - > size ;
2011-12-09 20:19:57 +01:00
uint8_t * reformatted_data = NULL ;
2012-01-05 12:57:05 +01:00
movenc: Buffer the mdat for the initial moov fragment, too
This allows writing QuickTime-compatible fragmented mp4 (with
a non-empty moov atom) to a non-seekable output.
This buffers the mdat for the initial fragment just as it does
for all normal fragments, too. Previously, the resulting
atom structure was mdat,moov, moof,mdat ..., while it now
is moov,mdat, moof,mdat.
Signed-off-by: Martin Storsjö <martin@martin.st>
2012-02-02 11:50:26 +01:00
if ( mov - > flags & FF_MOV_FLAG_FRAGMENT ) {
int ret ;
if ( mov - > fragments > 0 ) {
if ( ! trk - > mdat_buf ) {
if ( ( ret = avio_open_dyn_buf ( & trk - > mdat_buf ) ) < 0 )
return ret ;
}
pb = trk - > mdat_buf ;
} else {
if ( ! mov - > mdat_buf ) {
if ( ( ret = avio_open_dyn_buf ( & mov - > mdat_buf ) ) < 0 )
return ret ;
}
pb = mov - > mdat_buf ;
2012-01-05 12:57:05 +01:00
}
2011-12-06 16:15:35 +01:00
}
2012-08-05 11:11:04 +02:00
if ( enc - > codec_id = = AV_CODEC_ID_AMR_NB ) {
2006-07-04 16:03:59 +02:00
/* We must find out how many AMR blocks there are in one packet */
static uint16_t packed_size [ 16 ] =
2011-10-19 11:20:48 +02:00
{ 13 , 14 , 16 , 18 , 20 , 21 , 27 , 32 , 6 , 0 , 0 , 0 , 0 , 0 , 0 , 1 } ;
2006-07-04 16:03:59 +02:00
int len = 0 ;
2012-01-30 15:19:15 +01:00
while ( len < size & & samples_in_chunk < 100 ) {
2006-07-04 16:03:59 +02:00
len + = packed_size [ ( pkt - > data [ len ] > > 3 ) & 0x0F ] ;
2012-01-30 15:19:15 +01:00
samples_in_chunk + + ;
2003-08-26 22:23:13 +02:00
}
2012-01-30 15:19:15 +01:00
if ( samples_in_chunk > 1 ) {
2007-09-12 01:46:46 +02:00
av_log ( s , AV_LOG_ERROR , " fatal error, input is not a single packet, implement a AVParser for it \n " ) ;
2006-07-06 14:27:43 +02:00
return - 1 ;
}
2012-08-07 22:45:46 +02:00
} else if ( enc - > codec_id = = AV_CODEC_ID_ADPCM_MS | |
enc - > codec_id = = AV_CODEC_ID_ADPCM_IMA_WAV ) {
2012-01-31 01:14:58 +01:00
samples_in_chunk = enc - > frame_size ;
2012-01-30 15:19:15 +01:00
} else if ( trk - > sample_size )
samples_in_chunk = size / trk - > sample_size ;
2006-07-04 16:03:59 +02:00
else
2012-01-30 15:19:15 +01:00
samples_in_chunk = 1 ;
2003-11-03 22:51:07 +01:00
2006-04-14 12:51:32 +02:00
/* copy extradata if it exists */
2012-01-30 15:19:15 +01:00
if ( trk - > vos_len = = 0 & & enc - > extradata_size > 0 ) {
trk - > vos_len = enc - > extradata_size ;
trk - > vos_data = av_malloc ( trk - > vos_len ) ;
memcpy ( trk - > vos_data , enc - > extradata , trk - > vos_len ) ;
2003-11-03 22:51:07 +01:00
}
2012-08-05 11:11:04 +02:00
if ( enc - > codec_id = = AV_CODEC_ID_H264 & & trk - > vos_len > 0 & & * ( uint8_t * ) trk - > vos_data ! = 1 ) {
2009-01-16 02:12:32 +01:00
/* from x264 or from bytestream h264 */
/* nal reformating needed */
2011-12-09 20:19:57 +01:00
if ( trk - > hint_track > = 0 & & trk - > hint_track < mov - > nb_streams ) {
ff_avc_parse_nal_units_buf ( pkt - > data , & reformatted_data ,
& size ) ;
avio_write ( pb , reformatted_data , size ) ;
} else {
2011-12-06 16:15:35 +01:00
size = ff_avc_parse_nal_units ( pb , pkt - > data , pkt - > size ) ;
2011-12-09 20:19:57 +01:00
}
2012-08-07 22:45:46 +02:00
} else if ( enc - > codec_id = = AV_CODEC_ID_AAC & & pkt - > size > 2 & &
2011-01-29 06:32:09 +01:00
( AV_RB16 ( pkt - > data ) & 0xfff0 ) = = 0xfff0 ) {
av_log ( s , AV_LOG_ERROR , " malformated aac bitstream, use -absf aac_adtstoasc \n " ) ;
return - 1 ;
2009-01-16 02:12:32 +01:00
} else {
2011-02-21 19:28:17 +01:00
avio_write ( pb , pkt - > data , size ) ;
2009-01-16 02:12:32 +01:00
}
2012-08-05 11:11:04 +02:00
if ( ( enc - > codec_id = = AV_CODEC_ID_DNXHD | |
enc - > codec_id = = AV_CODEC_ID_AC3 ) & & ! trk - > vos_len ) {
2008-08-31 22:20:12 +02:00
/* copy frame to create needed atoms */
2012-01-30 15:19:15 +01:00
trk - > vos_len = size ;
trk - > vos_data = av_malloc ( size ) ;
if ( ! trk - > vos_data )
2008-08-31 22:21:00 +02:00
return AVERROR ( ENOMEM ) ;
2012-01-30 15:19:15 +01:00
memcpy ( trk - > vos_data , pkt - > data , size ) ;
2006-03-11 19:18:17 +01:00
}
2006-06-24 20:09:20 +02:00
if ( ! ( trk - > entry % MOV_INDEX_CLUSTER_SIZE ) ) {
2012-01-26 01:52:29 +01:00
trk - > cluster = av_realloc_f ( trk - > cluster , sizeof ( * trk - > cluster ) , ( trk - > entry + MOV_INDEX_CLUSTER_SIZE ) ) ;
2003-11-03 22:51:07 +01:00
if ( ! trk - > cluster )
return - 1 ;
}
2011-03-03 20:11:45 +01:00
trk - > cluster [ trk - > entry ] . pos = avio_tell ( pb ) - size ;
2012-01-30 15:19:15 +01:00
trk - > cluster [ trk - > entry ] . samples_in_chunk = samples_in_chunk ;
2011-11-30 23:11:49 +01:00
trk - > cluster [ trk - > entry ] . chunkNum = 0 ;
2006-06-24 20:09:20 +02:00
trk - > cluster [ trk - > entry ] . size = size ;
2012-01-30 15:19:15 +01:00
trk - > cluster [ trk - > entry ] . entries = samples_in_chunk ;
2006-11-01 18:27:39 +01:00
trk - > cluster [ trk - > entry ] . dts = pkt - > dts ;
2012-01-05 12:57:05 +01:00
if ( ! trk - > entry & & trk - > start_dts ! = AV_NOPTS_VALUE ) {
/* First packet of a new fragment. We already wrote the duration
2012-01-30 15:19:15 +01:00
* of the last packet of the previous fragment based on track_duration ,
2012-01-05 12:57:05 +01:00
* which might not exactly match our dts . Therefore adjust the dts
* of this packet to be what the previous packets duration implies . */
2012-01-30 15:19:15 +01:00
trk - > cluster [ trk - > entry ] . dts = trk - > start_dts + trk - > track_duration ;
2012-01-05 12:57:05 +01:00
}
2012-09-29 06:33:32 +02:00
if ( ! trk - > entry & & trk - > start_dts = = AV_NOPTS_VALUE & & ! supports_edts ( mov ) ) {
trk - > cluster [ trk - > entry ] . dts = trk - > start_dts = 0 ;
}
2012-01-07 00:32:53 +01:00
if ( trk - > start_dts = = AV_NOPTS_VALUE )
trk - > start_dts = pkt - > dts ;
2012-01-30 15:19:15 +01:00
trk - > track_duration = pkt - > dts - trk - > start_dts + pkt - > duration ;
2012-06-25 00:05:33 +02:00
trk - > last_sample_is_subtitle_end = 0 ;
2006-11-01 18:27:39 +01:00
2008-05-29 02:58:41 +02:00
if ( pkt - > pts = = AV_NOPTS_VALUE ) {
av_log ( s , AV_LOG_WARNING , " pts has no value \n " ) ;
pkt - > pts = pkt - > dts ;
}
2008-05-29 02:54:33 +02:00
if ( pkt - > dts ! = pkt - > pts )
2009-05-15 08:11:53 +02:00
trk - > flags | = MOV_TRACK_CTTS ;
2008-05-29 02:54:33 +02:00
trk - > cluster [ trk - > entry ] . cts = pkt - > pts - pkt - > dts ;
2009-05-15 08:11:53 +02:00
trk - > cluster [ trk - > entry ] . flags = 0 ;
2012-08-05 11:11:04 +02:00
if ( enc - > codec_id = = AV_CODEC_ID_VC1 ) {
2012-01-21 01:16:34 +01:00
mov_parse_vc1_frame ( pkt , trk , mov - > fragments ) ;
} else if ( pkt - > flags & AV_PKT_FLAG_KEY ) {
2012-08-05 11:11:04 +02:00
if ( mov - > mode = = MODE_MOV & & enc - > codec_id = = AV_CODEC_ID_MPEG2VIDEO & &
2011-02-13 01:18:45 +01:00
trk - > entry > 0 ) { // force sync sample for the first key frame
2009-05-15 08:11:53 +02:00
mov_parse_mpeg2_frame ( pkt , & trk - > cluster [ trk - > entry ] . flags ) ;
if ( trk - > cluster [ trk - > entry ] . flags & MOV_PARTIAL_SYNC_SAMPLE )
trk - > flags | = MOV_TRACK_STPS ;
} else {
trk - > cluster [ trk - > entry ] . flags = MOV_SYNC_SAMPLE ;
}
if ( trk - > cluster [ trk - > entry ] . flags & MOV_SYNC_SAMPLE )
2012-01-30 15:19:15 +01:00
trk - > has_keyframes + + ;
2009-05-14 23:05:52 +02:00
}
2003-11-03 22:51:07 +01:00
trk - > entry + + ;
2012-01-30 15:19:15 +01:00
trk - > sample_count + = samples_in_chunk ;
2006-05-13 20:01:16 +02:00
mov - > mdat_size + = size ;
2003-11-03 22:51:07 +01:00
2011-03-14 20:39:06 +01:00
avio_flush ( pb ) ;
2010-05-18 21:47:24 +02:00
if ( trk - > hint_track > = 0 & & trk - > hint_track < mov - > nb_streams )
2011-12-09 20:19:57 +01:00
ff_mov_add_hinted_packet ( s , pkt , trk - > hint_track , trk - > entry ,
reformatted_data , size ) ;
av_free ( reformatted_data ) ;
2003-08-26 22:23:13 +02:00
return 0 ;
}
2012-06-25 00:05:33 +02:00
static int mov_write_single_packet ( AVFormatContext * s , AVPacket * pkt )
2012-01-20 18:29:33 +01:00
{
2012-04-11 12:37:14 +02:00
MOVMuxContext * mov = s - > priv_data ;
MOVTrack * trk = & mov - > tracks [ pkt - > stream_index ] ;
AVCodecContext * enc = trk - > enc ;
int64_t frag_duration = 0 ;
int size = pkt - > size ;
if ( ! pkt - > size ) return 0 ; /* Discard 0 sized packets */
2012-04-11 22:50:22 +02:00
if ( trk - > entry & & pkt - > stream_index < s - > nb_streams )
2012-04-11 12:37:14 +02:00
frag_duration = av_rescale_q ( pkt - > dts - trk - > cluster [ 0 ] . dts ,
s - > streams [ pkt - > stream_index ] - > time_base ,
AV_TIME_BASE_Q ) ;
if ( ( mov - > max_fragment_duration & &
frag_duration > = mov - > max_fragment_duration ) | |
( mov - > max_fragment_size & & mov - > mdat_size + size > = mov - > max_fragment_size ) | |
( mov - > flags & FF_MOV_FLAG_FRAG_KEYFRAME & &
enc - > codec_type = = AVMEDIA_TYPE_VIDEO & &
trk - > entry & & pkt - > flags & AV_PKT_FLAG_KEY ) ) {
if ( frag_duration > = mov - > min_fragment_duration )
mov_flush_fragment ( s ) ;
}
return ff_mov_write_packet ( s , pkt ) ;
2012-06-25 00:05:33 +02:00
}
static int mov_write_subtitle_end_packet ( AVFormatContext * s ,
int stream_index ,
int64_t dts ) {
AVPacket end ;
2012-08-08 23:10:17 +02:00
uint8_t data [ 2 ] = { 0 } ;
2012-06-25 00:05:33 +02:00
int ret ;
av_init_packet ( & end ) ;
2012-08-08 23:10:17 +02:00
end . size = sizeof ( data ) ;
end . data = data ;
2012-06-25 00:05:33 +02:00
end . pts = dts ;
end . dts = dts ;
end . duration = 0 ;
end . stream_index = stream_index ;
ret = mov_write_single_packet ( s , & end ) ;
av_free_packet ( & end ) ;
return ret ;
}
static int mov_write_packet ( AVFormatContext * s , AVPacket * pkt )
{
if ( ! pkt ) {
mov_flush_fragment ( s ) ;
return 1 ;
} else {
int i ;
MOVMuxContext * mov = s - > priv_data ;
if ( ! pkt - > size ) return 0 ; /* Discard 0 sized packets */
/*
* Subtitles require special handling .
*
* 1 ) For full complaince , every track must have a sample at
* dts = = 0 , which is rarely true for subtitles . So , as soon
* as we see any packet with dts > 0 , write an empty subtitle
* at dts = = 0 for any subtitle track with no samples in it .
*
* 2 ) For each subtitle track , check if the current packet ' s
* dts is past the duration of the last subtitle sample . If
* so , we now need to write an end sample for that subtitle .
*
* This must be done conditionally to allow for subtitles that
* immediately replace each other , in which case an end sample
* is not needed , and is , in fact , actively harmful .
*
* 3 ) See mov_write_trailer for how the final end sample is
* handled .
*/
for ( i = 0 ; i < mov - > nb_streams ; i + + ) {
MOVTrack * trk = & mov - > tracks [ i ] ;
int ret ;
2012-08-07 22:45:46 +02:00
if ( trk - > enc - > codec_id = = AV_CODEC_ID_MOV_TEXT & &
2012-06-25 00:05:33 +02:00
trk - > track_duration < pkt - > dts & &
( trk - > entry = = 0 | | ! trk - > last_sample_is_subtitle_end ) ) {
ret = mov_write_subtitle_end_packet ( s , i , trk - > track_duration ) ;
if ( ret < 0 ) return ret ;
trk - > last_sample_is_subtitle_end = 1 ;
}
}
return mov_write_single_packet ( s , pkt ) ;
2012-01-20 18:29:33 +01:00
}
}
2010-05-05 10:41:10 +02:00
// QuickTime chapters involve an additional text track with the chapter names
// as samples, and a tref pointing from the other tracks to the chapter one.
static void mov_create_chapter_track ( AVFormatContext * s , int tracknum )
{
2012-05-20 02:10:47 +02:00
AVIOContext * pb ;
2010-05-05 10:41:10 +02:00
MOVMuxContext * mov = s - > priv_data ;
MOVTrack * track = & mov - > tracks [ tracknum ] ;
AVPacket pkt = { . stream_index = tracknum , . flags = AV_PKT_FLAG_KEY } ;
int i , len ;
track - > mode = mov - > mode ;
track - > tag = MKTAG ( ' t ' , ' e ' , ' x ' , ' t ' ) ;
track - > timescale = MOV_TIMESCALE ;
2011-06-18 13:40:48 +02:00
track - > enc = avcodec_alloc_context3 ( NULL ) ;
2010-05-05 10:41:10 +02:00
track - > enc - > codec_type = AVMEDIA_TYPE_SUBTITLE ;
2012-05-20 02:10:47 +02:00
if ( avio_open_dyn_buf ( & pb ) > = 0 ) {
int size ;
uint8_t * buf ;
/* Stub header (usually for Quicktime chapter track) */
// TextSampleEntry
avio_wb32 ( pb , 0x01 ) ; // displayFlags
avio_w8 ( pb , 0x00 ) ; // horizontal justification
avio_w8 ( pb , 0x00 ) ; // vertical justification
avio_w8 ( pb , 0x00 ) ; // bgColourRed
avio_w8 ( pb , 0x00 ) ; // bgColourGreen
avio_w8 ( pb , 0x00 ) ; // bgColourBlue
avio_w8 ( pb , 0x00 ) ; // bgColourAlpha
// BoxRecord
avio_wb16 ( pb , 0x00 ) ; // defTextBoxTop
avio_wb16 ( pb , 0x00 ) ; // defTextBoxLeft
avio_wb16 ( pb , 0x00 ) ; // defTextBoxBottom
avio_wb16 ( pb , 0x00 ) ; // defTextBoxRight
// StyleRecord
avio_wb16 ( pb , 0x00 ) ; // startChar
avio_wb16 ( pb , 0x00 ) ; // endChar
avio_wb16 ( pb , 0x01 ) ; // fontID
avio_w8 ( pb , 0x00 ) ; // fontStyleFlags
avio_w8 ( pb , 0x00 ) ; // fontSize
avio_w8 ( pb , 0x00 ) ; // fgColourRed
avio_w8 ( pb , 0x00 ) ; // fgColourGreen
avio_w8 ( pb , 0x00 ) ; // fgColourBlue
avio_w8 ( pb , 0x00 ) ; // fgColourAlpha
// FontTableBox
avio_wb32 ( pb , 0x0D ) ; // box size
ffio_wfourcc ( pb , " ftab " ) ; // box atom name
avio_wb16 ( pb , 0x01 ) ; // entry count
// FontRecord
avio_wb16 ( pb , 0x01 ) ; // font ID
avio_w8 ( pb , 0x00 ) ; // font name length
if ( ( size = avio_close_dyn_buf ( pb , & buf ) ) > 0 ) {
track - > enc - > extradata = buf ;
track - > enc - > extradata_size = size ;
} else {
av_free ( & buf ) ;
}
}
2010-05-05 10:41:10 +02:00
for ( i = 0 ; i < s - > nb_chapters ; i + + ) {
AVChapter * c = s - > chapters [ i ] ;
2011-05-22 12:46:29 +02:00
AVDictionaryEntry * t ;
2010-05-05 10:41:10 +02:00
int64_t end = av_rescale_q ( c - > end , c - > time_base , ( AVRational ) { 1 , MOV_TIMESCALE } ) ;
pkt . pts = pkt . dts = av_rescale_q ( c - > start , c - > time_base , ( AVRational ) { 1 , MOV_TIMESCALE } ) ;
pkt . duration = end - pkt . dts ;
2011-05-22 12:46:29 +02:00
if ( ( t = av_dict_get ( c - > metadata , " title " , NULL , 0 ) ) ) {
2010-05-05 10:41:10 +02:00
len = strlen ( t - > value ) ;
pkt . size = len + 2 ;
pkt . data = av_malloc ( pkt . size ) ;
AV_WB16 ( pkt . data , len ) ;
memcpy ( pkt . data + 2 , t - > value , len ) ;
2010-05-18 21:40:17 +02:00
ff_mov_write_packet ( s , & pkt ) ;
2010-05-05 10:41:10 +02:00
av_freep ( & pkt . data ) ;
}
}
}
2012-03-05 08:51:08 +01:00
static int mov_create_timecode_track ( AVFormatContext * s , int index , int src_index , const char * tcstr )
{
2012-08-03 15:40:48 +02:00
int ret ;
2012-03-05 08:51:08 +01:00
MOVMuxContext * mov = s - > priv_data ;
MOVTrack * track = & mov - > tracks [ index ] ;
AVStream * src_st = s - > streams [ src_index ] ;
AVTimecode tc ;
AVPacket pkt = { . stream_index = index , . flags = AV_PKT_FLAG_KEY , . size = 4 } ;
AVRational rate = { src_st - > codec - > time_base . den , src_st - > codec - > time_base . num } ;
2012-08-03 15:40:48 +02:00
/* if the codec time base makes no sense, try to fallback on stream frame rate */
if ( av_timecode_check_frame_rate ( rate ) < 0 ) {
av_log ( s , AV_LOG_DEBUG , " timecode: tbc=%d/%d invalid, fallback on %d/%d \n " ,
rate . num , rate . den , src_st - > avg_frame_rate . num , src_st - > avg_frame_rate . den ) ;
rate = src_st - > avg_frame_rate ;
}
2012-03-05 08:51:08 +01:00
/* compute the frame number */
2012-08-03 15:40:48 +02:00
ret = av_timecode_init_from_string ( & tc , rate , tcstr , s ) ;
2012-03-05 08:51:08 +01:00
if ( ret < 0 )
return ret ;
/* tmcd track based on video stream */
track - > mode = mov - > mode ;
track - > tag = MKTAG ( ' t ' , ' m ' , ' c ' , ' d ' ) ;
track - > src_track = src_index ;
2012-10-12 20:08:08 +02:00
track - > timescale = mov - > tracks [ src_index ] . timescale ;
2012-03-05 08:51:08 +01:00
if ( tc . flags & AV_TIMECODE_FLAG_DROPFRAME )
track - > timecode_flags | = MOV_TIMECODE_FLAG_DROPFRAME ;
/* encode context: tmcd data stream */
track - > enc = avcodec_alloc_context3 ( NULL ) ;
track - > enc - > codec_type = AVMEDIA_TYPE_DATA ;
track - > enc - > codec_tag = track - > tag ;
track - > enc - > time_base = src_st - > codec - > time_base ;
/* the tmcd track just contains one packet with the frame number */
pkt . data = av_malloc ( pkt . size ) ;
AV_WB32 ( pkt . data , tc . start ) ;
ret = ff_mov_write_packet ( s , & pkt ) ;
av_free ( pkt . data ) ;
return ret ;
}
2010-05-05 10:41:06 +02:00
static int mov_write_header ( AVFormatContext * s )
{
2011-02-20 11:04:12 +01:00
AVIOContext * pb = s - > pb ;
2010-05-05 10:41:06 +02:00
MOVMuxContext * mov = s - > priv_data ;
2012-03-05 08:51:08 +01:00
AVDictionaryEntry * t , * global_tcr = av_dict_get ( s - > metadata , " timecode " , NULL , 0 ) ;
int i , hint_track = 0 , tmcd_track = 0 ;
2010-05-05 10:41:06 +02:00
movenc: Buffer the mdat for the initial moov fragment, too
This allows writing QuickTime-compatible fragmented mp4 (with
a non-empty moov atom) to a non-seekable output.
This buffers the mdat for the initial fragment just as it does
for all normal fragments, too. Previously, the resulting
atom structure was mdat,moov, moof,mdat ..., while it now
is moov,mdat, moof,mdat.
Signed-off-by: Martin Storsjö <martin@martin.st>
2012-02-02 11:50:26 +01:00
/* Set the FRAGMENT flag if any of the fragmentation methods are
* enabled . */
if ( mov - > max_fragment_duration | | mov - > max_fragment_size | |
mov - > flags & ( FF_MOV_FLAG_EMPTY_MOOV |
FF_MOV_FLAG_FRAG_KEYFRAME |
FF_MOV_FLAG_FRAG_CUSTOM ) )
mov - > flags | = FF_MOV_FLAG_FRAGMENT ;
2012-09-20 10:40:10 +02:00
/* faststart: moov at the beginning of the file, if supported */
if ( mov - > flags & FF_MOV_FLAG_FASTSTART ) {
if ( mov - > flags & FF_MOV_FLAG_FRAGMENT )
mov - > flags & = ~ FF_MOV_FLAG_FASTSTART ;
else
mov - > reserved_moov_size = - 1 ;
}
2012-09-29 06:33:32 +02:00
if ( ! supports_edts ( mov ) & & s - > avoid_negative_ts < 0 ) {
s - > avoid_negative_ts = 1 ;
}
movenc: Buffer the mdat for the initial moov fragment, too
This allows writing QuickTime-compatible fragmented mp4 (with
a non-empty moov atom) to a non-seekable output.
This buffers the mdat for the initial fragment just as it does
for all normal fragments, too. Previously, the resulting
atom structure was mdat,moov, moof,mdat ..., while it now
is moov,mdat, moof,mdat.
Signed-off-by: Martin Storsjö <martin@martin.st>
2012-02-02 11:50:26 +01:00
/* Non-seekable output is ok if using fragmentation. If ism_lookahead
2012-01-19 10:17:13 +01:00
* is enabled , we don ' t support non - seekable output at all . */
if ( ! s - > pb - > seekable & &
movenc: Buffer the mdat for the initial moov fragment, too
This allows writing QuickTime-compatible fragmented mp4 (with
a non-empty moov atom) to a non-seekable output.
This buffers the mdat for the initial fragment just as it does
for all normal fragments, too. Previously, the resulting
atom structure was mdat,moov, moof,mdat ..., while it now
is moov,mdat, moof,mdat.
Signed-off-by: Martin Storsjö <martin@martin.st>
2012-02-02 11:50:26 +01:00
( ( ! ( mov - > flags & FF_MOV_FLAG_FRAGMENT ) & &
2012-01-19 10:17:13 +01:00
! ( s - > oformat & & ! strcmp ( s - > oformat - > name , " ismv " ) ) )
| | mov - > ism_lookahead ) ) {
2010-05-05 10:41:06 +02:00
av_log ( s , AV_LOG_ERROR , " muxer does not support non seekable output \n " ) ;
return - 1 ;
}
/* Default mode == MP4 */
mov - > mode = MODE_MP4 ;
if ( s - > oformat ! = NULL ) {
if ( ! strcmp ( " 3gp " , s - > oformat - > name ) ) mov - > mode = MODE_3GP ;
else if ( ! strcmp ( " 3g2 " , s - > oformat - > name ) ) mov - > mode = MODE_3GP | MODE_3G2 ;
else if ( ! strcmp ( " mov " , s - > oformat - > name ) ) mov - > mode = MODE_MOV ;
else if ( ! strcmp ( " psp " , s - > oformat - > name ) ) mov - > mode = MODE_PSP ;
else if ( ! strcmp ( " ipod " , s - > oformat - > name ) ) mov - > mode = MODE_IPOD ;
2012-01-09 16:58:26 +01:00
else if ( ! strcmp ( " ismv " , s - > oformat - > name ) ) mov - > mode = MODE_ISM ;
2012-09-17 16:16:16 +02:00
else if ( ! strcmp ( " f4v " , s - > oformat - > name ) ) mov - > mode = MODE_F4V ;
2010-05-05 10:41:06 +02:00
mov_write_ftyp_tag ( pb , s ) ;
if ( mov - > mode = = MODE_PSP ) {
if ( s - > nb_streams ! = 2 ) {
av_log ( s , AV_LOG_ERROR , " PSP mode need one video and one audio stream \n " ) ;
return - 1 ;
}
mov_write_uuidprof_tag ( pb , s ) ;
}
}
2010-05-05 10:41:10 +02:00
mov - > nb_streams = s - > nb_streams ;
if ( mov - > mode & ( MODE_MOV | MODE_IPOD ) & & s - > nb_chapters )
mov - > chapter_track = mov - > nb_streams + + ;
2011-05-20 11:27:02 +02:00
if ( mov - > flags & FF_MOV_FLAG_RTP_HINT ) {
2010-05-18 21:47:24 +02:00
/* Add hint tracks for each audio and video stream */
hint_track = mov - > nb_streams ;
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
AVStream * st = s - > streams [ i ] ;
if ( st - > codec - > codec_type = = AVMEDIA_TYPE_VIDEO | |
st - > codec - > codec_type = = AVMEDIA_TYPE_AUDIO ) {
mov - > nb_streams + + ;
}
}
}
2012-03-05 08:51:08 +01:00
if ( mov - > mode = = MODE_MOV ) {
tmcd_track = mov - > nb_streams ;
2012-08-03 09:38:45 +02:00
/* +1 tmcd track for each video stream with a timecode */
2012-03-05 08:51:08 +01:00
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
AVStream * st = s - > streams [ i ] ;
if ( st - > codec - > codec_type = = AVMEDIA_TYPE_VIDEO & &
( global_tcr | | av_dict_get ( st - > metadata , " timecode " , NULL , 0 ) ) )
2012-08-03 09:38:45 +02:00
mov - > nb_meta_tmcd + + ;
}
/* check if there is already a tmcd track to remux */
if ( mov - > nb_meta_tmcd ) {
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
AVStream * st = s - > streams [ i ] ;
if ( st - > codec - > codec_tag = = MKTAG ( ' t ' , ' m ' , ' c ' , ' d ' ) ) {
av_log ( s , AV_LOG_WARNING , " You requested a copy of the original timecode track "
" so timecode metadata are now ignored \n " ) ;
mov - > nb_meta_tmcd = 0 ;
}
}
2012-03-05 08:51:08 +01:00
}
2012-08-03 09:38:45 +02:00
mov - > nb_streams + = mov - > nb_meta_tmcd ;
2012-03-05 08:51:08 +01:00
}
2010-05-05 10:41:10 +02:00
mov - > tracks = av_mallocz ( mov - > nb_streams * sizeof ( * mov - > tracks ) ) ;
2010-05-05 10:41:06 +02:00
if ( ! mov - > tracks )
return AVERROR ( ENOMEM ) ;
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
AVStream * st = s - > streams [ i ] ;
MOVTrack * track = & mov - > tracks [ i ] ;
2011-05-22 12:46:29 +02:00
AVDictionaryEntry * lang = av_dict_get ( st - > metadata , " language " , NULL , 0 ) ;
2010-05-05 10:41:06 +02:00
track - > enc = st - > codec ;
track - > language = ff_mov_iso639_to_lang ( lang ? lang - > value : " und " , mov - > mode ! = MODE_MOV ) ;
if ( track - > language < 0 )
track - > language = 0 ;
track - > mode = mov - > mode ;
track - > tag = mov_find_codec_tag ( s , track ) ;
if ( ! track - > tag ) {
av_log ( s , AV_LOG_ERROR , " track %d: could not find tag, "
" codec not currently supported in container \n " , i ) ;
goto error ;
}
2010-05-18 21:47:24 +02:00
/* If hinting of this track is enabled by a later hint track,
* this is updated . */
track - > hint_track = - 1 ;
2012-01-07 00:32:53 +01:00
track - > start_dts = AV_NOPTS_VALUE ;
2010-05-05 10:41:06 +02:00
if ( st - > codec - > codec_type = = AVMEDIA_TYPE_VIDEO ) {
if ( track - > tag = = MKTAG ( ' m ' , ' x ' , ' 3 ' , ' p ' ) | | track - > tag = = MKTAG ( ' m ' , ' x ' , ' 3 ' , ' n ' ) | |
track - > tag = = MKTAG ( ' m ' , ' x ' , ' 4 ' , ' p ' ) | | track - > tag = = MKTAG ( ' m ' , ' x ' , ' 4 ' , ' n ' ) | |
track - > tag = = MKTAG ( ' m ' , ' x ' , ' 5 ' , ' p ' ) | | track - > tag = = MKTAG ( ' m ' , ' x ' , ' 5 ' , ' n ' ) ) {
if ( st - > codec - > width ! = 720 | | ( st - > codec - > height ! = 608 & & st - > codec - > height ! = 512 ) ) {
av_log ( s , AV_LOG_ERROR , " D-10/IMX must use 720x608 or 720x512 video resolution \n " ) ;
goto error ;
}
track - > height = track - > tag > > 24 = = ' n ' ? 486 : 576 ;
}
track - > timescale = st - > codec - > time_base . den ;
2012-10-04 00:51:44 +02:00
while ( track - > timescale < 10000 )
track - > timescale * = 2 ;
2010-05-05 10:41:06 +02:00
if ( track - > mode = = MODE_MOV & & track - > timescale > 100000 )
av_log ( s , AV_LOG_WARNING ,
" WARNING codec timebase is very high. If duration is too long, \n "
" file may not be playable by quicktime. Specify a shorter timebase \n "
" or choose different container. \n " ) ;
} else if ( st - > codec - > codec_type = = AVMEDIA_TYPE_AUDIO ) {
track - > timescale = st - > codec - > sample_rate ;
2012-01-22 23:23:23 +01:00
if ( ! st - > codec - > frame_size & & ! av_get_bits_per_sample ( st - > codec - > codec_id ) ) {
2012-05-07 23:32:45 +02:00
av_log ( s , AV_LOG_WARNING , " track %d: codec frame size is not set \n " , i ) ;
track - > audio_vbr = 1 ;
2012-08-07 22:45:46 +02:00
} else if ( st - > codec - > codec_id = = AV_CODEC_ID_ADPCM_MS | |
st - > codec - > codec_id = = AV_CODEC_ID_ADPCM_IMA_WAV | |
st - > codec - > codec_id = = AV_CODEC_ID_ILBC ) {
2011-01-20 22:14:12 +01:00
if ( ! st - > codec - > block_align ) {
2012-01-22 23:23:23 +01:00
av_log ( s , AV_LOG_ERROR , " track %d: codec block align is not set for adpcm \n " , i ) ;
2011-01-20 22:14:12 +01:00
goto error ;
}
2012-01-30 15:19:15 +01:00
track - > sample_size = st - > codec - > block_align ;
2012-01-22 23:23:23 +01:00
} else if ( st - > codec - > frame_size > 1 ) { /* assume compressed audio */
2010-05-05 10:41:06 +02:00
track - > audio_vbr = 1 ;
2012-01-22 23:23:23 +01:00
} else {
2012-01-31 01:14:58 +01:00
track - > sample_size = ( av_get_bits_per_sample ( st - > codec - > codec_id ) > > 3 ) * st - > codec - > channels ;
2010-05-05 10:41:06 +02:00
}
2012-04-20 22:21:28 +02:00
if ( track - > mode ! = MODE_MOV & &
2012-08-05 11:11:04 +02:00
track - > enc - > codec_id = = AV_CODEC_ID_MP3 & & track - > timescale < 16000 ) {
2012-04-20 22:21:28 +02:00
av_log ( s , AV_LOG_ERROR , " track %d: muxing mp3 at %dhz is not supported \n " ,
i , track - > enc - > sample_rate ) ;
goto error ;
2010-05-05 10:41:06 +02:00
}
} else if ( st - > codec - > codec_type = = AVMEDIA_TYPE_SUBTITLE ) {
track - > timescale = st - > codec - > time_base . den ;
2012-03-24 21:36:51 +01:00
} else {
track - > timescale = MOV_TIMESCALE ;
2010-05-05 10:41:06 +02:00
}
if ( ! track - > height )
track - > height = st - > codec - > height ;
2012-01-09 16:58:26 +01:00
/* The ism specific timescale isn't mandatory, but is assumed by
* some tools , such as mp4split . */
if ( mov - > mode = = MODE_ISM )
track - > timescale = 10000000 ;
2010-05-05 10:41:06 +02:00
2011-11-29 19:28:15 +01:00
avpriv_set_pts_info ( st , 64 , 1 , track - > timescale ) ;
2012-01-05 12:57:05 +01:00
/* copy extradata if it exists */
if ( st - > codec - > extradata_size ) {
2012-01-30 15:19:15 +01:00
track - > vos_len = st - > codec - > extradata_size ;
track - > vos_data = av_malloc ( track - > vos_len ) ;
memcpy ( track - > vos_data , st - > codec - > extradata , track - > vos_len ) ;
2012-01-05 12:57:05 +01:00
}
2010-05-05 10:41:06 +02:00
}
2012-01-09 16:58:26 +01:00
if ( mov - > mode = = MODE_ISM ) {
/* If no fragmentation options have been set, set a default. */
if ( ! ( mov - > flags & ( FF_MOV_FLAG_FRAG_KEYFRAME |
FF_MOV_FLAG_FRAG_CUSTOM ) ) & &
! mov - > max_fragment_duration & & ! mov - > max_fragment_size )
mov - > max_fragment_duration = 5000000 ;
movenc: Buffer the mdat for the initial moov fragment, too
This allows writing QuickTime-compatible fragmented mp4 (with
a non-empty moov atom) to a non-seekable output.
This buffers the mdat for the initial fragment just as it does
for all normal fragments, too. Previously, the resulting
atom structure was mdat,moov, moof,mdat ..., while it now
is moov,mdat, moof,mdat.
Signed-off-by: Martin Storsjö <martin@martin.st>
2012-02-02 11:50:26 +01:00
mov - > flags | = FF_MOV_FLAG_EMPTY_MOOV | FF_MOV_FLAG_SEPARATE_MOOF |
FF_MOV_FLAG_FRAGMENT ;
2010-05-05 10:41:06 +02:00
}
2011-10-26 22:09:26 +02:00
if ( mov - > reserved_moov_size ) {
mov - > reserved_moov_pos = avio_tell ( pb ) ;
2012-09-20 10:40:10 +02:00
if ( mov - > reserved_moov_size > 0 )
avio_skip ( pb , mov - > reserved_moov_size ) ;
2011-10-26 22:09:26 +02:00
}
movenc: Buffer the mdat for the initial moov fragment, too
This allows writing QuickTime-compatible fragmented mp4 (with
a non-empty moov atom) to a non-seekable output.
This buffers the mdat for the initial fragment just as it does
for all normal fragments, too. Previously, the resulting
atom structure was mdat,moov, moof,mdat ..., while it now
is moov,mdat, moof,mdat.
Signed-off-by: Martin Storsjö <martin@martin.st>
2012-02-02 11:50:26 +01:00
if ( ! ( mov - > flags & FF_MOV_FLAG_FRAGMENT ) )
2012-01-05 12:57:05 +01:00
mov_write_mdat_tag ( pb , mov ) ;
2011-07-07 11:25:03 +02:00
2011-07-13 11:45:17 +02:00
if ( t = av_dict_get ( s - > metadata , " creation_time " , NULL , 0 ) )
mov - > time = ff_iso8601_to_unix_time ( t - > value ) ;
2012-01-09 17:35:01 +01:00
if ( mov - > time )
mov - > time + = 0x7C25B080 ; // 1970 based -> 1904 based
2010-05-05 10:41:10 +02:00
if ( mov - > chapter_track )
mov_create_chapter_track ( s , mov - > chapter_track ) ;
2010-05-05 10:41:06 +02:00
2011-05-20 11:27:02 +02:00
if ( mov - > flags & FF_MOV_FLAG_RTP_HINT ) {
2010-05-18 21:47:24 +02:00
/* Initialize the hint tracks for each audio and video stream */
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
AVStream * st = s - > streams [ i ] ;
if ( st - > codec - > codec_type = = AVMEDIA_TYPE_VIDEO | |
st - > codec - > codec_type = = AVMEDIA_TYPE_AUDIO ) {
ff_mov_init_hinting ( s , hint_track , i ) ;
hint_track + + ;
}
}
}
2012-08-03 09:38:45 +02:00
if ( mov - > nb_meta_tmcd ) {
2012-03-05 08:51:08 +01:00
/* Initialize the tmcd tracks */
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
AVStream * st = s - > streams [ i ] ;
t = global_tcr ;
if ( st - > codec - > codec_type = = AVMEDIA_TYPE_VIDEO ) {
if ( ! t )
t = av_dict_get ( st - > metadata , " timecode " , NULL , 0 ) ;
if ( ! t )
continue ;
if ( mov_create_timecode_track ( s , tmcd_track , i , t - > value ) < 0 )
goto error ;
tmcd_track + + ;
}
}
}
2011-03-14 20:39:06 +01:00
avio_flush ( pb ) ;
2010-05-05 10:41:06 +02:00
2012-01-20 12:02:18 +01:00
if ( mov - > flags & FF_MOV_FLAG_ISML )
mov_write_isml_manifest ( pb , mov ) ;
2012-01-05 12:57:05 +01:00
if ( mov - > flags & FF_MOV_FLAG_EMPTY_MOOV ) {
mov_write_moov_tag ( pb , mov , s ) ;
mov - > fragments + + ;
}
2010-05-05 10:41:06 +02:00
return 0 ;
error :
av_freep ( & mov - > tracks ) ;
return - 1 ;
}
2012-09-20 10:40:10 +02:00
/**
* This function gets the moov size if moved to the top of the file : the chunk
* offset table can switch between stco ( 32 - bit entries ) to co64 ( 64 - bit
* entries ) when the moov is moved to the top , so the size of the moov would
* change . It also updates the chunk offset tables .
*/
static int compute_moov_size ( AVFormatContext * s )
{
int i , moov_size , moov_size2 ;
MOVMuxContext * mov = s - > priv_data ;
moov_size = get_moov_size ( s ) ;
if ( moov_size < 0 )
return moov_size ;
for ( i = 0 ; i < mov - > nb_streams ; i + + )
mov - > tracks [ i ] . data_offset + = moov_size ;
moov_size2 = get_moov_size ( s ) ;
if ( moov_size2 < 0 )
return moov_size2 ;
/* if the size changed, we just switched from stco to co64 and needs to
* update the offsets */
if ( moov_size2 ! = moov_size )
for ( i = 0 ; i < mov - > nb_streams ; i + + )
mov - > tracks [ i ] . data_offset + = moov_size2 - moov_size ;
return moov_size2 ;
}
static int shift_data ( AVFormatContext * s )
{
int ret = 0 , moov_size ;
MOVMuxContext * mov = s - > priv_data ;
int64_t pos , pos_end = avio_tell ( s - > pb ) ;
uint8_t * buf , * read_buf [ 2 ] ;
int read_buf_id = 0 ;
int read_size [ 2 ] ;
AVIOContext * read_pb ;
moov_size = compute_moov_size ( s ) ;
if ( moov_size < 0 )
return moov_size ;
buf = av_malloc ( moov_size * 2 ) ;
if ( ! buf )
return AVERROR ( ENOMEM ) ;
read_buf [ 0 ] = buf ;
read_buf [ 1 ] = buf + moov_size ;
/* Shift the data: the AVIO context of the output can only be used for
* writing , so we re - open the same output , but for reading . It also avoids
* a read / seek / write / seek back and forth . */
avio_flush ( s - > pb ) ;
ret = avio_open ( & read_pb , s - > filename , AVIO_FLAG_READ ) ;
if ( ret < 0 ) {
av_log ( s , AV_LOG_ERROR , " Unable to re-open %s output file for "
" the second pass (faststart) \n " , s - > filename ) ;
goto end ;
}
/* mark the end of the shift to up to the last data we wrote, and get ready
* for writing */
pos_end = avio_tell ( s - > pb ) ;
avio_seek ( s - > pb , mov - > reserved_moov_pos + moov_size , SEEK_SET ) ;
/* start reading at where the new moov will be placed */
avio_seek ( read_pb , mov - > reserved_moov_pos , SEEK_SET ) ;
pos = avio_tell ( read_pb ) ;
# define READ_BLOCK do { \
read_size [ read_buf_id ] = avio_read ( read_pb , read_buf [ read_buf_id ] , moov_size ) ; \
read_buf_id ^ = 1 ; \
} while ( 0 )
/* shift data by chunk of at most moov_size */
READ_BLOCK ;
do {
int n ;
READ_BLOCK ;
n = read_size [ read_buf_id ] ;
if ( n < = 0 )
break ;
avio_write ( s - > pb , read_buf [ read_buf_id ] , n ) ;
pos + = n ;
} while ( pos < pos_end ) ;
avio_close ( read_pb ) ;
end :
av_free ( buf ) ;
return ret ;
}
2003-08-26 22:23:13 +02:00
static int mov_write_trailer ( AVFormatContext * s )
{
2009-02-28 17:02:29 +01:00
MOVMuxContext * mov = s - > priv_data ;
2011-02-20 11:04:12 +01:00
AVIOContext * pb = s - > pb ;
2012-06-25 00:05:33 +02:00
int64_t moov_pos ;
2003-08-26 22:23:13 +02:00
int res = 0 ;
2006-06-24 20:09:20 +02:00
int i ;
2003-08-26 22:23:13 +02:00
2012-06-25 00:05:33 +02:00
/*
* Before actually writing the trailer , make sure that there are no
* dangling subtitles , that need a terminating sample .
*/
for ( i = 0 ; i < mov - > nb_streams ; i + + ) {
MOVTrack * trk = & mov - > tracks [ i ] ;
2012-08-07 22:45:46 +02:00
if ( trk - > enc - > codec_id = = AV_CODEC_ID_MOV_TEXT & &
2012-06-25 00:05:33 +02:00
! trk - > last_sample_is_subtitle_end ) {
mov_write_subtitle_end_packet ( s , i , trk - > track_duration ) ;
trk - > last_sample_is_subtitle_end = 1 ;
}
}
moov_pos = avio_tell ( pb ) ;
2003-08-26 22:23:13 +02:00
2012-01-05 12:57:05 +01:00
if ( ! ( mov - > flags & FF_MOV_FLAG_FRAGMENT ) ) {
2012-01-25 11:40:05 +01:00
/* Write size of mdat tag */
if ( mov - > mdat_size + 8 < = UINT32_MAX ) {
avio_seek ( pb , mov - > mdat_pos , SEEK_SET ) ;
avio_wb32 ( pb , mov - > mdat_size + 8 ) ;
} else {
/* overwrite 'wide' placeholder atom */
avio_seek ( pb , mov - > mdat_pos - 8 , SEEK_SET ) ;
/* special value: real atom size will be 64 bit value after
* tag field */
avio_wb32 ( pb , 1 ) ;
ffio_wfourcc ( pb , " mdat " ) ;
avio_wb64 ( pb , mov - > mdat_size + 16 ) ;
}
2012-09-20 10:40:10 +02:00
avio_seek ( pb , mov - > reserved_moov_size > 0 ? mov - > reserved_moov_pos : moov_pos , SEEK_SET ) ;
if ( mov - > reserved_moov_size = = - 1 ) {
av_log ( s , AV_LOG_INFO , " Starting second pass: moving header on top of the file \n " ) ;
res = shift_data ( s ) ;
if ( res = = 0 ) {
avio_seek ( s - > pb , mov - > reserved_moov_pos , SEEK_SET ) ;
mov_write_moov_tag ( pb , mov , s ) ;
}
} else if ( mov - > reserved_moov_size > 0 ) {
int64_t size ;
mov_write_moov_tag ( pb , mov , s ) ;
size = mov - > reserved_moov_size - ( avio_tell ( pb ) - mov - > reserved_moov_pos ) ;
2012-01-26 01:52:29 +01:00
if ( size < 8 ) {
av_log ( s , AV_LOG_ERROR , " reserved_moov_size is too small, needed % " PRId64 " additional \n " , 8 - size ) ;
return - 1 ;
}
avio_wb32 ( pb , size ) ;
ffio_wfourcc ( pb , " free " ) ;
for ( i = 0 ; i < size ; i + + )
avio_w8 ( pb , 0 ) ;
avio_seek ( pb , moov_pos , SEEK_SET ) ;
2012-09-20 10:40:10 +02:00
} else {
mov_write_moov_tag ( pb , mov , s ) ;
2011-10-26 22:09:26 +02:00
}
2012-01-05 12:57:05 +01:00
} else {
mov_flush_fragment ( s ) ;
mov_write_mfra_tag ( pb , mov ) ;
2011-10-26 22:09:26 +02:00
}
2003-08-26 22:23:13 +02:00
2010-05-05 10:41:10 +02:00
if ( mov - > chapter_track )
av_freep ( & mov - > tracks [ mov - > chapter_track ] . enc ) ;
2006-06-25 02:10:52 +02:00
for ( i = 0 ; i < mov - > nb_streams ; i + + ) {
2010-05-18 21:47:24 +02:00
if ( mov - > tracks [ i ] . tag = = MKTAG ( ' r ' , ' t ' , ' p ' , ' ' ) )
ff_mov_close_hinting ( & mov - > tracks [ i ] ) ;
2012-08-03 09:38:45 +02:00
else if ( mov - > tracks [ i ] . tag = = MKTAG ( ' t ' , ' m ' , ' c ' , ' d ' ) & & mov - > nb_meta_tmcd )
2012-03-05 08:51:08 +01:00
av_freep ( & mov - > tracks [ i ] . enc ) ;
2012-01-21 01:16:34 +01:00
if ( mov - > flags & FF_MOV_FLAG_FRAGMENT & &
mov - > tracks [ i ] . vc1_info . struct_offset & & s - > pb - > seekable ) {
int64_t off = avio_tell ( pb ) ;
uint8_t buf [ 7 ] ;
if ( mov_write_dvc1_structs ( & mov - > tracks [ i ] , buf ) > = 0 ) {
avio_seek ( pb , mov - > tracks [ i ] . vc1_info . struct_offset , SEEK_SET ) ;
avio_write ( pb , buf , 7 ) ;
avio_seek ( pb , off , SEEK_SET ) ;
}
}
2006-06-24 20:09:20 +02:00
av_freep ( & mov - > tracks [ i ] . cluster ) ;
2012-01-05 12:57:05 +01:00
av_freep ( & mov - > tracks [ i ] . frag_info ) ;
2006-06-24 20:09:20 +02:00
2012-01-30 15:19:15 +01:00
if ( mov - > tracks [ i ] . vos_len )
av_free ( mov - > tracks [ i ] . vos_data ) ;
2004-01-08 20:01:16 +01:00
2003-08-26 22:23:13 +02:00
}
2004-02-14 20:08:09 +01:00
2009-03-22 04:52:55 +01:00
av_freep ( & mov - > tracks ) ;
2003-08-26 22:23:13 +02:00
return res ;
}
2009-01-14 00:44:16 +01:00
# if CONFIG_MOV_MUXER
2011-10-03 19:14:03 +02:00
MOV_CLASS ( mov )
2011-01-25 23:03:28 +01:00
AVOutputFormat ff_mov_muxer = {
2011-07-16 22:18:12 +02:00
. name = " mov " ,
2012-07-24 03:23:48 +02:00
. long_name = NULL_IF_CONFIG_SMALL ( " QuickTime / MOV " ) ,
2011-07-16 22:18:12 +02:00
. extensions = " mov " ,
. priv_data_size = sizeof ( MOVMuxContext ) ,
2012-08-05 11:11:04 +02:00
. audio_codec = AV_CODEC_ID_AAC ,
2012-07-22 01:44:26 +02:00
. video_codec = CONFIG_LIBX264_ENCODER ?
2012-08-05 11:11:04 +02:00
AV_CODEC_ID_H264 : AV_CODEC_ID_MPEG4 ,
2011-07-16 22:18:12 +02:00
. write_header = mov_write_header ,
2012-04-11 12:37:14 +02:00
. write_packet = mov_write_packet ,
2011-07-16 22:18:12 +02:00
. write_trailer = mov_write_trailer ,
2012-04-06 16:50:48 +02:00
. flags = AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH ,
. codec_tag = ( const AVCodecTag * const [ ] ) {
ff_codec_movvideo_tags , ff_codec_movaudio_tags , 0
} ,
. priv_class = & mov_muxer_class ,
2003-08-26 22:23:13 +02:00
} ;
2006-07-10 23:14:37 +02:00
# endif
2009-01-14 00:44:16 +01:00
# if CONFIG_TGP_MUXER
2011-10-03 19:14:03 +02:00
MOV_CLASS ( tgp )
2011-01-25 23:03:28 +01:00
AVOutputFormat ff_tgp_muxer = {
2011-07-16 22:18:12 +02:00
. name = " 3gp " ,
2012-07-24 03:23:48 +02:00
. long_name = NULL_IF_CONFIG_SMALL ( " 3GP (3GPP file format) " ) ,
2011-07-16 22:18:12 +02:00
. extensions = " 3gp " ,
. priv_data_size = sizeof ( MOVMuxContext ) ,
2012-08-05 11:11:04 +02:00
. audio_codec = AV_CODEC_ID_AMR_NB ,
. video_codec = AV_CODEC_ID_H263 ,
2011-07-16 22:18:12 +02:00
. write_header = mov_write_header ,
2012-04-11 12:37:14 +02:00
. write_packet = mov_write_packet ,
2011-07-16 22:18:12 +02:00
. write_trailer = mov_write_trailer ,
2012-04-06 16:50:48 +02:00
. flags = AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH ,
. codec_tag = ( const AVCodecTag * const [ ] ) { codec_3gp_tags , 0 } ,
. priv_class = & tgp_muxer_class ,
2003-08-26 22:23:13 +02:00
} ;
2006-07-10 23:14:37 +02:00
# endif
2009-01-14 00:44:16 +01:00
# if CONFIG_MP4_MUXER
2011-10-03 19:14:03 +02:00
MOV_CLASS ( mp4 )
2011-01-25 23:03:28 +01:00
AVOutputFormat ff_mp4_muxer = {
2011-07-16 22:18:12 +02:00
. name = " mp4 " ,
2012-07-24 03:23:48 +02:00
. long_name = NULL_IF_CONFIG_SMALL ( " MP4 (MPEG-4 Part 14) " ) ,
2011-07-16 22:18:12 +02:00
. mime_type = " application/mp4 " ,
. extensions = " mp4 " ,
. priv_data_size = sizeof ( MOVMuxContext ) ,
2012-08-05 11:11:04 +02:00
. audio_codec = AV_CODEC_ID_AAC ,
2012-07-22 01:44:26 +02:00
. video_codec = CONFIG_LIBX264_ENCODER ?
2012-08-05 11:11:04 +02:00
AV_CODEC_ID_H264 : AV_CODEC_ID_MPEG4 ,
2011-07-16 22:18:12 +02:00
. write_header = mov_write_header ,
2012-04-11 12:37:14 +02:00
. write_packet = mov_write_packet ,
2011-07-16 22:18:12 +02:00
. write_trailer = mov_write_trailer ,
2012-04-06 16:50:48 +02:00
. flags = AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH ,
. codec_tag = ( const AVCodecTag * const [ ] ) { ff_mp4_obj_type , 0 } ,
. priv_class = & mp4_muxer_class ,
2003-08-26 22:23:13 +02:00
} ;
2006-07-10 23:14:37 +02:00
# endif
2009-01-14 00:44:16 +01:00
# if CONFIG_PSP_MUXER
2011-10-03 19:14:03 +02:00
MOV_CLASS ( psp )
2011-01-25 23:03:28 +01:00
AVOutputFormat ff_psp_muxer = {
2011-07-16 22:18:12 +02:00
. name = " psp " ,
2012-07-24 03:23:48 +02:00
. long_name = NULL_IF_CONFIG_SMALL ( " PSP MP4 (MPEG-4 Part 14) " ) ,
2011-07-16 22:18:12 +02:00
. extensions = " mp4,psp " ,
. priv_data_size = sizeof ( MOVMuxContext ) ,
2012-08-05 11:11:04 +02:00
. audio_codec = AV_CODEC_ID_AAC ,
2012-07-22 01:44:26 +02:00
. video_codec = CONFIG_LIBX264_ENCODER ?
2012-08-05 11:11:04 +02:00
AV_CODEC_ID_H264 : AV_CODEC_ID_MPEG4 ,
2011-07-16 22:18:12 +02:00
. write_header = mov_write_header ,
2012-04-11 12:37:14 +02:00
. write_packet = mov_write_packet ,
2011-07-16 22:18:12 +02:00
. write_trailer = mov_write_trailer ,
2012-04-06 16:50:48 +02:00
. flags = AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH ,
. codec_tag = ( const AVCodecTag * const [ ] ) { ff_mp4_obj_type , 0 } ,
. priv_class = & psp_muxer_class ,
2005-01-27 15:48:15 +01:00
} ;
2006-07-10 23:14:37 +02:00
# endif
2009-01-14 00:44:16 +01:00
# if CONFIG_TG2_MUXER
2011-10-03 19:14:03 +02:00
MOV_CLASS ( tg2 )
2011-01-25 23:03:28 +01:00
AVOutputFormat ff_tg2_muxer = {
2011-07-16 22:18:12 +02:00
. name = " 3g2 " ,
2012-07-24 03:23:48 +02:00
. long_name = NULL_IF_CONFIG_SMALL ( " 3GP2 (3GPP2 file format) " ) ,
2011-07-16 22:18:12 +02:00
. extensions = " 3g2 " ,
. priv_data_size = sizeof ( MOVMuxContext ) ,
2012-08-05 11:11:04 +02:00
. audio_codec = AV_CODEC_ID_AMR_NB ,
. video_codec = AV_CODEC_ID_H263 ,
2011-07-16 22:18:12 +02:00
. write_header = mov_write_header ,
2012-04-11 12:37:14 +02:00
. write_packet = mov_write_packet ,
2011-07-16 22:18:12 +02:00
. write_trailer = mov_write_trailer ,
2012-04-06 16:50:48 +02:00
. flags = AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH ,
. codec_tag = ( const AVCodecTag * const [ ] ) { codec_3gp_tags , 0 } ,
. priv_class = & tg2_muxer_class ,
2005-02-17 00:14:38 +01:00
} ;
2006-07-10 23:14:37 +02:00
# endif
2009-01-14 00:44:16 +01:00
# if CONFIG_IPOD_MUXER
2011-10-03 19:14:03 +02:00
MOV_CLASS ( ipod )
2011-01-25 23:03:28 +01:00
AVOutputFormat ff_ipod_muxer = {
2011-07-16 22:18:12 +02:00
. name = " ipod " ,
2012-07-24 03:23:48 +02:00
. long_name = NULL_IF_CONFIG_SMALL ( " iPod H.264 MP4 (MPEG-4 Part 14) " ) ,
2011-07-16 22:18:12 +02:00
. mime_type = " application/mp4 " ,
. extensions = " m4v,m4a " ,
. priv_data_size = sizeof ( MOVMuxContext ) ,
2012-08-05 11:11:04 +02:00
. audio_codec = AV_CODEC_ID_AAC ,
. video_codec = AV_CODEC_ID_H264 ,
2011-07-16 22:18:12 +02:00
. write_header = mov_write_header ,
2012-04-11 12:37:14 +02:00
. write_packet = mov_write_packet ,
2011-07-16 22:18:12 +02:00
. write_trailer = mov_write_trailer ,
2012-04-06 16:50:48 +02:00
. flags = AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH ,
. codec_tag = ( const AVCodecTag * const [ ] ) { codec_ipod_tags , 0 } ,
. priv_class = & ipod_muxer_class ,
2008-03-16 14:36:36 +01:00
} ;
# endif
2012-01-09 16:58:26 +01:00
# if CONFIG_ISMV_MUXER
MOV_CLASS ( ismv )
AVOutputFormat ff_ismv_muxer = {
. name = " ismv " ,
2012-07-24 23:51:41 +02:00
. long_name = NULL_IF_CONFIG_SMALL ( " ISMV/ISMA (Smooth Streaming) " ) ,
2012-01-09 16:58:26 +01:00
. mime_type = " application/mp4 " ,
. extensions = " ismv,isma " ,
. priv_data_size = sizeof ( MOVMuxContext ) ,
2012-08-05 11:11:04 +02:00
. audio_codec = AV_CODEC_ID_AAC ,
. video_codec = AV_CODEC_ID_H264 ,
2012-01-09 16:58:26 +01:00
. write_header = mov_write_header ,
2012-04-11 12:37:14 +02:00
. write_packet = mov_write_packet ,
2012-01-09 16:58:26 +01:00
. write_trailer = mov_write_trailer ,
. flags = AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH ,
2012-04-06 16:50:48 +02:00
. codec_tag = ( const AVCodecTag * const [ ] ) { ff_mp4_obj_type , 0 } ,
2012-01-09 16:58:26 +01:00
. priv_class = & ismv_muxer_class ,
} ;
# endif
2012-09-17 16:16:16 +02:00
# if CONFIG_F4V_MUXER
MOV_CLASS ( f4v )
AVOutputFormat ff_f4v_muxer = {
. name = " f4v " ,
. long_name = NULL_IF_CONFIG_SMALL ( " F4V Adobe Flash Video " ) ,
. mime_type = " application/f4v " ,
. extensions = " f4v " ,
. priv_data_size = sizeof ( MOVMuxContext ) ,
. audio_codec = AV_CODEC_ID_AAC ,
. video_codec = AV_CODEC_ID_H264 ,
. write_header = mov_write_header ,
. write_packet = mov_write_packet ,
. write_trailer = mov_write_trailer ,
. flags = AVFMT_GLOBALHEADER | AVFMT_ALLOW_FLUSH ,
. codec_tag = ( const AVCodecTag * const [ ] ) { codec_f4v_tags , 0 } ,
. priv_class = & f4v_muxer_class ,
} ;
# endif