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; \
} 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) \
{ \
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");
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;

47
libavformat/asf.c
View File

@ -20,7 +20,6 @@
#include "asf.h"
const ff_asf_guid ff_asf_header = {
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 = {
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 = {
@ -91,31 +90,31 @@ const ff_asf_guid ff_asf_head2_guid = {
};
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 = {
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 = {
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 = {
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 = {
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 = {
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
generate the stream */
* generate the stream */
const ff_asf_guid ff_asf_my_guid = {
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 */
const AVMetadataConv ff_asf_metadata_conv[] = {
{ "WM/AlbumArtist" , "album_artist"},
{ "WM/AlbumTitle" , "album" },
{ "Author" , "artist" },
{ "Description" , "comment" },
{ "WM/Composer" , "composer" },
{ "WM/EncodedBy" , "encoded_by" },
{ "WM/EncodingSettings", "encoder" },
{ "WM/Genre" , "genre" },
{ "WM/Language" , "language" },
{ "WM/OriginalFilename", "filename" },
{ "WM/PartOfSet" , "disc" },
{ "WM/Publisher" , "publisher" },
{ "WM/Tool" , "encoder" },
{ "WM/TrackNumber" , "track" },
{ "WM/AlbumArtist", "album_artist" },
{ "WM/AlbumTitle", "album" },
{ "Author", "artist" },
{ "Description", "comment" },
{ "WM/Composer", "composer" },
{ "WM/EncodedBy", "encoded_by" },
{ "WM/EncodingSettings", "encoder" },
{ "WM/Genre", "genre" },
{ "WM/Language", "language" },
{ "WM/OriginalFilename", "filename" },
{ "WM/PartOfSet", "disc" },
{ "WM/Publisher", "publisher" },
{ "WM/Tool", "encoder" },
{ "WM/TrackNumber", "track" },
{ "WM/MediaStationCallSign", "service_provider" },
{ "WM/MediaStationName", "service_name" },
{ "WM/MediaStationName", "service_name" },
// { "Year" , "date" }, TODO: conversion year<->date
{ 0 }
};

62
libavformat/asfcrypt.c
View File

@ -20,10 +20,10 @@
* 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/common.h"
#include "libavutil/des.h"
#include "libavutil/intreadwrite.h"
#include "libavutil/rc4.h"
#include "asfcrypt.h"
@ -32,7 +32,8 @@
* @param v number to invert, must be odd!
* @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
// as table etc. (only lowest 4 bits matter!)
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
* 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;
for (i = 0; i < 12; i++)
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.
* @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;
for (i = 0; i < 5; i++)
keys[i] = inverse(keys[i]);
@ -69,23 +72,25 @@ static void multiswap_invert_keys(uint32_t keys[12]) {
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;
v *= keys[0];
for (i = 1; i < 5; i++) {
v = (v >> 16) | (v << 16);
v = (v >> 16) | (v << 16);
v *= keys[i];
}
v += keys[5];
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;
v -= keys[5];
for (i = 4; i > 0; i--) {
v *= keys[i];
v = (v >> 16) | (v << 16);
v = (v >> 16) | (v << 16);
}
v *= keys[0];
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
* @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 b = data >> 32;
uint32_t c;
uint32_t tmp;
a += key;
tmp = multiswap_step(keys , a);
b += tmp;
c = (key >> 32) + tmp;
a += key;
tmp = multiswap_step(keys, a);
b += tmp;
c = (key >> 32) + tmp;
tmp = multiswap_step(keys + 6, b);
c += tmp;
c += 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
* @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 b;
uint32_t c = data >> 32;
uint32_t c = data >> 32;
uint32_t tmp = data;
c -= tmp;
b = multiswap_inv_step(keys + 6, tmp);
c -= tmp;
b = multiswap_inv_step(keys + 6, tmp);
tmp = c - (key >> 32);
b -= tmp;
a = multiswap_inv_step(keys , tmp);
a -= key;
b -= tmp;
a = multiswap_inv_step(keys, tmp);
a -= key;
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 AVRC4 rc4;
int num_qwords = len >> 3;
uint8_t *qwords = data;
int num_qwords = len >> 3;
uint8_t *qwords = data;
uint64_t rc4buff[8] = { 0 };
uint64_t packetkey;
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);
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];
av_des_init(&des, key + 12, 64, 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
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "libavutil/dict.h"
#include "avformat.h"
#include "avio_internal.h"
#include "internal.h"
#include "riff.h"
#include "asf.h"
#include "avio_internal.h"
#include "libavutil/dict.h"
#undef NDEBUG
#include <assert.h>
@ -33,10 +34,9 @@
#define ASF_INDEX_BLOCK (1<<9)
#define ASF_PACKET_ERROR_CORRECTION_DATA_SIZE 0x2
#define ASF_PACKET_ERROR_CORRECTION_FLAGS (\
ASF_PACKET_FLAG_ERROR_CORRECTION_PRESENT | \
ASF_PACKET_ERROR_CORRECTION_DATA_SIZE\
)
#define ASF_PACKET_ERROR_CORRECTION_FLAGS \
(ASF_PACKET_FLAG_ERROR_CORRECTION_PRESENT | \
ASF_PACKET_ERROR_CORRECTION_DATA_SIZE)
#if (ASF_PACKET_ERROR_CORRECTION_FLAGS != 0)
# define ASF_PACKET_ERROR_CORRECTION_FLAGS_FIELD_SIZE 1
@ -44,12 +44,11 @@
# define ASF_PACKET_ERROR_CORRECTION_FLAGS_FIELD_SIZE 0
#endif
#define ASF_PPI_PROPERTY_FLAGS (\
ASF_PL_FLAG_REPLICATED_DATA_LENGTH_FIELD_IS_BYTE | \
ASF_PL_FLAG_OFFSET_INTO_MEDIA_OBJECT_LENGTH_FIELD_IS_DWORD | \
ASF_PL_FLAG_MEDIA_OBJECT_NUMBER_LENGTH_FIELD_IS_BYTE | \
ASF_PL_FLAG_STREAM_NUMBER_LENGTH_FIELD_IS_BYTE \
)
#define ASF_PPI_PROPERTY_FLAGS \
(ASF_PL_FLAG_REPLICATED_DATA_LENGTH_FIELD_IS_BYTE | \
ASF_PL_FLAG_OFFSET_INTO_MEDIA_OBJECT_LENGTH_FIELD_IS_DWORD | \
ASF_PL_FLAG_MEDIA_OBJECT_NUMBER_LENGTH_FIELD_IS_BYTE | \
ASF_PL_FLAG_STREAM_NUMBER_LENGTH_FIELD_IS_BYTE)
#define ASF_PPI_LENGTH_TYPE_FLAGS 0
@ -68,7 +67,6 @@
# define ASF_PPI_SEQUENCE_FIELD_SIZE 0
#endif
#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
#endif
@ -144,51 +142,45 @@
# define ASF_PAYLOAD_LENGTH_FIELD_SIZE 0
#endif
#define PACKET_HEADER_MIN_SIZE (\
ASF_PACKET_ERROR_CORRECTION_FLAGS_FIELD_SIZE + \
ASF_PACKET_ERROR_CORRECTION_DATA_SIZE + \
1 + /*Length Type Flags*/ \
1 + /*Property Flags*/ \
ASF_PPI_PACKET_LENGTH_FIELD_SIZE + \
ASF_PPI_SEQUENCE_FIELD_SIZE + \
ASF_PPI_PADDING_LENGTH_FIELD_SIZE + \
4 + /*Send Time Field*/ \
2 /*Duration Field*/ \
)
#define PACKET_HEADER_MIN_SIZE \
(ASF_PACKET_ERROR_CORRECTION_FLAGS_FIELD_SIZE + \
ASF_PACKET_ERROR_CORRECTION_DATA_SIZE + \
1 + /* Length Type Flags */ \
1 + /* Property Flags */ \
ASF_PPI_PACKET_LENGTH_FIELD_SIZE + \
ASF_PPI_SEQUENCE_FIELD_SIZE + \
ASF_PPI_PADDING_LENGTH_FIELD_SIZE + \
4 + /* Send Time Field */ \
2) /* Duration Field */
// Replicated Data shall be at least 8 bytes long.
#define ASF_PAYLOAD_REPLICATED_DATA_LENGTH 0x08
#define PAYLOAD_HEADER_SIZE_SINGLE_PAYLOAD (\
1 + /*Stream Number*/ \
ASF_PAYLOAD_MEDIA_OBJECT_NUMBER_FIELD_SIZE + \
ASF_PAYLOAD_OFFSET_INTO_MEDIA_OBJECT_FIELD_SIZE + \
ASF_PAYLOAD_REPLICATED_DATA_LENGTH_FIELD_SIZE + \
ASF_PAYLOAD_REPLICATED_DATA_LENGTH \
)
#define PAYLOAD_HEADER_SIZE_SINGLE_PAYLOAD \
(1 + /* Stream Number */ \
ASF_PAYLOAD_MEDIA_OBJECT_NUMBER_FIELD_SIZE + \
ASF_PAYLOAD_OFFSET_INTO_MEDIA_OBJECT_FIELD_SIZE + \
ASF_PAYLOAD_REPLICATED_DATA_LENGTH_FIELD_SIZE + \
ASF_PAYLOAD_REPLICATED_DATA_LENGTH)
#define PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS (\
1 + /*Stream Number*/ \
ASF_PAYLOAD_MEDIA_OBJECT_NUMBER_FIELD_SIZE + \
ASF_PAYLOAD_OFFSET_INTO_MEDIA_OBJECT_FIELD_SIZE + \
ASF_PAYLOAD_REPLICATED_DATA_LENGTH_FIELD_SIZE + \
ASF_PAYLOAD_REPLICATED_DATA_LENGTH + \
ASF_PAYLOAD_LENGTH_FIELD_SIZE \
)
#define PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS \
(1 + /* Stream Number */ \
ASF_PAYLOAD_MEDIA_OBJECT_NUMBER_FIELD_SIZE + \
ASF_PAYLOAD_OFFSET_INTO_MEDIA_OBJECT_FIELD_SIZE + \
ASF_PAYLOAD_REPLICATED_DATA_LENGTH_FIELD_SIZE + \
ASF_PAYLOAD_REPLICATED_DATA_LENGTH + \
ASF_PAYLOAD_LENGTH_FIELD_SIZE)
#define SINGLE_PAYLOAD_DATA_LENGTH (\
PACKET_SIZE - \
PACKET_HEADER_MIN_SIZE - \
PAYLOAD_HEADER_SIZE_SINGLE_PAYLOAD \
)
#define SINGLE_PAYLOAD_DATA_LENGTH \
(PACKET_SIZE - \
PACKET_HEADER_MIN_SIZE - \
PAYLOAD_HEADER_SIZE_SINGLE_PAYLOAD)
#define MULTI_PAYLOAD_CONSTANT (\
PACKET_SIZE - \
PACKET_HEADER_MIN_SIZE - \
1 - /*Payload Flags*/ \
2*PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS \
)
#define MULTI_PAYLOAD_CONSTANT \
(PACKET_SIZE - \
PACKET_HEADER_MIN_SIZE - \
1 - /* Payload Flags */ \
2 * PAYLOAD_HEADER_SIZE_MULTIPLE_PAYLOADS)
typedef struct {
uint32_t seqno;
@ -208,7 +200,7 @@ typedef struct {
/* only for reading */
uint64_t data_offset; ///< beginning of the first data packet
ASFIndex* index_ptr;
ASFIndex *index_ptr;
uint32_t nb_index_memory_alloc;
uint16_t maximum_packet;
uint32_t next_packet_number;
@ -218,10 +210,10 @@ typedef struct {
} ASFContext;
static const AVCodecTag codec_asf_bmp_tags[] = {
{ AV_CODEC_ID_MPEG4, MKTAG('M', '4', 'S', '2') },
{ AV_CODEC_ID_MPEG4, MKTAG('M', 'P', '4', 'S') },
{ AV_CODEC_ID_MPEG4, MKTAG('M', '4', 'S', '2') },
{ AV_CODEC_ID_MPEG4, MKTAG('M', 'P', '4', 'S') },
{ AV_CODEC_ID_MSMPEG4V3, MKTAG('M', 'P', '4', '3') },
{ AV_CODEC_ID_NONE, 0 },
{ AV_CODEC_ID_NONE, 0 },
};
#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) */
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;
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;
avio_wl16(pb, type);
avio_wl16(pb, length); //size
avio_wl32(pb, asf->seqno);//sequence number
avio_wl16(pb, flags); /* unknown bytes */
avio_wl16(pb, length); //size_confirm
avio_wl16(pb, length); // size
avio_wl32(pb, asf->seqno); // sequence number
avio_wl16(pb, flags); // unknown bytes
avio_wl16(pb, length); // size_confirm
asf->seqno++;
}
@ -289,13 +282,14 @@ static int64_t unix_to_file_time(int ti)
{
int64_t t;
t = ti * INT64_C(10000000);
t = ti * INT64_C(10000000);
t += INT64_C(116444736000000000);
return t;
}
/* 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;
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);
tags[0] = av_dict_get(s->metadata, "title" , NULL, 0);
tags[1] = av_dict_get(s->metadata, "author" , NULL, 0);
tags[0] = av_dict_get(s->metadata, "title", NULL, 0);
tags[1] = av_dict_get(s->metadata, "author", NULL, 0);
tags[2] = av_dict_get(s->metadata, "copyright", NULL, 0);
tags[3] = av_dict_get(s->metadata, "comment" , NULL, 0);
tags[4] = av_dict_get(s->metadata, "rating" , NULL, 0);
tags[3] = av_dict_get(s->metadata, "comment", NULL, 0);
tags[4] = av_dict_get(s->metadata, "rating", NULL, 0);
duration = asf->duration + PREROLL_TIME * 10000;
has_title = tags[0] || tags[1] || tags[2] || tags[3] || tags[4];
duration = asf->duration + PREROLL_TIME * 10000;
has_title = tags[0] || tags[1] || tags[2] || tags[3] || tags[4];
metadata_count = av_dict_count(s->metadata);
bit_rate = 0;
for(n=0;n<s->nb_streams;n++) {
for (n = 0; n < s->nb_streams; n++) {
enc = s->streams[n]->codec;
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 */
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);
avio_wl64(pb, file_size);
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, asf->duration); /* duration (in 100ns units) */
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, 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 */
for(n=0;n<s->nb_streams;n++) {
for (n = 0; n < s->nb_streams; n++) {
int64_t es_pos;
// ASFStream *stream = &asf->streams[n];
enc = s->streams[n]->codec;
enc = s->streams[n]->codec;
asf->streams[n].num = n + 1;
asf->streams[n].seq = 1;
switch(enc->codec_type) {
switch (enc->codec_type) {
case AVMEDIA_TYPE_AUDIO:
wav_extra_size = 0;
extra_size = 18 + wav_extra_size;
extra_size2 = 8;
extra_size = 18 + wav_extra_size;
extra_size2 = 8;
break;
default:
case AVMEDIA_TYPE_VIDEO:
wav_extra_size = enc->extradata_size;
extra_size = 0x33 + wav_extra_size;
extra_size2 = 0;
extra_size = 0x33 + wav_extra_size;
extra_size2 = 0;
break;
}
@ -448,10 +441,10 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
}
/* ERROR Correction */
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);
}else{
} else {
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);
ff_put_guid(pb, &ff_asf_codec_comment1_header);
avio_wl32(pb, s->nb_streams);
for(n=0;n<s->nb_streams;n++) {
for (n = 0; n < s->nb_streams; n++) {
AVCodec *p;
const char *desc;
int len;
@ -482,21 +475,21 @@ static int asf_write_header1(AVFormatContext *s, int64_t file_size, int64_t data
AVIOContext *dyn_buf;
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);
else if(enc->codec_type == AVMEDIA_TYPE_VIDEO)
else if (enc->codec_type == AVMEDIA_TYPE_VIDEO)
avio_wl16(pb, 1);
else
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";
else
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);
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 */
/* id */
if (enc->codec_type == AVMEDIA_TYPE_AUDIO) {
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_wl32(pb, enc->codec_tag);
}
if(!enc->codec_tag)
if (!enc->codec_tag)
return -1;
}
end_header(pb, hpos);
/* patch the header size fields */
cur_pos = avio_tell(pb);
cur_pos = avio_tell(pb);
header_size = cur_pos - header_offset;
if (asf->is_streamed) {
header_size += 8 + 30 + 50;
@ -559,9 +551,9 @@ static int asf_write_header(AVFormatContext *s)
s->packet_size = PACKET_SIZE;
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->maximum_packet = 0;
asf->maximum_packet = 0;
/* 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
@ -573,11 +565,11 @@ static int asf_write_header(AVFormatContext *s)
avio_flush(s->pb);
asf->packet_nb_payloads = 0;
asf->packet_nb_payloads = 0;
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,
NULL, NULL, NULL, NULL);
NULL, NULL, NULL, NULL);
if (s->avoid_negative_ts < 0)
s->avoid_negative_ts = 1;
@ -594,30 +586,25 @@ static int asf_write_stream_header(AVFormatContext *s)
return asf_write_header(s);
}
static int put_payload_parsing_info(
AVFormatContext *s,
unsigned int sendtime,
unsigned int duration,
int nb_payloads,
int padsize
)
static int put_payload_parsing_info(AVFormatContext *s,
unsigned sendtime, unsigned duration,
int nb_payloads, int padsize)
{
ASFContext *asf = s->priv_data;
AVIOContext *pb = s->pb;
int ppi_size, i;
int64_t start= avio_tell(pb);
int64_t start = avio_tell(pb);
int iLengthTypeFlags = ASF_PPI_LENGTH_TYPE_FLAGS;
padsize -= PACKET_HEADER_MIN_SIZE;
if(asf->multi_payloads_present)
if (asf->multi_payloads_present)
padsize--;
assert(padsize>=0);
assert(padsize >= 0);
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);
}
if (asf->multi_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);
if (asf->is_streamed) {
if (asf->is_streamed)
put_chunk(s, 0x4424, s->packet_size, 0);
}
packet_hdr_size = put_payload_parsing_info(
s,
asf->packet_timestamp_start,
asf->packet_timestamp_end - asf->packet_timestamp_start,
asf->packet_nb_payloads,
asf->packet_size_left
);
packet_hdr_size = put_payload_parsing_info(s,
asf->packet_timestamp_start,
asf->packet_timestamp_end - asf->packet_timestamp_start,
asf->packet_nb_payloads,
asf->packet_size_left);
packet_filled_size = PACKET_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);
asf->nb_packets++;
asf->packet_nb_payloads = 0;
asf->packet_nb_payloads = 0;
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,
NULL, NULL, NULL, NULL);
NULL, NULL, NULL, NULL);
}
static void put_payload_header(
AVFormatContext *s,
ASFStream *stream,
int64_t presentation_time,
int m_obj_size,
int m_obj_offset,
int payload_len,
int flags
)
static void put_payload_header(AVFormatContext *s, ASFStream *stream,
int64_t presentation_time, int m_obj_size,
int m_obj_offset, int payload_len, int flags)
{
ASFContext *asf = s->priv_data;
AVIOContext *pb = &asf->pb;
@ -700,8 +678,8 @@ static void put_payload_header(
val |= ASF_PL_FLAG_KEY_FRAME;
avio_w8(pb, val);
avio_w8(pb, stream->seq); //Media object number
avio_wl32(pb, m_obj_offset); //Offset Into Media Object
avio_w8(pb, stream->seq); // Media object number
avio_wl32(pb, m_obj_offset); // Offset Into Media Object
// Replicated Data shall be at least 8 bytes long.
// 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.
avio_w8(pb, ASF_PAYLOAD_REPLICATED_DATA_LENGTH);
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, m_obj_size); // Replicated Data - Media Object Size
avio_wl32(pb, (uint32_t) presentation_time); // Replicated Data - Presentation Time
if (asf->multi_payloads_present){
avio_wl16(pb, payload_len); //payload length
if (asf->multi_payloads_present) {
avio_wl16(pb, payload_len); // payload length
}
}
static void put_frame(
AVFormatContext *s,
ASFStream *stream,
AVStream *avst,
int64_t timestamp,
const uint8_t *buf,
int m_obj_size,
int flags
)
static void put_frame(AVFormatContext *s, ASFStream *stream, AVStream *avst,
int64_t timestamp, const uint8_t *buf,
int m_obj_size, int flags)
{
ASFContext *asf = s->priv_data;
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->packet_size_left = PACKET_SIZE;
if (asf->multi_payloads_present){
if (asf->multi_payloads_present) {
frag_len1 = MULTI_PAYLOAD_CONSTANT - 1;
}
else {
} else {
frag_len1 = SINGLE_PAYLOAD_DATA_LENGTH;
}
asf->packet_timestamp_start = timestamp;
}
else {
} else {
// 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);
continue;
}
@ -759,9 +732,10 @@ static void put_frame(
if (payload_len > frag_len1)
payload_len = frag_len1;
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);
if (asf->multi_payloads_present)
@ -775,7 +749,7 @@ static void put_frame(
payload_len = 0;
}
m_obj_offset += payload_len;
buf += payload_len;
buf += payload_len;
if (!asf->multi_payloads_present)
flush_packet(s);
@ -821,21 +795,22 @@ static int asf_write_packet(AVFormatContext *s, AVPacket *pkt)
uint32_t packet_number;
int64_t pts;
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];
if(codec->codec_type == AVMEDIA_TYPE_AUDIO)
if (codec->codec_type == AVMEDIA_TYPE_AUDIO)
flags &= ~AV_PKT_FLAG_KEY;
pts = (pkt->pts != AV_NOPTS_VALUE) ? pkt->pts : pkt->dts;
assert(pts != AV_NOPTS_VALUE);
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;
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)
/ ASF_INDEXED_INTERVAL);
@ -850,19 +825,19 @@ static int asf_write_packet(AVFormatContext *s, AVPacket *pkt)
return 0;
}
//
static int asf_write_index(AVFormatContext *s, ASFIndex *index, uint16_t max, uint32_t count)
static int asf_write_index(AVFormatContext *s, ASFIndex *index,
uint16_t max, uint32_t count)
{
AVIOContext *pb = s->pb;
int i;
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);
avio_wl64(pb, ASF_INDEXED_INTERVAL);
avio_wl32(pb, max);
avio_wl32(pb, count);
for(i=0; i<count; i++) {
for (i = 0; i < count; i++) {
avio_wl32(pb, index[i].packet_number);
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)
{
ASFContext *asf = s->priv_data;
int64_t file_size,data_size;
int64_t file_size, data_size;
/* flush the current packet */
if (asf->pb.buf_ptr > asf->pb.buffer)
@ -913,11 +888,11 @@ AVOutputFormat ff_asf_muxer = {
.write_packet = asf_write_packet,
.write_trailer = asf_write_trailer,
.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
},
};
#endif
#endif /* CONFIG_ASF_MUXER */
#if CONFIG_ASF_STREAM_MUXER
AVOutputFormat ff_asf_stream_muxer = {
@ -932,8 +907,8 @@ AVOutputFormat ff_asf_stream_muxer = {
.write_packet = asf_write_packet,
.write_trailer = asf_write_trailer,
.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
},
};
#endif //CONFIG_ASF_STREAM_MUXER
#endif /* CONFIG_ASF_STREAM_MUXER */