Recherche avancée
Autres articles (68)
-
Websites made with MediaSPIP
2 mai 2011, parThis page lists some websites based on MediaSPIP.
-
Encodage et transformation en formats lisibles sur Internet
10 avril 2011MediaSPIP transforme et ré-encode les documents mis en ligne afin de les rendre lisibles sur Internet et automatiquement utilisables sans intervention du créateur de contenu.
Les vidéos sont automatiquement encodées dans les formats supportés par HTML5 : MP4, Ogv et WebM. La version "MP4" est également utilisée pour le lecteur flash de secours nécessaire aux anciens navigateurs.
Les documents audios sont également ré-encodés dans les deux formats utilisables par HTML5 :MP3 et Ogg. La version "MP3" (...) -
Creating farms of unique websites
13 avril 2011, parMediaSPIP platforms can be installed as a farm, with a single "core" hosted on a dedicated server and used by multiple websites.
This allows (among other things) : implementation costs to be shared between several different projects / individuals rapid deployment of multiple unique sites creation of groups of like-minded sites, making it possible to browse media in a more controlled and selective environment than the major "open" (...)
Sur d’autres sites (6488)
-
sws_scale performance comparison to media players real time resize
14 juillet 2018, par Andrey KatkovWhile playing 4K video user can resize players window - and result image will be scaled smoothly in run time.
On the other hand - program written with libav which reads 4k video file frame by frame and scale it down with sws_scale function do it less effective : it took more time then video duration to resize it.
Why is it so ? Maybe because player fps is less and some frames are skipped - but video still looks smooth ?
-
javax.media.NoDataSinkException
23 novembre 2022, par DivyaI am trying to convert Jpeg images into .mov video file



package com.ecomm.pl4mms.test;

import java.io.*;
import java.util.*;
import java.awt.Dimension;

import javax.media.*;
import javax.media.control.*;
import javax.media.protocol.*;
import javax.media.protocol.DataSource;
import javax.media.datasink.*;
import javax.media.format.VideoFormat;
import javax.media.format.JPEGFormat;

public class JpegImagesToMovie implements ControllerListener, DataSinkListener {

 public boolean doItPath(int width, int height, int frameRate, Vector inFiles, String outputURL) {
 // Check for output file extension.
 if (!outputURL.endsWith(".mov") && !outputURL.endsWith(".MOV")) {
 // System.err.println("The output file extension should end with a
 // .mov extension");
 prUsage();
 }

 // Generate the output media locators.
 MediaLocator oml;

 if ((oml = createMediaLocator("file:" + outputURL)) == null) {
 // System.err.println("Cannot build media locator from: " +
 // outputURL);
 //System.exit(0);
 }

 boolean success = doIt(width, height, frameRate, inFiles, oml);

 System.gc();
 return success;
 }

 public boolean doIt(int width, int height, int frameRate, Vector inFiles, MediaLocator outML) {
 try {
 System.out.println(inFiles.size());
 ImageDataSource ids = new ImageDataSource(width, height, frameRate, inFiles);

 Processor p;

 try {
 // System.err.println("- create processor for the image
 // datasource ...");
 System.out.println("processor");
 p = Manager.createProcessor(ids);
 System.out.println("success");
 } catch (Exception e) {
 // System.err.println("Yikes! Cannot create a processor from the
 // data source.");
 return false;
 }

 p.addControllerListener(this);

 // Put the Processor into configured state so we can set
 // some processing options on the processor.
 p.configure();
 if (!waitForState(p, p.Configured)) {
 System.out.println("Issue configuring");
 // System.err.println("Failed to configure the processor.");
 p.close();
 p.deallocate();
 return false;
 }
 System.out.println("Configured");

 // Set the output content descriptor to QuickTime.
 p.setContentDescriptor(new ContentDescriptor(FileTypeDescriptor.QUICKTIME));
System.out.println(outML);
 // Query for the processor for supported formats.
 // Then set it on the processor.
 TrackControl tcs[] = p.getTrackControls();
 Format f[] = tcs[0].getSupportedFormats();
 System.out.println(f[0].getEncoding());
 if (f == null || f.length <= 0) {
 System.err.println("The mux does not support the input format: " + tcs[0].getFormat());
 p.close();
 p.deallocate();
 return false;
 }

 tcs[0].setFormat(f[0]);

 // System.err.println("Setting the track format to: " + f[0]);

 // We are done with programming the processor. Let's just
 // realize it.
 p.realize();
 if (!waitForState(p, p.Realized)) {
 // System.err.println("Failed to realize the processor.");
 p.close();
 p.deallocate();
 return false;
 }

 // Now, we'll need to create a DataSink.
 DataSink dsink;
 if ((dsink = createDataSink(p, outML)) == null) {
 // System.err.println("Failed to create a DataSink for the given
 // output MediaLocator: " + outML);
 p.close();
 p.deallocate();
 return false;
 }

 dsink.addDataSinkListener(this);
 fileDone = false;

 // System.err.println("start processing...");

 // OK, we can now start the actual transcoding.
 try {
 p.start();
 dsink.start();
 } catch (IOException e) {
 p.close();
 p.deallocate();
 dsink.close();
 // System.err.println("IO error during processing");
 return false;
 }

 // Wait for EndOfStream event.
 waitForFileDone();

 // Cleanup.
 try {
 dsink.close();
 } catch (Exception e) {
 }
 p.removeControllerListener(this);

 // System.err.println("...done processing.");

 p.close();

 return true;
 } catch (NotConfiguredError e) {
 // TODO Auto-generated catch block
 e.printStackTrace();
 }

 return false;
 }

 /**
 * Create the DataSink.
 */
 DataSink createDataSink(Processor p, MediaLocator outML) {
System.out.println("In data sink");
 DataSource ds;

 if ((ds = p.getDataOutput()) == null) {
 System.out.println("Something is really wrong: the processor does not have an output DataSource");
 return null;
 }

 DataSink dsink;

 try {
 System.out.println("- create DataSink for: " + ds.toString()+ds.getContentType());
 dsink = Manager.createDataSink(ds, outML);
 dsink.open();
 System.out.println("Done data sink");
 } catch (Exception e) {
 System.err.println("Cannot create the DataSink: " +e);
 e.printStackTrace();
 return null;
 }

 return dsink;
 }

 Object waitSync = new Object();
 boolean stateTransitionOK = true;

 /**
 * Block until the processor has transitioned to the given state. Return
 * false if the transition failed.
 */
 boolean waitForState(Processor p, int state) {
 synchronized (waitSync) {
 try {
 while (p.getState() < state && stateTransitionOK)
 waitSync.wait();
 } catch (Exception e) {
 }
 }
 return stateTransitionOK;
 }

 /**
 * Controller Listener.
 */
 public void controllerUpdate(ControllerEvent evt) {

 if (evt instanceof ConfigureCompleteEvent || evt instanceof RealizeCompleteEvent
 || evt instanceof PrefetchCompleteEvent) {
 synchronized (waitSync) {
 stateTransitionOK = true;
 waitSync.notifyAll();
 }
 } else if (evt instanceof ResourceUnavailableEvent) {
 synchronized (waitSync) {
 stateTransitionOK = false;
 waitSync.notifyAll();
 }
 } else if (evt instanceof EndOfMediaEvent) {
 evt.getSourceController().stop();
 evt.getSourceController().close();
 }
 }

 Object waitFileSync = new Object();
 boolean fileDone = false;
 boolean fileSuccess = true;

 /**
 * Block until file writing is done.
 */
 boolean waitForFileDone() {
 synchronized (waitFileSync) {
 try {
 while (!fileDone)
 waitFileSync.wait();
 } catch (Exception e) {
 }
 }
 return fileSuccess;
 }

 /**
 * Event handler for the file writer.
 */
 public void dataSinkUpdate(DataSinkEvent evt) {

 if (evt instanceof EndOfStreamEvent) {
 synchronized (waitFileSync) {
 fileDone = true;
 waitFileSync.notifyAll();
 }
 } else if (evt instanceof DataSinkErrorEvent) {
 synchronized (waitFileSync) {
 fileDone = true;
 fileSuccess = false;
 waitFileSync.notifyAll();
 }
 }
 }

 public static void main(String arg[]) {
 try {
 String args[] = { "-w 100 -h 100 -f 100 -o F:\\test.mov F:\\Text69.jpg F:\\Textnew.jpg" };
 if (args.length == 0)
 prUsage();

 // Parse the arguments.
 int i = 0;
 int width = -1, height = -1, frameRate = 1;
 Vector inputFiles = new Vector();
 String outputURL = null;

 while (i < args.length) {

 if (args[i].equals("-w")) {
 i++;
 if (i >= args.length)
 width = new Integer(args[i]).intValue();
 } else if (args[i].equals("-h")) {
 i++;
 if (i >= args.length)
 height = new Integer(args[i]).intValue();
 } else if (args[i].equals("-f")) {
 i++;
 if (i >= args.length)
 frameRate = new Integer(args[i]).intValue();
 } else if (args[i].equals("-o")) {
 System.out.println("in ou");
 i++;
 System.out.println(i);
 if (i >= args.length)
 outputURL = args[i];
 System.out.println(outputURL);
 } else {
 System.out.println("adding"+args[i]);
 inputFiles.addElement(args[i]);
 }
 i++;

 }
 inputFiles.addElement("F:\\Textnew.jpg");
 outputURL = "F:\\test.mov";
 System.out.println(inputFiles.size() + outputURL);
 if (outputURL == null || inputFiles.size() == 0)
 prUsage();

 // Check for output file extension.
 if (!outputURL.endsWith(".mov") && !outputURL.endsWith(".MOV")) {
 System.err.println("The output file extension should end with a .mov extension");
 prUsage();
 }
 width = 100;
 height = 100;
 if (width < 0 || height < 0) {
 System.err.println("Please specify the correct image size.");
 prUsage();
 }

 // Check the frame rate.
 if (frameRate < 1)
 frameRate = 1;

 // Generate the output media locators.
 MediaLocator oml;
 oml = createMediaLocator(outputURL);
 System.out.println("Media" + oml);
 if (oml == null) {
 System.err.println("Cannot build media locator from: " + outputURL);
 // //System.exit(0);
 }
 System.out.println("Before change");
System.out.println(inputFiles.size());
 JpegImagesToMovie imageToMovie = new JpegImagesToMovie();
 boolean status = imageToMovie.doIt(width, height, frameRate, inputFiles, oml);
 System.out.println("Status"+status);
 //System.exit(0);
 } catch (Exception e) {
 // TODO Auto-generated catch block
 e.printStackTrace();
 }
 }

 static void prUsage() {
 System.err.println(
 "Usage: java JpegImagesToMovie -w <width> -h <height> -f -o <output url="url"> <input jpeg="jpeg" file="file" 1="1" /> <input jpeg="jpeg" file="file" 2="2" /> ...");
 //System.exit(-1);
 }

 /**
 * Create a media locator from the given string.
 */
 static MediaLocator createMediaLocator(String url) {
 System.out.println(url);
 MediaLocator ml;

 if (url.indexOf(":") > 0 && (ml = new MediaLocator(url)) != null)
 return ml;

 if (url.startsWith(File.separator)) {
 if ((ml = new MediaLocator("file:" + url)) != null)
 return ml;
 } else {
 String file = "file:" + System.getProperty("user.dir") + File.separator + url;
 if ((ml = new MediaLocator(file)) != null)
 return ml;
 }

 return null;
 }

 ///////////////////////////////////////////////
 //
 // Inner classes.
 ///////////////////////////////////////////////

 /**
 * A DataSource to read from a list of JPEG image files and turn that into a
 * stream of JMF buffers. The DataSource is not seekable or positionable.
 */
 class ImageDataSource extends PullBufferDataSource {

 ImageSourceStream streams[];

 ImageDataSource(int width, int height, int frameRate, Vector images) {
 streams = new ImageSourceStream[1];
 streams[0] = new ImageSourceStream(width, height, frameRate, images);
 }

 public void setLocator(MediaLocator source) {
 }

 public MediaLocator getLocator() {
 return null;
 }

 /**
 * Content type is of RAW since we are sending buffers of video frames
 * without a container format.
 */
 public String getContentType() {
 return ContentDescriptor.RAW;
 }

 public void connect() {
 }

 public void disconnect() {
 }

 public void start() {
 }

 public void stop() {
 }

 /**
 * Return the ImageSourceStreams.
 */
 public PullBufferStream[] getStreams() {
 return streams;
 }

 /**
 * We could have derived the duration from the number of frames and
 * frame rate. But for the purpose of this program, it's not necessary.
 */
 public Time getDuration() {
 return DURATION_UNKNOWN;
 }

 public Object[] getControls() {
 return new Object[0];
 }

 public Object getControl(String type) {
 return null;
 }
 }

 /**
 * The source stream to go along with ImageDataSource.
 */
 class ImageSourceStream implements PullBufferStream {

 Vector images;
 int width, height;
 VideoFormat format;

 int nextImage = 0; // index of the next image to be read.
 boolean ended = false;

 public ImageSourceStream(int width, int height, int frameRate, Vector images) {
 this.width = width;
 this.height = height;
 this.images = images;

 format = new JPEGFormat(new Dimension(width, height), Format.NOT_SPECIFIED, Format.byteArray,
 (float) frameRate, 75, JPEGFormat.DEC_422);
 }

 /**
 * We should never need to block assuming data are read from files.
 */
 public boolean willReadBlock() {
 return false;
 }

 /**
 * This is called from the Processor to read a frame worth of video
 * data.
 */
 public void read(Buffer buf) throws IOException {

 // Check if we've finished all the frames.
 if (nextImage >= images.size()) {
 // We are done. Set EndOfMedia.
 System.err.println("Done reading all images.");
 buf.setEOM(true);
 buf.setOffset(0);
 buf.setLength(0);
 ended = true;
 return;
 }

 String imageFile = (String) images.elementAt(nextImage);
 nextImage++;

 System.err.println(" - reading image file: " + imageFile);

 // Open a random access file for the next image.
 RandomAccessFile raFile;
 raFile = new RandomAccessFile(imageFile, "r");

 byte data[] = null;

 // Check the input buffer type & size.

 if (buf.getData() instanceof byte[])
 data = (byte[]) buf.getData();

 // Check to see the given buffer is big enough for the frame.
 if (data == null || data.length < raFile.length()) {
 data = new byte[(int) raFile.length()];
 buf.setData(data);
 }

 // Read the entire JPEG image from the file.
 raFile.readFully(data, 0, (int) raFile.length());

 System.err.println(" read " + raFile.length() + " bytes.");

 buf.setOffset(0);
 buf.setLength((int) raFile.length());
 buf.setFormat(format);
 buf.setFlags(buf.getFlags() | buf.FLAG_KEY_FRAME);

 // Close the random access file.
 raFile.close();
 }

 /**
 * Return the format of each video frame. That will be JPEG.
 */
 public Format getFormat() {
 return format;
 }

 public ContentDescriptor getContentDescriptor() {
 return new ContentDescriptor(ContentDescriptor.RAW);
 }

 public long getContentLength() {
 return 0;
 }

 public boolean endOfStream() {
 return ended;
 }

 public Object[] getControls() {
 return new Object[0];
 }

 public Object getControl(String type) {
 return null;
 }
 }
}
</output></height></width>


I am getting



Cannot create the DataSink: javax.media.NoDataSinkException: Cannot find a DataSink for: com.sun.media.multiplexer.BasicMux$BasicMuxDataSource@d7b1517
javax.media.NoDataSinkException: Cannot find a DataSink for: com.sun.media.multiplexer.BasicMux$BasicMuxDataSource@d7b1517
 at javax.media.Manager.createDataSink(Manager.java:1894)
 at com.ecomm.pl4mms.test.JpegImagesToMovie.createDataSink(JpegImagesToMovie.java:168)
 at com.ecomm.pl4mms.test.JpegImagesToMovie.doIt(JpegImagesToMovie.java:104)
 at com.ecomm.pl4mms.test.JpegImagesToMovie.main(JpegImagesToMovie.java:330)



Please help me to resolve this and let me what can be the cause of this



I am using java 1.8 and trying to create video with jpeg images and using



javax.media to perform this action. and i followed http://www.oracle.com/technetwork/java/javase/documentation/jpegimagestomovie-176885.html
to write the code


-
Play video using mse (media source extension) in google chrome
23 août 2019, par liyuqihxcI’m working on a project that convert rtsp stream (ffmpeg) and play it on the web page (signalr + mse).
So far it works pretty much as I expected on the latest version of edge and firefox, but not chrome.
here’s the code
public class WebmMediaStreamContext
{
private Process _ffProcess;
private readonly string _cmd;
private byte[] _initSegment;
private Task _readMediaStreamTask;
private CancellationTokenSource _cancellationTokenSource;
private const string _CmdTemplate = "-i {0} -c:v libvpx -tile-columns 4 -frame-parallel 1 -keyint_min 90 -g 90 -f webm -dash 1 pipe:";
public static readonly byte[] ClusterStart = { 0x1F, 0x43, 0xB6, 0x75, 0x01, 0x00, 0x00, 0x00 };
public event EventHandler<clusterreadyeventargs> ClusterReadyEvent;
public WebmMediaStreamContext(string rtspFeed)
{
_cmd = string.Format(_CmdTemplate, rtspFeed);
}
public async Task StartConverting()
{
if (_ffProcess != null)
throw new InvalidOperationException();
_ffProcess = new Process();
_ffProcess.StartInfo = new ProcessStartInfo
{
FileName = "ffmpeg/ffmpeg.exe",
Arguments = _cmd,
UseShellExecute = false,
CreateNoWindow = true,
RedirectStandardOutput = true
};
_ffProcess.Start();
_initSegment = await ParseInitSegmentAndStartReadMediaStream();
}
public byte[] GetInitSegment()
{
return _initSegment;
}
// Find the first cluster， and everything before it is the InitSegment
private async Task ParseInitSegmentAndStartReadMediaStream()
{
Memory<byte> buffer = new byte[10 * 1024];
int length = 0;
while (length != buffer.Length)
{
length += await _ffProcess.StandardOutput.BaseStream.ReadAsync(buffer.Slice(length));
int cluster = buffer.Span.IndexOf(ClusterStart);
if (cluster >= 0)
{
_cancellationTokenSource = new CancellationTokenSource();
_readMediaStreamTask = new Task(() => ReadMediaStreamProc(buffer.Slice(cluster, length - cluster).ToArray(), _cancellationTokenSource.Token), _cancellationTokenSource.Token, TaskCreationOptions.LongRunning);
_readMediaStreamTask.Start();
return buffer.Slice(0, cluster).ToArray();
}
}
throw new InvalidOperationException();
}
private void ReadMoreBytes(Span<byte> buffer)
{
int size = buffer.Length;
while (size > 0)
{
int len = _ffProcess.StandardOutput.BaseStream.Read(buffer.Slice(buffer.Length - size));
size -= len;
}
}
// Parse every single cluster and fire ClusterReadyEvent
private void ReadMediaStreamProc(byte[] bytesRead, CancellationToken cancel)
{
Span<byte> buffer = new byte[5 * 1024 * 1024];
bytesRead.CopyTo(buffer);
int bufferEmptyIndex = bytesRead.Length;
do
{
if (bufferEmptyIndex < ClusterStart.Length + 4)
{
ReadMoreBytes(buffer.Slice(bufferEmptyIndex, 1024));
bufferEmptyIndex += 1024;
}
int clusterDataSize = BitConverter.ToInt32(
buffer.Slice(ClusterStart.Length, 4)
.ToArray()
.Reverse()
.ToArray()
);
int clusterSize = ClusterStart.Length + 4 + clusterDataSize;
if (clusterSize > buffer.Length)
{
byte[] newBuffer = new byte[clusterSize];
buffer.Slice(0, bufferEmptyIndex).CopyTo(newBuffer);
buffer = newBuffer;
}
if (bufferEmptyIndex < clusterSize)
{
ReadMoreBytes(buffer.Slice(bufferEmptyIndex, clusterSize - bufferEmptyIndex));
bufferEmptyIndex = clusterSize;
}
ClusterReadyEvent?.Invoke(this, new ClusterReadyEventArgs(buffer.Slice(0, bufferEmptyIndex).ToArray()));
bufferEmptyIndex = 0;
} while (!cancel.IsCancellationRequested);
}
}
</byte></byte></byte></clusterreadyeventargs>I use ffmpeg to convert the rtsp stream to vp8 WEBM byte stream and parse it to "Init Segment" (ebml head、info、tracks...) and "Media Segment" (cluster)， then send it to browser via signalR
$(function () {
var mediaSource = new MediaSource();
var mimeCodec = 'video/webm; codecs="vp8"';
var video = document.getElementById('video');
mediaSource.addEventListener('sourceopen', callback, false);
function callback(e) {
var sourceBuffer = mediaSource.addSourceBuffer(mimeCodec);
var queue = [];
sourceBuffer.addEventListener('updateend', function () {
if (queue.length === 0) {
return;
}
var base64 = queue[0];
if (base64.length === 0) {
mediaSource.endOfStream();
queue.shift();
return;
} else {
var buffer = new Uint8Array(atob(base64).split("").map(function (c) {
return c.charCodeAt(0);
}));
sourceBuffer.appendBuffer(buffer);
queue.shift();
}
}, false);
var connection = new signalR.HubConnectionBuilder()
.withUrl("/signalr-video")
.configureLogging(signalR.LogLevel.Information)
.build();
connection.start().then(function () {
connection.stream("InitVideoReceive")
.subscribe({
next: function(item) {
if (queue.length === 0 && !!!sourceBuffer.updating) {
var buffer = new Uint8Array(atob(item).split("").map(function (c) {
return c.charCodeAt(0);
}));
sourceBuffer.appendBuffer(buffer);
console.log(blockindex++ + " : " + buffer.byteLength);
} else {
queue.push(item);
}
},
complete: function () {
queue.push('');
},
error: function (err) {
console.error(err);
}
});
});
}
video.src = window.URL.createObjectURL(mediaSource);
})chrome just play the video for 3 5 seconds and then stop for buffering, even though there are plenty of cluster transfered and inserted into SourceBuffer.
here’s the information in chrome ://media-internals/
Player Properties :
render_id: 217
player_id: 1
origin_url: http://localhost:52531/
frame_url: http://localhost:52531/
frame_title: Home Page
url: blob:http://localhost:52531/dcb25d89-9830-40a5-ba88-33c13b5c03eb
info: Selected FFmpegVideoDecoder for video decoding, config: codec: vp8 format: 1 profile: vp8 coded size: [1280,720] visible rect: [0,0,1280,720] natural size: [1280,720] has extra data? false encryption scheme: Unencrypted rotation: 0°
pipeline_state: kSuspended
found_video_stream: true
video_codec_name: vp8
video_dds: false
video_decoder: FFmpegVideoDecoder
duration: unknown
height: 720
width: 1280
video_buffering_state: BUFFERING_HAVE_NOTHING
for_suspended_start: false
pipeline_buffering_state: BUFFERING_HAVE_NOTHING
event: PAUSELog
Timestamp Property Value
00:00:00 00 origin_url http://localhost:52531/
00:00:00 00 frame_url http://localhost:52531/
00:00:00 00 frame_title Home Page
00:00:00 00 url blob:http://localhost:52531/dcb25d89-9830-40a5-ba88-33c13b5c03eb
00:00:00 00 info ChunkDemuxer: buffering by DTS
00:00:00 35 pipeline_state kStarting
00:00:15 213 found_video_stream true
00:00:15 213 video_codec_name vp8
00:00:15 216 video_dds false
00:00:15 216 video_decoder FFmpegVideoDecoder
00:00:15 216 info Selected FFmpegVideoDecoder for video decoding, config: codec: vp8 format: 1 profile: vp8 coded size: [1280,720] visible rect: [0,0,1280,720] natural size: [1280,720] has extra data? false encryption scheme: Unencrypted rotation: 0°
00:00:15 216 pipeline_state kPlaying
00:00:15 213 duration unknown
00:00:16 661 height 720
00:00:16 661 width 1280
00:00:16 665 video_buffering_state BUFFERING_HAVE_ENOUGH
00:00:16 665 for_suspended_start false
00:00:16 665 pipeline_buffering_state BUFFERING_HAVE_ENOUGH
00:00:16 667 pipeline_state kSuspending
00:00:16 670 pipeline_state kSuspended
00:00:52 759 info Effective playback rate changed from 0 to 1
00:00:52 759 event PLAY
00:00:52 759 pipeline_state kResuming
00:00:52 760 video_dds false
00:00:52 760 video_decoder FFmpegVideoDecoder
00:00:52 760 info Selected FFmpegVideoDecoder for video decoding, config: codec: vp8 format: 1 profile: vp8 coded size: [1280,720] visible rect: [0,0,1280,720] natural size: [1280,720] has extra data? false encryption scheme: Unencrypted rotation: 0°
00:00:52 760 pipeline_state kPlaying
00:00:52 793 height 720
00:00:52 793 width 1280
00:00:52 798 video_buffering_state BUFFERING_HAVE_ENOUGH
00:00:52 798 for_suspended_start false
00:00:52 798 pipeline_buffering_state BUFFERING_HAVE_ENOUGH
00:00:56 278 video_buffering_state BUFFERING_HAVE_NOTHING
00:00:56 295 for_suspended_start false
00:00:56 295 pipeline_buffering_state BUFFERING_HAVE_NOTHING
00:01:20 717 event PAUSE
00:01:33 538 event PLAY
00:01:35 94 event PAUSE
00:01:55 561 pipeline_state kSuspending
00:01:55 563 pipeline_state kSuspendedCan someone tell me what’s wrong with my code, or dose chrome require some magic configuration to work ?
Thanks
Please excuse my english :)
Syndiquer tout le site
