Recherche avancée

Recherche
Choix de la période de publication
Date minimale :

Date maximale :

Type de date :
Choix de la langue
Choix du type de média
Choix de la rubrique
Choix de la licence de publication
Choix de l’auteur

Médias (91)

1 | ... | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16

Autres articles (34)

MediaSPIP version 0.1 Beta

16 avril 2011, par kent1

MediaSPIP 0.1 beta est la première version de MediaSPIP décrétée comme "utilisable".
Le fichier zip ici présent contient uniquement les sources de MediaSPIP en version standalone.
Pour avoir une installation fonctionnelle, il est nécessaire d’installer manuellement l’ensemble des dépendances logicielles sur le serveur.
Si vous souhaitez utiliser cette archive pour une installation en mode ferme, il vous faudra également procéder à d’autres modifications (...)
MediaSPIP 0.1 Beta version

25 avril 2011, par kent1

MediaSPIP 0.1 beta is the first version of MediaSPIP proclaimed as "usable".
The zip file provided here only contains the sources of MediaSPIP in its standalone version.
To get a working installation, you must manually install all-software dependencies on the server.
If you want to use this archive for an installation in "farm mode", you will also need to proceed to other manual (...)
Amélioration de la version de base

13 septembre 2013

Jolie sélection multiple
Le plugin Chosen permet d’améliorer l’ergonomie des champs de sélection multiple. Voir les deux images suivantes pour comparer.
Il suffit pour cela d’activer le plugin Chosen (Configuration générale du site > Gestion des plugins), puis de configurer le plugin (Les squelettes > Chosen) en activant l’utilisation de Chosen dans le site public et en spécifiant les éléments de formulaires à améliorer, par exemple select[multiple] pour les listes à sélection multiple (...)

1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | ... | 12

Sur d’autres sites (2183)

Revision 891793a540 : Conditionally skip reference frame check For regular inter frames, if the dista

29 septembre 2014, par Jingning Han

Changed Paths :
Modify /vp9/encoder/vp9_rdopt.c

Conditionally skip reference frame check

For regular inter frames, if the distance from GOLDEN_FRAME is larger
than 2 and if the predicted motion vector of LAST_FRAME gives lower
sse than that of GOLDEN_FRAME, skip the GOLDE_FRAME mode checking in
the rate-distortion optimization. It provides about 5% speed-up at
expense of -0.137% and -0.230% performance down for speed 3. Local
experiment results :

pedestrian 1080p 2000 kbps
66712 b/f, 40.908 dB, 113688 ms ->
66768 b/f, 40.911 dB, 108752 ms

blue_sky 1080p 2000 kbps
51054 b/f, 35.894 dB, 70406 ms ->
51051 b/f, 35.891 dB, 67236 ms

old_town_cross 720p 1500 kbps
14412 b/f, 36.252 dB, 60690 ms ->
14431 b/f, 36.249 dB, 57346 ms

Change-Id : Idfcafe7f63da7a4896602fc60bd7093f0f0d82ca
Basic Video Palette Conversion

20 août 2011, par Multimedia Mike — General, Python
How do you take a 24-bit RGB image and convert it to an 8-bit paletted image for the purpose of compression using a codec that requires 8-bit input images ? Seems simple enough and that’s what I’m tackling in this post.

Ask FFmpeg/Libav To Do It
Ideally, FFmpeg / Libav should be able to handle this automatically. Indeed, FFmpeg used to be able to, at least at the time I wrote this post about ZMBV and was unhappy with FFmpeg’s default results. Somewhere along the line, FFmpeg and Libav lost the ability to do this. I suspect it got removed during some swscale refactoring.

Still, there’s no telling if the old system would have computed palettes correctly for QuickTime files.

Distance Approach
When I started writing my SMC video encoder, I needed to convert RGB (from PNG files) to PAL8 colorspace. The path of least resistance was to match the pixels in the input image to the default 256-color palette that QuickTime assumes (and is hardcoded into FFmpeg/Libav).

How to perform the matching ? Find the palette entry that is closest to a given input pixel, where "closest" is the minimum distance as computed by the usual distance formula (square root of the sum of the squares of the diffs of all the components).

That means for each pixel in an image, check the pixel against 256 palette entries (early termination is possible if an acceptable threshold is met). As you might imagine, this can be a bit time-consuming. I wondered about a faster approach...

Lookup Table
I think this is the approach that FFmpeg used to use, but I went and derived it for myself after studying the default QuickTime palette table. There’s a pattern there— all of the RGB entries are comprised of combinations of 6 values — 0x00, 0x33, 0x66, 0x99, 0xCC, and 0xFF. If you mix and match these for red, green, and blue values, you come up with 6 * 6 * 6 = 216 different colors. This happens to be identical to the web-safe color palette.

The first (0th) entry in the table is (FF, FF, FF), followed by (FF, FF, CC), (FF, FF, 99), and on down to (FF, FF, 00) when the green component gets knocked down and step and the next color is (FF, CC, FF). The first 36 palette entries in the table all have a red component of 0xFF. Thus, if an input RGB pixel has a red color closest to 0xFF, it must map to one of those first 36 entries.

I created a table which maps indices 0..215 to values from 5..0. Each of the R, G, and B components of an input pixel are used to index into this table and derive 3 indices ri, gi, and bi. Finally, the index into the palette table is given by :
```
  index = ri * 36 + gi * 6 + bi
```
For example, the pixel (0xFE, 0xFE, 0x01) would yield ri, gi, and bi values of 0, 0, and 5. Therefore :
```
  index = 0 * 36 + 0 * 6 + 5
```
The palette index is 5, which maps to color (0xFF, 0xFF, 0x00).

Validation
So I was pretty pleased with myself for coming up with that. Now, ideally, swapping out one algorithm for another in my SMC encoder should yield identical results. That wasn’t the case, initially.

One problem is that the regulation QuickTime palette actually has 40 more entries above and beyond the typical 216-entry color cube (rounding out the grand total of 256 colors). Thus, using the distance approach with the full default table provides for a little more accuracy.

However, there still seems to be a problem. Let’s check our old standby, the Big Buck Bunny logo image :

Distance approach using the full 256-color QuickTime default palette

Distance approach using the 216-color palette

Table lookup approach using the 216-color palette

I can’t quite account for that big red splotch there. That’s the most notable difference between images 1 and 2 and the only visible difference between images 2 and 3.

To prove to myself that the distance approach is equivalent to the table approach, I wrote a Python script to iterate through all possible RGB combinations and verify the equivalence. If you’re not up on your base 2 math, that’s 2²⁴ or 16,777,216 colors to run through. I used Python’s multiprocessing module to great effect and really maximized a Core i7 CPU with 8 hardware threads.

So I’m confident that the palette conversion techniques are sound. The red spot is probably attributable to a bug in my WIP SMC encoder.

Source Code
Update August 23, 2011 : Here’s the Python code I used for proving equivalence between the 2 approaches. In terms of leveraging multiple CPUs, it’s possibly the best program I have written to date.

PLAIN TEXT
PYTHON :
# !/usr/bin/python

from multiprocessing import Pool

palette = []

pal8_table = []

def process_r(r) :

counts = []

for i in xrange(216) :

  counts.append(0)

print "r = %d" % (r)

for g in xrange(256) :

  for b in xrange(256) :

   min_dsqrd = 0xFFFFFFFF

   best_index = 0

   for i in xrange(len(palette)) :

    dr = palette[i][0] - r

    dg = palette[i][1] - g

    db = palette[i][2] - b

    dsqrd = dr * dr + dg * dg + db * db

    if dsqrd <min_dsqrd :

     min_dsqrd = dsqrd

     best_index = i

   counts[best_index] += 1

   # check if the distance approach deviates from the table-based approach

   i = best_index

   r = palette[i][0]

   g = palette[i][1]

   b = palette[i][2]

   ri = pal8_table[r]

   gi = pal8_table[g]

   bi = pal8_table[b]

   table_index = ri * 36 + gi * 6 + bi ;

   if table_index != best_index :

    print "(0x%02X 0x%02X 0x%02X) : distance index = %d, table index = %d" % (r, g, b, best_index, table_index)

return counts

if __name__ == ’__main__’ :

counts = []

for i in xrange(216) :

  counts.append(0)

# initialize reference palette

color_steps = [ 0xFF, 0xCC, 0x99, 0x66, 0x33, 0x00 ]

for r in color_steps :

  for g in color_steps :

   for b in color_steps :

    palette.append([r, g, b])

# initialize palette conversion table

for i in range(0, 26) :

  pal8_table.append(5)

for i in range(26, 77) :

  pal8_table.append(4)

for i in range(77, 128) :

  pal8_table.append(3)

for i in range(128, 179) :

  pal8_table.append(2)

for i in range(179, 230) :

  pal8_table.append(1)

for i in range(230, 256) :

  pal8_table.append(0)

# create a pool of worker threads and break up the overall job

pool = Pool()

it = pool.imap_unordered(process_r, range(256))

try :

  while 1 :

   partial_counts = it.next()

   for i in xrange(216) :

    counts[i] += partial_counts[i]

except StopIteration :

  pass

print "index, count, red, green, blue"

for i in xrange(len(counts)) :

  print "%d, %d, %d, %d, %d" % (i, counts[i], palette[i][0], palette[i][1], palette[i][2])
FFMPEG concat video and audios with certain start point for each

6 août 2022, par Jybrcfn CA

I have some video files without voice and some audios and all of them are in .flv format. I want to combine them as a single file in way that each video or audio start at given start_time. the start_times are in way that no two videos or two audios overlap but there might be a distance between end of a video/audio and start of the next video/audio. Is there any way to do it using FFMPEG ?




for example :












































































file start_time(milliseconds)

audio1 400

audio2 1400

audio3 3100

video1 0

video2 1000

video3 2000

video4 3700







audio -> *




video -> +




emty -> -




final result should be some thing like




---*******---**************---**********************--




+++++++--+++++++---++++++++++++++---++++++++++++++++++




Thank you in advance.