2007-09-05 00:22:37 +00:00
/*
2007-09-05 00:25:18 +00:00
* Matroska muxer
2007-09-05 00:22:37 +00:00
* Copyright ( c ) 2007 David Conrad
*
2011-03-18 17:35:10 +00:00
* This file is part of Libav .
2007-09-05 00:22:37 +00:00
*
2011-03-18 17:35:10 +00:00
* Libav is free software ; you can redistribute it and / or
2007-09-05 00:22:37 +00:00
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation ; either
* version 2.1 of the License , or ( at your option ) any later version .
*
2011-03-18 17:35:10 +00:00
* Libav is distributed in the hope that it will be useful ,
2007-09-05 00:22:37 +00: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
2011-03-18 17:35:10 +00:00
* License along with Libav ; if not , write to the Free Software
2007-09-05 00:22:37 +00:00
* Foundation , Inc . , 51 Franklin Street , Fifth Floor , Boston , MA 02110 - 1301 USA
*/
2013-11-23 20:32:55 +00:00
# include <stdint.h>
2013-04-30 05:52:50 +00:00
# include "avc.h"
2014-03-03 14:53:44 +00:00
# include "hevc.h"
2007-09-05 00:22:37 +00:00
# include "avformat.h"
2013-04-30 05:52:50 +00:00
# include "avlanguage.h"
# include "flacenc.h"
2011-11-29 18:28:15 +00:00
# include "internal.h"
2008-07-27 15:11:04 +00:00
# include "isom.h"
2007-09-05 00:22:37 +00:00
# include "matroska.h"
2013-04-30 05:52:50 +00:00
# include "riff.h"
2014-05-26 11:53:13 +00:00
# include "vorbiscomment.h"
2013-05-28 08:09:21 +00:00
# include "wv.h"
2013-04-30 05:52:50 +00:00
# include "libavutil/avstring.h"
2014-05-26 11:53:13 +00:00
# include "libavutil/channel_layout.h"
2013-04-30 05:52:50 +00:00
# include "libavutil/dict.h"
2011-11-27 14:04:16 +00:00
# include "libavutil/intfloat.h"
2013-04-30 05:52:50 +00:00
# include "libavutil/intreadwrite.h"
# include "libavutil/lfg.h"
2011-06-04 11:58:23 +00:00
# include "libavutil/mathematics.h"
2013-04-30 06:36:20 +00:00
# include "libavutil/opt.h"
2010-06-04 22:41:03 +00:00
# include "libavutil/random_seed.h"
2013-04-30 05:52:50 +00:00
# include "libavutil/samplefmt.h"
2014-08-05 10:16:17 +00:00
# include "libavutil/stereo3d.h"
2013-04-30 05:52:50 +00:00
2008-05-09 11:56:36 +00:00
# include "libavcodec/xiph.h"
2008-04-02 21:41:48 +00:00
# include "libavcodec/mpeg4audio.h"
2007-09-05 00:22:37 +00:00
2007-09-05 00:24:56 +00:00
typedef struct ebml_master {
2008-10-03 10:16:29 +00:00
int64_t pos ; ///< absolute offset in the file where the master's elements start
2007-09-05 00:24:56 +00:00
int sizebytes ; ///< how many bytes were reserved for the size
} ebml_master ;
2007-09-05 00:23:19 +00:00
typedef struct mkv_seekhead_entry {
unsigned int elementid ;
uint64_t segmentpos ;
} mkv_seekhead_entry ;
typedef struct mkv_seekhead {
2008-10-03 10:16:29 +00:00
int64_t filepos ;
int64_t segment_offset ; ///< the file offset to the beginning of the segment
2007-09-05 00:23:26 +00:00
int reserved_size ; ///< -1 if appending to file
2007-09-05 00:23:19 +00:00
int max_entries ;
mkv_seekhead_entry * entries ;
int num_entries ;
} mkv_seekhead ;
2014-09-22 07:19:33 +00:00
typedef struct mkv_cuepoint {
2007-09-05 00:23:27 +00:00
uint64_t pts ;
int tracknum ;
2008-10-03 10:16:29 +00:00
int64_t cluster_pos ; ///< file offset of the cluster containing the block
2007-09-05 00:23:27 +00:00
} mkv_cuepoint ;
2014-09-22 07:19:33 +00:00
typedef struct mkv_cues {
2008-10-03 10:16:29 +00:00
int64_t segment_offset ;
2007-09-05 00:23:27 +00:00
mkv_cuepoint * entries ;
int num_entries ;
} mkv_cues ;
2014-09-22 07:19:33 +00:00
typedef struct mkv_track {
2010-03-09 04:23:28 +00:00
int write_dts ;
2014-04-29 10:26:38 +00:00
int64_t ts_offset ;
2010-03-09 04:23:28 +00:00
} mkv_track ;
2010-06-04 22:40:54 +00:00
# define MODE_MATROSKAv2 0x01
# define MODE_WEBM 0x02
2007-09-05 00:22:37 +00:00
typedef struct MatroskaMuxContext {
2013-04-30 06:36:20 +00:00
const AVClass * class ;
2010-06-04 22:40:54 +00:00
int mode ;
2011-02-20 10:04:12 +00:00
AVIOContext * dyn_bc ;
2007-09-05 00:24:56 +00:00
ebml_master segment ;
2008-10-03 10:16:29 +00:00
int64_t segment_offset ;
2007-09-05 00:24:56 +00:00
ebml_master cluster ;
2008-10-03 10:16:29 +00:00
int64_t cluster_pos ; ///< file offset of the current cluster
2010-03-09 04:23:36 +00:00
int64_t cluster_pts ;
2008-10-03 10:16:29 +00:00
int64_t duration_offset ;
2010-03-09 04:23:36 +00:00
int64_t duration ;
2007-09-05 00:23:19 +00:00
mkv_seekhead * main_seekhead ;
2007-09-05 00:23:27 +00:00
mkv_cues * cues ;
2010-03-09 04:23:28 +00:00
mkv_track * tracks ;
2007-09-05 00:24:29 +00:00
2010-06-04 22:40:50 +00:00
AVPacket cur_audio_pkt ;
2011-07-30 11:37:36 +00:00
int have_attachments ;
2016-05-04 19:31:28 +00:00
int have_video ;
2013-04-30 06:36:20 +00:00
int reserve_cues_space ;
2013-08-18 18:09:40 +00:00
int cluster_size_limit ;
2013-04-30 06:36:20 +00:00
int64_t cues_pos ;
2013-08-18 18:09:40 +00:00
int64_t cluster_time_limit ;
2013-09-03 17:53:34 +00:00
int wrote_chapters ;
2007-09-05 00:22:37 +00:00
} MatroskaMuxContext ;
2007-09-05 00:24:56 +00:00
2007-09-05 00:25:42 +00:00
/** 2 bytes * 3 for EBML IDs, 3 1-byte EBML lengths, 8 bytes for 64 bit
* offset , 4 bytes for target EBML ID */
2007-09-05 00:24:56 +00:00
# define MAX_SEEKENTRY_SIZE 21
2007-09-05 00:25:42 +00:00
/** per-cuepoint-track - 3 1-byte EBML IDs, 3 1-byte EBML sizes, 2
* 8 - byte uint max */
2007-09-05 00:24:56 +00:00
# define MAX_CUETRACKPOS_SIZE 22
2007-09-05 00:25:42 +00:00
/** per-cuepoint - 2 1-byte EBML IDs, 2 1-byte EBML sizes, 8-byte uint max */
2014-06-06 22:54:50 +00:00
# define MAX_CUEPOINT_SIZE(num_tracks) 12 + MAX_CUETRACKPOS_SIZE * num_tracks
2007-09-05 00:24:56 +00:00
2007-09-05 00:24:34 +00:00
static int ebml_id_size ( unsigned int id )
{
2014-06-06 22:54:50 +00:00
return ( av_log2 ( id + 1 ) - 1 ) / 7 + 1 ;
2007-09-05 00:24:34 +00:00
}
2011-02-20 10:04:12 +00:00
static void put_ebml_id ( AVIOContext * pb , unsigned int id )
2007-09-05 00:22:37 +00:00
{
2007-09-05 00:24:36 +00:00
int i = ebml_id_size ( id ) ;
while ( i - - )
2014-06-06 22:54:50 +00:00
avio_w8 ( pb , id > > ( i * 8 ) ) ;
2007-09-05 00:22:37 +00:00
}
2007-09-05 00:24:31 +00:00
/**
2007-09-05 20:31:40 +00:00
* Write an EBML size meaning " unknown size " .
2007-09-05 00:24:31 +00:00
*
2007-09-05 20:31:40 +00:00
* @ param bytes The number of bytes the size should occupy ( maximum : 8 ) .
2007-09-05 00:24:31 +00:00
*/
2011-02-20 10:04:12 +00:00
static void put_ebml_size_unknown ( AVIOContext * pb , int bytes )
2007-09-05 00:24:31 +00:00
{
2007-09-05 00:25:22 +00:00
assert ( bytes < = 8 ) ;
2011-02-21 18:28:17 +00:00
avio_w8 ( pb , 0x1ff > > bytes ) ;
2007-09-05 00:25:20 +00:00
while ( - - bytes )
2011-02-21 18:28:17 +00:00
avio_w8 ( pb , 0xff ) ;
2007-09-05 00:24:31 +00:00
}
2007-09-05 00:24:42 +00:00
/**
2007-09-05 00:26:07 +00:00
* Calculate how many bytes are needed to represent a given number in EBML .
2007-09-05 00:24:42 +00:00
*/
2007-09-05 00:26:07 +00:00
static int ebml_num_size ( uint64_t num )
2007-09-05 00:24:42 +00:00
{
int bytes = 1 ;
2014-06-06 22:54:50 +00:00
while ( ( num + 1 ) > > bytes * 7 )
bytes + + ;
2007-09-05 00:24:42 +00:00
return bytes ;
}
2007-09-05 00:24:50 +00:00
/**
2007-09-05 00:26:07 +00:00
* Write a number in EBML variable length format .
2007-09-05 00:24:50 +00:00
*
2007-09-05 00:26:07 +00:00
* @ param bytes The number of bytes that need to be used to write the number .
2007-09-05 00:24:50 +00:00
* If zero , any number of bytes can be used .
*/
2011-02-20 10:04:12 +00:00
static void put_ebml_num ( AVIOContext * pb , uint64_t num , int bytes )
2007-09-05 00:22:37 +00:00
{
2007-09-05 00:26:07 +00:00
int i , needed_bytes = ebml_num_size ( num ) ;
2007-09-05 00:22:37 +00:00
// sizes larger than this are currently undefined in EBML
2014-06-06 22:54:50 +00:00
assert ( num < ( 1ULL < < 56 ) - 1 ) ;
2007-09-05 00:23:06 +00:00
2007-09-05 00:24:50 +00:00
if ( bytes = = 0 )
// don't care how many bytes are used, so use the min
bytes = needed_bytes ;
2007-09-05 00:25:24 +00:00
// the bytes needed to write the given size would exceed the bytes
// that we need to use, so write unknown size. This shouldn't happen.
2007-09-05 00:25:22 +00:00
assert ( bytes > = needed_bytes ) ;
2007-09-05 00:24:50 +00:00
2014-06-06 22:54:50 +00:00
num | = 1ULL < < bytes * 7 ;
2007-09-05 00:24:44 +00:00
for ( i = bytes - 1 ; i > = 0 ; i - - )
2014-06-06 22:54:50 +00:00
avio_w8 ( pb , num > > i * 8 ) ;
2007-09-05 00:22:37 +00:00
}
2011-02-20 10:04:12 +00:00
static void put_ebml_uint ( AVIOContext * pb , unsigned int elementid , uint64_t val )
2007-09-05 00:22:37 +00:00
{
2007-09-05 00:24:39 +00:00
int i , bytes = 1 ;
2008-03-01 00:26:19 +00:00
uint64_t tmp = val ;
2014-06-06 22:54:50 +00:00
while ( tmp > > = 8 )
bytes + + ;
2007-09-05 00:22:37 +00:00
put_ebml_id ( pb , elementid ) ;
2007-09-05 00:26:07 +00:00
put_ebml_num ( pb , bytes , 0 ) ;
2007-09-05 00:24:39 +00:00
for ( i = bytes - 1 ; i > = 0 ; i - - )
2014-06-06 22:54:50 +00:00
avio_w8 ( pb , val > > i * 8 ) ;
2007-09-05 00:22:37 +00:00
}
2011-02-20 10:04:12 +00:00
static void put_ebml_float ( AVIOContext * pb , unsigned int elementid , double val )
2007-09-05 00:22:47 +00:00
{
put_ebml_id ( pb , elementid ) ;
2007-09-05 00:26:07 +00:00
put_ebml_num ( pb , 8 , 0 ) ;
2011-11-27 14:04:16 +00:00
avio_wb64 ( pb , av_double2int ( val ) ) ;
2007-09-05 00:22:47 +00:00
}
2011-02-20 10:04:12 +00:00
static void put_ebml_binary ( AVIOContext * pb , unsigned int elementid ,
2010-06-04 22:40:58 +00:00
const void * buf , int size )
2007-09-05 00:22:37 +00:00
{
put_ebml_id ( pb , elementid ) ;
2007-09-05 00:26:07 +00:00
put_ebml_num ( pb , size , 0 ) ;
2011-02-21 18:28:17 +00:00
avio_write ( pb , buf , size ) ;
2007-09-05 00:22:37 +00:00
}
2014-06-06 22:54:50 +00:00
static void put_ebml_string ( AVIOContext * pb , unsigned int elementid ,
const char * str )
2007-09-05 00:22:37 +00:00
{
put_ebml_binary ( pb , elementid , str , strlen ( str ) ) ;
}
2007-09-05 00:24:25 +00:00
/**
2010-06-30 15:38:06 +00:00
* Write a void element of a given size . Useful for reserving space in
2007-09-05 00:25:16 +00:00
* the file to be written to later .
2007-09-05 00:24:25 +00:00
*
2007-09-05 00:25:04 +00:00
* @ param size The number of bytes to reserve , which must be at least 2.
2007-09-05 00:24:25 +00:00
*/
2011-02-20 10:04:12 +00:00
static void put_ebml_void ( AVIOContext * pb , uint64_t size )
2007-09-05 00:23:09 +00:00
{
2011-03-03 19:11:45 +00:00
int64_t currentpos = avio_tell ( pb ) ;
2007-09-05 00:23:09 +00:00
2007-09-05 00:25:22 +00:00
assert ( size > = 2 ) ;
2007-09-05 00:23:09 +00:00
put_ebml_id ( pb , EBML_ID_VOID ) ;
2007-09-05 00:25:16 +00:00
// we need to subtract the length needed to store the size from the
// size we need to reserve so 2 cases, we use 8 bytes to store the
// size if possible, 1 byte otherwise
2007-09-05 00:23:09 +00:00
if ( size < 10 )
2014-06-06 22:54:50 +00:00
put_ebml_num ( pb , size - 1 , 0 ) ;
2007-09-05 00:23:09 +00:00
else
2014-06-06 22:54:50 +00:00
put_ebml_num ( pb , size - 9 , 8 ) ;
while ( avio_tell ( pb ) < currentpos + size )
2011-02-21 18:28:17 +00:00
avio_w8 ( pb , 0 ) ;
2007-09-05 00:23:09 +00:00
}
2014-06-06 22:54:50 +00:00
static ebml_master start_ebml_master ( AVIOContext * pb , unsigned int elementid ,
uint64_t expectedsize )
2007-09-05 00:22:37 +00:00
{
2007-09-05 00:26:07 +00:00
int bytes = expectedsize ? ebml_num_size ( expectedsize ) : 8 ;
2007-09-05 00:22:37 +00:00
put_ebml_id ( pb , elementid ) ;
2007-09-05 00:24:56 +00:00
put_ebml_size_unknown ( pb , bytes ) ;
2014-06-06 22:54:50 +00:00
return ( ebml_master ) { avio_tell ( pb ) , bytes } ;
2007-09-05 00:22:37 +00:00
}
2011-02-20 10:04:12 +00:00
static void end_ebml_master ( AVIOContext * pb , ebml_master master )
2007-09-05 00:22:37 +00:00
{
2011-03-03 19:11:45 +00:00
int64_t pos = avio_tell ( pb ) ;
2007-09-05 00:22:37 +00:00
2011-02-28 13:57:54 +00:00
if ( avio_seek ( pb , master . pos - master . sizebytes , SEEK_SET ) < 0 )
2007-09-05 00:26:00 +00:00
return ;
2007-09-05 00:26:07 +00:00
put_ebml_num ( pb , pos - master . pos , master . sizebytes ) ;
2011-02-28 13:57:54 +00:00
avio_seek ( pb , pos , SEEK_SET ) ;
2007-09-05 00:22:37 +00:00
}
2011-02-20 10:04:12 +00:00
static void put_xiph_size ( AVIOContext * pb , int size )
2007-09-05 00:24:06 +00:00
{
int i ;
for ( i = 0 ; i < size / 255 ; i + + )
2011-02-21 18:28:17 +00:00
avio_w8 ( pb , 255 ) ;
avio_w8 ( pb , size % 255 ) ;
2007-09-05 00:24:06 +00:00
}
2007-09-05 00:24:25 +00:00
/**
2007-09-05 00:25:16 +00:00
* Initialize a mkv_seekhead element to be ready to index level 1 Matroska
* elements . If a maximum number of elements is specified , enough space
* will be reserved at the current file location to write a seek head of
* that size .
2007-09-05 00:24:25 +00:00
*
2007-09-05 00:25:16 +00:00
* @ param segment_offset The absolute offset to the position in the file
2007-09-05 00:26:11 +00:00
* where the segment begins .
* @ param numelements The maximum number of elements that will be indexed
2007-09-05 00:25:16 +00:00
* by this seek head , 0 if unlimited .
2007-09-05 00:24:25 +00:00
*/
2014-06-06 22:54:50 +00:00
static mkv_seekhead * mkv_start_seekhead ( AVIOContext * pb , int64_t segment_offset ,
int numelements )
2007-09-05 00:23:19 +00:00
{
mkv_seekhead * new_seekhead = av_mallocz ( sizeof ( mkv_seekhead ) ) ;
2014-08-14 20:31:24 +00:00
if ( ! new_seekhead )
2007-09-05 00:23:19 +00:00
return NULL ;
new_seekhead - > segment_offset = segment_offset ;
if ( numelements > 0 ) {
2011-03-03 19:11:45 +00:00
new_seekhead - > filepos = avio_tell ( pb ) ;
2007-09-05 00:25:16 +00:00
// 21 bytes max for a seek entry, 10 bytes max for the SeekHead ID
// and size, and 3 bytes to guarantee that an EBML void element
// will fit afterwards
2007-09-05 00:24:56 +00:00
new_seekhead - > reserved_size = numelements * MAX_SEEKENTRY_SIZE + 13 ;
2014-06-06 22:54:50 +00:00
new_seekhead - > max_entries = numelements ;
2007-09-05 00:23:19 +00:00
put_ebml_void ( pb , new_seekhead - > reserved_size ) ;
}
return new_seekhead ;
}
static int mkv_add_seekhead_entry ( mkv_seekhead * seekhead , unsigned int elementid , uint64_t filepos )
{
2013-09-10 09:57:35 +00:00
int err ;
2007-09-05 00:23:19 +00:00
// don't store more elements than we reserved space for
if ( seekhead - > max_entries > 0 & & seekhead - > max_entries < = seekhead - > num_entries )
return - 1 ;
2013-09-12 07:49:38 +00:00
if ( ( err = av_reallocp_array ( & seekhead - > entries , seekhead - > num_entries + 1 ,
sizeof ( * seekhead - > entries ) ) ) < 0 ) {
2013-09-10 09:57:35 +00:00
seekhead - > num_entries = 0 ;
return err ;
}
2007-09-05 00:23:19 +00:00
2013-09-12 07:49:38 +00:00
seekhead - > entries [ seekhead - > num_entries ] . elementid = elementid ;
seekhead - > entries [ seekhead - > num_entries + + ] . segmentpos = filepos - seekhead - > segment_offset ;
2007-09-05 00:23:19 +00:00
return 0 ;
}
2007-09-05 00:24:25 +00:00
/**
2007-09-05 00:25:16 +00:00
* Write the seek head to the file and free it . If a maximum number of
* elements was specified to mkv_start_seekhead ( ) , the seek head will
* be written at the location reserved for it . Otherwise , it is written
* at the current location in the file .
2007-09-05 00:24:25 +00:00
*
2010-03-04 08:53:04 +00:00
* @ return The file offset where the seekhead was written ,
* - 1 if an error occurred .
2007-09-05 00:24:25 +00:00
*/
2011-02-20 10:04:12 +00:00
static int64_t mkv_write_seekhead ( AVIOContext * pb , mkv_seekhead * seekhead )
2007-09-05 00:23:19 +00:00
{
2007-09-05 00:24:56 +00:00
ebml_master metaseek , seekentry ;
2008-10-03 10:16:29 +00:00
int64_t currentpos ;
2007-09-05 00:23:19 +00:00
int i ;
2011-03-03 19:11:45 +00:00
currentpos = avio_tell ( pb ) ;
2007-09-05 00:23:19 +00:00
2011-11-07 19:06:01 +00:00
if ( seekhead - > reserved_size > 0 ) {
if ( avio_seek ( pb , seekhead - > filepos , SEEK_SET ) < 0 ) {
currentpos = - 1 ;
goto fail ;
}
}
2007-09-05 00:23:19 +00:00
2007-09-05 00:24:56 +00:00
metaseek = start_ebml_master ( pb , MATROSKA_ID_SEEKHEAD , seekhead - > reserved_size ) ;
2007-09-05 00:23:19 +00:00
for ( i = 0 ; i < seekhead - > num_entries ; i + + ) {
mkv_seekhead_entry * entry = & seekhead - > entries [ i ] ;
2007-09-05 00:24:56 +00:00
seekentry = start_ebml_master ( pb , MATROSKA_ID_SEEKENTRY , MAX_SEEKENTRY_SIZE ) ;
2007-09-05 00:23:19 +00:00
put_ebml_id ( pb , MATROSKA_ID_SEEKID ) ;
2007-09-05 00:26:07 +00:00
put_ebml_num ( pb , ebml_id_size ( entry - > elementid ) , 0 ) ;
2007-09-05 00:23:19 +00:00
put_ebml_id ( pb , entry - > elementid ) ;
put_ebml_uint ( pb , MATROSKA_ID_SEEKPOSITION , entry - > segmentpos ) ;
end_ebml_master ( pb , seekentry ) ;
}
end_ebml_master ( pb , metaseek ) ;
if ( seekhead - > reserved_size > 0 ) {
2011-03-03 19:11:45 +00:00
uint64_t remaining = seekhead - > filepos + seekhead - > reserved_size - avio_tell ( pb ) ;
2007-09-05 00:23:19 +00:00
put_ebml_void ( pb , remaining ) ;
2011-02-28 13:57:54 +00:00
avio_seek ( pb , currentpos , SEEK_SET ) ;
2007-09-05 00:23:19 +00:00
currentpos = seekhead - > filepos ;
}
2011-11-07 19:06:01 +00:00
fail :
2007-09-05 00:23:19 +00:00
av_free ( seekhead - > entries ) ;
av_free ( seekhead ) ;
return currentpos ;
}
2014-06-06 22:54:50 +00:00
static mkv_cues * mkv_start_cues ( int64_t segment_offset )
2007-09-05 00:23:27 +00:00
{
mkv_cues * cues = av_mallocz ( sizeof ( mkv_cues ) ) ;
2014-08-14 20:31:24 +00:00
if ( ! cues )
2007-09-05 00:23:27 +00:00
return NULL ;
cues - > segment_offset = segment_offset ;
return cues ;
}
2010-03-09 04:23:28 +00:00
static int mkv_add_cuepoint ( mkv_cues * cues , int stream , int64_t ts , int64_t cluster_pos )
2007-09-05 00:23:27 +00:00
{
2013-09-10 09:57:35 +00:00
int err ;
2007-09-05 00:23:27 +00:00
2012-10-09 12:54:01 +00:00
if ( ts < 0 )
return 0 ;
2013-09-12 07:49:38 +00:00
if ( ( err = av_reallocp_array ( & cues - > entries , cues - > num_entries + 1 ,
sizeof ( * cues - > entries ) ) ) < 0 ) {
2013-09-10 09:57:35 +00:00
cues - > num_entries = 0 ;
return err ;
}
2007-09-05 00:23:27 +00:00
2013-09-12 07:49:38 +00:00
cues - > entries [ cues - > num_entries ] . pts = ts ;
cues - > entries [ cues - > num_entries ] . tracknum = stream + 1 ;
cues - > entries [ cues - > num_entries + + ] . cluster_pos = cluster_pos - cues - > segment_offset ;
2007-09-05 00:23:27 +00:00
return 0 ;
}
2011-02-20 10:04:12 +00:00
static int64_t mkv_write_cues ( AVIOContext * pb , mkv_cues * cues , int num_tracks )
2007-09-05 00:23:27 +00:00
{
2007-09-05 00:24:56 +00:00
ebml_master cues_element ;
2008-10-03 10:16:29 +00:00
int64_t currentpos ;
2007-09-05 00:23:27 +00:00
int i , j ;
2011-03-03 19:11:45 +00:00
currentpos = avio_tell ( pb ) ;
2007-09-05 00:24:56 +00:00
cues_element = start_ebml_master ( pb , MATROSKA_ID_CUES , 0 ) ;
2007-09-05 00:23:27 +00:00
for ( i = 0 ; i < cues - > num_entries ; i + + ) {
2007-09-05 00:24:56 +00:00
ebml_master cuepoint , track_positions ;
2007-09-05 00:23:27 +00:00
mkv_cuepoint * entry = & cues - > entries [ i ] ;
uint64_t pts = entry - > pts ;
2007-09-05 00:24:56 +00:00
cuepoint = start_ebml_master ( pb , MATROSKA_ID_POINTENTRY , MAX_CUEPOINT_SIZE ( num_tracks ) ) ;
2007-09-05 00:23:27 +00:00
put_ebml_uint ( pb , MATROSKA_ID_CUETIME , pts ) ;
// put all the entries from different tracks that have the exact same
// timestamp into the same CuePoint
for ( j = 0 ; j < cues - > num_entries - i & & entry [ j ] . pts = = pts ; j + + ) {
2007-09-05 00:24:56 +00:00
track_positions = start_ebml_master ( pb , MATROSKA_ID_CUETRACKPOSITION , MAX_CUETRACKPOS_SIZE ) ;
2007-09-05 00:23:27 +00:00
put_ebml_uint ( pb , MATROSKA_ID_CUETRACK , entry [ j ] . tracknum ) ;
put_ebml_uint ( pb , MATROSKA_ID_CUECLUSTERPOSITION , entry [ j ] . cluster_pos ) ;
end_ebml_master ( pb , track_positions ) ;
}
i + = j - 1 ;
end_ebml_master ( pb , cuepoint ) ;
}
end_ebml_master ( pb , cues_element ) ;
return currentpos ;
}
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
static int put_xiph_codecpriv ( AVFormatContext * s , AVIOContext * pb , AVCodecParameters * par )
2007-09-05 00:23:13 +00:00
{
uint8_t * header_start [ 3 ] ;
int header_len [ 3 ] ;
int first_header_size ;
2007-09-05 00:24:06 +00:00
int j ;
2007-09-05 00:23:13 +00:00
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
if ( par - > codec_id = = AV_CODEC_ID_VORBIS )
2007-09-05 00:23:13 +00:00
first_header_size = 30 ;
else
first_header_size = 42 ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
if ( avpriv_split_xiph_headers ( par - > extradata , par - > extradata_size ,
2007-09-05 00:23:13 +00:00
first_header_size , header_start , header_len ) < 0 ) {
2007-09-05 00:26:09 +00:00
av_log ( s , AV_LOG_ERROR , " Extradata corrupt. \n " ) ;
2007-09-05 00:23:13 +00:00
return - 1 ;
}
2011-02-21 18:28:17 +00:00
avio_w8 ( pb , 2 ) ; // number packets - 1
2007-09-05 00:23:13 +00:00
for ( j = 0 ; j < 2 ; j + + ) {
2007-09-05 00:24:06 +00:00
put_xiph_size ( pb , header_len [ j ] ) ;
2007-09-05 00:23:13 +00:00
}
for ( j = 0 ; j < 3 ; j + + )
2011-02-21 18:28:17 +00:00
avio_write ( pb , header_start [ j ] , header_len [ j ] ) ;
2007-09-05 00:23:17 +00:00
return 0 ;
2007-09-05 00:23:13 +00:00
}
2007-09-05 00:22:37 +00:00
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
static int put_wv_codecpriv ( AVIOContext * pb , AVCodecParameters * par )
2013-05-28 08:09:21 +00:00
{
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
if ( par - > extradata & & par - > extradata_size = = 2 )
avio_write ( pb , par - > extradata , 2 ) ;
2013-05-28 08:09:21 +00:00
else
avio_wl16 ( pb , 0x403 ) ; // fallback to the version mentioned in matroska specs
return 0 ;
}
2014-05-26 11:53:13 +00:00
static int put_flac_codecpriv ( AVFormatContext * s ,
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
AVIOContext * pb , AVCodecParameters * par )
2014-05-26 11:53:13 +00:00
{
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
int write_comment = ( par - > channel_layout & &
! ( par - > channel_layout & ~ 0x3ffffULL ) & &
! ff_flac_is_native_layout ( par - > channel_layout ) ) ;
int ret = ff_flac_write_header ( pb , par - > extradata , par - > extradata_size ,
2014-05-26 20:14:14 +00:00
! write_comment ) ;
2014-05-26 11:53:13 +00:00
if ( ret < 0 )
return ret ;
if ( write_comment ) {
const char * vendor = ( s - > flags & AVFMT_FLAG_BITEXACT ) ?
" Libav " : LIBAVFORMAT_IDENT ;
AVDictionary * dict = NULL ;
uint8_t buf [ 32 ] , * data , * p ;
int len ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
snprintf ( buf , sizeof ( buf ) , " 0x% " PRIx64 , par - > channel_layout ) ;
2014-05-26 11:53:13 +00:00
av_dict_set ( & dict , " WAVEFORMATEXTENSIBLE_CHANNEL_MASK " , buf , 0 ) ;
len = ff_vorbiscomment_length ( dict , vendor ) ;
data = av_malloc ( len + 4 ) ;
if ( ! data ) {
av_dict_free ( & dict ) ;
return AVERROR ( ENOMEM ) ;
}
data [ 0 ] = 0x84 ;
AV_WB24 ( data + 1 , len ) ;
p = data + 4 ;
ff_vorbiscomment_write ( & p , & dict , vendor ) ;
avio_write ( pb , data , len + 4 ) ;
av_freep ( & data ) ;
av_dict_free ( & dict ) ;
}
return 0 ;
}
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
static int get_aac_sample_rates ( AVFormatContext * s , AVCodecParameters * par ,
2015-01-01 17:22:46 +00:00
int * sample_rate , int * output_sample_rate )
2007-09-05 00:23:43 +00:00
{
2011-03-21 08:05:36 +00:00
MPEG4AudioConfig mp4ac ;
2007-09-05 00:23:43 +00:00
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
if ( avpriv_mpeg4audio_get_config ( & mp4ac , par - > extradata ,
par - > extradata_size * 8 , 1 ) < 0 ) {
2015-01-01 17:22:46 +00:00
av_log ( s , AV_LOG_ERROR ,
2014-06-06 22:54:50 +00:00
" Error parsing AAC extradata, unable to determine samplerate. \n " ) ;
2015-01-01 17:22:46 +00:00
return AVERROR ( EINVAL ) ;
2007-09-05 00:23:43 +00:00
}
2011-03-21 08:05:36 +00:00
* sample_rate = mp4ac . sample_rate ;
* output_sample_rate = mp4ac . ext_sample_rate ;
2015-01-01 17:22:46 +00:00
return 0 ;
2007-09-05 00:23:43 +00:00
}
2014-06-06 23:21:13 +00:00
static int mkv_write_native_codecprivate ( AVFormatContext * s ,
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
AVCodecParameters * par ,
2014-06-06 23:21:13 +00:00
AVIOContext * dyn_cp )
{
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
switch ( par - > codec_id ) {
2014-06-06 23:21:13 +00:00
case AV_CODEC_ID_VORBIS :
case AV_CODEC_ID_THEORA :
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
return put_xiph_codecpriv ( s , dyn_cp , par ) ;
2014-06-06 23:21:13 +00:00
case AV_CODEC_ID_FLAC :
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
return put_flac_codecpriv ( s , dyn_cp , par ) ;
2014-06-06 23:21:13 +00:00
case AV_CODEC_ID_WAVPACK :
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
return put_wv_codecpriv ( dyn_cp , par ) ;
2014-06-06 23:21:13 +00:00
case AV_CODEC_ID_H264 :
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
return ff_isom_write_avcc ( dyn_cp , par - > extradata ,
par - > extradata_size ) ;
2014-06-06 23:21:13 +00:00
case AV_CODEC_ID_HEVC :
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
return ff_isom_write_hvcc ( dyn_cp , par - > extradata ,
par - > extradata_size , 0 ) ;
2014-06-06 23:21:13 +00:00
case AV_CODEC_ID_ALAC :
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
if ( par - > extradata_size < 36 ) {
2014-06-06 23:21:13 +00:00
av_log ( s , AV_LOG_ERROR ,
" Invalid extradata found, ALAC expects a 36-byte "
" QuickTime atom. " ) ;
return AVERROR_INVALIDDATA ;
} else
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
avio_write ( dyn_cp , par - > extradata + 12 ,
par - > extradata_size - 12 ) ;
2014-06-06 23:21:13 +00:00
break ;
default :
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
if ( par - > extradata_size )
avio_write ( dyn_cp , par - > extradata , par - > extradata_size ) ;
2014-06-06 23:21:13 +00:00
}
return 0 ;
}
2014-06-06 22:54:50 +00:00
static int mkv_write_codecprivate ( AVFormatContext * s , AVIOContext * pb ,
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
AVCodecParameters * par ,
int native_id , int qt_id )
2007-09-05 00:25:49 +00:00
{
2011-02-20 10:04:12 +00:00
AVIOContext * dyn_cp ;
2007-09-05 00:25:52 +00:00
uint8_t * codecpriv ;
2007-11-21 07:41:00 +00:00
int ret , codecpriv_size ;
2007-09-05 00:25:52 +00:00
2011-03-17 07:13:34 +00:00
ret = avio_open_dyn_buf ( & dyn_cp ) ;
2014-06-06 22:54:50 +00:00
if ( ret < 0 )
2007-11-21 07:41:00 +00:00
return ret ;
2007-09-05 00:25:49 +00:00
if ( native_id ) {
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
ret = mkv_write_native_codecprivate ( s , par , dyn_cp ) ;
} else if ( par - > codec_type = = AVMEDIA_TYPE_VIDEO ) {
2008-07-27 15:11:04 +00:00
if ( qt_id ) {
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
if ( ! par - > codec_tag )
par - > codec_tag = ff_codec_get_tag ( ff_codec_movvideo_tags ,
par - > codec_id ) ;
if ( par - > extradata_size )
avio_write ( dyn_cp , par - > extradata , par - > extradata_size ) ;
2008-07-27 15:11:04 +00:00
} else {
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
if ( ! par - > codec_tag )
par - > codec_tag = ff_codec_get_tag ( ff_codec_bmp_tags ,
par - > codec_id ) ;
if ( ! par - > codec_tag ) {
2010-03-15 19:03:48 +00:00
av_log ( s , AV_LOG_ERROR , " No bmp codec ID found. \n " ) ;
2010-03-04 08:53:11 +00:00
ret = - 1 ;
}
2007-09-05 00:25:49 +00:00
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
ff_put_bmp_header ( dyn_cp , par , ff_codec_bmp_tags , 0 ) ;
2008-07-27 15:11:04 +00:00
}
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
} else if ( par - > codec_type = = AVMEDIA_TYPE_AUDIO ) {
2010-03-25 14:34:19 +00:00
unsigned int tag ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
tag = ff_codec_get_tag ( ff_codec_wav_tags , par - > codec_id ) ;
2010-03-25 14:34:19 +00:00
if ( ! tag ) {
2010-03-15 19:03:48 +00:00
av_log ( s , AV_LOG_ERROR , " No wav codec ID found. \n " ) ;
2007-09-05 00:25:52 +00:00
ret = - 1 ;
2007-09-05 00:25:49 +00:00
}
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
if ( ! par - > codec_tag )
par - > codec_tag = tag ;
2007-09-05 00:25:49 +00:00
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
ff_put_wav_header ( s , dyn_cp , par ) ;
2007-09-05 00:25:49 +00:00
}
2007-09-05 00:25:52 +00:00
2011-03-17 07:16:07 +00:00
codecpriv_size = avio_close_dyn_buf ( dyn_cp , & codecpriv ) ;
2007-09-05 00:25:52 +00:00
if ( codecpriv_size )
2014-06-06 22:54:50 +00:00
put_ebml_binary ( pb , MATROSKA_ID_CODECPRIVATE , codecpriv ,
codecpriv_size ) ;
2007-09-05 00:25:52 +00:00
av_free ( codecpriv ) ;
return ret ;
2007-09-05 00:25:49 +00:00
}
2016-04-02 20:35:44 +00:00
static void mkv_write_field_order ( AVIOContext * pb ,
enum AVFieldOrder field_order )
{
switch ( field_order ) {
case AV_FIELD_UNKNOWN :
put_ebml_uint ( pb , MATROSKA_ID_VIDEOFLAGINTERLACED ,
MATROSKA_VIDEO_INTERLACE_FLAG_UNDETERMINED ) ;
break ;
case AV_FIELD_PROGRESSIVE :
put_ebml_uint ( pb , MATROSKA_ID_VIDEOFLAGINTERLACED ,
MATROSKA_VIDEO_INTERLACE_FLAG_PROGRESSIVE ) ;
break ;
case AV_FIELD_TT :
case AV_FIELD_BB :
case AV_FIELD_TB :
case AV_FIELD_BT :
put_ebml_uint ( pb , MATROSKA_ID_VIDEOFLAGINTERLACED ,
MATROSKA_VIDEO_INTERLACE_FLAG_INTERLACED ) ;
switch ( field_order ) {
case AV_FIELD_TT :
put_ebml_uint ( pb , MATROSKA_ID_VIDEOFIELDORDER ,
MATROSKA_VIDEO_FIELDORDER_TT ) ;
break ;
case AV_FIELD_BB :
put_ebml_uint ( pb , MATROSKA_ID_VIDEOFIELDORDER ,
MATROSKA_VIDEO_FIELDORDER_BB ) ;
break ;
case AV_FIELD_TB :
put_ebml_uint ( pb , MATROSKA_ID_VIDEOFIELDORDER ,
MATROSKA_VIDEO_FIELDORDER_TB ) ;
break ;
case AV_FIELD_BT :
put_ebml_uint ( pb , MATROSKA_ID_VIDEOFIELDORDER ,
MATROSKA_VIDEO_FIELDORDER_BT ) ;
break ;
}
}
}
2014-08-05 10:16:17 +00:00
static int mkv_write_stereo_mode ( AVFormatContext * s , AVIOContext * pb ,
AVStream * st , int mode )
2014-06-06 23:38:00 +00:00
{
2014-08-05 10:16:17 +00:00
int i ;
2014-10-22 13:36:32 +00:00
int display_width , display_height ;
int h_width = 1 , h_height = 1 ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
AVCodecParameters * par = st - > codecpar ;
2014-08-05 10:16:17 +00:00
AVDictionaryEntry * tag ;
MatroskaVideoStereoModeType format = MATROSKA_VIDEO_STEREOMODE_TYPE_NB ;
// convert metadata into proper side data and add it to the stream
if ( ( tag = av_dict_get ( s - > metadata , " stereo_mode " , NULL , 0 ) ) ) {
int stereo_mode = atoi ( tag - > value ) ;
if ( stereo_mode < MATROSKA_VIDEO_STEREOMODE_TYPE_NB & &
stereo_mode ! = 10 & & stereo_mode ! = 12 ) {
int ret = ff_mkv_stereo3d_conv ( st , stereo_mode ) ;
if ( ret < 0 )
return ret ;
}
}
2014-06-06 23:38:00 +00:00
2014-10-22 13:36:32 +00:00
// iterate to find the stereo3d side data
2014-08-05 10:16:17 +00:00
for ( i = 0 ; i < st - > nb_side_data ; i + + ) {
AVPacketSideData sd = st - > side_data [ i ] ;
if ( sd . type = = AV_PKT_DATA_STEREO3D ) {
AVStereo3D * stereo = ( AVStereo3D * ) sd . data ;
switch ( stereo - > type ) {
case AV_STEREO3D_2D :
format = MATROSKA_VIDEO_STEREOMODE_TYPE_MONO ;
break ;
case AV_STEREO3D_SIDEBYSIDE :
format = ( stereo - > flags & AV_STEREO3D_FLAG_INVERT )
? MATROSKA_VIDEO_STEREOMODE_TYPE_RIGHT_LEFT
: MATROSKA_VIDEO_STEREOMODE_TYPE_LEFT_RIGHT ;
2014-10-22 13:36:32 +00:00
h_width = 2 ;
2014-08-05 10:16:17 +00:00
break ;
case AV_STEREO3D_TOPBOTTOM :
format = MATROSKA_VIDEO_STEREOMODE_TYPE_TOP_BOTTOM ;
if ( stereo - > flags & AV_STEREO3D_FLAG_INVERT )
format - - ;
2014-10-22 13:36:32 +00:00
h_height = 2 ;
2014-08-05 10:16:17 +00:00
break ;
case AV_STEREO3D_CHECKERBOARD :
format = MATROSKA_VIDEO_STEREOMODE_TYPE_CHECKERBOARD_LR ;
if ( stereo - > flags & AV_STEREO3D_FLAG_INVERT )
format - - ;
break ;
case AV_STEREO3D_LINES :
format = MATROSKA_VIDEO_STEREOMODE_TYPE_ROW_INTERLEAVED_LR ;
if ( stereo - > flags & AV_STEREO3D_FLAG_INVERT )
format - - ;
2014-10-22 13:36:32 +00:00
h_height = 2 ;
2014-08-05 10:16:17 +00:00
break ;
case AV_STEREO3D_COLUMNS :
format = MATROSKA_VIDEO_STEREOMODE_TYPE_COL_INTERLEAVED_LR ;
if ( stereo - > flags & AV_STEREO3D_FLAG_INVERT )
format - - ;
2014-10-22 13:36:32 +00:00
h_width = 2 ;
2014-08-05 10:16:17 +00:00
break ;
case AV_STEREO3D_FRAMESEQUENCE :
format = MATROSKA_VIDEO_STEREOMODE_TYPE_BOTH_EYES_BLOCK_LR ;
if ( stereo - > flags & AV_STEREO3D_FLAG_INVERT )
format + + ;
break ;
}
break ;
}
2014-06-06 23:38:00 +00:00
}
2014-10-22 13:36:32 +00:00
// if webm, do not write unsupported modes
2014-08-05 10:16:17 +00:00
if ( mode = = MODE_WEBM & &
( format > MATROSKA_VIDEO_STEREOMODE_TYPE_TOP_BOTTOM & &
format ! = MATROSKA_VIDEO_STEREOMODE_TYPE_RIGHT_LEFT ) )
format = MATROSKA_VIDEO_STEREOMODE_TYPE_NB ;
2014-10-22 13:36:32 +00:00
// write StereoMode if format is valid
2014-08-05 10:16:17 +00:00
if ( format < MATROSKA_VIDEO_STEREOMODE_TYPE_NB )
put_ebml_uint ( pb , MATROSKA_ID_VIDEOSTEREOMODE , format ) ;
2014-10-22 13:36:32 +00:00
// write DisplayWidth and DisplayHeight, they contain the size of
// a single source view and/or the display aspect ratio
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
display_width = par - > width / h_width ;
display_height = par - > height / h_height ;
2014-10-22 13:36:32 +00:00
if ( st - > sample_aspect_ratio . num ) {
display_width * = av_q2d ( st - > sample_aspect_ratio ) ;
put_ebml_uint ( pb , MATROSKA_ID_VIDEODISPLAYUNIT , 3 ) ; // DAR
}
if ( st - > sample_aspect_ratio . num | |
format < MATROSKA_VIDEO_STEREOMODE_TYPE_NB ) {
put_ebml_uint ( pb , MATROSKA_ID_VIDEODISPLAYWIDTH , display_width ) ;
put_ebml_uint ( pb , MATROSKA_ID_VIDEODISPLAYHEIGHT , display_height ) ;
}
2014-08-05 10:16:17 +00:00
return 0 ;
2014-06-06 23:38:00 +00:00
}
2014-06-06 23:21:13 +00:00
static int mkv_write_track ( AVFormatContext * s , MatroskaMuxContext * mkv ,
int i , AVIOContext * pb )
2007-09-05 00:22:37 +00:00
{
2014-06-06 23:21:13 +00:00
AVStream * st = s - > streams [ i ] ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
AVCodecParameters * par = st - > codecpar ;
2014-06-06 23:21:13 +00:00
ebml_master subinfo , track ;
int native_id = 0 ;
int qt_id = 0 ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
int bit_depth = av_get_bits_per_sample ( par - > codec_id ) ;
int sample_rate = par - > sample_rate ;
2014-06-06 23:21:13 +00:00
int output_sample_rate = 0 ;
int j , ret ;
AVDictionaryEntry * tag ;
// ms precision is the de-facto standard timescale for mkv files
avpriv_set_pts_info ( st , 64 , 1 , 1000 ) ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
if ( par - > codec_type = = AVMEDIA_TYPE_ATTACHMENT ) {
2014-06-06 23:21:13 +00:00
mkv - > have_attachments = 1 ;
return 0 ;
}
2007-09-05 00:22:37 +00:00
2014-06-06 23:21:13 +00:00
if ( ! bit_depth )
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
bit_depth = av_get_bytes_per_sample ( par - > format ) < < 3 ;
2007-09-05 00:23:19 +00:00
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
if ( par - > codec_id = = AV_CODEC_ID_AAC ) {
ret = get_aac_sample_rates ( s , par , & sample_rate , & output_sample_rate ) ;
2015-01-01 17:22:46 +00:00
if ( ret < 0 )
return ret ;
}
2011-07-30 11:37:36 +00:00
2014-06-06 23:21:13 +00:00
track = start_ebml_master ( pb , MATROSKA_ID_TRACKENTRY , 0 ) ;
put_ebml_uint ( pb , MATROSKA_ID_TRACKNUMBER , i + 1 ) ;
put_ebml_uint ( pb , MATROSKA_ID_TRACKUID , i + 1 ) ;
put_ebml_uint ( pb , MATROSKA_ID_TRACKFLAGLACING , 0 ) ; // no lacing (yet)
2007-09-05 00:25:14 +00:00
2014-06-06 23:21:13 +00:00
if ( ( tag = av_dict_get ( st - > metadata , " title " , NULL , 0 ) ) )
put_ebml_string ( pb , MATROSKA_ID_TRACKNAME , tag - > value ) ;
tag = av_dict_get ( st - > metadata , " language " , NULL , 0 ) ;
put_ebml_string ( pb , MATROSKA_ID_TRACKLANGUAGE , tag ? tag - > value : " und " ) ;
2007-09-05 00:22:50 +00:00
2014-06-06 23:21:13 +00:00
// The default value for TRACKFLAGDEFAULT is 1, so add element
// if we need to clear it.
if ( ! ( st - > disposition & AV_DISPOSITION_DEFAULT ) )
put_ebml_uint ( pb , MATROSKA_ID_TRACKFLAGDEFAULT , ! ! ( st - > disposition & AV_DISPOSITION_DEFAULT ) ) ;
2015-02-24 20:44:48 +00:00
if ( st - > disposition & AV_DISPOSITION_FORCED )
put_ebml_uint ( pb , MATROSKA_ID_TRACKFLAGFORCED , ! ! ( st - > disposition & AV_DISPOSITION_FORCED ) ) ;
2007-09-05 00:22:50 +00:00
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
if ( par - > codec_type = = AVMEDIA_TYPE_AUDIO & & par - > initial_padding ) {
mkv - > tracks [ i ] . ts_offset = av_rescale_q ( par - > initial_padding ,
( AVRational ) { 1 , par - > sample_rate } ,
2014-06-06 23:21:13 +00:00
st - > time_base ) ;
2007-09-05 00:22:50 +00:00
2014-06-06 23:21:13 +00:00
put_ebml_uint ( pb , MATROSKA_ID_CODECDELAY ,
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
av_rescale_q ( par - > initial_padding ,
( AVRational ) { 1 , par - > sample_rate } ,
2014-06-06 23:21:13 +00:00
( AVRational ) { 1 , 1000000000 } ) ) ;
}
// look for a codec ID string specific to mkv to use,
// if none are found, use AVI codes
for ( j = 0 ; ff_mkv_codec_tags [ j ] . id ! = AV_CODEC_ID_NONE ; j + + ) {
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
if ( ff_mkv_codec_tags [ j ] . id = = par - > codec_id ) {
2014-06-06 23:21:13 +00:00
put_ebml_string ( pb , MATROSKA_ID_CODECID , ff_mkv_codec_tags [ j ] . str ) ;
native_id = 1 ;
break ;
}
}
2008-03-07 19:25:09 +00:00
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
if ( mkv - > mode = = MODE_WEBM & & ! ( par - > codec_id = = AV_CODEC_ID_VP8 | |
par - > codec_id = = AV_CODEC_ID_VP9 | |
par - > codec_id = = AV_CODEC_ID_OPUS | |
par - > codec_id = = AV_CODEC_ID_VORBIS ) ) {
2014-06-06 23:21:13 +00:00
av_log ( s , AV_LOG_ERROR ,
" Only VP8 or VP9 video and Vorbis or Opus audio are supported for WebM. \n " ) ;
return AVERROR ( EINVAL ) ;
}
2014-04-29 10:26:38 +00:00
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
switch ( par - > codec_type ) {
2014-06-06 23:21:13 +00:00
case AVMEDIA_TYPE_VIDEO :
2016-05-04 19:31:28 +00:00
mkv - > have_video = 1 ;
2014-06-06 23:21:13 +00:00
put_ebml_uint ( pb , MATROSKA_ID_TRACKTYPE , MATROSKA_TRACK_TYPE_VIDEO ) ;
if ( st - > avg_frame_rate . num > 0 & & st - > avg_frame_rate . den > 0 )
put_ebml_uint ( pb , MATROSKA_ID_TRACKDEFAULTDURATION , 1E9 / av_q2d ( st - > avg_frame_rate ) ) ;
if ( ! native_id & &
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
ff_codec_get_tag ( ff_codec_movvideo_tags , par - > codec_id ) & &
( ! ff_codec_get_tag ( ff_codec_bmp_tags , par - > codec_id ) | |
par - > codec_id = = AV_CODEC_ID_SVQ1 | |
par - > codec_id = = AV_CODEC_ID_SVQ3 | |
par - > codec_id = = AV_CODEC_ID_CINEPAK ) )
2014-06-06 23:21:13 +00:00
qt_id = 1 ;
if ( qt_id )
put_ebml_string ( pb , MATROSKA_ID_CODECID , " V_QUICKTIME " ) ;
else if ( ! native_id ) {
// if there is no mkv-specific codec ID, use VFW mode
put_ebml_string ( pb , MATROSKA_ID_CODECID , " V_MS/VFW/FOURCC " ) ;
mkv - > tracks [ i ] . write_dts = 1 ;
2014-04-29 10:26:38 +00:00
}
2014-06-06 23:21:13 +00:00
subinfo = start_ebml_master ( pb , MATROSKA_ID_TRACKVIDEO , 0 ) ;
2016-04-02 20:35:44 +00:00
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
put_ebml_uint ( pb , MATROSKA_ID_VIDEOPIXELWIDTH , par - > width ) ;
put_ebml_uint ( pb , MATROSKA_ID_VIDEOPIXELHEIGHT , par - > height ) ;
2014-08-05 10:16:17 +00:00
2016-04-02 20:35:44 +00:00
mkv_write_field_order ( pb , par - > field_order ) ;
2014-08-05 10:16:17 +00:00
// check both side data and metadata for stereo information,
// write the result to the bitstream if any is found
ret = mkv_write_stereo_mode ( s , pb , st , mkv - > mode ) ;
if ( ret < 0 )
return ret ;
2014-06-06 23:21:13 +00:00
end_ebml_master ( pb , subinfo ) ;
break ;
case AVMEDIA_TYPE_AUDIO :
put_ebml_uint ( pb , MATROSKA_ID_TRACKTYPE , MATROSKA_TRACK_TYPE_AUDIO ) ;
if ( ! native_id )
// no mkv-specific ID, use ACM mode
put_ebml_string ( pb , MATROSKA_ID_CODECID , " A_MS/ACM " ) ;
subinfo = start_ebml_master ( pb , MATROSKA_ID_TRACKAUDIO , 0 ) ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
put_ebml_uint ( pb , MATROSKA_ID_AUDIOCHANNELS , par - > channels ) ;
2014-06-06 23:21:13 +00:00
put_ebml_float ( pb , MATROSKA_ID_AUDIOSAMPLINGFREQ , sample_rate ) ;
if ( output_sample_rate )
put_ebml_float ( pb , MATROSKA_ID_AUDIOOUTSAMPLINGFREQ , output_sample_rate ) ;
if ( bit_depth )
put_ebml_uint ( pb , MATROSKA_ID_AUDIOBITDEPTH , bit_depth ) ;
end_ebml_master ( pb , subinfo ) ;
break ;
case AVMEDIA_TYPE_SUBTITLE :
put_ebml_uint ( pb , MATROSKA_ID_TRACKTYPE , MATROSKA_TRACK_TYPE_SUBTITLE ) ;
if ( ! native_id ) {
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
av_log ( s , AV_LOG_ERROR , " Subtitle codec %d is not supported. \n " , par - > codec_id ) ;
2014-06-06 23:21:13 +00:00
return AVERROR ( ENOSYS ) ;
}
break ;
default :
av_log ( s , AV_LOG_ERROR , " Only audio, video, and subtitles are supported for Matroska. \n " ) ;
break ;
}
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
ret = mkv_write_codecprivate ( s , pb , par , native_id , qt_id ) ;
2014-06-06 23:21:13 +00:00
if ( ret < 0 )
return ret ;
2010-06-04 22:40:54 +00:00
2014-06-06 23:21:13 +00:00
end_ebml_master ( pb , track ) ;
2007-09-05 00:25:58 +00:00
2014-06-06 23:21:13 +00:00
return 0 ;
}
2014-06-06 22:54:50 +00:00
2014-06-06 23:21:13 +00:00
static int mkv_write_tracks ( AVFormatContext * s )
{
MatroskaMuxContext * mkv = s - > priv_data ;
AVIOContext * pb = s - > pb ;
ebml_master tracks ;
int i , ret ;
2014-06-06 22:54:50 +00:00
2014-06-06 23:21:13 +00:00
ret = mkv_add_seekhead_entry ( mkv - > main_seekhead , MATROSKA_ID_TRACKS , avio_tell ( pb ) ) ;
if ( ret < 0 )
return ret ;
tracks = start_ebml_master ( pb , MATROSKA_ID_TRACKS , 0 ) ;
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
ret = mkv_write_track ( s , mkv , i , pb ) ;
2014-06-06 22:54:50 +00:00
if ( ret < 0 )
return ret ;
2007-09-05 00:22:37 +00:00
}
end_ebml_master ( pb , tracks ) ;
2007-09-05 00:23:17 +00:00
return 0 ;
2007-09-05 00:23:15 +00:00
}
2009-10-18 12:17:01 +00:00
static int mkv_write_chapters ( AVFormatContext * s )
{
MatroskaMuxContext * mkv = s - > priv_data ;
2011-02-20 10:04:12 +00:00
AVIOContext * pb = s - > pb ;
2009-10-18 12:17:01 +00:00
ebml_master chapters , editionentry ;
AVRational scale = { 1 , 1E9 } ;
int i , ret ;
2013-09-03 17:53:34 +00:00
if ( ! s - > nb_chapters | | mkv - > wrote_chapters )
2009-10-18 12:17:01 +00:00
return 0 ;
2011-03-03 19:11:45 +00:00
ret = mkv_add_seekhead_entry ( mkv - > main_seekhead , MATROSKA_ID_CHAPTERS , avio_tell ( pb ) ) ;
2009-10-18 12:17:01 +00:00
if ( ret < 0 ) return ret ;
chapters = start_ebml_master ( pb , MATROSKA_ID_CHAPTERS , 0 ) ;
editionentry = start_ebml_master ( pb , MATROSKA_ID_EDITIONENTRY , 0 ) ;
put_ebml_uint ( pb , MATROSKA_ID_EDITIONFLAGDEFAULT , 1 ) ;
put_ebml_uint ( pb , MATROSKA_ID_EDITIONFLAGHIDDEN , 0 ) ;
for ( i = 0 ; i < s - > nb_chapters ; i + + ) {
ebml_master chapteratom , chapterdisplay ;
AVChapter * c = s - > chapters [ i ] ;
2015-03-11 14:56:52 +00:00
int64_t chapterstart = av_rescale_q ( c - > start , c - > time_base , scale ) ;
int64_t chapterend = av_rescale_q ( c - > end , c - > time_base , scale ) ;
2011-05-22 10:46:29 +00:00
AVDictionaryEntry * t = NULL ;
2015-03-09 00:05:30 +00:00
if ( chapterstart < 0 | | chapterstart > chapterend | | chapterend < 0 ) {
2015-03-11 14:56:52 +00:00
av_log ( s , AV_LOG_ERROR ,
" Invalid chapter start (% " PRId64 " ) or end (% " PRId64 " ). \n " ,
2015-03-09 00:05:30 +00:00
chapterstart , chapterend ) ;
2015-02-03 15:40:34 +00:00
return AVERROR_INVALIDDATA ;
2015-03-09 00:05:30 +00:00
}
2009-10-18 12:17:01 +00:00
chapteratom = start_ebml_master ( pb , MATROSKA_ID_CHAPTERATOM , 0 ) ;
put_ebml_uint ( pb , MATROSKA_ID_CHAPTERUID , c - > id ) ;
2015-02-03 15:40:34 +00:00
put_ebml_uint ( pb , MATROSKA_ID_CHAPTERTIMESTART , chapterstart ) ;
put_ebml_uint ( pb , MATROSKA_ID_CHAPTERTIMEEND , chapterend ) ;
2009-10-18 12:17:01 +00:00
put_ebml_uint ( pb , MATROSKA_ID_CHAPTERFLAGHIDDEN , 0 ) ;
put_ebml_uint ( pb , MATROSKA_ID_CHAPTERFLAGENABLED , 1 ) ;
2011-05-22 10:46:29 +00:00
if ( ( t = av_dict_get ( c - > metadata , " title " , NULL , 0 ) ) ) {
2009-10-18 12:17:01 +00:00
chapterdisplay = start_ebml_master ( pb , MATROSKA_ID_CHAPTERDISPLAY , 0 ) ;
put_ebml_string ( pb , MATROSKA_ID_CHAPSTRING , t - > value ) ;
put_ebml_string ( pb , MATROSKA_ID_CHAPLANG , " und " ) ;
end_ebml_master ( pb , chapterdisplay ) ;
}
end_ebml_master ( pb , chapteratom ) ;
}
end_ebml_master ( pb , editionentry ) ;
end_ebml_master ( pb , chapters ) ;
2013-09-03 17:53:34 +00:00
mkv - > wrote_chapters = 1 ;
2009-10-18 12:17:01 +00:00
return 0 ;
}
2014-12-17 13:53:45 +00:00
static int mkv_write_simpletag ( AVIOContext * pb , AVDictionaryEntry * t )
2010-10-05 09:40:43 +00:00
{
uint8_t * key = av_strdup ( t - > key ) ;
uint8_t * p = key ;
const uint8_t * lang = NULL ;
ebml_master tag ;
2014-12-17 13:53:45 +00:00
if ( ! key )
return AVERROR ( ENOMEM ) ;
2010-10-05 09:40:43 +00:00
if ( ( p = strrchr ( p , ' - ' ) ) & &
( lang = av_convert_lang_to ( p + 1 , AV_LANG_ISO639_2_BIBL ) ) )
* p = 0 ;
p = key ;
while ( * p ) {
if ( * p = = ' ' )
* p = ' _ ' ;
else if ( * p > = ' a ' & & * p < = ' z ' )
* p - = ' a ' - ' A ' ;
p + + ;
}
tag = start_ebml_master ( pb , MATROSKA_ID_SIMPLETAG , 0 ) ;
put_ebml_string ( pb , MATROSKA_ID_TAGNAME , key ) ;
if ( lang )
put_ebml_string ( pb , MATROSKA_ID_TAGLANG , lang ) ;
put_ebml_string ( pb , MATROSKA_ID_TAGSTRING , t - > value ) ;
end_ebml_master ( pb , tag ) ;
av_freep ( & key ) ;
2014-12-17 13:53:45 +00:00
return 0 ;
2010-10-05 09:40:43 +00:00
}
2011-05-22 10:46:29 +00:00
static int mkv_write_tag ( AVFormatContext * s , AVDictionary * m , unsigned int elementid ,
2010-10-05 09:40:43 +00:00
unsigned int uid , ebml_master * tags )
{
MatroskaMuxContext * mkv = s - > priv_data ;
ebml_master tag , targets ;
2011-05-22 10:46:29 +00:00
AVDictionaryEntry * t = NULL ;
2010-10-05 09:40:43 +00:00
int ret ;
if ( ! tags - > pos ) {
2011-03-03 19:11:45 +00:00
ret = mkv_add_seekhead_entry ( mkv - > main_seekhead , MATROSKA_ID_TAGS , avio_tell ( s - > pb ) ) ;
2010-10-05 09:40:43 +00:00
if ( ret < 0 ) return ret ;
* tags = start_ebml_master ( s - > pb , MATROSKA_ID_TAGS , 0 ) ;
}
tag = start_ebml_master ( s - > pb , MATROSKA_ID_TAG , 0 ) ;
targets = start_ebml_master ( s - > pb , MATROSKA_ID_TAGTARGETS , 0 ) ;
if ( elementid )
put_ebml_uint ( s - > pb , elementid , uid ) ;
end_ebml_master ( s - > pb , targets ) ;
2014-12-17 13:53:45 +00:00
while ( ( t = av_dict_get ( m , " " , t , AV_DICT_IGNORE_SUFFIX ) ) ) {
2014-03-03 20:20:14 +00:00
if ( av_strcasecmp ( t - > key , " title " ) & &
2015-09-25 15:36:30 +00:00
av_strcasecmp ( t - > key , " encoding_tool " ) & &
( elementid ! = MATROSKA_ID_TAGTARGETS_TRACKUID | |
av_strcasecmp ( t - > key , " language " ) ) ) {
2014-12-17 13:53:45 +00:00
ret = mkv_write_simpletag ( s - > pb , t ) ;
if ( ret < 0 )
return ret ;
}
}
2010-10-05 09:40:43 +00:00
end_ebml_master ( s - > pb , tag ) ;
return 0 ;
}
static int mkv_write_tags ( AVFormatContext * s )
{
ebml_master tags = { 0 } ;
int i , ret ;
2010-10-15 19:04:25 +00:00
ff_metadata_conv_ctx ( s , ff_mkv_metadata_conv , NULL ) ;
2011-05-22 10:46:29 +00:00
if ( av_dict_get ( s - > metadata , " " , NULL , AV_DICT_IGNORE_SUFFIX ) ) {
2010-10-05 09:40:43 +00:00
ret = mkv_write_tag ( s , s - > metadata , 0 , 0 , & tags ) ;
if ( ret < 0 ) return ret ;
}
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
AVStream * st = s - > streams [ i ] ;
2011-05-22 10:46:29 +00:00
if ( ! av_dict_get ( st - > metadata , " " , 0 , AV_DICT_IGNORE_SUFFIX ) )
2010-10-05 09:40:43 +00:00
continue ;
ret = mkv_write_tag ( s , st - > metadata , MATROSKA_ID_TAGTARGETS_TRACKUID , i + 1 , & tags ) ;
if ( ret < 0 ) return ret ;
}
for ( i = 0 ; i < s - > nb_chapters ; i + + ) {
AVChapter * ch = s - > chapters [ i ] ;
2011-05-22 10:46:29 +00:00
if ( ! av_dict_get ( ch - > metadata , " " , NULL , AV_DICT_IGNORE_SUFFIX ) )
2010-10-05 09:40:43 +00:00
continue ;
ret = mkv_write_tag ( s , ch - > metadata , MATROSKA_ID_TAGTARGETS_CHAPTERUID , ch - > id , & tags ) ;
if ( ret < 0 ) return ret ;
}
if ( tags . pos )
end_ebml_master ( s - > pb , tags ) ;
return 0 ;
}
2011-07-30 11:37:36 +00:00
static int mkv_write_attachments ( AVFormatContext * s )
{
MatroskaMuxContext * mkv = s - > priv_data ;
AVIOContext * pb = s - > pb ;
ebml_master attachments ;
AVLFG c ;
int i , ret ;
if ( ! mkv - > have_attachments )
return 0 ;
av_lfg_init ( & c , av_get_random_seed ( ) ) ;
ret = mkv_add_seekhead_entry ( mkv - > main_seekhead , MATROSKA_ID_ATTACHMENTS , avio_tell ( pb ) ) ;
if ( ret < 0 ) return ret ;
attachments = start_ebml_master ( pb , MATROSKA_ID_ATTACHMENTS , 0 ) ;
for ( i = 0 ; i < s - > nb_streams ; i + + ) {
AVStream * st = s - > streams [ i ] ;
ebml_master attached_file ;
AVDictionaryEntry * t ;
const char * mimetype = NULL ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
if ( st - > codecpar - > codec_type ! = AVMEDIA_TYPE_ATTACHMENT )
2011-07-30 11:37:36 +00:00
continue ;
attached_file = start_ebml_master ( pb , MATROSKA_ID_ATTACHEDFILE , 0 ) ;
if ( t = av_dict_get ( st - > metadata , " title " , NULL , 0 ) )
put_ebml_string ( pb , MATROSKA_ID_FILEDESC , t - > value ) ;
if ( ! ( t = av_dict_get ( st - > metadata , " filename " , NULL , 0 ) ) ) {
av_log ( s , AV_LOG_ERROR , " Attachment stream %d has no filename tag. \n " , i ) ;
return AVERROR ( EINVAL ) ;
}
put_ebml_string ( pb , MATROSKA_ID_FILENAME , t - > value ) ;
if ( t = av_dict_get ( st - > metadata , " mimetype " , NULL , 0 ) )
mimetype = t - > value ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
else if ( st - > codecpar - > codec_id ! = AV_CODEC_ID_NONE ) {
2011-07-30 11:37:36 +00:00
int i ;
2012-08-05 09:11:04 +00:00
for ( i = 0 ; ff_mkv_mime_tags [ i ] . id ! = AV_CODEC_ID_NONE ; i + + )
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
if ( ff_mkv_mime_tags [ i ] . id = = st - > codecpar - > codec_id ) {
2011-07-30 11:37:36 +00:00
mimetype = ff_mkv_mime_tags [ i ] . str ;
break ;
}
2015-04-03 14:11:53 +00:00
for ( i = 0 ; ff_mkv_image_mime_tags [ i ] . id ! = AV_CODEC_ID_NONE ; i + + )
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
if ( ff_mkv_image_mime_tags [ i ] . id = = st - > codecpar - > codec_id ) {
2015-04-03 14:11:53 +00:00
mimetype = ff_mkv_image_mime_tags [ i ] . str ;
break ;
}
2011-07-30 11:37:36 +00:00
}
if ( ! mimetype ) {
av_log ( s , AV_LOG_ERROR , " Attachment stream %d has no mimetype tag and "
" it cannot be deduced from the codec id. \n " , i ) ;
return AVERROR ( EINVAL ) ;
}
put_ebml_string ( pb , MATROSKA_ID_FILEMIMETYPE , mimetype ) ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
put_ebml_binary ( pb , MATROSKA_ID_FILEDATA , st - > codecpar - > extradata , st - > codecpar - > extradata_size ) ;
2011-07-30 11:37:36 +00:00
put_ebml_uint ( pb , MATROSKA_ID_FILEUID , av_lfg_get ( & c ) ) ;
end_ebml_master ( pb , attached_file ) ;
}
end_ebml_master ( pb , attachments ) ;
return 0 ;
}
2007-09-05 00:23:15 +00:00
static int mkv_write_header ( AVFormatContext * s )
{
MatroskaMuxContext * mkv = s - > priv_data ;
2011-02-20 10:04:12 +00:00
AVIOContext * pb = s - > pb ;
2007-09-05 00:24:56 +00:00
ebml_master ebml_header , segment_info ;
2011-05-22 10:46:29 +00:00
AVDictionaryEntry * tag ;
2010-06-04 22:41:03 +00:00
int ret , i ;
2007-09-05 00:23:15 +00:00
2014-06-06 22:54:50 +00:00
if ( ! strcmp ( s - > oformat - > name , " webm " ) )
mkv - > mode = MODE_WEBM ;
else
mkv - > mode = MODE_MATROSKAv2 ;
2010-06-04 22:40:54 +00:00
2010-03-09 04:23:28 +00:00
mkv - > tracks = av_mallocz ( s - > nb_streams * sizeof ( * mkv - > tracks ) ) ;
2010-06-04 22:41:06 +00:00
if ( ! mkv - > tracks )
return AVERROR ( ENOMEM ) ;
2007-09-05 00:24:29 +00:00
2007-09-05 00:24:56 +00:00
ebml_header = start_ebml_master ( pb , EBML_ID_HEADER , 0 ) ;
2007-09-05 00:23:15 +00:00
put_ebml_uint ( pb , EBML_ID_EBMLVERSION , 1 ) ;
put_ebml_uint ( pb , EBML_ID_EBMLREADVERSION , 1 ) ;
put_ebml_uint ( pb , EBML_ID_EBMLMAXIDLENGTH , 4 ) ;
put_ebml_uint ( pb , EBML_ID_EBMLMAXSIZELENGTH , 8 ) ;
2010-06-04 22:40:54 +00:00
put_ebml_string ( pb , EBML_ID_DOCTYPE , s - > oformat - > name ) ;
2016-04-02 20:35:44 +00:00
put_ebml_uint ( pb , EBML_ID_DOCTYPEVERSION , 4 ) ;
2007-09-05 00:23:15 +00:00
put_ebml_uint ( pb , EBML_ID_DOCTYPEREADVERSION , 2 ) ;
end_ebml_master ( pb , ebml_header ) ;
2007-09-05 00:24:56 +00:00
mkv - > segment = start_ebml_master ( pb , MATROSKA_ID_SEGMENT , 0 ) ;
2011-03-03 19:11:45 +00:00
mkv - > segment_offset = avio_tell ( pb ) ;
2007-09-05 00:23:19 +00:00
2007-09-05 00:25:16 +00:00
// we write 2 seek heads - one at the end of the file to point to each
// cluster, and one at the beginning to point to all other level one
// elements (including the seek head at the end of the file), which
// isn't more than 10 elements if we only write one of each other
// currently defined level 1 element
2007-09-05 00:23:19 +00:00
mkv - > main_seekhead = mkv_start_seekhead ( pb , mkv - > segment_offset , 10 ) ;
2010-06-04 22:41:11 +00:00
if ( ! mkv - > main_seekhead )
2007-09-05 00:25:29 +00:00
return AVERROR ( ENOMEM ) ;
2007-09-05 00:23:19 +00:00
2011-03-03 19:11:45 +00:00
ret = mkv_add_seekhead_entry ( mkv - > main_seekhead , MATROSKA_ID_INFO , avio_tell ( pb ) ) ;
2007-09-05 00:25:32 +00:00
if ( ret < 0 ) return ret ;
2007-09-05 00:23:15 +00:00
2007-09-05 00:24:56 +00:00
segment_info = start_ebml_master ( pb , MATROSKA_ID_INFO , 0 ) ;
2007-09-05 00:23:15 +00:00
put_ebml_uint ( pb , MATROSKA_ID_TIMECODESCALE , 1000000 ) ;
2011-05-22 10:46:29 +00:00
if ( ( tag = av_dict_get ( s - > metadata , " title " , NULL , 0 ) ) )
2009-02-15 16:53:05 +00:00
put_ebml_string ( pb , MATROSKA_ID_TITLE , tag - > value ) ;
2014-05-01 08:43:10 +00:00
if ( ! ( s - > flags & AVFMT_FLAG_BITEXACT ) ) {
2010-06-04 22:41:03 +00:00
uint32_t segment_uid [ 4 ] ;
2010-06-08 10:44:27 +00:00
AVLFG lfg ;
av_lfg_init ( & lfg , av_get_random_seed ( ) ) ;
2010-06-04 22:41:03 +00:00
for ( i = 0 ; i < 4 ; i + + )
2010-06-08 10:44:27 +00:00
segment_uid [ i ] = av_lfg_get ( & lfg ) ;
2010-06-04 22:41:03 +00:00
2014-06-06 22:54:50 +00:00
put_ebml_string ( pb , MATROSKA_ID_MUXINGAPP , LIBAVFORMAT_IDENT ) ;
2014-03-03 20:20:14 +00:00
if ( ( tag = av_dict_get ( s - > metadata , " encoding_tool " , NULL , 0 ) ) )
put_ebml_string ( pb , MATROSKA_ID_WRITINGAPP , tag - > value ) ;
else
put_ebml_string ( pb , MATROSKA_ID_WRITINGAPP , LIBAVFORMAT_IDENT ) ;
2010-06-04 22:41:03 +00:00
put_ebml_binary ( pb , MATROSKA_ID_SEGMENTUID , segment_uid , 16 ) ;
2007-09-05 00:23:15 +00:00
}
2007-09-05 00:24:03 +00:00
2007-09-05 00:23:15 +00:00
// reserve space for the duration
mkv - > duration = 0 ;
2011-03-03 19:11:45 +00:00
mkv - > duration_offset = avio_tell ( pb ) ;
2007-09-05 00:23:15 +00:00
put_ebml_void ( pb , 11 ) ; // assumes double-precision float to be written
end_ebml_master ( pb , segment_info ) ;
2007-09-05 00:25:32 +00:00
ret = mkv_write_tracks ( s ) ;
2014-06-06 22:54:50 +00:00
if ( ret < 0 )
return ret ;
2007-09-05 00:22:37 +00:00
2010-06-04 22:40:54 +00:00
if ( mkv - > mode ! = MODE_WEBM ) {
ret = mkv_write_chapters ( s ) ;
2014-06-06 22:54:50 +00:00
if ( ret < 0 )
return ret ;
2010-10-05 09:40:43 +00:00
ret = mkv_write_tags ( s ) ;
2014-06-06 22:54:50 +00:00
if ( ret < 0 )
return ret ;
2011-07-30 11:37:36 +00:00
ret = mkv_write_attachments ( s ) ;
2014-06-06 22:54:50 +00:00
if ( ret < 0 )
return ret ;
2010-06-04 22:40:54 +00:00
}
2009-10-18 12:17:01 +00:00
2011-03-05 20:06:46 +00:00
if ( ! s - > pb - > seekable )
2010-03-04 08:53:04 +00:00
mkv_write_seekhead ( pb , mkv - > main_seekhead ) ;
2007-09-05 00:23:27 +00:00
mkv - > cues = mkv_start_cues ( mkv - > segment_offset ) ;
2014-08-14 20:31:24 +00:00
if ( ! mkv - > cues )
2007-09-05 00:25:27 +00:00
return AVERROR ( ENOMEM ) ;
2007-09-05 00:23:27 +00:00
2013-04-30 06:36:20 +00:00
if ( pb - > seekable & & mkv - > reserve_cues_space ) {
mkv - > cues_pos = avio_tell ( pb ) ;
put_ebml_void ( pb , mkv - > reserve_cues_space ) ;
}
2010-06-04 22:40:50 +00:00
av_init_packet ( & mkv - > cur_audio_pkt ) ;
mkv - > cur_audio_pkt . size = 0 ;
2011-03-14 19:39:06 +00:00
avio_flush ( pb ) ;
2013-08-18 18:09:40 +00:00
// start a new cluster every 5 MB or 5 sec, or 32k / 1 sec for streaming or
// after 4k and on a keyframe
if ( pb - > seekable ) {
if ( mkv - > cluster_time_limit < 0 )
mkv - > cluster_time_limit = 5000 ;
if ( mkv - > cluster_size_limit < 0 )
mkv - > cluster_size_limit = 5 * 1024 * 1024 ;
} else {
if ( mkv - > cluster_time_limit < 0 )
mkv - > cluster_time_limit = 1000 ;
if ( mkv - > cluster_size_limit < 0 )
mkv - > cluster_size_limit = 32 * 1024 ;
}
2007-09-05 00:22:37 +00:00
return 0 ;
}
2008-10-04 22:44:50 +00:00
static int mkv_blockgroup_size ( int pkt_size )
2007-09-05 00:24:56 +00:00
{
2008-10-04 22:44:50 +00:00
int size = pkt_size + 4 ;
2007-09-05 00:26:07 +00:00
size + = ebml_num_size ( size ) ;
2007-09-05 00:24:56 +00:00
size + = 2 ; // EBML ID for block and block duration
size + = 8 ; // max size of block duration
2007-09-05 00:26:07 +00:00
size + = ebml_num_size ( size ) ;
2007-09-05 00:24:56 +00:00
size + = 1 ; // blockgroup EBML ID
return size ;
}
2014-10-29 19:39:46 +00:00
static int ass_get_duration ( AVFormatContext * s , const uint8_t * p )
2008-10-04 22:57:56 +00:00
{
int sh , sm , ss , sc , eh , em , es , ec ;
uint64_t start , end ;
if ( sscanf ( p , " %*[^,],%d:%d:%d%*c%d,%d:%d:%d%*c%d " ,
& sh , & sm , & ss , & sc , & eh , & em , & es , & ec ) ! = 8 )
return 0 ;
2014-10-29 19:39:46 +00:00
if ( sh > 9 | | sm > 59 | | ss > 59 | | sc > 99 | |
eh > 9 | | em > 59 | | es > 59 | | ec > 99 ) {
av_log ( s , AV_LOG_WARNING ,
" Non-standard time reference %d:%d:%d.%d,%d:%d:%d.%d \n " ,
sh , sm , ss , sc , eh , em , es , ec ) ;
return 0 ;
}
2014-06-06 22:54:50 +00:00
start = 3600000 * sh + 60000 * sm + 1000 * ss + 10 * sc ;
end = 3600000 * eh + 60000 * em + 1000 * es + 10 * ec ;
2014-10-29 19:39:46 +00:00
if ( start > end ) {
av_log ( s , AV_LOG_WARNING ,
" Unexpected time reference %d:%d:%d.%d,%d:%d:%d.%d \n " ,
sh , sm , ss , sc , eh , em , es , ec ) ;
return 0 ;
}
2008-10-04 22:57:56 +00:00
return end - start ;
}
2014-06-06 22:54:50 +00:00
static int mkv_write_ass_blocks ( AVFormatContext * s , AVIOContext * pb ,
AVPacket * pkt )
2008-10-04 22:57:56 +00:00
{
MatroskaMuxContext * mkv = s - > priv_data ;
int i , layer = 0 , max_duration = 0 , size , line_size , data_size = pkt - > size ;
uint8_t * start , * end , * data = pkt - > data ;
ebml_master blockgroup ;
char buffer [ 2048 ] ;
while ( data_size ) {
2014-10-29 19:39:46 +00:00
int duration = ass_get_duration ( s , data ) ;
2008-10-04 22:57:56 +00:00
max_duration = FFMAX ( duration , max_duration ) ;
2014-06-06 22:54:50 +00:00
end = memchr ( data , ' \n ' , data_size ) ;
size = line_size = end ? end - data + 1 : data_size ;
size - = end ? ( end [ - 1 ] = = ' \r ' ) + 1 : 0 ;
start = data ;
for ( i = 0 ; i < 3 ; i + + , start + + )
if ( ! ( start = memchr ( start , ' , ' , size - ( start - data ) ) ) )
2008-10-04 22:57:56 +00:00
return max_duration ;
size - = start - data ;
sscanf ( data , " Dialogue: %d, " , & layer ) ;
2014-06-06 22:54:50 +00:00
i = snprintf ( buffer , sizeof ( buffer ) , " % " PRId64 " ,%d, " ,
2011-03-16 07:45:14 +00:00
s - > streams [ pkt - > stream_index ] - > nb_frames , layer ) ;
2014-06-06 22:54:50 +00:00
size = FFMIN ( i + size , sizeof ( buffer ) ) ;
memcpy ( buffer + i , start , size - i ) ;
2008-10-04 22:57:56 +00:00
2014-06-06 22:54:50 +00:00
av_log ( s , AV_LOG_DEBUG ,
" Writing block at offset % " PRIu64 " , size %d, "
2008-10-04 22:57:56 +00:00
" pts % " PRId64 " , duration %d \n " ,
2011-03-03 19:11:45 +00:00
avio_tell ( pb ) , size , pkt - > pts , duration ) ;
2014-06-06 22:54:50 +00:00
blockgroup = start_ebml_master ( pb , MATROSKA_ID_BLOCKGROUP ,
mkv_blockgroup_size ( size ) ) ;
2008-10-04 22:57:56 +00:00
put_ebml_id ( pb , MATROSKA_ID_BLOCK ) ;
2014-06-06 22:54:50 +00:00
put_ebml_num ( pb , size + 4 , 0 ) ;
// this assumes stream_index is less than 126
avio_w8 ( pb , 0x80 | ( pkt - > stream_index + 1 ) ) ;
2011-02-21 18:28:17 +00:00
avio_wb16 ( pb , pkt - > pts - mkv - > cluster_pts ) ;
avio_w8 ( pb , 0 ) ;
avio_write ( pb , buffer , size ) ;
2008-10-04 22:57:56 +00:00
put_ebml_uint ( pb , MATROSKA_ID_BLOCKDURATION , duration ) ;
end_ebml_master ( pb , blockgroup ) ;
2014-06-06 22:54:50 +00:00
data + = line_size ;
2008-10-04 22:57:56 +00:00
data_size - = line_size ;
}
return max_duration ;
}
2013-05-28 08:09:21 +00:00
static int mkv_strip_wavpack ( const uint8_t * src , uint8_t * * pdst , int * size )
{
uint8_t * dst ;
int srclen = * size ;
int offset = 0 ;
int ret ;
dst = av_malloc ( srclen ) ;
if ( ! dst )
return AVERROR ( ENOMEM ) ;
while ( srclen > = WV_HEADER_SIZE ) {
WvHeader header ;
ret = ff_wv_parse_header ( & header , src ) ;
if ( ret < 0 )
goto fail ;
src + = WV_HEADER_SIZE ;
srclen - = WV_HEADER_SIZE ;
if ( srclen < header . blocksize ) {
ret = AVERROR_INVALIDDATA ;
goto fail ;
}
if ( header . initial ) {
AV_WL32 ( dst + offset , header . samples ) ;
offset + = 4 ;
}
AV_WL32 ( dst + offset , header . flags ) ;
AV_WL32 ( dst + offset + 4 , header . crc ) ;
offset + = 8 ;
if ( ! ( header . initial & & header . final ) ) {
AV_WL32 ( dst + offset , header . blocksize ) ;
offset + = 4 ;
}
memcpy ( dst + offset , src , header . blocksize ) ;
src + = header . blocksize ;
srclen - = header . blocksize ;
offset + = header . blocksize ;
}
* pdst = dst ;
* size = offset ;
return 0 ;
fail :
av_freep ( & dst ) ;
return ret ;
}
2011-02-20 10:04:12 +00:00
static void mkv_write_block ( AVFormatContext * s , AVIOContext * pb ,
2010-03-04 08:53:14 +00:00
unsigned int blockid , AVPacket * pkt , int flags )
2007-09-05 00:23:47 +00:00
{
MatroskaMuxContext * mkv = s - > priv_data ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
AVCodecParameters * par = s - > streams [ pkt - > stream_index ] - > codecpar ;
2009-01-20 00:52:12 +00:00
uint8_t * data = NULL ;
2012-09-14 22:59:05 +00:00
int offset = 0 , size = pkt - > size ;
2010-03-09 04:23:28 +00:00
int64_t ts = mkv - > tracks [ pkt - > stream_index ] . write_dts ? pkt - > dts : pkt - > pts ;
2007-09-05 00:23:47 +00:00
2007-09-05 00:25:38 +00:00
av_log ( s , AV_LOG_DEBUG , " Writing block at offset % " PRIu64 " , size %d, "
2015-09-26 16:13:55 +00:00
" pts % " PRId64 " , dts % " PRId64 " , duration % " PRId64 " , flags %d \n " ,
2011-03-03 19:11:45 +00:00
avio_tell ( pb ) , pkt - > size , pkt - > pts , pkt - > dts , pkt - > duration , flags ) ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
if ( par - > codec_id = = AV_CODEC_ID_H264 & & par - > extradata_size > 0 & &
( AV_RB24 ( par - > extradata ) = = 1 | | AV_RB32 ( par - > extradata ) = = 1 ) )
2009-01-20 00:52:12 +00:00
ff_avc_parse_nal_units_buf ( pkt - > data , & data , & size ) ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
else if ( par - > codec_id = = AV_CODEC_ID_HEVC & & par - > extradata_size > 6 & &
( AV_RB24 ( par - > extradata ) = = 1 | | AV_RB32 ( par - > extradata ) = = 1 ) )
2014-03-03 14:53:45 +00:00
/* extradata is Annex B, assume the bitstream is too and convert it */
ff_hevc_annexb2mp4_buf ( pkt - > data , & data , & size , 0 , NULL ) ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
else if ( par - > codec_id = = AV_CODEC_ID_WAVPACK ) {
2013-05-28 08:09:21 +00:00
int ret = mkv_strip_wavpack ( pkt - > data , & data , & size ) ;
if ( ret < 0 ) {
av_log ( s , AV_LOG_ERROR , " Error stripping a WavPack packet. \n " ) ;
return ;
}
} else
2009-01-20 00:52:12 +00:00
data = pkt - > data ;
2012-09-14 22:59:05 +00:00
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
if ( par - > codec_id = = AV_CODEC_ID_PRORES ) {
2012-09-14 22:59:05 +00:00
/* Matroska specification requires to remove the first QuickTime atom
*/
2014-06-06 22:54:50 +00:00
size - = 8 ;
2012-09-14 22:59:05 +00:00
offset = 8 ;
}
2007-09-05 00:23:47 +00:00
put_ebml_id ( pb , blockid ) ;
2014-06-06 22:54:50 +00:00
put_ebml_num ( pb , size + 4 , 0 ) ;
// this assumes stream_index is less than 126
avio_w8 ( pb , 0x80 | ( pkt - > stream_index + 1 ) ) ;
2011-02-21 18:28:17 +00:00
avio_wb16 ( pb , ts - mkv - > cluster_pts ) ;
avio_w8 ( pb , flags ) ;
2012-09-14 22:59:05 +00:00
avio_write ( pb , data + offset , size ) ;
2009-01-20 00:52:12 +00:00
if ( data ! = pkt - > data )
av_free ( data ) ;
2007-09-05 00:23:47 +00:00
}
2010-07-25 21:16:58 +00:00
static int srt_get_duration ( uint8_t * * buf )
{
int i , duration = 0 ;
2014-06-06 22:54:50 +00:00
for ( i = 0 ; i < 2 & & ! duration ; i + + ) {
2010-07-25 21:16:58 +00:00
int s_hour , s_min , s_sec , s_hsec , e_hour , e_min , e_sec , e_hsec ;
if ( sscanf ( * buf , " %d:%2d:%2d%*1[,.]%3d --> %d:%2d:%2d%*1[,.]%3d " ,
& s_hour , & s_min , & s_sec , & s_hsec ,
& e_hour , & e_min , & e_sec , & e_hsec ) = = 8 ) {
2014-06-06 22:54:50 +00:00
s_min + = 60 * s_hour ;
e_min + = 60 * e_hour ;
s_sec + = 60 * s_min ;
e_sec + = 60 * e_min ;
s_hsec + = 1000 * s_sec ;
e_hsec + = 1000 * e_sec ;
2010-07-25 21:16:58 +00:00
duration = e_hsec - s_hsec ;
}
* buf + = strcspn ( * buf , " \n " ) + 1 ;
}
return duration ;
}
2014-06-06 22:54:50 +00:00
static int mkv_write_srt_blocks ( AVFormatContext * s , AVIOContext * pb ,
AVPacket * pkt )
2010-07-25 21:16:58 +00:00
{
ebml_master blockgroup ;
AVPacket pkt2 = * pkt ;
int64_t duration = srt_get_duration ( & pkt2 . data ) ;
pkt2 . size - = pkt2 . data - pkt - > data ;
blockgroup = start_ebml_master ( pb , MATROSKA_ID_BLOCKGROUP ,
mkv_blockgroup_size ( pkt2 . size ) ) ;
mkv_write_block ( s , pb , MATROSKA_ID_BLOCK , & pkt2 , 0 ) ;
put_ebml_uint ( pb , MATROSKA_ID_BLOCKDURATION , duration ) ;
end_ebml_master ( pb , blockgroup ) ;
return duration ;
}
2010-03-04 08:53:14 +00:00
static void mkv_flush_dynbuf ( AVFormatContext * s )
{
MatroskaMuxContext * mkv = s - > priv_data ;
int bufsize ;
uint8_t * dyn_buf ;
if ( ! mkv - > dyn_bc )
return ;
2011-03-17 07:16:07 +00:00
bufsize = avio_close_dyn_buf ( mkv - > dyn_bc , & dyn_buf ) ;
2011-02-21 18:28:17 +00:00
avio_write ( s - > pb , dyn_buf , bufsize ) ;
2010-03-04 08:53:14 +00:00
av_free ( dyn_buf ) ;
mkv - > dyn_bc = NULL ;
}
2010-06-04 22:40:50 +00:00
static int mkv_write_packet_internal ( AVFormatContext * s , AVPacket * pkt )
2007-09-05 00:22:37 +00:00
{
2007-09-05 00:23:00 +00:00
MatroskaMuxContext * mkv = s - > priv_data ;
2014-06-06 22:54:50 +00:00
AVIOContext * pb = s - > pb ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
AVCodecParameters * par = s - > streams [ pkt - > stream_index ] - > codecpar ;
2014-06-06 22:54:50 +00:00
int keyframe = ! ! ( pkt - > flags & AV_PKT_FLAG_KEY ) ;
int duration = pkt - > duration ;
2007-09-05 00:25:32 +00:00
int ret ;
2010-03-09 04:23:28 +00:00
int64_t ts = mkv - > tracks [ pkt - > stream_index ] . write_dts ? pkt - > dts : pkt - > pts ;
2007-09-05 00:22:52 +00:00
2010-03-09 04:23:33 +00:00
if ( ts = = AV_NOPTS_VALUE ) {
av_log ( s , AV_LOG_ERROR , " Can't write packet with unknown timestamp \n " ) ;
return AVERROR ( EINVAL ) ;
}
2014-04-29 10:26:38 +00:00
ts + = mkv - > tracks [ pkt - > stream_index ] . ts_offset ;
2010-03-09 04:23:33 +00:00
2011-03-05 20:06:46 +00:00
if ( ! s - > pb - > seekable ) {
2014-10-23 23:05:55 +00:00
if ( ! mkv - > dyn_bc ) {
ret = avio_open_dyn_buf ( & mkv - > dyn_bc ) ;
if ( ret < 0 )
return ret ;
}
2010-03-04 08:53:14 +00:00
pb = mkv - > dyn_bc ;
}
2010-03-04 08:53:08 +00:00
if ( ! mkv - > cluster_pos ) {
2011-03-03 19:11:45 +00:00
mkv - > cluster_pos = avio_tell ( s - > pb ) ;
2014-06-06 22:54:50 +00:00
mkv - > cluster = start_ebml_master ( pb , MATROSKA_ID_CLUSTER , 0 ) ;
2010-03-09 04:23:36 +00:00
put_ebml_uint ( pb , MATROSKA_ID_CLUSTERTIMECODE , FFMAX ( 0 , ts ) ) ;
mkv - > cluster_pts = FFMAX ( 0 , ts ) ;
2007-09-05 00:23:00 +00:00
}
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
if ( par - > codec_type ! = AVMEDIA_TYPE_SUBTITLE ) {
2010-03-04 08:53:14 +00:00
mkv_write_block ( s , pb , MATROSKA_ID_SIMPLEBLOCK , pkt , keyframe < < 7 ) ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
} else if ( par - > codec_id = = AV_CODEC_ID_SSA ) {
2010-03-04 08:53:14 +00:00
duration = mkv_write_ass_blocks ( s , pb , pkt ) ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
} else if ( par - > codec_id = = AV_CODEC_ID_SRT ) {
2010-07-25 21:16:58 +00:00
duration = mkv_write_srt_blocks ( s , pb , pkt ) ;
2007-09-05 00:23:49 +00:00
} else {
2014-06-06 22:54:50 +00:00
ebml_master blockgroup = start_ebml_master ( pb , MATROSKA_ID_BLOCKGROUP ,
mkv_blockgroup_size ( pkt - > size ) ) ;
2015-09-26 16:13:55 +00:00
duration = pkt - > duration ;
# if FF_API_CONVERGENCE_DURATION
FF_DISABLE_DEPRECATION_WARNINGS
if ( pkt - > convergence_duration )
duration = pkt - > convergence_duration ;
FF_ENABLE_DEPRECATION_WARNINGS
# endif
2010-03-04 08:53:14 +00:00
mkv_write_block ( s , pb , MATROSKA_ID_BLOCK , pkt , 0 ) ;
2008-10-04 22:47:10 +00:00
put_ebml_uint ( pb , MATROSKA_ID_BLOCKDURATION , duration ) ;
2007-09-05 00:23:49 +00:00
end_ebml_master ( pb , blockgroup ) ;
}
2007-09-05 00:23:11 +00:00
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
if ( par - > codec_type = = AVMEDIA_TYPE_VIDEO & & keyframe ) {
2014-06-06 22:54:50 +00:00
ret = mkv_add_cuepoint ( mkv - > cues , pkt - > stream_index , ts ,
mkv - > cluster_pos ) ;
if ( ret < 0 )
return ret ;
2007-09-05 00:23:27 +00:00
}
2010-06-04 22:40:50 +00:00
mkv - > duration = FFMAX ( mkv - > duration , ts + duration ) ;
return 0 ;
}
static int mkv_write_packet ( AVFormatContext * s , AVPacket * pkt )
{
MatroskaMuxContext * mkv = s - > priv_data ;
lavf: replace AVStream.codec with AVStream.codecpar
Currently, AVStream contains an embedded AVCodecContext instance, which
is used by demuxers to export stream parameters to the caller and by
muxers to receive stream parameters from the caller. It is also used
internally as the codec context that is passed to parsers.
In addition, it is also widely used by the callers as the decoding (when
demuxer) or encoding (when muxing) context, though this has been
officially discouraged since Libav 11.
There are multiple important problems with this approach:
- the fields in AVCodecContext are in general one of
* stream parameters
* codec options
* codec state
However, it's not clear which ones are which. It is consequently
unclear which fields are a demuxer allowed to set or a muxer allowed to
read. This leads to erratic behaviour depending on whether decoding or
encoding is being performed or not (and whether it uses the AVStream
embedded codec context).
- various synchronization issues arising from the fact that the same
context is used by several different APIs (muxers/demuxers,
parsers, bitstream filters and encoders/decoders) simultaneously, with
there being no clear rules for who can modify what and the different
processes being typically delayed with respect to each other.
- avformat_find_stream_info() making it necessary to support opening
and closing a single codec context multiple times, thus
complicating the semantics of freeing various allocated objects in the
codec context.
Those problems are resolved by replacing the AVStream embedded codec
context with a newly added AVCodecParameters instance, which stores only
the stream parameters exported by the demuxers or read by the muxers.
2014-06-18 18:42:52 +00:00
int codec_type = s - > streams [ pkt - > stream_index ] - > codecpar - > codec_type ;
2013-08-18 18:09:39 +00:00
int keyframe = ! ! ( pkt - > flags & AV_PKT_FLAG_KEY ) ;
int cluster_size ;
int64_t cluster_time ;
AVIOContext * pb ;
int ret ;
if ( mkv - > tracks [ pkt - > stream_index ] . write_dts )
cluster_time = pkt - > dts - mkv - > cluster_pts ;
else
cluster_time = pkt - > pts - mkv - > cluster_pts ;
2014-04-29 10:26:38 +00:00
cluster_time + = mkv - > tracks [ pkt - > stream_index ] . ts_offset ;
2010-06-04 22:40:50 +00:00
// start a new cluster every 5 MB or 5 sec, or 32k / 1 sec for streaming or
// after 4k and on a keyframe
2013-08-18 18:09:39 +00:00
if ( s - > pb - > seekable ) {
pb = s - > pb ;
cluster_size = avio_tell ( pb ) - mkv - > cluster_pos ;
} else {
pb = mkv - > dyn_bc ;
cluster_size = avio_tell ( pb ) ;
}
2010-06-04 22:40:50 +00:00
if ( mkv - > cluster_pos & &
2013-08-18 18:09:40 +00:00
( cluster_size > mkv - > cluster_size_limit | |
cluster_time > mkv - > cluster_time_limit | |
2013-08-18 18:09:39 +00:00
( codec_type = = AVMEDIA_TYPE_VIDEO & & keyframe & &
cluster_size > 4 * 1024 ) ) ) {
2014-06-06 22:54:50 +00:00
av_log ( s , AV_LOG_DEBUG ,
" Starting new cluster at offset % " PRIu64 " bytes, "
" pts % " PRIu64 " dts % " PRIu64 " \n " ,
2013-08-18 18:09:39 +00:00
avio_tell ( pb ) , pkt - > pts , pkt - > dts ) ;
2010-03-04 08:53:08 +00:00
end_ebml_master ( pb , mkv - > cluster ) ;
mkv - > cluster_pos = 0 ;
2010-03-04 08:53:14 +00:00
if ( mkv - > dyn_bc )
mkv_flush_dynbuf ( s ) ;
2013-08-18 18:09:41 +00:00
avio_flush ( s - > pb ) ;
2010-03-04 08:53:08 +00:00
}
2016-05-04 19:31:28 +00:00
if ( ! mkv - > cluster_pos )
avio_write_marker ( s - > pb ,
av_rescale_q ( pkt - > dts , s - > streams [ pkt - > stream_index ] - > time_base , AV_TIME_BASE_Q ) ,
keyframe & & ( mkv - > have_video ? codec_type = = AVMEDIA_TYPE_VIDEO : 1 ) ? AVIO_DATA_MARKER_SYNC_POINT : AVIO_DATA_MARKER_BOUNDARY_POINT ) ;
2010-06-04 22:40:50 +00:00
// check if we have an audio packet cached
if ( mkv - > cur_audio_pkt . size > 0 ) {
ret = mkv_write_packet_internal ( s , & mkv - > cur_audio_pkt ) ;
2015-10-23 09:11:31 +00:00
av_packet_unref ( & mkv - > cur_audio_pkt ) ;
2010-06-04 22:40:50 +00:00
if ( ret < 0 ) {
2014-06-06 22:54:50 +00:00
av_log ( s , AV_LOG_ERROR ,
" Could not write cached audio packet ret:%d \n " , ret ) ;
2010-06-04 22:40:50 +00:00
return ret ;
}
}
// buffer an audio packet to ensure the packet containing the video
// keyframe's timecode is contained in the same cluster for WebM
2013-08-18 18:09:39 +00:00
if ( codec_type = = AVMEDIA_TYPE_AUDIO ) {
2015-10-23 09:11:33 +00:00
ret = av_packet_ref ( & mkv - > cur_audio_pkt , pkt ) ;
2012-10-31 07:53:18 +00:00
} else
2010-06-04 22:40:50 +00:00
ret = mkv_write_packet_internal ( s , pkt ) ;
return ret ;
2007-09-05 00:22:37 +00:00
}
2013-08-19 07:33:14 +00:00
static int mkv_write_flush_packet ( AVFormatContext * s , AVPacket * pkt )
{
MatroskaMuxContext * mkv = s - > priv_data ;
AVIOContext * pb ;
if ( s - > pb - > seekable )
pb = s - > pb ;
else
pb = mkv - > dyn_bc ;
if ( ! pkt ) {
if ( mkv - > cluster_pos ) {
2014-06-06 22:54:50 +00:00
av_log ( s , AV_LOG_DEBUG ,
" Flushing cluster at offset % " PRIu64 " bytes \n " ,
avio_tell ( pb ) ) ;
2013-08-19 07:33:14 +00:00
end_ebml_master ( pb , mkv - > cluster ) ;
mkv - > cluster_pos = 0 ;
if ( mkv - > dyn_bc )
mkv_flush_dynbuf ( s ) ;
avio_flush ( s - > pb ) ;
}
2015-06-09 08:47:11 +00:00
return 1 ;
2013-08-19 07:33:14 +00:00
}
return mkv_write_packet ( s , pkt ) ;
}
2007-09-05 00:22:37 +00:00
static int mkv_write_trailer ( AVFormatContext * s )
{
MatroskaMuxContext * mkv = s - > priv_data ;
2011-02-20 10:04:12 +00:00
AVIOContext * pb = s - > pb ;
2010-06-04 22:41:11 +00:00
int64_t currentpos , cuespos ;
2007-09-05 00:25:34 +00:00
int ret ;
2007-09-05 00:23:11 +00:00
2010-06-04 22:40:50 +00:00
// check if we have an audio packet cached
if ( mkv - > cur_audio_pkt . size > 0 ) {
ret = mkv_write_packet_internal ( s , & mkv - > cur_audio_pkt ) ;
2015-10-23 09:11:31 +00:00
av_packet_unref ( & mkv - > cur_audio_pkt ) ;
2010-06-04 22:40:50 +00:00
if ( ret < 0 ) {
2014-06-06 22:54:50 +00:00
av_log ( s , AV_LOG_ERROR ,
" Could not write cached audio packet ret:%d \n " , ret ) ;
2010-06-04 22:40:50 +00:00
return ret ;
}
}
2010-03-04 08:53:14 +00:00
if ( mkv - > dyn_bc ) {
end_ebml_master ( mkv - > dyn_bc , mkv - > cluster ) ;
mkv_flush_dynbuf ( s ) ;
} else if ( mkv - > cluster_pos ) {
end_ebml_master ( pb , mkv - > cluster ) ;
}
2007-09-05 00:23:11 +00:00
2013-09-03 17:53:34 +00:00
if ( mkv - > mode ! = MODE_WEBM ) {
ret = mkv_write_chapters ( s ) ;
2014-06-06 22:54:50 +00:00
if ( ret < 0 )
return ret ;
2013-09-03 17:53:34 +00:00
}
2011-03-05 20:06:46 +00:00
if ( pb - > seekable ) {
2011-04-04 20:29:21 +00:00
if ( mkv - > cues - > num_entries ) {
2013-04-30 06:36:20 +00:00
if ( mkv - > reserve_cues_space ) {
int64_t cues_end ;
currentpos = avio_tell ( pb ) ;
avio_seek ( pb , mkv - > cues_pos , SEEK_SET ) ;
2014-06-06 22:54:50 +00:00
cuespos = mkv_write_cues ( pb , mkv - > cues , s - > nb_streams ) ;
2013-04-30 06:36:20 +00:00
cues_end = avio_tell ( pb ) ;
if ( cues_end > cuespos + mkv - > reserve_cues_space ) {
2014-06-06 22:54:50 +00:00
av_log ( s , AV_LOG_ERROR ,
" Insufficient space reserved for cues: %d "
" (needed: % " PRId64 " ). \n " ,
mkv - > reserve_cues_space , cues_end - cuespos ) ;
2013-04-30 06:36:20 +00:00
return AVERROR ( EINVAL ) ;
}
if ( cues_end < cuespos + mkv - > reserve_cues_space )
2014-06-06 22:54:50 +00:00
put_ebml_void ( pb , mkv - > reserve_cues_space -
( cues_end - cuespos ) ) ;
2013-04-30 06:36:20 +00:00
avio_seek ( pb , currentpos , SEEK_SET ) ;
} else {
cuespos = mkv_write_cues ( pb , mkv - > cues , s - > nb_streams ) ;
}
2011-04-04 20:29:21 +00:00
2014-06-06 22:54:50 +00:00
ret = mkv_add_seekhead_entry ( mkv - > main_seekhead , MATROSKA_ID_CUES ,
cuespos ) ;
if ( ret < 0 )
return ret ;
2011-04-04 20:29:21 +00:00
}
2007-09-05 00:23:27 +00:00
2007-09-05 00:26:03 +00:00
mkv_write_seekhead ( pb , mkv - > main_seekhead ) ;
// update the duration
av_log ( s , AV_LOG_DEBUG , " end duration = % " PRIu64 " \n " , mkv - > duration ) ;
2011-03-03 19:11:45 +00:00
currentpos = avio_tell ( pb ) ;
2011-02-28 13:57:54 +00:00
avio_seek ( pb , mkv - > duration_offset , SEEK_SET ) ;
2007-09-05 00:26:03 +00:00
put_ebml_float ( pb , MATROSKA_ID_DURATION , mkv - > duration ) ;
2011-02-28 13:57:54 +00:00
avio_seek ( pb , currentpos , SEEK_SET ) ;
2007-09-05 00:26:00 +00:00
}
2007-09-05 00:23:11 +00:00
2007-09-05 00:22:37 +00:00
end_ebml_master ( pb , mkv - > segment ) ;
2010-03-09 04:23:28 +00:00
av_free ( mkv - > tracks ) ;
2011-05-04 16:57:37 +00:00
av_freep ( & mkv - > cues - > entries ) ;
av_freep ( & mkv - > cues ) ;
2012-09-09 19:35:23 +00:00
2007-09-05 00:22:37 +00:00
return 0 ;
}
2012-08-05 09:11:04 +00:00
static int mkv_query_codec ( enum AVCodecID codec_id , int std_compliance )
2011-08-11 18:35:46 +00:00
{
int i ;
2012-08-05 09:11:04 +00:00
for ( i = 0 ; ff_mkv_codec_tags [ i ] . id ! = AV_CODEC_ID_NONE ; i + + )
2011-08-11 18:35:46 +00:00
if ( ff_mkv_codec_tags [ i ] . id = = codec_id )
return 1 ;
2014-06-06 22:54:50 +00:00
if ( std_compliance < FF_COMPLIANCE_NORMAL ) {
enum AVMediaType type = avcodec_get_type ( codec_id ) ;
// mkv theoretically supports any video/audio through VFW/ACM
2011-08-11 18:35:46 +00:00
if ( type = = AVMEDIA_TYPE_VIDEO | | type = = AVMEDIA_TYPE_AUDIO )
return 1 ;
}
return 0 ;
}
2013-04-30 06:36:20 +00:00
# define OFFSET(x) offsetof(MatroskaMuxContext, x)
# define FLAGS AV_OPT_FLAG_ENCODING_PARAM
static const AVOption options [ ] = {
2013-08-18 18:09:40 +00:00
{ " reserve_index_space " , " Reserve a given amount of space (in bytes) at the beginning of the file for the index (cues). " , OFFSET ( reserve_cues_space ) , AV_OPT_TYPE_INT , { . i64 = 0 } , 0 , INT_MAX , FLAGS } ,
{ " cluster_size_limit " , " Store at most the provided amount of bytes in a cluster. " , OFFSET ( cluster_size_limit ) , AV_OPT_TYPE_INT , { . i64 = - 1 } , - 1 , INT_MAX , FLAGS } ,
{ " cluster_time_limit " , " Store at most the provided number of milliseconds in a cluster. " , OFFSET ( cluster_time_limit ) , AV_OPT_TYPE_INT64 , { . i64 = - 1 } , - 1 , INT64_MAX , FLAGS } ,
2013-04-30 06:36:20 +00:00
{ NULL } ,
} ;
2010-06-04 22:40:54 +00:00
# if CONFIG_MATROSKA_MUXER
2013-04-30 06:36:20 +00:00
static const AVClass matroska_class = {
. class_name = " matroska muxer " ,
. item_name = av_default_item_name ,
. option = options ,
. version = LIBAVUTIL_VERSION_INT ,
} ;
2011-01-25 22:03:28 +00:00
AVOutputFormat ff_matroska_muxer = {
2011-07-16 20:18:12 +00:00
. name = " matroska " ,
2012-07-24 21:51:41 +00:00
. long_name = NULL_IF_CONFIG_SMALL ( " Matroska " ) ,
2011-07-16 20:18:12 +00:00
. mime_type = " video/x-matroska " ,
. extensions = " mkv " ,
. priv_data_size = sizeof ( MatroskaMuxContext ) ,
2012-07-21 23:44:26 +00:00
. audio_codec = CONFIG_LIBVORBIS_ENCODER ?
2012-08-05 09:11:04 +00:00
AV_CODEC_ID_VORBIS : AV_CODEC_ID_AC3 ,
2012-07-21 23:44:26 +00:00
. video_codec = CONFIG_LIBX264_ENCODER ?
2012-08-05 09:11:04 +00:00
AV_CODEC_ID_H264 : AV_CODEC_ID_MPEG4 ,
2011-07-16 20:18:12 +00:00
. write_header = mkv_write_header ,
2013-08-19 07:33:14 +00:00
. write_packet = mkv_write_flush_packet ,
2011-07-16 20:18:12 +00:00
. write_trailer = mkv_write_trailer ,
2011-05-26 18:19:04 +00:00
. flags = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS |
2013-08-19 07:33:14 +00:00
AVFMT_TS_NONSTRICT | AVFMT_ALLOW_FLUSH ,
2012-04-06 14:50:48 +00:00
. codec_tag = ( const AVCodecTag * const [ ] ) {
ff_codec_bmp_tags , ff_codec_wav_tags , 0
} ,
2012-08-05 09:11:04 +00:00
. subtitle_codec = AV_CODEC_ID_SSA ,
2011-08-11 18:35:46 +00:00
. query_codec = mkv_query_codec ,
2013-04-30 06:36:20 +00:00
. priv_class = & matroska_class ,
2007-09-05 00:22:37 +00:00
} ;
2010-06-04 22:40:54 +00:00
# endif
# if CONFIG_WEBM_MUXER
2013-04-30 06:36:20 +00:00
static const AVClass webm_class = {
. class_name = " webm muxer " ,
. item_name = av_default_item_name ,
. option = options ,
. version = LIBAVUTIL_VERSION_INT ,
} ;
2011-01-25 22:03:28 +00:00
AVOutputFormat ff_webm_muxer = {
2011-07-16 20:18:12 +00:00
. name = " webm " ,
2012-07-24 21:51:41 +00:00
. long_name = NULL_IF_CONFIG_SMALL ( " WebM " ) ,
2011-07-16 20:18:12 +00:00
. mime_type = " video/webm " ,
. extensions = " webm " ,
. priv_data_size = sizeof ( MatroskaMuxContext ) ,
2015-08-09 08:59:33 +00:00
. audio_codec = CONFIG_LIBOPUS_ENCODER ? AV_CODEC_ID_OPUS : AV_CODEC_ID_VORBIS ,
. video_codec = CONFIG_LIBVPX_VP9_ENCODER ? AV_CODEC_ID_VP9 : AV_CODEC_ID_VP8 ,
2011-07-16 20:18:12 +00:00
. write_header = mkv_write_header ,
2013-08-19 07:33:14 +00:00
. write_packet = mkv_write_flush_packet ,
2011-07-16 20:18:12 +00:00
. write_trailer = mkv_write_trailer ,
2011-05-26 18:19:04 +00:00
. flags = AVFMT_GLOBALHEADER | AVFMT_VARIABLE_FPS |
2013-08-19 07:33:14 +00:00
AVFMT_TS_NONSTRICT | AVFMT_ALLOW_FLUSH ,
2013-04-30 06:36:20 +00:00
. priv_class = & webm_class ,
2010-06-04 22:40:54 +00:00
} ;
# endif
2007-09-05 00:24:19 +00:00
2010-06-04 22:40:54 +00:00
# if CONFIG_MATROSKA_AUDIO_MUXER
2013-04-30 06:36:20 +00:00
static const AVClass mka_class = {
. class_name = " matroska audio muxer " ,
. item_name = av_default_item_name ,
. option = options ,
. version = LIBAVUTIL_VERSION_INT ,
} ;
2011-01-25 22:03:28 +00:00
AVOutputFormat ff_matroska_audio_muxer = {
2011-07-16 20:18:12 +00:00
. name = " matroska " ,
2012-07-24 21:51:41 +00:00
. long_name = NULL_IF_CONFIG_SMALL ( " Matroska " ) ,
2011-07-16 20:18:12 +00:00
. mime_type = " audio/x-matroska " ,
. extensions = " mka " ,
. priv_data_size = sizeof ( MatroskaMuxContext ) ,
2012-07-21 23:44:26 +00:00
. audio_codec = CONFIG_LIBVORBIS_ENCODER ?
2012-08-05 09:11:04 +00:00
AV_CODEC_ID_VORBIS : AV_CODEC_ID_AC3 ,
. video_codec = AV_CODEC_ID_NONE ,
2011-07-16 20:18:12 +00:00
. write_header = mkv_write_header ,
2013-08-19 07:33:14 +00:00
. write_packet = mkv_write_flush_packet ,
2011-07-16 20:18:12 +00:00
. write_trailer = mkv_write_trailer ,
2013-08-19 07:33:14 +00:00
. flags = AVFMT_GLOBALHEADER | AVFMT_TS_NONSTRICT |
AVFMT_ALLOW_FLUSH ,
2012-04-06 14:50:48 +00:00
. codec_tag = ( const AVCodecTag * const [ ] ) { ff_codec_wav_tags , 0 } ,
2013-04-30 06:36:20 +00:00
. priv_class = & mka_class ,
2007-09-05 00:24:19 +00:00
} ;
2010-06-04 22:40:54 +00:00
# endif