virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2024-12-23 12:43:46 +02:00
Code Issues Releases Activity

Merge commit '48a4ffa722c0874b251de9d201babed52cef0bcb'

Browse Source 
* commit '48a4ffa722c0874b251de9d201babed52cef0bcb':
  asf: K&R formatting cosmetics
  vc1dec: use codec_id instead of codec_tag for VC1IMAGE
  sh4: drop unused functions

Conflicts:
	libavformat/asf.c
	libavformat/asfdec.c
	libavformat/asfenc.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
This commit is contained in:
Michael Niedermayer 2013-02-06 14:10:26 +01:00
commit fadf845973
6 changed files with 529 additions and 519 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
libavcodec/sh4/dsputil_align.c
View File

@ -65,34 +65,6 @@
dest+=stride; \ dest+=stride; \
} while(--height) } while(--height)
#define OP put
static void put_pixels4_c(uint8_t *dest,const uint8_t *ref, const int stride,int height)
{
switch((int)ref&3){
case 0: OP_C40(); return;
case 1: OP_C4(1); return;
case 2: OP_C4(2); return;
case 3: OP_C4(3); return;
}
}
#undef OP
#define OP avg
static void avg_pixels4_c(uint8_t *dest,const uint8_t *ref, const int stride,int height)
{
switch((int)ref&3){
case 0: OP_C40(); return;
case 1: OP_C4(1); return;
case 2: OP_C4(2); return;
case 3: OP_C4(3); return;
}
}
#undef OP
#define OP_C(ofs,sz,avg2) \ #define OP_C(ofs,sz,avg2) \
{ \ { \
ref-=ofs; \ ref-=ofs; \

2
libavcodec/vc1dec.c
View File

@ -5262,7 +5262,7 @@ static av_cold int vc1_decode_init(AVCodecContext *avctx)
av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n"); av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
return -1; return -1;
} }
v->res_sprite = (avctx->codec_tag == MKTAG('W','V','P','2')); v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
} }
avctx->profile = v->profile; avctx->profile = v->profile;

47
libavformat/asf.c
View File

@ -20,7 +20,6 @@
#include "asf.h" #include "asf.h"
const ff_asf_guid ff_asf_header = { const ff_asf_guid ff_asf_header = {
0x30, 0x26, 0xB2, 0x75, 0x8E, 0x66, 0xCF, 0x11, 0xA6, 0xD9, 0x00, 0xAA, 0x00, 0x62, 0xCE, 0x6C 0x30, 0x26, 0xB2, 0x75, 0x8E, 0x66, 0xCF, 0x11, 0xA6, 0xD9, 0x00, 0xAA, 0x00, 0x62, 0xCE, 0x6C
}; };
@ -48,7 +47,7 @@ const ff_asf_guid ff_asf_audio_conceal_none = {
}; };
const ff_asf_guid ff_asf_audio_conceal_spread = { const ff_asf_guid ff_asf_audio_conceal_spread = {
0x50, 0xCD, 0xC3, 0xBF, 0x8F, 0x61, 0xCF, 0x11, 0x8B, 0xB2, 0x00, 0xAA, 0x00, 0xB4, 0xE2, 0x20 0x50, 0xCD, 0xC3, 0xBF, 0x8F, 0x61, 0xCF, 0x11, 0x8B, 0xB2, 0x00, 0xAA, 0x00, 0xB4, 0xE2, 0x20
}; };
const ff_asf_guid ff_asf_video_stream = { const ff_asf_guid ff_asf_video_stream = {
@ -91,31 +90,31 @@ const ff_asf_guid ff_asf_head2_guid = {
}; };
const ff_asf_guid ff_asf_extended_content_header = { const ff_asf_guid ff_asf_extended_content_header = {
0x40, 0xA4, 0xD0, 0xD2, 0x07, 0xE3, 0xD2, 0x11, 0x97, 0xF0, 0x00, 0xA0, 0xC9, 0x5E, 0xA8, 0x50 0x40, 0xA4, 0xD0, 0xD2, 0x07, 0xE3, 0xD2, 0x11, 0x97, 0xF0, 0x00, 0xA0, 0xC9, 0x5E, 0xA8, 0x50
}; };
const ff_asf_guid ff_asf_simple_index_header = { const ff_asf_guid ff_asf_simple_index_header = {
0x90, 0x08, 0x00, 0x33, 0xB1, 0xE5, 0xCF, 0x11, 0x89, 0xF4, 0x00, 0xA0, 0xC9, 0x03, 0x49, 0xCB 0x90, 0x08, 0x00, 0x33, 0xB1, 0xE5, 0xCF, 0x11, 0x89, 0xF4, 0x00, 0xA0, 0xC9, 0x03, 0x49, 0xCB
}; };
const ff_asf_guid ff_asf_ext_stream_embed_stream_header = { const ff_asf_guid ff_asf_ext_stream_embed_stream_header = {
0xe2, 0x65, 0xfb, 0x3a, 0xEF, 0x47, 0xF2, 0x40, 0xac, 0x2c, 0x70, 0xa9, 0x0d, 0x71, 0xd3, 0x43 0xe2, 0x65, 0xfb, 0x3a, 0xEF, 0x47, 0xF2, 0x40, 0xac, 0x2c, 0x70, 0xa9, 0x0d, 0x71, 0xd3, 0x43
}; };
const ff_asf_guid ff_asf_ext_stream_audio_stream = { const ff_asf_guid ff_asf_ext_stream_audio_stream = {
0x9d, 0x8c, 0x17, 0x31, 0xE1, 0x03, 0x28, 0x45, 0xb5, 0x82, 0x3d, 0xf9, 0xdb, 0x22, 0xf5, 0x03 0x9d, 0x8c, 0x17, 0x31, 0xE1, 0x03, 0x28, 0x45, 0xb5, 0x82, 0x3d, 0xf9, 0xdb, 0x22, 0xf5, 0x03
}; };
const ff_asf_guid ff_asf_metadata_header = { const ff_asf_guid ff_asf_metadata_header = {
0xea, 0xcb, 0xf8, 0xc5, 0xaf, 0x5b, 0x77, 0x48, 0x84, 0x67, 0xaa, 0x8c, 0x44, 0xfa, 0x4c, 0xca 0xea, 0xcb, 0xf8, 0xc5, 0xaf, 0x5b, 0x77, 0x48, 0x84, 0x67, 0xaa, 0x8c, 0x44, 0xfa, 0x4c, 0xca
}; };
const ff_asf_guid ff_asf_marker_header = { const ff_asf_guid ff_asf_marker_header = {
0x01, 0xCD, 0x87, 0xF4, 0x51, 0xA9, 0xCF, 0x11, 0x8E, 0xE6, 0x00, 0xC0, 0x0C, 0x20, 0x53, 0x65 0x01, 0xCD, 0x87, 0xF4, 0x51, 0xA9, 0xCF, 0x11, 0x8E, 0xE6, 0x00, 0xC0, 0x0C, 0x20, 0x53, 0x65
}; };
/* I am not a number !!! This GUID is the one found on the PC used to /* I am not a number !!! This GUID is the one found on the PC used to
generate the stream */ * generate the stream */
const ff_asf_guid ff_asf_my_guid = { const ff_asf_guid ff_asf_my_guid = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
}; };
@ -138,22 +137,22 @@ const ff_asf_guid ff_asf_digital_signature = {
/* List of official tags at http://msdn.microsoft.com/en-us/library/dd743066(VS.85).aspx */ /* List of official tags at http://msdn.microsoft.com/en-us/library/dd743066(VS.85).aspx */
const AVMetadataConv ff_asf_metadata_conv[] = { const AVMetadataConv ff_asf_metadata_conv[] = {
{ "WM/AlbumArtist" , "album_artist"}, { "WM/AlbumArtist", "album_artist" },
{ "WM/AlbumTitle" , "album" }, { "WM/AlbumTitle", "album" },
{ "Author" , "artist" }, { "Author", "artist" },
{ "Description" , "comment" }, { "Description", "comment" },
{ "WM/Composer" , "composer" }, { "WM/Composer", "composer" },
{ "WM/EncodedBy" , "encoded_by" }, { "WM/EncodedBy", "encoded_by" },
{ "WM/EncodingSettings", "encoder" }, { "WM/EncodingSettings", "encoder" },
{ "WM/Genre" , "genre" }, { "WM/Genre", "genre" },
{ "WM/Language" , "language" }, { "WM/Language", "language" },
{ "WM/OriginalFilename", "filename" }, { "WM/OriginalFilename", "filename" },
{ "WM/PartOfSet" , "disc" }, { "WM/PartOfSet", "disc" },
{ "WM/Publisher" , "publisher" }, { "WM/Publisher", "publisher" },
{ "WM/Tool" , "encoder" }, { "WM/Tool", "encoder" },
{ "WM/TrackNumber" , "track" }, { "WM/TrackNumber", "track" },
{ "WM/MediaStationCallSign", "service_provider" }, { "WM/MediaStationCallSign", "service_provider" },
{ "WM/MediaStationName", "service_name" }, { "WM/MediaStationName", "service_name" },
// { "Year" , "date" }, TODO: conversion year<->date // { "Year" , "date" }, TODO: conversion year<->date
{ 0 } { 0 }
}; };

62
libavformat/asfcrypt.c
View File

@ -20,10 +20,10 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
#include "libavutil/common.h"
#include "libavutil/intreadwrite.h"
#include "libavutil/bswap.h" #include "libavutil/bswap.h"
#include "libavutil/common.h"
#include "libavutil/des.h" #include "libavutil/des.h"
#include "libavutil/intreadwrite.h"
#include "libavutil/rc4.h" #include "libavutil/rc4.h"
#include "asfcrypt.h" #include "asfcrypt.h"
@ -32,7 +32,8 @@
* @param v number to invert, must be odd! * @param v number to invert, must be odd!
* @return number so that result * v = 1 (mod 2^32) * @return number so that result * v = 1 (mod 2^32)
*/ */
static uint32_t inverse(uint32_t v) { static uint32_t inverse(uint32_t v)
{
// v ^ 3 gives the inverse (mod 16), could also be implemented // v ^ 3 gives the inverse (mod 16), could also be implemented
// as table etc. (only lowest 4 bits matter!) // as table etc. (only lowest 4 bits matter!)
uint32_t inverse = v * v * v; uint32_t inverse = v * v * v;
@ -50,7 +51,8 @@ static uint32_t inverse(uint32_t v) {
* @param keys output key array containing the keys for encryption in * @param keys output key array containing the keys for encryption in
* native endianness * native endianness
*/ */
static void multiswap_init(const uint8_t keybuf[48], uint32_t keys[12]) { static void multiswap_init(const uint8_t keybuf[48], uint32_t keys[12])
{
int i; int i;
for (i = 0; i < 12; i++) for (i = 0; i < 12; i++)
keys[i] = AV_RL32(keybuf + (i << 2)) | 1; keys[i] = AV_RL32(keybuf + (i << 2)) | 1;
@ -61,7 +63,8 @@ static void multiswap_init(const uint8_t keybuf[48], uint32_t keys[12]) {
* the other way round. * the other way round.
* @param keys key array of ints to invert * @param keys key array of ints to invert
*/ */
static void multiswap_invert_keys(uint32_t keys[12]) { static void multiswap_invert_keys(uint32_t keys[12])
{
int i; int i;
for (i = 0; i < 5; i++) for (i = 0; i < 5; i++)
keys[i] = inverse(keys[i]); keys[i] = inverse(keys[i]);
@ -69,23 +72,25 @@ static void multiswap_invert_keys(uint32_t keys[12]) {
keys[i] = inverse(keys[i]); keys[i] = inverse(keys[i]);
} }
static uint32_t multiswap_step(const uint32_t keys[12], uint32_t v) { static uint32_t multiswap_step(const uint32_t keys[12], uint32_t v)
{
int i; int i;
v *= keys[0]; v *= keys[0];
for (i = 1; i < 5; i++) { for (i = 1; i < 5; i++) {
v = (v >> 16) | (v << 16); v = (v >> 16) | (v << 16);
v *= keys[i]; v *= keys[i];
} }
v += keys[5]; v += keys[5];
return v; return v;
} }
static uint32_t multiswap_inv_step(const uint32_t keys[12], uint32_t v) { static uint32_t multiswap_inv_step(const uint32_t keys[12], uint32_t v)
{
int i; int i;
v -= keys[5]; v -= keys[5];
for (i = 4; i > 0; i--) { for (i = 4; i > 0; i--) {
v *= keys[i]; v *= keys[i];
v = (v >> 16) | (v << 16); v = (v >> 16) | (v << 16);
} }
v *= keys[0]; v *= keys[0];
return v; return v;
@ -99,17 +104,19 @@ static uint32_t multiswap_inv_step(const uint32_t keys[12], uint32_t v) {
* @param data data to encrypt * @param data data to encrypt
* @return encrypted data * @return encrypted data
*/ */
static uint64_t multiswap_enc(const uint32_t keys[12], uint64_t key, uint64_t data) { static uint64_t multiswap_enc(const uint32_t keys[12],
uint64_t key, uint64_t data)
{
uint32_t a = data; uint32_t a = data;
uint32_t b = data >> 32; uint32_t b = data >> 32;
uint32_t c; uint32_t c;
uint32_t tmp; uint32_t tmp;
a += key; a += key;
tmp = multiswap_step(keys , a); tmp = multiswap_step(keys, a);
b += tmp; b += tmp;
c = (key >> 32) + tmp; c = (key >> 32) + tmp;
tmp = multiswap_step(keys + 6, b); tmp = multiswap_step(keys + 6, b);
c += tmp; c += tmp;
return ((uint64_t)c << 32) | tmp; return ((uint64_t)c << 32) | tmp;
} }
@ -121,25 +128,28 @@ static uint64_t multiswap_enc(const uint32_t keys[12], uint64_t key, uint64_t da
* @param data data to decrypt * @param data data to decrypt
* @return decrypted data * @return decrypted data
*/ */
static uint64_t multiswap_dec(const uint32_t keys[12], uint64_t key, uint64_t data) { static uint64_t multiswap_dec(const uint32_t keys[12],
uint64_t key, uint64_t data)
{
uint32_t a; uint32_t a;
uint32_t b; uint32_t b;
uint32_t c = data >> 32; uint32_t c = data >> 32;
uint32_t tmp = data; uint32_t tmp = data;
c -= tmp; c -= tmp;
b = multiswap_inv_step(keys + 6, tmp); b = multiswap_inv_step(keys + 6, tmp);
tmp = c - (key >> 32); tmp = c - (key >> 32);
b -= tmp; b -= tmp;
a = multiswap_inv_step(keys , tmp); a = multiswap_inv_step(keys, tmp);
a -= key; a -= key;
return ((uint64_t)b << 32) | a; return ((uint64_t)b << 32) | a;
} }
void ff_asfcrypt_dec(const uint8_t key[20], uint8_t *data, int len) { void ff_asfcrypt_dec(const uint8_t key[20], uint8_t *data, int len)
{
struct AVDES des; struct AVDES des;
struct AVRC4 rc4; struct AVRC4 rc4;
int num_qwords = len >> 3; int num_qwords = len >> 3;
uint8_t *qwords = data; uint8_t *qwords = data;
uint64_t rc4buff[8] = { 0 }; uint64_t rc4buff[8] = { 0 };
uint64_t packetkey; uint64_t packetkey;
uint32_t ms_keys[12]; uint32_t ms_keys[12];
@ -155,7 +165,7 @@ void ff_asfcrypt_dec(const uint8_t key[20], uint8_t *data, int len) {
av_rc4_crypt(&rc4, (uint8_t *)rc4buff, NULL, sizeof(rc4buff), NULL, 1); av_rc4_crypt(&rc4, (uint8_t *)rc4buff, NULL, sizeof(rc4buff), NULL, 1);
multiswap_init((uint8_t *)rc4buff, ms_keys); multiswap_init((uint8_t *)rc4buff, ms_keys);
packetkey = AV_RN64(&qwords[num_qwords*8 - 8]); packetkey = AV_RN64(&qwords[num_qwords * 8 - 8]);
packetkey ^= rc4buff[7]; packetkey ^= rc4buff[7];
av_des_init(&des, key + 12, 64, 1); av_des_init(&des, key + 12, 64, 1);
av_des_crypt(&des, (uint8_t *)&packetkey, (uint8_t *)&packetkey, 1, NULL, 1); av_des_crypt(&des, (uint8_t *)&packetkey, (uint8_t *)&packetkey, 1, NULL, 1);

600
libavformat/asfdec.c
View File

File diff suppressed because it is too large Load Diff

309
libavformat/asfenc.c
View File

@ -18,12 +18,13 @@
* License along with FFmpeg; if not, write to the Free Software * License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
#include "libavutil/dict.h"
#include "avformat.h" #include "avformat.h"
#include "avio_internal.h"
#include "internal.h" #include "internal.h"
#include "riff.h" #include "riff.h"
#include "asf.h" #include "asf.h"
#include "avio_internal.h"
#include "libavutil/dict.h"
#undef NDEBUG #undef NDEBUG
#include <assert.h> #include <assert.h>
@ -33,10 +34,9 @@
#define ASF_INDEX_BLOCK (1<<9) #define ASF_INDEX_BLOCK (1<<9)
#define ASF_PACKET_ERROR_CORRECTION_DATA_SIZE 0x2 #define ASF_PACKET_ERROR_CORRECTION_DATA_SIZE 0x2
#define ASF_PACKET_ERROR_CORRECTION_FLAGS (\ #define ASF_PACKET_ERROR_CORRECTION_FLAGS \
ASF_PACKET_FLAG_ERROR_CORRECTION_PRESENT | \ (ASF_PACKET_FLAG_ERROR_CORRECTION_PRESENT | \
ASF_PACKET_ERROR_CORRECTION_DATA_SIZE\ ASF_PACKET_ERROR_CORRECTION_DATA_SIZE)
)
#if (ASF_PACKET_ERROR_CORRECTION_FLAGS != 0) #if (ASF_PACKET_ERROR_CORRECTION_FLAGS != 0)
# define ASF_PACKET_ERROR_CORRECTION_FLAGS_FIELD_SIZE 1 # define ASF_PACKET_ERROR_CORRECTION_FLAGS_FIELD_SIZE 1
@ -44,12 +44,11 @@
# define ASF_PACKET_ERROR_CORRECTION_FLAGS_FIELD_SIZE 0 # define ASF_PACKET_ERROR_CORRECTION_FLAGS_FIELD_SIZE 0
#endif #endif
#define ASF_PPI_PROPERTY_FLAGS (\ #define ASF_PPI_PROPERTY_FLAGS \
ASF_PL_FLAG_REPLICATED_DATA_LENGTH_FIELD_IS_BYTE | \ (ASF_PL_FLAG_REPLICATED_DATA_LENGTH_FIELD_IS_BYTE | \
ASF_PL_FLAG_OFFSET_INTO_MEDIA_OBJECT_LENGTH_FIELD_IS_DWORD | \ ASF_PL_FLAG_OFFSET_INTO_MEDIA_OBJECT_LENGTH_FIELD_IS_DWORD | \
ASF_PL_FLAG_MEDIA_OBJECT_NUMBER_LENGTH_FIELD_IS_BYTE | \ ASF_PL_FLAG_MEDIA_OBJECT_NUMBER_LENGTH_FIELD_IS_BYTE | \
ASF_PL_FLAG_STREAM_NUMBER_LENGTH_FIELD_IS_BYTE \ ASF_PL_FLAG_STREAM_NUMBER_LENGTH_FIELD_IS_BYTE)
)
#define ASF_PPI_LENGTH_TYPE_FLAGS 0 #define ASF_PPI_LENGTH_TYPE_FLAGS 0
@ -68,7 +67,6 @@
# define ASF_PPI_SEQUENCE_FIELD_SIZE 0 # define ASF_PPI_SEQUENCE_FIELD_SIZE 0
#endif #endif
#if (ASF_PPI_FLAG_PACKET_LENGTH_FIELD_IS_BYTE == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_PACKET_LENGTH_FIELD_SIZE)) #if (ASF_PPI_FLAG_PACKET_LENGTH_FIELD_IS_BYTE == (ASF_PPI_LENGTH_TYPE_FLAGS & ASF_PPI_MASK_PACKET_LENGTH_FIELD_SIZE))
# define ASF_PPI_PACKET_LENGTH_FIELD_SIZE 1 # define ASF_PPI_PACKET_LENGTH_FIELD_SIZE 1
#endif #endif
@ -144,51 +142,45 @@
# define ASF_PAYLOAD_LENGTH_FIELD_SIZE 0 # define ASF_PAYLOAD_LENGTH_FIELD_SIZE 0
#endif #endif
#define PACKET_HEADER_MIN_SIZE (\ #define PACKET_HEADER_MIN_SIZE \
ASF_PACKET_ERROR_CORRECTION_FLAGS_FIELD_SIZE + \ (ASF_PACKET_ERROR_CORRECTION_FLAGS_FIELD_SIZE + \
ASF_PACKET_ERROR_CORRECTION_DATA_SIZE + \ ASF_PACKET_ERROR_CORRECTION_DATA_SIZE + \
1 + /*Length Type Flags*/ \ 1 + /* Length Type Flags */ \
1 + /*Property Flags*/ \ 1 + /* Property Flags */ \
ASF_PPI_PACKET_LENGTH_FIELD_SIZE + \ ASF_PPI_PACKET_LENGTH_FIELD_SIZE + \
ASF_PPI_SEQUENCE_FIELD_SIZE + \ ASF_PPI_SEQUENCE_FIELD_SIZE + \
ASF_PPI_PADDING_LENGTH_FIELD_SIZE + \ ASF_PPI_PADDING_LENGTH_FIELD_SIZE + \
4 + /*Send Time Field*/ \ 4 + /* Send Time Field */ \
2 /*Duration Field*/ \ 2) /* Duration Field */
)
// Replicated Data shall be at least 8 bytes long. // Replicated Data shall be at least 8 bytes long.
#define ASF_PAYLOAD_REPLICATED_DATA_LENGTH 0x08 #define ASF_PAYLOAD_REPLICATED_DATA_LENGTH 0x08
#define PAYLOAD_HEADER_SIZE_SINGLE_PAYLOAD (\ #define PAYLOAD_HEADER_SIZE_SINGLE_PAYLOAD \
1 + /*Stream Number*/ \ (1 + /* Stream Number */ \
ASF_PAYLOAD_MEDIA_OBJECT_NUMBER_FIELD_SIZE + \ ASF_PAYLOAD_MEDIA_OBJECT_NUMBER_FIELD_SIZE + \
ASF_PAYLOAD_OFFSET_INTO_MEDIA_OBJECT_FIELD_SIZE + \ ASF_PAYLOAD_OFFSET_INTO_MEDIA_OBJECT_FIELD_SIZE + \
ASF_PAYLOAD_REPLICATED_DATA_LENGTH_FIELD_SIZE + \ ASF_PAYLOAD_REPLICATED_DATA_LENGTH_FIELD_SIZE + \
ASF_PAYLOAD_REPLICATED_DATA_LENGTH \ ASF_PAYLOAD_REPLICATED_DATA_LENGTH)
)
#define PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS (\ #define PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS \
1 + /*Stream Number*/ \ (1 + /* Stream Number */ \
ASF_PAYLOAD_MEDIA_OBJECT_NUMBER_FIELD_SIZE + \ ASF_PAYLOAD_MEDIA_OBJECT_NUMBER_FIELD_SIZE + \
ASF_PAYLOAD_OFFSET_INTO_MEDIA_OBJECT_FIELD_SIZE + \ ASF_PAYLOAD_OFFSET_INTO_MEDIA_OBJECT_FIELD_SIZE + \
ASF_PAYLOAD_REPLICATED_DATA_LENGTH_FIELD_SIZE + \ ASF_PAYLOAD_REPLICATED_DATA_LENGTH_FIELD_SIZE + \
ASF_PAYLOAD_REPLICATED_DATA_LENGTH + \ ASF_PAYLOAD_REPLICATED_DATA_LENGTH + \
ASF_PAYLOAD_LENGTH_FIELD_SIZE \ ASF_PAYLOAD_LENGTH_FIELD_SIZE)
)
#define SINGLE_PAYLOAD_DATA_LENGTH (\ #define SINGLE_PAYLOAD_DATA_LENGTH \
PACKET_SIZE - \ (PACKET_SIZE - \
PACKET_HEADER_MIN_SIZE - \ PACKET_HEADER_MIN_SIZE - \
PAYLOAD_HEADER_SIZE_SINGLE_PAYLOAD \ PAYLOAD_HEADER_SIZE_SINGLE_PAYLOAD)
)
#define MULTI_PAYLOAD_CONSTANT (\ #define MULTI_PAYLOAD_CONSTANT \
PACKET_SIZE - \ (PACKET_SIZE - \
PACKET_HEADER_MIN_SIZE - \ PACKET_HEADER_MIN_SIZE - \
1 - /*Payload Flags*/ \ 1 - /* Payload Flags */ \
2*PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS \ 2 * PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS)
)
typedef struct { typedef struct {
uint32_t seqno; uint32_t seqno;
@ -208,7 +200,7 @@ typedef struct {
/* only for reading */ /* only for reading */
uint64_t data_offset; ///< beginning of the first data packet uint64_t data_offset; ///< beginning of the first data packet
ASFIndex* index_ptr; ASFIndex *index_ptr;
uint32_t nb_index_memory_alloc; uint32_t nb_index_memory_alloc;
uint16_t maximum_packet; uint16_t maximum_packet;
uint32_t next_packet_number; uint32_t next_packet_number;
@ -218,10 +210,10 @@ typedef struct {
} ASFContext; } ASFContext;
static const AVCodecTag codec_asf_bmp_tags[] = { static const AVCodecTag codec_asf_bmp_tags[] = {
{ AV_CODEC_ID_MPEG4, MKTAG('M', '4', 'S', '2') }, { AV_CODEC_ID_MPEG4, MKTAG('M', '4', 'S', '2') },
{ AV_CODEC_ID_MPEG4, MKTAG('M', 'P', '4', 'S') }, { AV_CODEC_ID_MPEG4, MKTAG('M', 'P', '4', 'S') },
{ AV_CODEC_ID_MSMPEG4V3, MKTAG('M', 'P', '4', '3') }, { AV_CODEC_ID_MSMPEG4V3, MKTAG('M', 'P', '4', '3') },
{ AV_CODEC_ID_NONE, 0 }, { AV_CODEC_ID_NONE, 0 },
}; };
#define PREROLL_TIME 3100 #define PREROLL_TIME 3100
@ -269,7 +261,8 @@ static void end_header(AVIOContext *pb, int64_t pos)
} }
/* write an asf chunk (only used in streaming case) */ /* write an asf chunk (only used in streaming case) */
static void put_chunk(AVFormatContext *s, int type, int payload_length, int flags) static void put_chunk(AVFormatContext *s, int type,
int payload_length, int flags)
{ {
ASFContext *asf = s->priv_data; ASFContext *asf = s->priv_data;
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
@ -277,10 +270,10 @@ static void put_chunk(AVFormatContext *s, int type, int payload_length, int flag
length = payload_length + 8; length = payload_length + 8;
avio_wl16(pb, type); avio_wl16(pb, type);
avio_wl16(pb, length); //size avio_wl16(pb, length); // size
avio_wl32(pb, asf->seqno);//sequence number avio_wl32(pb, asf->seqno); // sequence number
avio_wl16(pb, flags); /* unknown bytes */ avio_wl16(pb, flags); // unknown bytes
avio_wl16(pb, length); //size_confirm avio_wl16(pb, length); // size_confirm
asf->seqno++; asf->seqno++;
} }
@ -289,13 +282,14 @@ static int64_t unix_to_file_time(int ti)
{ {
int64_t t; int64_t t;
t = ti * INT64_C(10000000); t = ti * INT64_C(10000000);
t += INT64_C(116444736000000000); t += INT64_C(116444736000000000);
return t; return t;
} }
/* write the header (used two times if non streamed) */ /* write the header (used two times if non streamed) */
static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data_chunk_size) static int asf_write_header1(AVFormatContext *s, int64_t file_size,
int64_t data_chunk_size)
{ {
ASFContext *asf = s->priv_data; ASFContext *asf = s->priv_data;
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
@ -310,18 +304,18 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
ff_metadata_conv(&s->metadata, ff_asf_metadata_conv, NULL); ff_metadata_conv(&s->metadata, ff_asf_metadata_conv, NULL);
tags[0] = av_dict_get(s->metadata, "title" , NULL, 0); tags[0] = av_dict_get(s->metadata, "title", NULL, 0);
tags[1] = av_dict_get(s->metadata, "author" , NULL, 0); tags[1] = av_dict_get(s->metadata, "author", NULL, 0);
tags[2] = av_dict_get(s->metadata, "copyright", NULL, 0); tags[2] = av_dict_get(s->metadata, "copyright", NULL, 0);
tags[3] = av_dict_get(s->metadata, "comment" , NULL, 0); tags[3] = av_dict_get(s->metadata, "comment", NULL, 0);
tags[4] = av_dict_get(s->metadata, "rating" , NULL, 0); tags[4] = av_dict_get(s->metadata, "rating", NULL, 0);
duration = asf->duration + PREROLL_TIME * 10000; duration = asf->duration + PREROLL_TIME * 10000;
has_title = tags[0] || tags[1] || tags[2] || tags[3] || tags[4]; has_title = tags[0] || tags[1] || tags[2] || tags[3] || tags[4];
metadata_count = av_dict_count(s->metadata); metadata_count = av_dict_count(s->metadata);
bit_rate = 0; bit_rate = 0;
for(n=0;n<s->nb_streams;n++) { for (n = 0; n < s->nb_streams; n++) {
enc = s->streams[n]->codec; enc = s->streams[n]->codec;
avpriv_set_pts_info(s->streams[n], 32, 1, 1000); /* 32 bit pts in ms */ avpriv_set_pts_info(s->streams[n], 32, 1, 1000); /* 32 bit pts in ms */
@ -341,7 +335,7 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
/* file header */ /* file header */
header_offset = avio_tell(pb); header_offset = avio_tell(pb);
hpos = put_header(pb, &ff_asf_file_header); hpos = put_header(pb, &ff_asf_file_header);
ff_put_guid(pb, &ff_asf_my_guid); ff_put_guid(pb, &ff_asf_my_guid);
avio_wl64(pb, file_size); avio_wl64(pb, file_size);
file_time = 0; file_time = 0;
@ -350,7 +344,7 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
avio_wl64(pb, duration); /* end time stamp (in 100ns units) */ avio_wl64(pb, duration); /* end time stamp (in 100ns units) */
avio_wl64(pb, asf->duration); /* duration (in 100ns units) */ avio_wl64(pb, asf->duration); /* duration (in 100ns units) */
avio_wl64(pb, PREROLL_TIME); /* start time stamp */ avio_wl64(pb, PREROLL_TIME); /* start time stamp */
avio_wl32(pb, (asf->is_streamed || !pb->seekable ) ? 3 : 2); /* ??? */ avio_wl32(pb, (asf->is_streamed || !pb->seekable) ? 3 : 2); /* ??? */
avio_wl32(pb, s->packet_size); /* packet size */ avio_wl32(pb, s->packet_size); /* packet size */
avio_wl32(pb, s->packet_size); /* packet size */ avio_wl32(pb, s->packet_size); /* packet size */
avio_wl32(pb, bit_rate); /* Nominal data rate in bps */ avio_wl32(pb, bit_rate); /* Nominal data rate in bps */
@ -396,26 +390,25 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
} }
/* stream headers */ /* stream headers */
for(n=0;n<s->nb_streams;n++) { for (n = 0; n < s->nb_streams; n++) {
int64_t es_pos; int64_t es_pos;
// ASFStream *stream = &asf->streams[n]; // ASFStream *stream = &asf->streams[n];
enc = s->streams[n]->codec; enc = s->streams[n]->codec;
asf->streams[n].num = n + 1; asf->streams[n].num = n + 1;
asf->streams[n].seq = 1; asf->streams[n].seq = 1;
switch (enc->codec_type) {
switch(enc->codec_type) {
case AVMEDIA_TYPE_AUDIO: case AVMEDIA_TYPE_AUDIO:
wav_extra_size = 0; wav_extra_size = 0;
extra_size = 18 + wav_extra_size; extra_size = 18 + wav_extra_size;
extra_size2 = 8; extra_size2 = 8;
break; break;
default: default:
case AVMEDIA_TYPE_VIDEO: case AVMEDIA_TYPE_VIDEO:
wav_extra_size = enc->extradata_size; wav_extra_size = enc->extradata_size;
extra_size = 0x33 + wav_extra_size; extra_size = 0x33 + wav_extra_size;
extra_size2 = 0; extra_size2 = 0;
break; break;
} }
@ -448,10 +441,10 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
} }
/* ERROR Correction */ /* ERROR Correction */
avio_w8(pb, 0x01); avio_w8(pb, 0x01);
if(enc->codec_id == AV_CODEC_ID_ADPCM_G726 || !enc->block_align){ if (enc->codec_id == AV_CODEC_ID_ADPCM_G726 || !enc->block_align) {
avio_wl16(pb, 0x0190); avio_wl16(pb, 0x0190);
avio_wl16(pb, 0x0190); avio_wl16(pb, 0x0190);
}else{ } else {
avio_wl16(pb, enc->block_align); avio_wl16(pb, enc->block_align);
avio_wl16(pb, enc->block_align); avio_wl16(pb, enc->block_align);
} }
@ -474,7 +467,7 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
hpos = put_header(pb, &ff_asf_codec_comment_header); hpos = put_header(pb, &ff_asf_codec_comment_header);
ff_put_guid(pb, &ff_asf_codec_comment1_header); ff_put_guid(pb, &ff_asf_codec_comment1_header);
avio_wl32(pb, s->nb_streams); avio_wl32(pb, s->nb_streams);
for(n=0;n<s->nb_streams;n++) { for (n = 0; n < s->nb_streams; n++) {
AVCodec *p; AVCodec *p;
const char *desc; const char *desc;
int len; int len;
@ -482,21 +475,21 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
AVIOContext *dyn_buf; AVIOContext *dyn_buf;
enc = s->streams[n]->codec; enc = s->streams[n]->codec;
p = avcodec_find_encoder(enc->codec_id); p = avcodec_find_encoder(enc->codec_id);
if(enc->codec_type == AVMEDIA_TYPE_AUDIO) if (enc->codec_type == AVMEDIA_TYPE_AUDIO)
avio_wl16(pb, 2); avio_wl16(pb, 2);
else if(enc->codec_type == AVMEDIA_TYPE_VIDEO) else if (enc->codec_type == AVMEDIA_TYPE_VIDEO)
avio_wl16(pb, 1); avio_wl16(pb, 1);
else else
avio_wl16(pb, -1); avio_wl16(pb, -1);
if(enc->codec_id == AV_CODEC_ID_WMAV2) if (enc->codec_id == AV_CODEC_ID_WMAV2)
desc = "Windows Media Audio V8"; desc = "Windows Media Audio V8";
else else
desc = p ? p->name : enc->codec_name; desc = p ? p->name : enc->codec_name;
if ( avio_open_dyn_buf(&dyn_buf) < 0) if (avio_open_dyn_buf(&dyn_buf) < 0)
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
avio_put_str16le(dyn_buf, desc); avio_put_str16le(dyn_buf, desc);
@ -508,7 +501,6 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
avio_wl16(pb, 0); /* no parameters */ avio_wl16(pb, 0); /* no parameters */
/* id */ /* id */
if (enc->codec_type == AVMEDIA_TYPE_AUDIO) { if (enc->codec_type == AVMEDIA_TYPE_AUDIO) {
avio_wl16(pb, 2); avio_wl16(pb, 2);
@ -517,14 +509,14 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
avio_wl16(pb, 4); avio_wl16(pb, 4);
avio_wl32(pb, enc->codec_tag); avio_wl32(pb, enc->codec_tag);
} }
if(!enc->codec_tag) if (!enc->codec_tag)
return -1; return -1;
} }
end_header(pb, hpos); end_header(pb, hpos);
/* patch the header size fields */ /* patch the header size fields */
cur_pos = avio_tell(pb); cur_pos = avio_tell(pb);
header_size = cur_pos - header_offset; header_size = cur_pos - header_offset;
if (asf->is_streamed) { if (asf->is_streamed) {
header_size += 8 + 30 + 50; header_size += 8 + 30 + 50;
@ -559,9 +551,9 @@ static int asf_write_header(AVFormatContext *s)
s->packet_size = PACKET_SIZE; s->packet_size = PACKET_SIZE;
asf->nb_packets = 0; asf->nb_packets = 0;
asf->index_ptr = av_malloc( sizeof(ASFIndex) * ASF_INDEX_BLOCK ); asf->index_ptr = av_malloc(sizeof(ASFIndex) * ASF_INDEX_BLOCK);
asf->nb_index_memory_alloc = ASF_INDEX_BLOCK; asf->nb_index_memory_alloc = ASF_INDEX_BLOCK;
asf->maximum_packet = 0; asf->maximum_packet = 0;
/* the data-chunk-size has to be 50, which is data_size - asf->data_offset /* the data-chunk-size has to be 50, which is data_size - asf->data_offset
* at the moment this function is done. It is needed to use asf as * at the moment this function is done. It is needed to use asf as
@ -573,11 +565,11 @@ static int asf_write_header(AVFormatContext *s)
avio_flush(s->pb); avio_flush(s->pb);
asf->packet_nb_payloads = 0; asf->packet_nb_payloads = 0;
asf->packet_timestamp_start = -1; asf->packet_timestamp_start = -1;
asf->packet_timestamp_end = -1; asf->packet_timestamp_end = -1;
ffio_init_context(&asf->pb, asf->packet_buf, s->packet_size, 1, ffio_init_context(&asf->pb, asf->packet_buf, s->packet_size, 1,
NULL, NULL, NULL, NULL); NULL, NULL, NULL, NULL);
if (s->avoid_negative_ts < 0) if (s->avoid_negative_ts < 0)
s->avoid_negative_ts = 1; s->avoid_negative_ts = 1;
@ -594,30 +586,25 @@ static int asf_write_stream_header(AVFormatContext *s)
return asf_write_header(s); return asf_write_header(s);
} }
static int put_payload_parsing_info( static int put_payload_parsing_info(AVFormatContext *s,
AVFormatContext *s, unsigned sendtime, unsigned duration,
unsigned int sendtime, int nb_payloads, int padsize)
unsigned int duration,
int nb_payloads,
int padsize
)
{ {
ASFContext *asf = s->priv_data; ASFContext *asf = s->priv_data;
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
int ppi_size, i; int ppi_size, i;
int64_t start= avio_tell(pb); int64_t start = avio_tell(pb);
int iLengthTypeFlags = ASF_PPI_LENGTH_TYPE_FLAGS; int iLengthTypeFlags = ASF_PPI_LENGTH_TYPE_FLAGS;
padsize -= PACKET_HEADER_MIN_SIZE; padsize -= PACKET_HEADER_MIN_SIZE;
if(asf->multi_payloads_present) if (asf->multi_payloads_present)
padsize--; padsize--;
assert(padsize>=0); assert(padsize >= 0);
avio_w8(pb, ASF_PACKET_ERROR_CORRECTION_FLAGS); avio_w8(pb, ASF_PACKET_ERROR_CORRECTION_FLAGS);
for (i = 0; i < ASF_PACKET_ERROR_CORRECTION_DATA_SIZE; i++){ for (i = 0; i < ASF_PACKET_ERROR_CORRECTION_DATA_SIZE; i++)
avio_w8(pb, 0x0); avio_w8(pb, 0x0);
}
if (asf->multi_payloads_present) if (asf->multi_payloads_present)
iLengthTypeFlags |= ASF_PPI_FLAG_MULTIPLE_PAYLOADS_PRESENT; iLengthTypeFlags |= ASF_PPI_FLAG_MULTIPLE_PAYLOADS_PRESENT;
@ -654,17 +641,14 @@ static void flush_packet(AVFormatContext *s)
assert(asf->packet_timestamp_end >= asf->packet_timestamp_start); assert(asf->packet_timestamp_end >= asf->packet_timestamp_start);
if (asf->is_streamed) { if (asf->is_streamed)
put_chunk(s, 0x4424, s->packet_size, 0); put_chunk(s, 0x4424, s->packet_size, 0);
}
packet_hdr_size = put_payload_parsing_info( packet_hdr_size = put_payload_parsing_info(s,
s, asf->packet_timestamp_start,
asf->packet_timestamp_start, asf->packet_timestamp_end - asf->packet_timestamp_start,
asf->packet_timestamp_end - asf->packet_timestamp_start, asf->packet_nb_payloads,
asf->packet_nb_payloads, asf->packet_size_left);
asf->packet_size_left
);
packet_filled_size = PACKET_SIZE - asf->packet_size_left; packet_filled_size = PACKET_SIZE - asf->packet_size_left;
assert(packet_hdr_size <= asf->packet_size_left); assert(packet_hdr_size <= asf->packet_size_left);
@ -674,22 +658,16 @@ static void flush_packet(AVFormatContext *s)
avio_flush(s->pb); avio_flush(s->pb);
asf->nb_packets++; asf->nb_packets++;
asf->packet_nb_payloads = 0; asf->packet_nb_payloads = 0;
asf->packet_timestamp_start = -1; asf->packet_timestamp_start = -1;
asf->packet_timestamp_end = -1; asf->packet_timestamp_end = -1;
ffio_init_context(&asf->pb, asf->packet_buf, s->packet_size, 1, ffio_init_context(&asf->pb, asf->packet_buf, s->packet_size, 1,
NULL, NULL, NULL, NULL); NULL, NULL, NULL, NULL);
} }
static void put_payload_header( static void put_payload_header(AVFormatContext *s, ASFStream *stream,
AVFormatContext *s, int64_t presentation_time, int m_obj_size,
ASFStream *stream, int m_obj_offset, int payload_len, int flags)
int64_t presentation_time,
int m_obj_size,
int m_obj_offset,
int payload_len,
int flags
)
{ {
ASFContext *asf = s->priv_data; ASFContext *asf = s->priv_data;
AVIOContext *pb = &asf->pb; AVIOContext *pb = &asf->pb;
@ -700,8 +678,8 @@ static void put_payload_header(
val |= ASF_PL_FLAG_KEY_FRAME; val |= ASF_PL_FLAG_KEY_FRAME;
avio_w8(pb, val); avio_w8(pb, val);
avio_w8(pb, stream->seq); //Media object number avio_w8(pb, stream->seq); // Media object number
avio_wl32(pb, m_obj_offset); //Offset Into Media Object avio_wl32(pb, m_obj_offset); // Offset Into Media Object
// Replicated Data shall be at least 8 bytes long. // Replicated Data shall be at least 8 bytes long.
// The first 4 bytes of data shall contain the // The first 4 bytes of data shall contain the
@ -710,23 +688,17 @@ static void put_payload_header(
// Presentation Time for the media object that the payload belongs to. // Presentation Time for the media object that the payload belongs to.
avio_w8(pb, ASF_PAYLOAD_REPLICATED_DATA_LENGTH); avio_w8(pb, ASF_PAYLOAD_REPLICATED_DATA_LENGTH);
avio_wl32(pb, m_obj_size); //Replicated Data - Media Object Size avio_wl32(pb, m_obj_size); // Replicated Data - Media Object Size
avio_wl32(pb, (uint32_t) presentation_time);//Replicated Data - Presentation Time avio_wl32(pb, (uint32_t) presentation_time); // Replicated Data - Presentation Time
if (asf->multi_payloads_present){ if (asf->multi_payloads_present) {
avio_wl16(pb, payload_len); //payload length avio_wl16(pb, payload_len); // payload length
} }
} }
static void put_frame( static void put_frame(AVFormatContext *s, ASFStream *stream, AVStream *avst,
AVFormatContext *s, int64_t timestamp, const uint8_t *buf,
ASFStream *stream, int m_obj_size, int flags)
AVStream *avst,
int64_t timestamp,
const uint8_t *buf,
int m_obj_size,
int flags
)
{ {
ASFContext *asf = s->priv_data; ASFContext *asf = s->priv_data;
int m_obj_offset, payload_len, frag_len1; int m_obj_offset, payload_len, frag_len1;
@ -738,19 +710,20 @@ static void put_frame(
asf->multi_payloads_present = (payload_len < MULTI_PAYLOAD_CONSTANT); asf->multi_payloads_present = (payload_len < MULTI_PAYLOAD_CONSTANT);
asf->packet_size_left = PACKET_SIZE; asf->packet_size_left = PACKET_SIZE;
if (asf->multi_payloads_present){ if (asf->multi_payloads_present) {
frag_len1 = MULTI_PAYLOAD_CONSTANT - 1; frag_len1 = MULTI_PAYLOAD_CONSTANT - 1;
} } else {
else {
frag_len1 = SINGLE_PAYLOAD_DATA_LENGTH; frag_len1 = SINGLE_PAYLOAD_DATA_LENGTH;
} }
asf->packet_timestamp_start = timestamp; asf->packet_timestamp_start = timestamp;
} } else {
else {
// multi payloads // multi payloads
frag_len1 = asf->packet_size_left - PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS - PACKET_HEADER_MIN_SIZE - 1; frag_len1 = asf->packet_size_left -
PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS -
PACKET_HEADER_MIN_SIZE - 1;
if(frag_len1 < payload_len && avst->codec->codec_type == AVMEDIA_TYPE_AUDIO){ if (frag_len1 < payload_len &&
avst->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
flush_packet(s); flush_packet(s);
continue; continue;
} }
@ -759,9 +732,10 @@ static void put_frame(
if (payload_len > frag_len1) if (payload_len > frag_len1)
payload_len = frag_len1; payload_len = frag_len1;
else if (payload_len == (frag_len1 - 1)) else if (payload_len == (frag_len1 - 1))
payload_len = frag_len1 - 2; //additional byte need to put padding length payload_len = frag_len1 - 2; // additional byte need to put padding length
put_payload_header(s, stream, timestamp+PREROLL_TIME, m_obj_size, m_obj_offset, payload_len, flags); put_payload_header(s, stream, timestamp + PREROLL_TIME,
m_obj_size, m_obj_offset, payload_len, flags);
avio_write(&asf->pb, buf, payload_len); avio_write(&asf->pb, buf, payload_len);
if (asf->multi_payloads_present) if (asf->multi_payloads_present)
@ -775,7 +749,7 @@ static void put_frame(
payload_len = 0; payload_len = 0;
} }
m_obj_offset += payload_len; m_obj_offset += payload_len;
buf += payload_len; buf += payload_len;
if (!asf->multi_payloads_present) if (!asf->multi_payloads_present)
flush_packet(s); flush_packet(s);
@ -821,21 +795,22 @@ static int asf_write_packet(AVFormatContext *s, AVPacket *pkt)
uint32_t packet_number; uint32_t packet_number;
int64_t pts; int64_t pts;
int start_sec; int start_sec;
int flags= pkt->flags; int flags = pkt->flags;
codec = s->streams[pkt->stream_index]->codec; codec = s->streams[pkt->stream_index]->codec;
stream = &asf->streams[pkt->stream_index]; stream = &asf->streams[pkt->stream_index];
if(codec->codec_type == AVMEDIA_TYPE_AUDIO) if (codec->codec_type == AVMEDIA_TYPE_AUDIO)
flags &= ~AV_PKT_FLAG_KEY; flags &= ~AV_PKT_FLAG_KEY;
pts = (pkt->pts != AV_NOPTS_VALUE) ? pkt->pts : pkt->dts; pts = (pkt->pts != AV_NOPTS_VALUE) ? pkt->pts : pkt->dts;
assert(pts != AV_NOPTS_VALUE); assert(pts != AV_NOPTS_VALUE);
pts *= 10000; pts *= 10000;
asf->duration= FFMAX(asf->duration, pts + pkt->duration * 10000); asf->duration = FFMAX(asf->duration, pts + pkt->duration * 10000);
packet_number = asf->nb_packets; packet_number = asf->nb_packets;
put_frame(s, stream, s->streams[pkt->stream_index], pkt->dts, pkt->data, pkt->size, flags); put_frame(s, stream, s->streams[pkt->stream_index],
pkt->dts, pkt->data, pkt->size, flags);
start_sec = (int)((PREROLL_TIME * 10000 + pts + ASF_INDEXED_INTERVAL - 1) start_sec = (int)((PREROLL_TIME * 10000 + pts + ASF_INDEXED_INTERVAL - 1)
/ ASF_INDEXED_INTERVAL); / ASF_INDEXED_INTERVAL);
@ -850,19 +825,19 @@ static int asf_write_packet(AVFormatContext *s, AVPacket *pkt)
return 0; return 0;
} }
// static int asf_write_index(AVFormatContext *s, ASFIndex *index,
static int asf_write_index(AVFormatContext *s, ASFIndex *index, uint16_t max, uint32_t count) uint16_t max, uint32_t count)
{ {
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
int i; int i;
ff_put_guid(pb, &ff_asf_simple_index_header); ff_put_guid(pb, &ff_asf_simple_index_header);
avio_wl64(pb, 24 + 16 + 8 + 4 + 4 + (4 + 2)*count); avio_wl64(pb, 24 + 16 + 8 + 4 + 4 + (4 + 2) * count);
ff_put_guid(pb, &ff_asf_my_guid); ff_put_guid(pb, &ff_asf_my_guid);
avio_wl64(pb, ASF_INDEXED_INTERVAL); avio_wl64(pb, ASF_INDEXED_INTERVAL);
avio_wl32(pb, max); avio_wl32(pb, max);
avio_wl32(pb, count); avio_wl32(pb, count);
for(i=0; i<count; i++) { for (i = 0; i < count; i++) {
avio_wl32(pb, index[i].packet_number); avio_wl32(pb, index[i].packet_number);
avio_wl16(pb, index[i].packet_count); avio_wl16(pb, index[i].packet_count);
} }
@ -873,7 +848,7 @@ static int asf_write_index(AVFormatContext *s, ASFIndex *index, uint16_t max, ui
static int asf_write_trailer(AVFormatContext *s) static int asf_write_trailer(AVFormatContext *s)
{ {
ASFContext *asf = s->priv_data; ASFContext *asf = s->priv_data;
int64_t file_size,data_size; int64_t file_size, data_size;
/* flush the current packet */ /* flush the current packet */
if (asf->pb.buf_ptr > asf->pb.buffer) if (asf->pb.buf_ptr > asf->pb.buffer)
@ -913,11 +888,11 @@ AVOutputFormat ff_asf_muxer = {
.write_packet = asf_write_packet, .write_packet = asf_write_packet,
.write_trailer = asf_write_trailer, .write_trailer = asf_write_trailer,
.flags = AVFMT_GLOBALHEADER, .flags = AVFMT_GLOBALHEADER,
.codec_tag = (const AVCodecTag* const []){ .codec_tag = (const AVCodecTag * const []) {
codec_asf_bmp_tags, ff_codec_bmp_tags, ff_codec_wav_tags, 0 codec_asf_bmp_tags, ff_codec_bmp_tags, ff_codec_wav_tags, 0
}, },
}; };
#endif #endif /* CONFIG_ASF_MUXER */
#if CONFIG_ASF_STREAM_MUXER #if CONFIG_ASF_STREAM_MUXER
AVOutputFormat ff_asf_stream_muxer = { AVOutputFormat ff_asf_stream_muxer = {
@ -932,8 +907,8 @@ AVOutputFormat ff_asf_stream_muxer = {
.write_packet = asf_write_packet, .write_packet = asf_write_packet,
.write_trailer = asf_write_trailer, .write_trailer = asf_write_trailer,
.flags = AVFMT_GLOBALHEADER, .flags = AVFMT_GLOBALHEADER,
.codec_tag = (const AVCodecTag* const []){ .codec_tag = (const AVCodecTag * const []) {
codec_asf_bmp_tags, ff_codec_bmp_tags, ff_codec_wav_tags, 0 codec_asf_bmp_tags, ff_codec_bmp_tags, ff_codec_wav_tags, 0
}, },
}; };
#endif //CONFIG_ASF_STREAM_MUXER #endif /* CONFIG_ASF_STREAM_MUXER */