Recherche avancée

Sur d’autres sites (10263)

• NoClassDefFoundError at FFmpegFrameRecorder

  30 janvier 2015, par Sanjay Rapolu

  I am developing a android application and converting set of images into videos is one of its functionality. whenever I am trying to create an object of FFmpegFrameRecorder, NoClassDefFoundError java lang.ClassNotFoundException org.bytedeco.javacv.FFmpegFraerecorder exception is getting throwed. Here is the code on which I’m working. can anyone please suggest the reason for this error and the solution ?

  package com.example.makevideo;
  
  
  
  import java.io.File;
  
  
  
  import org.bytedeco.javacpp.opencv_core;
  
  import org.bytedeco.javacpp.opencv_core.IplImage;
  
  import org.bytedeco.javacv.FFmpegFrameRecorder;
  
  
  
  import android.app.Activity;
  
  import android.os.Bundle;
  
  import android.os.Environment;
  
  import android.util.Log;
  
  import android.view.View;
  
  import android.widget.Button;
  
  import android.widget.Toast;
  
  import static org.bytedeco.javacpp.opencv_highgui.cvLoadImage;
  
  
  
  
  
  public class MainActivity extends Activity {
  
  
  
          private static final String EXTR_DIR = "Screenshot";
  
  
  
          String path = Environment.getExternalStorageDirectory() + File.separator
  
                          + EXTR_DIR;
  
          Button Record;
  
  
  
          @Override
  
          protected void onCreate(Bundle savedInstanceState) {
  
                  super.onCreate(savedInstanceState);
  
                  setContentView(R.layout.activity_main);
  
  
  
                  System.out.println("Application Runs");
  
  
  
                  Toast.makeText(getApplicationContext(), path, Toast.LENGTH_SHORT)
  
                                  .show();
  
                  ;
  
                  recording();
  
  
  
          }
  
  
  
          private void recording() {
  
                  // TODO Auto-generated method stub
  
  
  
                  Record = (Button) findViewById(R.id.Record);
  
  
  
                  Record.setOnClickListener(new View.OnClickListener() {
  
  
  
                          @Override
  
                          public void onClick(View v) {
  
                                  // TODO Auto-generated method stub
  
                                  System.out.println(path);
  
                                  Toast.makeText(getApplicationContext(), path, Toast.LENGTH_LONG)
  
                                                  .show();
  
                                  Log.d("Record",
  
                                                  "Environment.getExternalStorageDirectory().getPath()  : "
  
                                                                  + path);
  
                                  record();
  
                          }
  
                  });
  
          }
  
  
  
          private void record() {
  
  
  
                  File folder = new File(path);
  
  
  
                  File[] listOfFiles = folder.listFiles();
  
                  opencv_core.IplImage[] iplimage = null;
  
                  if (listOfFiles.length > 0) {
  
  
  
                          System.out.println("in IFFF...");
  
  
  
                          // Toast.makeText(getApplicationContext(), listOfFiles.length,
  
                          // Toast.LENGTH_SHORT).show();
  
                          iplimage = new opencv_core.IplImage[listOfFiles.length];
  
  
  
                          for (int j = 0; j < listOfFiles.length; j++) {
  
  
  
                                  String files = "";
  
  
  
                                  if (listOfFiles[j].isFile()) {
  
                                          files = listOfFiles[j].getName();
  
                                          System.out.println(" j " + j + listOfFiles[j]);
  
                                  }
  
  
  
                                  String[] tokens = files.split("\\.(?=[^\\.]+$)");
  
                                  String name = tokens[0];
  
  
  
                                  Toast.makeText(getApplicationContext(),
  
                                                  "size=" + listOfFiles.length, Toast.LENGTH_SHORT)
  
                                                  .show();
  
  
  
                                  iplimage[j] = cvLoadImage(path + File.separator + name + ".jpg");
  
  
  
                          }
  
  
  
                  }
  
  
  
                  FFmpegFrameRecorder recorder = new FFmpegFrameRecorder(path
  
                                  + File.separator + "OUTPUT" + System.currentTimeMillis()
  
                                  + ".mp4", 200, 150);
  
  
  
                  try {
  
                          recorder.setVideoCodec(13); // CODEC_ID_MPEG4 //CODEC_ID_MPEG1VIDEO
  
                          // //http://stackoverflow.com/questions/14125758/javacv-ffmpegframerecorder-properties-explanation-needed
  
  
  
                          recorder.setFrameRate(1); // This is the frame rate for video. If
  
                                                                                  // you really want to have good video
  
                                                                                  // quality you need to provide large set
  
                                                                                  // of images.
  
                          recorder.setPixelFormat(0); // PIX_FMT_YUV420P
  
  
  
                          recorder.start();
  
  
  
                          for (int i = 0; i < iplimage.length; i++) {
  
  
  
                                  recorder.record(iplimage[i]);
  
  
  
                          }
  
                          
  
                          recorder.stop();
  
                          Toast.makeText(MainActivity.this, "Record Completed",
  
                                          Toast.LENGTH_SHORT).show();
  
  
  
                  } catch (Exception e) {
  
                          e.printStackTrace();
  
                  }
  
          }
  
  
  
  }

• Anomalie #4623 : Styles des fieldset dans l’espace privé

  17 avril 2021

  Je propose pour ce ticket d’en profiter pour uniformiser tous les quelques formulaires qui ont des "vrais" fieldsets toujours dans un conteneur.

  Ah oui, je suis en plein confronté à ce problème pour gérer les marges et tout ça, si on peut uniformiser super.
  Dans la charte c’est sans conteneur .fieldset, alors pour comprendre quel est le cas normal et quelles sont les exceptions, c’est sport.
  Donc la vraie règle c’est avec conteneur .fieldset, c’est bien ça ? (Pour que j’adapte la charte au passage).

• ffmpeg : error while loading shared libraries : libvpx.so.6 : cannot open shared object file : No such file or directory

  16 avril 2021, par Panos

  I am building a multi tool discord bot in Python rewrite.

  


  So I decided to add music to it as well. When I completed the bot and tried it on my local pc it worked perfectly. However when I uploaded to Heroku I got some errors for ffmpeg.

  


  Initially I thought Heroku is Linux based so I downloaded ffmpeg for Linux. Still didn't work. Then i added a apt buildpack and downloaded it that way. It worked however now a get a different error. It finds the ffmpeg but the song is not played and this is displayed in the console :

  


  


  [ffmpeg : error while loading shared libraries : libvpx.so.6 : cannot
open shared object file : No such file or directory]

  


  


  How can I resolve this issue ?

  


  Here is the whole code :

  


  import discord
from discord.ext import commands

import asyncio
import itertools
import sys
import traceback
from async_timeout import timeout
from functools import partial
from youtube_dl import YoutubeDL
import ctypes
import ctypes.util

@commands.Cog.listener()
async def on_ready(self):

    print("ctypes - Find opus:")
    a = ctypes.util.find_library('opus')
    print(a)
    
    print("Discord - Load Opus:")
    b = discord.opus.load_opus(a)
    print(b)
    
    print("Discord - Is loaded:")
    c = discord.opus.is_loaded()
    print(c)



ytdlopts = {
    'format': 'bestaudio/best',
    'outtmpl': 'downloads/%(extractor)s-%(id)s-%(title)s.%(ext)s',
    'restrictfilenames': True,
    'noplaylist': True,
    'nocheckcertificate': True,
    'ignoreerrors': False,
    'logtostderr': False,
    'quiet': True,
    'no_warnings': True,
    'default_search': 'auto',
    'source_address': '0.0.0.0'
}

ffmpegopts = {
    'before_options': '-nostdin',
    'options': '-vn'
}

ytdl = YoutubeDL(ytdlopts)


class VoiceConnectionError(commands.CommandError):


class InvalidVoiceChannel(VoiceConnectionError):



class YTDLSource(discord.PCMVolumeTransformer):

    def __init__(self, source, *, data, requester):
        super().__init__(source)
        self.requester = requester

        self.title = data.get('title')
        self.web_url = data.get('webpage_url')


    def __getitem__(self, item: str):
        return self.__getattribute__(item)

    @classmethod
    async def create_source(cls, ctx, search: str, *, loop, download=False):
        loop = loop or asyncio.get_event_loop()

        to_run = partial(ytdl.extract_info, url=search, download=download)
        data = await loop.run_in_executor(None, to_run)

        if 'entries' in data:
            data = data['entries'][0]

        await ctx.send(f'```ini\n[Added {data["title"]} to the Queue.]\n```')

        if download:
            source = ytdl.prepare_filename(data)
        else:
            return {'webpage_url': data['webpage_url'], 'requester': ctx.author, 'title': data['title']}

        return cls(discord.FFmpegPCMAudio(source), data=data, requester=ctx.author)

    @classmethod
    async def regather_stream(cls, data, *, loop):
        """Used for preparing a stream, instead of downloading.
        Since Youtube Streaming links expire."""
        loop = loop or asyncio.get_event_loop()
        requester = data['requester']

        to_run = partial(ytdl.extract_info, url=data['webpage_url'], download=False)
        data = await loop.run_in_executor(None, to_run)

        return cls(discord.FFmpegPCMAudio(data['url']), data=data, requester=requester)


class MusicPlayer(commands.Cog):

    __slots__ = ('bot', '_guild', '_channel', '_cog', 'queue', 'next', 'current', 'np', 'volume')

    def __init__(self, ctx):
        self.bot = ctx.bot
        self._guild = ctx.guild
        self._channel = ctx.channel
        self._cog = ctx.cog

        self.queue = asyncio.Queue()
        self.next = asyncio.Event()

        self.np = None
        self.volume = .5
        self.current = None

        ctx.bot.loop.create_task(self.player_loop())

    async def player_loop(self):
        """Our main player loop."""
        await self.bot.wait_until_ready()

        while not self.bot.is_closed():
            self.next.clear()

            try:
                    source = await self.queue.get()
            except asyncio.TimeoutError:
                return self.destroy(self._guild)

            if not isinstance(source, YTDLSource):
                try:
                    source = await YTDLSource.regather_stream(source, loop=self.bot.loop)
                except Exception as e:
                    await self._channel.send(f'There was an error processing your song.\n'
                                             f'```css\n[{e}]\n```')
                    continue

            source.volume = self.volume
            self.current = source

            self._guild.voice_client.play(source, after=lambda _: self.bot.loop.call_soon_threadsafe(self.next.set))
            self.np = await self._channel.send(f'**Now Playing:** `{source.title}` requested by '
                                               f'`{source.requester}`')
            await self.next.wait()

            source.cleanup()
            self.current = None

            try:
                await self.np.delete()
            except discord.HTTPException:
                pass

    def destroy(self, guild):
        """Disconnect and cleanup the player."""
        return self.bot.loop.create_task(self._cog.cleanup(guild))


class Music(commands.Cog):
    """Music related commands."""

    __slots__ = ('bot', 'players')

    def __init__(self, bot):
        self.bot = bot
        self.players = {}

    async def cleanup(self, guild):
        try:
            await guild.voice_client.disconnect()
        except AttributeError:
            pass

        try:
            del self.players[guild.id]
        except KeyError:
            pass

    async def __local_check(self, ctx):
        """A local check which applies to all commands in this cog."""
        if not ctx.guild:
            raise commands.NoPrivateMessage
        return True

    async def __error(self, ctx, error):
        """A local error handler for all errors arising from commands in this cog."""
        if isinstance(error, commands.NoPrivateMessage):
            try:
                return await ctx.send('This command can not be used in Private Messages.')
            except discord.HTTPException:
                pass
        elif isinstance(error, InvalidVoiceChannel):
            await ctx.send('Error connecting to Voice Channel. '
                           'Please make sure you are in a valid channel or provide me with one')

        print('Ignoring exception in command {}:'.format(ctx.command), file=sys.stderr)
        traceback.print_exception(type(error), error, error.__traceback__, file=sys.stderr)

    def get_player(self, ctx):
        """Retrieve the guild player, or generate one."""
        try:
            player = self.players[ctx.guild.id]
        except KeyError:
            player = MusicPlayer(ctx)
            self.players[ctx.guild.id] = player

        return player

    @commands.command(name='connect', aliases=['join'])
    async def connect_(self, ctx):
        try:
            channel = ctx.author.voice.channel
        except AttributeError:
            raise InvalidVoiceChannel('No channel to join.')

        vc = ctx.voice_client

        if vc:
            if vc.channel.id == channel.id:
                return
            try:
                await vc.move_to(channel)
            except asyncio.TimeoutError:
                raise VoiceConnectionError(f'Moving to channel: <{channel}> timed out.')
        else:
            try:
                await channel.connect()
            except asyncio.TimeoutError:
                raise VoiceConnectionError(f'Connecting to channel: <{channel}> timed out.')

        await ctx.send(f'Connected to: **{channel}**', )

    @commands.command(name='play', aliases=['sing'])
    async def play_(self, ctx, *, search: str):
        await ctx.trigger_typing()

        vc = ctx.voice_client

        if not vc:
            await ctx.invoke(self.connect_)

        player = self.get_player(ctx)
        source = await YTDLSource.create_source(ctx, search, loop=self.bot.loop, download=False)

        await player.queue.put(source)

    @commands.command(name='pause')
    async def pause_(self, ctx):
        """Pause the currently playing song."""
        vc = ctx.voice_client

        if not vc or not vc.is_playing():
            return await ctx.send('I am not currently playing anything!')
        elif vc.is_paused():
            return

        vc.pause()
        await ctx.send(f'**`{ctx.author}`**: Paused the song!')

    @commands.command(name='resume')
    async def resume_(self, ctx):
        """Resume the currently paused song."""
        vc = ctx.voice_client

        if not vc or not vc.is_connected():
            return await ctx.send('I am not currently playing anything!', )
        elif not vc.is_paused():
            return

        vc.resume()
        await ctx.send(f'**`{ctx.author}`**: Resumed the song!')

    @commands.command(name='skip')
    async def skip_(self, ctx):
        """Skip the song."""
        vc = ctx.voice_client

        if not vc or not vc.is_connected():
            return await ctx.send('I am not currently playing anything!')

        if vc.is_paused():
            pass
        elif not vc.is_playing():
            return

        vc.stop()
        await ctx.send(f'**`{ctx.author}`**: Skipped the song!')

    @commands.command(name='queue', aliases=['q', 'playlist'])
    async def queue_info(self, ctx):
        """Retrieve a basic queue of upcoming songs."""
        vc = ctx.voice_client

        if not vc or not vc.is_connected():
            return await ctx.send('I am not currently connected to voice!')

        player = self.get_player(ctx)
        if player.queue.empty():
            return await ctx.send('There are currently no more queued songs.')

        upcoming = list(itertools.islice(player.queue._queue, 0, 5))

        fmt = '\n'.join(f'**`{_["title"]}`**' for _ in upcoming)
        embed = discord.Embed(title=f'Upcoming - Next {len(upcoming)}', description=fmt)

        await ctx.send(embed=embed)

    @commands.command(name='now_playing', aliases=['np', 'current', 'currentsong', 'playing'])
    async def now_playing_(self, ctx):
        """Display information about the currently playing song."""
        vc = ctx.voice_client

        if not vc or not vc.is_connected():
            return await ctx.send('I am not currently connected to voice!', )

        player = self.get_player(ctx)
        if not player.current:
            return await ctx.send('I am not currently playing anything!')

        try:
            await player.np.delete()
        except discord.HTTPException:
            pass

        player.np = await ctx.send(f'**Now Playing:** `{vc.source.title}` '
                                   f'requested by `{vc.source.requester}`')

    @commands.command(name='volume', aliases=['vol'])
    async def change_volume(self, ctx, *, vol: float):
        """Change the player volume.
        Parameters
        ------------
        volume: float or int [Required]
            The volume to set the player to in percentage. This must be between 1 and 100.
        """
        vc = ctx.voice_client

        if not vc or not vc.is_connected():
            return await ctx.send('I am not currently connected to voice!', )

        if not 0 < vol < 101:
            return await ctx.send('Please enter a value between 1 and 100.')

        player = self.get_player(ctx)

        if vc.source:
            vc.source.volume = vol / 100

        player.volume = vol / 100
        await ctx.send(f'**`{ctx.author}`**: Set the volume to **{vol}%**')

    @commands.command(name='stop', aliases=['leave'])
    async def stop_(self, ctx):
        vc = ctx.voice_client

        if not vc or not vc.is_connected():
            return await ctx.send('I am not currently playing anything!')

        await self.cleanup(ctx.guild)


def setup(client):
    client.add_cog(Music(client))