falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
Browse Source

Merge remote-tracking branch 'qatar/master' 

* qatar/master:
  xan: Convert to bytestream2
  oggenc: add a page_duration option and deprecate the pagesize option
  x86: lavr: add SSE2/AVX dither_int_to_float()

Conflicts:
	libavcodec/xan.c
	libavformat/oggenc.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
tags/n1.2
Michael Niedermayer 12 years ago
parent
75afbe2ab4 d744801f1a
commit
4765f63538
5 changed files with 174 additions and 34 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +15
    -0
      doc/muxers.texi
  2. +31
    -27
      libavcodec/xan.c
  3. +42
    -7
      libavformat/oggenc.c
  4. +64
    -0
      libavresample/x86/dither.asm
  5. +22
    -0
      libavresample/x86/dither_init.c

+ 15
- 0
doc/muxers.texi View File

@@ -717,4 +717,19 @@ ffmpeg -i input.mp3 -i cover.png -c copy -metadata:s:v title="Album cover"
-metadata:s:v comment="Cover (Front)" out.mp3
@end example

@section ogg

Ogg container muxer.

@table @option
@item -page_duration @var{duration}
Preferred page duration, in microseconds. The muxer will attempt to create
pages that are approximately @var{duration} microseconds long. This allows the
user to compromise between seek granularity and container overhead. The default
is 1 second. A value of 0 will fill all segments, making pages as large as
possible. A value of 1 will effectively use 1 packet-per-page in most
situations, giving a small seek granularity at the cost of additional container
overhead.
@end table

@c man end MUXERS

+ 31
- 27
libavcodec/xan.c View File

@@ -142,44 +142,47 @@ static void xan_unpack(unsigned char *dest, int dest_len,
int size;
unsigned char *dest_org = dest;
unsigned char *dest_end = dest + dest_len;
const unsigned char *src_end = src + src_len;
GetByteContext ctx;

while (dest < dest_end && src < src_end) {
opcode = *src++;
bytestream2_init(&ctx, src, src_len);
while (dest < dest_end && bytestream2_get_bytes_left(&ctx)) {
opcode = bytestream2_get_byte(&ctx);

if (opcode < 0xe0) {
int size2, back;
if ((opcode & 0x80) == 0) {
size = opcode & 3;

back = ((opcode & 0x60) << 3) + *src++ + 1;
back = ((opcode & 0x60) << 3) + bytestream2_get_byte(&ctx) + 1;
size2 = ((opcode & 0x1c) >> 2) + 3;
} else if ((opcode & 0x40) == 0) {
size = *src >> 6;
size = bytestream2_peek_byte(&ctx) >> 6;

back = (bytestream_get_be16(&src) & 0x3fff) + 1;
back = (bytestream2_get_be16(&ctx) & 0x3fff) + 1;
size2 = (opcode & 0x3f) + 4;
} else {
size = opcode & 3;

back = ((opcode & 0x10) << 12) + bytestream_get_be16(&src) + 1;
size2 = ((opcode & 0x0c) << 6) + *src++ + 5;
back = ((opcode & 0x10) << 12) + bytestream2_get_be16(&ctx) + 1;
size2 = ((opcode & 0x0c) << 6) + bytestream2_get_byte(&ctx) + 5;
}

if (dest_end - dest < size + size2 ||
dest + size - dest_org < back ||
src_end - src < size)
bytestream2_get_bytes_left(&ctx) < size)
return;
memcpy(dest, src, size); dest += size; src += size;
bytestream2_get_buffer(&ctx, dest, size);
dest += size;
av_memcpy_backptr(dest, back, size2);
dest += size2;
} else {
int finish = opcode >= 0xfc;
size = finish ? opcode & 3 : ((opcode & 0x1f) << 2) + 4;

if (dest_end - dest < size || src_end - src < size)
if (dest_end - dest < size || bytestream2_get_bytes_left(&ctx) < size)
return;
memcpy(dest, src, size); dest += size; src += size;
bytestream2_get_buffer(&ctx, dest, size);
dest += size;
if (finish)
return;
}
@@ -518,21 +521,22 @@ static int xan_decode_frame(AVCodecContext *avctx,
const uint8_t *buf = avpkt->data;
int ret, buf_size = avpkt->size;
XanContext *s = avctx->priv_data;
const uint8_t *buf_end = buf + buf_size;
GetByteContext ctx;
int tag = 0;

while (buf_end - buf > 8 && tag != VGA__TAG) {
bytestream2_init(&ctx, buf, buf_size);
while (bytestream2_get_bytes_left(&ctx) > 8 && tag != VGA__TAG) {
unsigned *tmpptr;
uint32_t new_pal;
int size;
int i;
tag = bytestream_get_le32(&buf);
size = bytestream_get_be32(&buf);
tag = bytestream2_get_le32(&ctx);
size = bytestream2_get_be32(&ctx);
if(size < 0) {
av_log(avctx, AV_LOG_ERROR, "Invalid tag size %d\n", size);
return AVERROR_INVALIDDATA;
}
size = FFMIN(size, buf_end - buf);
size = FFMIN(size, bytestream2_get_bytes_left(&ctx));
switch (tag) {
case PALT_TAG:
if (size < PALETTE_SIZE)
@@ -547,13 +551,13 @@ static int xan_decode_frame(AVCodecContext *avctx,
tmpptr += s->palettes_count * AVPALETTE_COUNT;
for (i = 0; i < PALETTE_COUNT; i++) {
#if RUNTIME_GAMMA
int r = gamma_corr(*buf++);
int g = gamma_corr(*buf++);
int b = gamma_corr(*buf++);
int r = gamma_corr(bytestream2_get_byteu(&ctx));
int g = gamma_corr(bytestream2_get_byteu(&ctx));
int b = gamma_corr(bytestream2_get_byteu(&ctx));
#else
int r = gamma_lookup[*buf++];
int g = gamma_lookup[*buf++];
int b = gamma_lookup[*buf++];
int r = gamma_lookup[bytestream2_get_byteu(&ctx)];
int g = gamma_lookup[bytestream2_get_byteu(&ctx)];
int b = gamma_lookup[bytestream2_get_byteu(&ctx)];
#endif
*tmpptr++ = (0xFFU << 24) | (r << 16) | (g << 8) | b;
}
@@ -562,7 +566,7 @@ static int xan_decode_frame(AVCodecContext *avctx,
case SHOT_TAG:
if (size < 4)
return AVERROR_INVALIDDATA;
new_pal = bytestream_get_le32(&buf);
new_pal = bytestream2_get_le32(&ctx);
if (new_pal < s->palettes_count) {
s->cur_palette = new_pal;
} else
@@ -571,11 +575,11 @@ static int xan_decode_frame(AVCodecContext *avctx,
case VGA__TAG:
break;
default:
buf += size;
bytestream2_skip(&ctx, size);
break;
}
}
buf_size = buf_end - buf;
buf_size = bytestream2_get_bytes_left(&ctx);

if (s->palettes_count <= 0) {
av_log(s->avctx, AV_LOG_ERROR, "No palette found\n");
@@ -594,7 +598,7 @@ static int xan_decode_frame(AVCodecContext *avctx,
memcpy(s->current_frame.data[1],
s->palettes + s->cur_palette * AVPALETTE_COUNT, AVPALETTE_SIZE);

s->buf = buf;
s->buf = ctx.buffer;
s->size = buf_size;

if (xan_wc3_decode_frame(s) < 0)


+ 42
- 7
libavformat/oggenc.c View File

@@ -35,6 +35,7 @@
#define MAX_PAGE_SIZE 65025

typedef struct {
int64_t start_granule;
int64_t granule;
int stream_index;
uint8_t flags;
@@ -68,6 +69,7 @@ typedef struct {
const AVClass *class;
OGGPageList *page_list;
int pref_size; ///< preferred page size (0 => fill all segments)
int64_t pref_duration; ///< preferred page duration (0 => fill all segments)
} OGGContext;

#define OFFSET(x) offsetof(OGGContext, x)
@@ -76,8 +78,10 @@ typedef struct {
static const AVOption options[] = {
{ "oggpagesize", "Set preferred Ogg page size.",
offsetof(OGGContext, pref_size), AV_OPT_TYPE_INT, {.i64 = 0}, 0, MAX_PAGE_SIZE, AV_OPT_FLAG_ENCODING_PARAM},
{ "pagesize", "preferred page size in bytes",
{ "pagesize", "preferred page size in bytes (deprecated)",
OFFSET(pref_size), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, MAX_PAGE_SIZE, PARAM },
{ "page_duration", "preferred page duration, in microseconds",
OFFSET(pref_duration), AV_OPT_TYPE_INT, { .i64 = 1000000 }, 0, INT64_MAX, PARAM },
{ NULL },
};

@@ -185,6 +189,7 @@ static int ogg_buffer_page(AVFormatContext *s, OGGStreamContext *oggstream)
return AVERROR(ENOMEM);
l->page = oggstream->page;

oggstream->page.start_granule = oggstream->page.granule;
oggstream->page_count++;
ogg_reset_cur_page(oggstream);

@@ -223,6 +228,12 @@ static int ogg_buffer_data(AVFormatContext *s, AVStream *st,
flush = 1;
}

// avoid a continued page
if (!header && oggstream->page.size > 0 &&
MAX_PAGE_SIZE - oggstream->page.size < size) {
ogg_buffer_page(s, oggstream);
}

for (i = 0; i < total_segments; ) {
OGGPage *page = &oggstream->page;

@@ -245,9 +256,19 @@ static int ogg_buffer_data(AVFormatContext *s, AVStream *st,
if (i == total_segments)
page->granule = granule;

if (!header && (page->segments_count == 255 ||
(ogg->pref_size > 0 && page->size >= ogg->pref_size))) {
ogg_buffer_page(s, oggstream);
if (!header) {
AVStream *st = s->streams[page->stream_index];

int64_t start = av_rescale_q(page->start_granule, st->time_base,
AV_TIME_BASE_Q);
int64_t next = av_rescale_q(page->granule, st->time_base,
AV_TIME_BASE_Q);

if (page->segments_count == 255 ||
(ogg->pref_size > 0 && page->size >= ogg->pref_size) ||
(ogg->pref_duration > 0 && next - start >= ogg->pref_duration)) {
ogg_buffer_page(s, oggstream);
}
}
}

@@ -380,9 +401,13 @@ static int ogg_build_opus_headers(AVCodecContext *avctx,

static int ogg_write_header(AVFormatContext *s)
{
OGGContext *ogg = s->priv_data;
OGGStreamContext *oggstream;
int i, j;

if (ogg->pref_size)
av_log(s, AV_LOG_WARNING, "The pagesize option is deprecated\n");

for (i = 0; i < s->nb_streams; i++) {
AVStream *st = s->streams[i];
unsigned serial_num = i;
@@ -502,6 +527,9 @@ static int ogg_write_header(AVFormatContext *s)
}
ogg_buffer_page(s, oggstream);
}

oggstream->page.start_granule = AV_NOPTS_VALUE;

return 0;
}

@@ -551,6 +579,9 @@ static int ogg_write_packet(AVFormatContext *s, AVPacket *pkt)
else
granule = pkt->pts + pkt->duration;

if (oggstream->page.start_granule == AV_NOPTS_VALUE)
oggstream->page.start_granule = pkt->pts;

ret = ogg_buffer_data(s, st, pkt->data, pkt->size, granule, 0);
if (ret < 0)
return ret;
@@ -566,9 +597,13 @@ static int ogg_write_trailer(AVFormatContext *s)
{
int i;

/* flush current page */
for (i = 0; i < s->nb_streams; i++)
ogg_buffer_page(s, s->streams[i]->priv_data);
/* flush current page if needed */
for (i = 0; i < s->nb_streams; i++) {
OGGStreamContext *oggstream = s->streams[i]->priv_data;

if (oggstream->page.size > 0)
ogg_buffer_page(s, oggstream);
}

ogg_write_pages(s, 1);



+ 64
- 0
libavresample/x86/dither.asm View File

@@ -23,6 +23,9 @@

SECTION_RODATA 32

; 1.0f / (2.0f * INT32_MAX)
pf_dither_scale: times 8 dd 2.32830643762e-10

pf_s16_scale: times 4 dd 32753.0

SECTION_TEXT
@@ -51,3 +54,64 @@ cglobal quantize, 4,4,3, dst, src, dither, len
add lenq, mmsize
jl .loop
REP_RET

;------------------------------------------------------------------------------
; void ff_dither_int_to_float_rectangular(float *dst, int *src, int len)
;------------------------------------------------------------------------------

%macro DITHER_INT_TO_FLOAT_RECTANGULAR 0
cglobal dither_int_to_float_rectangular, 3,3,3, dst, src, len
lea lenq, [4*lend]
add srcq, lenq
add dstq, lenq
neg lenq
mova m0, [pf_dither_scale]
.loop:
cvtdq2ps m1, [srcq+lenq]
cvtdq2ps m2, [srcq+lenq+mmsize]
mulps m1, m1, m0
mulps m2, m2, m0
mova [dstq+lenq], m1
mova [dstq+lenq+mmsize], m2
add lenq, 2*mmsize
jl .loop
REP_RET
%endmacro

INIT_XMM sse2
DITHER_INT_TO_FLOAT_RECTANGULAR
INIT_YMM avx
DITHER_INT_TO_FLOAT_RECTANGULAR

;------------------------------------------------------------------------------
; void ff_dither_int_to_float_triangular(float *dst, int *src0, int len)
;------------------------------------------------------------------------------

%macro DITHER_INT_TO_FLOAT_TRIANGULAR 0
cglobal dither_int_to_float_triangular, 3,4,5, dst, src0, len, src1
lea lenq, [4*lend]
lea src1q, [src0q+2*lenq]
add src0q, lenq
add dstq, lenq
neg lenq
mova m0, [pf_dither_scale]
.loop:
cvtdq2ps m1, [src0q+lenq]
cvtdq2ps m2, [src0q+lenq+mmsize]
cvtdq2ps m3, [src1q+lenq]
cvtdq2ps m4, [src1q+lenq+mmsize]
addps m1, m1, m3
addps m2, m2, m4
mulps m1, m1, m0
mulps m2, m2, m0
mova [dstq+lenq], m1
mova [dstq+lenq+mmsize], m2
add lenq, 2*mmsize
jl .loop
REP_RET
%endmacro

INIT_XMM sse2
DITHER_INT_TO_FLOAT_TRIANGULAR
INIT_YMM avx
DITHER_INT_TO_FLOAT_TRIANGULAR

+ 22
- 0
libavresample/x86/dither_init.c View File

@@ -26,6 +26,12 @@
extern void ff_quantize_sse2(int16_t *dst, const float *src, float *dither,
int len);

extern void ff_dither_int_to_float_rectangular_sse2(float *dst, int *src, int len);
extern void ff_dither_int_to_float_rectangular_avx(float *dst, int *src, int len);

extern void ff_dither_int_to_float_triangular_sse2(float *dst, int *src0, int len);
extern void ff_dither_int_to_float_triangular_avx(float *dst, int *src0, int len);

av_cold void ff_dither_init_x86(DitherDSPContext *ddsp,
enum AVResampleDitherMethod method)
{
@@ -36,4 +42,20 @@ av_cold void ff_dither_init_x86(DitherDSPContext *ddsp,
ddsp->ptr_align = 16;
ddsp->samples_align = 8;
}

if (method == AV_RESAMPLE_DITHER_RECTANGULAR) {
if (EXTERNAL_SSE2(mm_flags)) {
ddsp->dither_int_to_float = ff_dither_int_to_float_rectangular_sse2;
}
if (EXTERNAL_AVX(mm_flags)) {
ddsp->dither_int_to_float = ff_dither_int_to_float_rectangular_avx;
}
} else {
if (EXTERNAL_SSE2(mm_flags)) {
ddsp->dither_int_to_float = ff_dither_int_to_float_triangular_sse2;
}
if (EXTERNAL_AVX(mm_flags)) {
ddsp->dither_int_to_float = ff_dither_int_to_float_triangular_avx;
}
}
}

Write Preview
Loading…
Cancel
Save