Recherche avancée
Médias (1)
-
Rennes Emotion Map 2010-11
19 octobre 2011, par
Mis à jour : Juillet 2013
Langue : français
Type : Texte
Autres articles (66)
-
Les autorisations surchargées par les plugins
27 avril 2010, parMediaspip core
autoriser_auteur_modifier() afin que les visiteurs soient capables de modifier leurs informations sur la page d’auteurs -
HTML5 audio and video support
13 avril 2011, parMediaSPIP uses HTML5 video and audio tags to play multimedia files, taking advantage of the latest W3C innovations supported by modern browsers.
The MediaSPIP player used has been created specifically for MediaSPIP and can be easily adapted to fit in with a specific theme.
For older browsers the Flowplayer flash fallback is used.
MediaSPIP allows for media playback on major mobile platforms with the above (...) -
Support audio et vidéo HTML5
10 avril 2011MediaSPIP utilise les balises HTML5 video et audio pour la lecture de documents multimedia en profitant des dernières innovations du W3C supportées par les navigateurs modernes.
Pour les navigateurs plus anciens, le lecteur flash Flowplayer est utilisé.
Le lecteur HTML5 utilisé a été spécifiquement créé pour MediaSPIP : il est complètement modifiable graphiquement pour correspondre à un thème choisi.
Ces technologies permettent de distribuer vidéo et son à la fois sur des ordinateurs conventionnels (...)
Sur d’autres sites (9514)
-
x264 encoding severe quality loss
1er septembre 2020, par SolskGaerI used this repo to encode a mjpeg stream to a h264 one, but the output is not so good. The stream is a series of screenshot of an iPhone. In the output stream, even the lines between two items in the settings app are gone. How do I improve the output stream quality ?
Here is the code snippet that x264-go use to init an encoder


func NewEncoder(w io.Writer, opts *Options) (e *Encoder, err error) {
 e = &Encoder{}

 e.w = w
 e.pts = 0
 e.opts = opts

 e.csp = x264c.CspI420

 e.nals = make([]*x264c.Nal, 3)
 e.img = NewYCbCr(image.Rect(0, 0, e.opts.Width, e.opts.Height))

 param := x264c.Param{}

 if e.opts.Preset != "" && e.opts.Profile != "" {
 ret := x264c.ParamDefaultPreset(&param, e.opts.Preset, e.opts.Tune)
 if ret < 0 {
 err = fmt.Errorf("x264: invalid preset/tune name")
 return
 }
 } else {
 x264c.ParamDefault(&param)
 }

 param.IWidth = int32(e.opts.Width)
 param.IHeight = int32(e.opts.Height)

 param.ICsp = e.csp
 param.BVfrInput = 0
 param.BRepeatHeaders = 1
 param.BAnnexb = 1

 param.ILogLevel = e.opts.LogLevel

 if e.opts.FrameRate > 0 {
 param.IFpsNum = uint32(e.opts.FrameRate)
 param.IFpsDen = 1

 param.IKeyintMax = int32(e.opts.FrameRate)
 param.BIntraRefresh = 1
 }

 if e.opts.Profile != "" {
 ret := x264c.ParamApplyProfile(&param, e.opts.Profile)
 if ret < 0 {
 err = fmt.Errorf("x264: invalid profile name")
 return
 }
 }

 // Allocate on create instead while encoding
 var picIn x264c.Picture
 ret := x264c.PictureAlloc(&picIn, e.csp, int32(e.opts.Width), int32(e.opts.Height))
 if ret < 0 {
 err = fmt.Errorf("x264: cannot allocate picture")
 return
 }
 e.picIn = picIn
 defer func() {
 // Cleanup if intialization fail
 if err != nil {
 x264c.PictureClean(&picIn)
 }
 }()

 e.e = x264c.EncoderOpen(&param)
 if e.e == nil {
 err = fmt.Errorf("x264: cannot open the encoder")
 return
 }

 ret = x264c.EncoderHeaders(e.e, e.nals, &e.nnals)
 if ret < 0 {
 err = fmt.Errorf("x264: cannot encode headers")
 return
 }

 if ret > 0 {
 b := C.GoBytes(e.nals[0].PPayload, C.int(ret))
 n, er := e.w.Write(b)
 if er != nil {
 err = er
 return
 }

 if int(ret) != n {
 err = fmt.Errorf("x264: error writing headers, size=%d, n=%d", ret, n)
 }
 }

 return
}


and the encoder option is defined as


opts := &x264.Options{
 Width: int(width)/2*2,
 Height: int(height)/2*2,
 FrameRate: 15,
 Tune: "zerolatency",
 Preset: "medium",
 Profile: "baseline",
 LogLevel: x264.LogNone,
 }


And I also used ffmpeg(though the api is pretty old)


package screencast

import (

 /*
 #include 
 #include 
 #include 
 #include 
 #include <libavcodec></libavcodec>avcodec.h>
 #include <libavformat></libavformat>avformat.h>
 #include <libavutil></libavutil>avutil.h>
 #include <libavutil></libavutil>opt.h>
 #include <libavutil></libavutil>channel_layout.h>
 #include <libavutil></libavutil>common.h>
 #include <libavutil></libavutil>imgutils.h>
 #include <libavutil></libavutil>mathematics.h>
 #include <libavutil></libavutil>samplefmt.h>

 typedef struct {
 int w, h;
 int pixfmt;
 char *preset[2];
 char *profile;
 int bitrate;
 int got;
 AVCodec *c;
 AVCodecContext *ctx;
 AVFrame *f;
 AVPacket pkt;
 } h264enc_t;

 static int h264enc_new(h264enc_t *m) {
 m->c = avcodec_find_encoder(AV_CODEC_ID_H264);
 m->ctx = avcodec_alloc_context3(m->c);
 m->ctx->width = m->w;
 m->ctx->height = m->h;
 m->ctx->pix_fmt = m->pixfmt;
 m->ctx->time_base = (AVRational){1,10};
 av_opt_set(m->ctx->priv_data, "preset", "slow", 0);
 av_opt_set(m->ctx->priv_data, "tune", "zerolatency", 0);
 av_opt_set(m->ctx->priv_data, "profile", "baseline", 0);
 av_opt_set(m->ctx->priv_data, "crf", "18.0.", 0);
 m->f = av_frame_alloc();
 m->f->format = m->ctx->pix_fmt;
 m->f->width = m->ctx->width;
 m->f->height = m->ctx->height;
 avcodec_open2(m->ctx, m->c, NULL);
 return av_image_alloc(m->f->data, m->f->linesize, m->ctx->width, m->ctx->height, m->ctx->pix_fmt, 32);
 }

 */
 "C"
 "errors"
 "image"
 "unsafe"
 //"log"
)

type H264Encoder struct {
 m C.h264enc_t
 Header []byte
 Pixfmt image.YCbCrSubsampleRatio
 W, H int
 pts int
}

func NewH264Encoder(w, h int) (m *H264Encoder, err error) {
 m = &H264Encoder{}
 m.m.w = (C.int)(w)
 m.m.h = (C.int)(h)
 m.W = w
 m.H = h
 m.Pixfmt = image.YCbCrSubsampleRatio420
 m.m.pixfmt = C.AV_PIX_FMT_YUV420P
 r := C.h264enc_new(&m.m)
 if int(r) < 0 {
 err = errors.New("open encoder failed")
 return
 }
 return
}

func (m *H264Encoder) Encode(img *image.YCbCr) (data []byte, err error) {
 var f *C.AVFrame
 if img == nil {
 f = nil
 } else {
 if img.SubsampleRatio != m.Pixfmt {
 err = errors.New("image pixfmt not match")
 return
 }
 if img.Rect.Dx() != m.W || img.Rect.Dy() != m.H {
 err = errors.New("image size not match")
 return
 }
 f = m.m.f
 f.data[0] = (*C.uint8_t)(unsafe.Pointer(&img.Y[0]))
 f.data[1] = (*C.uint8_t)(unsafe.Pointer(&img.Cb[0]))
 f.data[2] = (*C.uint8_t)(unsafe.Pointer(&img.Cr[0]))
 f.linesize[0] = (C.int)(img.YStride)
 f.linesize[1] = (C.int)(img.CStride)
 f.linesize[2] = (C.int)(img.CStride)
 }

 C.av_init_packet(&m.m.pkt)
 m.m.pkt.data = nil
 m.m.pkt.size = 0
 f.pts = (C.longlong)(m.pts)
 m.pts++
 r := C.avcodec_encode_video2(m.m.ctx, &m.m.pkt, f, &m.m.got)
 defer C.av_packet_unref(&m.m.pkt)
 if int(r) < 0 {
 err = errors.New("encode failed")
 return
 }
 if m.m.got == 0 {
 err = errors.New("no picture")
 return
 }
 if m.m.pkt.size == 0 {
 err = errors.New("packet size == 0")
 return
 }

 data = make([]byte, m.m.pkt.size)
 C.memcpy(
 unsafe.Pointer(&data[0]),
 unsafe.Pointer(m.m.pkt.data),
 (C.size_t)(m.m.pkt.size),
 )
 return data, nil
}


but got the same output. However, when I use the ffmpeg binary, the result was pretty good, so I guess I set wrong parameters, but I don't know which.
Any suggestion would be appreciated. If you have better way to achieve this, I'll appreciate it.


For your information : I must do this using golang.




-
x264 encoding severe quality loss
1er septembre 2020, par SolskGaerI used this repo to encode a mjpeg stream to a h264 one, but the output is not so good. The stream is a series of screenshot of an iPhone. In the output stream, even the lines between two items in the settings app are gone. How do I improve the output stream quality ?
Here is the code snippet that x264-go use to init an encoder


func NewEncoder(w io.Writer, opts *Options) (e *Encoder, err error) {
 e = &Encoder{}

 e.w = w
 e.pts = 0
 e.opts = opts

 e.csp = x264c.CspI420

 e.nals = make([]*x264c.Nal, 3)
 e.img = NewYCbCr(image.Rect(0, 0, e.opts.Width, e.opts.Height))

 param := x264c.Param{}

 if e.opts.Preset != "" && e.opts.Profile != "" {
 ret := x264c.ParamDefaultPreset(&param, e.opts.Preset, e.opts.Tune)
 if ret < 0 {
 err = fmt.Errorf("x264: invalid preset/tune name")
 return
 }
 } else {
 x264c.ParamDefault(&param)
 }

 param.IWidth = int32(e.opts.Width)
 param.IHeight = int32(e.opts.Height)

 param.ICsp = e.csp
 param.BVfrInput = 0
 param.BRepeatHeaders = 1
 param.BAnnexb = 1

 param.ILogLevel = e.opts.LogLevel

 if e.opts.FrameRate > 0 {
 param.IFpsNum = uint32(e.opts.FrameRate)
 param.IFpsDen = 1

 param.IKeyintMax = int32(e.opts.FrameRate)
 param.BIntraRefresh = 1
 }

 if e.opts.Profile != "" {
 ret := x264c.ParamApplyProfile(&param, e.opts.Profile)
 if ret < 0 {
 err = fmt.Errorf("x264: invalid profile name")
 return
 }
 }

 // Allocate on create instead while encoding
 var picIn x264c.Picture
 ret := x264c.PictureAlloc(&picIn, e.csp, int32(e.opts.Width), int32(e.opts.Height))
 if ret < 0 {
 err = fmt.Errorf("x264: cannot allocate picture")
 return
 }
 e.picIn = picIn
 defer func() {
 // Cleanup if intialization fail
 if err != nil {
 x264c.PictureClean(&picIn)
 }
 }()

 e.e = x264c.EncoderOpen(&param)
 if e.e == nil {
 err = fmt.Errorf("x264: cannot open the encoder")
 return
 }

 ret = x264c.EncoderHeaders(e.e, e.nals, &e.nnals)
 if ret < 0 {
 err = fmt.Errorf("x264: cannot encode headers")
 return
 }

 if ret > 0 {
 b := C.GoBytes(e.nals[0].PPayload, C.int(ret))
 n, er := e.w.Write(b)
 if er != nil {
 err = er
 return
 }

 if int(ret) != n {
 err = fmt.Errorf("x264: error writing headers, size=%d, n=%d", ret, n)
 }
 }

 return
}


and the encoder option is defined as


opts := &x264.Options{
 Width: int(width)/2*2,
 Height: int(height)/2*2,
 FrameRate: 15,
 Tune: "zerolatency",
 Preset: "medium",
 Profile: "baseline",
 LogLevel: x264.LogNone,
 }


And I also used ffmpeg(though the api is pretty old)


package screencast

import (

 /*
 #include 
 #include 
 #include 
 #include 
 #include <libavcodec></libavcodec>avcodec.h>
 #include <libavformat></libavformat>avformat.h>
 #include <libavutil></libavutil>avutil.h>
 #include <libavutil></libavutil>opt.h>
 #include <libavutil></libavutil>channel_layout.h>
 #include <libavutil></libavutil>common.h>
 #include <libavutil></libavutil>imgutils.h>
 #include <libavutil></libavutil>mathematics.h>
 #include <libavutil></libavutil>samplefmt.h>

 typedef struct {
 int w, h;
 int pixfmt;
 char *preset[2];
 char *profile;
 int bitrate;
 int got;
 AVCodec *c;
 AVCodecContext *ctx;
 AVFrame *f;
 AVPacket pkt;
 } h264enc_t;

 static int h264enc_new(h264enc_t *m) {
 m->c = avcodec_find_encoder(AV_CODEC_ID_H264);
 m->ctx = avcodec_alloc_context3(m->c);
 m->ctx->width = m->w;
 m->ctx->height = m->h;
 m->ctx->pix_fmt = m->pixfmt;
 m->ctx->time_base = (AVRational){1,10};
 av_opt_set(m->ctx->priv_data, "preset", "slow", 0);
 av_opt_set(m->ctx->priv_data, "tune", "zerolatency", 0);
 av_opt_set(m->ctx->priv_data, "profile", "baseline", 0);
 av_opt_set(m->ctx->priv_data, "crf", "18.0.", 0);
 m->f = av_frame_alloc();
 m->f->format = m->ctx->pix_fmt;
 m->f->width = m->ctx->width;
 m->f->height = m->ctx->height;
 avcodec_open2(m->ctx, m->c, NULL);
 return av_image_alloc(m->f->data, m->f->linesize, m->ctx->width, m->ctx->height, m->ctx->pix_fmt, 32);
 }

 */
 "C"
 "errors"
 "image"
 "unsafe"
 //"log"
)

type H264Encoder struct {
 m C.h264enc_t
 Header []byte
 Pixfmt image.YCbCrSubsampleRatio
 W, H int
 pts int
}

func NewH264Encoder(w, h int) (m *H264Encoder, err error) {
 m = &H264Encoder{}
 m.m.w = (C.int)(w)
 m.m.h = (C.int)(h)
 m.W = w
 m.H = h
 m.Pixfmt = image.YCbCrSubsampleRatio420
 m.m.pixfmt = C.AV_PIX_FMT_YUV420P
 r := C.h264enc_new(&m.m)
 if int(r) < 0 {
 err = errors.New("open encoder failed")
 return
 }
 return
}

func (m *H264Encoder) Encode(img *image.YCbCr) (data []byte, err error) {
 var f *C.AVFrame
 if img == nil {
 f = nil
 } else {
 if img.SubsampleRatio != m.Pixfmt {
 err = errors.New("image pixfmt not match")
 return
 }
 if img.Rect.Dx() != m.W || img.Rect.Dy() != m.H {
 err = errors.New("image size not match")
 return
 }
 f = m.m.f
 f.data[0] = (*C.uint8_t)(unsafe.Pointer(&img.Y[0]))
 f.data[1] = (*C.uint8_t)(unsafe.Pointer(&img.Cb[0]))
 f.data[2] = (*C.uint8_t)(unsafe.Pointer(&img.Cr[0]))
 f.linesize[0] = (C.int)(img.YStride)
 f.linesize[1] = (C.int)(img.CStride)
 f.linesize[2] = (C.int)(img.CStride)
 }

 C.av_init_packet(&m.m.pkt)
 m.m.pkt.data = nil
 m.m.pkt.size = 0
 f.pts = (C.longlong)(m.pts)
 m.pts++
 r := C.avcodec_encode_video2(m.m.ctx, &m.m.pkt, f, &m.m.got)
 defer C.av_packet_unref(&m.m.pkt)
 if int(r) < 0 {
 err = errors.New("encode failed")
 return
 }
 if m.m.got == 0 {
 err = errors.New("no picture")
 return
 }
 if m.m.pkt.size == 0 {
 err = errors.New("packet size == 0")
 return
 }

 data = make([]byte, m.m.pkt.size)
 C.memcpy(
 unsafe.Pointer(&data[0]),
 unsafe.Pointer(m.m.pkt.data),
 (C.size_t)(m.m.pkt.size),
 )
 return data, nil
}


but got the same output. However, when I use the ffmpeg binary, the result was pretty good, so I guess I set wrong parameters, but I don't know which.
Any suggestion would be appreciated. If you have better way to achieve this, I'll appreciate it.


For your information : I must do this using golang.




-
ffmpeg fix video orientation
22 juillet 2020, par PiTheNumberA video can contain a meta info about the camera orientation. For example iPhone and other phones set this flag if you turn the device. Problem is while some player read this info and rotate the video accordingly, other players do not.



To fix this the video has to be rotated and the meta info needs to be set correctly.



Does ffmpeg provide a fix for this or do I have to go the hard way (Read rotation, rotate, set meta data)


Syndiquer tout le site
