Recherche avancée
Autres articles (39)
-
MediaSPIP v0.2
21 juin 2013, parMediaSPIP 0.2 est la première version de MediaSPIP stable.
Sa date de sortie officielle est le 21 juin 2013 et est annoncée ici.
Le fichier zip ici présent contient uniquement les sources de MediaSPIP en version standalone.
Comme pour la version précédente, il est nécessaire d’installer manuellement l’ensemble des dépendances logicielles sur le serveur.
Si vous souhaitez utiliser cette archive pour une installation en mode ferme, il vous faudra également procéder à d’autres modifications (...) -
Mise à disposition des fichiers
14 avril 2011, parPar défaut, lors de son initialisation, MediaSPIP ne permet pas aux visiteurs de télécharger les fichiers qu’ils soient originaux ou le résultat de leur transformation ou encodage. Il permet uniquement de les visualiser.
Cependant, il est possible et facile d’autoriser les visiteurs à avoir accès à ces documents et ce sous différentes formes.
Tout cela se passe dans la page de configuration du squelette. Il vous faut aller dans l’espace d’administration du canal, et choisir dans la navigation (...) -
MediaSPIP version 0.1 Beta
16 avril 2011, parMediaSPIP 0.1 beta est la première version de MediaSPIP décrétée comme "utilisable".
Le fichier zip ici présent contient uniquement les sources de MediaSPIP en version standalone.
Pour avoir une installation fonctionnelle, il est nécessaire d’installer manuellement l’ensemble des dépendances logicielles sur le serveur.
Si vous souhaitez utiliser cette archive pour une installation en mode ferme, il vous faudra également procéder à d’autres modifications (...)
Sur d’autres sites (6355)
-
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


-
Revision 32596 : minuscules et fin pour aujourd’hui
1er novembre 2009, par fil@… — Logminuscules et fin pour aujourd’hui
-
Transcode of H.264 to VP8 using libav* has incorrect frame rate
17 avril 2014, par Kevin WatsonI’ve so far failed to get the correct output frame rate when transcoding H.264 to VP8 with the libav* libraries. I created a functioning encode of Sintel.2010.720p.mkv as WebM (VP8/Vorbis) using a modification of the transcoding.c example in the FFmpeg source. Unfortunately the resulting file is 48 fps unlike the 24 fps of the original and the output of the ffmpeg command I’m trying to mimic.
I noticed ffprobe produces a tbc of double the fps for this and other H.264 videos, while the tbc of the resulting VP8 stream produced by the ffmpeg command is the default 1000. The stock transcoding.c example copies the time base of the decoder to the encoder AVCodecContext, which is 1/48. Running the ffmpeg command through gdb it looks like the time base of the AVCodecContext is set to 1/24, but making that change alone only causes the resulting video to be slowed to twice the duration at 24 fps.
I can create a usable video, but the frame rate doubles. When the output frame rate is the correct 24 fps, the video is smooth but slowed to half speed.
Here is my modification of the example.
/*
* Copyright (c) 2010 Nicolas George
* Copyright (c) 2011 Stefano Sabatini
* Copyright (c) 2014 Andrey Utkin
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
/**
* @file
* API example for demuxing, decoding, filtering, encoding and muxing
* @example doc/examples/transcoding.c
*/
#include <libavcodec></libavcodec>avcodec.h>
#include <libavformat></libavformat>avformat.h>
#include <libavfilter></libavfilter>avfiltergraph.h>
#include <libavfilter></libavfilter>avcodec.h>
#include <libavfilter></libavfilter>buffersink.h>
#include <libavfilter></libavfilter>buffersrc.h>
#include <libavutil></libavutil>opt.h>
#include <libavutil></libavutil>pixdesc.h>
#define STATS_LOG "stats.log"
static AVFormatContext *ifmt_ctx;
static AVFormatContext *ofmt_ctx;
typedef struct FilteringContext {
AVFilterContext *buffersink_ctx;
AVFilterContext *buffersrc_ctx;
AVFilterGraph *filter_graph;
} FilteringContext;
static FilteringContext *filter_ctx;
static int open_input_file(const char *filename) {
int ret;
unsigned int i;
ifmt_ctx = NULL;
if ((ret = avformat_open_input(&ifmt_ctx, filename, NULL, NULL)) < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot open input file\n");
return ret;
}
if ((ret = avformat_find_stream_info(ifmt_ctx, NULL)) < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot find stream information\n");
return ret;
}
for (i = 0; i < ifmt_ctx->nb_streams; i++) {
AVStream *stream;
AVCodecContext *codec_ctx;
stream = ifmt_ctx->streams[i];
codec_ctx = stream->codec;
/* Reencode video & audio and remux subtitles etc. */
if (codec_ctx->codec_type == AVMEDIA_TYPE_VIDEO
|| codec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
/* Open decoder */
ret = avcodec_open2(codec_ctx,
avcodec_find_decoder(codec_ctx->codec_id), NULL);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Failed to open decoder for stream #%u\n", i);
return ret;
}
}
}
av_dump_format(ifmt_ctx, 0, filename, 0);
return 0;
}
static int init_output_context(char* filename) {
int ret;
ofmt_ctx = NULL;
avformat_alloc_output_context2(&ofmt_ctx, NULL, NULL, filename);
if (!ofmt_ctx) {
av_log(NULL, AV_LOG_ERROR, "Could not create output context\n");
return AVERROR_UNKNOWN;
}
return 0;
}
static int init_webm_encoders(int audioBitRate, int crf, int videoMaxBitRate, int threads,
char* quality, int speed, int pass, char* stats) {
AVStream *out_stream;
AVStream *in_stream;
AVCodecContext *dec_ctx, *enc_ctx;
AVCodec *encoder;
int ret;
unsigned int i;
for (i = 0; i < ifmt_ctx->nb_streams; i++) {
in_stream = ifmt_ctx->streams[i];
dec_ctx = in_stream->codec;
if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO || dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
AVDictionary *opts = NULL;
if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
encoder = avcodec_find_encoder(AV_CODEC_ID_VP8);
out_stream = avformat_new_stream(ofmt_ctx, encoder);
if (!out_stream) {
av_log(NULL, AV_LOG_ERROR, "Failed allocating output stream\n");
return AVERROR_UNKNOWN;
}
enc_ctx = out_stream->codec;
enc_ctx->height = dec_ctx->height;
enc_ctx->width = dec_ctx->width;
enc_ctx->sample_aspect_ratio = dec_ctx->sample_aspect_ratio;
/* take first format from list of supported formats */
enc_ctx->pix_fmt = encoder->pix_fmts[0];
/* video time_base can be set to whatever is handy and supported by encoder */
enc_ctx->time_base = dec_ctx->time_base;
/* enc_ctx->time_base.num = 1; */
/* enc_ctx->time_base.den = 24; */
enc_ctx->bit_rate = videoMaxBitRate;
enc_ctx->thread_count = threads;
switch (pass) {
case 1:
enc_ctx->flags |= CODEC_FLAG_PASS1;
break;
case 2:
enc_ctx->flags |= CODEC_FLAG_PASS2;
if (stats) {
enc_ctx->stats_in = stats;
}
break;
}
char crfString[3];
snprintf(crfString, 3, "%d", crf);
av_dict_set(&opts, "crf", crfString, 0);
av_dict_set(&opts, "quality", quality, 0);
char speedString[3];
snprintf(speedString, 3, "%d", speed);
av_dict_set(&opts, "speed", speedString, 0);
} else {
encoder = avcodec_find_encoder(AV_CODEC_ID_VORBIS);
out_stream = avformat_new_stream(ofmt_ctx, encoder);
if (!out_stream) {
av_log(NULL, AV_LOG_ERROR, "Failed allocating output stream\n");
return AVERROR_UNKNOWN;
}
/* in_stream = ifmt_ctx->streams[i]; */
/* dec_ctx = in_stream->codec; */
enc_ctx = out_stream->codec;
/* encoder = out_stream->codec->codec; */
enc_ctx->sample_rate = dec_ctx->sample_rate;
enc_ctx->channel_layout = dec_ctx->channel_layout;
enc_ctx->channels = av_get_channel_layout_nb_channels(enc_ctx->channel_layout);
/* take first format from list of supported formats */
enc_ctx->sample_fmt = encoder->sample_fmts[0];
enc_ctx->time_base = (AVRational){1, enc_ctx->sample_rate};
enc_ctx->bit_rate = audioBitRate;
}
/* Open codec with the set options */
ret = avcodec_open2(enc_ctx, encoder, &opts);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot open video encoder for stream #%u\n", i);
return ret;
}
int unused = av_dict_count(opts);
if (unused > 0) {
av_log(NULL, AV_LOG_WARNING, "%d unused options\n", unused);
}
/* } else if (dec_ctx->codec_type == AVMEDIA_TYPE_UNKNOWN) { */
} else {
av_log(NULL, AV_LOG_FATAL, "Elementary stream #%d is of unknown type, cannot proceed\n", i);
return AVERROR_INVALIDDATA;
} /* else { */
/* /\* if this stream must be remuxed *\/ */
/* ret = avcodec_copy_context(ofmt_ctx->streams[i]->codec, */
/* ifmt_ctx->streams[i]->codec); */
/* if (ret < 0) { */
/* av_log(NULL, AV_LOG_ERROR, "Copying stream context failed\n"); */
/* return ret; */
/* } */
/* } */
if (ofmt_ctx->oformat->flags & AVFMT_GLOBALHEADER)
enc_ctx->flags |= CODEC_FLAG_GLOBAL_HEADER;
}
return 0;
}
static int open_output_file(const char *filename) {
int ret;
av_dump_format(ofmt_ctx, 0, filename, 1);
if (!(ofmt_ctx->oformat->flags & AVFMT_NOFILE)) {
ret = avio_open(&ofmt_ctx->pb, filename, AVIO_FLAG_WRITE);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Could not open output file '%s'", filename);
return ret;
}
}
/* init muxer, write output file header */
ret = avformat_write_header(ofmt_ctx, NULL);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Error occurred when opening output file\n");
return ret;
}
return 0;
}
static int init_filter(FilteringContext* fctx, AVCodecContext *dec_ctx,
AVCodecContext *enc_ctx, const char *filter_spec) {
char args[512];
int ret = 0;
AVFilter *buffersrc = NULL;
AVFilter *buffersink = NULL;
AVFilterContext *buffersrc_ctx = NULL;
AVFilterContext *buffersink_ctx = NULL;
AVFilterInOut *outputs = avfilter_inout_alloc();
AVFilterInOut *inputs = avfilter_inout_alloc();
AVFilterGraph *filter_graph = avfilter_graph_alloc();
if (!outputs || !inputs || !filter_graph) {
ret = AVERROR(ENOMEM);
goto end;
}
if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
buffersrc = avfilter_get_by_name("buffer");
buffersink = avfilter_get_by_name("buffersink");
if (!buffersrc || !buffersink) {
av_log(NULL, AV_LOG_ERROR, "filtering source or sink element not found\n");
ret = AVERROR_UNKNOWN;
goto end;
}
snprintf(args, sizeof(args),
"video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
dec_ctx->width, dec_ctx->height, dec_ctx->pix_fmt,
dec_ctx->time_base.num, dec_ctx->time_base.den,
dec_ctx->sample_aspect_ratio.num,
dec_ctx->sample_aspect_ratio.den);
ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",
args, NULL, filter_graph);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot create buffer source\n");
goto end;
}
ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",
NULL, NULL, filter_graph);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot create buffer sink\n");
goto end;
}
ret = av_opt_set_bin(buffersink_ctx, "pix_fmts",
(uint8_t*)&enc_ctx->pix_fmt, sizeof(enc_ctx->pix_fmt),
AV_OPT_SEARCH_CHILDREN);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot set output pixel format\n");
goto end;
}
} else if (dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
buffersrc = avfilter_get_by_name("abuffer");
buffersink = avfilter_get_by_name("abuffersink");
if (!buffersrc || !buffersink) {
av_log(NULL, AV_LOG_ERROR, "filtering source or sink element not found\n");
ret = AVERROR_UNKNOWN;
goto end;
}
if (!dec_ctx->channel_layout)
dec_ctx->channel_layout =
av_get_default_channel_layout(dec_ctx->channels);
snprintf(args, sizeof(args),
"time_base=%d/%d:sample_rate=%d:sample_fmt=%s:channel_layout=0x%"PRIx64,
dec_ctx->time_base.num, dec_ctx->time_base.den, dec_ctx->sample_rate,
av_get_sample_fmt_name(dec_ctx->sample_fmt),
dec_ctx->channel_layout);
ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",
args, NULL, filter_graph);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot create audio buffer source\n");
goto end;
}
ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",
NULL, NULL, filter_graph);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot create audio buffer sink\n");
goto end;
}
ret = av_opt_set_bin(buffersink_ctx, "sample_fmts",
(uint8_t*)&enc_ctx->sample_fmt, sizeof(enc_ctx->sample_fmt),
AV_OPT_SEARCH_CHILDREN);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot set output sample format\n");
goto end;
}
ret = av_opt_set_bin(buffersink_ctx, "channel_layouts",
(uint8_t*)&enc_ctx->channel_layout,
sizeof(enc_ctx->channel_layout), AV_OPT_SEARCH_CHILDREN);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot set output channel layout\n");
goto end;
}
ret = av_opt_set_bin(buffersink_ctx, "sample_rates",
(uint8_t*)&enc_ctx->sample_rate, sizeof(enc_ctx->sample_rate),
AV_OPT_SEARCH_CHILDREN);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Cannot set output sample rate\n");
goto end;
}
} else {
ret = AVERROR_UNKNOWN;
goto end;
}
/* Endpoints for the filter graph. */
outputs->name = av_strdup("in");
outputs->filter_ctx = buffersrc_ctx;
outputs->pad_idx = 0;
outputs->next = NULL;
inputs->name = av_strdup("out");
inputs->filter_ctx = buffersink_ctx;
inputs->pad_idx = 0;
inputs->next = NULL;
if (!outputs->name || !inputs->name) {
ret = AVERROR(ENOMEM);
goto end;
}
if ((ret = avfilter_graph_parse_ptr(filter_graph, filter_spec,
&inputs, &outputs, NULL)) < 0)
goto end;
if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0)
goto end;
/* Fill FilteringContext */
fctx->buffersrc_ctx = buffersrc_ctx;
fctx->buffersink_ctx = buffersink_ctx;
fctx->filter_graph = filter_graph;
end:
avfilter_inout_free(&inputs);
avfilter_inout_free(&outputs);
return ret;
}
static int init_filters(enum AVCodecID audioCodec) {
const char *filter_spec;
unsigned int i;
int ret;
filter_ctx = av_malloc_array(ifmt_ctx->nb_streams, sizeof(*filter_ctx));
if (!filter_ctx)
return AVERROR(ENOMEM);
for (i = 0; i < ifmt_ctx->nb_streams; i++) {
filter_ctx[i].buffersrc_ctx = NULL;
filter_ctx[i].buffersink_ctx = NULL;
filter_ctx[i].filter_graph = NULL;
/* Skip streams that are neither audio nor video */
if (!(ifmt_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO
|| ifmt_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO))
continue;
if (ifmt_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO)
filter_spec = "null"; /* passthrough (dummy) filter for video */
else
/* TODO: make this more general */
if (audioCodec == AV_CODEC_ID_VORBIS) {
filter_spec = "asetnsamples=n=64";
} else {
/* filter_spec = "null"; /\* passthrough (dummy) filter for audio *\/ */
filter_spec = "fps=24";
/* filter_spec = "settb=expr=1/24"; */
}
ret = init_filter(&filter_ctx[i], ifmt_ctx->streams[i]->codec,
ofmt_ctx->streams[i]->codec, filter_spec);
if (ret)
return ret;
}
return 0;
}
static int encode_write_frame(AVFrame *filt_frame, unsigned int stream_index, int *got_frame) {
int ret;
int got_frame_local;
AVPacket enc_pkt;
int (*enc_func)(AVCodecContext *, AVPacket *, const AVFrame *, int *) =
(ifmt_ctx->streams[stream_index]->codec->codec_type ==
AVMEDIA_TYPE_VIDEO) ? avcodec_encode_video2 : avcodec_encode_audio2;
if (!got_frame)
got_frame = &got_frame_local;
/* av_log(NULL, AV_LOG_INFO, "Encoding frame\n"); */
/* encode filtered frame */
enc_pkt.data = NULL;
enc_pkt.size = 0;
av_init_packet(&enc_pkt);
ret = enc_func(ofmt_ctx->streams[stream_index]->codec, &enc_pkt,
filt_frame, got_frame);
av_frame_free(&filt_frame);
if (ret < 0)
return ret;
if (!(*got_frame))
return 0;
/* prepare packet for muxing */
enc_pkt.stream_index = stream_index;
enc_pkt.dts = av_rescale_q_rnd(enc_pkt.dts,
ofmt_ctx->streams[stream_index]->codec->time_base,
ofmt_ctx->streams[stream_index]->time_base,
AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
enc_pkt.pts = av_rescale_q_rnd(enc_pkt.pts,
ofmt_ctx->streams[stream_index]->codec->time_base,
ofmt_ctx->streams[stream_index]->time_base,
AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
enc_pkt.duration = av_rescale_q(enc_pkt.duration,
ofmt_ctx->streams[stream_index]->codec->time_base,
ofmt_ctx->streams[stream_index]->time_base);
/* av_log(NULL, AV_LOG_DEBUG, "Muxing frame\n"); */
/* mux encoded frame */
ret = av_interleaved_write_frame(ofmt_ctx, &enc_pkt);
return ret;
}
static int filter_encode_write_frame(AVFrame *frame, unsigned int stream_index) {
int ret;
AVFrame *filt_frame;
/* av_log(NULL, AV_LOG_INFO, "Pushing decoded frame to filters\n"); */
/* push the decoded frame into the filtergraph */
ret = av_buffersrc_add_frame_flags(filter_ctx[stream_index].buffersrc_ctx,
frame, 0);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Error while feeding the filtergraph\n");
return ret;
}
/* pull filtered frames from the filtergraph */
while (1) {
filt_frame = av_frame_alloc();
if (!filt_frame) {
ret = AVERROR(ENOMEM);
break;
}
/* av_log(NULL, AV_LOG_INFO, "Pulling filtered frame from filters\n"); */
ret = av_buffersink_get_frame(filter_ctx[stream_index].buffersink_ctx,
filt_frame);
if (ret < 0) {
/* if no more frames for output - returns AVERROR(EAGAIN)
* if flushed and no more frames for output - returns AVERROR_EOF
* rewrite retcode to 0 to show it as normal procedure completion
*/
if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
ret = 0;
av_frame_free(&filt_frame);
break;
}
filt_frame->pict_type = AV_PICTURE_TYPE_NONE;
ret = encode_write_frame(filt_frame, stream_index, NULL);
if (ret < 0)
break;
}
return ret;
}
static int flush_encoder(unsigned int stream_index) {
int ret;
int got_frame;
if (!(ofmt_ctx->streams[stream_index]->codec->codec->capabilities &
CODEC_CAP_DELAY))
return 0;
while (1) {
av_log(NULL, AV_LOG_INFO, "Flushing stream #%u encoder\n", stream_index);
ret = encode_write_frame(NULL, stream_index, &got_frame);
if (ret < 0)
break;
if (!got_frame)
return 0;
}
return ret;
}
static int transcode() {
int ret;
AVPacket packet = { .data = NULL, .size = 0 };
AVFrame *frame = NULL;
enum AVMediaType type;
unsigned int stream_index;
unsigned int i;
int got_frame;
int (*dec_func)(AVCodecContext *, AVFrame *, int *, const AVPacket *);
/* read all packets */
while (1) {
if ((ret = av_read_frame(ifmt_ctx, &packet)) < 0)
break;
stream_index = packet.stream_index;
type = ifmt_ctx->streams[packet.stream_index]->codec->codec_type;
av_log(NULL, AV_LOG_DEBUG, "Demuxer gave frame of stream_index %u\n",
stream_index);
if (filter_ctx[stream_index].filter_graph) {
av_log(NULL, AV_LOG_DEBUG, "Going to reencode&filter the frame\n");
frame = av_frame_alloc();
if (!frame) {
ret = AVERROR(ENOMEM);
break;
}
packet.dts = av_rescale_q_rnd(packet.dts,
ifmt_ctx->streams[stream_index]->time_base,
ifmt_ctx->streams[stream_index]->codec->time_base,
AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
packet.pts = av_rescale_q_rnd(packet.pts,
ifmt_ctx->streams[stream_index]->time_base,
ifmt_ctx->streams[stream_index]->codec->time_base,
AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
dec_func = (type == AVMEDIA_TYPE_VIDEO) ? avcodec_decode_video2 :
avcodec_decode_audio4;
ret = dec_func(ifmt_ctx->streams[stream_index]->codec, frame,
&got_frame, &packet);
if (ret < 0) {
av_frame_free(&frame);
av_log(NULL, AV_LOG_ERROR, "Decoding failed\n");
break;
}
if (got_frame) {
frame->pts = av_frame_get_best_effort_timestamp(frame);
ret = filter_encode_write_frame(frame, stream_index);
av_frame_free(&frame);
if (ret < 0)
goto end;
} else {
av_frame_free(&frame);
}
} else {
/* remux this frame without reencoding */
packet.dts = av_rescale_q_rnd(packet.dts,
ifmt_ctx->streams[stream_index]->time_base,
ofmt_ctx->streams[stream_index]->time_base,
AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
packet.pts = av_rescale_q_rnd(packet.pts,
ifmt_ctx->streams[stream_index]->time_base,
ofmt_ctx->streams[stream_index]->time_base,
AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
ret = av_interleaved_write_frame(ofmt_ctx, &packet);
if (ret < 0)
goto end;
}
av_free_packet(&packet);
}
/* flush filters and encoders */
for (i = 0; i < ifmt_ctx->nb_streams; i++) {
/* flush filter */
if (!filter_ctx[i].filter_graph)
continue;
ret = filter_encode_write_frame(NULL, i);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Flushing filter failed\n");
goto end;
}
/* flush encoder */
ret = flush_encoder(i);
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Flushing encoder failed\n");
goto end;
}
}
av_write_trailer(ofmt_ctx);
// Retrieve and store the first instance of codec statistics
// TODO: less naive, deal with multiple instances of statistics
for (i = 0; i < ofmt_ctx->nb_streams; i++) {
AVCodecContext* codec = ofmt_ctx->streams[i]->codec;
if ((codec->flags & CODEC_FLAG_PASS1) && (codec->stats_out)){
FILE* logfile = fopen(STATS_LOG, "wb");
fprintf(logfile, "%s", codec->stats_out);
if (fclose(logfile) < 0) {
av_log(NULL, AV_LOG_ERROR, "Error closing log file.\n");
}
break;
}
}
av_log(NULL, AV_LOG_INFO, "output duration = %" PRId64 "\n", ofmt_ctx->duration);
end:
av_free_packet(&packet);
av_frame_free(&frame);
for (i = 0; i < ifmt_ctx->nb_streams; i++) {
avcodec_close(ifmt_ctx->streams[i]->codec);
if (ofmt_ctx && ofmt_ctx->nb_streams > i && ofmt_ctx->streams[i] && ofmt_ctx->streams[i]->codec)
avcodec_close(ofmt_ctx->streams[i]->codec);
if (filter_ctx && filter_ctx[i].filter_graph)
avfilter_graph_free(&filter_ctx[i].filter_graph);
}
av_free(filter_ctx);
avformat_close_input(&ifmt_ctx);
if (ofmt_ctx && !(ofmt_ctx->oformat->flags & AVFMT_NOFILE))
avio_close(ofmt_ctx->pb);
avformat_free_context(ofmt_ctx);
if (ret < 0)
av_log(NULL, AV_LOG_ERROR, "Error occurred: %s\n", av_err2str(ret));
return ret ? 1 : 0;
}
int TranscodeToWebM(char* inputPath, char* outputPath, int audioBitRate, int crf, int videoMaxBitRate, int threads,
char* quality, int speed) {
int ret;
unsigned int pass;
char* stats = NULL;
av_register_all();
avfilter_register_all();
for (pass = 1; pass <= 2; pass++) {
if ((ret = open_input_file(inputPath)) < 0)
goto end;
if ((ret = init_output_context(outputPath)) < 0)
goto end;
if (pass == 2) {
size_t stats_length;
if (cmdutils_read_file(STATS_LOG, &stats, &stats_length) < 0) {
av_log(NULL, AV_LOG_ERROR, "Error reading stats file.\n");
break;
}
}
if ((ret = init_webm_encoders(audioBitRate, crf, videoMaxBitRate, threads, quality, speed, pass, stats)) < 0)
goto end;
if ((ret = open_output_file(outputPath)) < 0)
goto end;
if ((ret = init_filters(AV_CODEC_ID_VORBIS)) < 0)
goto end;
if ((ret = transcode()) < 0)
goto end;
}
if (remove(STATS_LOG) != 0) {
av_log(NULL, AV_LOG_ERROR, "Failed to remove %s\n", STATS_LOG);
}
end:
if (ret < 0) {
av_log(NULL, AV_LOG_ERROR, "Error occurred: %s\n", av_err2str(ret));
return ret;
}
return 0;
}Here is the output from the ffmpeg command I am trying to mimic.
ffmpeg version N-62301-g59a5384 Copyright (c) 2000-2014 the FFmpeg developers
built on Apr 9 2014 09:58:44 with gcc 4.8.2 (GCC) 20140206 (prerelease)
configuration: --prefix=/opt/ffmpeg --extra-cflags=-I/opt/x264/include --extra-ldflags=-L/opt/x264/lib --extra-libs=-ldl --enable-gpl --enable-nonfree --enable-libfdk-aac --enable-libopus --enable-libvorbis --enable-libvpx --enable-libx264
libavutil 52. 75.100 / 52. 75.100
libavcodec 55. 58.103 / 55. 58.103
libavformat 55. 36.102 / 55. 36.102
libavdevice 55. 11.100 / 55. 11.100
libavfilter 4. 3.100 / 4. 3.100
libswscale 2. 6.100 / 2. 6.100
libswresample 0. 18.100 / 0. 18.100
libpostproc 52. 3.100 / 52. 3.100
Input #0, matroska,webm, from '/mnt/scratch/test_source/Sintel.2010.720p.mkv':
Metadata:
encoder : libebml v1.0.0 + libmatroska v1.0.0
creation_time : 2011-04-24 17:20:33
Duration: 00:14:48.03, start: 0.000000, bitrate: 6071 kb/s
Chapter #0.0: start 0.000000, end 103.125000
Metadata:
title : Chapter 01
Chapter #0.1: start 103.125000, end 148.667000
Metadata:
title : Chapter 02
Chapter #0.2: start 148.667000, end 349.792000
Metadata:
title : Chapter 03
Chapter #0.3: start 349.792000, end 437.208000
Metadata:
title : Chapter 04
Chapter #0.4: start 437.208000, end 472.075000
Metadata:
title : Chapter 05
Chapter #0.5: start 472.075000, end 678.833000
Metadata:
title : Chapter 06
Chapter #0.6: start 678.833000, end 744.083000
Metadata:
title : Chapter 07
Chapter #0.7: start 744.083000, end 888.032000
Metadata:
title : Chapter 08
Stream #0:0(eng): Video: h264 (High), yuv420p(tv, bt709), 1280x544, SAR 1:1 DAR 40:17, 24 fps, 24 tbr, 1k tbn, 48 tbc
Stream #0:1(eng): Audio: ac3, 48000 Hz, 5.1(side), fltp, 640 kb/s
Metadata:
title : AC3 5.1 @ 640 Kbps
Stream #0:2(ger): Subtitle: subrip
Stream #0:3(eng): Subtitle: subrip
Stream #0:4(spa): Subtitle: subrip
Stream #0:5(fre): Subtitle: subrip
Stream #0:6(ita): Subtitle: subrip
Stream #0:7(dut): Subtitle: subrip
Stream #0:8(pol): Subtitle: subrip
Stream #0:9(por): Subtitle: subrip
Stream #0:10(rus): Subtitle: subrip
Stream #0:11(vie): Subtitle: subrip
[libvpx @ 0x24b74c0] v1.3.0
Output #0, webm, to '/mnt/scratch/test_out/Sintel.2010.720p.script.webm':
Metadata:
encoder : Lavf55.36.102
Chapter #0.0: start 0.000000, end 103.125000
Metadata:
title : Chapter 01
Chapter #0.1: start 103.125000, end 148.667000
Metadata:
title : Chapter 02
Chapter #0.2: start 148.667000, end 349.792000
Metadata:
title : Chapter 03
Chapter #0.3: start 349.792000, end 437.208000
Metadata:
title : Chapter 04
Chapter #0.4: start 437.208000, end 472.075000
Metadata:
title : Chapter 05
Chapter #0.5: start 472.075000, end 678.833000
Metadata:
title : Chapter 06
Chapter #0.6: start 678.833000, end 744.083000
Metadata:
title : Chapter 07
Chapter #0.7: start 744.083000, end 888.032000
Metadata:
title : Chapter 08
Stream #0:0(eng): Video: vp8 (libvpx), yuv420p, 1280x544 [SAR 1:1 DAR 40:17], q=-1--1, pass 2, 60000 kb/s, 1k tbn, 24 tbc
Stream #0:1(eng): Audio: vorbis (libvorbis), 48000 Hz, 5.1(side), fltp, 384 kb/s
Metadata:
title : AC3 5.1 @ 640 Kbps
Stream mapping:
Stream #0:0 -> #0:0 (h264 -> libvpx)
Stream #0:1 -> #0:1 (ac3 -> libvorbis)
Press [q] to stop, [?] for help
frame=21312 fps= 11 q=0.0 Lsize= 567191kB time=00:14:48.01 bitrate=5232.4kbits/s
video:537377kB audio:29266kB subtitle:0kB other streams:0kB global headers:7kB muxing overhead: 0.096885%
Syndiquer tout le site
