April 2013 - ffmpeg-devel - lists.ffmpeg.org

[PATCH]Fix linesize for pix_fmt pal8
by Carl Eugen Hoyos 14 Jun '13

14 Jun '13

Hi! FFmpeg currently cannot read raw pal8 files written with ffmpeg if width mod 4 != 0. Attached patch fixes that (and allows QuickTime to read the files if a palette is written). Please review, Carl Eugen

3 19

[WIP] rotate filter(s)
by stefano.sabatini-lala＠poste.it 13 Jun '13

13 Jun '13

Hi, in attachment a first stub at the rotate filter. I don't know if it is a good idea to keep the float variant, while the rotate_ss may be useful (and the rotation angle could be made parametric). The integer-only rotating code is taken from tests/rotozoom.c, I don't know if we have a corresponding version in the libs. fill_line_with_color() and draw_rectangle() are duplicated from vf_pad.c, so maybe we should make them public (or at least ff_ them), drawutils.[ch] may be a good place where to put them. Note that ffplay/SDL doesn't work with odd width/height sizes, so you may need to rescale to an even wxh size (this could be done with a parametric scale as discussed some months ago). What this rotate filter still lacks, apart a resolution to the refactoring problems mentioned above, is a YUV planar version of the rotating function, and possibly the extension to other RGB variants, which should be pretty easy to add. Everyone feel free to continue to work on this and post an updated patch. Regards. -- FFmpeg = Fostering and Frightening Multimedia Portable Emblematic Guru

9 23

[PATCH] lavfi/WIP: vignette filter.
by Clément Bœsch 30 May '13

30 May '13

--- An ugly encode showing a bit the feature: http://lucy.pkh.me/gonenutty-vintage-vignette.webm The filtergraph used here was something like this (I don't remember the exact settings: curves=vintage,vignette=edge_dist_factor=3:r1=(0.02*random(1)+0.79)*h/2:r2=(0.02*random(1)+0.79)*w/2 Note that it's still far from perfect. I have an annoying halo problem, which can be seen in bright scenes: http://imgur.com/2wyhQlR This bright halo in the center is actually where the picture starts to get darker linearly (it's the ellipse defined by r1, r2). Unfortunately, the eye notices it fairly well when it's bright. I don't really know how to solve that. One idea I had was to start darkening starting at the origin instead of the outside of an ellipse, with an exponential or something. Maybe some dithering could also help. Any suggestion? --- doc/filters.texi | 50 +++++++++ libavfilter/Makefile | 1 + libavfilter/allfilters.c | 1 + libavfilter/vf_vignette.c | 273 ++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 325 insertions(+) create mode 100644 libavfilter/vf_vignette.c diff --git a/doc/filters.texi b/doc/filters.texi index 75e8a72..aaf1548 100644 --- a/doc/filters.texi +++ b/doc/filters.texi @@ -5582,6 +5582,56 @@ Flip the input video vertically. ffmpeg -i in.avi -vf "vflip" out.avi @end example +@section vignette + +Make a "vignette" effect on the video by adding shadows in the corners. + +The filter accepts parameters as a list of @var{key}=@var{value} +pairs, separated by ":". If the key of the first options is omitted, +the arguments are interpreted according to syntax +@var{r1}:@var{r2}:@var{x0}:@var{y0}. + +The description of the accepted parameters follows. + +@table @option +@item r1, r2 +Set vertical and horizontal radius expressions of the "bright" ellipse. Outside +the ellipse, the brightness starts to decrease. Default are respectively +(a)code{0.9*h/2} and @code{0.9*w/2}. + +@item x0, y0 +Set the coordinates of the center of the ellipse. Default are respectively +@code{w/2} and @code{h/2}. + +@item edge_dist_factor +Set the distance factor between the edges and the ellipse. This allows to +control the strength of the darkness on the edges. A high value will make the +borders darker quickly while a low value will make it smoother. Default is @code{2}. +@end table + +The @var{r1}, @var{r2}, @var{x0} and @var{x0} parameters are expressions +containing the following constants: + +@table @option +@item w, h +video width and height + +@item n +frame count of the input frame starting from 0 + +@item pts +presentation timestamp of the input frame expressed in time base units + +@item r +frame rate of the input video, NAN if the input frame rate is unknown + +@item t +timestamp expressed in seconds, NAN if the input timestamp is unknown + +@item tb +time base of the input video +@end table + @section yadif Deinterlace the input video ("yadif" means "yet another deinterlacing diff --git a/libavfilter/Makefile b/libavfilter/Makefile index 277ff71..5451e68 100644 --- a/libavfilter/Makefile +++ b/libavfilter/Makefile @@ -169,6 +169,7 @@ OBJS-$(CONFIG_TINTERLACE_FILTER) += vf_tinterlace.o OBJS-$(CONFIG_TRANSPOSE_FILTER) += vf_transpose.o OBJS-$(CONFIG_UNSHARP_FILTER) += vf_unsharp.o OBJS-$(CONFIG_VFLIP_FILTER) += vf_vflip.o +OBJS-$(CONFIG_VIGNETTE_FILTER) += vf_vignette.o OBJS-$(CONFIG_YADIF_FILTER) += vf_yadif.o OBJS-$(CONFIG_CELLAUTO_FILTER) += vsrc_cellauto.o diff --git a/libavfilter/allfilters.c b/libavfilter/allfilters.c index 4972322..53f740b 100644 --- a/libavfilter/allfilters.c +++ b/libavfilter/allfilters.c @@ -164,6 +164,7 @@ void avfilter_register_all(void) REGISTER_FILTER(TRANSPOSE, transpose, vf); REGISTER_FILTER(UNSHARP, unsharp, vf); REGISTER_FILTER(VFLIP, vflip, vf); + REGISTER_FILTER(VIGNETTE, vignette, vf); REGISTER_FILTER(YADIF, yadif, vf); REGISTER_FILTER(CELLAUTO, cellauto, vsrc); diff --git a/libavfilter/vf_vignette.c b/libavfilter/vf_vignette.c new file mode 100644 index 0000000..743b194 --- /dev/null +++ b/libavfilter/vf_vignette.c @@ -0,0 +1,273 @@ +/* + * Copyright (c) 2013 Clément Bœsch + * + * This file is part of FFmpeg. + * + * FFmpeg 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. + * + * FFmpeg 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 FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "libavutil/opt.h" +#include "libavutil/eval.h" +#include "libavutil/avassert.h" +#include "libavutil/pixdesc.h" +#include "avfilter.h" +#include "formats.h" +#include "internal.h" +#include "video.h" + +static const char *const var_names[] = { + "w", // stream width + "h", // stream height + "n", // frame count + "pts", // presentation timestamp expressed in AV_TIME_BASE units + "r", // frame rate + "t", // timestamp expressed in seconds + "tb", // timebase + NULL +}; + +enum var_name { + VAR_W, + VAR_H, + VAR_N, + VAR_PTS, + VAR_R, + VAR_T, + VAR_TB, + VAR_NB +}; + +typedef struct { + const AVClass *class; + const AVPixFmtDescriptor *desc; +#define DEF_EXPR_FIELDS(name) AVExpr *name##_pexpr; char *name##_expr; int name + DEF_EXPR_FIELDS(r1); + DEF_EXPR_FIELDS(r2); + DEF_EXPR_FIELDS(x0); + DEF_EXPR_FIELDS(y0); + double edge_dist_factor; + double var_values[VAR_NB]; +} VignetteContext; + +#define OFFSET(x) offsetof(VignetteContext, x) +#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM +static const AVOption vignette_options[] = { + { "r1", "set vertical radius of the ellipse", OFFSET(r1_expr), AV_OPT_TYPE_STRING, {.str="0.9*h/2"}, .flags = FLAGS }, + { "r2", "set horizontal radius of the ellipse", OFFSET(r2_expr), AV_OPT_TYPE_STRING, {.str="0.9*w/2"}, .flags = FLAGS }, + { "x0", "set ellipse center pos on x-axis", OFFSET(x0_expr), AV_OPT_TYPE_STRING, {.str="w/2"}, .flags = FLAGS }, + { "y0", "set ellipse center pos on y-axis", OFFSET(y0_expr), AV_OPT_TYPE_STRING, {.str="h/2"}, .flags = FLAGS }, + { "edge_dist_factor", "set distance factor between the edges and the ellipse", OFFSET(edge_dist_factor), AV_OPT_TYPE_DOUBLE, {.dbl=2}, 1, 1000, .flags = FLAGS }, + { NULL } +}; + +AVFILTER_DEFINE_CLASS(vignette); + +static av_cold int init(AVFilterContext *ctx, const char *args) +{ + int ret; + VignetteContext *vignette = ctx->priv; + + if ((ret = av_expr_parse(&vignette->r1_pexpr, vignette->r1_expr, var_names, NULL, NULL, NULL, NULL, 0, ctx)) < 0 || + (ret = av_expr_parse(&vignette->r2_pexpr, vignette->r2_expr, var_names, NULL, NULL, NULL, NULL, 0, ctx)) < 0 || + (ret = av_expr_parse(&vignette->x0_pexpr, vignette->x0_expr, var_names, NULL, NULL, NULL, NULL, 0, ctx)) < 0 || + (ret = av_expr_parse(&vignette->y0_pexpr, vignette->y0_expr, var_names, NULL, NULL, NULL, NULL, 0, ctx)) < 0) + return ret; + return 0; +} + +static av_cold void uninit(AVFilterContext *ctx) +{ + VignetteContext *vignette = ctx->priv; + av_expr_free(vignette->x0_pexpr); + av_expr_free(vignette->y0_pexpr); + av_expr_free(vignette->r1_pexpr); + av_expr_free(vignette->r2_pexpr); +} + +static int query_formats(AVFilterContext *ctx) +{ + static const enum AVPixelFormat pix_fmts[] = { + AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV422P, + AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV411P, + AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV440P, + AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24, + AV_PIX_FMT_GRAY8, + AV_PIX_FMT_NONE + }; + ff_set_common_formats(ctx, ff_make_format_list(pix_fmts)); + return 0; +} + +#define TS2D(ts) ((ts) == AV_NOPTS_VALUE ? NAN : (double)(ts)) +#define TS2T(ts, tb) ((ts) == AV_NOPTS_VALUE ? NAN : (double)(ts) * av_q2d(tb)) + +static double get_brightness_factor(const VignetteContext *vignette, int x, int y) +{ + double d, r; + double xx = x - vignette->x0; + double yy = y - vignette->y0; + + if (vignette->r1 > vignette->r2) { + xx *= (double)vignette->r1 / vignette->r2; + r = vignette->r2; + } else { + yy *= (double)vignette->r2 / vignette->r1; + r = vignette->r1; + } + d = sqrt(xx*xx + yy*yy); + if (d > r) { + const double d2 = (vignette->edge_dist_factor - 1) * r; + const double f = 1 - (d - r) / (d2 ? d2 : 1); + av_assert0(f <= 1); + return f < 0 ? 0 : f; + } else { + return 1; + } +} + +static int filter_frame(AVFilterLink *inlink, AVFrame *in) +{ + int x, y, direct = 0; + AVFilterContext *ctx = inlink->dst; + VignetteContext *vignette = ctx->priv; + AVFilterLink *outlink = inlink->dst->outputs[0]; + AVFrame *out; + + if (av_frame_is_writable(in)) { + direct = 1; + out = in; + } else { + out = ff_get_video_buffer(outlink, outlink->w, outlink->h); + if (!out) { + av_frame_free(&in); + return AVERROR(ENOMEM); + } + av_frame_copy_props(out, in); + } + + vignette->var_values[VAR_T] = TS2T(in->pts, inlink->time_base); + vignette->var_values[VAR_PTS] = TS2D(in->pts); + + vignette->r1 = av_expr_eval(vignette->r1_pexpr, vignette->var_values, NULL); + vignette->r2 = av_expr_eval(vignette->r2_pexpr, vignette->var_values, NULL); + vignette->x0 = av_expr_eval(vignette->x0_pexpr, vignette->var_values, NULL); + vignette->y0 = av_expr_eval(vignette->y0_pexpr, vignette->var_values, NULL); + + if (vignette->desc->flags & PIX_FMT_RGB) { + uint8_t *dst = out->data[0]; + const uint8_t *src = in ->data[0]; + const int dst_linesize = out->linesize[0]; + const int src_linesize = in ->linesize[0]; + + for (y = 0; y < inlink->h; y++) { + uint8_t *dstp = dst; + const uint8_t *srcp = src; + + for (x = 0; x < inlink->w; x++, dstp += 3, srcp += 3) { + double f = get_brightness_factor(vignette, x, y); + if (f == 1.) { + if (!direct) + memcpy(dstp, srcp, 3); + } else if (f == 0.) { + memset(dstp, 0, 3); + } else { + dstp[0] = f * srcp[0]; + dstp[1] = f * srcp[1]; + dstp[2] = f * srcp[2]; + } + } + dst += dst_linesize; + src += src_linesize; + } + } else { + int plane; + + for (plane = 0; plane < 4 && in->data[plane]; plane++) { + uint8_t *dst = out->data[plane]; + const uint8_t *src = in ->data[plane]; + const int dst_linesize = out->linesize[plane]; + const int src_linesize = in ->linesize[plane]; + const int hsub = plane == 0 ? 0 : vignette->desc->log2_chroma_w; + const int vsub = plane == 0 ? 0 : vignette->desc->log2_chroma_h; + + for (y = 0; y < inlink->h >> vsub; y++) { + uint8_t *dstp = dst; + const uint8_t *srcp = src; + + for (x = 0; x < inlink->w >> hsub; x++) { + double f = get_brightness_factor(vignette, x << hsub, y << vsub); + if (plane == 0) *dstp++ = f * *srcp++; + else *dstp++ = f * (*srcp++ - 127) + 127; + } + dst += dst_linesize; + src += src_linesize; + } + } + } + + vignette->var_values[VAR_N] += 1; + + if (!direct) + av_frame_free(&in); + + return ff_filter_frame(outlink, out); +} + +static int config_props(AVFilterLink *inlink) +{ + VignetteContext *vignette = inlink->dst->priv; + + vignette->desc = av_pix_fmt_desc_get(inlink->format); + vignette->var_values[VAR_W] = inlink->w; + vignette->var_values[VAR_H] = inlink->h; + vignette->var_values[VAR_N] = 0; + vignette->var_values[VAR_TB] = av_q2d(inlink->time_base); + vignette->var_values[VAR_R] = inlink->frame_rate.num == 0 || inlink->frame_rate.den == 0 ? + NAN : av_q2d(inlink->frame_rate); + return 0; +} + +static const AVFilterPad vignette_inputs[] = { + { + .name = "default", + .type = AVMEDIA_TYPE_VIDEO, + .filter_frame = filter_frame, + .config_props = config_props, + }, + { NULL } +}; + +static const AVFilterPad vignette_outputs[] = { + { + .name = "default", + .type = AVMEDIA_TYPE_VIDEO, + }, + { NULL } +}; + +static const char *const shorthand[] = { "r1", "r2", "x0", "y0", NULL }; + +AVFilter avfilter_vf_vignette = { + .name = "vignette", + .description = NULL_IF_CONFIG_SMALL("Make a vignette effect."), + .priv_size = sizeof(VignetteContext), + .init = init, + .uninit = uninit, + .query_formats = query_formats, + .inputs = vignette_inputs, + .outputs = vignette_outputs, + .priv_class = &vignette_class, + .shorthand = shorthand, +}; -- 1.8.2

4 9

x11 output device for libavdevice
by Moguillansky, Jeff 30 May '13

30 May '13

Hello, I really like the libavdevice code. I implemented an X11 output device for libavdevice. I would like to request if it's possible to add this to the main branch? It uses XVideo extension for hardware acceleration and it supports window resizing. To use (with video and audio output): ffmpeg -i <input file> -f x11 "Output" -f alsa "default" Here's my code: libavdevice/x11.c: /* * Copyright (c) 2011 Jeff Moguillansky * * This file is part of FFmpeg. * * FFmpeg 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. * * FFmpeg 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 FFmpeg; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "libavutil/avstring.h" #include "libavutil/opt.h" #include "libavutil/parseutils.h" #include "libavutil/pixdesc.h" #include "avdevice.h" #include <X11/Xlib.h> #include <X11/extensions/Xv.h> #include <X11/extensions/Xvlib.h> #include <sys/shm.h> typedef struct { GC gc; Window window; Display* dpy; XvImage* yuv_image[1]; XShmSegmentInfo yuv_shminfo[1]; int xv_port, width, height; } X11Data; typedef struct { AVClass *class; char *window_title; X11Data *data; } X11Context; #define OFFSET(x) offsetof(X11Context,x) static int x11_write_header(AVFormatContext *s) { X11Context *x11 = s->priv_data; X11Data *data = (X11Data*)calloc(1,sizeof(X11Data)); unsigned int p_num_adaptors; int j; XvAdaptorInfo *ai; AVCodecContext *pCodecCtx = s->streams[0]->codec; x11->data = data; if (!x11->window_title) x11->window_title = av_strdup(""); data->width = pCodecCtx->width; data->height = pCodecCtx->height; data->dpy = XOpenDisplay(NULL); data->window = XCreateSimpleWindow(data->dpy, DefaultRootWindow(data->dpy),0, 0,data->width,data->height,0,0,0); XStoreName(data->dpy, data->window, x11->window_title); XMapWindow(data->dpy, data->window); XvQueryAdaptors(data->dpy, DefaultRootWindow(data->dpy),&p_num_adaptors, &ai); data->xv_port = ai[0].base_id; data->gc = XCreateGC(data->dpy, data->window, 0, 0); for (j = 0; j<1; j++) { data->yuv_image[j] = XvShmCreateImage(data->dpy, data->xv_port+j, ('I'|('4'<<8)|('2'<<16)|'0'<<24) , 0, data->width, data->height, &data->yuv_shminfo[j]); data->yuv_shminfo[j].shmid = shmget(IPC_PRIVATE, data->yuv_image[j]->data_size, IPC_CREAT | 0777); data->yuv_image[j]->data = (char*)shmat(data->yuv_shminfo[j].shmid, 0, 0); data->yuv_shminfo[j].shmaddr = data->yuv_image[j]->data; data->yuv_shminfo[j].readOnly = False; } XShmAttach(data->dpy, &data->yuv_shminfo[0]); return 0; } static int x11_write_packet(AVFormatContext *s, AVPacket *pkt) { X11Context *x11 = s->priv_data; X11Data *data = x11->data; XvImage *img = data->yuv_image[0]; int y, h = img->height / 2; XWindowAttributes attr; AVPicture pict; AVCodecContext *pCodecCtx = s->streams[0]->codec; avpicture_fill(&pict, pkt->data, pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height); for(y = 0; y < img->height; y++) { memcpy(&img->data[img->offsets[0] + (y * img->pitches[0])], &pict.data[0][y * pict.linesize[0]], img->pitches[0]); } for(y = 0; y < h; ++y) { memcpy(&img->data[img->offsets[1] + (y * img->pitches[1])], &pict.data[1][y * pict.linesize[1]], img->pitches[1]); memcpy(&img->data[img->offsets[2] + (y * img->pitches[2])],&pict.data[2][y * pict.linesize[2]], img->pitches[2]); } XGetWindowAttributes(data->dpy, data->window,&attr); XvShmPutImage(data->dpy, data->xv_port, data->window, data->gc, data->yuv_image[0],0, 0, data->width, data->height,0, 0, attr.width,attr.height, True); XSync(data->dpy,True); return 0; } static int x11_write_trailer(AVFormatContext *s) { X11Context *x11 = s->priv_data; X11Data *data = x11->data; int j; av_freep(&x11->window_title); XShmDetach(data->dpy,&data->yuv_shminfo[0]); for (j = 0; j<1; j++) { shmdt(data->yuv_image[j]->data); XFree(data->yuv_image[j]); } XCloseDisplay(data->dpy); return 0; } static const AVOption options[] = { { "window_title", "set X11 window title", OFFSET(window_title), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, AV_OPT_FLAG_ENCODING_PARAM }, { NULL }, }; static const AVClass x11_class = { .class_name = "x11 outdev", .item_name = av_default_item_name, .option = options, .version = LIBAVUTIL_VERSION_INT, }; AVOutputFormat ff_x11_muxer = { .name = "x11", .long_name = NULL_IF_CONFIG_SMALL("x11 output device"), .priv_data_size = sizeof(X11Context), .audio_codec = AV_CODEC_ID_NONE, .video_codec = AV_CODEC_ID_RAWVIDEO, .write_header = x11_write_header, .write_packet = x11_write_packet, .write_trailer = x11_write_trailer, .flags = AVFMT_NOFILE | AVFMT_VARIABLE_FPS | AVFMT_NOTIMESTAMPS, .priv_class = &x11_class, }; .... here's the other modifications: libavdevice/alldevices.c: void avdevice_register_all(void) { ... REGISTER_OUTDEV (X11, x11); ... } libavdevice/Makefile: ... OBJS-$(CONFIG_X11_OUTDEV) += x11.o ffmpeg/config.mak: EXTRALIBS=... -lX11 -lXv ... ffmpeg/config.h: ... #define CONFIG_X11_OUTDEV 1 Thanks, Jeff

7 46

[PATCH] Support playing SMV files.
by Ash Hughes 30 May '13

30 May '13

This patch updates SMV support to display video properly, addressing the issue in the archive (http://thread.gmane.org/gmane.comp.video.ffmpeg.devel/135864/focus=135893) of more than one frame in a single jpeg. This also helps towards ticket 412 (http://ffmpeg.org/trac/ffmpeg/ticket/412) The patch modifies two functions in libavutil/imgutils.c to reuse code and ensure maintainability. The changed functions now call the modified ones with a default extra argument of 0. Not sure if this is the best way to do this, but it works! Signed-off-by: Ash Hughes <ashley.hughes <at> blueyonder.co.uk> --- diff -uNr ffmpeg-vanilla//libavcodec/allcodecs.c ffmpeg//libavcodec/allcodecs.c --- ffmpeg-vanilla//libavcodec/allcodecs.c 2012-10-01 19:34:06.944974579 +0100 +++ ffmpeg//libavcodec/allcodecs.c 2012-10-01 19:36:15.533611881 +0100 @@ -215,6 +215,7 @@ REGISTER_ENCDEC (SGI, sgi); REGISTER_DECODER (SMACKER, smacker); REGISTER_DECODER (SMC, smc); + REGISTER_DECODER (SMVJPEG, smvjpeg); REGISTER_ENCDEC (SNOW, snow); REGISTER_DECODER (SP5X, sp5x); REGISTER_ENCDEC (SUNRAST, sunrast); diff -uNr ffmpeg-vanilla//libavcodec/avcodec.h ffmpeg//libavcodec/avcodec.h --- ffmpeg-vanilla//libavcodec/avcodec.h 2012-10-01 19:34:06.956974647 +0100 +++ ffmpeg//libavcodec/avcodec.h 2012-10-01 19:36:15.537611963 +0100 @@ -282,6 +282,7 @@ AV_CODEC_ID_PAF_VIDEO = MKBETAG('P','A','F','V'), AV_CODEC_ID_AVRN = MKBETAG('A','V','R','n'), AV_CODEC_ID_CPIA = MKBETAG('C','P','I','A'), + AV_CODEC_ID_SMVJPEG, /* various PCM "codecs" */ AV_CODEC_ID_FIRST_AUDIO = 0x10000, ///< A dummy id pointing at the start of audio codecs diff -uNr ffmpeg-vanilla//libavcodec/Makefile ffmpeg//libavcodec/Makefile --- ffmpeg-vanilla//libavcodec/Makefile 2012-10-01 19:34:06.928974504 +0100 +++ ffmpeg//libavcodec/Makefile 2012-10-01 19:36:15.537611963 +0100 @@ -388,6 +388,7 @@ OBJS-$(CONFIG_SMACKAUD_DECODER) += smacker.o OBJS-$(CONFIG_SMACKER_DECODER) += smacker.o OBJS-$(CONFIG_SMC_DECODER) += smc.o +OBJS-$(CONFIG_SMVJPEG_DECODER) += smvjpegdec.o OBJS-$(CONFIG_SNOW_DECODER) += snowdec.o snow.o OBJS-$(CONFIG_SNOW_ENCODER) += snowenc.o snow.o \ h263.o ituh263enc.o diff -uNr ffmpeg-vanilla//libavformat/wav.c ffmpeg//libavformat/wav.c --- ffmpeg-vanilla//libavformat/wav.c 2012-10-01 19:34:06.872974243 +0100 +++ ffmpeg//libavformat/wav.c 2012-10-01 19:41:31.131177230 +0100 @@ -23,6 +23,7 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ +#include "libavcodec/smvjpegdec.h" #include "libavutil/avassert.h" #include "libavutil/dict.h" #include "libavutil/log.h" @@ -53,6 +54,8 @@ int smv_eof; int audio_eof; int ignore_length; + int smv_cur_pt; + int force_decode; } WAVContext; #if CONFIG_WAV_MUXER @@ -506,9 +509,11 @@ avio_r8(pb); vst->id = 1; vst->codec->codec_type = AVMEDIA_TYPE_VIDEO; - vst->codec->codec_id = AV_CODEC_ID_MJPEG; + vst->codec->codec_id = AV_CODEC_ID_SMVJPEG; vst->codec->width = avio_rl24(pb); vst->codec->height = avio_rl24(pb); + vst->codec->extradata_size = sizeof(SMVCodecExtra); + vst->codec->extradata = av_malloc(sizeof(SMVCodecExtra) + FF_INPUT_BUFFER_PADDING_SIZE); size = avio_rl24(pb); wav->smv_data_ofs = avio_tell(pb) + (size - 5) * 3; avio_rl24(pb); @@ -518,6 +523,9 @@ avio_rl24(pb); avio_rl24(pb); wav->smv_frames_per_jpeg = avio_rl24(pb); + ((SMVCodecExtra*)vst->codec->extradata)->frames_per_block = wav->smv_frames_per_jpeg; + wav->smv_cur_pt = 0; + vst->codec->height /= wav->smv_frames_per_jpeg; goto break_loop; case MKTAG('L', 'I', 'S', 'T'): list_type = avio_rl32(pb); @@ -617,9 +625,14 @@ if (ret < 0) goto smv_out; pkt->pos -= 3; - pkt->pts = wav->smv_block * wav->smv_frames_per_jpeg; - wav->smv_block++; + pkt->pts = wav->smv_block * wav->smv_frames_per_jpeg + wav->smv_cur_pt; + wav->smv_cur_pt++; + wav->smv_cur_pt %= wav->smv_frames_per_jpeg; + if (wav->smv_cur_pt == 0) + wav->smv_block++; + pkt->stream_index = 1; + pkt->priv = &wav->force_decode; smv_out: avio_seek(s->pb, old_pos, SEEK_SET); if (ret == AVERROR_EOF) { @@ -678,6 +691,8 @@ else timestamp = av_rescale_q(smv_timestamp, s->streams[1]->time_base, s->streams[0]->time_base); wav->smv_block = smv_timestamp / wav->smv_frames_per_jpeg; + wav->smv_cur_pt = smv_timestamp % wav->smv_frames_per_jpeg; + wav->force_decode = 1; } st = s->streams[0]; diff -uNr ffmpeg-vanilla//libavutil/imgutils.c ffmpeg//libavutil/imgutils.c --- ffmpeg-vanilla//libavutil/imgutils.c 2012-10-01 19:34:06.888974305 +0100 +++ ffmpeg//libavutil/imgutils.c 2012-10-01 19:36:15.541612053 +0100 @@ -235,8 +235,17 @@ const uint8_t *src, int src_linesize, int bytewidth, int height) { + av_image_copy_plane_skip(dst, dst_linesize, src, src_linesize, + bytewidth, height, 0); +} + +void av_image_copy_plane_skip(uint8_t *dst, int dst_linesize, + const uint8_t *src, int src_linesize, + int bytewidth, int height, int nlines) +{ if (!dst || !src) return; + src += (nlines) * src_linesize * height; for (;height > 0; height--) { memcpy(dst, src, bytewidth); dst += dst_linesize; @@ -248,6 +257,14 @@ const uint8_t *src_data[4], const int src_linesizes[4], enum PixelFormat pix_fmt, int width, int height) { + av_image_copy_skip(dst_data, dst_linesizes, src_data, src_linesizes, + pix_fmt, width, height, 0); +} + +void av_image_copy_skip(uint8_t *dst_data[4], int dst_linesizes[4], + const uint8_t *src_data[4], const int src_linesizes[4], + enum PixelFormat pix_fmt, int width, int height, int nlines) +{ const AVPixFmtDescriptor *desc = &av_pix_fmt_descriptors[pix_fmt]; if (desc->flags & PIX_FMT_HWACCEL) @@ -255,9 +272,9 @@ if (desc->flags & PIX_FMT_PAL || desc->flags & PIX_FMT_PSEUDOPAL) { - av_image_copy_plane(dst_data[0], dst_linesizes[0], + av_image_copy_plane_skip(dst_data[0], dst_linesizes[0], src_data[0], src_linesizes[0], - width, height); + width, height, nlines); /* copy the palette */ memcpy(dst_data[1], src_data[1], 4*256); } else { @@ -272,9 +289,9 @@ if (i == 1 || i == 2) { h= -((-height)>>desc->log2_chroma_h); } - av_image_copy_plane(dst_data[i], dst_linesizes[i], + av_image_copy_plane_skip(dst_data[i], dst_linesizes[i], src_data[i], src_linesizes[i], - bwidth, h); + bwidth, h, nlines); } } } diff -uNr ffmpeg-vanilla//libavutil/imgutils.h ffmpeg//libavutil/imgutils.h --- ffmpeg-vanilla//libavutil/imgutils.h 2012-10-01 19:34:06.884974280 +0100 +++ ffmpeg//libavutil/imgutils.h 2012-10-01 19:36:15.541612053 +0100 @@ -107,6 +107,20 @@ int bytewidth, int height); /** + * Copy image plane from src to dst. + * That is, copy "height" number of lines of "bytewidth" bytes each. + * The first byte of each successive line is separated by *_linesize + * bytes. Skips copying the first n lines. + * + * @param dst_linesize linesize for the image plane in dst + * @param src_linesize linesize for the image plane in src + * @param nlines number of lines to skip before copying + */ +void av_image_copy_plane_skip(uint8_t *dst, int dst_linesize, + const uint8_t *src, int src_linesize, + int bytewidth, int height, int nlines); + +/** * Copy image in src_data to dst_data. * * @param dst_linesizes linesizes for the image in dst_data @@ -117,6 +131,17 @@ enum PixelFormat pix_fmt, int width, int height); /** + * Copy image in src_data to dst_data. + * + * @param dst_linesizes linesizes for the image in dst_data + * @param src_linesizes linesizes for the image in src_data + * @param nlines number of lines to skip before copying + */ +void av_image_copy_skip(uint8_t *dst_data[4], int dst_linesizes[4], + const uint8_t *src_data[4], const int src_linesizes[4], + enum PixelFormat pix_fmt, int width, int height, int nlines); + +/** * Setup the data pointers and linesizes based on the specified image * parameters and the provided array. * diff -uNr ffmpeg-vanilla//smvjpegdec.c ffmpeg//smvjpegdec.c --- ffmpeg-vanilla//smvjpegdec.c 1970-01-01 01:00:00.000000000 +0100 +++ ffmpeg//smvjpegdec.c 2012-10-01 19:42:32.295480490 +0100 @@ -0,0 +1,177 @@ +/* + * SMV JPEG decoder + * Copyright (c) 2012 Ash Hughes + * + * This file is part of FFmpeg. + * + * FFmpeg 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. + * + * FFmpeg 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 FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** + * @file + * SMV JPEG decoder. + */ + +// #define DEBUG +#include "avcodec.h" +#include "libavutil/opt.h" +#include "libavutil/imgutils.h" +#include "smvjpegdec.h" +#include "mjpegdec.h" + +int ff_smvjpeg_decode_init(AVCodecContext *avctx); +int ff_smvjpeg_decode_end(AVCodecContext *avctx); +int ff_smvjpeg_decode_frame(AVCodecContext *avctx, + void *data, int *data_size, + AVPacket *avpkt); + +typedef struct SMVJpegDecodeContext { + MJpegDecodeContext jpg; + AVFrame picture[3]; /* pictures array */ + AVCodecContext* avctx[2]; + AVCodec *codec; + int frames_per_jpeg; + enum PixelFormat pix_fmt; +} SMVJpegDecodeContext; + +av_cold int ff_smvjpeg_decode_init(AVCodecContext *avctx) +{ + SMVJpegDecodeContext *s = avctx->priv_data; + SMVCodecExtra* xtra = (SMVCodecExtra*)(avctx->extradata); + + s->frames_per_jpeg = xtra->frames_per_block; + + s->picture[0].reference = s->picture[1].reference = 3; + s->picture[2].reference = 3; + s->jpg.picture_ptr = &s->picture[0]; + + avcodec_get_frame_defaults(&s->picture[1]); + avctx->coded_frame = &s->picture[1]; + s->codec = avcodec_find_decoder(AV_CODEC_ID_MJPEG); + if (!s->codec) + av_log(avctx, AV_LOG_ERROR, "MJPEG codec not found\n"); + + s->avctx[0] = avctx; + s->avctx[1] = avcodec_alloc_context3(s->codec); + + return 0; +} + +int ff_smvjpeg_decode_frame(AVCodecContext *avctx, void *data, int *data_size, + AVPacket *avpkt) +{ + SMVJpegDecodeContext *s = avctx->priv_data; + int ret = 0; + AVFrame* buf_data = &s->picture[2]; + AVFrame* mjpeg_data = &s->picture[0]; + AVFrame* output = data; + int u; + int cur_frame = avpkt->pts % s->frames_per_jpeg; + int* force_decode = (int*)avpkt->priv; + + /* Are we at the start of a block or forced to decode again? + Also call mjpeg if we start on an odd pts and buf_data isn't + allocated yet. */ + if (cur_frame == 0 || *force_decode == 1 || !buf_data->data[0]) { + *force_decode = 0; /* reset */ + /* we can't open or close the codec in init or end so we have + to do it all here. */ + if (avcodec_open2(s->avctx[1], s->codec, NULL) < 0) { + av_log(avctx, AV_LOG_ERROR, "MJPEG codec failed to open\n"); + return -1; + } else { + /* Codec opened, create yet another buffer so the avcodec_close + will not wipe it. */ + ret = s->codec->decode(s->avctx[1], mjpeg_data, data_size, avpkt); + s->pix_fmt = s->avctx[1]->pix_fmt; + buf_data->width = s->avctx[1]->width; + buf_data->height = s->avctx[1]->height; + if (buf_data->data[0]) { + av_freep(&buf_data->data[0]); + } + u = av_image_alloc(buf_data->data, buf_data->linesize, + buf_data->width, buf_data->height, s->pix_fmt, 16); + if (u < 0) { + av_log(avctx, AV_LOG_ERROR, + "could not alloc raw picture buffer\n"); + return -1; + } + av_picture_copy((AVPicture*)&s->picture[2], (AVPicture*)mjpeg_data, + s->pix_fmt, buf_data->width, buf_data->height); + avcodec_close(s->avctx[1]); + } + } else { /*use the last lot... */ + *data_size = sizeof(AVPicture); + } + + avctx->pix_fmt = s->pix_fmt; + avcodec_set_dimensions(avctx, buf_data->width, + buf_data->height / s->frames_per_jpeg); + + if (s->picture[1].data[0]) + avctx->release_buffer(avctx, &s->picture[1]); + if (u = avctx->get_buffer(avctx, &s->picture[1]) < 0) { + av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); + return -1; + } + av_image_copy_skip(&s->picture[1].data, &s->picture[1].linesize, + buf_data->data, buf_data->linesize, avctx->pix_fmt, avctx->width, + avctx->height, cur_frame); + + *output = s->picture[1]; + + return ret; + +} + +av_cold int ff_smvjpeg_decode_end(AVCodecContext *avctx) +{ + SMVJpegDecodeContext *s = avctx->priv_data; + MJpegDecodeContext *jpg = &s->jpg; + + jpg->picture_ptr = NULL; + if (s->picture[1].data[0]) + avctx->release_buffer(avctx, &s->picture[1]); + if (s->picture[2].data[0]) { + av_freep(&s->picture[2].data[0]); + } + av_free(s->avctx[1]); + return 0; +} + +static const AVOption options[] = { + { NULL }, +}; + +static const AVClass smvjpegdec_class = { + .class_name = "SMVJPEG decoder", + .item_name = av_default_item_name, + .option = options, + .version = LIBAVUTIL_VERSION_INT, +}; + +AVCodec ff_smvjpeg_decoder = { + .name = "smvjpeg", + .type = AVMEDIA_TYPE_VIDEO, + .id = AV_CODEC_ID_SMVJPEG, + .priv_data_size = sizeof(SMVJpegDecodeContext), + .init = ff_smvjpeg_decode_init, + .close = ff_smvjpeg_decode_end, + .decode = ff_smvjpeg_decode_frame, + .capabilities = CODEC_CAP_DR1, + .max_lowres = 3, + .long_name = NULL_IF_CONFIG_SMALL("SMV JPEG"), + .priv_class = &smvjpegdec_class, +}; diff -uNr ffmpeg-vanilla//smvjpegdec.h ffmpeg//smvjpegdec.h --- ffmpeg-vanilla//smvjpegdec.h 1970-01-01 01:00:00.000000000 +0100 +++ ffmpeg//smvjpegdec.h 2012-10-01 19:42:32.295480490 +0100 @@ -0,0 +1,35 @@ +/* + * SMV JPEG decoder + * Copyright (c) 2012 Ash Hughes + * + * This file is part of FFmpeg. + * + * FFmpeg 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. + * + * FFmpeg 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 FFmpeg; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** + * @file + * SMV JPEG decoder. + */ + +#ifndef AVCODEC_SMVJPEG_H +#define AVCODEC_SMVJPEG_H + +typedef struct SMVCodecExtra { + int frames_per_block; +} SMVCodecExtra; + +#endif +

5 28

Implementations of fixed point AC3 decoder and 32bit fixed point FFT
by Nedeljko Babic 27 May '13

27 May '13

Hi, Requested changes are made to patch that implements ac3 fixed point decoder and the patch is resubmitted. I am also resubmitting patch with implementation of 32bit fixed point FFT since it is needed for ac3 fixed point decoder to work and it is not reviewed yet. Regards, -Nedeljko

1 4

[PATCH] configure: Enable MinGW-w64's implementation of vsnprintf and pals
by Derek Buitenhuis 24 May '13

24 May '13

As of r5799 in MinGW-w64's trunk, which is he upcoming major version 3, the POSIX-compliant vsnprintf implementation is disabled by default. Enable it for this version. Keep using out own implementation for prior versions, because it is broken in them. Relevant Reference Thread: http://article.gmane.org/gmane.comp.gnu.mingw.w64.general/7133 Signed-off-by: Derek Buitenhuis <derek.buitenhuis(a)gmail.com> --- configure | 2 ++ 1 file changed, 2 insertions(+) diff --git a/configure b/configure index e5f47b0..7be050a 100755 --- a/configure +++ b/configure @@ -3514,6 +3514,8 @@ elif check_header _mingw.h; then __MINGW64_VERSION_MAJOR < 3"; then add_compat msvcrt/snprintf.o add_cflags "-include $source_path/compat/msvcrt/snprintf.h" + elif + add_cppflags -D__USE_MINGW_ANSI_STDIO=1 fi elif check_func_headers stdlib.h _get_doserrno; then libc_type=msvcrt -- 1.7.10.4

3 12

[PATCH] s302m encoder
by Paul B Mahol 18 May '13

18 May '13

From: Darryl Wallace <wallacdj(a)gmail.com> Signed-off-by: Paul B Mahol <onemda(a)gmail.com> --- TODO: proper frame->nb_samples calculation, current one does not follow specification. --- doc/general.texi | 2 +- libavcodec/Makefile | 1 + libavcodec/allcodecs.c | 2 +- libavcodec/s302menc.c | 187 +++++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 190 insertions(+), 2 deletions(-) create mode 100644 libavcodec/s302menc.c diff --git a/doc/general.texi b/doc/general.texi index 39b9360..0b1cade 100644 --- a/doc/general.texi +++ b/doc/general.texi @@ -886,7 +886,7 @@ following image formats are supported: @item Sierra VMD audio @tab @tab X @tab Used in Sierra VMD files. @item Smacker audio @tab @tab X -@item SMPTE 302M AES3 audio @tab @tab X +@item SMPTE 302M AES3 audio @tab X @tab X @item Sonic @tab X @tab X @tab experimental codec @item Sonic lossless @tab X @tab X diff --git a/libavcodec/Makefile b/libavcodec/Makefile index ac342b1..59c756d 100644 --- a/libavcodec/Makefile +++ b/libavcodec/Makefile @@ -372,6 +372,7 @@ OBJS-$(CONFIG_RV30_DECODER) += rv30.o rv34.o rv30dsp.o rv34dsp.o OBJS-$(CONFIG_RV40_DECODER) += rv40.o rv34.o rv34dsp.o rv40dsp.o OBJS-$(CONFIG_SAMI_DECODER) += samidec.o ass.o OBJS-$(CONFIG_S302M_DECODER) += s302m.o +OBJS-$(CONFIG_S302M_ENCODER) += s302menc.o OBJS-$(CONFIG_SANM_DECODER) += sanm.o OBJS-$(CONFIG_SGI_DECODER) += sgidec.o OBJS-$(CONFIG_SGI_ENCODER) += sgienc.o rle.o diff --git a/libavcodec/allcodecs.c b/libavcodec/allcodecs.c index 19a638c..eeb6324 100644 --- a/libavcodec/allcodecs.c +++ b/libavcodec/allcodecs.c @@ -237,7 +237,7 @@ void avcodec_register_all(void) REGISTER_ENCDEC (RV20, rv20); REGISTER_DECODER(RV30, rv30); REGISTER_DECODER(RV40, rv40); - REGISTER_DECODER(S302M, s302m); + REGISTER_ENCDEC (S302M, s302m); REGISTER_DECODER(SANM, sanm); REGISTER_ENCDEC (SGI, sgi); REGISTER_DECODER(SGIRLE, sgirle); diff --git a/libavcodec/s302menc.c b/libavcodec/s302menc.c new file mode 100644 index 0000000..dbfbbff --- /dev/null +++ b/libavcodec/s302menc.c @@ -0,0 +1,187 @@ +/* + * SMPTE 302M encoder + * Copyright (c) 2010, Google, Inc. + * Copyright (c) 2013, Darryl Wallace <wallacdj(a)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 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include "avcodec.h" +#include "internal.h" +#include "put_bits.h" + +#define AES3_HEADER_LEN 4 + +typedef struct S302MEncContext { + uint8_t framing_index; /* Set for even channels on multiple of 192 samples */ +} S302MEncContext; + +static av_cold int s302m_encode_init(AVCodecContext *avctx) +{ + S302MEncContext *s = avctx->priv_data; + + if (avctx->channels & 1 || avctx->channels > 8) { + av_log(avctx, AV_LOG_ERROR, + "Encoding %d channel(s) is not allowed. Only 2, 4, 6 and 8 channels are supported.\n", + avctx->channels); + return AVERROR(EINVAL); + } + + if (avctx->bits_per_coded_sample == 0) { + if (avctx->sample_fmt == AV_SAMPLE_FMT_S32) { + avctx->bits_per_coded_sample = 24; + } else if (avctx->sample_fmt == AV_SAMPLE_FMT_S16) { + avctx->bits_per_coded_sample = 16; + } + } else if (avctx->bits_per_coded_sample == 24 || + avctx->bits_per_coded_sample == 20) { + avctx->sample_fmt = AV_SAMPLE_FMT_S32; + } else if(avctx->bits_per_coded_sample == 16) { + avctx->sample_fmt = AV_SAMPLE_FMT_S16; + } else { + av_log(avctx, AV_LOG_ERROR, + "Unsupported bits per coded sample of %d.\n", + avctx->bits_per_coded_sample); + return AVERROR(EINVAL); + } + + avctx->frame_size = 0; + avctx->bit_rate = 48000 * avctx->channels * + (avctx->bits_per_coded_sample + 4); + s->framing_index = 0; + + return 0; +} + +static int s302m_encode2_frame(AVCodecContext *avctx, AVPacket *avpkt, + const AVFrame *frame, int *got_packet_ptr) +{ + S302MEncContext *s = avctx->priv_data; + const int buf_size = AES3_HEADER_LEN + + (frame->nb_samples * + avctx->channels * + (avctx->bits_per_coded_sample + 4)) / 8; + int ret, c, channels; + uint8_t *o; + PutBitContext pb; + + if ((ret = ff_alloc_packet2(avctx, avpkt, buf_size)) < 0) + return ret; + + o = avpkt->data; + init_put_bits(&pb, o, buf_size * 8); + put_bits(&pb, 16, buf_size - AES3_HEADER_LEN); + put_bits(&pb, 2, (avctx->channels - 2) >> 1); // number of channels + put_bits(&pb, 8, 0); // channel ID + put_bits(&pb, 2, (avctx->bits_per_coded_sample - 16) / 4); // bits per samples (0 = 16bit, 1 = 20bit, 2 = 24bit) + put_bits(&pb, 4, 0); // alignments + flush_put_bits(&pb); + o += AES3_HEADER_LEN; + + if (avctx->bits_per_coded_sample == 24) { + const uint32_t *samples = (uint32_t *)frame->data[0]; + + for (c = 0; c < frame->nb_samples; c++) { + uint8_t vucf = s->framing_index == 0 ? 0x10: 0; + + for (channels = 0; channels < avctx->channels; channels += 2) { + o[0] = ff_reverse[(samples[0] & 0x0000FF00) >> 8]; + o[1] = ff_reverse[(samples[0] & 0x00FF0000) >> 16]; + o[2] = ff_reverse[(samples[0] & 0xFF000000) >> 24]; + o[3] = ff_reverse[(samples[1] & 0x00000F00) >> 4] | vucf; + o[4] = ff_reverse[(samples[1] & 0x000FF000) >> 12]; + o[5] = ff_reverse[(samples[1] & 0x0FF00000) >> 20]; + o[6] = ff_reverse[(samples[1] & 0xF0000000) >> 28]; + o += 7; + samples += 2; + } + + s->framing_index++; + if (s->framing_index >= 192) + s->framing_index = 0; + } + } else if (avctx->bits_per_coded_sample == 20) { + const uint32_t *samples = (uint32_t *)frame->data[0]; + + for (c = 0; c < frame->nb_samples; c++) { + uint8_t vucf = s->framing_index == 0 ? 0x80: 0; + + for (channels = 0; channels < avctx->channels; channels += 2) { + o[0] = ff_reverse[ (samples[0] & 0x000FF000) >> 12]; + o[1] = ff_reverse[ (samples[0] & 0x0FF00000) >> 20]; + o[2] = ff_reverse[((samples[0] & 0xF0000000) >> 28) | vucf]; + o[3] = ff_reverse[ (samples[1] & 0x000FF000) >> 12]; + o[4] = ff_reverse[ (samples[1] & 0x0FF00000) >> 20]; + o[5] = ff_reverse[ (samples[1] & 0xF0000000) >> 28]; + o += 6; + samples += 2; + } + + s->framing_index++; + if (s->framing_index >= 192) + s->framing_index = 0; + } + } else if (avctx->bits_per_coded_sample == 16) { + const uint16_t *samples = (uint16_t *)frame->data[0]; + + for (c = 0; c < frame->nb_samples; c++) { + uint8_t vucf = s->framing_index == 0 ? 0x10 : 0; + + for (channels = 0; channels < avctx->channels; channels += 2) { + o[0] = ff_reverse[ samples[0] & 0xFF]; + o[1] = ff_reverse[(samples[0] & 0xFF00) >> 8]; + o[2] = ff_reverse[(samples[1] & 0x0F) << 4] | vucf; + o[3] = ff_reverse[(samples[1] & 0x0FF0) >> 4]; + o[4] = ff_reverse[(samples[1] & 0xF000) >> 12]; + o += 5; + samples += 2; + + } + + s->framing_index++; + if (s->framing_index >= 192) + s->framing_index = 0; + } + } + + *got_packet_ptr = 1; + return 0; +} + +static const uint64_t s302m_channel_layout[] = { + AV_CH_LAYOUT_STEREO, + AV_CH_LAYOUT_QUAD, + AV_CH_LAYOUT_5POINT1_BACK, + AV_CH_LAYOUT_5POINT1_BACK | AV_CH_LAYOUT_STEREO_DOWNMIX, + 0, +}; + +AVCodec ff_s302m_encoder = { + .name = "s302m", + .type = AVMEDIA_TYPE_AUDIO, + .id = CODEC_ID_S302M, + .priv_data_size = sizeof(S302MEncContext), + .init = s302m_encode_init, + .encode2 = s302m_encode2_frame, + .long_name = NULL_IF_CONFIG_SMALL("SMPTE 302M"), + .sample_fmts = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S32, + AV_SAMPLE_FMT_S16, + AV_SAMPLE_FMT_NONE }, + .capabilities = CODEC_CAP_VARIABLE_FRAME_SIZE, + .supported_samplerates = (const int[]) { 48000, 0 }, + .channel_layouts = s302m_channel_layout, +}; -- 1.7.11.2

3 4

Re: [FFmpeg-devel] a new benchmarking option for ffmpeg - patch 1 of 1
by "René J.V. Bertin" 18 May '13

18 May '13

On Mar 07, 2013, at 10:15, René J.V. Bertin wrote: Just had a look at the macros in libavutil/*/timer.h . At least for x86 and ppc, these use the TSC register (and PPC equivalent). While this is the cheapest and highest resolution timer available, it is not reliable without some additional logic - at least that's what I gathered from reading up on the subject. This register contains a ticker that's linked to the CPU frequency ... which thus has to be taken into account (didn't see that being done) but more importantly, that frequency is typically not constant on modern CPUs. Thus, the STOP_TIMER macro is perfectly write to log information about the number of cycles used. On Mac OS X, the mach_absolute_time() function does read the TSC register (or its PPC equivalent), but when diving into the kernel code one can see that an effort is made to ensure that result return does indeed reflect time, and not simply a CPU frequency ticker. From what I understand, the MS PerformanceCounter does the same thing, as do the Linux clock_gettime functions. I agree that it is a bad idea to duplicate functionality if it can be avoided. I'd probably have modified ppc/timer.h and x86/timer.h if I had discovered their presence (I frankly didn't expect the presence of HR timers which don't seem relevant for video encoding/decoding ... though indeed more so for playback). What do you suggest? Should I move my various init_hr_time and get_hr_time functions to the ppc/timer.h and x86/timer.h ? R PS: what's the BFIN architecture?

2 4

Re: [FFmpeg-devel] [FFmpeg-cvslog] Fix compilation on ARM with android gcc 4.7
by Christophe Gisquet 18 May '13

18 May '13

Hi, (no longer registered on -cvslog, so I'm sending this here) I noticed some time earlier an issue with this code. Indeed, it uses int*, which could be fine. But it seems to me it should be int32_t: it is used as input to int32_to_float_fmul_scalar at some point. The corresponding branch is deep away in my todo list, but here is what I did regarding this: https://github.com/kurosu/libav/commit/5a57bfa1a3024193503be0788a615e5abbe5… (not yet ported to ffmpeg) I don't understand why it didn't cause any issue when sizeof(int)==8. FYI, -- Christophe

2 1