Recherche avancée
Médias (91)
-
Spoon - Revenge !
15 septembre 2011, par
Mis à jour : Septembre 2011
Langue : English
Type : Audio
-
My Morning Jacket - One Big Holiday
15 septembre 2011, par
Mis à jour : Septembre 2011
Langue : English
Type : Audio
-
Zap Mama - Wadidyusay ?
15 septembre 2011, par
Mis à jour : Septembre 2011
Langue : English
Type : Audio
-
David Byrne - My Fair Lady
15 septembre 2011, par
Mis à jour : Septembre 2011
Langue : English
Type : Audio
-
Beastie Boys - Now Get Busy
15 septembre 2011, par
Mis à jour : Septembre 2011
Langue : English
Type : Audio
-
Granite de l’Aber Ildut
9 septembre 2011, par
Mis à jour : Septembre 2011
Langue : français
Type : Texte
Autres articles (78)
-
Le profil des utilisateurs
12 avril 2011, parChaque utilisateur dispose d’une page de profil lui permettant de modifier ses informations personnelle. Dans le menu de haut de page par défaut, un élément de menu est automatiquement créé à l’initialisation de MediaSPIP, visible uniquement si le visiteur est identifié sur le site.
L’utilisateur a accès à la modification de profil depuis sa page auteur, un lien dans la navigation "Modifier votre profil" est (...) -
Configurer la prise en compte des langues
15 novembre 2010, parAccéder à la configuration et ajouter des langues prises en compte
Afin de configurer la prise en compte de nouvelles langues, il est nécessaire de se rendre dans la partie "Administrer" du site.
De là, dans le menu de navigation, vous pouvez accéder à une partie "Gestion des langues" permettant d’activer la prise en compte de nouvelles langues.
Chaque nouvelle langue ajoutée reste désactivable tant qu’aucun objet n’est créé dans cette langue. Dans ce cas, elle devient grisée dans la configuration et (...) -
XMP PHP
13 mai 2011, parDixit Wikipedia, XMP signifie :
Extensible Metadata Platform ou XMP est un format de métadonnées basé sur XML utilisé dans les applications PDF, de photographie et de graphisme. Il a été lancé par Adobe Systems en avril 2001 en étant intégré à la version 5.0 d’Adobe Acrobat.
Étant basé sur XML, il gère un ensemble de tags dynamiques pour l’utilisation dans le cadre du Web sémantique.
XMP permet d’enregistrer sous forme d’un document XML des informations relatives à un fichier : titre, auteur, historique (...)
Sur d’autres sites (13404)
-
avcodec/x86/vvc : add avg and avg_w AVX2 optimizations
23 janvier 2024, par Wu Jianhuaavcodec/x86/vvc : add avg and avg_w AVX2 optimizations
The avg/avg_w is based on dav1d.
See https://code.videolan.org/videolan/dav1d/-/blob/master/src/x86/mc_avx2.asmvvc_avg_8_2x2_c : 71.6
vvc_avg_8_2x2_avx2 : 26.8
vvc_avg_8_2x4_c : 140.8
vvc_avg_8_2x4_avx2 : 34.6
vvc_avg_8_2x8_c : 410.3
vvc_avg_8_2x8_avx2 : 41.3
vvc_avg_8_2x16_c : 769.3
vvc_avg_8_2x16_avx2 : 60.3
vvc_avg_8_2x32_c : 1669.6
vvc_avg_8_2x32_avx2 : 105.1
vvc_avg_8_2x64_c : 1978.3
vvc_avg_8_2x64_avx2 : 425.8
vvc_avg_8_2x128_c : 6536.8
vvc_avg_8_2x128_avx2 : 1315.1
vvc_avg_8_4x2_c : 155.6
vvc_avg_8_4x2_avx2 : 26.1
vvc_avg_8_4x4_c : 250.3
vvc_avg_8_4x4_avx2 : 31.3
vvc_avg_8_4x8_c : 831.8
vvc_avg_8_4x8_avx2 : 41.3
vvc_avg_8_4x16_c : 1461.1
vvc_avg_8_4x16_avx2 : 57.1
vvc_avg_8_4x32_c : 2821.6
vvc_avg_8_4x32_avx2 : 105.1
vvc_avg_8_4x64_c : 3615.8
vvc_avg_8_4x64_avx2 : 412.6
vvc_avg_8_4x128_c : 11962.6
vvc_avg_8_4x128_avx2 : 1274.3
vvc_avg_8_8x2_c : 215.8
vvc_avg_8_8x2_avx2 : 29.1
vvc_avg_8_8x4_c : 430.6
vvc_avg_8_8x4_avx2 : 37.6
vvc_avg_8_8x8_c : 1463.3
vvc_avg_8_8x8_avx2 : 51.8
vvc_avg_8_8x16_c : 2630.1
vvc_avg_8_8x16_avx2 : 97.6
vvc_avg_8_8x32_c : 5813.8
vvc_avg_8_8x32_avx2 : 196.6
vvc_avg_8_8x64_c : 6687.3
vvc_avg_8_8x64_avx2 : 487.8
vvc_avg_8_8x128_c : 13178.6
vvc_avg_8_8x128_avx2 : 1290.6
vvc_avg_8_16x2_c : 443.8
vvc_avg_8_16x2_avx2 : 28.3
vvc_avg_8_16x4_c : 1253.3
vvc_avg_8_16x4_avx2 : 32.1
vvc_avg_8_16x8_c : 2236.3
vvc_avg_8_16x8_avx2 : 44.3
vvc_avg_8_16x16_c : 5127.8
vvc_avg_8_16x16_avx2 : 63.3
vvc_avg_8_16x32_c : 6573.3
vvc_avg_8_16x32_avx2 : 223.6
vvc_avg_8_16x64_c : 30311.8
vvc_avg_8_16x64_avx2 : 437.8
vvc_avg_8_16x128_c : 25693.3
vvc_avg_8_16x128_avx2 : 1266.8
vvc_avg_8_32x2_c : 954.6
vvc_avg_8_32x2_avx2 : 32.1
vvc_avg_8_32x4_c : 2359.6
vvc_avg_8_32x4_avx2 : 39.6
vvc_avg_8_32x8_c : 5703.6
vvc_avg_8_32x8_avx2 : 57.1
vvc_avg_8_32x16_c : 9967.6
vvc_avg_8_32x16_avx2 : 107.1
vvc_avg_8_32x32_c : 21327.6
vvc_avg_8_32x32_avx2 : 272.6
vvc_avg_8_32x64_c : 39240.8
vvc_avg_8_32x64_avx2 : 529.6
vvc_avg_8_32x128_c : 52580.8
vvc_avg_8_32x128_avx2 : 1338.8
vvc_avg_8_64x2_c : 1647.3
vvc_avg_8_64x2_avx2 : 38.8
vvc_avg_8_64x4_c : 5130.1
vvc_avg_8_64x4_avx2 : 58.8
vvc_avg_8_64x8_c : 6529.3
vvc_avg_8_64x8_avx2 : 88.3
vvc_avg_8_64x16_c : 19913.6
vvc_avg_8_64x16_avx2 : 162.3
vvc_avg_8_64x32_c : 39360.8
vvc_avg_8_64x32_avx2 : 295.8
vvc_avg_8_64x64_c : 49658.3
vvc_avg_8_64x64_avx2 : 784.1
vvc_avg_8_64x128_c : 108513.1
vvc_avg_8_64x128_avx2 : 1977.1
vvc_avg_8_128x2_c : 3226.1
vvc_avg_8_128x2_avx2 : 61.1
vvc_avg_8_128x4_c : 10280.3
vvc_avg_8_128x4_avx2 : 94.6
vvc_avg_8_128x8_c : 18079.3
vvc_avg_8_128x8_avx2 : 155.3
vvc_avg_8_128x16_c : 45121.8
vvc_avg_8_128x16_avx2 : 285.3
vvc_avg_8_128x32_c : 48651.8
vvc_avg_8_128x32_avx2 : 581.6
vvc_avg_8_128x64_c : 165078.6
vvc_avg_8_128x64_avx2 : 1942.8
vvc_avg_8_128x128_c : 339103.1
vvc_avg_8_128x128_avx2 : 4332.6
vvc_avg_10_2x2_c : 144.3
vvc_avg_10_2x2_avx2 : 26.8
vvc_avg_10_2x4_c : 142.6
vvc_avg_10_2x4_avx2 : 45.3
vvc_avg_10_2x8_c : 478.1
vvc_avg_10_2x8_avx2 : 38.1
vvc_avg_10_2x16_c : 518.3
vvc_avg_10_2x16_avx2 : 58.1
vvc_avg_10_2x32_c : 2059.8
vvc_avg_10_2x32_avx2 : 93.1
vvc_avg_10_2x64_c : 2383.8
vvc_avg_10_2x64_avx2 : 714.8
vvc_avg_10_2x128_c : 4498.3
vvc_avg_10_2x128_avx2 : 1466.3
vvc_avg_10_4x2_c : 228.6
vvc_avg_10_4x2_avx2 : 26.8
vvc_avg_10_4x4_c : 378.3
vvc_avg_10_4x4_avx2 : 30.6
vvc_avg_10_4x8_c : 866.8
vvc_avg_10_4x8_avx2 : 44.6
vvc_avg_10_4x16_c : 1018.1
vvc_avg_10_4x16_avx2 : 58.1
vvc_avg_10_4x32_c : 3590.8
vvc_avg_10_4x32_avx2 : 128.8
vvc_avg_10_4x64_c : 4200.8
vvc_avg_10_4x64_avx2 : 663.6
vvc_avg_10_4x128_c : 8450.8
vvc_avg_10_4x128_avx2 : 1531.8
vvc_avg_10_8x2_c : 369.3
vvc_avg_10_8x2_avx2 : 28.3
vvc_avg_10_8x4_c : 513.8
vvc_avg_10_8x4_avx2 : 32.1
vvc_avg_10_8x8_c : 1720.3
vvc_avg_10_8x8_avx2 : 49.1
vvc_avg_10_8x16_c : 1894.8
vvc_avg_10_8x16_avx2 : 71.6
vvc_avg_10_8x32_c : 3931.3
vvc_avg_10_8x32_avx2 : 148.1
vvc_avg_10_8x64_c : 7964.3
vvc_avg_10_8x64_avx2 : 613.1
vvc_avg_10_8x128_c : 15540.1
vvc_avg_10_8x128_avx2 : 1585.1
vvc_avg_10_16x2_c : 877.3
vvc_avg_10_16x2_avx2 : 27.6
vvc_avg_10_16x4_c : 955.8
vvc_avg_10_16x4_avx2 : 29.8
vvc_avg_10_16x8_c : 3419.6
vvc_avg_10_16x8_avx2 : 62.6
vvc_avg_10_16x16_c : 3826.8
vvc_avg_10_16x16_avx2 : 54.3
vvc_avg_10_16x32_c : 7655.3
vvc_avg_10_16x32_avx2 : 86.3
vvc_avg_10_16x64_c : 30011.1
vvc_avg_10_16x64_avx2 : 692.6
vvc_avg_10_16x128_c : 47894.8
vvc_avg_10_16x128_avx2 : 1580.3
vvc_avg_10_32x2_c : 944.3
vvc_avg_10_32x2_avx2 : 29.8
vvc_avg_10_32x4_c : 2022.6
vvc_avg_10_32x4_avx2 : 35.1
vvc_avg_10_32x8_c : 6148.8
vvc_avg_10_32x8_avx2 : 51.3
vvc_avg_10_32x16_c : 12601.6
vvc_avg_10_32x16_avx2 : 70.8
vvc_avg_10_32x32_c : 15958.6
vvc_avg_10_32x32_avx2 : 124.3
vvc_avg_10_32x64_c : 31784.6
vvc_avg_10_32x64_avx2 : 757.3
vvc_avg_10_32x128_c : 63892.8
vvc_avg_10_32x128_avx2 : 1711.3
vvc_avg_10_64x2_c : 1890.8
vvc_avg_10_64x2_avx2 : 34.3
vvc_avg_10_64x4_c : 6267.3
vvc_avg_10_64x4_avx2 : 42.6
vvc_avg_10_64x8_c : 12778.1
vvc_avg_10_64x8_avx2 : 67.8
vvc_avg_10_64x16_c : 22304.3
vvc_avg_10_64x16_avx2 : 116.8
vvc_avg_10_64x32_c : 30777.1
vvc_avg_10_64x32_avx2 : 201.1
vvc_avg_10_64x64_c : 60169.1
vvc_avg_10_64x64_avx2 : 1454.3
vvc_avg_10_64x128_c : 124392.8
vvc_avg_10_64x128_avx2 : 3648.6
vvc_avg_10_128x2_c : 3650.1
vvc_avg_10_128x2_avx2 : 41.1
vvc_avg_10_128x4_c : 22887.8
vvc_avg_10_128x4_avx2 : 64.1
vvc_avg_10_128x8_c : 14622.6
vvc_avg_10_128x8_avx2 : 111.6
vvc_avg_10_128x16_c : 62207.6
vvc_avg_10_128x16_avx2 : 186.3
vvc_avg_10_128x32_c : 59761.3
vvc_avg_10_128x32_avx2 : 374.6
vvc_avg_10_128x64_c : 117504.3
vvc_avg_10_128x64_avx2 : 2684.6
vvc_avg_10_128x128_c : 236767.6
vvc_avg_10_128x128_avx2 : 15278.1
vvc_avg_12_2x2_c : 78.6
vvc_avg_12_2x2_avx2 : 26.1
vvc_avg_12_2x4_c : 254.1
vvc_avg_12_2x4_avx2 : 30.6
vvc_avg_12_2x8_c : 261.8
vvc_avg_12_2x8_avx2 : 39.1
vvc_avg_12_2x16_c : 527.6
vvc_avg_12_2x16_avx2 : 57.3
vvc_avg_12_2x32_c : 1089.1
vvc_avg_12_2x32_avx2 : 93.8
vvc_avg_12_2x64_c : 2337.6
vvc_avg_12_2x64_avx2 : 707.1
vvc_avg_12_2x128_c : 4582.1
vvc_avg_12_2x128_avx2 : 1414.6
vvc_avg_12_4x2_c : 129.6
vvc_avg_12_4x2_avx2 : 26.8
vvc_avg_12_4x4_c : 427.3
vvc_avg_12_4x4_avx2 : 30.6
vvc_avg_12_4x8_c : 529.6
vvc_avg_12_4x8_avx2 : 36.6
vvc_avg_12_4x16_c : 1022.1
vvc_avg_12_4x16_avx2 : 57.3
vvc_avg_12_4x32_c : 1987.6
vvc_avg_12_4x32_avx2 : 84.3
vvc_avg_12_4x64_c : 4147.6
vvc_avg_12_4x64_avx2 : 706.3
vvc_avg_12_4x128_c : 8469.3
vvc_avg_12_4x128_avx2 : 1448.3
vvc_avg_12_8x2_c : 253.6
vvc_avg_12_8x2_avx2 : 27.6
vvc_avg_12_8x4_c : 836.3
vvc_avg_12_8x4_avx2 : 32.1
vvc_avg_12_8x8_c : 1074.6
vvc_avg_12_8x8_avx2 : 45.1
vvc_avg_12_8x16_c : 3616.8
vvc_avg_12_8x16_avx2 : 71.6
vvc_avg_12_8x32_c : 3823.6
vvc_avg_12_8x32_avx2 : 140.1
vvc_avg_12_8x64_c : 7764.8
vvc_avg_12_8x64_avx2 : 656.1
vvc_avg_12_8x128_c : 15896.1
vvc_avg_12_8x128_avx2 : 1232.8
vvc_avg_12_16x2_c : 462.1
vvc_avg_12_16x2_avx2 : 26.8
vvc_avg_12_16x4_c : 1732.1
vvc_avg_12_16x4_avx2 : 29.1
vvc_avg_12_16x8_c : 2097.6
vvc_avg_12_16x8_avx2 : 62.6
vvc_avg_12_16x16_c : 6753.1
vvc_avg_12_16x16_avx2 : 47.8
vvc_avg_12_16x32_c : 7373.1
vvc_avg_12_16x32_avx2 : 80.8
vvc_avg_12_16x64_c : 15046.3
vvc_avg_12_16x64_avx2 : 621.1
vvc_avg_12_16x128_c : 52574.6
vvc_avg_12_16x128_avx2 : 1417.1
vvc_avg_12_32x2_c : 1712.1
vvc_avg_12_32x2_avx2 : 29.8
vvc_avg_12_32x4_c : 2036.8
vvc_avg_12_32x4_avx2 : 37.6
vvc_avg_12_32x8_c : 4017.6
vvc_avg_12_32x8_avx2 : 44.1
vvc_avg_12_32x16_c : 8018.6
vvc_avg_12_32x16_avx2 : 70.8
vvc_avg_12_32x32_c : 15637.6
vvc_avg_12_32x32_avx2 : 124.3
vvc_avg_12_32x64_c : 31143.3
vvc_avg_12_32x64_avx2 : 830.3
vvc_avg_12_32x128_c : 75706.8
vvc_avg_12_32x128_avx2 : 1604.8
vvc_avg_12_64x2_c : 3230.3
vvc_avg_12_64x2_avx2 : 33.6
vvc_avg_12_64x4_c : 4139.6
vvc_avg_12_64x4_avx2 : 45.1
vvc_avg_12_64x8_c : 8201.6
vvc_avg_12_64x8_avx2 : 67.1
vvc_avg_12_64x16_c : 25632.3
vvc_avg_12_64x16_avx2 : 110.3
vvc_avg_12_64x32_c : 30744.3
vvc_avg_12_64x32_avx2 : 200.3
vvc_avg_12_64x64_c : 105554.8
vvc_avg_12_64x64_avx2 : 1325.6
vvc_avg_12_64x128_c : 235254.3
vvc_avg_12_64x128_avx2 : 3132.6
vvc_avg_12_128x2_c : 6194.3
vvc_avg_12_128x2_avx2 : 55.1
vvc_avg_12_128x4_c : 7583.8
vvc_avg_12_128x4_avx2 : 79.3
vvc_avg_12_128x8_c : 14635.6
vvc_avg_12_128x8_avx2 : 104.3
vvc_avg_12_128x16_c : 29270.8
vvc_avg_12_128x16_avx2 : 194.3
vvc_avg_12_128x32_c : 60113.6
vvc_avg_12_128x32_avx2 : 346.3
vvc_avg_12_128x64_c : 197030.3
vvc_avg_12_128x64_avx2 : 2779.6
vvc_avg_12_128x128_c : 432809.6
vvc_avg_12_128x128_avx2 : 5513.3
vvc_w_avg_8_2x2_c : 84.3
vvc_w_avg_8_2x2_avx2 : 42.6
vvc_w_avg_8_2x4_c : 156.3
vvc_w_avg_8_2x4_avx2 : 58.8
vvc_w_avg_8_2x8_c : 310.6
vvc_w_avg_8_2x8_avx2 : 73.1
vvc_w_avg_8_2x16_c : 942.1
vvc_w_avg_8_2x16_avx2 : 113.3
vvc_w_avg_8_2x32_c : 1098.8
vvc_w_avg_8_2x32_avx2 : 202.6
vvc_w_avg_8_2x64_c : 2414.3
vvc_w_avg_8_2x64_avx2 : 467.6
vvc_w_avg_8_2x128_c : 4763.8
vvc_w_avg_8_2x128_avx2 : 1333.1
vvc_w_avg_8_4x2_c : 140.1
vvc_w_avg_8_4x2_avx2 : 49.8
vvc_w_avg_8_4x4_c : 276.3
vvc_w_avg_8_4x4_avx2 : 58.1
vvc_w_avg_8_4x8_c : 524.3
vvc_w_avg_8_4x8_avx2 : 72.3
vvc_w_avg_8_4x16_c : 1108.1
vvc_w_avg_8_4x16_avx2 : 111.8
vvc_w_avg_8_4x32_c : 2149.8
vvc_w_avg_8_4x32_avx2 : 199.6
vvc_w_avg_8_4x64_c : 12288.1
vvc_w_avg_8_4x64_avx2 : 509.3
vvc_w_avg_8_4x128_c : 8398.6
vvc_w_avg_8_4x128_avx2 : 1319.6
vvc_w_avg_8_8x2_c : 271.1
vvc_w_avg_8_8x2_avx2 : 44.1
vvc_w_avg_8_8x4_c : 503.3
vvc_w_avg_8_8x4_avx2 : 61.8
vvc_w_avg_8_8x8_c : 1031.1
vvc_w_avg_8_8x8_avx2 : 93.8
vvc_w_avg_8_8x16_c : 2009.8
vvc_w_avg_8_8x16_avx2 : 163.1
vvc_w_avg_8_8x32_c : 4161.3
vvc_w_avg_8_8x32_avx2 : 292.1
vvc_w_avg_8_8x64_c : 7940.6
vvc_w_avg_8_8x64_avx2 : 592.1
vvc_w_avg_8_8x128_c : 16802.3
vvc_w_avg_8_8x128_avx2 : 1287.6
vvc_w_avg_8_16x2_c : 762.6
vvc_w_avg_8_16x2_avx2 : 53.6
vvc_w_avg_8_16x4_c : 1486.3
vvc_w_avg_8_16x4_avx2 : 67.1
vvc_w_avg_8_16x8_c : 1907.8
vvc_w_avg_8_16x8_avx2 : 96.8
vvc_w_avg_8_16x16_c : 3883.6
vvc_w_avg_8_16x16_avx2 : 151.3
vvc_w_avg_8_16x32_c : 7974.8
vvc_w_avg_8_16x32_avx2 : 285.8
vvc_w_avg_8_16x64_c : 25160.6
vvc_w_avg_8_16x64_avx2 : 589.8
vvc_w_avg_8_16x128_c : 58328.1
vvc_w_avg_8_16x128_avx2 : 1169.8
vvc_w_avg_8_32x2_c : 1009.1
vvc_w_avg_8_32x2_avx2 : 65.6
vvc_w_avg_8_32x4_c : 2091.1
vvc_w_avg_8_32x4_avx2 : 96.8
vvc_w_avg_8_32x8_c : 3997.8
vvc_w_avg_8_32x8_avx2 : 156.3
vvc_w_avg_8_32x16_c : 8216.8
vvc_w_avg_8_32x16_avx2 : 269.6
vvc_w_avg_8_32x32_c : 21746.1
vvc_w_avg_8_32x32_avx2 : 635.3
vvc_w_avg_8_32x64_c : 31564.8
vvc_w_avg_8_32x64_avx2 : 1010.6
vvc_w_avg_8_32x128_c : 114373.3
vvc_w_avg_8_32x128_avx2 : 2013.6
vvc_w_avg_8_64x2_c : 2067.3
vvc_w_avg_8_64x2_avx2 : 97.6
vvc_w_avg_8_64x4_c : 3901.1
vvc_w_avg_8_64x4_avx2 : 154.8
vvc_w_avg_8_64x8_c : 7911.6
vvc_w_avg_8_64x8_avx2 : 268.8
vvc_w_avg_8_64x16_c : 16508.8
vvc_w_avg_8_64x16_avx2 : 501.8
vvc_w_avg_8_64x32_c : 38770.3
vvc_w_avg_8_64x32_avx2 : 1287.6
vvc_w_avg_8_64x64_c : 110350.6
vvc_w_avg_8_64x64_avx2 : 1890.8
vvc_w_avg_8_64x128_c : 141354.6
vvc_w_avg_8_64x128_avx2 : 3839.6
vvc_w_avg_8_128x2_c : 7012.1
vvc_w_avg_8_128x2_avx2 : 159.3
vvc_w_avg_8_128x4_c : 8146.8
vvc_w_avg_8_128x4_avx2 : 272.6
vvc_w_avg_8_128x8_c : 24596.8
vvc_w_avg_8_128x8_avx2 : 501.1
vvc_w_avg_8_128x16_c : 35918.1
vvc_w_avg_8_128x16_avx2 : 948.8
vvc_w_avg_8_128x32_c : 68799.6
vvc_w_avg_8_128x32_avx2 : 1963.1
vvc_w_avg_8_128x64_c : 133862.1
vvc_w_avg_8_128x64_avx2 : 3833.6
vvc_w_avg_8_128x128_c : 348427.8
vvc_w_avg_8_128x128_avx2 : 7682.8
vvc_w_avg_10_2x2_c : 118.6
vvc_w_avg_10_2x2_avx2 : 73.1
vvc_w_avg_10_2x4_c : 189.1
vvc_w_avg_10_2x4_avx2 : 89.3
vvc_w_avg_10_2x8_c : 382.8
vvc_w_avg_10_2x8_avx2 : 179.8
vvc_w_avg_10_2x16_c : 658.3
vvc_w_avg_10_2x16_avx2 : 185.1
vvc_w_avg_10_2x32_c : 1409.3
vvc_w_avg_10_2x32_avx2 : 290.8
vvc_w_avg_10_2x64_c : 2906.8
vvc_w_avg_10_2x64_avx2 : 793.1
vvc_w_avg_10_2x128_c : 6292.6
vvc_w_avg_10_2x128_avx2 : 1696.8
vvc_w_avg_10_4x2_c : 178.8
vvc_w_avg_10_4x2_avx2 : 80.1
vvc_w_avg_10_4x4_c : 581.6
vvc_w_avg_10_4x4_avx2 : 97.6
vvc_w_avg_10_4x8_c : 693.3
vvc_w_avg_10_4x8_avx2 : 128.1
vvc_w_avg_10_4x16_c : 1436.6
vvc_w_avg_10_4x16_avx2 : 179.8
vvc_w_avg_10_4x32_c : 2409.1
vvc_w_avg_10_4x32_avx2 : 292.3
vvc_w_avg_10_4x64_c : 4925.3
vvc_w_avg_10_4x64_avx2 : 746.1
vvc_w_avg_10_4x128_c : 10664.6
vvc_w_avg_10_4x128_avx2 : 1647.6
vvc_w_avg_10_8x2_c : 359.3
vvc_w_avg_10_8x2_avx2 : 80.1
vvc_w_avg_10_8x4_c : 925.6
vvc_w_avg_10_8x4_avx2 : 97.6
vvc_w_avg_10_8x8_c : 1360.6
vvc_w_avg_10_8x8_avx2 : 121.8
vvc_w_avg_10_8x16_c : 3490.3
vvc_w_avg_10_8x16_avx2 : 203.3
vvc_w_avg_10_8x32_c : 5266.1
vvc_w_avg_10_8x32_avx2 : 325.8
vvc_w_avg_10_8x64_c : 11127.1
vvc_w_avg_10_8x64_avx2 : 747.8
vvc_w_avg_10_8x128_c : 31058.3
vvc_w_avg_10_8x128_avx2 : 1424.6
vvc_w_avg_10_16x2_c : 624.8
vvc_w_avg_10_16x2_avx2 : 84.6
vvc_w_avg_10_16x4_c : 1389.6
vvc_w_avg_10_16x4_avx2 : 109.1
vvc_w_avg_10_16x8_c : 2688.3
vvc_w_avg_10_16x8_avx2 : 137.1
vvc_w_avg_10_16x16_c : 5387.1
vvc_w_avg_10_16x16_avx2 : 224.6
vvc_w_avg_10_16x32_c : 10776.3
vvc_w_avg_10_16x32_avx2 : 312.1
vvc_w_avg_10_16x64_c : 18069.1
vvc_w_avg_10_16x64_avx2 : 858.6
vvc_w_avg_10_16x128_c : 43460.3
vvc_w_avg_10_16x128_avx2 : 1411.6
vvc_w_avg_10_32x2_c : 1232.8
vvc_w_avg_10_32x2_avx2 : 99.1
vvc_w_avg_10_32x4_c : 4017.6
vvc_w_avg_10_32x4_avx2 : 134.1
vvc_w_avg_10_32x8_c : 9306.3
vvc_w_avg_10_32x8_avx2 : 208.1
vvc_w_avg_10_32x16_c : 8424.6
vvc_w_avg_10_32x16_avx2 : 349.3
vvc_w_avg_10_32x32_c : 20787.8
vvc_w_avg_10_32x32_avx2 : 655.3
vvc_w_avg_10_32x64_c : 40972.1
vvc_w_avg_10_32x64_avx2 : 904.8
vvc_w_avg_10_32x128_c : 85670.3
vvc_w_avg_10_32x128_avx2 : 1751.6
vvc_w_avg_10_64x2_c : 2454.1
vvc_w_avg_10_64x2_avx2 : 132.6
vvc_w_avg_10_64x4_c : 5012.6
vvc_w_avg_10_64x4_avx2 : 215.6
vvc_w_avg_10_64x8_c : 10811.3
vvc_w_avg_10_64x8_avx2 : 361.1
vvc_w_avg_10_64x16_c : 33349.1
vvc_w_avg_10_64x16_avx2 : 904.1
vvc_w_avg_10_64x32_c : 41892.3
vvc_w_avg_10_64x32_avx2 : 1220.6
vvc_w_avg_10_64x64_c : 66983.3
vvc_w_avg_10_64x64_avx2 : 2622.1
vvc_w_avg_10_64x128_c : 246508.8
vvc_w_avg_10_64x128_avx2 : 3316.8
vvc_w_avg_10_128x2_c : 7791.6
vvc_w_avg_10_128x2_avx2 : 198.8
vvc_w_avg_10_128x4_c : 10534.3
vvc_w_avg_10_128x4_avx2 : 337.3
vvc_w_avg_10_128x8_c : 21142.3
vvc_w_avg_10_128x8_avx2 : 614.8
vvc_w_avg_10_128x16_c : 40968.6
vvc_w_avg_10_128x16_avx2 : 1160.6
vvc_w_avg_10_128x32_c : 113043.3
vvc_w_avg_10_128x32_avx2 : 1644.6
vvc_w_avg_10_128x64_c : 230658.3
vvc_w_avg_10_128x64_avx2 : 5065.3
vvc_w_avg_10_128x128_c : 335236.3
vvc_w_avg_10_128x128_avx2 : 6450.3
vvc_w_avg_12_2x2_c : 185.3
vvc_w_avg_12_2x2_avx2 : 43.6
vvc_w_avg_12_2x4_c : 340.3
vvc_w_avg_12_2x4_avx2 : 55.8
vvc_w_avg_12_2x8_c : 632.3
vvc_w_avg_12_2x8_avx2 : 70.1
vvc_w_avg_12_2x16_c : 728.3
vvc_w_avg_12_2x16_avx2 : 108.1
vvc_w_avg_12_2x32_c : 1392.6
vvc_w_avg_12_2x32_avx2 : 176.8
vvc_w_avg_12_2x64_c : 2618.3
vvc_w_avg_12_2x64_avx2 : 757.3
vvc_w_avg_12_2x128_c : 6408.8
vvc_w_avg_12_2x128_avx2 : 1435.1
vvc_w_avg_12_4x2_c : 349.3
vvc_w_avg_12_4x2_avx2 : 44.3
vvc_w_avg_12_4x4_c : 607.1
vvc_w_avg_12_4x4_avx2 : 52.6
vvc_w_avg_12_4x8_c : 1134.8
vvc_w_avg_12_4x8_avx2 : 70.1
vvc_w_avg_12_4x16_c : 1378.1
vvc_w_avg_12_4x16_avx2 : 115.3
vvc_w_avg_12_4x32_c : 2599.3
vvc_w_avg_12_4x32_avx2 : 174.3
vvc_w_avg_12_4x64_c : 4474.8
vvc_w_avg_12_4x64_avx2 : 656.1
vvc_w_avg_12_4x128_c : 11319.6
vvc_w_avg_12_4x128_avx2 : 1373.1
vvc_w_avg_12_8x2_c : 595.8
vvc_w_avg_12_8x2_avx2 : 44.3
vvc_w_avg_12_8x4_c : 1164.3
vvc_w_avg_12_8x4_avx2 : 56.6
vvc_w_avg_12_8x8_c : 2019.6
vvc_w_avg_12_8x8_avx2 : 80.1
vvc_w_avg_12_8x16_c : 4071.6
vvc_w_avg_12_8x16_avx2 : 139.3
vvc_w_avg_12_8x32_c : 4485.1
vvc_w_avg_12_8x32_avx2 : 250.6
vvc_w_avg_12_8x64_c : 8404.8
vvc_w_avg_12_8x64_avx2 : 735.8
vvc_w_avg_12_8x128_c : 35679.8
vvc_w_avg_12_8x128_avx2 : 1252.6
vvc_w_avg_12_16x2_c : 1114.8
vvc_w_avg_12_16x2_avx2 : 46.6
vvc_w_avg_12_16x4_c : 2240.1
vvc_w_avg_12_16x4_avx2 : 62.6
vvc_w_avg_12_16x8_c : 13174.6
vvc_w_avg_12_16x8_avx2 : 88.6
vvc_w_avg_12_16x16_c : 5334.6
vvc_w_avg_12_16x16_avx2 : 144.3
vvc_w_avg_12_16x32_c : 8378.1
vvc_w_avg_12_16x32_avx2 : 234.6
vvc_w_avg_12_16x64_c : 21300.8
vvc_w_avg_12_16x64_avx2 : 761.8
vvc_w_avg_12_16x128_c : 32786.8
vvc_w_avg_12_16x128_avx2 : 1432.8
vvc_w_avg_12_32x2_c : 2154.3
vvc_w_avg_12_32x2_avx2 : 61.1
vvc_w_avg_12_32x4_c : 4299.8
vvc_w_avg_12_32x4_avx2 : 83.1
vvc_w_avg_12_32x8_c : 7964.8
vvc_w_avg_12_32x8_avx2 : 132.6
vvc_w_avg_12_32x16_c : 13321.6
vvc_w_avg_12_32x16_avx2 : 234.6
vvc_w_avg_12_32x32_c : 21149.3
vvc_w_avg_12_32x32_avx2 : 433.3
vvc_w_avg_12_32x64_c : 43666.6
vvc_w_avg_12_32x64_avx2 : 876.6
vvc_w_avg_12_32x128_c : 83189.8
vvc_w_avg_12_32x128_avx2 : 1756.6
vvc_w_avg_12_64x2_c : 3829.8
vvc_w_avg_12_64x2_avx2 : 83.1
vvc_w_avg_12_64x4_c : 8588.1
vvc_w_avg_12_64x4_avx2 : 127.1
vvc_w_avg_12_64x8_c : 17027.6
vvc_w_avg_12_64x8_avx2 : 310.6
vvc_w_avg_12_64x16_c : 29797.8
vvc_w_avg_12_64x16_avx2 : 415.6
vvc_w_avg_12_64x32_c : 43854.3
vvc_w_avg_12_64x32_avx2 : 773.3
vvc_w_avg_12_64x64_c : 137767.3
vvc_w_avg_12_64x64_avx2 : 1608.6
vvc_w_avg_12_64x128_c : 316428.3
vvc_w_avg_12_64x128_avx2 : 3249.8
vvc_w_avg_12_128x2_c : 8824.6
vvc_w_avg_12_128x2_avx2 : 130.3
vvc_w_avg_12_128x4_c : 17173.6
vvc_w_avg_12_128x4_avx2 : 219.3
vvc_w_avg_12_128x8_c : 21997.8
vvc_w_avg_12_128x8_avx2 : 397.3
vvc_w_avg_12_128x16_c : 43553.8
vvc_w_avg_12_128x16_avx2 : 790.1
vvc_w_avg_12_128x32_c : 89792.1
vvc_w_avg_12_128x32_avx2 : 1497.6
vvc_w_avg_12_128x64_c : 226573.3
vvc_w_avg_12_128x64_avx2 : 3153.1
vvc_w_avg_12_128x128_c : 332090.1
vvc_w_avg_12_128x128_avx2 : 6499.6Signed-off-by : Wu Jianhua <toqsxw@outlook.com>
-
How can I fix a segmentation fault in a C program ? [duplicate]
31 mars 2023, par ipegasus

Possible Duplicate :

Segmentation fault



Currently I am upgrading an open source program used for HTTP streaming. It needs to support the latest FFmpeg.
The code compiles fine without any warnings, although I am getting a segmentation fault error.


How can I fix the issue ? And / or, what is the best way to debug ? Please find attached a portion of the code due to size. I will try to add the project to GitHub :)


Sample Usage


# segmenter --i out.ts --l 10 --o stream.m3u8 --d segments --f stream


Makefile


FFLIBS=`pkg-config --libs libavformat libavcodec libavutil`
FFFLAGS=`pkg-config --cflags libavformat libavcodec libavutil`

all:
 gcc -Wall -g segmenter.c -o segmenter ${FFFLAGS} ${FFLIBS}


segmenter.c


/*
 * Copyright (c) 2009 Chase Douglas
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version 2
 * as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */
#include 
#include 
#include 
#include 
#include 
#include "libavformat/avformat.h"

#include "libavformat/avio.h"

#include <sys></sys>stat.h>

#include "segmenter.h"
#include "libavformat/avformat.h"

#define IMAGE_ID3_SIZE 9171

void printUsage() {
 fprintf(stderr, "\nExample: segmenter --i infile --d baseDir --f baseFileName --o playListFile.m3u8 --l 10 \n");
 fprintf(stderr, "\nOptions: \n");
 fprintf(stderr, "--i <infile>.\n");
 fprintf(stderr, "--o <outfile>.\n");
 fprintf(stderr, "--d basedir, the base directory for files.\n");
 fprintf(stderr, "--f baseFileName, output files will be baseFileName-#.\n");
 fprintf(stderr, "--l segment length, the length of each segment.\n");
 fprintf(stderr, "--a, audio only decode for < 64k streams.\n");
 fprintf(stderr, "--v, video only decode for < 64k streams.\n");
 fprintf(stderr, "--version, print version details and exit.\n");
 fprintf(stderr, "\n\n");
}

void ffmpeg_version() {
 // output build and version numbers
 fprintf(stderr, " libavutil version: %s\n", AV_STRINGIFY(LIBAVUTIL_VERSION));
 fprintf(stderr, " libavutil build: %d\n", LIBAVUTIL_BUILD);
 fprintf(stderr, " libavcodec version: %s\n", AV_STRINGIFY(LIBAVCODEC_VERSION));
 fprintf(stdout, " libavcodec build: %d\n", LIBAVCODEC_BUILD);
 fprintf(stderr, " libavformat version: %s\n", AV_STRINGIFY(LIBAVFORMAT_VERSION));
 fprintf(stderr, " libavformat build: %d\n", LIBAVFORMAT_BUILD);
 fprintf(stderr, " built on " __DATE__ " " __TIME__);
#ifdef __GNUC__
 fprintf(stderr, ", gcc: " __VERSION__ "\n");
#else
 fprintf(stderr, ", using a non-gcc compiler\n");
#endif
}


static AVStream *add_output_stream(AVFormatContext *output_format_context, AVStream *input_stream) {
 AVCodecContext *input_codec_context;
 AVCodecContext *output_codec_context;
 AVStream *output_stream;

 output_stream = avformat_new_stream(output_format_context, 0);
 if (!output_stream) {
 fprintf(stderr, "Segmenter error: Could not allocate stream\n");
 exit(1);
 }

 input_codec_context = input_stream->codec;
 output_codec_context = output_stream->codec;

 output_codec_context->codec_id = input_codec_context->codec_id;
 output_codec_context->codec_type = input_codec_context->codec_type;
 output_codec_context->codec_tag = input_codec_context->codec_tag;
 output_codec_context->bit_rate = input_codec_context->bit_rate;
 output_codec_context->extradata = input_codec_context->extradata;
 output_codec_context->extradata_size = input_codec_context->extradata_size;

 if (av_q2d(input_codec_context->time_base) * input_codec_context->ticks_per_frame > av_q2d(input_stream->time_base) && av_q2d(input_stream->time_base) < 1.0 / 1000) {
 output_codec_context->time_base = input_codec_context->time_base;
 output_codec_context->time_base.num *= input_codec_context->ticks_per_frame;
 } else {
 output_codec_context->time_base = input_stream->time_base;
 }

 switch (input_codec_context->codec_type) {
#ifdef USE_OLD_FFMPEG
 case CODEC_TYPE_AUDIO:
#else
 case AVMEDIA_TYPE_AUDIO:
#endif
 output_codec_context->channel_layout = input_codec_context->channel_layout;
 output_codec_context->sample_rate = input_codec_context->sample_rate;
 output_codec_context->channels = input_codec_context->channels;
 output_codec_context->frame_size = input_codec_context->frame_size;
 if ((input_codec_context->block_align == 1 && input_codec_context->codec_id == CODEC_ID_MP3) || input_codec_context->codec_id == CODEC_ID_AC3) {
 output_codec_context->block_align = 0;
 } else {
 output_codec_context->block_align = input_codec_context->block_align;
 }
 break;
#ifdef USE_OLD_FFMPEG
 case CODEC_TYPE_VIDEO:
#else
 case AVMEDIA_TYPE_VIDEO:
#endif
 output_codec_context->pix_fmt = input_codec_context->pix_fmt;
 output_codec_context->width = input_codec_context->width;
 output_codec_context->height = input_codec_context->height;
 output_codec_context->has_b_frames = input_codec_context->has_b_frames;

 if (output_format_context->oformat->flags & AVFMT_GLOBALHEADER) {
 output_codec_context->flags |= CODEC_FLAG_GLOBAL_HEADER;
 }
 break;
 default:
 break;
 }

 return output_stream;
}

int write_index_file(const char index[], const char tmp_index[], const unsigned int planned_segment_duration, const unsigned int actual_segment_duration[],
 const char output_directory[], const char output_prefix[], const char output_file_extension[],
 const unsigned int first_segment, const unsigned int last_segment) {
 FILE *index_fp;
 char *write_buf;
 unsigned int i;

 index_fp = fopen(tmp_index, "w");
 if (!index_fp) {
 fprintf(stderr, "Could not open temporary m3u8 index file (%s), no index file will be created\n", tmp_index);
 return -1;
 }

 write_buf = malloc(sizeof (char) * 1024);
 if (!write_buf) {
 fprintf(stderr, "Could not allocate write buffer for index file, index file will be invalid\n");
 fclose(index_fp);
 return -1;
 }

 unsigned int maxDuration = planned_segment_duration;

 for (i = first_segment; i <= last_segment; i++)
 if (actual_segment_duration[i] > maxDuration)
 maxDuration = actual_segment_duration[i];



 snprintf(write_buf, 1024, "#EXTM3U\n#EXT-X-TARGETDURATION:%u\n", maxDuration);

 if (fwrite(write_buf, strlen(write_buf), 1, index_fp) != 1) {
 fprintf(stderr, "Could not write to m3u8 index file, will not continue writing to index file\n");
 free(write_buf);
 fclose(index_fp);
 return -1;
 }

 for (i = first_segment; i <= last_segment; i++) {
 snprintf(write_buf, 1024, "#EXTINF:%u,\n%s-%u%s\n", actual_segment_duration[i], output_prefix, i, output_file_extension);
 if (fwrite(write_buf, strlen(write_buf), 1, index_fp) != 1) {
 fprintf(stderr, "Could not write to m3u8 index file, will not continue writing to index file\n");
 free(write_buf);
 fclose(index_fp);
 return -1;
 }
 }

 snprintf(write_buf, 1024, "#EXT-X-ENDLIST\n");
 if (fwrite(write_buf, strlen(write_buf), 1, index_fp) != 1) {
 fprintf(stderr, "Could not write last file and endlist tag to m3u8 index file\n");
 free(write_buf);
 fclose(index_fp);
 return -1;
 }

 free(write_buf);
 fclose(index_fp);

 return rename(tmp_index, index);
}

int main(int argc, const char *argv[]) {
 //input parameters
 char inputFilename[MAX_FILENAME_LENGTH], playlistFilename[MAX_FILENAME_LENGTH], baseDirName[MAX_FILENAME_LENGTH], baseFileName[MAX_FILENAME_LENGTH];
 char baseFileExtension[5]; //either "ts", "aac" or "mp3"
 int segmentLength, outputStreams, verbosity, version;



 char currentOutputFileName[MAX_FILENAME_LENGTH];
 char tempPlaylistName[MAX_FILENAME_LENGTH];


 //these are used to determine the exact length of the current segment
 double prev_segment_time = 0;
 double segment_time;
 unsigned int actual_segment_durations[2048];
 double packet_time = 0;

 //new variables to keep track of output size
 double output_bytes = 0;

 unsigned int output_index = 1;
 AVOutputFormat *ofmt;
 AVFormatContext *ic = NULL;
 AVFormatContext *oc;
 AVStream *video_st = NULL;
 AVStream *audio_st = NULL;
 AVCodec *codec;
 int video_index;
 int audio_index;
 unsigned int first_segment = 1;
 unsigned int last_segment = 0;
 int write_index = 1;
 int decode_done;
 int ret;
 int i;

 unsigned char id3_tag[128];
 unsigned char * image_id3_tag;

 size_t id3_tag_size = 73;
 int newFile = 1; //a boolean value to flag when a new file needs id3 tag info in it

 if (parseCommandLine(inputFilename, playlistFilename, baseDirName, baseFileName, baseFileExtension, &outputStreams, &segmentLength, &verbosity, &version, argc, argv) != 0)
 return 0;

 if (version) {
 ffmpeg_version();
 return 0;
 }


 fprintf(stderr, "%s %s\n", playlistFilename, tempPlaylistName);


 image_id3_tag = malloc(IMAGE_ID3_SIZE);
 if (outputStreams == OUTPUT_STREAM_AUDIO)
 build_image_id3_tag(image_id3_tag);
 build_id3_tag((char *) id3_tag, id3_tag_size);

 snprintf(tempPlaylistName, strlen(playlistFilename) + strlen(baseDirName) + 1, "%s%s", baseDirName, playlistFilename);
 strncpy(playlistFilename, tempPlaylistName, strlen(tempPlaylistName));
 strncpy(tempPlaylistName, playlistFilename, MAX_FILENAME_LENGTH);
 strncat(tempPlaylistName, ".", 1);

 //decide if this is an aac file or a mpegts file.
 //postpone deciding format until later
 /* ifmt = av_find_input_format("mpegts");
 if (!ifmt)
 {
 fprintf(stderr, "Could not find MPEG-TS demuxer.\n");
 exit(1);
 } */

 av_log_set_level(AV_LOG_DEBUG);

 av_register_all();
 ret = avformat_open_input(&ic, inputFilename, NULL, NULL);
 if (ret != 0) {
 fprintf(stderr, "Could not open input file %s. Error %d.\n", inputFilename, ret);
 exit(1);
 }

 if (avformat_find_stream_info(ic, NULL) < 0) {
 fprintf(stderr, "Could not read stream information.\n");
 exit(1);
 }

 oc = avformat_alloc_context();
 if (!oc) {
 fprintf(stderr, "Could not allocate output context.");
 exit(1);
 }

 video_index = -1;
 audio_index = -1;

 for (i = 0; i < ic->nb_streams && (video_index < 0 || audio_index < 0); i++) {
 switch (ic->streams[i]->codec->codec_type) {

#ifdef USE_OLD_FFMPEG
 case CODEC_TYPE_VIDEO:
#else
 case AVMEDIA_TYPE_VIDEO:
#endif
 video_index = i;
 ic->streams[i]->discard = AVDISCARD_NONE;
 if (outputStreams & OUTPUT_STREAM_VIDEO)
 video_st = add_output_stream(oc, ic->streams[i]);
 break;
#ifdef USE_OLD_FFMPEG
 case CODEC_TYPE_AUDIO:
#else
 case AVMEDIA_TYPE_AUDIO:
#endif
 audio_index = i;
 ic->streams[i]->discard = AVDISCARD_NONE;
 if (outputStreams & OUTPUT_STREAM_AUDIO)
 audio_st = add_output_stream(oc, ic->streams[i]);
 break;
 default:
 ic->streams[i]->discard = AVDISCARD_ALL;
 break;
 }
 }

 if (video_index == -1) {
 fprintf(stderr, "Stream must have video component.\n");
 exit(1);
 }

 //now that we know the audio and video output streams
 //we can decide on an output format.
 if (outputStreams == OUTPUT_STREAM_AUDIO) {
 //the audio output format should be the same as the audio input format
 switch (ic->streams[audio_index]->codec->codec_id) {
 case CODEC_ID_MP3:
 fprintf(stderr, "Setting output audio to mp3.");
 strncpy(baseFileExtension, ".mp3", strlen(".mp3"));
 ofmt = av_guess_format("mp3", NULL, NULL);
 break;
 case CODEC_ID_AAC:
 fprintf(stderr, "Setting output audio to aac.");
 ofmt = av_guess_format("adts", NULL, NULL);
 break;
 default:
 fprintf(stderr, "Codec id %d not supported.\n", ic->streams[audio_index]->id);
 }
 if (!ofmt) {
 fprintf(stderr, "Could not find audio muxer.\n");
 exit(1);
 }
 } else {
 ofmt = av_guess_format("mpegts", NULL, NULL);
 if (!ofmt) {
 fprintf(stderr, "Could not find MPEG-TS muxer.\n");
 exit(1);
 }
 }
 oc->oformat = ofmt;

 if (outputStreams & OUTPUT_STREAM_VIDEO && oc->oformat->flags & AVFMT_GLOBALHEADER) {
 oc->flags |= CODEC_FLAG_GLOBAL_HEADER;
 }


 /* Deprecated: pass the options to avformat_write_header directly.
 if (av_set_parameters(oc, NULL) < 0) {
 fprintf(stderr, "Invalid output format parameters.\n");
 exit(1);
 }
 */

 av_dump_format(oc, 0, baseFileName, 1);


 //open the video codec only if there is video data
 if (video_index != -1) {
 if (outputStreams & OUTPUT_STREAM_VIDEO)
 codec = avcodec_find_decoder(video_st->codec->codec_id);
 else
 codec = avcodec_find_decoder(ic->streams[video_index]->codec->codec_id);
 if (!codec) {
 fprintf(stderr, "Could not find video decoder, key frames will not be honored.\n");
 }

 if (outputStreams & OUTPUT_STREAM_VIDEO)
 ret = avcodec_open2(video_st->codec, codec, NULL);
 else
 avcodec_open2(ic->streams[video_index]->codec, codec, NULL);
 if (ret < 0) {
 fprintf(stderr, "Could not open video decoder, key frames will not be honored.\n");
 }
 }

 snprintf(currentOutputFileName, strlen(baseDirName) + strlen(baseFileName) + strlen(baseFileExtension) + 10, "%s%s-%u%s", baseDirName, baseFileName, output_index++, baseFileExtension);

 if (avio_open(&oc->pb, currentOutputFileName, URL_WRONLY) < 0) {
 fprintf(stderr, "Could not open '%s'.\n", currentOutputFileName);
 exit(1);
 }
 newFile = 1;

 int r = avformat_write_header(oc,NULL);
 if (r) {
 fprintf(stderr, "Could not write mpegts header to first output file.\n");
 debugReturnCode(r);
 exit(1);
 }

 //no segment info is written here. This just creates the shell of the playlist file
 write_index = !write_index_file(playlistFilename, tempPlaylistName, segmentLength, actual_segment_durations, baseDirName, baseFileName, baseFileExtension, first_segment, last_segment);

 do {
 AVPacket packet;

 decode_done = av_read_frame(ic, &packet);

 if (decode_done < 0) {
 break;
 }

 if (av_dup_packet(&packet) < 0) {
 fprintf(stderr, "Could not duplicate packet.");
 av_free_packet(&packet);
 break;
 }

 //this time is used to check for a break in the segments
 // if (packet.stream_index == video_index && (packet.flags & PKT_FLAG_KEY))
 // {
 // segment_time = (double)video_st->pts.val * video_st->time_base.num / video_st->time_base.den;
 // }
#if USE_OLD_FFMPEG
 if (packet.stream_index == video_index && (packet.flags & PKT_FLAG_KEY))
#else
 if (packet.stream_index == video_index && (packet.flags & AV_PKT_FLAG_KEY))
#endif
 {
 segment_time = (double) packet.pts * ic->streams[video_index]->time_base.num / ic->streams[video_index]->time_base.den;
 }
 // else if (video_index < 0)
 // {
 // segment_time = (double)audio_st->pts.val * audio_st->time_base.num / audio_st->time_base.den;
 // }

 //get the most recent packet time
 //this time is used when the time for the final segment is printed. It may not be on the edge of
 //of a keyframe!
 if (packet.stream_index == video_index)
 packet_time = (double) packet.pts * ic->streams[video_index]->time_base.num / ic->streams[video_index]->time_base.den; //(double)video_st->pts.val * video_st->time_base.num / video_st->time_base.den;
 else if (outputStreams & OUTPUT_STREAM_AUDIO)
 packet_time = (double) audio_st->pts.val * audio_st->time_base.num / audio_st->time_base.den;
 else
 continue;
 //start looking for segment splits for videos one half second before segment duration expires. This is because the
 //segments are split on key frames so we cannot expect all segments to be split exactly equally.
 if (segment_time - prev_segment_time >= segmentLength - 0.5) {
 fprintf(stderr, "looking to print index file at time %lf\n", segment_time);
 avio_flush(oc->pb);
 avio_close(oc->pb);

 if (write_index) {
 actual_segment_durations[++last_segment] = (unsigned int) rint(segment_time - prev_segment_time);
 write_index = !write_index_file(playlistFilename, tempPlaylistName, segmentLength, actual_segment_durations, baseDirName, baseFileName, baseFileExtension, first_segment, last_segment);
 fprintf(stderr, "Writing index file at time %lf\n", packet_time);
 }

 struct stat st;
 stat(currentOutputFileName, &st);
 output_bytes += st.st_size;

 snprintf(currentOutputFileName, strlen(baseDirName) + strlen(baseFileName) + strlen(baseFileExtension) + 10, "%s%s-%u%s", baseDirName, baseFileName, output_index++, baseFileExtension);
 if (avio_open(&oc->pb, currentOutputFileName, URL_WRONLY) < 0) {
 fprintf(stderr, "Could not open '%s'\n", currentOutputFileName);
 break;
 }

 newFile = 1;
 prev_segment_time = segment_time;
 }

 if (outputStreams == OUTPUT_STREAM_AUDIO && packet.stream_index == audio_index) {
 if (newFile && outputStreams == OUTPUT_STREAM_AUDIO) {
 //add id3 tag info
 //fprintf(stderr, "adding id3tag to file %s\n", currentOutputFileName);
 //printf("%lf %lld %lld %lld %lld %lld %lf\n", segment_time, audio_st->pts.val, audio_st->cur_dts, audio_st->cur_pkt.pts, packet.pts, packet.dts, packet.dts * av_q2d(ic->streams[audio_index]->time_base) );
 fill_id3_tag((char*) id3_tag, id3_tag_size, packet.dts);
 avio_write(oc->pb, id3_tag, id3_tag_size);
 avio_write(oc->pb, image_id3_tag, IMAGE_ID3_SIZE);
 avio_flush(oc->pb);
 newFile = 0;
 }

 packet.stream_index = 0; //only one stream in audio only segments
 ret = av_interleaved_write_frame(oc, &packet);
 } else if (outputStreams & OUTPUT_STREAM_VIDEO) {
 if (newFile) {
 //fprintf(stderr, "New File: %lld %lld %lld\n", packet.pts, video_st->pts.val, audio_st->pts.val);
 //printf("%lf %lld %lld %lld %lld %lld %lf\n", segment_time, audio_st->pts.val, audio_st->cur_dts, audio_st->cur_pkt.pts, packet.pts, packet.dts, packet.dts * av_q2d(ic->streams[audio_index]->time_base) );
 newFile = 0;
 }
 if (outputStreams == OUTPUT_STREAM_VIDEO)
 ret = av_write_frame(oc, &packet);
 else
 ret = av_interleaved_write_frame(oc, &packet);
 }

 if (ret < 0) {
 fprintf(stderr, "Warning: Could not write frame of stream.\n");
 } else if (ret > 0) {
 fprintf(stderr, "End of stream requested.\n");
 av_free_packet(&packet);
 break;
 }

 av_free_packet(&packet);
 } while (!decode_done);

 //make sure all packets are written and then close the last file.
 avio_flush(oc->pb);
 av_write_trailer(oc);

 if (video_st && video_st->codec)
 avcodec_close(video_st->codec);

 if (audio_st && audio_st->codec)
 avcodec_close(audio_st->codec);

 for (i = 0; i < oc->nb_streams; i++) {
 av_freep(&oc->streams[i]->codec);
 av_freep(&oc->streams[i]);
 }

 avio_close(oc->pb);
 av_free(oc);

 struct stat st;
 stat(currentOutputFileName, &st);
 output_bytes += st.st_size;


 if (write_index) {
 actual_segment_durations[++last_segment] = (unsigned int) rint(packet_time - prev_segment_time);

 //make sure that the last segment length is not zero
 if (actual_segment_durations[last_segment] == 0)
 actual_segment_durations[last_segment] = 1;

 write_index_file(playlistFilename, tempPlaylistName, segmentLength, actual_segment_durations, baseDirName, baseFileName, baseFileExtension, first_segment, last_segment);

 }

 write_stream_size_file(baseDirName, baseFileName, output_bytes * 8 / segment_time);

 return 0;
}
</outfile></infile>

-
Trying to compile x264 and ffmpeg for iPhone - "missing required architecture arm in file"
4 août 2012, par jtrimI'm trying to compile x264 for use in an iPhone application. I see there are instructions on how to compile ffmpeg for use on the platform here : http://lists.mplayerhq.hu/pipermail/ffmpeg-devel/2009-October/076618.html , but I can't seem to find anything this complete for compiling x264 on the iPhone. I've found this source tree : http://gitorious.org/x264-arm that seems to have support for the ARM platform.
Here is my config line :
./configure —cross-prefix=/usr/bin/ —host=arm-apple-darwin10 —extra-cflags="-B /Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS3.2.sdk/usr/lib/ -I /Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS3.2.sdk/usr/lib/"
...and inside
configureI'm using the gas-preprocessor script (first link above) as my assembler :gas-preprocessor.pl gcc
When I start compiling, it chunks away for a little while, then it spits out these warnings and a huge list of undefined symbols :
ld : warning : option -s is obsolete and being ignored ld : warning : -force_cpusubtype_ALL will become unsupported for ARM architectures ld : warning : in /usr/lib/crt1.o, missing required architecture arm in file ld : warning : in /usr/X11R6/lib/libX11.dylib, missing required architecture arm in file ld : warning : in /usr/lib/libm.dylib, missing required architecture arm in file ld : warning : in /usr/lib/libpthread.dylib, missing required architecture arm in file ld : warning : in /usr/lib/libgcc_s.1.dylib, missing required architecture arm in file ld : warning : in /usr/lib/libSystem.dylib, missing required architecture arm in file Undefined symbols :
My guess would be that the problem has to do with the "missing required architecture arm in file" warning...any ideas ?
Syndiquer tout le site
