Recherche avancée

Médias (91)

Autres articles (50)

  • Participer à sa documentation

    10 avril 2011

    La documentation est un des travaux les plus importants et les plus contraignants lors de la réalisation d’un outil technique.
    Tout apport extérieur à ce sujet est primordial : la critique de l’existant ; la participation à la rédaction d’articles orientés : utilisateur (administrateur de MediaSPIP ou simplement producteur de contenu) ; développeur ; la création de screencasts d’explication ; la traduction de la documentation dans une nouvelle langue ;
    Pour ce faire, vous pouvez vous inscrire sur (...)

  • MediaSPIP v0.2

    21 juin 2013, par

    MediaSPIP 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, par

    Par 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 (...)

Sur d’autres sites (5683)

  • Error while Creating Videos from images using ffmpeg

    12 octobre 2011, par Rcrd 009

    I am trying to create videos from images sequence. I tried all the below code given in $ff_command variable.

    $path = dirname(__FILE__);
    
$ff_command = "ffmpeg -f image2 -i {$path}/img%03d.jpg video.mpg";
    

    
$ff_command = "ffmpeg -r 10 -b 1800 -i {$path}/img%03d.jpg test1800.mpg";
    

    
$ff_command = "ffmpeg -i {$path}/img%03d.jpg -s 1280x720 -aspect 16:9 -r 24 -vb 20M teste.mp4";
    

    
$ff_command = "ffmpeg -f image2 -i {$path}/img%03d.jpg -vcodec mpeg4 -b 800k video.avi";
    

    
$ff_command = "ffmpeg -f image2 -i {$path}/img%03d.jpg -vcodec libx264 -b 800k video.avi";

    Most of these commands are creating a video file. But when I open that video nothing comes or first image is coming for a split second and nothing after that

    Please let me know what I am doing wrong here

    I noticed that video is too short to see. Is it possible to increase the video duration so that we can see all the images ?

  • Raw PCM 16 bit 8Khz file to GSM_MS (610) conversion using ffmpeg

    20 septembre 2011, par MANN

    I'm trying to convert a raw PCM 8000Hz MONO 16 bit file to GSM_MS (gsm610) encoded file using the ffmpeg. I Have compiled the ffmpeg with libgsm and while executing code I'm able to get the GSM_MS codec. But as of now I'm not able to create a valid gsm_ms file.
    Here is my code...

    void EncodeTest(uint8_t *audioData, size_t audioSize){
    
AVCodecContext  *audioCodec;
    
AVCodec *codec;
    
uint8_t *buf;    int bufSize, frameBytes;
    
__android_log_print(ANDROID_LOG_INFO, DEBUG_TAG,"Lets encode :%u with size %d\n",(int)audioData, (int)audioSize);
    
//Set up audio encoder
    
codec = avcodec_find_encoder(CODEC_ID_GSM_MS);
    

    

    

    
if (codec == NULL){
    
    __android_log_print(ANDROID_LOG_ERROR, DEBUG_TAG,"ERROR:: Unable to find encoder(CODEC_ID_GSM)");
    
    codec = avcodec_find_encoder(CODEC_ID_GSM);
    
    if (codec == NULL){
    
        __android_log_print(ANDROID_LOG_ERROR, DEBUG_TAG,"ERROR:: Unable to find encoder(CODEC_ID_GSM)");
    
        return;
    
    }
    
}
    
audioCodec                  = avcodec_alloc_context();
    
audioCodec->channels        = 1;
    
audioCodec->sample_rate     = 8000;
    
audioCodec->sample_fmt      = SAMPLE_FMT_S16;
    
audioCodec->bit_rate        = 13200;
    
audioCodec->priv_data       = gsm_create();
    
audioCodec->codec_id        = CODEC_ID_GSM_MS;
    
__android_log_print(ANDROID_LOG_INFO, DEBUG_TAG,"audioCodec->codec_id == %d",audioCodec->codec_id);
    
switch(audioCodec->codec_id) {
    
    case CODEC_ID_GSM:
    
        audioCodec->frame_size = GSM_FRAME_SIZE;
    
        audioCodec->block_align = GSM_BLOCK_SIZE;
    
        int one = 1;
    
        gsm_option(audioCodec->priv_data, GSM_OPT_WAV49, &one);
    
        break;
    
    case CODEC_ID_GSM_MS: {
    
        int one = 1;
    
        gsm_option(audioCodec->priv_data, GSM_OPT_WAV49, &one);
    
        audioCodec->frame_size = 2*GSM_FRAME_SIZE;
    
        audioCodec->block_align = GSM_MS_BLOCK_SIZE;
    
    }
    
}
    
audioCodec->coded_frame= avcodec_alloc_frame();
    
audioCodec->coded_frame->key_frame= 1;
    
audioCodec->time_base       = (AVRational){1,  audioCodec->sample_rate};
    
audioCodec->codec_type      = CODEC_TYPE_AUDIO;
    

    
if (avcodec_open(audioCodec, codec) < 0){
    
    __android_log_print(ANDROID_LOG_ERROR, DEBUG_TAG,"ERROR:: Unable to avcodec_open");
    
    return;
    
}
    

    
bufSize     = FF_MIN_BUFFER_SIZE;
    
buf         = (uint8_t *)malloc(bufSize);
    
if (buf == NULL) return;
    

    

    
//frameBytes = audioCodec->frame_size * audioCodec->channels * 2;
    
//audioCodec->frame_size = 160;
    
frameBytes = audioCodec->frame_size * audioCodec->channels * 2;
    

    
 //frameBytes = buf_size * input_sample_size / output_sample_size;
    
//frameBytes = 160;//audioSize * 8000 / 13000;
    

    

    

    
FILE *fileWrite = fopen(FILE_NAME,"w+b");
    
if(NULL == fileWrite){
    
    __android_log_print(ANDROID_LOG_ERROR, DEBUG_TAG,"ERROR:: Unable to open file for reading.");
    
}
    
/*Write wave header*/
    
WriteWav(fileWrite, 127920);/*Just for test*/
    

    
/*Lets encode raw packet and write into file after header.*/
    
__android_log_print(ANDROID_LOG_INFO, DEBUG_TAG,"Lets Encode Actual Bytes");
    
int nChunckSize = 0;
    
while (audioSize >= frameBytes)
    
{
    
    int packetSize;
    

    
    packetSize = avcodec_encode_audio(audioCodec, buf, bufSize, (short *)audioData);
    
    if(packetSize < 0){
    
         __android_log_print(ANDROID_LOG_ERROR, DEBUG_TAG,"Encoder returned -ve data, %d bytes of data\n", packetSize);
    
    }
    
    __android_log_print(ANDROID_LOG_INFO, DEBUG_TAG,"Consumed Bytes: %d  and encoded Bytes:%d\n", packetSize,bufSize);
    
    nChunckSize += packetSize;
    

    

    
    audioData += 160;
    
    audioSize -= 160;
    

    
    if(NULL != fileWrite){
    
        fwrite(buf, 1,packetSize, fileWrite);
    
    }
    
    else{
    
        __android_log_print(ANDROID_LOG_ERROR, DEBUG_TAG,"Unable to open file for writting... NULL");
    
    }
    
}
    
if(NULL != fileWrite){
    
    fclose(fileWrite);
    
}
    
__android_log_print(ANDROID_LOG_INFO, DEBUG_TAG,"----- Done with nChunckSize: %d --- ",nChunckSize);
    
 __android_log_print(ANDROID_LOG_INFO, DEBUG_TAG,"*****************************");
    
wavReadnDisplayHeader(FILE_NAME);
    
__android_log_print(ANDROID_LOG_INFO, DEBUG_TAG,"*****************************");
    
wavReadnDisplayHeader("/sdcard/Voicemail2.wav");

    } code here

  • "undefined reference to " when calling ffmpeg1.2.1 in Cplusplus using ANDROID NDK

    21 mars 2014, par wolfz

    when i call ffmpeg1.2.1 lib in Cplusplus wrapper with android NDK, some symbols cannot be linked ,the errors occur when linking as follows. but the other symbols can be linked,why ? how to correct the mistake ?

    SharedLibrary  : libplayer.so
    
/home/mytest/player/jni/lib/DllAvCodec.h:124: error: undefined reference to 'avcodec_string(char*, int, AVCodecContext*, int)'
    
/home/mytest/player/jni/lib/DllAvCodec.h:124: error: undefined reference to 'avcodec_string(char*, int, AVCodecContext*, int)'
    
/home/mytest/player/jni/lib/DllAvCodec.h:124: error: undefined reference to 'avcodec_string(char*, int, AVCodecContext*, int)'
    
/home/mytest/player/jni/lib/DllAvCodec.h:144: error: undefined reference to 'av_free_packet(AVPacket*)'
    
/home/mytest/player/jni/cores/player/Demuxers/DemuxFFmpeg.cpp:248: error: undefined reference to 'av_log_set_callback(void (*)(void*,mytestt*,     std::__va_list))'
    
/home/mytest/player/jni/lib/DllAvCodec.h:144: error: undefined reference to 'av_free_packet(AVPacket*)'
    
/home/mytest/player/jni/cores/player/Demuxers/DemuxFFmpeg.cpp:701: error: undefined reference to 'av_free_packet(AVPacket*)'
    
/home/mytest/player/jni/cores/player/Demuxers/DemuxFFmpeg.cpp:798: error: undefined reference to 'av_free_packet(AVPacket*)'
    
/home/mytest/player/jni/lib/DllAvCodec.h:108: error: undefined reference to 'avcodec_find_decoder(AVCodecID)'
    
clang++: error: linker command failed with exit code 1 (use -v to see invocation)    

    my android.mk is :

    LOCAL_PATH := $(call my-dir)
    
DEFINES += \
    
           -DTARGET_POSIX \
    
           -DTARGET_LINUX \
    
           -D_LINUX \
    
           -DTARGET_ANDROID \
    
           -D__STDC_CONSTANT_MACROS 
    

    
######################################
    
#build ffmpeg prebuilt lib
    
######################################
    
include $(CLEAR_VARS)  
    
LOCAL_MODULE := libavcodec
    
LOCAL_SRC_FILES :=lib/lib/libavcodec.a
    
include $(PREBUILT_STATIC_LIBRARY)
    

    
include $(CLEAR_VARS)  
    
LOCAL_MODULE := libavfilter  
    
LOCAL_SRC_FILES :=lib/lib/libavfilter.a
    
include $(PREBUILT_STATIC_LIBRARY)
    

    
include $(CLEAR_VARS)  
    
LOCAL_MODULE := libavformat  
    
LOCAL_SRC_FILES :=lib/lib/libavformat.a
    
include $(PREBUILT_STATIC_LIBRARY)
    

    
include $(CLEAR_VARS)  
    
LOCAL_MODULE := libavutil  
    
LOCAL_SRC_FILES :=lib/lib/libavutil.a
    
include $(PREBUILT_STATIC_LIBRARY)
    

    
include $(CLEAR_VARS)  
    
LOCAL_MODULE := libpostproc  
    
LOCAL_SRC_FILES :=lib/lib/libpostproc.a
    
include $(PREBUILT_STATIC_LIBRARY)
    

    
include $(CLEAR_VARS)  
    
LOCAL_MODULE := libswresample  
    
LOCAL_SRC_FILES :=lib/lib/libswresample.a
    
include $(PREBUILT_STATIC_LIBRARY)
    

    
include $(CLEAR_VARS)  
    
LOCAL_MODULE := libswscale  
    
LOCAL_SRC_FILES := lib/lib/libswscale.a
    
include $(PREBUILT_STATIC_LIBRARY)
    

    

    
######################################
    
#build lib
    
######################################
    
include $(CLEAR_VARS)
    
LOCAL_MODULE:= player
    
base := $(LOCAL_PATH)
    

    
LOCAL_SRC_FILES += ... #ignore
    

    

    
LOCAL_C_INCLUDES += $(LOCAL_PATH) \
    
            $(LOCAL_PATH)/lib \
    
            $(LOCAL_PATH)/lib/include \
    
            $(LOCAL_PATH)/cores/dvdplayer \
    

    
LOCAL_CPPFLAGS += -Wall -fexceptions $(DEFINES)
    

    
LOCAL_STATIC_LIBRARIES := libavformat libavcodec libavfilter  \
    
                          libavutil libpostproc libswscale libswresample 
    

    
LOCAL_LDLIBS += -llog -lz 
    
LOCAL_LDFLAGS += -L../jni/lib/lib  
    

    
include $(BUILD_SHARED_LIBRARY)

    the DllAvcodec.h is :

    #pragma once
    

    

    
#include "DllAvUtil.h"
    
#include "utils/log.h"
    
#define USE_EXTERNAL_FFMPEG  1
    

    
extern "C" {
    
  #include <libavcodec></libavcodec>avcodec.h>
    
}
    

    
#if LIBAVCODEC_VERSION_MICRO >= 100
    
  #define LIBAVCODEC_FROM_FFMPEG
    
#else
    
  #define LIBAVCODEC_FROM_LIBAV
    
#endif
    

    
#include "threads/SingleLock.h"
    

    
class DllAvCodecInterface
    
{
    
public:
    
  virtual ~DllAvCodecInterface() {}
    
  virtual void avcodec_register_all(void)=0;
    
  virtual void avcodec_flush_buffers(AVCodecContext *avctx)=0;
    
  virtual int avcodec_open2_dont_call(AVCodecContext *avctx, AVCodec *codec, AVDictionary **options)=0;
    
  virtual AVCodec *avcodec_find_decoder(enum CodecID id)=0;
    
  virtual AVCodec *avcodec_find_encoder(enum CodecID id)=0;
    
  virtual int avcodec_close_dont_call(AVCodecContext *avctx)=0;
    
  virtual AVFrame *avcodec_alloc_frame(void)=0;
    
  virtual int avpicture_fill(AVPicture *picture, uint8_t *ptr, PixelFormat pix_fmt, int width, int height)=0;
    
  virtual int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture, int *got_picture_ptr, AVPacket *avpkt)=0;
    
  virtual int avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)=0;
    
  virtual int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int *got_sub_ptr, AVPacket *avpkt)=0;
    
  ///virtual int avcodec_encode_audio(AVCodecContext *avctx, uint8_t *buf, int buf_size, const short *samples)=0;
    
  ///virtual int avcodec_encode_audio2(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)=0;
    
  virtual int avpicture_get_size(PixelFormat pix_fmt, int width, int height)=0;
    
  virtual AVCodecContext *avcodec_alloc_context3(AVCodec *codec)=0;
    
  virtual void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)=0;
    
  virtual void avcodec_get_context_defaults3(AVCodecContext *s, AVCodec *codec)=0;
    
  virtual AVCodecParserContext *av_parser_init(int codec_id)=0;
    
  virtual int av_parser_parse2(AVCodecParserContext *s,AVCodecContext *avctx, uint8_t **poutbuf, int *poutbuf_size,
    
                    const uint8_t *buf, int buf_size,
    
                    int64_t pts, int64_t dts, int64_t pos)=0;
    
  virtual void av_parser_close(AVCodecParserContext *s)=0;
    
  virtual AVBitStreamFilterContext *av_bitstream_filter_init(const char *name)=0;
    
  virtual int av_bitstream_filter_filter(AVBitStreamFilterContext *bsfc,
    
    AVCodecContext *avctx, const char *args,
    
    uint8_t **poutbuf, int *poutbuf_size,
    
    const uint8_t *buf, int buf_size, int keyframe) =0;
    
  virtual void av_bitstream_filter_close(AVBitStreamFilterContext *bsfc) =0;
    
  virtual void avpicture_free(AVPicture *picture)=0;
    
  virtual void av_free_packet(AVPacket *pkt)=0;
    
  virtual int avpicture_alloc(AVPicture *picture, PixelFormat pix_fmt, int width, int height)=0;
    
  virtual enum PixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum PixelFormat *fmt)=0;
    
  virtual int avcodec_default_get_buffer(AVCodecContext *s, AVFrame *pic)=0;
    
  virtual void avcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic)=0;
    
  virtual AVCodec *av_codec_next(AVCodec *c)=0;
    
  virtual int av_dup_packet(AVPacket *pkt)=0;
    
  virtual void av_init_packet(AVPacket *pkt)=0;
    
  virtual int avcodec_fill_audio_frame(AVFrame *frame, int nb_channels, enum AVSampleFormat sample_fmt, const uint8_t *buf, int buf_size, int align) = 0;
    
  virtual void avcodec_free_frame(AVFrame **frame)=0;
    
};
    

    

    
// Use direct layer
    
class DllAvCodec : public DllAvCodecInterface
    
{
    
public:
    
  static CCriticalSection m_critSection;
    

    
  virtual ~DllAvCodec() {}
    
  virtual void avcodec_register_all()
    
  {
    
    CSingleLock lock(DllAvCodec::m_critSection);
    
    ::avcodec_register_all();
    
  }
    
  virtual void avcodec_flush_buffers(AVCodecContext *avctx) { ::avcodec_flush_buffers(avctx); }
    
  virtual int avcodec_open2(AVCodecContext *avctx, AVCodec *codec, AVDictionary **options)
    
  {
    
    CSingleLock lock(DllAvCodec::m_critSection);
    
    return ::avcodec_open2(avctx, codec, options);
    
  }
    
  virtual int avcodec_open2_dont_call(AVCodecContext *avctx, AVCodec *codec, AVDictionary **options) { *(volatile int *)0x0 = 0; return 0; }
    
  virtual int avcodec_close_dont_call(AVCodecContext *avctx) { *(volatile int *)0x0 = 0; return 0; }
    
  virtual AVCodec *avcodec_find_decoder(enum CodecID id) { return ::avcodec_find_decoder(id); }
    
  virtual AVCodec *avcodec_find_encoder(enum CodecID id) { return ::avcodec_find_encoder(id); }
    
  virtual int avcodec_close(AVCodecContext *avctx)
    
  {
    
    CSingleLock lock(DllAvCodec::m_critSection);
    
    return ::avcodec_close(avctx);
    
  }
    
  virtual AVFrame *avcodec_alloc_frame() { return ::avcodec_alloc_frame(); }
    
  virtual int avpicture_fill(AVPicture *picture, uint8_t *ptr, PixelFormat pix_fmt, int width, int height) { return ::avpicture_fill(picture, ptr, pix_fmt, width, height); }
    
  virtual int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture, int *got_picture_ptr, AVPacket *avpkt) { return ::avcodec_decode_video2(avctx, picture, got_picture_ptr, avpkt); }
    
  virtual int avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt) { return ::avcodec_decode_audio4(avctx, frame, got_frame_ptr, avpkt); }
    
  virtual int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int *got_sub_ptr, AVPacket *avpkt) { return ::avcodec_decode_subtitle2(avctx, sub, got_sub_ptr, avpkt); }
    
  ///virtual int avcodec_encode_audio(AVCodecContext *avctx, uint8_t *buf, int buf_size, const short *samples) { return ::avcodec_encode_audio(avctx, buf, buf_size, samples); }
    
  ///virtual int avcodec_encode_audio2(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr) { return ::avcodec_encode_audio2(avctx, avpkt, frame, got_packet_ptr); }
    
  virtual int avpicture_get_size(PixelFormat pix_fmt, int width, int height) { return ::avpicture_get_size(pix_fmt, width, height); }
    
  virtual AVCodecContext *avcodec_alloc_context3(AVCodec *codec) { return ::avcodec_alloc_context3(codec); }
    
  virtual void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode) { ::avcodec_string(buf, buf_size, enc, encode); }
    
  virtual void avcodec_get_context_defaults3(AVCodecContext *s, AVCodec *codec) { ::avcodec_get_context_defaults3(s, codec); }
    

    
  virtual AVCodecParserContext *av_parser_init(int codec_id) { return ::av_parser_init(codec_id); }
    
  virtual int av_parser_parse2(AVCodecParserContext *s,AVCodecContext *avctx, uint8_t **poutbuf, int *poutbuf_size,
    
                    const uint8_t *buf, int buf_size,
    
                    int64_t pts, int64_t dts, int64_t pos)
    
  {
    
    return ::av_parser_parse2(s, avctx, poutbuf, poutbuf_size, buf, buf_size, pts, dts, pos);
    
  }
    
  virtual void av_parser_close(AVCodecParserContext *s) { ::av_parser_close(s); }
    

    
  virtual AVBitStreamFilterContext *av_bitstream_filter_init(const char *name) { return ::av_bitstream_filter_init(name); }
    
  virtual int av_bitstream_filter_filter(AVBitStreamFilterContext *bsfc,
    
    AVCodecContext *avctx, const char *args,
    
    uint8_t **poutbuf, int *poutbuf_size,
    
    const uint8_t *buf, int buf_size, int keyframe) { return ::av_bitstream_filter_filter(bsfc, avctx, args, poutbuf, poutbuf_size, buf, buf_size, keyframe); }
    
  virtual void av_bitstream_filter_close(AVBitStreamFilterContext *bsfc) { ::av_bitstream_filter_close(bsfc); }
    

    
  virtual void avpicture_free(AVPicture *picture) { ::avpicture_free(picture); }
    
  virtual void av_free_packet(AVPacket *pkt) { ::av_free_packet(pkt); }
    
  virtual int avpicture_alloc(AVPicture *picture, PixelFormat pix_fmt, int width, int height) { return ::avpicture_alloc(picture, pix_fmt, width, height); }
    
  virtual int avcodec_default_get_buffer(AVCodecContext *s, AVFrame *pic) { return ::avcodec_default_get_buffer(s, pic); }
    
  virtual void avcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic) { ::avcodec_default_release_buffer(s, pic); }
    
  virtual enum PixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum PixelFormat *fmt) { return ::avcodec_default_get_format(s, fmt); }
    
  virtual AVCodec *av_codec_next(AVCodec *c) { return ::av_codec_next(c); }
    

    
  virtual int av_dup_packet(AVPacket *pkt) { return ::av_dup_packet(pkt); }
    
  virtual void av_init_packet(AVPacket *pkt) { return ::av_init_packet(pkt); }
    
  virtual int avcodec_fill_audio_frame(AVFrame *frame, int nb_channels, enum AVSampleFormat sample_fmt, const uint8_t *buf, int buf_size, int align) { return ::avcodec_fill_audio_frame(frame, nb_channels, sample_fmt, buf, buf_size, align); }
    
  virtual void avcodec_free_frame(AVFrame **frame) { return ::avcodec_free_frame(frame); };
    

    
};

Navigation