Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge remote-tracking branch 'qatar/master'

Browse Source 
* qatar/master: (26 commits)
  avconv: deprecate the -deinterlace option
  doc: Fix the name of the new function
  aacenc: make sure to encode enough frames to cover all input samples.
  aacenc: only use the number of input samples provided by the user.
  wmadec: Verify bitstream size makes sense before calling init_get_bits.
  kmvc: Log into a context at a log level constant.
  mpeg12: Pad framerate tab to 16 entries.
  kgv1dec: Increase offsets array size so it is large enough.
  kmvc: Check palsize.
  nsvdec: Propagate errors
  nsvdec: Be more careful with av_malloc().
  nsvdec: Fix use of uninitialized streams.
  movenc: cosmetics: Get rid of camelCase identifiers
  swscale: more generic check for planar destination formats with alpha
  doc: Document mov/mp4 fragmentation options
  build: Use order-only prerequisites for creating FATE reference file dirs.
  x86 dsputil: provide SSE2/SSSE3 versions of bswap_buf
  rtsp: Remove some unused variables from ff_rtsp_connect().
  avutil: make intfloat api public
  avformat_write_header(): detail error message
  ...

Conflicts:
	doc/APIchanges
	doc/ffmpeg.texi
	doc/muxers.texi
	ffmpeg.c
	libavcodec/kmvc.c
	libavcodec/x86/Makefile
	libavcodec/x86/dsputil_yasm.asm
	libavcodec/x86/pngdsp-init.c
	libavformat/movenc.c
	libavformat/movenc.h
	libavformat/mpegtsenc.c
	libavformat/nsvdec.c
	libavformat/utils.c
	libavutil/avutil.h
	libswscale/swscale.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
pull/3/merge
Michael Niedermayer 13 years ago
parent b8c1655882 d7edd359ec
commit 151ecc2aec
25 changed files with 608 additions and 303 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 6
      doc/APIchanges
  2. 2
      doc/ffmpeg.texi
  3. 62
      doc/muxers.texi
  4. 13
      ffmpeg.c
  5. 20
      libavcodec/aacenc.c
  6. 12
      libavcodec/kmvc.c
  7. 2
      libavcodec/mpc7.c
  8. 2
      libavcodec/mpeg12data.c
  9. 2
      libavcodec/wmadec.c
  10. 1
      libavcodec/x86/Makefile
  11. 5
      libavcodec/x86/dsputil_mmx.c
  12. 124
      libavcodec/x86/dsputil_yasm.asm
  13. 123
      libavcodec/x86/pngdsp-init.c
  14. 174
      libavcodec/x86/pngdsp.asm
  15. 291
      libavformat/movenc.c
  16. 16
      libavformat/movenc.h
  17. 2
      libavformat/mpegtsenc.c
  18. 13
      libavformat/nsvdec.c
  19. 1
      libavformat/rtsp.c
  20. 6
      libavformat/utils.c
  21. 3
      libavformat/yuv4mpeg.c
  22. 1
      libavutil/Makefile
  23. 4
      libavutil/avutil.h
  24. 2
      libswscale/swscale.c
  25. 14
      tests/Makefile

6
doc/APIchanges
Unescape View File

@ -16,6 +16,10 @@ API changes, most recent first:
2012-01-24 - xxxxxxx - lavfi 2.60.100
Add avfilter_graph_dump.
2012-01-30 - xxxxxxx - lavu 51.22.0 - intfloat.h
Add a new installed header libavutil/intfloat.h with int/float punning
functions.
2012-01-25 - lavf 53.22.0
f1caf01 Allow doing av_write_frame(ctx, NULL) for flushing possible
buffered data within a muxer. Added AVFMT_ALLOW_FLUSH for
@ -109,7 +113,7 @@ API changes, most recent first:
Add av_toupper()/av_tolower()
2011-11-05 - b6d08f4 - lavf 53.13.0
Add avformat_network_init()/avformat_network_uninit()
Add avformat_network_init()/avformat_network_deinit()
2011-10-27 - 512557b - lavc 53.15.0
Remove avcodec_parse_frame.

2
doc/ffmpeg.texi
Unescape View File

@ -620,6 +620,8 @@ Enable Unlimited Motion Vector (h263+)
@item -deinterlace
Deinterlace pictures.
This option is deprecated since the deinterlacing is very low quality.
Use the yadif filter with @code{-filter:v yadif}.
@item -ilme
Force interlacing support in encoder (MPEG-2 and MPEG-4 only).
Use this option if your input file is interlaced and you want

62
doc/muxers.texi
Unescape View File

@ -148,18 +148,70 @@ each of the YUV420P components. To read or write this image file format,
specify the name of the '.Y' file. The muxer will automatically open the
'.U' and '.V' files as required.
@section mov
MOV / MP4 muxer
The muxer options are:
@section MOV/MP4/ISMV
The mov/mp4/ismv muxer supports fragmentation. Normally, a MOV/MP4
file has all the metadata about all packets stored in one location
(written at the end of the file, it can be moved to the start for
better playback using the @command{qt-faststart} tool). A fragmented
file consists of a number of fragments, where packets and metadata
about these packets are stored together. Writing a fragmented
file has the advantage that the file is decodable even if the
writing is interrupted (while a normal MOV/MP4 is undecodable if
it is not properly finished), and it requires less memory when writing
very long files (since writing normal MOV/MP4 files stores info about
every single packet in memory until the file is closed). The downside
is that it is less compatible with other applications.
Fragmentation is enabled by setting one of the AVOptions that define
how to cut the file into fragments:
@table @option
@item -moov_size @var{bytes}
Reserves space for the moov atom at the beginning of the file instead of placing the
moov atom at the end. If the space reserved is insufficient, muxing will fail.
@item -movflags frag_keyframe
Start a new fragment at each video keyframe.
@item -frag_duration @var{duration}
Create fragments that are @var{duration} microseconds long.
@item -frag_size @var{size}
Create fragments that contain up to @var{size} bytes of payload data.
@item -movflags frag_custom
Allow the caller to manually choose when to cut fragments, by
calling @code{av_write_frame(ctx, NULL)} to write a fragment with
the packets written so far. (This is only useful with other
applications integrating libavformat, not from @command{avconv}.)
@end table
Additionally, the way the output file is written can be adjusted
through a few other options:
@table @option
@item -movflags empty_moov
Write an initial moov atom directly at the start of the file, without
describing any samples in it. Generally, an mdat/moov pair is written
at the start of the file, as a normal MOV/MP4 file, containing only
a short portion of the file. With this option set, there is no initial
mdat atom, and the moov atom only describes the tracks but has
a zero duration.
Files written with this option set do not work in QuickTime.
This option is implicitly set when writing ismv (Smooth Streaming) files.
@item -movflags separate_moof
Write a separate moof (movie fragment) atom for each track. Normally,
packets for all tracks are written in a moof atom (which is slightly
more efficient), but with this option set, the muxer writes one moof/mdat
pair for each track, making it easier to separate tracks.
This option is implicitly set when writing ismv (Smooth Streaming) files.
@end table
Smooth Streaming content can be pushed in real time to a publishing
point on IIS with this muxer. Example:
@example
avconv -re @var{<normal input/transcoding options>} -movflags isml+frag_keyframe -f ismv http://server/publishingpoint.isml/Streams(Encoder1)
@end example
@section mpegts
MPEG transport stream muxer.

13
ffmpeg.c
Unescape View File

@ -471,7 +471,7 @@ static void reset_options(OptionsContext *o, int is_input)
static int alloc_buffer(AVCodecContext *s, InputStream *ist, FrameBuffer **pbuf)
{
FrameBuffer *buf = av_mallocz(sizeof(*buf));
int ret, i;
int i, ret;
const int pixel_size = av_pix_fmt_descriptors[s->pix_fmt].comp[0].step_minus1+1;
int h_chroma_shift, v_chroma_shift;
int edge = 32; // XXX should be avcodec_get_edge_width(), but that fails on svq1
@ -4939,6 +4939,13 @@ static int opt_vsync(const char *opt, const char *arg)
return 0;
}
static int opt_deinterlace(const char *opt, const char *arg)
{
av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
do_deinterlace = 1;
return 0;
}
#define OFFSET(x) offsetof(OptionsContext, x)
static const OptionDef options[] = {
/* main options */
@ -5018,8 +5025,8 @@ static const OptionDef options[] = {
"use same quantizer as source (implies VBR)" },
{ "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
{ "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
{ "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
"deinterlace pictures" },
{ "deinterlace", OPT_EXPERT | OPT_VIDEO, {(void*)opt_deinterlace},
"this option is deprecated, use the yadif filter instead" },
{ "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
{ "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
{ "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },

20
libavcodec/aacenc.c
Unescape View File

@ -223,8 +223,9 @@ WINDOW_FUNC(eight_short)
const float *pwindow = sce->ics.use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128;
const float *in = audio + 448;
float *out = sce->ret;
int w;
for (int w = 0; w < 8; w++) {
for (w = 0; w < 8; w++) {
dsp->vector_fmul (out, in, w ? pwindow : swindow, 128);
out += 128;
in += 128;
@ -476,7 +477,7 @@ static void put_bitstream_info(AVCodecContext *avctx, AACEncContext *s,
* Channels are reordered from Libav's default order to AAC order.
*/
static void deinterleave_input_samples(AACEncContext *s,
const float *samples)
const float *samples, int nb_samples)
{
int ch, i;
const int sinc = s->channels;
@ -490,10 +491,12 @@ static void deinterleave_input_samples(AACEncContext *s,
memcpy(&s->planar_samples[ch][1024], &s->planar_samples[ch][2048], 1024 * sizeof(s->planar_samples[0][0]));
/* deinterleave */
for (i = 2048; i < 3072; i++) {
for (i = 2048; i < 2048 + nb_samples; i++) {
s->planar_samples[ch][i] = *sptr;
sptr += sinc;
}
memset(&s->planar_samples[ch][i], 0,
(3072 - i) * sizeof(s->planar_samples[0][0]));
}
}
@ -507,14 +510,12 @@ static int aac_encode_frame(AVCodecContext *avctx,
int chan_el_counter[4];
FFPsyWindowInfo windows[AAC_MAX_CHANNELS];
if (s->last_frame)
if (s->last_frame == 2)
return 0;
if (data) {
deinterleave_input_samples(s, data);
deinterleave_input_samples(s, data, data ? avctx->frame_size : 0);
if (s->psypp)
ff_psy_preprocess(s->psypp, s->planar_samples, s->channels);
}
if (!avctx->frame_number)
return 0;
@ -645,7 +646,7 @@ static int aac_encode_frame(AVCodecContext *avctx,
}
if (!data)
s->last_frame = 1;
s->last_frame++;
return put_bits_count(&s->pb)>>3;
}
@ -686,11 +687,12 @@ static av_cold int dsp_init(AVCodecContext *avctx, AACEncContext *s)
static av_cold int alloc_buffers(AVCodecContext *avctx, AACEncContext *s)
{
int ch;
FF_ALLOCZ_OR_GOTO(avctx, s->buffer.samples, 3 * 1024 * s->channels * sizeof(s->buffer.samples[0]), alloc_fail);
FF_ALLOCZ_OR_GOTO(avctx, s->cpe, sizeof(ChannelElement) * s->chan_map[0], alloc_fail);
FF_ALLOCZ_OR_GOTO(avctx, avctx->extradata, 5 + FF_INPUT_BUFFER_PADDING_SIZE, alloc_fail);
for(int ch = 0; ch < s->channels; ch++)
for(ch = 0; ch < s->channels; ch++)
s->planar_samples[ch] = s->buffer.samples + 3 * 1024 * ch;
return 0;

12
libavcodec/kmvc.c
Unescape View File

@ -33,6 +33,7 @@
#define KMVC_KEYFRAME 0x80
#define KMVC_PALETTE 0x40
#define KMVC_METHOD 0x0F
#define MAX_PALSIZE 256
/*
* Decoder context
@ -43,7 +44,7 @@ typedef struct KmvcContext {
int setpal;
int palsize;
uint32_t pal[256];
uint32_t pal[MAX_PALSIZE];
uint8_t *cur, *prev;
uint8_t *frm0, *frm1;
GetByteContext g;
@ -376,14 +377,15 @@ static av_cold int decode_init(AVCodecContext * avctx)
}
if (avctx->extradata_size < 12) {
av_log(NULL, 0, "Extradata missing, decoding may not work properly...\n");
av_log(avctx, AV_LOG_WARNING,
"Extradata missing, decoding may not work properly...\n");
c->palsize = 127;
} else {
c->palsize = AV_RL16(avctx->extradata + 10);
if (c->palsize > 255U) {
if (c->palsize >= (unsigned)MAX_PALSIZE) {
c->palsize = 127;
av_log(NULL, AV_LOG_ERROR, "palsize too big\n");
return -1;
av_log(avctx, AV_LOG_ERROR, "KMVC palette too large\n");
return AVERROR_INVALIDDATA;
}
}

2
libavcodec/mpc7.c
Unescape View File

@ -53,7 +53,7 @@ static av_cold int mpc7_decode_init(AVCodecContext * avctx)
int i, j;
MPCContext *c = avctx->priv_data;
GetBitContext gb;
uint8_t buf[16];
LOCAL_ALIGNED_16(uint8_t, buf, [16]);
static int vlc_initialized = 0;
static VLC_TYPE scfi_table[1 << MPC7_SCFI_BITS][2];

2
libavcodec/mpeg12data.c
Unescape View File

@ -305,7 +305,7 @@ const uint8_t ff_mpeg12_mbMotionVectorTable[17][2] = {
{ 0xc, 10 },
};
const AVRational avpriv_frame_rate_tab[] = {
const AVRational avpriv_frame_rate_tab[16] = {
{ 0, 0},
{24000, 1001},
{ 24, 1},

2
libavcodec/wmadec.c
Unescape View File

@ -891,6 +891,8 @@ static int wma_decode_superframe(AVCodecContext *avctx, void *data,
/* read each frame starting from bit_offset */
pos = bit_offset + 4 + 4 + s->byte_offset_bits + 3;
if (pos >= MAX_CODED_SUPERFRAME_SIZE * 8)
return AVERROR_INVALIDDATA;
init_get_bits(&s->gb, buf + (pos >> 3), (MAX_CODED_SUPERFRAME_SIZE - (pos >> 3))*8);
len = pos & 7;
if (len > 0)

1
libavcodec/x86/Makefile
Unescape View File

@ -48,6 +48,7 @@ MMX-OBJS-$(CONFIG_GPL) += x86/idct_mmx.o
MMX-OBJS-$(CONFIG_LPC) += x86/lpc_mmx.o
YASM-OBJS-$(CONFIG_PRORES_LGPL_DECODER) += x86/proresdsp.o
MMX-OBJS-$(CONFIG_PRORES_LGPL_DECODER) += x86/proresdsp-init.o
YASM-OBJS-$(CONFIG_PNG_DECODER) += x86/pngdsp.o
MMX-OBJS-$(CONFIG_PNG_DECODER) += x86/pngdsp-init.o
YASM-OBJS-$(CONFIG_PRORES_DECODER) += x86/proresdsp.o
MMX-OBJS-$(CONFIG_PRORES_DECODER) += x86/proresdsp-init.o

5
libavcodec/x86/dsputil_mmx.c
Unescape View File

@ -2392,6 +2392,9 @@ void ff_apply_window_int16_ssse3 (int16_t *output, const int16_t *input,
void ff_apply_window_int16_ssse3_atom(int16_t *output, const int16_t *input,
const int16_t *window, unsigned int len);
void ff_bswap32_buf_ssse3(uint32_t *dst, const uint32_t *src, int w);
void ff_bswap32_buf_sse2(uint32_t *dst, const uint32_t *src, int w);
void ff_add_hfyu_median_prediction_mmx2(uint8_t *dst, const uint8_t *top, const uint8_t *diff, int w, int *left, int *left_top);
int ff_add_hfyu_left_prediction_ssse3(uint8_t *dst, const uint8_t *src, int w, int left);
int ff_add_hfyu_left_prediction_sse4(uint8_t *dst, const uint8_t *src, int w, int left);
@ -2880,6 +2883,7 @@ void dsputil_init_mmx(DSPContext* c, AVCodecContext *avctx)
c->apply_window_int16 = ff_apply_window_int16_sse2;
}
}
c->bswap_buf = ff_bswap32_buf_sse2;
#endif
}
if (mm_flags & AV_CPU_FLAG_SSSE3) {
@ -2892,6 +2896,7 @@ void dsputil_init_mmx(DSPContext* c, AVCodecContext *avctx)
if (!(mm_flags & (AV_CPU_FLAG_SSE42|AV_CPU_FLAG_3DNOW))) { // cachesplit
c->scalarproduct_and_madd_int16 = ff_scalarproduct_and_madd_int16_ssse3;
}
c->bswap_buf = ff_bswap32_buf_ssse3;
#endif
}

124
libavcodec/x86/dsputil_yasm.asm
Unescape View File

@ -30,6 +30,7 @@ pb_zzzz3333zzzzbbbb: db -1,-1,-1,-1,3,3,3,3,-1,-1,-1,-1,11,11,11,11
pb_zz11zz55zz99zzdd: db -1,-1,1,1,-1,-1,5,5,-1,-1,9,9,-1,-1,13,13
pb_revwords: db 14, 15, 12, 13, 10, 11, 8, 9, 6, 7, 4, 5, 2, 3, 0, 1
pd_16384: times 4 dd 16384
pb_bswap32: db 3, 2, 1, 0, 7, 6, 5, 4, 11, 10, 9, 8, 15, 14, 13, 12
SECTION_TEXT
@ -1180,3 +1181,126 @@ BUTTERFLIES_FLOAT_INTERLEAVE
INIT_YMM avx
BUTTERFLIES_FLOAT_INTERLEAVE
%endif
INIT_XMM sse2
; %1 = aligned/unaligned
%macro BSWAP_LOOPS_SSE2 1
mov r3, r2
sar r2, 3
jz .left4_%1
.loop8_%1:
mov%1 m0, [r1 + 0]
mov%1 m1, [r1 + 16]
pshuflw m0, m0, 10110001b
pshuflw m1, m1, 10110001b
pshufhw m0, m0, 10110001b
pshufhw m1, m1, 10110001b
mova m2, m0
mova m3, m1
psllw m0, 8
psllw m1, 8
psrlw m2, 8
psrlw m3, 8
por m2, m0
por m3, m1
mova [r0 + 0], m2
mova [r0 + 16], m3
add r1, 32
add r0, 32
dec r2
jnz .loop8_%1
.left4_%1:
mov r2, r3
and r3, 4
jz .left
mov%1 m0, [r1]
pshuflw m0, m0, 10110001b
pshufhw m0, m0, 10110001b
mova m2, m0
psllw m0, 8
psrlw m2, 8
por m2, m0
mova [r0], m2
add r1, 16
add r0, 16
%endmacro
; void bswap_buf(uint32_t *dst, const uint32_t *src, int w);
cglobal bswap32_buf, 3,4,5
mov r3, r1
and r3, 15
jz .start_align
BSWAP_LOOPS_SSE2 u
jmp .left
.start_align:
BSWAP_LOOPS_SSE2 a
.left:
and r2, 3
jz .end
.loop2:
mov r3d, [r1]
bswap r3d
mov [r0], r3d
add r1, 4
add r0, 4
dec r2
jnz .loop2
.end
RET
; %1 = aligned/unaligned
%macro BSWAP_LOOPS_SSSE3 1
mov r3, r2
sar r2, 3
jz .left4_%1
.loop8_%1:
mov%1 m0, [r1 + 0]
mov%1 m1, [r1 + 16]
pshufb m0, m2
pshufb m1, m2
mova [r0 + 0], m0
mova [r0 + 16], m1
add r0, 32
add r1, 32
dec r2
jnz .loop8_%1
.left4_%1:
mov r2, r3
and r3, 4
jz .left2
mov%1 m0, [r1]
pshufb m0, m2
mova [r0], m0
add r1, 16
add r0, 16
%endmacro
INIT_XMM ssse3
; void bswap_buf(uint32_t *dst, const uint32_t *src, int w);
cglobal bswap32_buf, 3,4,3
mov r3, r1
mova m2, [pb_bswap32]
and r3, 15
jz .start_align
BSWAP_LOOPS_SSSE3 u
jmp .left2
.start_align:
BSWAP_LOOPS_SSSE3 a
.left2:
mov r3, r2
and r2, 2
jz .left1
movq m0, [r1]
pshufb m0, m2
movq [r0], m0
add r1, 8
add r0, 8
.left1:
and r3, 1
jz .end
mov r2d, [r1]
bswap r2d
mov [r0], r2d
.end:
RET

123
libavcodec/x86/pngdsp-init.c
Unescape View File

@ -19,118 +19,33 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "libavutil/common.h"
#include "libavutil/cpu.h"
#include "libavutil/x86_cpu.h"
#include "libavcodec/pngdsp.h"
#include "dsputil_mmx.h"
#define PAETH(cpu, abs3)\
static void add_png_paeth_prediction_##cpu(uint8_t *dst, uint8_t *src, uint8_t *top, int w, int bpp)\
{\
x86_reg i, end;\
if(bpp>4) add_png_paeth_prediction_##cpu(dst+bpp/2, src+bpp/2, top+bpp/2, w-bpp/2, -bpp);\
if(bpp<0) bpp=-bpp;\
i= -bpp;\
end = w-3;\
__asm__ volatile(\
"pxor %%mm7, %%mm7 \n"\
"movd (%1,%0), %%mm0 \n"\
"movd (%2,%0), %%mm1 \n"\
"punpcklbw %%mm7, %%mm0 \n"\
"punpcklbw %%mm7, %%mm1 \n"\
"add %4, %0 \n"\
"1: \n"\
"movq %%mm1, %%mm2 \n"\
"movd (%2,%0), %%mm1 \n"\
"movq %%mm2, %%mm3 \n"\
"punpcklbw %%mm7, %%mm1 \n"\
"movq %%mm2, %%mm4 \n"\
"psubw %%mm1, %%mm3 \n"\
"psubw %%mm0, %%mm4 \n"\
"movq %%mm3, %%mm5 \n"\
"paddw %%mm4, %%mm5 \n"\
abs3\
"movq %%mm4, %%mm6 \n"\
"pminsw %%mm5, %%mm6 \n"\
"pcmpgtw %%mm6, %%mm3 \n"\
"pcmpgtw %%mm5, %%mm4 \n"\
"movq %%mm4, %%mm6 \n"\
"pand %%mm3, %%mm4 \n"\
"pandn %%mm3, %%mm6 \n"\
"pandn %%mm0, %%mm3 \n"\
"movd (%3,%0), %%mm0 \n"\
"pand %%mm1, %%mm6 \n"\
"pand %%mm4, %%mm2 \n"\
"punpcklbw %%mm7, %%mm0 \n"\
"paddw %%mm6, %%mm0 \n"\
"paddw %%mm2, %%mm3 \n"\
"paddw %%mm3, %%mm0 \n"\
"pand %6 , %%mm0 \n"\
"movq %%mm0, %%mm3 \n"\
"packuswb %%mm3, %%mm3 \n"\
"movd %%mm3, (%1,%0) \n"\
"add %4, %0 \n"\
"cmp %5, %0 \n"\
"jle 1b \n"\
:"+r"(i)\
:"r"(dst), "r"(top), "r"(src), "r"((x86_reg)bpp), "g"(end),\
"m"(ff_pw_255)\
:"memory"\
);\
}
#define ABS3_MMX2\
"psubw %%mm5, %%mm7 \n"\
"pmaxsw %%mm7, %%mm5 \n"\
"pxor %%mm6, %%mm6 \n"\
"pxor %%mm7, %%mm7 \n"\
"psubw %%mm3, %%mm6 \n"\
"psubw %%mm4, %%mm7 \n"\
"pmaxsw %%mm6, %%mm3 \n"\
"pmaxsw %%mm7, %%mm4 \n"\
"pxor %%mm7, %%mm7 \n"
#define ABS3_SSSE3\
"pabsw %%mm3, %%mm3 \n"\
"pabsw %%mm4, %%mm4 \n"\
"pabsw %%mm5, %%mm5 \n"
PAETH(mmx2, ABS3_MMX2)
#if HAVE_SSSE3
PAETH(ssse3, ABS3_SSSE3)
#endif
static void add_bytes_l2_mmx(uint8_t *dst, uint8_t *src1, uint8_t *src2, int w)
{
x86_reg i=0;
__asm__ volatile(
"jmp 2f \n\t"
"1: \n\t"
"movq (%2, %0), %%mm0 \n\t"
"movq 8(%2, %0), %%mm1 \n\t"
"paddb (%3, %0), %%mm0 \n\t"
"paddb 8(%3, %0), %%mm1 \n\t"
"movq %%mm0, (%1, %0) \n\t"
"movq %%mm1, 8(%1, %0) \n\t"
"add $16, %0 \n\t"
"2: \n\t"
"cmp %4, %0 \n\t"
" js 1b \n\t"
: "+r" (i)
: "r"(dst), "r"(src1), "r"(src2), "r"((x86_reg) w - 15)
);
for (; i < w; i++)
dst[i] = src1[i] + src2[i];
}
void ff_add_png_paeth_prediction_mmx2 (uint8_t *dst, uint8_t *src,
uint8_t *top, int w, int bpp);
void ff_add_png_paeth_prediction_ssse3(uint8_t *dst, uint8_t *src,
uint8_t *top, int w, int bpp);
void ff_add_bytes_l2_mmx (uint8_t *dst, uint8_t *src1,
uint8_t *src2, int w);
void ff_add_bytes_l2_sse2(uint8_t *dst, uint8_t *src1,
uint8_t *src2, int w);
void ff_pngdsp_init_x86(PNGDSPContext *dsp)
{
#if HAVE_YASM
int flags = av_get_cpu_flags();
#if ARCH_X86_32
if (flags & AV_CPU_FLAG_MMX)
dsp->add_bytes_l2 = add_bytes_l2_mmx;
dsp->add_bytes_l2 = ff_add_bytes_l2_mmx;
#endif
if (flags & AV_CPU_FLAG_MMX2)
dsp->add_paeth_prediction = add_png_paeth_prediction_mmx2;
if (HAVE_SSSE3 && flags & AV_CPU_FLAG_SSSE3)
dsp->add_paeth_prediction = add_png_paeth_prediction_ssse3;
dsp->add_paeth_prediction = ff_add_png_paeth_prediction_mmx2;
if (flags & AV_CPU_FLAG_SSE2)
dsp->add_bytes_l2 = ff_add_bytes_l2_sse2;
if (flags & AV_CPU_FLAG_SSSE3)
dsp->add_paeth_prediction = ff_add_png_paeth_prediction_ssse3;
#endif
}

174
libavcodec/x86/pngdsp.asm
Unescape View File

@ -0,0 +1,174 @@
;******************************************************************************
;* x86 optimizations for PNG decoding
;*
;* Copyright (c) 2008 Loren Merritt <lorenm@u.washington.edu>
;* Copyright (c) 2012 Ronald S. Bultje <rsbultje@gmail.com>
;*
;* This file is part of Libav.
;*
;* Libav is free software; you can redistribute it and/or
;* 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.
;*
;* Libav is distributed in the hope that it will be useful,
;* 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
;* License along with Libav; if not, write to the Free Software
;* 51, Inc., Foundation Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
;******************************************************************************
%include "x86inc.asm"
%include "x86util.asm"
SECTION_RODATA
cextern pw_255
section .text align=16
; %1 = nr. of xmm registers used
%macro ADD_BYTES_FN 1
cglobal add_bytes_l2, 4, 6, %1, dst, src1, src2, wa, w, i
%if ARCH_X86_64
movsxd waq, wad
%endif
xor iq, iq
; vector loop
mov wq, waq
and waq, ~(mmsize*2-1)
jmp .end_v
.loop_v:
mova m0, [src1q+iq]
mova m1, [src1q+iq+mmsize]
paddb m0, [src2q+iq]
paddb m1, [src2q+iq+mmsize]
mova [dstq+iq ], m0
mova [dstq+iq+mmsize], m1
add iq, mmsize*2
.end_v:
cmp iq, waq
jl .loop_v
%if mmsize == 16
; vector loop
mov wq, waq
and waq, ~7
jmp .end_l
.loop_l:
movq mm0, [src1q+iq]
paddb mm0, [src2q+iq]
movq [dstq+iq ], mm0
add iq, 8
.end_l:
cmp iq, waq
jl .loop_l
%endif
; scalar loop for leftover
jmp .end_s
.loop_s:
mov wab, [src1q+iq]
add wab, [src2q+iq]
mov [dstq+iq], wab
inc iq
.end_s:
cmp iq, wq
jl .loop_s
REP_RET
%endmacro
%if ARCH_X86_32
INIT_MMX mmx
ADD_BYTES_FN 0
%endif
INIT_XMM sse2
ADD_BYTES_FN 2
%macro ADD_PAETH_PRED_FN 1
cglobal add_png_paeth_prediction, 5, 7, %1, dst, src, top, w, bpp, end, cntr
%if ARCH_X86_64
movsxd bppq, bppd
movsxd wq, wd
%endif
lea endq, [dstq+wq-(mmsize/2-1)]
sub topq, dstq
sub srcq, dstq
sub dstq, bppq
pxor m7, m7
PUSH dstq
lea cntrq, [bppq-1]
shr cntrq, 2 + mmsize/16
.bpp_loop:
lea dstq, [dstq+cntrq*(mmsize/2)]
movh m0, [dstq]
movh m1, [topq+dstq]
punpcklbw m0, m7
punpcklbw m1, m7
add dstq, bppq
.loop:
mova m2, m1
movh m1, [topq+dstq]
mova m3, m2
punpcklbw m1, m7
mova m4, m2
psubw m3, m1
psubw m4, m0
mova m5, m3
paddw m5, m4
%if cpuflag(ssse3)
pabsw m3, m3
pabsw m4, m4
pabsw m5, m5
%else ; !cpuflag(ssse3)
psubw m7, m5
pmaxsw m5, m7
pxor m6, m6
pxor m7, m7
psubw m6, m3
psubw m7, m4
pmaxsw m3, m6
pmaxsw m4, m7
pxor m7, m7
%endif ; cpuflag(ssse3)
mova m6, m4
pminsw m6, m5
pcmpgtw m3, m6
pcmpgtw m4, m5
mova m6, m4
pand m4, m3
pandn m6, m3
pandn m3, m0
movh m0, [srcq+dstq]
pand m6, m1
pand m2, m4
punpcklbw m0, m7
paddw m0, m6
paddw m3, m2
paddw m0, m3
pand m0, [pw_255]
mova m3, m0
packuswb m3, m3
movh [dstq], m3
add dstq, bppq
cmp dstq, endq
jle .loop
mov dstq, [rsp]
dec cntrq
jge .bpp_loop
POP dstq
RET
%endmacro
INIT_MMX mmx2
ADD_PAETH_PRED_FN 0
INIT_MMX ssse3
ADD_PAETH_PRED_FN 0

291
libavformat/movenc.c
Unescape View File

@ -70,7 +70,7 @@ static const AVClass flavor ## _muxer_class = {\
};
//FIXME support 64 bit variant with wide placeholders
static int64_t updateSize(AVIOContext *pb, int64_t pos)
static int64_t update_size(AVIOContext *pb, int64_t pos)
{
int64_t curpos = avio_tell(pb);
avio_seek(pb, pos, SEEK_SET);
@ -102,7 +102,7 @@ static int mov_write_stco_tag(AVIOContext *pb, MOVTrack *track)
else
avio_wb32(pb, track->cluster[i].pos);
}
return updateSize(pb, pos);
return update_size(pb, pos);
}
/* Sample size atom */
@ -140,7 +140,7 @@ static int mov_write_stsz_tag(AVIOContext *pb, MOVTrack *track)
}
}
}
return updateSize(pb, pos);
return update_size(pb, pos);
}
/* Sample to chunk atom */
@ -156,12 +156,12 @@ static int mov_write_stsc_tag(AVIOContext *pb, MOVTrack *track)
entryPos = avio_tell(pb);
avio_wb32(pb, track->chunkCount); // entry count
for (i=0; i<track->entry; i++) {
if(oldval != track->cluster[i].samplesInChunk && track->cluster[i].chunkNum)
if (oldval != track->cluster[i].samples_in_chunk && track->cluster[i].chunkNum)
{
avio_wb32(pb, track->cluster[i].chunkNum); // first chunk
avio_wb32(pb, track->cluster[i].samplesInChunk); // samples per chunk
avio_wb32(pb, track->cluster[i].samples_in_chunk); // samples per chunk
avio_wb32(pb, 0x1); // sample description index
oldval = track->cluster[i].samplesInChunk;
oldval = track->cluster[i].samples_in_chunk;
index++;
}
}
@ -170,7 +170,7 @@ static int mov_write_stsc_tag(AVIOContext *pb, MOVTrack *track)
avio_wb32(pb, index); // rewrite size
avio_seek(pb, curpos, SEEK_SET);
return updateSize(pb, pos);
return update_size(pb, pos);
}
/* Sync sample atom */
@ -194,7 +194,7 @@ static int mov_write_stss_tag(AVIOContext *pb, MOVTrack *track, uint32_t flag)
avio_seek(pb, entryPos, SEEK_SET);
avio_wb32(pb, index); // rewrite size
avio_seek(pb, curpos, SEEK_SET);
return updateSize(pb, pos);
return update_size(pb, pos);
}
static int mov_write_amr_tag(AVIOContext *pb, MOVTrack *track)
@ -218,13 +218,13 @@ static int mov_write_ac3_tag(AVIOContext *pb, MOVTrack *track)
uint8_t buf[3];
int fscod, bsid, bsmod, acmod, lfeon, frmsizecod;
if (track->vosLen < 7)
if (track->vos_len < 7)
return -1;
avio_wb32(pb, 11);
ffio_wfourcc(pb, "dac3");
init_get_bits(&gbc, track->vosData+4, (track->vosLen-4) * 8);
init_get_bits(&gbc, track->vos_data + 4, (track->vos_len - 4) * 8);
fscod = get_bits(&gbc, 2);
frmsizecod = get_bits(&gbc, 6);
bsid = get_bits(&gbc, 5);
@ -273,7 +273,7 @@ static int mov_write_enda_tag(AVIOContext *pb)
return 10;
}
static void putDescr(AVIOContext *pb, int tag, unsigned int size)
static void put_descr(AVIOContext *pb, int tag, unsigned int size)
{
int i = 3;
avio_w8(pb, tag);
@ -288,13 +288,13 @@ static unsigned compute_avg_bitrate(MOVTrack *track)
int i;
for (i = 0; i < track->entry; i++)
size += track->cluster[i].size;
return size * 8 * track->timescale / track->trackDuration;
return size * 8 * track->timescale / track->track_duration;
}
static int mov_write_esds_tag(AVIOContext *pb, MOVTrack *track) // Basic
{
int64_t pos = avio_tell(pb);
int decoderSpecificInfoLen = track->vosLen ? 5+track->vosLen : 0;
int decoder_specific_info_len = track->vos_len ? 5 + track->vos_len : 0;
unsigned avg_bitrate;
avio_wb32(pb, 0); // size
@ -302,12 +302,12 @@ static int mov_write_esds_tag(AVIOContext *pb, MOVTrack *track) // Basic
avio_wb32(pb, 0); // Version
// ES descriptor
putDescr(pb, 0x03, 3 + 5+13 + decoderSpecificInfoLen + 5+1);
avio_wb16(pb, track->trackID);
put_descr(pb, 0x03, 3 + 5+13 + decoder_specific_info_len + 5+1);
avio_wb16(pb, track->track_id);
avio_w8(pb, 0x00); // flags (= no flags)
// DecoderConfig descriptor
putDescr(pb, 0x04, 13 + decoderSpecificInfoLen);
put_descr(pb, 0x04, 13 + decoder_specific_info_len);
// Object type indication
if ((track->enc->codec_id == CODEC_ID_MP2 ||
@ -332,16 +332,16 @@ static int mov_write_esds_tag(AVIOContext *pb, MOVTrack *track) // Basic
avio_wb32(pb, FFMAX3(track->enc->bit_rate, track->enc->rc_max_rate, avg_bitrate));
avio_wb32(pb, avg_bitrate);
if (track->vosLen) {
if (track->vos_len) {
// DecoderSpecific info descriptor
putDescr(pb, 0x05, track->vosLen);
avio_write(pb, track->vosData, track->vosLen);
put_descr(pb, 0x05, track->vos_len);
avio_write(pb, track->vos_data, track->vos_len);
}
// SL descriptor
putDescr(pb, 0x06, 1);
put_descr(pb, 0x06, 1);
avio_w8(pb, 0x02);
return updateSize(pb, pos);
return update_size(pb, pos);
}
static int mov_pcm_le_gt16(enum CodecID codec_id)
@ -359,7 +359,7 @@ static int mov_write_ms_tag(AVIOContext *pb, MOVTrack *track)
avio_wl32(pb, track->tag); // store it byteswapped
track->enc->codec_tag = av_bswap16(track->tag >> 16);
ff_put_wav_header(pb, track->enc);
return updateSize(pb, pos);
return update_size(pb, pos);
}
static int mov_write_chan_tag(AVIOContext *pb, MOVTrack *track)
@ -384,7 +384,7 @@ static int mov_write_chan_tag(AVIOContext *pb, MOVTrack *track)
avio_wb32(pb, bitmap); // mChannelBitmap
avio_wb32(pb, 0); // mNumberChannelDescriptions
return updateSize(pb, pos);
return update_size(pb, pos);
}
static int mov_write_wave_tag(AVIOContext *pb, MOVTrack *track)
@ -421,15 +421,15 @@ static int mov_write_wave_tag(AVIOContext *pb, MOVTrack *track)
avio_wb32(pb, 8); /* size */
avio_wb32(pb, 0); /* null tag */
return updateSize(pb, pos);
return update_size(pb, pos);
}
static int mov_write_glbl_tag(AVIOContext *pb, MOVTrack *track)
{
avio_wb32(pb, track->vosLen+8);
avio_wb32(pb, track->vos_len + 8);
ffio_wfourcc(pb, "glbl");
avio_write(pb, track->vosData, track->vosLen);
return 8+track->vosLen;
avio_write(pb, track->vos_data, track->vos_len);
return 8 + track->vos_len;
}
/**
@ -502,7 +502,7 @@ static int mov_write_audio_tag(AVIOContext *pb, MOVTrack *track)
avio_wb32(pb, 0x7F000000);
avio_wb32(pb, av_get_bits_per_sample(track->enc->codec_id));
avio_wb32(pb, mov_get_lpcm_flags(track->enc->codec_id));
avio_wb32(pb, track->sampleSize);
avio_wb32(pb, track->sample_size);
avio_wb32(pb, track->enc->frame_size);
} else {
if (track->mode == MODE_MOV) {
@ -526,8 +526,8 @@ static int mov_write_audio_tag(AVIOContext *pb, MOVTrack *track)
if(version == 1) { /* SoundDescription V1 extended info */
avio_wb32(pb, track->enc->frame_size); /* Samples per packet */
avio_wb32(pb, track->sampleSize / track->enc->channels); /* Bytes per packet */
avio_wb32(pb, track->sampleSize); /* Bytes per frame */
avio_wb32(pb, track->sample_size / track->enc->channels); /* Bytes per packet */
avio_wb32(pb, track->sample_size); /* Bytes per frame */
avio_wb32(pb, 2); /* Bytes per sample */
}
@ -548,10 +548,10 @@ static int mov_write_audio_tag(AVIOContext *pb, MOVTrack *track)
mov_write_ac3_tag(pb, track);
else if(track->enc->codec_id == CODEC_ID_ALAC)
mov_write_extradata_tag(pb, track);
else if(track->vosLen > 0)
else if (track->vos_len > 0)
mov_write_glbl_tag(pb, track);
return updateSize(pb, pos);
return update_size(pb, pos);
}
static int mov_write_d263_tag(AVIOContext *pb)
@ -585,8 +585,8 @@ static int mov_write_avcc_tag(AVIOContext *pb, MOVTrack *track)
avio_wb32(pb, 0);
ffio_wfourcc(pb, "avcC");
ff_isom_write_avcc(pb, track->vosData, track->vosLen);
return updateSize(pb, pos);
ff_isom_write_avcc(pb, track->vos_data, track->vos_len);
return update_size(pb, pos);
}
/* also used by all avid codecs (dv, imx, meridien) and their variants */
@ -611,10 +611,10 @@ static int mov_write_avid_tag(AVIOContext *pb, MOVTrack *track)
ffio_wfourcc(pb, "ARES");
ffio_wfourcc(pb, "ARES");
ffio_wfourcc(pb, "0001");
avio_wb32(pb, AV_RB32(track->vosData + 0x28)); /* dnxhd cid, some id ? */
avio_wb32(pb, AV_RB32(track->vos_data + 0x28)); /* dnxhd cid, some id ? */
avio_wb32(pb, track->enc->width);
/* values below are based on samples created with quicktime and avid codecs */
if (track->vosData[5] & 2) { // interlaced
if (track->vos_data[5] & 2) { // interlaced
avio_wb32(pb, track->enc->height/2);
avio_wb32(pb, 2); /* unknown */
avio_wb32(pb, 0); /* unknown */
@ -854,7 +854,7 @@ static int mov_write_subtitle_tag(AVIOContext *pb, MOVTrack *track)
if (track->enc->extradata_size)
avio_write(pb, track->enc->extradata, track->enc->extradata_size);
return updateSize(pb, pos);
return update_size(pb, pos);
}
static int mov_write_pasp_tag(AVIOContext *pb, MOVTrack *track)
@ -930,7 +930,7 @@ static int mov_write_video_tag(AVIOContext *pb, MOVTrack *track)
mov_write_uuid_tag_ipod(pb);
} else if (track->enc->field_order != AV_FIELD_UNKNOWN)
mov_write_fiel_tag(pb, track);
else if(track->vosLen > 0)
else if (track->vos_len > 0)
mov_write_glbl_tag(pb, track);
if (track->enc->sample_aspect_ratio.den && track->enc->sample_aspect_ratio.num &&
@ -938,7 +938,7 @@ static int mov_write_video_tag(AVIOContext *pb, MOVTrack *track)
mov_write_pasp_tag(pb, track);
}
return updateSize(pb, pos);
return update_size(pb, pos);
}
static int mov_write_rtp_tag(AVIOContext *pb, MOVTrack *track)
@ -958,7 +958,7 @@ static int mov_write_rtp_tag(AVIOContext *pb, MOVTrack *track)
ffio_wfourcc(pb, "tims");
avio_wb32(pb, track->timescale);
return updateSize(pb, pos);
return update_size(pb, pos);
}
static int mov_write_stsd_tag(AVIOContext *pb, MOVTrack *track)
@ -976,7 +976,7 @@ static int mov_write_stsd_tag(AVIOContext *pb, MOVTrack *track)
mov_write_subtitle_tag(pb, track);
else if (track->enc->codec_tag == MKTAG('r','t','p',' '))
mov_write_rtp_tag(pb, track);
return updateSize(pb, pos);
return update_size(pb, pos);
}
static int mov_write_ctts_tag(AVIOContext *pb, MOVTrack *track)
@ -1022,7 +1022,7 @@ static int mov_write_stts_tag(AVIOContext *pb, MOVTrack *track)
if (track->enc->codec_type == AVMEDIA_TYPE_AUDIO && !track->audio_vbr) {
stts_entries = av_malloc(sizeof(*stts_entries)); /* one entry */
stts_entries[0].count = track->sampleCount;
stts_entries[0].count = track->sample_count;
stts_entries[0].duration = 1;
entries = 1;
} else {
@ -1031,7 +1031,7 @@ static int mov_write_stts_tag(AVIOContext *pb, MOVTrack *track)
NULL;
for (i=0; i<track->entry; i++) {
int64_t duration = i + 1 == track->entry ?
track->trackDuration - track->cluster[i].dts + track->start_dts : /* readjusting */
track->track_duration - track->cluster[i].dts + track->start_dts : /* readjusting */
track->cluster[i+1].dts - track->cluster[i].dts;
if (i && duration == stts_entries[entries].duration) {
stts_entries[entries].count++; /* compress */
@ -1080,7 +1080,7 @@ static int mov_write_stbl_tag(AVIOContext *pb, MOVTrack *track)
mov_write_stts_tag(pb, track);
if ((track->enc->codec_type == AVMEDIA_TYPE_VIDEO ||
track->enc->codec_tag == MKTAG('r','t','p',' ')) &&
track->hasKeyframes && track->hasKeyframes < track->entry)
track->has_keyframes && track->has_keyframes < track->entry)
mov_write_stss_tag(pb, track, MOV_SYNC_SAMPLE);
if (track->mode == MODE_MOV && track->flags & MOV_TRACK_STPS)
mov_write_stss_tag(pb, track, MOV_PARTIAL_SYNC_SAMPLE);
@ -1090,7 +1090,7 @@ static int mov_write_stbl_tag(AVIOContext *pb, MOVTrack *track)
mov_write_stsc_tag(pb, track);
mov_write_stsz_tag(pb, track);
mov_write_stco_tag(pb, track);
return updateSize(pb, pos);
return update_size(pb, pos);
}
static int mov_write_dinf_tag(AVIOContext *pb)
@ -1099,7 +1099,7 @@ static int mov_write_dinf_tag(AVIOContext *pb)
avio_wb32(pb, 0); /* size */
ffio_wfourcc(pb, "dinf");
mov_write_dref_tag(pb);
return updateSize(pb, pos);
return update_size(pb, pos);
}
static int mov_write_nmhd_tag(AVIOContext *pb)
@ -1185,7 +1185,7 @@ static int mov_write_hdlr_tag(AVIOContext *pb, MOVTrack *track)
avio_write(pb, descr, strlen(descr)); /* handler description */
if (track && track->mode != MODE_MOV)
avio_w8(pb, 0); /* c string */
return updateSize(pb, pos);
return update_size(pb, pos);
}
static int mov_write_hmhd_tag(AVIOContext *pb)
@ -1222,12 +1222,12 @@ static int mov_write_minf_tag(AVIOContext *pb, MOVTrack *track)
mov_write_hdlr_tag(pb, NULL);
mov_write_dinf_tag(pb);
mov_write_stbl_tag(pb, track);
return updateSize(pb, pos);
return update_size(pb, pos);
}
static int mov_write_mdhd_tag(AVIOContext *pb, MOVTrack *track)
{
int version = track->trackDuration < INT32_MAX ? 0 : 1;
int version = track->track_duration < INT32_MAX ? 0 : 1;
(version == 1) ? avio_wb32(pb, 44) : avio_wb32(pb, 32); /* size */
ffio_wfourcc(pb, "mdhd");
@ -1241,7 +1241,7 @@ static int mov_write_mdhd_tag(AVIOContext *pb, MOVTrack *track)
avio_wb32(pb, track->time); /* modification time */
}
avio_wb32(pb, track->timescale); /* time scale (sample rate for audio) */
(version == 1) ? avio_wb64(pb, track->trackDuration) : avio_wb32(pb, track->trackDuration); /* duration */
(version == 1) ? avio_wb64(pb, track->track_duration) : avio_wb32(pb, track->track_duration); /* duration */
avio_wb16(pb, track->language); /* language */
avio_wb16(pb, 0); /* reserved (quality) */
@ -1263,12 +1263,12 @@ static int mov_write_mdia_tag(AVIOContext *pb, MOVTrack *track)
mov_write_mdhd_tag(pb, track);
mov_write_hdlr_tag(pb, track);
mov_write_minf_tag(pb, track);
return updateSize(pb, pos);
return update_size(pb, pos);
}
static int mov_write_tkhd_tag(AVIOContext *pb, MOVTrack *track, AVStream *st)
{
int64_t duration = av_rescale_rnd(track->trackDuration, MOV_TIMESCALE,
int64_t duration = av_rescale_rnd(track->track_duration, MOV_TIMESCALE,
track->timescale, AV_ROUND_UP);
int version = duration < INT32_MAX ? 0 : 1;
@ -1283,7 +1283,7 @@ static int mov_write_tkhd_tag(AVIOContext *pb, MOVTrack *track, AVStream *st)
avio_wb32(pb, track->time); /* creation time */
avio_wb32(pb, track->time); /* modification time */
}
avio_wb32(pb, track->trackID); /* track-id */
avio_wb32(pb, track->track_id); /* track-id */
avio_wb32(pb, 0); /* reserved */
(version == 1) ? avio_wb64(pb, duration) : avio_wb32(pb, duration);
@ -1352,13 +1352,13 @@ static int mov_write_tapt_tag(AVIOContext *pb, MOVTrack *track)
avio_wb32(pb, track->enc->width << 16);
avio_wb32(pb, track->enc->height << 16);
return updateSize(pb, pos);
return update_size(pb, pos);
}
// This box seems important for the psp playback ... without it the movie seems to hang
static int mov_write_edts_tag(AVIOContext *pb, MOVTrack *track)
{
int64_t duration = av_rescale_rnd(track->trackDuration, MOV_TIMESCALE,
int64_t duration = av_rescale_rnd(track->track_duration, MOV_TIMESCALE,
track->timescale, AV_ROUND_UP);
int version = duration < INT32_MAX ? 0 : 1;
int entry_size, entry_count, size;
@ -1466,13 +1466,13 @@ static int mov_write_trak_tag(AVIOContext *pb, MOVMuxContext *mov,
if (track->mode == MODE_PSP)
mov_write_uuid_tag_psp(pb,track); // PSP Movies require this uuid box
if (track->tag == MKTAG('r','t','p',' '))
mov_write_udta_sdp(pb, track->rtp_ctx, track->trackID);
mov_write_udta_sdp(pb, track->rtp_ctx, track->track_id);
if (track->enc->codec_type == AVMEDIA_TYPE_VIDEO && track->mode == MODE_MOV) {
double sample_aspect_ratio = av_q2d(st->sample_aspect_ratio);
if (0.0 != sample_aspect_ratio && 1.0 != sample_aspect_ratio)
mov_write_tapt_tag(pb, track);
};
return updateSize(pb, pos);
return update_size(pb, pos);
}
static int mov_write_iods_tag(AVIOContext *pb, MOVMuxContext *mov)
@ -1494,14 +1494,14 @@ static int mov_write_iods_tag(AVIOContext *pb, MOVMuxContext *mov)
avio_wb32(pb, 0x0); /* size */
ffio_wfourcc(pb, "iods");
avio_wb32(pb, 0); /* version & flags */
putDescr(pb, 0x10, 7);
put_descr(pb, 0x10, 7);
avio_wb16(pb, 0x004f);
avio_w8(pb, 0xff);
avio_w8(pb, 0xff);
avio_w8(pb, audio_profile);
avio_w8(pb, video_profile);
avio_w8(pb, 0xff);
return updateSize(pb, pos);
return update_size(pb, pos);
}
static int mov_write_trex_tag(AVIOContext *pb, MOVTrack *track)
@ -1509,7 +1509,7 @@ static int mov_write_trex_tag(AVIOContext *pb, MOVTrack *track)
avio_wb32(pb, 0x20); /* size */
ffio_wfourcc(pb, "trex");
avio_wb32(pb, 0); /* version & flags */
avio_wb32(pb, track->trackID); /* track ID */
avio_wb32(pb, track->track_id); /* track ID */
avio_wb32(pb, 1); /* default sample description index */
avio_wb32(pb, 0); /* default sample duration */
avio_wb32(pb, 0); /* default sample size */
@ -1525,29 +1525,29 @@ static int mov_write_mvex_tag(AVIOContext *pb, MOVMuxContext *mov)
ffio_wfourcc(pb, "mvex");
for (i = 0; i < mov->nb_streams; i++)
mov_write_trex_tag(pb, &mov->tracks[i]);
return updateSize(pb, pos);
return update_size(pb, pos);
}
static int mov_write_mvhd_tag(AVIOContext *pb, MOVMuxContext *mov)
{
int maxTrackID = 1, i;
int64_t maxTrackLenTemp, maxTrackLen = 0;
int max_track_id = 1, i;
int64_t max_track_len_temp, max_track_len = 0;
int version;
for (i=0; i<mov->nb_streams; i++) {
if(mov->tracks[i].entry > 0) {
maxTrackLenTemp = av_rescale_rnd(mov->tracks[i].trackDuration,
max_track_len_temp = av_rescale_rnd(mov->tracks[i].track_duration,
MOV_TIMESCALE,
mov->tracks[i].timescale,
AV_ROUND_UP);
if(maxTrackLen < maxTrackLenTemp)
maxTrackLen = maxTrackLenTemp;
if(maxTrackID < mov->tracks[i].trackID)
maxTrackID = mov->tracks[i].trackID;
if (max_track_len < max_track_len_temp)
max_track_len = max_track_len_temp;
if (max_track_id < mov->tracks[i].track_id)
max_track_id = mov->tracks[i].track_id;
}
}
version = maxTrackLen < UINT32_MAX ? 0 : 1;
version = max_track_len < UINT32_MAX ? 0 : 1;
(version == 1) ? avio_wb32(pb, 120) : avio_wb32(pb, 108); /* size */
ffio_wfourcc(pb, "mvhd");
avio_w8(pb, version);
@ -1560,7 +1560,7 @@ static int mov_write_mvhd_tag(AVIOContext *pb, MOVMuxContext *mov)
avio_wb32(pb, mov->time); /* modification time */
}
avio_wb32(pb, MOV_TIMESCALE);
(version == 1) ? avio_wb64(pb, maxTrackLen) : avio_wb32(pb, maxTrackLen); /* duration of longest track */
(version == 1) ? avio_wb64(pb, max_track_len) : avio_wb32(pb, max_track_len); /* duration of longest track */
avio_wb32(pb, 0x00010000); /* reserved (preferred rate) 1.0 = normal */
avio_wb16(pb, 0x0100); /* reserved (preferred volume) 1.0 = normal */
@ -1585,7 +1585,7 @@ static int mov_write_mvhd_tag(AVIOContext *pb, MOVMuxContext *mov)
avio_wb32(pb, 0); /* reserved (selection time) */
avio_wb32(pb, 0); /* reserved (selection duration) */
avio_wb32(pb, 0); /* reserved (current time) */
avio_wb32(pb, maxTrackID+1); /* Next track id */
avio_wb32(pb, max_track_id + 1); /* Next track id */
return 0x6c;
}
@ -1632,7 +1632,7 @@ static int mov_write_string_tag(AVIOContext *pb, const char *name, const char *v
avio_wb32(pb, 0); /* size */
ffio_wfourcc(pb, name);
mov_write_string_data_tag(pb, value, lang, long_style);
size= updateSize(pb, pos);
size = update_size(pb, pos);
}
return size;
}
@ -1708,7 +1708,7 @@ static int mov_write_ilst_tag(AVIOContext *pb, MOVMuxContext *mov,
mov_write_string_metadata(s, pb, "tven", "episode_id",1);
mov_write_string_metadata(s, pb, "tvnn", "network" , 1);
mov_write_trkn_tag(pb, mov, s);
return updateSize(pb, pos);
return update_size(pb, pos);
}
/* iTunes meta data tag */
@ -1722,7 +1722,7 @@ static int mov_write_meta_tag(AVIOContext *pb, MOVMuxContext *mov,
avio_wb32(pb, 0);
mov_write_itunes_hdlr_tag(pb, mov, s);
mov_write_ilst_tag(pb, mov, s);
size = updateSize(pb, pos);
size = update_size(pb, pos);
return size;
}
@ -1772,7 +1772,7 @@ static int mov_write_3gp_udta_tag(AVIOContext *pb, AVFormatContext *s,
(t = av_dict_get(s->metadata, "track", NULL, 0)))
avio_w8(pb, atoi(t->value));
}
return updateSize(pb, pos);
return update_size(pb, pos);
}
static int mov_write_chpl_tag(AVIOContext *pb, AVFormatContext *s)
@ -1798,7 +1798,7 @@ static int mov_write_chpl_tag(AVIOContext *pb, AVFormatContext *s)
} else
avio_w8(pb, 0);
}
return updateSize(pb, pos);
return update_size(pb, pos);
}
static int mov_write_udta_tag(AVIOContext *pb, MOVMuxContext *mov,
@ -1898,8 +1898,8 @@ static int mov_write_uuidusmt_tag(AVIOContext *pb, AVFormatContext *s)
// snprintf(dt,32,"%04d/%02d/%02d %02d:%02d:%02d",t_st->tm_year+1900,t_st->tm_mon+1,t_st->tm_mday,t_st->tm_hour,t_st->tm_min,t_st->tm_sec);
mov_write_psp_udta_tag(pb, "2006/04/01 11:11:11", "und", 0x03);
updateSize(pb, pos2);
return updateSize(pb, pos);
update_size(pb, pos2);
return update_size(pb, pos);
}
return 0;
@ -1916,7 +1916,7 @@ static void build_chunks(MOVTrack *trk)
if(chunk->pos + chunkSize == trk->cluster[i].pos &&
chunkSize + trk->cluster[i].size < (1<<20)){
chunkSize += trk->cluster[i].size;
chunk->samplesInChunk += trk->cluster[i].entries;
chunk->samples_in_chunk += trk->cluster[i].entries;
}else{
trk->cluster[i].chunkNum = chunk->chunkNum+1;
chunk=&trk->cluster[i];
@ -1939,7 +1939,7 @@ static int mov_write_moov_tag(AVIOContext *pb, MOVMuxContext *mov,
continue;
mov->tracks[i].time = mov->time;
mov->tracks[i].trackID = i+1;
mov->tracks[i].track_id = i+1;
build_chunks(&mov->tracks[i]);
}
@ -1947,13 +1947,13 @@ static int mov_write_moov_tag(AVIOContext *pb, MOVMuxContext *mov,
if (mov->chapter_track)
for (i=0; i<s->nb_streams; i++) {
mov->tracks[i].tref_tag = MKTAG('c','h','a','p');
mov->tracks[i].tref_id = mov->tracks[mov->chapter_track].trackID;
mov->tracks[i].tref_id = mov->tracks[mov->chapter_track].track_id;
}
for (i = 0; i < mov->nb_streams; i++) {
if (mov->tracks[i].tag == MKTAG('r','t','p',' ')) {
mov->tracks[i].tref_tag = MKTAG('h','i','n','t');
mov->tracks[i].tref_id =
mov->tracks[mov->tracks[i].src_track].trackID;
mov->tracks[mov->tracks[i].src_track].track_id;
}
}
@ -1973,7 +1973,7 @@ static int mov_write_moov_tag(AVIOContext *pb, MOVMuxContext *mov,
else
mov_write_udta_tag(pb, mov, s);
return updateSize(pb, pos);
return update_size(pb, pos);
}
static void param_write_int(AVIOContext *pb, const char *name, int value)
@ -2040,7 +2040,7 @@ static int mov_write_isml_manifest(AVIOContext *pb, MOVMuxContext *mov)
for (i = 0; i < mov->nb_streams; i++) {
MOVTrack *track = &mov->tracks[i];
const char *type;
/* track->trackID is initialized in write_moov, and thus isn't known
/* track->track_id is initialized in write_moov, and thus isn't known
* here yet */
int track_id = i + 1;
@ -2095,7 +2095,7 @@ static int mov_write_isml_manifest(AVIOContext *pb, MOVMuxContext *mov)
avio_printf(pb, "</body>\n");
avio_printf(pb, "</smil>\n");
return updateSize(pb, pos);
return update_size(pb, pos);
}
static int mov_write_mfhd_tag(AVIOContext *pb, MOVMuxContext *mov)
@ -2129,7 +2129,7 @@ static int mov_write_tfhd_tag(AVIOContext *pb, MOVTrack *track,
avio_w8(pb, 0); /* version */
avio_wb24(pb, flags);
avio_wb32(pb, track->trackID); /* track-id */
avio_wb32(pb, track->track_id); /* track-id */
if (flags & 0x01)
avio_wb64(pb, moof_offset);
if (flags & 0x08) {
@ -2149,7 +2149,7 @@ static int mov_write_tfhd_tag(AVIOContext *pb, MOVTrack *track,
avio_wb32(pb, track->default_sample_flags);
}
return updateSize(pb, pos);
return update_size(pb, pos);
}
static uint32_t get_sample_flags(MOVTrack *track, MOVIentry *entry)
@ -2165,7 +2165,7 @@ static int mov_write_trun_tag(AVIOContext *pb, MOVTrack *track)
for (i = 0; i < track->entry; i++) {
int64_t duration = i + 1 == track->entry ?
track->trackDuration - track->cluster[i].dts + track->start_dts :
track->track_duration - track->cluster[i].dts + track->start_dts :
track->cluster[i + 1].dts - track->cluster[i].dts;
if (duration != track->default_duration)
flags |= 0x100; /* sample-duration-present */
@ -2192,7 +2192,7 @@ static int mov_write_trun_tag(AVIOContext *pb, MOVTrack *track)
for (i = 0; i < track->entry; i++) {
int64_t duration = i + 1 == track->entry ?
track->trackDuration - track->cluster[i].dts + track->start_dts :
track->track_duration - track->cluster[i].dts + track->start_dts :
track->cluster[i + 1].dts - track->cluster[i].dts;
if (flags & 0x100)
avio_wb32(pb, duration);
@ -2204,7 +2204,7 @@ static int mov_write_trun_tag(AVIOContext *pb, MOVTrack *track)
avio_wb32(pb, track->cluster[i].cts);
}
return updateSize(pb, pos);
return update_size(pb, pos);
}
static int mov_write_tfxd_tag(AVIOContext *pb, MOVTrack *track)
@ -2221,10 +2221,10 @@ static int mov_write_tfxd_tag(AVIOContext *pb, MOVTrack *track)
avio_w8(pb, 1);
avio_wb24(pb, 0);
avio_wb64(pb, track->frag_start);
avio_wb64(pb, track->start_dts + track->trackDuration -
avio_wb64(pb, track->start_dts + track->track_duration -
track->cluster[0].dts);
return updateSize(pb, pos);
return update_size(pb, pos);
}
static int mov_write_tfrf_tag(AVIOContext *pb, MOVMuxContext *mov,
@ -2300,7 +2300,7 @@ static int mov_write_traf_tag(AVIOContext *pb, MOVMuxContext *mov,
}
}
return updateSize(pb, pos);
return update_size(pb, pos);
}
static int mov_write_moof_tag(AVIOContext *pb, MOVMuxContext *mov, int tracks)
@ -2334,7 +2334,7 @@ static int mov_write_moof_tag(AVIOContext *pb, MOVMuxContext *mov, int tracks)
}
avio_seek(pb, end, SEEK_SET);
return updateSize(pb, pos);
return update_size(pb, pos);
}
static int mov_write_tfra_tag(AVIOContext *pb, MOVTrack *track)
@ -2347,7 +2347,7 @@ static int mov_write_tfra_tag(AVIOContext *pb, MOVTrack *track)
avio_w8(pb, 1); /* version */
avio_wb24(pb, 0);
avio_wb32(pb, track->trackID);
avio_wb32(pb, track->track_id);
avio_wb32(pb, 0); /* length of traf/trun/sample num */
avio_wb32(pb, track->nb_frag_info);
for (i = 0; i < track->nb_frag_info; i++) {
@ -2358,7 +2358,7 @@ static int mov_write_tfra_tag(AVIOContext *pb, MOVTrack *track)
avio_w8(pb, 1); /* sample number */
}
return updateSize(pb, pos);
return update_size(pb, pos);
}
static int mov_write_mfra_tag(AVIOContext *pb, MOVMuxContext *mov)
@ -2371,7 +2371,7 @@ static int mov_write_mfra_tag(AVIOContext *pb, MOVMuxContext *mov)
/* An empty mfra atom is enough to indicate to the publishing point that
* the stream has ended. */
if (mov->flags & FF_MOV_FLAG_ISML)
return updateSize(pb, pos);
return update_size(pb, pos);
for (i = 0; i < mov->nb_streams; i++) {
MOVTrack *track = &mov->tracks[i];
@ -2384,7 +2384,7 @@ static int mov_write_mfra_tag(AVIOContext *pb, MOVMuxContext *mov)
avio_wb32(pb, 0); /* version + flags */
avio_wb32(pb, avio_tell(pb) + 4 - pos);
return updateSize(pb, pos);
return update_size(pb, pos);
}
static int mov_write_mdat_tag(AVIOContext *pb, MOVMuxContext *mov)
@ -2457,17 +2457,17 @@ static int mov_write_ftyp_tag(AVIOContext *pb, AVFormatContext *s)
ffio_wfourcc(pb, "MSNV");
else if (mov->mode == MODE_MP4)
ffio_wfourcc(pb, "mp41");
return updateSize(pb, pos);
return update_size(pb, pos);
}
static void mov_write_uuidprof_tag(AVIOContext *pb, AVFormatContext *s)
{
AVCodecContext *VideoCodec = s->streams[0]->codec;
AVCodecContext *AudioCodec = s->streams[1]->codec;
int AudioRate = AudioCodec->sample_rate;
int FrameRate = ((VideoCodec->time_base.den) * (0x10000))/ (VideoCodec->time_base.num);
int audio_kbitrate= AudioCodec->bit_rate / 1000;
int video_kbitrate= FFMIN(VideoCodec->bit_rate / 1000, 800 - audio_kbitrate);
AVCodecContext *video_codec = s->streams[0]->codec;
AVCodecContext *audio_codec = s->streams[1]->codec;
int audio_rate = audio_codec->sample_rate;
int frame_rate = ((video_codec->time_base.den) * (0x10000))/ (video_codec->time_base.num);
int audio_kbitrate = audio_codec->bit_rate / 1000;
int video_kbitrate = FFMIN(video_codec->bit_rate / 1000, 800 - audio_kbitrate);
avio_wb32(pb, 0x94); /* size */
ffio_wfourcc(pb, "uuid");
@ -2495,14 +2495,14 @@ static void mov_write_uuidprof_tag(AVIOContext *pb, AVFormatContext *s)
avio_wb32(pb, 0x0);
avio_wb32(pb, audio_kbitrate);
avio_wb32(pb, audio_kbitrate);
avio_wb32(pb, AudioRate);
avio_wb32(pb, AudioCodec->channels);
avio_wb32(pb, audio_rate);
avio_wb32(pb, audio_codec->channels);
avio_wb32(pb, 0x34); /* size */
ffio_wfourcc(pb, "VPRF"); /* video */
avio_wb32(pb, 0x0);
avio_wb32(pb, 0x1); /* TrackID */
if (VideoCodec->codec_id == CODEC_ID_H264) {
if (video_codec->codec_id == CODEC_ID_H264) {
ffio_wfourcc(pb, "avc1");
avio_wb16(pb, 0x014D);
avio_wb16(pb, 0x0015);
@ -2514,10 +2514,10 @@ static void mov_write_uuidprof_tag(AVIOContext *pb, AVFormatContext *s)
avio_wb32(pb, 0x0);
avio_wb32(pb, video_kbitrate);
avio_wb32(pb, video_kbitrate);
avio_wb32(pb, FrameRate);
avio_wb32(pb, FrameRate);
avio_wb16(pb, VideoCodec->width);
avio_wb16(pb, VideoCodec->height);
avio_wb32(pb, frame_rate);
avio_wb32(pb, frame_rate);
avio_wb16(pb, video_codec->width);
avio_wb16(pb, video_codec->height);
avio_wb32(pb, 0x010001); /* ? */
}
@ -2569,7 +2569,7 @@ static int mov_flush_fragment(AVFormatContext *s)
for (i = 0; i < mov->nb_streams; i++) {
if (mov->tracks[i].entry)
mov->tracks[i].frag_start += mov->tracks[i].start_dts +
mov->tracks[i].trackDuration -
mov->tracks[i].track_duration -
mov->tracks[i].cluster[0].dts;
mov->tracks[i].entry = 0;
}
@ -2600,7 +2600,7 @@ static int mov_flush_fragment(AVFormatContext *s)
int64_t duration = 0;
if (track->entry)
duration = track->start_dts + track->trackDuration -
duration = track->start_dts + track->track_duration -
track->cluster[0].dts;
if (mov->flags & FF_MOV_FLAG_SEPARATE_MOOF) {
if (!track->mdat_buf)
@ -2656,7 +2656,7 @@ static int mov_write_packet_internal(AVFormatContext *s, AVPacket *pkt)
AVIOContext *pb = s->pb;
MOVTrack *trk = &mov->tracks[pkt->stream_index];
AVCodecContext *enc = trk->enc;
unsigned int samplesInChunk = 0;
unsigned int samples_in_chunk = 0;
int size= pkt->size;
uint8_t *reformatted_data = NULL;
@ -2691,30 +2691,30 @@ static int mov_write_packet_internal(AVFormatContext *s, AVPacket *pkt)
{13, 14, 16, 18, 20, 21, 27, 32, 6, 0, 0, 0, 0, 0, 0, 1};
int len = 0;
while (len < size && samplesInChunk < 100) {
while (len < size && samples_in_chunk < 100) {
len += packed_size[(pkt->data[len] >> 3) & 0x0F];
samplesInChunk++;
samples_in_chunk++;
}
if(samplesInChunk > 1){
if (samples_in_chunk > 1) {
av_log(s, AV_LOG_ERROR, "fatal error, input is not a single packet, implement a AVParser for it\n");
return -1;
}
} else if (enc->codec_id == CODEC_ID_ADPCM_MS ||
enc->codec_id == CODEC_ID_ADPCM_IMA_WAV) {
samplesInChunk = enc->frame_size;
} else if (trk->sampleSize)
samplesInChunk = size/trk->sampleSize;
samples_in_chunk = enc->frame_size;
} else if (trk->sample_size)
samples_in_chunk = size / trk->sample_size;
else
samplesInChunk = 1;
samples_in_chunk = 1;
/* copy extradata if it exists */
if (trk->vosLen == 0 && enc->extradata_size > 0) {
trk->vosLen = enc->extradata_size;
trk->vosData = av_malloc(trk->vosLen);
memcpy(trk->vosData, enc->extradata, trk->vosLen);
if (trk->vos_len == 0 && enc->extradata_size > 0) {
trk->vos_len = enc->extradata_size;
trk->vos_data = av_malloc(trk->vos_len);
memcpy(trk->vos_data, enc->extradata, trk->vos_len);
}
if (enc->codec_id == CODEC_ID_H264 && trk->vosLen > 0 && *(uint8_t *)trk->vosData != 1) {
if (enc->codec_id == CODEC_ID_H264 && trk->vos_len > 0 && *(uint8_t *)trk->vos_data != 1) {
/* from x264 or from bytestream h264 */
/* nal reformating needed */
if (trk->hint_track >= 0 && trk->hint_track < mov->nb_streams) {
@ -2733,13 +2733,13 @@ static int mov_write_packet_internal(AVFormatContext *s, AVPacket *pkt)
}
if ((enc->codec_id == CODEC_ID_DNXHD ||
enc->codec_id == CODEC_ID_AC3) && !trk->vosLen) {
enc->codec_id == CODEC_ID_AC3) && !trk->vos_len) {
/* copy frame to create needed atoms */
trk->vosLen = size;
trk->vosData = av_malloc(size);
if (!trk->vosData)
trk->vos_len = size;
trk->vos_data = av_malloc(size);
if (!trk->vos_data)
return AVERROR(ENOMEM);
memcpy(trk->vosData, pkt->data, size);
memcpy(trk->vos_data, pkt->data, size);
}
if (!(trk->entry % MOV_INDEX_CLUSTER_SIZE)) {
@ -2749,21 +2749,21 @@ static int mov_write_packet_internal(AVFormatContext *s, AVPacket *pkt)
}
trk->cluster[trk->entry].pos = avio_tell(pb) - size;
trk->cluster[trk->entry].samplesInChunk = samplesInChunk;
trk->cluster[trk->entry].samples_in_chunk = samples_in_chunk;
trk->cluster[trk->entry].chunkNum = 0;
trk->cluster[trk->entry].size = size;
trk->cluster[trk->entry].entries = samplesInChunk;
trk->cluster[trk->entry].entries = samples_in_chunk;
trk->cluster[trk->entry].dts = pkt->dts;
if (!trk->entry && trk->start_dts != AV_NOPTS_VALUE) {
/* First packet of a new fragment. We already wrote the duration
* of the last packet of the previous fragment based on trackDuration,
* of the last packet of the previous fragment based on track_duration,
* which might not exactly match our dts. Therefore adjust the dts
* of this packet to be what the previous packets duration implies. */
trk->cluster[trk->entry].dts = trk->start_dts + trk->trackDuration;
trk->cluster[trk->entry].dts = trk->start_dts + trk->track_duration;
}
if (trk->start_dts == AV_NOPTS_VALUE)
trk->start_dts = pkt->dts;
trk->trackDuration = pkt->dts - trk->start_dts + pkt->duration;
trk->track_duration = pkt->dts - trk->start_dts + pkt->duration;
if (pkt->pts == AV_NOPTS_VALUE) {
av_log(s, AV_LOG_WARNING, "pts has no value\n");
@ -2783,10 +2783,10 @@ static int mov_write_packet_internal(AVFormatContext *s, AVPacket *pkt)
trk->cluster[trk->entry].flags = MOV_SYNC_SAMPLE;
}
if (trk->cluster[trk->entry].flags & MOV_SYNC_SAMPLE)
trk->hasKeyframes++;
trk->has_keyframes++;
}
trk->entry++;
trk->sampleCount += samplesInChunk;
trk->sample_count += samples_in_chunk;
mov->mdat_size += size;
avio_flush(pb);
@ -2949,12 +2949,12 @@ static int mov_write_header(AVFormatContext *s)
av_log(s, AV_LOG_ERROR, "track %d: codec block align is not set for adpcm\n", i);
goto error;
}
track->sampleSize = st->codec->block_align;
track->sample_size = st->codec->block_align;
}else if(st->codec->frame_size > 1){ /* assume compressed audio */
track->audio_vbr = 1;
}else{
st->codec->frame_size = 1;
track->sampleSize = (av_get_bits_per_sample(st->codec->codec_id) >> 3) * st->codec->channels;
track->sample_size = (av_get_bits_per_sample(st->codec->codec_id) >> 3) * st->codec->channels;
}
if (track->mode != MODE_MOV) {
if (track->timescale > UINT16_MAX) {
@ -2982,9 +2982,9 @@ static int mov_write_header(AVFormatContext *s)
/* copy extradata if it exists */
if (st->codec->extradata_size) {
track->vosLen = st->codec->extradata_size;
track->vosData = av_malloc(track->vosLen);
memcpy(track->vosData, st->codec->extradata, track->vosLen);
track->vos_len = st->codec->extradata_size;
track->vos_data = av_malloc(track->vos_len);
memcpy(track->vos_data, st->codec->extradata, track->vos_len);
}
}
@ -3101,7 +3101,8 @@ static int mov_write_trailer(AVFormatContext *s)
av_freep(&mov->tracks[i].cluster);
av_freep(&mov->tracks[i].frag_info);
if(mov->tracks[i].vosLen) av_free(mov->tracks[i].vosData);
if (mov->tracks[i].vos_len)
av_free(mov->tracks[i].vos_data);
}

16
libavformat/movenc.h
Unescape View File

@ -44,7 +44,7 @@ typedef struct MOVIentry {
uint64_t pos;
int64_t dts;
unsigned int size;
unsigned int samplesInChunk;
unsigned int samples_in_chunk;
unsigned int chunkNum; ///< Chunk number if the current entry is a chunk start otherwise 0
unsigned int entries;
int cts;
@ -79,21 +79,21 @@ typedef struct MOVIndex {
int entry;
unsigned timescale;
uint64_t time;
int64_t trackDuration;
long sampleCount;
long sampleSize;
int64_t track_duration;
long sample_count;
long sample_size;
long chunkCount;
int hasKeyframes;
int has_keyframes;
#define MOV_TRACK_CTTS 0x0001
#define MOV_TRACK_STPS 0x0002
uint32_t flags;
int language;
int trackID;
int track_id;
int tag; ///< stsd fourcc
AVCodecContext *enc;
int vosLen;
uint8_t *vosData;
int vos_len;
uint8_t *vos_data;
MOVIentry *cluster;
int audio_vbr;
int height; ///< active picture (w/o VBI) height for D-10/IMX

2
libavformat/mpegtsenc.c
Unescape View File

@ -991,7 +991,7 @@ static int mpegts_write_packet(AVFormatContext *s, AVPacket *pkt)
if (pkt->size < 5 || AV_RB32(pkt->data) != 0x0000001) {
av_log(s, AV_LOG_ERROR, "H.264 bitstream malformed, "
"no startcode found, use the h264_mp4toannexb bitstream filter\n");
"no startcode found, use the h264_mp4toannexb bitstream filter (-bsf h264_mp4toannexb)\n");
return AVERROR_INVALIDDATA;
}

13
libavformat/nsvdec.c
Unescape View File

@ -313,7 +313,7 @@ static int nsv_parse_NSVf_header(AVFormatContext *s)
char *token, *value;
char quote;
p = strings = av_mallocz(strings_size + 1);
p = strings = av_mallocz((size_t)strings_size + 1);
if (!p)
return AVERROR(ENOMEM);
endp = strings + strings_size;
@ -350,6 +350,8 @@ static int nsv_parse_NSVf_header(AVFormatContext *s)
if((unsigned)table_entries_used >= UINT_MAX / sizeof(uint32_t))
return -1;
nsv->nsvs_file_offset = av_malloc((unsigned)table_entries_used * sizeof(uint32_t));
if (!nsv->nsvs_file_offset)
return AVERROR(ENOMEM);
for(i=0;i<table_entries_used;i++)
nsv->nsvs_file_offset[i] = avio_rl32(pb) + size;
@ -357,6 +359,8 @@ static int nsv_parse_NSVf_header(AVFormatContext *s)
if(table_entries > table_entries_used &&
avio_rl32(pb) == MKTAG('T','O','C','2')) {
nsv->nsvs_timestamps = av_malloc((unsigned)table_entries_used*sizeof(uint32_t));
if (!nsv->nsvs_timestamps)
return AVERROR(ENOMEM);
for(i=0;i<table_entries_used;i++) {
nsv->nsvs_timestamps[i] = avio_rl32(pb);
}
@ -527,11 +531,16 @@ static int nsv_read_header(AVFormatContext *s)
for (i = 0; i < NSV_MAX_RESYNC_TRIES; i++) {
if (nsv_resync(s) < 0)
return -1;
if (nsv->state == NSV_FOUND_NSVF)
if (nsv->state == NSV_FOUND_NSVF) {
err = nsv_parse_NSVf_header(s);
if (err < 0)
return err;
}
/* we need the first NSVs also... */
if (nsv->state == NSV_FOUND_NSVS) {
err = nsv_parse_NSVs_header(s);
if (err < 0)
return err;
break; /* we just want the first one */
}
}

1
libavformat/rtsp.c
Unescape View File

@ -1352,7 +1352,6 @@ int ff_rtsp_connect(AVFormatContext *s)
{
RTSPState *rt = s->priv_data;
char host[1024], path[1024], tcpname[1024], cmd[2048], auth[128];
char *option_list, *option, *filename;
int port, err, tcp_fd;
RTSPMessageHeader reply1 = {0}, *reply = &reply1;
int lower_transport_mask = 0;

6
libavformat/utils.c
Unescape View File

@ -2988,7 +2988,11 @@ int avformat_write_header(AVFormatContext *s, AVDictionary **options)
if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)
&& FFABS(av_q2d(st->sample_aspect_ratio) - av_q2d(st->codec->sample_aspect_ratio)) > 0.004*av_q2d(st->sample_aspect_ratio)
){
av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder "
"(%d/%d) and muxer layer (%d/%d)\n",
st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
st->codec->sample_aspect_ratio.num,
st->codec->sample_aspect_ratio.den);
ret = AVERROR(EINVAL);
goto fail;
}

3
libavformat/yuv4mpeg.c
Unescape View File

@ -249,6 +249,9 @@ static int yuv4_read_header(AVFormatContext *s)
} else if (strncmp("420paldv", tokstart, 8) == 0) {
pix_fmt = PIX_FMT_YUV420P;
chroma_sample_location = AVCHROMA_LOC_TOPLEFT;
} else if (strncmp("420", tokstart, 3) == 0) {
pix_fmt = PIX_FMT_YUV420P;
chroma_sample_location = AVCHROMA_LOC_CENTER;
} else if (strncmp("411", tokstart, 3) == 0)
pix_fmt = PIX_FMT_YUV411P;
else if (strncmp("422", tokstart, 3) == 0)

1
libavutil/Makefile
Unescape View File

@ -19,6 +19,7 @@ HEADERS = adler32.h \
fifo.h \
file.h \
imgutils.h \
intfloat.h \
intfloat_readwrite.h \
intreadwrite.h \
lfg.h \

4
libavutil/avutil.h
Unescape View File

@ -154,8 +154,8 @@
*/
#define LIBAVUTIL_VERSION_MAJOR 51
#define LIBAVUTIL_VERSION_MINOR 35
#define LIBAVUTIL_VERSION_MICRO 101
#define LIBAVUTIL_VERSION_MINOR 36
#define LIBAVUTIL_VERSION_MICRO 100
#define LIBAVUTIL_VERSION_INT AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \
LIBAVUTIL_VERSION_MINOR, \

2
libswscale/swscale.c
Unescape View File

@ -2804,7 +2804,7 @@ static int swScale(SwsContext *c, const uint8_t* src[],
}
}
if (isPlanarYUV(dstFormat) && isALPHA(dstFormat) && !alpPixBuf)
if (isPlanar(dstFormat) && isALPHA(dstFormat) && !alpPixBuf)
fillPlane(dst[3], dstStride[3], dstW, dstY-lastDstY, lastDstY, 255);
#if HAVE_MMX2

14
tests/Makefile
Unescape View File

@ -14,20 +14,18 @@ ffservertest: ffserver$(EXESUF) tests/vsynth1/00.pgm tests/data/asynth1.sw
@echo
$(SRC_PATH)/tests/ffserver-regression.sh $(FFSERVER_REFFILE) $(SRC_PATH)/tests/ffserver.conf
tests/vsynth1/00.pgm: tests/videogen$(HOSTEXESUF)
@mkdir -p tests/vsynth1
OBJDIRS += tests/data tests/vsynth1 tests/vsynth2
tests/vsynth1/00.pgm: tests/videogen$(HOSTEXESUF) | tests/vsynth1
$(M)./$< 'tests/vsynth1/'
tests/vsynth2/00.pgm: tests/rotozoom$(HOSTEXESUF)
@mkdir -p tests/vsynth2
tests/vsynth2/00.pgm: tests/rotozoom$(HOSTEXESUF) | tests/vsynth2
$(M)./$< 'tests/vsynth2/' $(SRC_PATH)/tests/lena.pnm
tests/data/asynth1.sw: tests/audiogen$(HOSTEXESUF)
@mkdir -p tests/data
tests/data/asynth1.sw: tests/audiogen$(HOSTEXESUF) | tests/data
$(M)./$< $@
tests/data/asynth-16000-1.sw: tests/audiogen$(HOSTEXESUF)
@mkdir -p tests/data
tests/data/asynth-16000-1.sw: tests/audiogen$(HOSTEXESUF) | tests/data
$(M)./$< $@ 16000 1
tests/data/mapchan-6ch.sw: tests/audiogen$(HOSTEXESUF)

Write Preview
Loading…
Cancel
Save