Recherche avancée

Médias (3)

Mot : - Tags -/pdf

Autres articles (104)

  • Soumettre améliorations et plugins supplémentaires

    10 avril 2011

    Si vous avez développé une nouvelle extension permettant d’ajouter une ou plusieurs fonctionnalités utiles à MediaSPIP, faites le nous savoir et son intégration dans la distribution officielle sera envisagée.
    Vous pouvez utiliser la liste de discussion de développement afin de le faire savoir ou demander de l’aide quant à la réalisation de ce plugin. MediaSPIP étant basé sur SPIP, il est également possible d’utiliser le liste de discussion SPIP-zone de SPIP pour (...)

  • Emballe médias : à quoi cela sert ?

    4 février 2011, par

    Ce plugin vise à gérer des sites de mise en ligne de documents de tous types.
    Il crée des "médias", à savoir : un "média" est un article au sens SPIP créé automatiquement lors du téléversement d’un document qu’il soit audio, vidéo, image ou textuel ; un seul document ne peut être lié à un article dit "média" ;

  • ANNEXE : Les plugins utilisés spécifiquement pour la ferme

    5 mars 2010, par

    Le site central/maître de la ferme a besoin d’utiliser plusieurs plugins supplémentaires vis à vis des canaux pour son bon fonctionnement. le plugin Gestion de la mutualisation ; le plugin inscription3 pour gérer les inscriptions et les demandes de création d’instance de mutualisation dès l’inscription des utilisateurs ; le plugin verifier qui fournit une API de vérification des champs (utilisé par inscription3) ; le plugin champs extras v2 nécessité par inscription3 (...)

Sur d’autres sites (11948)

  • FFMPEG compiled binaries don't run using MinGW

    9 juin 2015, par Paul Knopf

    I am trying to build windows executables/dlls for Windows XP, and they are not working. They are the correct architecture. They run fine on my Windows 8 device machine.

    I used dependency walker to find missing DLLs, and all were present.

    Here are the compiled executables I am trying to run.

    I ran the windows build script for ffmpeg.

    Here is a dumpbin /headers ffmpeg.exe

    Microsoft (R) COFF/PE Dumper Version 10.00.30319.01
    
Copyright (C) Microsoft Corporation.  All rights reserved.
    

    

    
Dump of file ffmpeg.exe
    

    
PE signature found
    

    
File Type: EXECUTABLE IMAGE
    

    
FILE HEADER VALUES
    
             14C machine (x86)
    
               7 number of sections
    
           51A40 time date stamp Sun Jan 04 15:53:20 1970
    
               0 file pointer to symbol table
    
               0 number of symbols
    
              E0 size of optional header
    
             32F characteristics
    
                   Relocations stripped
    
                   Executable
    
                   Line numbers stripped
    
                   Symbols stripped
    
                   Application can handle large (>2GB) addresses
    
                   32 bit word machine
    
                   Debug information stripped
    

    
OPTIONAL HEADER VALUES
    
             10B magic # (PE32)
    
            2.25 linker version
    
           41400 size of code
    
           4FA00 size of initialized data
    
            1200 size of uninitialized data
    
            14E0 entry point (004014E0)
    
            1000 base of code
    
           43000 base of data
    
          400000 image base (00400000 to 00456FFF)
    
            1000 section alignment
    
             200 file alignment
    
            4.00 operating system version
    
            1.00 image version
    
            4.00 subsystem version
    
               0 Win32 version
    
           57000 size of image
    
             400 size of headers
    
           597A9 checksum
    
               3 subsystem (Windows CUI)
    
             140 DLL characteristics
    
                   Dynamic base
    
                   NX compatible
    
          200000 size of stack reserve
    
            1000 size of stack commit
    
          100000 size of heap reserve
    
            1000 size of heap commit
    
               0 loader flags
    
              10 number of directories
    
               0 [       0] RVA [size] of Export Directory
    
           51000 [    36F0] RVA [size] of Import Directory
    
               0 [       0] RVA [size] of Resource Directory
    
               0 [       0] RVA [size] of Exception Directory
    
               0 [       0] RVA [size] of Certificates Directory
    
               0 [       0] RVA [size] of Base Relocation Directory
    
               0 [       0] RVA [size] of Debug Directory
    
               0 [       0] RVA [size] of Architecture Directory
    
               0 [       0] RVA [size] of Global Pointer Directory
    
           56004 [      18] RVA [size] of Thread Storage Directory
    
               0 [       0] RVA [size] of Load Configuration Directory
    
               0 [       0] RVA [size] of Bound Import Directory
    
           517F0 [     6C4] RVA [size] of Import Address Table Directory
    
               0 [       0] RVA [size] of Delay Import Directory
    
               0 [       0] RVA [size] of COM Descriptor Directory
    
               0 [       0] RVA [size] of Reserved Directory
    

    

    
SECTION HEADER #1
    
   .text name
    
   412BC virtual size
    
    1000 virtual address (00401000 to 004422BB)
    
   41400 size of raw data
    
     400 file pointer to raw data (00000400 to 000417FF)
    
       0 file pointer to relocation table
    
       0 file pointer to line numbers
    
       0 number of relocations
    
       0 number of line numbers
    
60500060 flags
    
         Code
    
         Initialized Data
    
         RESERVED - UNKNOWN
    
         RESERVED - UNKNOWN
    
         Execute Read
    

    
SECTION HEADER #2
    
   .data name
    
     19C virtual size
    
   43000 virtual address (00443000 to 0044319B)
    
     200 size of raw data
    
   41800 file pointer to raw data (00041800 to 000419FF)
    
       0 file pointer to relocation table
    
       0 file pointer to line numbers
    
       0 number of relocations
    
       0 number of line numbers
    
C0700040 flags
    
         Initialized Data
    
         RESERVED - UNKNOWN
    
         RESERVED - UNKNOWN
    
         RESERVED - UNKNOWN
    
         Read Write
    

    
SECTION HEADER #3
    
  .rdata name
    
    A7D8 virtual size
    
   44000 virtual address (00444000 to 0044E7D7)
    
    A800 size of raw data
    
   41A00 file pointer to raw data (00041A00 to 0004C1FF)
    
       0 file pointer to relocation table
    
       0 file pointer to line numbers
    
       0 number of relocations
    
       0 number of line numbers
    
40700040 flags
    
         Initialized Data
    
         RESERVED - UNKNOWN
    
         RESERVED - UNKNOWN
    
         RESERVED - UNKNOWN
    
         Read Only
    

    
SECTION HEADER #4
    
    .bss name
    
    1200 virtual size
    
   4F000 virtual address (0044F000 to 004501FF)
    
       0 size of raw data
    
       0 file pointer to raw data
    
       0 file pointer to relocation table
    
       0 file pointer to line numbers
    
       0 number of relocations
    
       0 number of line numbers
    
C0700080 flags
    
         Uninitialized Data
    
         RESERVED - UNKNOWN
    
         RESERVED - UNKNOWN
    
         RESERVED - UNKNOWN
    
         Read Write
    

    
SECTION HEADER #5
    
  .idata name
    
    36F0 virtual size
    
   51000 virtual address (00451000 to 004546EF)
    
    3800 size of raw data
    
   4C200 file pointer to raw data (0004C200 to 0004F9FF)
    
       0 file pointer to relocation table
    
       0 file pointer to line numbers
    
       0 number of relocations
    
       0 number of line numbers
    
C0300040 flags
    
         Initialized Data
    
         RESERVED - UNKNOWN
    
         RESERVED - UNKNOWN
    
         Read Write
    

    
SECTION HEADER #6
    
    .CRT name
    
      3C virtual size
    
   55000 virtual address (00455000 to 0045503B)
    
     200 size of raw data
    
   4FA00 file pointer to raw data (0004FA00 to 0004FBFF)
    
       0 file pointer to relocation table
    
       0 file pointer to line numbers
    
       0 number of relocations
    
       0 number of line numbers
    
C0300040 flags
    
         Initialized Data
    
         RESERVED - UNKNOWN
    
         RESERVED - UNKNOWN
    
         Read Write
    

    
SECTION HEADER #7
    
    .tls name
    
      20 virtual size
    
   56000 virtual address (00456000 to 0045601F)
    
     200 size of raw data
    
   4FC00 file pointer to raw data (0004FC00 to 0004FDFF)
    
       0 file pointer to relocation table
    
       0 file pointer to line numbers
    
       0 number of relocations
    
       0 number of line numbers
    
C0300040 flags
    
         Initialized Data
    
         RESERVED - UNKNOWN
    
         RESERVED - UNKNOWN
    
         Read Write
    

    
  Summary
    

    
        1000 .CRT
    
        2000 .bss
    
        1000 .data
    
        4000 .idata
    
        B000 .rdata
    
       42000 .text
    
        1000 .tls

    When I attempt to run the executable on XP, it just closes. There is no "missing dll" messages, nor anything in the event viewer.

  • Cortex-A7 instruction cycle timings

    15 mai 2014, par Mans — ARM

    The Cortex-A7 ARM core is a popular choice in low-power and low-cost designs. Unfortunately, the public TRM does not include instruction timing information. It does reveal that execution is in-order which makes measuring the throughput and latency for individual instructions relatively straight-forward.

    The table below lists the measured issue cycles (inverse throughput) and result latency of some commonly used instructions.

    It should be noted that in some cases, the perceived latency depends on the instruction consuming the result. Most of the values were measured with the result used as input to the same instruction. For instructions with multiple outputs, the latencies of the result registers may also differ.

    Finally, although instruction issue is in-order, completion is out of order, allowing independent instructions to issue and complete unimpeded while a multi-cycle instruction is executing in another unit. For example, a 3-cycle MUL instruction does not block ADD instructions following it in program order.

    ALU instructions Issue cycles Result latency
    MOV Rd, Rm 1/2 1
    ADD Rd, Rn, #imm 1/2 1
    ADD Rd, Rn, Rm 1 1
    ADD Rd, Rn, Rm, LSL #imm 1 1
    ADD Rd, Rn, Rm, LSL Rs 1 1
    LSL Rd, Rn, #imm 1 2
    LSL Rd, Rn, Rs 1 2
    QADD Rd, Rn, Rm 1 2
    QADD8 Rd, Rn, Rm 1 2
    QADD16 Rd, Rn, Rm 1 2
    CLZ Rd, Rm 1 1
    RBIT Rd, Rm 1 2
    REV Rd, Rm 1 2
    SBFX Rd, Rn 1 2
    BFC Rd, #lsb, #width 1 2
    BFI Rd, Rn, #lsb, #width 1 2
    NOTE : Shifted operands and shift amounts needed one cycle early.
    Multiply instructions Issue cycles Result latency
    MUL Rd, Rn, Rm 1 3
    MLA Rd, Rn, Rm, Ra 1 31
    SMULL Rd, RdHi, Rn, Rm 1 3
    SMLAL Rd, RdHi, Rn, Rm 1 31
    SMMUL Rd, Rn, Rm 1 3
    SMMLA Rd, Rn, Rm, Ra 1 31
    SMULBB Rd, Rn, Rm 1 3
    SMLABB Rd, Rn, Rm, Ra 1 31
    SMULWB Rd, Rn, Rm 1 3
    SMLAWB Rd, Rn, Rm, Ra 1 31
    SMUAD Rd, Rn, Rm 1 3
    1 Accumulator forwarding allows back to back MLA instructions without delay.
    Divide instructions Issue cycles Result latency
    SDIV Rd, Rn, Rm 4-20 6-22
    UDIV Rd, Rn, Rm 3-19 5-21
    Load/store instructions Issue cycles Result latency
    LDR Rt, [Rn] 1 3
    LDR Rt, [Rn, #imm] 1 3
    LDR Rt, [Rn, Rm] 1 3
    LDR Rt, [Rn, Rm, lsl #imm] 1 3
    LDRD Rt, Rt2, [Rn] 1 3-4
    LDM Rn, regs 1-8 3-10
    STR Rt, [Rn] 1 2
    STRD Rt, Rt2, [Rn] 1 2
    STM Rn, regs 1-10 2-12
    NOTE : Load results are forwarded to dependent stores without delay.
    VFP instructions Issue cycles Result latency
    VMOV.F32 Sd, Sm 1 4
    VMOV.F64 Dd, Dm 1 4
    VNEG.F32 Sd, Sm 1 4
    VNEG.F64 Dd, Dm 1 4
    VABS.F32 Sd, Sm 1 4
    VABS.F64 Dd, Dm 1 4
    VADD.F32 Sd, Sn, Sm 1 4
    VADD.F64 Dd, Dn, Dm 1 4
    VMUL.F32 Sd, Sn, Sm 1 4
    VMUL.F64 Dd, Dn, Dm 4 7
    VMLA.F32 Sd, Sn, Sm 1 81
    VMLA.F64 Dd, Dn, Dm 4 112
    VFMA.F32 Sd, Sn, Sm 1 81
    VFMA.F64 Dd, Dn, Dm 5 82
    VDIV.F32 Sd, Sn, Sm 15 18
    VDIV.F64 Dd, Dn, Dm 29 32
    VSQRT.F32 Sd, Sm 14 17
    VSQRT.F64 Dd, Dm 28 31
    VCVT.F32.F64 Sd, Dm 1 4
    VCVT.F64.F32 Dd, Sm 1 4
    VCVT.F32.S32 Sd, Sm 1 4
    VCVT.F64.S32 Dd, Sm 1 4
    VCVT.S32.F32 Sd, Sm 1 4
    VCVT.S32.F64 Sd, Dm 1 4
    VCVT.F32.S32 Sd, Sd, #fbits 1 4
    VCVT.F64.S32 Dd, Dd, #fbits 1 4
    VCVT.S32.F32 Sd, Sd, #fbits 1 4
    VCVT.S32.F64 Dd, Dd, #fbits 1 4
    1 5 cycles with dependency only on accumulator.
    2 8 cycles with dependency only on accumulator.
    NEON integer instructions Issue cycles Result latency
    VADD.I8 Dd, Dn, Dm 1 4
    VADDL.S8 Qd, Dn, Dm 2 4
    VADD.I8 Qd, Qn, Qm 2 4
    VMUL.I8 Dd, Dn, Dm 2 4
    VMULL.S8 Qd, Dn, Dm 2 4
    VMUL.I8 Qd, Qn, Qm 4 4
    VMLA.I8 Dd, Dn, Dm 2 4
    VMLAL.S8 Qd, Dn, Dm 2 4
    VMLA.I8 Qd, Qn, Qm 4 4
    VADD.I16 Dd, Dn, Dm 1 4
    VADDL.S16 Qd, Dn, Dm 2 4
    VADD.I16 Qd, Qn, Qm 2 4
    VMUL.I16 Dd, Dn, Dm 1 4
    VMULL.S16 Qd, Dn, Dm 2 4
    VMUL.I16 Qd, Qn, Qm 2 4
    VMLA.I16 Dd, Dn, Dm 1 4
    VMLAL.S16 Qd, Dn, Dm 2 4
    VMLA.I16 Qd, Qn, Qm 2 4
    VADD.I32 Dd, Dn, Dm 1 4
    VADDL.S32 Qd, Dn, Dm 2 4
    VADD.I32 Qd, Qn, Qm 2 4
    VMUL.I32 Dd, Dn, Dm 2 4
    VMULL.S32 Qd, Dn, Dm 2 4
    VMUL.I32 Qd, Qn, Qm 4 4
    VMLA.I32 Dd, Dn, Dm 2 4
    VMLAL.S32 Qd, Dn, Dm 2 4
    VMLA.I32 Qd, Qn, Qm 4 4
    NEON floating-point instructions Issue cycles Result latency
    VADD.F32 Dd, Dn, Dm 2 4
    VADD.F32 Qd, Qn, Qm 4 4
    VMUL.F32 Dd, Dn, Dm 2 4
    VMUL.F32 Qd, Qn, Qm 4 4
    VMLA.F32 Dd, Dn, Dm 2 81
    VMLA.F32 Qd, Qn, Qm 4 81
    1 5 cycles with dependency only on accumulator.
    NEON permute instructions Issue cycles Result latency
    VEXT.n Dd, Dn, Dm, #imm 1 4
    VEXT.n Qd, Qn, Qm, #imm 2 5
    VTRN.n Dd, Dn, Dm 2 5
    VTRN.n Qd, Qn, Qm 4 5
    VUZP.n Dd, Dn, Dm 2 5
    VUZP.n Qd, Qn, Qm 4 6
    VZIP.n Dd, Dn, Dm 2 5
    VZIP.n Qd, Qn, Qm 4 6
    VTBL.8 Dd, Dn, Dm 1 4
    VTBL.8 Dd, Dn-Dn+1, Dm 1 4
    VTBL.8 Dd, Dn-Dn+2, Dm 2 5
    VTBL.8 Dd, Dn-Dn+3, Dm 2 5

  • Running a py script in the Cloud

    12 janvier 2018, par Anay Bose

    I’m new to Google’s cloud & Virtual Machine(VM) instances, and I need some clarifications on a couple of points. I have a python script ; it imports a long range of functions. I need to run those functions in parallel. I’m using multiprocessing and Process, not threads. These functions are basically image and media processors, and they use many other tools like FFMPEG, imagemagick and Avisynth in addition to a wide range of python modules, including moviepy. Now, I would like to run some 50 functions in parallel assigning a CPU for each process. Images, media and avi files are stored in seperate folders. I’m on Windows7 Core-i7 machine. So, need cloud computing power.

    Now, my question can I run such a python script/app in the cloud that requires a very complicated file system and non-python tools i.e. ffmpeg, avisynth and avi files ?

    Can Google VMs emulate my local machine and empower me with more cores and memory to run such a program ? if not, then what are my options ? Is their any tutorials that I can follow ? I need your suggestions. I have given below an example script and some codes to help facilitate your understanding about my situation.

    from __future__ import unicode_literals
    
import youtube_dl
    
import os
    
import time
    
import sys
    
reload(sys)  
    
sys.setdefaultencoding('utf-8')
    
from multiprocessing import Process
    
from utils import *
    

    
from clip31 import VIDEO31
    
from clip32 import VIDEO32
    
from clip189 import VIDEO189
    
from clip16 import VIDEO16
    
from clip39 import VIDEO39
    

    

    
if __name__== '__main__':
    

    
    # 1. CALLING A FUNCTION
    
    folder = "bodyforce3\\16"
    
    serial = "16"
    
    images = get_filepaths("../16")
    
    videos = get_filepaths("12__media")
    
    pngs = get_filepaths("../pngs")
    

    
    Process(target=VIDEO192, args=(folder, serial, color1, color2, color3, images, videos)).start()
    

    

    
    # 2. CALLING A FUNCTION
    
    folder = "bodyforce3\\20"
    
    serial = "20"
    
    images = get_filepaths("../20")
    
    videos = get_filepaths("18__media")
    

    
    Process(target=VIDEO32, args=(folder, serial, color1, color2, color3, images, videos)).start()
    

    

    
    # 3. CALLING A FUNCTION
    
    folder = "bodyforce3\\14"
    
    serial = "14"
    
    images = get_filepaths("../14")
    
    videos = get_filepaths("16__media")
    

    
    Process(target=VIDEO91, args=(folder, serial, color1, color2, color3, images, videos)).start()

    I copy avi files in functions like this :

    src = "clip50_files"
    
src_files = os.listdir(src)
    
for file_name in src_files:
    
    full_file_name = os.path.join(src, file_name)
    
    if (os.path.isfile(full_file_name)):
    
        shutil.copy(full_file_name, folder)

    I call ffmpeg commands like this, and they are included within py functions.

    ###########################
    
#### FFMPEG OPERATIONS ####
    
###########################
    

    
print "Starting FFMPEG operations ..."
    

    
if os.path.isfile(os.path.join(folder, "bounce-(3).avi")):
    
    os.remove(os.path.join(folder, "bounce-(3).avi"))
    

    

    
infile = folder + "/bounce-(3).avs"
    
outfile = folder + "/bounce-(3).avi"
    
codec = "rawvideo"
    
pix_fmt = "bgra"
    

    
try:
    
    subprocess.call(["ffmpeg",
    
                     "-i" ,infile, 
    
                     "-c:v" ,codec, 
    
                     "-pix_fmt", pix_fmt, 
    
                     outfile],
    
                    stdout=open(os.devnull, 'w'), 
    
                    stderr=subprocess.STDOUT)
    
except subprocess.CalledProcessError as e:   
    
    #except subprocess.CalledProcessError as e:
    
    sys.exit(e.output)
    
except OSError as e:
    
    sys.exit(e.strerror)
    

    

    
print "FFMPEG operations ended"

Navigation