Recherche avancée

Sur d’autres sites (10763)

• Managing Music Playback Channels

  30 juin 2013, par Multimedia Mike — General

  My Game Music Appreciation site allows users to interact with old video game music by toggling various channels, as long as the underlying synthesizer engine supports it.

  
  
  

  Users often find their way to the Nintendo DS section pretty quickly. This is when they notice an obnoxious quirk with the channel toggling feature : specifically, one channel doesn’t seem to map to a particular instrument or track.

  When it comes to computer music playback methodologies, I have long observed that there are 2 general strategies : Fixed channel and dynamic channel allocation.

  Fixed Channel Approach
  One of my primary sources of computer-based entertainment used to be watching music. Sure I listened to it as well. But for things like Amiga MOD files and related tracker formats, there was a rich ecosystem of fun music playback programs that visualized the music. There exist music visualization modes in various music players these days (such as iTunes and Windows Media Player), but those largely just show you a single wave form. These files were real time syntheses based on multiple audio channels and usually showed some form of analysis for each channel. My personal favorite was Cubic Player :

  
  
  

  Most of these players supported the concept of masking individual channels. In doing so, the user could isolate, study, and enjoy different components of the song. For many 4-channel Amiga MOD files, I observed that the common arrangement was to use the 4 channels for beat (percussion track), bass line, chords, and melody. Thus, it was easy to just listen to, e.g., the bass line in isolation.

  MODs and similar formats specified precisely which digital audio sample to play at what time and on which specific audio channel. To view the internals of one of these formats, one gets the impression that they contain an extremely computer-centric view of music.

  Dynamic Channel Allocation Algorithm
  MODs et al. enjoyed a lot of popularity, but the standard for computer music is MIDI. While MOD and friends took a computer-centric view of music, MIDI takes, well, a music-centric view of music.

  There are MIDI visualization programs as well. The one that came with my Gravis Ultrasound was called PLAYMIDI.EXE. It looked like this…

  
  
  

  … and it confused me. There are 16 distinct channels being visualized but some channels are shown playing multiple notes. When I dug into the technical details, I learned that MIDI just specifies what notes need to be played, at what times and frequencies and using which instrument samples, and it was the MIDI playback program’s job to make it happen.

  Thus, if a MIDI file specifies that track 1 should play a C major chord consisting of notes C, E, and G, it would transmit events “key-on C ; delta time 0 ; key-on E ; delta time 0 ; key-on G ; delta time … ; [other commands]“. If the playback program has access to multiple channels (say, up to 32, in the case of the GUS), the intuitive approach would be to maintain a pool of all available channels. Then, when it’s time to process the “key-on C” event, fetch the first available channel from the pool, mark it as in-use, play C on the channel, and return that channel to the pool when either the sample runs its course or the corresponding “key-off C” event is encountered in the MIDI command stream.

  About That Game Music
  Circling back around to my game music website, numerous supported systems use the fixed channel approach for playback while others use dynamic channel allocation approach, including evey Nintendo DS game I have so far analyzed.

  Which approach is better ? As in many technical matters, there are trade-offs either way. For many systems, the fixed channel approach is necessary because for many older audio synthesis systems, different channels had very specific purposes. The 8-bit NES had 5 channels : 2 square wave generators (used musically for melody/treble), 1 triangle wave generator (usually used for bass line), a noise generator (subverted for all manner of percussive sounds), and a limited digital channel (was sometimes assigned richer percussive sounds). Dynamic channel allocation wouldn’t work here.

  But the dynamic approach works great on hardware with 16 digital channels available like, for example, the Nintendo DS. Digital channels are very general-purpose. What about the SNES, with its 8 digital channels ? Either approach could work. In practice, most games used a fixed channel approach : Games might use 4-6 channels for music while reserving the remainder for various in-game sound effects. Some notable exceptions to this pattern were David Wise’s compositions for Rare’s SNES games (think Battletoads and the various Donkey Kong Country titles). These clearly use some dynamic channel approach since masking all but one channel will give you a variety of instrument sounds.

  Epilogue
  There ! That took a long time to explain but I find it fascinating for some reason. I need to distill it down to far fewer words because I want to make it a FAQ on my website for “Why can’t I isolate specific tracks for Nintendo DS games ?”

  Actually, perhaps I should remove the ability to toggle Nintendo DS channels in the first place. Here’s a funny tale of needless work : I found the Vio2sf engine for synthesizing Nintendo DS music and incorporated it into the program. It didn’t support toggling of individual channels so I figured out a way to add that feature to the engine. And then I noticed that most Nintendo DS games render that feature moot. After I released the webapp, I learned that I was out of date on the Vio2sf engine. The final insult was that the latest version already supports channel toggling. So I did the work for nothing. But then again, since I want to remove that feature from the UI, doubly so.

• How to set CONFIG_PATH in Heroku buildpack

  3 avril 2015, par johnklawlor

  Before I elaborate on the problem, I should let you know that I’ve successfully installed ffmpegthumbnailer on heroku’s bash (heroku run bash).

  I’m trying to build ffmpegthumbnailer using a custom Heroku buildpack I’ve written, but when I run ./configure && make install in the bin/compile buildpack file, ffmpegthumbnailer tells me that it can’t find the ffmpeg libs (util, format, codec, scale) and suggest that I set the PKG_CONFIG_PATH. So I set the PKG_CONFIG_PATH and it still can’t seem to find the libraries.

  I’ve tried setting the PKG_CONFIG_PATH every which way. echo export, export, directly set it via PKG_CONFIG_PATH=/app... I’ve always set it inline with the .configure command. I even set PKG_CONFIG_PATH as a heroku config var, and tried to acces it via the ENV_DIR variable that’s passed into the buildpack as the third parameter, but I soon realized that I was simply setting a variable PKG_CONFIG_PATH to the contents of the file called PKG_CONFIG_PATH, i.e. I was setting PKG_CONFIG_PATH=/app/vendor..., which I’ve already done !! None of these have worked. Also, as you can see in the compile file and the log, echo $PKG_CONFIG_PATH prints the correct path.

  What more debugging can i do ? What is going on ?

  Below is my bin/compile buildpack file, and the log after I deploy my app to heroku.

  #!/bin/sh
  
  
  
  indent() {
  
    sed -u 's/^/       /'
  
  }
  
  
  
  echo "-----> Install ffmpeg-thumbnailer"
  
  BUILD_DIR=$1
  
  VENDOR_DIR="vendor"
  
  DOWNLOAD_URL="https://ffmpegthumbnailer.googlecode.com/files/ffmpegthumbnailer-2.0.8.tar.gz"
  
  
  
  echo "DOWNLOAD_URL = " $DOWNLOAD_URL | indent
  
  
  
  cd $BUILD_DIR
  
  mkdir -p $VENDOR_DIR
  
  cd $VENDOR_DIR
  
  curl -L --silent $DOWNLOAD_URL | tar xz
  
  cd ffmpegthumbnailer-2.0.8/
  
  export PKG_CONFIG_PATH="$PKG_CONFIG_PATH:/app/vendor/ffmpeg/lib/pkgconfig/"
  
  echo $PKG_CONFIG_PATH
  
  ./configure --prefix /app/vendor/ffmpegthumbnailer && make install
  
  
  
  echo "exporting PATH and LIBRARY_PATH" | indent
  
  PROFILE_PATH="$BUILD_DIR/.profile.d/ffmpeg-thumbnailer.sh"
  
  mkdir -p $(dirname $PROFILE_PATH)
  
  echo 'export PATH="$PATH:vendor/ffmpeg-thumbnailer/bin"' >> $PROFILE_PATH
  
  echo 'export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:vendor/ffmpeg-thumbnailer/lib"' >> $PROFILE_PATH

  And my heroku deployment log...

  Fetching repository, done.
  
  Counting objects: 5, done.
  
  Delta compression using up to 2 threads.
  
  Compressing objects: 100% (3/3), done.
  
  Writing objects: 100% (3/3), 311 bytes, done.
  
  Total 3 (delta 2), reused 0 (delta 0)
  
  
  
  -----> Fetching custom git buildpack... done
  
  -----> Multipack app detected
  
  =====> Downloading Buildpack: https://github.com/shunjikonishi/heroku-buildpack-ffmpeg
  
  =====> Detected Framework: ffmpeg
  
  -----> Install ffmpeg
  
         DOWNLOAD_URL =  http://flect.github.io/heroku-binaries/libs/ffmpeg.tar.gz
  
         exporting PATH and LIBRARY_PATH
  
  =====> Downloading Buildpack: https://github.com/johnklawlor/heroku-buildpack-ffmpeg-thumbnailer
  
  =====> Detected Framework: ffmpeg
  
  -----> Install ffmpeg-thumbnailer
  
  HERE COMES PKG_CONFIG!
  
  /app/vendor/ffmpeg/lib/pkgconfig
  
         DOWNLOAD_URL =  https://ffmpegthumbnailer.googlecode.com/files/ffmpegthumbnailer-2.0.8.tar.gz
  
  /app/vendor/ffmpeg/lib/pkgconfig
  
  checking for a BSD-compatible install... /usr/bin/install -c
  
  checking whether build environment is sane... yes
  
  checking for a thread-safe mkdir -p... /bin/mkdir -p
  
  checking for gawk... no
  
  checking for mawk... mawk
  
  checking whether make sets $(MAKE)... yes
  
  checking for g++... g++
  
  checking whether the C++ compiler works... yes
  
  checking for C++ compiler default output file name... a.out
  
  checking for suffix of executables...
  
  checking whether we are cross compiling... no
  
  checking for suffix of object files... o
  
  checking whether we are using the GNU C++ compiler... yes
  
  checking whether g++ accepts -g... yes
  
  checking for style of include used by make... GNU
  
  checking dependency style of g++... gcc3
  
  checking build system type... x86_64-unknown-linux-gnu
  
  checking host system type... x86_64-unknown-linux-gnu
  
  checking how to print strings... printf
  
  checking for gcc... gcc
  
  checking whether we are using the GNU C compiler... yes
  
  checking whether gcc accepts -g... yes
  
  checking for gcc option to accept ISO C89... none needed
  
  checking dependency style of gcc... gcc3
  
  checking for a sed that does not truncate output... /bin/sed
  
  checking for grep that handles long lines and -e... /bin/grep
  
  checking for egrep... /bin/grep -E
  
  checking for fgrep... /bin/grep -F
  
  checking for ld used by gcc... /usr/bin/ld
  
  checking if the linker (/usr/bin/ld) is GNU ld... yes
  
  checking for BSD- or MS-compatible name lister (nm)... /usr/bin/nm -B
  
  checking the name lister (/usr/bin/nm -B) interface... BSD nm
  
  checking whether ln -s works... yes
  
  checking the maximum length of command line arguments... 1572864
  
  checking whether the shell understands some XSI constructs... yes
  
  checking whether the shell understands "+="... yes
  
  checking how to convert x86_64-unknown-linux-gnu file names to x86_64-unknown-linux-gnu format... func_convert_file_noop
  
  checking how to convert x86_64-unknown-linux-gnu file names to toolchain format... func_convert_file_noop
  
  checking for /usr/bin/ld option to reload object files... -r
  
  checking for objdump... objdump
  
  checking how to recognize dependent libraries... pass_all
  
  checking for dlltool... no
  
  checking how to associate runtime and link libraries... printf %s\n
  
  checking for ar... ar
  
  checking for archiver @FILE support... @
  
  checking for strip... strip
  
  checking for ranlib... ranlib
  
  checking command to parse /usr/bin/nm -B output from gcc object... ok
  
  checking for sysroot... no
  
  checking for mt... mt
  
  checking if mt is a manifest tool... no
  
  checking how to run the C preprocessor... gcc -E
  
  checking for ANSI C header files... yes
  
  checking for sys/types.h... yes
  
  checking for sys/stat.h... yes
  
  checking for stdlib.h... yes
  
  checking for string.h... yes
  
  checking for memory.h... yes
  
  checking for strings.h... yes
  
  checking for inttypes.h... yes
  
  checking for stdint.h... yes
  
  checking for unistd.h... yes
  
  checking for dlfcn.h... yes
  
  checking for objdir... .libs
  
  checking if gcc supports -fno-rtti -fno-exceptions... no
  
  checking for gcc option to produce PIC... -fPIC -DPIC
  
  checking if gcc PIC flag -fPIC -DPIC works... yes
  
  checking if gcc static flag -static works... yes
  
  checking if gcc supports -c -o file.o... yes
  
  checking if gcc supports -c -o file.o... (cached) yes
  
  checking whether the gcc linker (/usr/bin/ld -m elf_x86_64) supports shared libraries... yes
  
  checking whether -lc should be explicitly linked in... no
  
  checking dynamic linker characteristics... GNU/Linux ld.so
  
  checking how to hardcode library paths into programs... immediate
  
  checking whether stripping libraries is possible... yes
  
  checking if libtool supports shared libraries... yes
  
  checking whether to build shared libraries... yes
  
  checking whether to build static libraries... yes
  
  checking how to run the C++ preprocessor... g++ -E
  
  checking for ld used by g++... /usr/bin/ld -m elf_x86_64
  
  checking if the linker (/usr/bin/ld -m elf_x86_64) is GNU ld... yes
  
  checking whether the g++ linker (/usr/bin/ld -m elf_x86_64) supports shared libraries... yes
  
  checking for g++ option to produce PIC... -fPIC -DPIC
  
  checking if g++ PIC flag -fPIC -DPIC works... yes
  
  checking if g++ static flag -static works... yes
  
  checking if g++ supports -c -o file.o... yes
  
  checking if g++ supports -c -o file.o... (cached) yes
  
  checking whether the g++ linker (/usr/bin/ld -m elf_x86_64) supports shared libraries... yes
  
  checking dynamic linker characteristics... (cached) GNU/Linux ld.so
  
  checking how to hardcode library paths into programs... immediate
  
  checking for special C compiler options needed for large files... no
  
  checking for _FILE_OFFSET_BITS value needed for large files... no
  
  checking whether make supports nested variables... yes
  
  checking for ANSI C header files... (cached) yes
  
  checking for inttypes.h... (cached) yes
  
  checking for sys/stat.h... (cached) yes
  
  checking whether /usr/bin/ld -m elf_x86_64 accepts --as-needed... yes
  
  checking for pkg-config... /usr/bin/pkg-config
  
  checking pkg-config is at least version 0.9.0... yes
  
  checking for FFMPEG... no
  
  configure: error: Package requirements (libavutil libavformat libavcodec >= 52.26.0 libswscale) were not met:
  
  
  
  No package 'libavutil' found
  
  No package 'libavformat' found
  
  No package 'libavcodec' found
  
  No package 'libswscale' found
  
  
  
  Consider adjusting the PKG_CONFIG_PATH environment variable if you
  
  installed software in a non-standard prefix.
  
  
  
  Alternatively, you may set the environment variables FFMPEG_CFLAGS
  
  and FFMPEG_LIBS to avoid the need to call pkg-config.
  
  See the pkg-config man page for more details.
  
         exporting PATH and LIBRARY_PATH
  
  =====> Downloading Buildpack: https://github.com/heroku/heroku-buildpack-ruby

• lavf : improve handling of sparse streams when muxing

  20 janvier 2014, par Luca Barbato

  lavf : improve handling of sparse streams when muxing
  Currently ff_interleave_packet_per_dts() waits until it gets a frame for
  
  each stream before outputting packets in interleaved order.
  Sparse streams (i.e. streams with much fewer packets than the other
  
  streams, like subtitles or audio with DTX) tend to add up latency and in
  
  specific cases end up allocating a large amount of memory.
  Emit the top packet from the packet_buffer if it has a time delta
  
  larger than a specified threshold.
  Original report of the issue and initial proposed solution by
  
  mus.svz@gmail.com.
  Bug-id : 31
  
  Signed-off-by : Anton Khirnov <anton@khirnov.net>
  

  • [DH] doc/APIchanges
  • [DH] libavformat/avformat.h
  • [DH] libavformat/mux.c
  • [DH] libavformat/options_table.h
  • [DH] libavformat/version.h