"Animated video wallpaper" kurulum hatası

Başlatan nasilolcekbuisler, 18 Eylül 2012 - 21:03:15

« önceki - sonraki »

0 Üyeler ve 1 Ziyaretçi konuyu incelemekte.

nasilolcekbuisler

merhaba

Kurmaya çalıştığım plasma : http://kde-look.org/content/show.php/Animated+Video+Wallpaper?content=112105

kde :Platform Sürümü 4.7.4 (4.7.4)

Aldığım hata iletileri:

cmake . -DCMAKE_INSTALL_PREFIX=`kde4-config --prefix` yazdığımda

linx@linx:~/Downloads/plasma-video-wallpaper$ cmake . -DCMAKE_INSTALL_PREFIX=`kde4-config --prefix`
-- The CXX compiler identification is unknown
CMake Error: your CXX compiler: "CMAKE_CXX_COMPILER-NOTFOUND" was not found.   Please set CMAKE_CXX_COMPILER to a valid compiler path or name.
-- Unable to find libavformat header files!
-- Unable to find libavformat library files!
CMake Error at cmake/modules/Findlibavformat.cmake:40 (message):
  Could not find libavformat!
Call Stack (most recent call first):
  CMakeLists.txt:5 (find_package)


CMake Warning (dev) in CMakeLists.txt:
  No cmake_minimum_required command is present.  A line of code such as

    cmake_minimum_required(VERSION 2.8)

  should be added at the top of the file.  The version specified may be lower
  if you wish to support older CMake versions for this project.  For more
  information run "cmake --help-policy CMP0000".
This warning is for project developers.  Use -Wno-dev to suppress it.

-- Configuring incomplete, errors occurred!


dpkg -l | grep build-essential



ii  build-essential                        11.5ubuntu1                              Informational list of build-essential packages


neyi yanlış yada eksik yapıyorum?


gecegezen

#1
cmake ile ilgili bir hata vermis galiba bunu google yazdığımda buraya gittim. Şunu bir denermisiniz.

sudo apt-get install gcc-c++

pardon ubuntu depolarında gcc-c++ yokmuş. build-essential paketini içindeymiş o. kaynak

sudo apt-get install  build-essential
Yotube kanalım hepinizi beklerim...
https://www.youtube.com/channel/UCsRQPZxNJKZbfpGy6r97nJw

heartsmagic

Hayattan çıkarı olmayanların, ölümden de çıkarı olmayacaktır.
Hayatlarıyla yanlış olanların ölümleriyle doğru olmalarına imkân var mıdır?


Böylece yalan, dünyanın düzenine dönüştürülüyor.

nasilolcekbuisler

Alıntı yapılan: heartsmagic - 19 Eylül 2012 - 01:04:23
cmake paketini kurmayı deneyebilirsin.

cmake paketi kurulu.program merkezi ile en son sürmünü kurdum


Mesaj tekrarı yüzünden mesajınız birleştirildi. Bu mesajın gönderim tarihi : 19 Eylül 2012 - 11:42:00

Alıntı yapılan: gecegezen - 18 Eylül 2012 - 22:55:46


build-essential 11.5 kurulu

if

sudo apt-get update && sudo apt-get upgrade
sudo apt-get install kdelibs5-dev libavformat-dev
yüklemesinden sonra deneyin.

nasilolcekbuisler

#5
Alıntı yapılan: if - 19 Eylül 2012 - 11:55:12
sudo apt-get update && sudo apt-get upgrade
sudo apt-get install kdelibs5-dev libavformat-dev
yüklemesinden sonra deneyin.

dediklerinizi denedim.kurulum için aşağıdaki komut satırını girince paylaştığım ileti çıkıyor.
cmake . -DCMAKE_INSTALL_PREFIX=`kde4-config --prefix`

-- Found components for libavformat
-- libavformat_INCLUDES = /usr/include/libavformat
-- libavformat_LIBRARIES     = /usr/lib/libavformat.so
-- Found components for libavcodec
-- libavcodec_INCLUDES = /usr/include/libavcodec
-- libavcodec_LIBRARIES     = /usr/lib/libavcodec.so
-- Unable to find libswscale header files!
-- Unable to find libswscale library files!
CMake Error at cmake/modules/Findlibswscale.cmake:40 (message):
  Could not find libswscale!
Call Stack (most recent call first):
  CMakeLists.txt:7 (find_package)


CMake Warning (dev) in CMakeLists.txt:
  No cmake_minimum_required command is present.  A line of code such as

    cmake_minimum_required(VERSION 2.8)

  should be added at the top of the file.  The version specified may be lower
  if you wish to support older CMake versions for this project.  For more
  information run "cmake --help-policy CMP0000".
This warning is for project developers.  Use -Wno-dev to suppress it.

-- Configuring incomplete, errors occurred!


cmake 2.8 istiyorum diye uyarı veriyor ama zaten bende ki de2.8.5

ii  cmake                                  2.8.5-1ubuntu1                           cross-platform, open-source make system
ii  cmake-data                             2.8.5-1ubuntu1                           CMake data files (modules, templates and documentation)



if

@nasilolcekbuisler, çıktıyı okuyup ne yapmanız gerektiğini çıkartabilirdiniz aslında. sudo apt-cache search libswscale
[sudo] password for pisi:
libswscale-dev - Development files for libswscale
libswscale2 - Libav video scaling library
libswscale-extra-2 - Libav video software scaling library


sudo apt-get install libswscale-dev

nasilolcekbuisler

şimdi de şu ileti çıkıyor.sürekli böyle mi oluyor derleme işlerinde?yoksa piyango bana mı vurdu?

CMake Error at /usr/share/kde4/apps/cmake/modules/FindPackageHandleStandardArgs.cmake:198 (MESSAGE):
  Could NOT find KDE4Workspace (missing: KDE4Workspace_CONFIG)
Call Stack (most recent call first):
  /usr/share/kde4/apps/cmake/modules/FindKDE4Workspace.cmake:70 (find_package_handle_standard_args)
  CMakeLists.txt:10 (find_package)

if

@nasilolcekbuisler, gerekli kütüphaneler yüklenmedikten sonra benzer hatalar her derlemede alınabilir. Geliştiricinin hangi kütüphanelerin yüklenmesi gerektiğini belirtmesi gerekti.

dpkg -S KDE4Workspace
kdelibs5-dev: /usr/share/kde4/apps/cmake/modules/FindKDE4Workspace.cmake
kde-workspace-dev: /usr/lib/cmake/KDE4Workspace
kde-workspace-dev: /usr/lib/cmake/KDE4Workspace/KDE4WorkspaceConfigVersion.cmake
kde-workspace-dev: /usr/lib/cmake/KDE4Workspace/KDE4WorkspaceLibraryTargets-debian.cmake
kde-workspace-dev: /usr/lib/cmake/KDE4Workspace/KDE4WorkspaceConfig.cmake
kde-workspace-dev: /usr/lib/cmake/KDE4Workspace/KDE4WorkspaceLibraryTargets.cmake


Buna göre sudo apt-get install kde-workspace-dev

nasilolcekbuisler

@if ilgi ve alakana teşekkür ederim.verdiğin cevaplar tam yerinde o basamaktaki hatanın kaynağını buluyor ama.cırt bırt birşeyler çıkıyor. bu sefer make komutunda şu aşağıdaki uzun satırlar çıktı.

from /home/linx/Downloads/plasma-video-wallpaper/vid.cpp:12:
/usr/include/KDE/KNS/../../knewstuff2/engine.h:159:5: UYARI: 'Engine' is deprecated [-Wdeprecated-declarations]
/usr/include/KDE/KNS/../../knewstuff2/engine.h:159:5: UYARI: 'Engine' is deprecated (declared at /usr/include/KDE/KNS/../../knewstuff2/engine.h:43) [-Wdeprecated-declarations]
/usr/include/KDE/KNS/../../knewstuff2/engine.h:159:5: UYARI: 'Engine' is deprecated [-Wdeprecated-declarations]
/home/linx/Downloads/plasma-video-wallpaper/vid.cpp: 'void Tutorial1::Init()' üye fonksiyonunda:
/home/linx/Downloads/plasma-video-wallpaper/vid.cpp:85:6: UYARI: 'int av_open_input_file(AVFormatContext**, const char*, AVInputFormat*, int, AVFormatParameters*)' is deprecated (declared at /usr/include/libavformat/avformat.h:1050) [-Wdeprecated-declarations]
/home/linx/Downloads/plasma-video-wallpaper/vid.cpp:85:99: UYARI: 'int av_open_input_file(AVFormatContext**, const char*, AVInputFormat*, int, AVFormatParameters*)' is deprecated (declared at /usr/include/libavformat/avformat.h:1050) [-Wdeprecated-declarations]
/home/linx/Downloads/plasma-video-wallpaper/vid.cpp:99:51: hata: 'CODEC_TYPE_VIDEO' bu etki alanında bildirilmemiş
/home/linx/Downloads/plasma-video-wallpaper/vid.cpp:120:6: UYARI: 'int avcodec_open(AVCodecContext*, AVCodec*)' is deprecated (declared at /usr/include/libavcodec/avcodec.h:3650) [-Wdeprecated-declarations]
/home/linx/Downloads/plasma-video-wallpaper/vid.cpp:120:36: UYARI: 'int avcodec_open(AVCodecContext*, AVCodec*)' is deprecated (declared at /usr/include/libavcodec/avcodec.h:3650) [-Wdeprecated-declarations]
/home/linx/Downloads/plasma-video-wallpaper/vid.cpp: 'virtual QWidget* Tutorial1::createConfigurationInterface(QWidget*)' üye fonksiyonunda:
/home/linx/Downloads/plasma-video-wallpaper/vid.cpp:265:40: UYARI: işaretli ve işaretsiz tamsayı ifadeler arasında karşılaştırma [-Wsign-compare]
/home/linx/Downloads/plasma-video-wallpaper/vid.cpp: 'virtual void Blaa::run()' üye fonksiyonunda:
/home/linx/Downloads/plasma-video-wallpaper/vid.cpp:379:53: hata: 'avcodec_decode_video' bu etki alanında bildirilmemiş
/home/linx/Downloads/plasma-video-wallpaper/vid.cpp:381:1: UYARI: işaretli ve işaretsiz tamsayı ifadeler arasında karşılaştırma [-Wsign-compare]
/home/linx/Downloads/plasma-video-wallpaper/vid.cpp:384:1: UYARI: işaretli ve işaretsiz tamsayı ifadeler arasında karşılaştırma [-Wsign-compare]
make[2]: *** [CMakeFiles/wallpapervideo.dir/vid.o] Hata 1
make[1]: *** [CMakeFiles/wallpapervideo.dir/all] Hata 2
make: *** [all] Hata 2


eğer yapabileceğimiz birşeyse yardım edersen sevinirim.yoksa bende sıkıldım bu ne yav 4 harflik komuttan 1 sayfa şey çıkarmı :)

if

Bu çıktılardaki hataları geliştiricinin düzeltmesi gerek sanırım. Bakalım, belki çözeriz.

ls /home/linx/Downloads/plasma-video-wallpaper
cat /usr/include/libavformat/avformat.h
ve ./configure --help çıktısına bakayım.

nasilolcekbuisler

ls /home/linx/Downloads/plasma-video-wallpaper


cmake           cmake_install.cmake  cmake_uninstall.cmake  lib       release.py        videoconfig.ui  vid.moc
CMakeCache.txt  CMakeLists.txt       CTestTestfile.cmake    Makefile  ui_videoconfig.h  video.desktop   wallpapervideo_automoc.cpp
CMakeFiles      CMakeTmp             INSTALL                README    vid.cpp           vid.h           wallpapervideo_automoc.cpp.files


cat /usr/include/libavformat/avformat.h

    AVIndexEntry *index_entries; /**< Only used if the format does not
                                    support seeking natively. */
    int nb_index_entries;
    unsigned int index_entries_allocated_size;

    int64_t nb_frames;                 ///< number of frames in this stream if known or 0

    int disposition; /**< AV_DISPOSITION_* bit field */

    AVProbeData probe_data;
#define MAX_REORDER_DELAY 16
    int64_t pts_buffer[MAX_REORDER_DELAY+1];

    /**
     * sample aspect ratio (0 if unknown)
     * - encoding: Set by user.
     * - decoding: Set by libavformat.
     */
    AVRational sample_aspect_ratio;

    AVDictionary *metadata;

    /* Intended mostly for av_read_frame() support. Not supposed to be used by */
    /* external applications; try to use something else if at all possible.    */
    const uint8_t *cur_ptr;
    int cur_len;
    AVPacket cur_pkt;

    // Timestamp generation support:
    /**
     * Timestamp corresponding to the last dts sync point.
     *
     * Initialized when AVCodecParserContext.dts_sync_point >= 0 and
     * a DTS is received from the underlying container. Otherwise set to
     * AV_NOPTS_VALUE by default.
     */
    int64_t reference_dts;

    /**
     * Number of packets to buffer for codec probing
     * NOT PART OF PUBLIC API
     */
#define MAX_PROBE_PACKETS 2500
    int probe_packets;

    /**
     * last packet in packet_buffer for this stream when muxing.
     * used internally, NOT PART OF PUBLIC API, dont read or write from outside of libav*
     */
    struct AVPacketList *last_in_packet_buffer;

    /**
     * Average framerate
     */
    AVRational avg_frame_rate;

    /**
     * Number of frames that have been demuxed during av_find_stream_info()
     */
    int codec_info_nb_frames;

    /**
     * Stream informations used internally by av_find_stream_info()
     */
#define MAX_STD_TIMEBASES (60*12+5)
    struct {
        int64_t last_dts;
        int64_t duration_gcd;
        int duration_count;
        double duration_error[MAX_STD_TIMEBASES];
        int64_t codec_info_duration;
    } *info;
} AVStream;

#define AV_PROGRAM_RUNNING 1

/**
* New fields can be added to the end with minor version bumps.
* Removal, reordering and changes to existing fields require a major
* version bump.
* sizeof(AVProgram) must not be used outside libav*.
*/
typedef struct AVProgram {
    int            id;
    int            flags;
    enum AVDiscard discard;        ///< selects which program to discard and which to feed to the caller
    unsigned int   *stream_index;
    unsigned int   nb_stream_indexes;
    AVDictionary *metadata;
} AVProgram;

#define AVFMTCTX_NOHEADER      0x0001 /**< signal that no header is present
                                         (streams are added dynamically) */

typedef struct AVChapter {
    int id;                 ///< unique ID to identify the chapter
    AVRational time_base;   ///< time base in which the start/end timestamps are specified
    int64_t start, end;     ///< chapter start/end time in time_base units
    AVDictionary *metadata;
} AVChapter;

/**
* Format I/O context.
* New fields can be added to the end with minor version bumps.
* Removal, reordering and changes to existing fields require a major
* version bump.
* sizeof(AVFormatContext) must not be used outside libav*.
*/
typedef struct AVFormatContext {
    const AVClass *av_class; /**< Set by avformat_alloc_context. */
    /* Can only be iformat or oformat, not both at the same time. */
    struct AVInputFormat *iformat;
    struct AVOutputFormat *oformat;
    void *priv_data;
    AVIOContext *pb;
    unsigned int nb_streams;
    AVStream **streams;
    char filename[1024]; /**< input or output filename */
    /* stream info */
    int64_t timestamp;

    int ctx_flags; /**< Format-specific flags, see AVFMTCTX_xx */
    /* private data for pts handling (do not modify directly). */
    /**
     * This buffer is only needed when packets were already buffered but
     * not decoded, for example to get the codec parameters in MPEG
     * streams.
     */
    struct AVPacketList *packet_buffer;

    /**
     * Decoding: position of the first frame of the component, in
     * AV_TIME_BASE fractional seconds. NEVER set this value directly:
     * It is deduced from the AVStream values.
     */
    int64_t start_time;

    /**
     * Decoding: duration of the stream, in AV_TIME_BASE fractional
     * seconds. Only set this value if you know none of the individual stream
     * durations and also dont set any of them. This is deduced from the
     * AVStream values if not set.
     */
    int64_t duration;

    /**
     * decoding: total file size, 0 if unknown
     */
    int64_t file_size;

    /**
     * Decoding: total stream bitrate in bit/s, 0 if not
     * available. Never set it directly if the file_size and the
     * duration are known as Libav can compute it automatically.
     */
    int bit_rate;

    /* av_read_frame() support */
    AVStream *cur_st;

    /* av_seek_frame() support */
    int64_t data_offset; /**< offset of the first packet */

    int mux_rate;
    unsigned int packet_size;
    int preload;
    int max_delay;

#define AVFMT_NOOUTPUTLOOP -1
#define AVFMT_INFINITEOUTPUTLOOP 0
    /**
     * number of times to loop output in formats that support it
     */
    int loop_output;

    int flags;
#define AVFMT_FLAG_GENPTS       0x0001 ///< Generate missing pts even if it requires parsing future frames.
#define AVFMT_FLAG_IGNIDX       0x0002 ///< Ignore index.
#define AVFMT_FLAG_NONBLOCK     0x0004 ///< Do not block when reading packets from input.
#define AVFMT_FLAG_IGNDTS       0x0008 ///< Ignore DTS on frames that contain both DTS & PTS
#define AVFMT_FLAG_NOFILLIN     0x0010 ///< Do not infer any values from other values, just return what is stored in the container
#define AVFMT_FLAG_NOPARSE      0x0020 ///< Do not use AVParsers, you also must set AVFMT_FLAG_NOFILLIN as the fillin code works on frames and no parsing -> no frames. Also seeking to frames can not work if parsing to find frame boundaries has been disabled
#if FF_API_FLAG_RTP_HINT
#define AVFMT_FLAG_RTP_HINT     0x0040 ///< Deprecated, use the -movflags rtphint muxer specific AVOption instead
#endif
#define AVFMT_FLAG_CUSTOM_IO    0x0080 ///< The caller has supplied a custom AVIOContext, don't avio_close() it.

    int loop_input;

    /**
     * decoding: size of data to probe; encoding: unused.
     */
    unsigned int probesize;

    /**
     * Maximum time (in AV_TIME_BASE units) during which the input should
     * be analyzed in av_find_stream_info().
     */
    int max_analyze_duration;

    const uint8_t *key;
    int keylen;

    unsigned int nb_programs;
    AVProgram **programs;

    /**
     * Forced video codec_id.
     * Demuxing: Set by user.
     */
    enum CodecID video_codec_id;

    /**
     * Forced audio codec_id.
     * Demuxing: Set by user.
     */
    enum CodecID audio_codec_id;

    /**
     * Forced subtitle codec_id.
     * Demuxing: Set by user.
     */
    enum CodecID subtitle_codec_id;

    /**
     * Maximum amount of memory in bytes to use for the index of each stream.
     * If the index exceeds this size, entries will be discarded as
     * needed to maintain a smaller size. This can lead to slower or less
     * accurate seeking (depends on demuxer).
     * Demuxers for which a full in-memory index is mandatory will ignore
     * this.
     * muxing  : unused
     * demuxing: set by user
     */
    unsigned int max_index_size;

    /**
     * Maximum amount of memory in bytes to use for buffering frames
     * obtained from realtime capture devices.
     */
    unsigned int max_picture_buffer;

    unsigned int nb_chapters;
    AVChapter **chapters;

    /**
     * Flags to enable debugging.
     */
    int debug;
#define FF_FDEBUG_TS        0x0001

    /**
     * Raw packets from the demuxer, prior to parsing and decoding.
     * This buffer is used for buffering packets until the codec can
     * be identified, as parsing cannot be done without knowing the
     * codec.
     */
    struct AVPacketList *raw_packet_buffer;
    struct AVPacketList *raw_packet_buffer_end;

    struct AVPacketList *packet_buffer_end;

    AVDictionary *metadata;

    /**
     * Remaining size available for raw_packet_buffer, in bytes.
     * NOT PART OF PUBLIC API
     */
#define RAW_PACKET_BUFFER_SIZE 2500000
    int raw_packet_buffer_remaining_size;

    /**
     * Start time of the stream in real world time, in microseconds
     * since the unix epoch (00:00 1st January 1970). That is, pts=0
     * in the stream was captured at this real world time.
     * - encoding: Set by user.
     * - decoding: Unused.
     */
    int64_t start_time_realtime;

    /**
     * decoding: number of frames used to probe fps
     */
    int fps_probe_size;
} AVFormatContext;

typedef struct AVPacketList {
    AVPacket pkt;
    struct AVPacketList *next;
} AVPacketList;

/**
* If f is NULL, returns the first registered input format,
* if f is non-NULL, returns the next registered input format after f
* or NULL if f is the last one.
*/
AVInputFormat  *av_iformat_next(AVInputFormat  *f);

/**
* If f is NULL, returns the first registered output format,
* if f is non-NULL, returns the next registered output format after f
* or NULL if f is the last one.
*/
AVOutputFormat *av_oformat_next(AVOutputFormat *f);

#if FF_API_GUESS_IMG2_CODEC
attribute_deprecated enum CodecID av_guess_image2_codec(const char *filename);
#endif

/* XXX: Use automatic init with either ELF sections or C file parser */
/* modules. */

/* utils.c */
void av_register_input_format(AVInputFormat *format);
void av_register_output_format(AVOutputFormat *format);

/**
* Return the output format in the list of registered output formats
* which best matches the provided parameters, or return NULL if
* there is no match.
*
* @param short_name if non-NULL checks if short_name matches with the
* names of the registered formats
* @param filename if non-NULL checks if filename terminates with the
* extensions of the registered formats
* @param mime_type if non-NULL checks if mime_type matches with the
* MIME type of the registered formats
*/
AVOutputFormat *av_guess_format(const char *short_name,
                                const char *filename,
                                const char *mime_type);

/**
* Guess the codec ID based upon muxer and filename.
*/
enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
                            const char *filename, const char *mime_type,
                            enum AVMediaType type);

/**
* Send a nice hexadecimal dump of a buffer to the specified file stream.
*
* @param f The file stream pointer where the dump should be sent to.
* @param buf buffer
* @param size buffer size
*
* @see av_hex_dump_log, av_pkt_dump2, av_pkt_dump_log2
*/
void av_hex_dump(FILE *f, uint8_t *buf, int size);

/**
* Send a nice hexadecimal dump of a buffer to the log.
*
* @param avcl A pointer to an arbitrary struct of which the first field is a
* pointer to an AVClass struct.
* @param level The importance level of the message, lower values signifying
* higher importance.
* @param buf buffer
* @param size buffer size
*
* @see av_hex_dump, av_pkt_dump2, av_pkt_dump_log2
*/
void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size);

/**
* Send a nice dump of a packet to the specified file stream.
*
* @param f The file stream pointer where the dump should be sent to.
* @param pkt packet to dump
* @param dump_payload True if the payload must be displayed, too.
* @param st AVStream that the packet belongs to
*/
void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st);


/**
* Send a nice dump of a packet to the log.
*
* @param avcl A pointer to an arbitrary struct of which the first field is a
* pointer to an AVClass struct.
* @param level The importance level of the message, lower values signifying
* higher importance.
* @param pkt packet to dump
* @param dump_payload True if the payload must be displayed, too.
* @param st AVStream that the packet belongs to
*/
void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
                      AVStream *st);

#if FF_API_PKT_DUMP
attribute_deprecated void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload);
attribute_deprecated void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt,
                                          int dump_payload);
#endif

/**
* Initialize libavformat and register all the muxers, demuxers and
* protocols. If you do not call this function, then you can select
* exactly which formats you want to support.
*
* @see av_register_input_format()
* @see av_register_output_format()
* @see av_register_protocol()
*/
void av_register_all(void);

/**
* Get the CodecID for the given codec tag tag.
* If no codec id is found returns CODEC_ID_NONE.
*
* @param tags list of supported codec_id-codec_tag pairs, as stored
* in AVInputFormat.codec_tag and AVOutputFormat.codec_tag
*/
enum CodecID av_codec_get_id(const struct AVCodecTag * const *tags, unsigned int tag);

/**
* Get the codec tag for the given codec id id.
* If no codec tag is found returns 0.
*
* @param tags list of supported codec_id-codec_tag pairs, as stored
* in AVInputFormat.codec_tag and AVOutputFormat.codec_tag
*/
unsigned int av_codec_get_tag(const struct AVCodecTag * const *tags, enum CodecID id);

/* media file input */

/**
* Find AVInputFormat based on the short name of the input format.
*/
AVInputFormat *av_find_input_format(const char *short_name);

/**
* Guess the file format.
*
* @param is_opened Whether the file is already opened; determines whether
*                  demuxers with or without AVFMT_NOFILE are probed.
*/
AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened);

/**
* Guess the file format.
*
* @param is_opened Whether the file is already opened; determines whether
*                  demuxers with or without AVFMT_NOFILE are probed.
* @param score_max A probe score larger that this is required to accept a
*                  detection, the variable is set to the actual detection
*                  score afterwards.
*                  If the score is <= AVPROBE_SCORE_MAX / 4 it is recommended
*                  to retry with a larger probe buffer.
*/
AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max);

/**
* Probe a bytestream to determine the input format. Each time a probe returns
* with a score that is too low, the probe buffer size is increased and another
* attempt is made. When the maximum probe size is reached, the input format
* with the highest score is returned.
*
* @param pb the bytestream to probe
* @param fmt the input format is put here
* @param filename the filename of the stream
* @param logctx the log context
* @param offset the offset within the bytestream to probe from
* @param max_probe_size the maximum probe buffer size (zero for default)
* @return 0 in case of success, a negative value corresponding to an
* AVERROR code otherwise
*/
int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
                          const char *filename, void *logctx,
                          unsigned int offset, unsigned int max_probe_size);

#if FF_API_FORMAT_PARAMETERS
/**
* Allocate all the structures needed to read an input stream.
*        This does not open the needed codecs for decoding the stream[s].
* @deprecated use avformat_open_input instead.
*/
attribute_deprecated int av_open_input_stream(AVFormatContext **ic_ptr,
                         AVIOContext *pb, const char *filename,
                         AVInputFormat *fmt, AVFormatParameters *ap);

/**
* Open a media file as input. The codecs are not opened. Only the file
* header (if present) is read.
*
* @param ic_ptr The opened media file handle is put here.
* @param filename filename to open
* @param fmt If non-NULL, force the file format to use.
* @param buf_size optional buffer size (zero if default is OK)
* @param ap Additional parameters needed when opening the file
*           (NULL if default).
* @return 0 if OK, AVERROR_xxx otherwise
*
* @deprecated use avformat_open_input instead.
*/
attribute_deprecated int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
                       AVInputFormat *fmt,
                       int buf_size,
                       AVFormatParameters *ap);
#endif

/**
* Open an input stream and read the header. The codecs are not opened.
* The stream must be closed with av_close_input_file().
*
* @param ps Pointer to user-supplied AVFormatContext (allocated by avformat_alloc_context).
*           May be a pointer to NULL, in which case an AVFormatContext is allocated by this
*           function and written into ps.
*           Note that a user-supplied AVFormatContext will be freed on failure.
* @param filename Name of the stream to open.
* @param fmt If non-NULL, this parameter forces a specific input format.
*            Otherwise the format is autodetected.
* @param options  A dictionary filled with AVFormatContext and demuxer-private options.
*                 On return this parameter will be destroyed and replaced with a dict containing
*                 options that were not found. May be NULL.
*
* @return 0 on success, a negative AVERROR on failure.
*
* @note If you want to use custom IO, preallocate the format context and set its pb field.
*/
int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options);

/**
* Allocate an AVFormatContext.
* avformat_free_context() can be used to free the context and everything
* allocated by the framework within it.
*/
AVFormatContext *avformat_alloc_context(void);

#if FF_API_FORMAT_PARAMETERS
/**
* Read packets of a media file to get stream information. This
* is useful for file formats with no headers such as MPEG. This
* function also computes the real framerate in case of MPEG-2 repeat
* frame mode.
* The logical file position is not changed by this function;
* examined packets may be buffered for later processing.
*
* @param ic media file handle
* @return >=0 if OK, AVERROR_xxx on error
* @todo Let the user decide somehow what information is needed so that
*       we do not waste time getting stuff the user does not need.
*
* @deprecated use avformat_find_stream_info.
*/
int av_find_stream_info(AVFormatContext *ic);
#endif

/**
* Read packets of a media file to get stream information. This
* is useful for file formats with no headers such as MPEG. This
* function also computes the real framerate in case of MPEG-2 repeat
* frame mode.
* The logical file position is not changed by this function;
* examined packets may be buffered for later processing.
*
* @param ic media file handle
* @param options  If non-NULL, an ic.nb_streams long array of pointers to
*                 dictionaries, where i-th member contains options for
*                 codec corresponding to i-th stream.
*                 On return each dictionary will be filled with options that were not found.
* @return >=0 if OK, AVERROR_xxx on error
*
* @note this function isn't guaranteed to open all the codecs, so
*       options being non-empty at return is a perfectly normal behavior.
*
* @todo Let the user decide somehow what information is needed so that
*       we do not waste time getting stuff the user does not need.
*/
int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options);

/**
* Find the "best" stream in the file.
* The best stream is determined according to various heuristics as the most
* likely to be what the user expects.
* If the decoder parameter is non-NULL, av_find_best_stream will find the
* default decoder for the stream's codec; streams for which no decoder can
* be found are ignored.
*
* @param ic                media file handle
* @param type              stream type: video, audio, subtitles, etc.
* @param wanted_stream_nb  user-requested stream number,
*                          or -1 for automatic selection
* @param related_stream    try to find a stream related (eg. in the same
*                          program) to this one, or -1 if none
* @param decoder_ret       if non-NULL, returns the decoder for the
*                          selected stream
* @param flags             flags; none are currently defined
* @return  the non-negative stream number in case of success,
*          AVERROR_STREAM_NOT_FOUND if no stream with the requested type
*          could be found,
*          AVERROR_DECODER_NOT_FOUND if streams were found but no decoder
* @note  If av_find_best_stream returns successfully and decoder_ret is not
*        NULL, then *decoder_ret is guaranteed to be set to a valid AVCodec.
*/
int av_find_best_stream(AVFormatContext *ic,
                        enum AVMediaType type,
                        int wanted_stream_nb,
                        int related_stream,
                        AVCodec **decoder_ret,
                        int flags);

/**
* Read a transport packet from a media file.
*
* This function is obsolete and should never be used.
* Use av_read_frame() instead.
*
* @param s media file handle
* @param pkt is filled
* @return 0 if OK, AVERROR_xxx on error
*/
int av_read_packet(AVFormatContext *s, AVPacket *pkt);

/**
* Return the next frame of a stream.
* This function returns what is stored in the file, and does not validate
* that what is there are valid frames for the decoder. It will split what is
* stored in the file into frames and return one for each call. It will not
* omit invalid data between valid frames so as to give the decoder the maximum
* information possible for decoding.
*
* The returned packet is valid
* until the next av_read_frame() or until av_close_input_file() and
* must be freed with av_free_packet. For video, the packet contains
* exactly one frame. For audio, it contains an integer number of
* frames if each frame has a known fixed size (e.g. PCM or ADPCM
* data). If the audio frames have a variable size (e.g. MPEG audio),
* then it contains one frame.
*
* pkt->pts, pkt->dts and pkt->duration are always set to correct
* values in AVStream.time_base units (and guessed if the format cannot
* provide them). pkt->pts can be AV_NOPTS_VALUE if the video format
* has B-frames, so it is better to rely on pkt->dts if you do not
* decompress the payload.
*
* @return 0 if OK, < 0 on error or end of file
*/
int av_read_frame(AVFormatContext *s, AVPacket *pkt);

/**
* Seek to the keyframe at timestamp.
* 'timestamp' in 'stream_index'.
* @param stream_index If stream_index is (-1), a default
* stream is selected, and timestamp is automatically converted
* from AV_TIME_BASE units to the stream specific time_base.
* @param timestamp Timestamp in AVStream.time_base units
*        or, if no stream is specified, in AV_TIME_BASE units.
* @param flags flags which select direction and seeking mode
* @return >= 0 on success
*/
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp,
                  int flags);

/**
* Seek to timestamp ts.
* Seeking will be done so that the point from which all active streams
* can be presented successfully will be closest to ts and within min/max_ts.
* Active streams are all streams that have AVStream.discard < AVDISCARD_ALL.
*
* If flags contain AVSEEK_FLAG_BYTE, then all timestamps are in bytes and
* are the file position (this may not be supported by all demuxers).
* If flags contain AVSEEK_FLAG_FRAME, then all timestamps are in frames
* in the stream with stream_index (this may not be supported by all demuxers).
* Otherwise all timestamps are in units of the stream selected by stream_index
* or if stream_index is -1, in AV_TIME_BASE units.
* If flags contain AVSEEK_FLAG_ANY, then non-keyframes are treated as
* keyframes (this may not be supported by all demuxers).
*
* @param stream_index index of the stream which is used as time base reference
* @param min_ts smallest acceptable timestamp
* @param ts target timestamp
* @param max_ts largest acceptable timestamp
* @param flags flags
* @return >=0 on success, error code otherwise
*
* @note This is part of the new seek API which is still under construction.
*       Thus do not use this yet. It may change at any time, do not expect
*       ABI compatibility yet!
*/
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags);

/**
* Start playing a network-based stream (e.g. RTSP stream) at the
* current position.
*/
int av_read_play(AVFormatContext *s);

/**
* Pause a network-based stream (e.g. RTSP stream).
*
* Use av_read_play() to resume it.
*/
int av_read_pause(AVFormatContext *s);

/**
* Free a AVFormatContext allocated by av_open_input_stream.
* @param s context to free
*/
void av_close_input_stream(AVFormatContext *s);

/**
* Close a media file (but not its codecs).
*
* @param s media file handle
*/
void av_close_input_file(AVFormatContext *s);

/**
* Free an AVFormatContext and all its streams.
* @param s context to free
*/
void avformat_free_context(AVFormatContext *s);

/**
* Add a new stream to a media file.
*
* Can only be called in the read_header() function. If the flag
* AVFMTCTX_NOHEADER is in the format context, then new streams
* can be added in read_packet too.
*
* @param s media file handle
* @param id file-format-dependent stream ID
*/
AVStream *av_new_stream(AVFormatContext *s, int id);
AVProgram *av_new_program(AVFormatContext *s, int id);

/**
* Set the pts for a given stream. If the new values would be invalid
* (<= 0), it leaves the AVStream unchanged.
*
* @param s stream
* @param pts_wrap_bits number of bits effectively used by the pts
*        (used for wrap control, 33 is the value for MPEG)
* @param pts_num numerator to convert to seconds (MPEG: 1)
* @param pts_den denominator to convert to seconds (MPEG: 90000)
*/
void av_set_pts_info(AVStream *s, int pts_wrap_bits,
                     unsigned int pts_num, unsigned int pts_den);

#define AVSEEK_FLAG_BACKWARD 1 ///< seek backward
#define AVSEEK_FLAG_BYTE     2 ///< seeking based on position in bytes
#define AVSEEK_FLAG_ANY      4 ///< seek to any frame, even non-keyframes
#define AVSEEK_FLAG_FRAME    8 ///< seeking based on frame number

int av_find_default_stream_index(AVFormatContext *s);

/**
* Get the index for a specific timestamp.
* @param flags if AVSEEK_FLAG_BACKWARD then the returned index will correspond
*                 to the timestamp which is <= the requested one, if backward
*                 is 0, then it will be >=
*              if AVSEEK_FLAG_ANY seek to any frame, only keyframes otherwise
* @return < 0 if no such timestamp could be found
*/
int av_index_search_timestamp(AVStream *st, int64_t timestamp, int flags);

/**
* Add an index entry into a sorted list. Update the entry if the list
* already contains it.
*
* @param timestamp timestamp in the time base of the given stream
*/
int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp,
                       int size, int distance, int flags);

/**
* Perform a binary search using av_index_search_timestamp() and
* AVInputFormat.read_timestamp().
* This is not supposed to be called directly by a user application,
* but by demuxers.
* @param target_ts target timestamp in the time base of the given stream
* @param stream_index stream number
*/
int av_seek_frame_binary(AVFormatContext *s, int stream_index,
                         int64_t target_ts, int flags);

/**
* Update cur_dts of all streams based on the given timestamp and AVStream.
*
* Stream ref_st unchanged, others set cur_dts in their native time base.
* Only needed for timestamp wrapping or if (dts not set and pts!=dts).
* @param timestamp new dts expressed in time_base of param ref_st
* @param ref_st reference stream giving time_base of param timestamp
*/
void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp);

/**
* Perform a binary search using read_timestamp().
* This is not supposed to be called directly by a user application,
* but by demuxers.
* @param target_ts target timestamp in the time base of the given stream
* @param stream_index stream number
*/
int64_t av_gen_search(AVFormatContext *s, int stream_index,
                      int64_t target_ts, int64_t pos_min,
                      int64_t pos_max, int64_t pos_limit,
                      int64_t ts_min, int64_t ts_max,
                      int flags, int64_t *ts_ret,
                      int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ));

/**
* media file output
*/
#if FF_API_FORMAT_PARAMETERS
/**
* @deprecated pass the options to avformat_write_header directly.
*/
attribute_deprecated int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap);
#endif

/**
* Split a URL string into components.
*
* The pointers to buffers for storing individual components may be null,
* in order to ignore that component. Buffers for components not found are
* set to empty strings. If the port is not found, it is set to a negative
* value.
*
* @param proto the buffer for the protocol
* @param proto_size the size of the proto buffer
* @param authorization the buffer for the authorization
* @param authorization_size the size of the authorization buffer
* @param hostname the buffer for the host name
* @param hostname_size the size of the hostname buffer
* @param port_ptr a pointer to store the port number in
* @param path the buffer for the path
* @param path_size the size of the path buffer
* @param url the URL to split
*/
void av_url_split(char *proto,         int proto_size,
                  char *authorization, int authorization_size,
                  char *hostname,      int hostname_size,
                  int *port_ptr,
                  char *path,          int path_size,
                  const char *url);

/**
* Allocate the stream private data and write the stream header to
* an output media file.
*
* @param s Media file handle, must be allocated with avformat_alloc_context().
*          Its oformat field must be set to the desired output format;
*          Its pb field must be set to an already openened AVIOContext.
* @param options  An AVDictionary filled with AVFormatContext and muxer-private options.
*                 On return this parameter will be destroyed and replaced with a dict containing
*                 options that were not found. May be NULL.
*
* @return 0 on success, negative AVERROR on failure.
*
* @see av_opt_find, av_dict_set, avio_open, av_oformat_next.
*/
int avformat_write_header(AVFormatContext *s, AVDictionary **options);

#if FF_API_FORMAT_PARAMETERS
/**
* Allocate the stream private data and write the stream header to an
* output media file.
* @note: this sets stream time-bases, if possible to stream->codec->time_base
* but for some formats it might also be some other time base
*
* @param s media file handle
* @return 0 if OK, AVERROR_xxx on error
*
* @deprecated use avformat_write_header.
*/
attribute_deprecated int av_write_header(AVFormatContext *s);
#endif

/**
* Write a packet to an output media file.
*
* The packet shall contain one audio or video frame.
* The packet must be correctly interleaved according to the container
* specification, if not then av_interleaved_write_frame must be used.
*
* @param s media file handle
* @param pkt The packet, which contains the stream_index, buf/buf_size,
              dts/pts, ...
* @return < 0 on error, = 0 if OK, 1 if end of stream wanted
*/
int av_write_frame(AVFormatContext *s, AVPacket *pkt);

/**
* Write a packet to an output media file ensuring correct interleaving.
*
* The packet must contain one audio or video frame.
* If the packets are already correctly interleaved, the application should
* call av_write_frame() instead as it is slightly faster. It is also important
* to keep in mind that completely non-interleaved input will need huge amounts
* of memory to interleave with this, so it is preferable to interleave at the
* demuxer level.
*
* @param s media file handle
* @param pkt The packet, which contains the stream_index, buf/buf_size,
              dts/pts, ...
* @return < 0 on error, = 0 if OK, 1 if end of stream wanted
*/
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt);

/**
* Interleave a packet per dts in an output media file.
*
* Packets with pkt->destruct == av_destruct_packet will be freed inside this
* function, so they cannot be used after it. Note that calling av_free_packet()
* on them is still safe.
*
* @param s media file handle
* @param out the interleaved packet will be output here
* @param pkt the input packet
* @param flush 1 if no further packets are available as input and all
*              remaining packets should be output
* @return 1 if a packet was output, 0 if no packet could be output,
*         < 0 if an error occurred
*/
int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out,
                                 AVPacket *pkt, int flush);

/**
* Write the stream trailer to an output media file and free the
* file private data.
*
* May only be called after a successful call to av_write_header.
*
* @param s media file handle
* @return 0 if OK, AVERROR_xxx on error
*/
int av_write_trailer(AVFormatContext *s);

#if FF_API_DUMP_FORMAT
attribute_deprecated void dump_format(AVFormatContext *ic,
                                      int index,
                                      const char *url,
                                      int is_output);
#endif

void av_dump_format(AVFormatContext *ic,
                    int index,
                    const char *url,
                    int is_output);

#if FF_API_PARSE_DATE
/**
* Parse datestr and return a corresponding number of microseconds.
*
* @param datestr String representing a date or a duration.
* See av_parse_time() for the syntax of the provided string.
* @deprecated in favor of av_parse_time()
*/
attribute_deprecated
int64_t parse_date(const char *datestr, int duration);
#endif

/**
* Get the current time in microseconds.
*/
int64_t av_gettime(void);

#if FF_API_FIND_INFO_TAG
/**
* @deprecated use av_find_info_tag in libavutil instead.
*/
attribute_deprecated int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info);
#endif

/**
* Return in 'buf' the path with '%d' replaced by a number.
*
* Also handles the '%0nd' format where 'n' is the total number
* of digits and '%%'.
*
* @param buf destination buffer
* @param buf_size destination buffer size
* @param path numbered sequence string
* @param number frame number
* @return 0 if OK, -1 on format error
*/
int av_get_frame_filename(char *buf, int buf_size,
                          const char *path, int number);

/**
* Check whether filename actually is a numbered sequence generator.
*
* @param filename possible numbered sequence string
* @return 1 if a valid numbered sequence string, 0 otherwise
*/
int av_filename_number_test(const char *filename);

/**
* Generate an SDP for an RTP session.
*
* @param ac array of AVFormatContexts describing the RTP streams. If the
*           array is composed by only one context, such context can contain
*           multiple AVStreams (one AVStream per RTP stream). Otherwise,
*           all the contexts in the array (an AVCodecContext per RTP stream)
*           must contain only one AVStream.
* @param n_files number of AVCodecContexts contained in ac
* @param buf buffer where the SDP will be stored (must be allocated by
*            the caller)
* @param size the size of the buffer
* @return 0 if OK, AVERROR_xxx on error
*/
int av_sdp_create(AVFormatContext *ac[], int n_files, char *buf, int size);

#if FF_API_SDP_CREATE
attribute_deprecated int avf_sdp_create(AVFormatContext *ac[], int n_files, char *buff, int size);
#endif

/**
* Return a positive value if the given filename has one of the given
* extensions, 0 otherwise.
*
* @param extensions a comma-separated list of filename extensions
*/
int av_match_ext(const char *filename, const char *extensions);

#endif /* AVFORMAT_AVFORMAT_H */


./configure --help

bash: ./configure: Böyle bir dosya ya da dizin yok

if


nasilolcekbuisler

Alıntı Yapif

yardımların için teşekkürler.dediğin satırı buldum değiştirdim.şimdi de başka bir hata veriyor.sanırım.üzerinde biraz daha uğraşılıp bütün kde lere uygun hale getirilmesi gerekiyor.

if

Geliştiriciye not düşmek gerek de hatırladığım kadarıyla geliştiric geliştirmeyi durdurmuş.