MultimediaWiki - User contributions [en]

SubStation Alpha

2010-06-26T17:41:50Z

Aurel: mention muxing in avi

* Extensions: .ssa or .ass
** Can also be muxed into [[Matroska]] and [[AVI]] files (AviMux)
* Website: http://www.eswat.demon.co.uk/substation.html (No longer available)
* Specs: http://moodub.free.fr/video/ass-specs.doc

'''SubStation Alpha''' (SSA) is an external subtitle fileformat that supports Text Formatting and Styling. It has an enormous amount of options including Karaoke, audio effects, graphic drawing etc. It is usually considered to be somewhat bloated and badly designed, however is the only subtitle format that (at least on windows) really supports text formatting and styling at all. It is popular in the Anime scene and among Karaoke fans.

There were several versions. 1, 2, 3, 4 and 4+. The latter is better known Advanced SubStation (ASS). Only 4 and 4+ are still being used.

== Examples ==

=== SSA V4+ (ASS) ===
<pre>
[Script Info]
; This is an Advanced Sub Station Alpha v4+ script.
; For Sub Station Alpha info and downloads,
; go to http://www.eswat.demon.co.uk/
; or email kotus@eswat.demon.co.uk
;
; Advanced Sub Station Alpha script format developed by #Anime-Fansubs@EfNET
; http://www.anime-fansubs.org
;
; For additional info and downloads go to http://vobsub.edensrising.com/
; or email gabest@freemail.hu
;
; Note: This file was saved by Subresync.
;
ScriptType: v4.00+
Collisions: Normal
PlayResX: 384
PlayResY: 288
Timer: 100.0000

[V4+ Styles]
Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
Style: Default,Tahoma,16,&H00000000,&H00ffffff,&H00ffffff,&H00c0c0c0,-1,0,0,0,100,100,0,0.00,1,2,3,2,20,20,20,1

[Events]
Format: Layer, Start, End, Style, Actor, MarginL, MarginR, MarginV, Effect, Text
Dialogue: 0,0:01:41.70,0:01:46.84,Default,,0000,0000,0000,,Le rugissement des larmes !\NTu es mon ami.
Dialogue: 0,0:02:00.99,0:02:02.87,Default,,0000,0000,0000,,Est-ce vraiment Naruto ?
</pre>

=== SSA v4 ===
<pre>
[Script Info]
; This is a Sub Station Alpha v4 script.
; For Sub Station Alpha info and downloads,
; go to http://www.eswat.demon.co.uk/
; or email kotus@eswat.demon.co.uk
Title: Spirited Away
Original Script: Ian Roberts
Original Translation: Eisuke Ishibashi
ScriptType: v4.00
Collisions: Normal
PlayResY: 480
PlayDepth: 0
Wav: 0, 28688,H:\3.wav
LastWav: 1
Timer: 100.0000

[V4 Styles]
Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, TertiaryColour, BackColour, Bold, Italic, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, AlphaLevel, Encoding
Style: ICredit,Gill Sans Condensed,36,16777215,65535,65535,-2147483640,-1,0,1,3,0,2,70,70,40,0,0
Style: IDefault,Gill Sans Condensed,30,65535,65535,65535,-2147483640,-1,0,1,3,0,2,70,70,40,0,0
Style: IScreenText,Gill Sans Condensed,30,16744576,65535,65535,-2147483640,-1,0,1,3,5,2,70,70,40,0,0

[Events]
Format: Marked, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
Dialogue: Marked=0,0:00:06.60,0:00:08.90,IScreenText,,0000,0000,0000,,{\a10}See you again... Best wishes
Dialogue: Marked=0,0:00:11.84,0:00:14.74,ICredit,,0000,0000,0100,,{\a2}Story, Script & Direction - MIYAZAKI Hayao
</pre>

=== SSA v3 ===
<pre>
!: This is a Sub Station Alpha v3.x script.

!: You cannot load this script into any version of Sub Station Alpha prior to v2.00

!: Check web page http://www.eswat.demon.co.uk/ for SSA details and latest versions,

!: or e-mail kotus@eswat.demon.co.uk

Title: Lupin TV ep. 3

Original Script: Neko Creations

Original Translation: Miki Okamoto

Original Editing: Neko-chan

Original Timing: Neko-chan

Original Script Checking: Neko-chan

Synch Point: start of LD--play immediately pause.

ScriptType: v3.00

Collisions: Reverse

PlayResY: 480

PlayResX: 640

PlayDepth: 24

Comment: Marked=0,0:00:00.0,0:00:00.5,*Default,Warning,0000,0000,0000,This is a script for SSA v2.x\nYou are running SSA v1.x, which will crash if you use this script

Wav: 0,C:\Program Files\ssa32-v2\lupin3.wav

Wav: 0,C:\Program Files\Sub Station Alpha v3.00T\lupin4.wav

Timer: 100.0000

Style: Default,Arial,20,65535,65280,16777215,0,-1,0,2,3,2,30,35,35,255
Style: Normal1,Arial,18,65535,65408,16777215,0,-1,0,1,3,2,30,30,30,255
Style: owari,Arial,18,65535,65280,16777215,0,-1,0,2,3,2,40,40,35,255
Style: songgreen,Arial,18,65280,16777215,65535,0,-1,0,2,3,2,35,35,35,255
Style: top,Arial,20,65535,65280,16777215,0,-1,0,2,3,2,45,45,380,255

Dialogue: Marked=0,0:00:02.07,0:00:11.81,*Default,Credit,0000,0000,0300,,Lupin III
Dialogue: Marked=0,0:00:14.00,0:00:19.01,Normal1,Credit,0000,0000,0000,,{\fs20\c&HFFFFFF&\a1}Song of Lupin III\nCharley Kohsei
Dialogue: Marked=0,0:00:28.91,0:00:33.01,Normal1,Credit,0000,0000,0000,,{\fs20\c&HFFFFFF&}Original idea\nMonkey Punch
Dialogue: Marked=0,0:01:37.46,0:01:38.66,owari,Fujiko,0000,0000,0000,,It's fantastic, Lupin.
Dialogue: Marked=0,0:01:38.95,0:01:41.75,owari,Lupin,0000,0000,0000,,Yeah, love is wonderful.
</pre>

=== SSA v1 ===
<pre>
!: This is a Sub Station Alpha v1.x script.
!: Check web page http://www.eswat.demon.co.uk/ for details
!: or e-mail kotus@eswat.demon.co.uk
Timer: 100.000
Style: title,Arial,28,16777215,65280,16776960,-2147483640,-1,0,1,3,2,30,30,30
Style: White Text,Arial,28,16777215,65535,16777215,2039583,-1,0,1,4,2,30,30,30
Style: Song Title,Arial,24,16777215,65535,16777215,2039583,-1,0,1,3,2,30,30,50
Comment: Marked=0,0:00:10.0,0:00:12.0,title,,0000,0000,0000,From the collection
of\nAnnapuma's Script Crypt http://www.archea.demon.co.uk/crypt.html
Comment: Marked=0,0:00:13.0,0:00:15.0,White Text,,0000,0000,0000,Original transl
ation by Arctic Animation
Comment: Marked=0,0:00:16.0,0:00:18.0,White Text,,0000,0000,0000,Re-timed, re-ed
ited, and partially re-translated by Studio Kawaii
Comment: Marked=0,0:00:19.0,0:00:21.0,White Text,synch point,0000,0000,0000,Stud
io Kawaii version SK 1.0
Comment: Marked=0,0:00:22.0,0:00:24.0,*Default,synch point,0000,0000,0000,Pause
laserdisk at chapter 1. Unpause laserdisk and begin subtitling simultaneously
Dialogue: Marked=0,0:01:16.0,0:01:23.4,White Text,Usagi,0000,0000,0000,Pretty So
ldier Sailor Moon
Dialogue: Marked=0,0:01:30.1,0:01:33.3,Song Title,Usagi,0000,0000,0000,{\a5}Wish
I could be as honest about you
</pre>

[[Category:Subtitle Formats]]

FFmpeg SFLC representation

2009-02-03T00:16:05Z

Aurel:

=== FFmpeg legal representation ===

The [http://softwarefreedom.org/ Software Freedom Law Center (SFLC)] represents FFmpeg in legal affairs. To do this, they need a signed contract with individual copyright holders that gives them the right to represent them in legal matters concerning FFmpeg. To have an overview who signed those papers, we are collecting the names of those developers who already signed here.

Add your names in alphabetical order.

* Aurelien Jacobs
* Diego Biurrun

[[Category:FFmpeg]]

Electronic Arts Formats

2007-10-28T16:02:06Z

Aurel: set NFSC byte order

* Extensions: ASF, CMV, DCT, SND, TGI, TGV, TGQ, WVE, UV, UV2, MAD, VP6
* Company: [[Electronic Arts]]

Electronic Arts, the video game publishing empire, and the various constituent development houses under its umbrella, have deployed a number of multimedia formats in its games.

EA multimedia formats are comprised of a series of blocks with the following format:

bytes 0-3 block type [[FourCC]]
bytes 4-7 block size (including this 8-byte preamble)
bytes 8.. block payload

It is important to note that there is no consistent byte order for multi-byte numbers. However, order is optimized for target platform.

== Chunk Types ==

* Audio
** [[Electronic Arts SEAD]]: SEAD, SNDC, SEND
** [[Electronic Arts 1SNx]]: 1SNh, 1SNd, 1SNl, 1SNe
** [[Electronic Arts SCxl]]: SCHl, SCCl, SCDl, SCLl, SCEl
* Video
** [[Electronic Arts CMV]]: MVIh, MVIf, MVIe
** [[Electronic Arts TGV]]: kVGT, fVGT
** [[Electronic Arts DCT]]: mTCD
** [[Electronic Arts TGQ]]: pQTG, TGQs (rumored MUVf?)
** [[Electronic Arts TQI]]: pIQT, (rumored UV2f?)
** [[Electronic Arts MAD]]: MADk, MADm, MADe
** [[Electronic Arts VP6]]: MVhd, MV0K, MV0F
** [[Electronic Arts MPC]]: MPCh

== Games Using Electronic Arts Multimedia Formats ==

{| border="1" cellpadding="2"
! Name !! File Ext !! Video Codec !! Audio Codec || Byte Order
|-
| [http://www.mobygames.com/game/dos/nhl-95 NHL 95]
| cmv || CMV || none || le
|-
| [http://www.mobygames.com/game/dos/nhl-96 NHL 96]
| tgv || ? || ? || ?
|-
| [http://www.mobygames.com/game/dos/cybermage-darklight-awakening CyberMage: Darklight Awakening]
| tgv || TGV || 1SNx/EACS/pcm_s8 || le
|-
| [http://www.mobygames.com/game/need-for-speed Need for Speed]
| tgv || TGV || 1SNx/EACS/pcm_s8 || le
|-
| [http://www.mobygames.com/game/privateer-2-the-darkening Privateer 2: The Darkening]
| tgv || TGV || SEAD/adpcm_ima_ea_sead || le
|-
| [http://www.mobygames.com/game/dos/nba-live-96 NBA Live 96]
| tgv || TGV || 1SNh/EACS/adpcm_ima_ea_eacs || le
|-
| [http://www.mobygames.com/game/need-for-speed-ii Need for Speed 2]
| dct || DCT || SCHl/PT/adpcm_ea || le
|-
| [http://www.mobygames.com/game/need-for-speed-ii Need for Speed 2 (Demo)]
| uv || TGQ || SCHl/PT/adpcm_ea || le
|-
| [http://www.mobygames.com/game/saturn/warcraft-ii-the-dark-saga Warcraft II: The Dark Saga (Sega Saturn)]
| tgq || TGQ || ? || be
|-
| [http://www.mobygames.com/game/superbike-2001 Superbike 2001]
| tgq || ? || ? || ?
|-
| [http://www.mobygames.com/game/saturn/crusader-no-remorse Crusader: No Remorse (Sega Saturn)]
| tgq || TGQ || 1SNh/EACS/mulaw || be
|-
| [http://www.mobygames.com/game/harry-potter-quidditch-world-cup Harry Potter: Quidditch World Cup]
| tgq || TQI (not a typo) || SCHl/PT/adpcm_ea || le
|-
| [http://www.mobygames.com/game/windows/wing-commander-prophecy Wing Commander: Prophecy]
| wve || TQI || SCHl/PT/adpcm_ea || le
|-
| [http://www.mobygames.com/game/windows/the-sims The Sims]
| wve || TQI || SCHl/PT/adpcm_ea || le
|-
| [http://www.mobygames.com/game/nba-live-99 NBA Live 99]
| mad || MAD || SCHl/PT/adpcm_ea || le
|-
| [http://www.mobygames.com/game/need-for-speed-iii-hot-pursuit Need for Speed 3: Hot Pursuit]
| mad || MAD || SCHl/PT/adpcm_ea || le
|-
| [http://www.mobygames.com/game/need-for-speed-high-stakes Need for Speed 4: High Stakes]
| mad || MAD || SCHl/PT/adpcm_ea || le
|-
| [http://www.mobygames.com/game/need-for-speed-porsche-unleashed Need for Speed 5: Porsche]
| mad || MAD || SCHl/PT/adpcm_ea_r1 || le
|-
| [http://www.mobygames.com/game/need-for-speed-hot-pursuit-2 Need for Speed 6: Hot Pursuit 2]
| mad || MAD || SCHl/PT/adpcm_ea_r1 || le
|-
| rowspan="2"| [http://www.mobygames.com/game/nba-live-2003 NBA Live 2003]
| mad || MAD || pcm_s16le_planar || le
|-
| asf || none || SCHl/PT/mp3 || le
|-
| [http://www.mobygames.com/game/fifa-soccer-2005 FIFA 2004]
| mad || ? || ? || ?
|-
| [http://www.mobygames.com/game/fifa-soccer-2005 FIFA 2005]
| mad || MAD || SCHl/PT/adpcm_ea_r1, SCHl/PT/adpcm_ea_r3 || le
|-
| [http://www.mobygames.com/game/windows/simcity-4-rush-hour Sim City 4: Rush Hour]
| mad || MAD || ? || ?
|-
| [http://www.mobygames.com/game/sims-2 The Sims 2]
| mad || MAD || ? || ?
|-
| [http://www.mobygames.com/game/need-for-speed-underground-2 Need for Speed: Underground 2]
| vp6 || VP6 || SCHl/GSTR/adpcm_ea_r3 || le
|-
| [http://www.mobygames.com/game/need-for-speed-most-wanted Need for Speed: Most Wanted]
| vp6 || VP6 || SCHl/GSTR/adpcm_ea_r3 || le
|-
| [http://www.mobygames.com/game/need-for-speed-carbon Need for Speed: Carbon]
| vp6 || VP6 || SCHl/GSTR/adpcm_ea_r3 || le
|-
| [http://www.mobygames.com/game/windows/lord-of-the-rings-the-battle-for-middle-earth The Lord of the Rings: The Battle for Middle Earth]
| vp6 || VP6 || ? || ?
|-
| [http://www.mobygames.com/game/lord-of-the-rings-the-battle-for-middle-earth-ii The Lord of the Rings: The Battle for Middle Earth II]
| vp6 || VP6 || ? || ?
|-
| [http://www.mobygames.com/game/windows/lord-of-the-rings-the-battle-for-middle-earth-ii-the-rise-of-the The Lord of the Rings: The Battle for Middle Earth II - The Rise of the Witch-King]
| vp6 || VP6 || ? || ?
|-
| Command & Conquer: Tiberium Wars
| vp6/snd || VP6 || adpcm_ea_r3 || le
|}

In addition to FMV, the EA audio chunk types are frequently used throughout Electronic Arts games for music tracks, audio effects and speech. Older titles use the .ASF file extension for individual music tracks, whereas newer titles store multiple audio sequentially within the one file (hence rational for the ending chunk types) and use a variety of file extensions.

[[Category:Game Formats]]

Electronic Arts Formats

2007-10-28T15:59:21Z

Aurel: fix codec name

* Extensions: ASF, CMV, DCT, SND, TGI, TGV, TGQ, WVE, UV, UV2, MAD, VP6
* Company: [[Electronic Arts]]

Electronic Arts, the video game publishing empire, and the various constituent development houses under its umbrella, have deployed a number of multimedia formats in its games.

EA multimedia formats are comprised of a series of blocks with the following format:

bytes 0-3 block type [[FourCC]]
bytes 4-7 block size (including this 8-byte preamble)
bytes 8.. block payload

It is important to note that there is no consistent byte order for multi-byte numbers. However, order is optimized for target platform.

== Chunk Types ==

* Audio
** [[Electronic Arts SEAD]]: SEAD, SNDC, SEND
** [[Electronic Arts 1SNx]]: 1SNh, 1SNd, 1SNl, 1SNe
** [[Electronic Arts SCxl]]: SCHl, SCCl, SCDl, SCLl, SCEl
* Video
** [[Electronic Arts CMV]]: MVIh, MVIf, MVIe
** [[Electronic Arts TGV]]: kVGT, fVGT
** [[Electronic Arts DCT]]: mTCD
** [[Electronic Arts TGQ]]: pQTG, TGQs (rumored MUVf?)
** [[Electronic Arts TQI]]: pIQT, (rumored UV2f?)
** [[Electronic Arts MAD]]: MADk, MADm, MADe
** [[Electronic Arts VP6]]: MVhd, MV0K, MV0F
** [[Electronic Arts MPC]]: MPCh

== Games Using Electronic Arts Multimedia Formats ==

{| border="1" cellpadding="2"
! Name !! File Ext !! Video Codec !! Audio Codec || Byte Order
|-
| [http://www.mobygames.com/game/dos/nhl-95 NHL 95]
| cmv || CMV || none || le
|-
| [http://www.mobygames.com/game/dos/nhl-96 NHL 96]
| tgv || ? || ? || ?
|-
| [http://www.mobygames.com/game/dos/cybermage-darklight-awakening CyberMage: Darklight Awakening]
| tgv || TGV || 1SNx/EACS/pcm_s8 || le
|-
| [http://www.mobygames.com/game/need-for-speed Need for Speed]
| tgv || TGV || 1SNx/EACS/pcm_s8 || le
|-
| [http://www.mobygames.com/game/privateer-2-the-darkening Privateer 2: The Darkening]
| tgv || TGV || SEAD/adpcm_ima_ea_sead || le
|-
| [http://www.mobygames.com/game/dos/nba-live-96 NBA Live 96]
| tgv || TGV || 1SNh/EACS/adpcm_ima_ea_eacs || le
|-
| [http://www.mobygames.com/game/need-for-speed-ii Need for Speed 2]
| dct || DCT || SCHl/PT/adpcm_ea || le
|-
| [http://www.mobygames.com/game/need-for-speed-ii Need for Speed 2 (Demo)]
| uv || TGQ || SCHl/PT/adpcm_ea || le
|-
| [http://www.mobygames.com/game/saturn/warcraft-ii-the-dark-saga Warcraft II: The Dark Saga (Sega Saturn)]
| tgq || TGQ || ? || be
|-
| [http://www.mobygames.com/game/superbike-2001 Superbike 2001]
| tgq || ? || ? || ?
|-
| [http://www.mobygames.com/game/saturn/crusader-no-remorse Crusader: No Remorse (Sega Saturn)]
| tgq || TGQ || 1SNh/EACS/mulaw || be
|-
| [http://www.mobygames.com/game/harry-potter-quidditch-world-cup Harry Potter: Quidditch World Cup]
| tgq || TQI (not a typo) || SCHl/PT/adpcm_ea || le
|-
| [http://www.mobygames.com/game/windows/wing-commander-prophecy Wing Commander: Prophecy]
| wve || TQI || SCHl/PT/adpcm_ea || le
|-
| [http://www.mobygames.com/game/windows/the-sims The Sims]
| wve || TQI || SCHl/PT/adpcm_ea || le
|-
| [http://www.mobygames.com/game/nba-live-99 NBA Live 99]
| mad || MAD || SCHl/PT/adpcm_ea || le
|-
| [http://www.mobygames.com/game/need-for-speed-iii-hot-pursuit Need for Speed 3: Hot Pursuit]
| mad || MAD || SCHl/PT/adpcm_ea || le
|-
| [http://www.mobygames.com/game/need-for-speed-high-stakes Need for Speed 4: High Stakes]
| mad || MAD || SCHl/PT/adpcm_ea || le
|-
| [http://www.mobygames.com/game/need-for-speed-porsche-unleashed Need for Speed 5: Porsche]
| mad || MAD || SCHl/PT/adpcm_ea_r1 || le
|-
| [http://www.mobygames.com/game/need-for-speed-hot-pursuit-2 Need for Speed 6: Hot Pursuit 2]
| mad || MAD || SCHl/PT/adpcm_ea_r1 || le
|-
| rowspan="2"| [http://www.mobygames.com/game/nba-live-2003 NBA Live 2003]
| mad || MAD || pcm_s16le_planar || le
|-
| asf || none || SCHl/PT/mp3 || le
|-
| [http://www.mobygames.com/game/fifa-soccer-2005 FIFA 2004]
| mad || ? || ? || ?
|-
| [http://www.mobygames.com/game/fifa-soccer-2005 FIFA 2005]
| mad || MAD || SCHl/PT/adpcm_ea_r1, SCHl/PT/adpcm_ea_r3 || le
|-
| [http://www.mobygames.com/game/windows/simcity-4-rush-hour Sim City 4: Rush Hour]
| mad || MAD || ? || ?
|-
| [http://www.mobygames.com/game/sims-2 The Sims 2]
| mad || MAD || ? || ?
|-
| [http://www.mobygames.com/game/need-for-speed-underground-2 Need for Speed: Underground 2]
| vp6 || VP6 || SCHl/GSTR/adpcm_ea_r3 || le
|-
| [http://www.mobygames.com/game/need-for-speed-most-wanted Need for Speed: Most Wanted]
| vp6 || VP6 || SCHl/GSTR/adpcm_ea_r3 || le
|-
| [http://www.mobygames.com/game/need-for-speed-carbon Need for Speed: Carbon]
| vp6 || VP6 || SCHl/GSTR/adpcm_ea_r3 || ?
|-
| [http://www.mobygames.com/game/windows/lord-of-the-rings-the-battle-for-middle-earth The Lord of the Rings: The Battle for Middle Earth]
| vp6 || VP6 || ? || ?
|-
| [http://www.mobygames.com/game/lord-of-the-rings-the-battle-for-middle-earth-ii The Lord of the Rings: The Battle for Middle Earth II]
| vp6 || VP6 || ? || ?
|-
| [http://www.mobygames.com/game/windows/lord-of-the-rings-the-battle-for-middle-earth-ii-the-rise-of-the The Lord of the Rings: The Battle for Middle Earth II - The Rise of the Witch-King]
| vp6 || VP6 || ? || ?
|-
| Command & Conquer: Tiberium Wars
| vp6/snd || VP6 || adpcm_ea_r3 || le
|}

In addition to FMV, the EA audio chunk types are frequently used throughout Electronic Arts games for music tracks, audio effects and speech. Older titles use the .ASF file extension for individual music tracks, whereas newer titles store multiple audio sequentially within the one file (hence rational for the ending chunk types) and use a variety of file extensions.

[[Category:Game Formats]]

Electronic Arts Formats

2007-10-26T17:53:28Z

Aurel: specify NFSC audio format

* Extensions: ASF, CMV, DCT, SND, TGI, TGV, TGQ, WVE, UV, UV2, MAD, VP6
* Company: [[Electronic Arts]]

Electronic Arts, the video game publishing empire, and the various constituent development houses under its umbrella, have deployed a number of multimedia formats in its games.

EA multimedia formats are comprised of a series of blocks with the following format:

bytes 0-3 block type [[FourCC]]
bytes 4-7 block size (including this 8-byte preamble)
bytes 8.. block payload

It is important to note that there is no consistent byte order for multi-byte numbers. However, order is optimized for target platform.

== Chunk Types ==

* Audio
** [[Electronic Arts SEAD]]: SEAD, SNDC, SEND
** [[Electronic Arts 1SNx]]: 1SNh, 1SNd, 1SNl, 1SNe
** [[Electronic Arts SCxl]]: SCHl, SCCl, SCDl, SCLl, SCEl
* Video
** [[Electronic Arts CMV]]: MVIh, MVIf, MVIe
** [[Electronic Arts TGV]]: kVGT, fVGT
** [[Electronic Arts DCT]]: mTCD
** [[Electronic Arts TGQ]]: pQTG, TGQs (rumored MUVf?)
** [[Electronic Arts TQI]]: pIQT, (rumored UV2f?)
** [[Electronic Arts MAD]]: MADk, MADm, MADe
** [[Electronic Arts VP6]]: MVhd, MV0K, MV0F
** [[Electronic Arts MPC]]: MPCh

== Games Using Electronic Arts Multimedia Formats ==

{| border="1" cellpadding="2"
! Name !! File Ext !! Video Codec !! Audio Codec || Byte Order
|-
| [http://www.mobygames.com/game/dos/nhl-95 NHL 95]
| cmv || CMV || none || le
|-
| [http://www.mobygames.com/game/dos/nhl-96 NHL 96]
| tgv || ? || ? || ?
|-
| [http://www.mobygames.com/game/dos/cybermage-darklight-awakening CyberMage: Darklight Awakening]
| tgv || TGV || 1SNx/EACS/pcm_s8 || le
|-
| [http://www.mobygames.com/game/need-for-speed Need for Speed]
| tgv || TGV || 1SNx/EACS/pcm_s8 || le
|-
| [http://www.mobygames.com/game/privateer-2-the-darkening Privateer 2: The Darkening]
| tgv || TGV || SEAD/adpcm_ima_ea_sead || le
|-
| [http://www.mobygames.com/game/dos/nba-live-96 NBA Live 96]
| tgv || TGV || 1SNh/EACS/adpcm_ima_ea_eacs || le
|-
| [http://www.mobygames.com/game/need-for-speed-ii Need for Speed 2]
| dct || DCT || SCHl/PT/adpcm_ea || le
|-
| [http://www.mobygames.com/game/need-for-speed-ii Need for Speed 2 (Demo)]
| uv || TGQ || SCHl/PT/adpcm_ea || le
|-
| [http://www.mobygames.com/game/saturn/warcraft-ii-the-dark-saga Warcraft II: The Dark Saga (Sega Saturn)]
| tgq || TGQ || ? || be
|-
| [http://www.mobygames.com/game/superbike-2001 Superbike 2001]
| tgq || ? || ? || ?
|-
| [http://www.mobygames.com/game/saturn/crusader-no-remorse Crusader: No Remorse (Sega Saturn)]
| tgq || TGQ || 1SNh/EACS/mulaw || be
|-
| [http://www.mobygames.com/game/harry-potter-quidditch-world-cup Harry Potter: Quidditch World Cup]
| tgq || TQI (not a typo) || SCHl/PT/adpcm_ea || le
|-
| [http://www.mobygames.com/game/windows/wing-commander-prophecy Wing Commander: Prophecy]
| wve || TQI || SCHl/PT/adpcm_ea || le
|-
| [http://www.mobygames.com/game/windows/the-sims The Sims]
| wve || TQI || SCHl/PT/adpcm_ea || le
|-
| [http://www.mobygames.com/game/nba-live-99 NBA Live 99]
| mad || MAD || SCHl/PT/adpcm_ea || le
|-
| [http://www.mobygames.com/game/need-for-speed-iii-hot-pursuit Need for Speed 3: Hot Pursuit]
| mad || MAD || SCHl/PT/adpcm_ea || le
|-
| [http://www.mobygames.com/game/need-for-speed-high-stakes Need for Speed 4: High Stakes]
| mad || MAD || SCHl/PT/adpcm_ea || le
|-
| [http://www.mobygames.com/game/need-for-speed-porsche-unleashed Need for Speed 5: Porsche]
| mad || MAD || SCHl/PT/adpcm_ea_r1 || le
|-
| [http://www.mobygames.com/game/need-for-speed-hot-pursuit-2 Need for Speed 6: Hot Pursuit 2]
| mad || MAD || SCHl/PT/adpcm_ea_r1 || le
|-
| rowspan="2"| [http://www.mobygames.com/game/nba-live-2003 NBA Live 2003]
| mad || MAD || pcm_s16le_planar || le
|-
| asf || none || SCHl/PT/mp3 || le
|-
| [http://www.mobygames.com/game/fifa-soccer-2005 FIFA 2004]
| mad || ? || ? || ?
|-
| [http://www.mobygames.com/game/fifa-soccer-2005 FIFA 2005]
| mad || MAD || SCHl/PT/adpcm_ea_r1, SCHl/PT/adpcm_ea_r3 || le
|-
| [http://www.mobygames.com/game/windows/simcity-4-rush-hour Sim City 4: Rush Hour]
| mad || MAD || ? || ?
|-
| [http://www.mobygames.com/game/sims-2 The Sims 2]
| mad || MAD || ? || ?
|-
| [http://www.mobygames.com/game/need-for-speed-underground-2 Need for Speed: Underground 2]
| vp6 || VP6 || SCHl/GSTR/ealayer3 || le
|-
| [http://www.mobygames.com/game/need-for-speed-most-wanted Need for Speed: Most Wanted]
| vp6 || VP6 || SCHl/GSTR/ealayer3 || le
|-
| [http://www.mobygames.com/game/need-for-speed-carbon Need for Speed: Carbon]
| vp6 || VP6 || SCHl/GSTR/adpcm_ea_r3 || ?
|-
| [http://www.mobygames.com/game/windows/lord-of-the-rings-the-battle-for-middle-earth The Lord of the Rings: The Battle for Middle Earth]
| vp6 || VP6 || ? || ?
|-
| [http://www.mobygames.com/game/lord-of-the-rings-the-battle-for-middle-earth-ii The Lord of the Rings: The Battle for Middle Earth II]
| vp6 || VP6 || ? || ?
|-
| [http://www.mobygames.com/game/windows/lord-of-the-rings-the-battle-for-middle-earth-ii-the-rise-of-the The Lord of the Rings: The Battle for Middle Earth II - The Rise of the Witch-King]
| vp6 || VP6 || ? || ?
|-
| Command & Conquer: Tiberium Wars
| vp6/snd || VP6 || adpcm_ea_r3 || le
|}

In addition to FMV, the EA audio chunk types are frequently used throughout Electronic Arts games for music tracks, audio effects and speech. Older titles use the .ASF file extension for individual music tracks, whereas newer titles store multiple audio sequentially within the one file (hence rational for the ending chunk types) and use a variety of file extensions.

[[Category:Game Formats]]

On2 VP6

2007-10-14T22:54:20Z

Aurel: Alternative coding is in fact huffman

* FOURCCs: VP60, VP61, VP62
* Company: [[On2]]
* Whitepaper: [http://www.on2.com/cms-data/pdf/1125607149174329.pdf http://www.on2.com/cms-data/pdf/1125607149174329.pdf]
* Samples: [http://samples.mplayerhq.hu/V-codecs/VP6/ http://samples.mplayerhq.hu/V-codecs/VP6/]

== Implementations ==

An early open source implementation could be found at http://libvp62.sourceforge.net/, but
was driven underground by On2 on copyright infringement claims.

This specification is said to be incomplete with regard to the On2 VP6 specification.

A decoder implementation may be found in the FFMPEG source file [http://svn.mplayerhq.hu/ffmpeg/trunk/libavcodec/vp6.c?view=markup vp6.c]

== Format ==

The aim here is to open this standard with a full description of the bitstream format and decoding process. Contributors from On2 especially encouraged here, but it is anticipated that this section will be completed through reverse engineering and by people who saw libvp62 source code before it was censored.

Please do not submit any copyrighted text or code here.

=== Introduction ===

VP6 uses unidirectional ("P-frame") and intra-frame (within the current frame) prediction. Entropy coding is performed using arithmetic (range?) coding and an 8x8 iDCT is used. The format supports dynamic adjustment of encoded video resolution. There are three variants of the VP6 codec, VP60 (Simple Profile), VP62 (Advanced Profile) and VP62 (Heightened Sharpness Profile).

=== Macroblocks ===

Each video frame is composed of an array of 16x16 macroblocks, just like [[MPEG-2]], [[MPEG-4]] parts 2 and 10. Each [[MB]] (macroblock) takes one of the following modes ("[[MV]]" means "motion vector"):

* Intra MB
* Inter MB, null MV, previous frame reference
* Inter MB, differential MV, previous frame reference
* Inter MB, four MVs, previous frame reference
* Inter MB, MV 1, previous frame reference
* Inter MB, MV 2, previous frame reference
* Inter MB, null MV, bookmarked frame reference
* Inter MB, differential MV, bookmarked frame reference
* Inter MB, MV 1, bookmarked frame reference
* Inter MB, MV 2, bookmarked frame reference

=== Frame Header ===

The frame header commences with a section that is encoded using conventional big-endian bit packing.

{| border="1"
! Syntax !! Number of bits !! Type !! Semantics
|-
| frame_mode || 1 || Enum || 0x0 signifies an intra frame
|-
| qp || 6 || Unsigned || Quantization parameter valid range 0..63
|-
| marker || 1 || Constant || 0=VP61/62, 1=VP60
|-
| if (frame_mode == 0) { || || ||0 equals to INTRA_FRAME
|-
| version || 5 || Constant || 6=VP60/61, 7=VP60(Electronic Arts), 8=VP62
|-
| version2 || 2 || Constant || 0=VP60, 3=VP61/62
|-
| interlace || 1 || Boolean || true (1) means interlace will be used
|-
| if (marker==1 or version2==0) {
|-
| offset || 16 || Unsigned || secondary buffer offset (bytes releative to start of buffer)
|-
| }
|-
| dim_y || 8 || Unsigned || Macroblock height of video
|-
| dim_x || 8 || Unsigned || Macroblock width of video
|-
| render_y || 8 || Unsigned || Display height of video
|-
| render_x || 8 || Unsigned || Display width of video
|-
| }else{
|-
| if (marker==1 or version2==0) {
|-
| offset || 16 || Unsigned || secondary buffer offset (bytes releative to start of buffer)
|-
| }
|-
| }
|}

If dim_x or dim_y have values different from the previous intra frame, then the resolution of the encoded image has changed.

Arithmetic coding commences at the next bit (which should be on a byte boundary):

{| border="1"
! Syntax !! Type !! Semantics
|-
| if (frame_mode == 0) {
|-
| marker1 || Equiprobable 2-bit || Ignored
|-
| } else {
|-
| bookmark || Equiprobable 1-bit || bookmark == 0x1 means this frame will be the next bookmark frame
|-
| filter1 || Equiprobable 1-bit ||
|-
| if (filter1 == 0x1) {
|-
| filter2 || Equiprobable 1-bit ||
|-
| }
|-
| filter_info || Equiprobable 1-bit ||
|-
| }
|-
| if (frame_mode == 0 <nowiki>||</nowiki> filter_info == 0x1) {
|-
| filter_mode1 || Equiprobable 1-bit ||
|-
| if (filter_mode1 == 0x1) {
|-
| filter_threshold1 || Equiprobable 5-bit ||
|-
| filter_motion_param || Equiprobable 3-bit ||
|-
| } else {
|-
| filter_mode2 || Equiprobable 1-bit ||
|-
| }
|-
| filter_mode3 || Equiprobable 4-bit ||
|-
| }
|-
| marker2 || Equiprobable 1-bit || Secondary buffer encoding algorithm. 0=Range coding, 1=Huffman coding.
|}

If the secondary buffer is present, coeffient symbols are read from the secondary buffer using the algorithm indicated by marker2. VP60 has "the ability to switch to a faster entropy encoding strategy to ensure smooth playback" and "the ability to decode different parts of the bitstream on different sub-processors (for instance the vlx and the core), to ensure better overall system utilization" [http://www.on2.com/cms-data/pdf/1125607149174329.pdf].

=== Entropy Coding ===

Described here is the decoding process for the arithmetically-coded (AC) parts of the bitstream. VP6 uses a 16-bit [http://en.wikipedia.org/wiki/Range_encoding range coding] scheme to code binary symbols.

The AC decoder maintains three state variables: ''code'', ''mask'' and ''high''.

====Initialization====

At initialization, the first two bytes of the AC bitstream are shifted into ''code''. The variable ''high'' is set to 0xff00. The variable ''mask'' is set to 0xffff.

====Decoding a Binary Value====

Each binary symbol has an associated probability ''p'' in the range 0 to 0xff.

A threshold, ''t'', is computed thus:

: ''t'' = 0x100 + ( 0xff00 & ( ( (''high''-0x100) * ''p'' ) >> 8 ) )

Equiprobable binary symbols are treated somewhat differently:

: ''t'' = 0xff00 & ( (''high''+0x100) >> 1 )

The binary value may then be decoded by comparing ''code'' and ''t''. If ''code'' is less than ''t'', the binary value is decoded as 0. If ''code'' is equal to or greater than ''t'', the binary value is decoded as 1.

If a 1 was decoded, then

: ''high'' = ''high'' - ''t''
: ''code'' = ''code'' - ''t''

If a 0 was decoded, then

: ''high'' = ''t''

The following renormalization is now repeated while (''high'' & 0x8000) is non-zero.

: ''high'' = 2 * ''high''
: ''code'' = 2 * ''code''
: ''mask'' = 2 * ''mask''
: if ((''mask'' & 0xff) == 0x00) {
:: ''code'' = ''code'' | next byte from bitstream
:: ''mask'' = ''mask'' | 0xff
:}

====Decoding an Equiprobable n-bit Integer Value====

Integer values are coded as a big-endian sequence of equiprobable binary values. To decode an n-bit equiprobable integer value, n equiprobable binary values should be decoded using the sequence above and left-shifted into an integral result variable.

=== Inverse DCT ===

Inverse DCT is performed on 8x8 blocks of pixels. The algorithm used is the same (or a small variation) of the one used for the [[On2 VP3|VP3]] decoder in [[FFmpeg]] [http://www1.mplayerhq.hu/cgi-bin/cvsweb.cgi/ffmpeg/libavcodec/vp3dsp.c?rev=1.9&content-type=text/x-cvsweb-markup&cvsroot=FFMpeg], the original vp3 iDCT code is here [http://svn.xiph.org/trunk/vp32/CoreLibs/CDXV/Vp31/dx/generic/IDctPart.c].

[[Category:Video Codecs]]
[[Category:Incomplete Video Codecs]]

FFmpeg Summer Of Code 2007

2007-03-07T21:45:36Z

Aurel: /* Matroska Muxer */

[http://www.google.com/ Google] is sponsoring their third annual Summer of Code for the summer of 2007. This entails sponsoring students to work on assorted open source projects as well as sponsoring mentors in those same projects. Everyone wins.

[[FFmpeg]] was a Summer of Code participant in the summer of 2006 (here is the [[FFmpeg Summer Of Code|corresponding Wiki page]]) and hopes to be accepted again this year.

[[User:Multimedia Mike|Mike Melanson]] (mike -at- multimedia.cx) is the administrator and main point of contact for matters relating to the FFmpeg Summer of Code.

== How to apply ==

Before you can apply make sure you are qualified enough to apply. Last year 50% of the applicants weren't qualified for the task they applied for.

* You have to know how to program in C fairly well.
* We would like you to submit a patch that fixes a bug or adds a feature to FFmpeg. By doing that we will know that you are qualified for the task or not. On this page there is a list of [[Summer Of Code 2007#Small_tasks|Small Tasks]] that can be done. But you are free to submit anything you feel might be of value to FFmpeg.
* Submit a good application.

== Current Status ==
* March 5-12, 2007: Application period for mentoring organizations.
* March 6, 2007: Mike Melanson submitted FFmpeg mentoring application.
Waiting for acceptance...

== Project Proposals ==

=== Overview ===
Qualifications for a good Summer of Code proposal:
* discrete, well-defined, modular
* comprised of a series of measurable sub-goals
* based on open specs that are available free of charge
* based on complete specs
An example of a good proposal is the implementation of a decoder or demuxer for an as yet unsupported multimedia format, or an encoder or muxer for a format that can already be demuxed/decoded by FFmpeg.

An example of a less desirable proposal is one that's not as measurable, such as refactoring APIs. Bad proposals tend to be ones that would require touching a lot of core code.

To re-iterate:
* Localized/isolated code projects = ''good''
* Global code refactoring = ''bad''

=== JPEG2000 ===
* Specifications: [http://www.itu.int/rec/T-REC-T/e As ITU-T recommendations], [http://isotc.iso.org/livelink/livelink/fetch/2000/2489/Ittf_Home/PubliclyAvailableStandards.htm ISO publicly available standards]
* Sources: [http://www.ece.uvic.ca/~mdadams/jasper/ JasPer], [http://www.openjpeg.org/ OpenJpeg], [http://jj2000.epfl.ch/ JJ2000 (in Java)]
* Samples: [http://samples.mplayerhq.hu/jpeg2000/ http://samples.mplayerhq.hu/jpeg2000/]

=== Monkey's Audio Decoder ===
* Sources: [http://www.monkeysaudio.com/files/MAC_SDK_399.zip original sources], [http://sourceforge.net/projects/mac-port/ original sources port for non-win32 platforms], [http://jmac.sourceforge.net/ LGPLed Java implementation]

=== QCELP Decoder ===

* Specification: QCELP decoder [http://www.3gpp2.org/Public_html/specs/alltsgscfm.cfm spec] is c.s0020 and source is c.r0020
* Sample files: http://samples.mplayerhq.hu/A-codecs/qclp/

''Mentor: Benjamin Larsson''

=== E-AC3 Decoder ===
* Specification: [http://www.atsc.org/standards/a_52b.pdf http://www.atsc.org/standards/a_52b.pdf]
* Samples: [http://samples.mplayerhq.hu/evob/MAININTRO.EVO http://samples.mplayerhq.hu/evob/MAININTRO.EVO]

=== GSM Decoder ===

=== Dirac Decoder ===

=== Dirac Encoder ===

=== i263 Decoder ===
* Specification: [[I263 | I263 Format Specification at MultimediaWiki]]
* Sources: [http://multimedia.cx/I263Src.zip GPLed I263 decoder]
* Sample files: [http://samples.mplayerhq.hu/V-codecs/I263/ http://samples.mplayerhq.hu/V-codecs/I263/]

=== VP6 Encoder ===

=== NUT Muxer ===

=== Matroska Muxer ===

* Specification: http://www.matroska.org/technical/specs/index.html
* Sample files: http://samples.mplayerhq.hu/Matroska/

''Mentor: Aurelien Jacobs; Backup mentors: Steve Lhomme, Ronald S. Bultje''

=== MPEG TS/DVB Muxer ===

=== PAFF decoding for H.264/AVC ===
* Specification: [http://www.itu.int/rec/T-REC-H.264-200503-I/en ITU-T]
* Sample files: [http://samples.mplayerhq.hu/V-codecs/h264/PAFF http://samples.mplayerhq.hu/V-codecs/h264/PAFF]

=== MXF Muxer ===

=== Finish AAC decoder and land it in FFmpeg ===
* Code: http://svn.mplayerhq.hu/aac/

=== RV30/RV40 decoders ===
''(contingent on near-term reverse engineering efforts)''

== Small tasks ==

=== TGA encoder ===
* Specification: http://www.dca.fee.unicamp.br/~martino/disciplinas/ea978/tgaffs.pdf
* Samples: http://www.openquicktime.org/files.php//aletrek/

=== TIFF encoder ===
* Specification: http://partners.adobe.com/public/developer/en/tiff/TIFF6.pdf
* Samples: http://samples.mplayerhq.hu/mov/tiff/

=== Bethsoft VID demuxer ===

=== Vivo demuxer ===
* Specification: look at the mplayer vivo demuxer [http://svn.mplayerhq.hu/mplayer/trunk/libmpdemux/demux_viv.c?revision=22301&view=markup]
* Samples: http://samples.mplayerhq.hu/vivo/

=== IFF/8SVX 8-bit audio demuxer ===
* Specification: http://netghost.narod.ru/gff/vendspec/iff/iff.txt, http://sox.sourceforge.net/AudioFormats-11.html, and [http://xine.cvs.sourceforge.net/xine/xine-lib/src/demuxers/demux_iff.c?view=markup xine demuxer]
* Samples: http://aminet.net/mods/smpl

=== Optimize some code ===
Do you think some code in ffmpeg could run faster? We would love to get some faster decoders or encoders.

This requires some ASM skills and using timer code to benchmark.

Speedups needed in:
h264 decoder

=== Review/fix some FFmpeg patches ===
insert FFmpeg patch list here.

FFmpeg codec HOWTO

2007-02-24T14:31:31Z

Aurel: /* libavcodec/allcodecs.c */ upgrade to new structure of this file

This page is meant as an introduction to the internal codec API in [[FFmpeg]].
It will also show how the codecs are connected with the demuxers. This is by
no means a complete guide but enough to understand how to add a codec to FFmpeg.
Cook is used as an example throughout.

== libavcodec/avcodec.h ==
The first thing to look at is the AVCodec struct.

typedef struct AVCodec {
const char *name;
enum CodecType type;
enum CodecID id;
int priv_data_size;
int (*init)(AVCodecContext *);
int (*encode)(AVCodecContext *, uint8_t *buf, int buf_size, void *data);
int (*close)(AVCodecContext *);
int (*decode)(AVCodecContext *, void *outdata, int *outdata_size,
uint8_t *buf, int buf_size);
int capabilities;
struct AVCodec *next;
void (*flush)(AVCodecContext *);
const AVRational *supported_framerates; ///array of supported framerates, or NULL if any, array is terminated by {0,0}
const enum PixelFormat *pix_fmts; ///array of supported pixel formats, or NULL if unknown, array is terminanted by -1
} AVCodec;

Here we can see that we have some elements to name the codec, what type it is (audio/video), the supported pixel formats and some function
pointers for init/encode/decode and close. Now lets see how it is used.

== libavcodec/cook.c ==
If we look in this file at the bottom we can see this code:

AVCodec cook_decoder =
{
.name = "cook",
.type = CODEC_TYPE_AUDIO,
.id = CODEC_ID_COOK,
.priv_data_size = sizeof(COOKContext),
.init = cook_decode_init,
.close = cook_decode_close,
.decode = cook_decode_frame,
};

First we get an AVCodec struct named cook_decoder. And then we set the variables of cook_decoder. Note that we only set the variables that are needed. Currently there is no encoder so we don't set any. If we now look at the id variable we can see that CODEC_ID_COOK isn't defined in libavcodec/cook.c. It is declared in avcodec.h.

== libavcodec/avcodec.h ==

Here we will find the CodecID enumeration.

enum CodecID {
...
CODEC_ID_GSM,
CODEC_ID_QDM2,
CODEC_ID_COOK,
CODEC_ID_TRUESPEECH,
CODEC_ID_TTA,
...
};

CODEC_ID_COOK is there in the list. This is the list of all supported codecs in FFmpeg, the list is fixed and used internally to id every codec. Changing the order would break binary compatibility.

This is all enough to declare a codec. Now we must register them for internal use also. This is done at runtime.

== libavcodec/allcodecs.c ==
In this file we have the avcodec_register_all() function, it has entries like this for all codecs.

...
REGISTER_DECODER(COOK, cook);
...

This macro expands to a register_avcodec() call which registers a codec for internal use.
Note that register_avcodec() will only be called when CONFIG_COOK_DECODER is defined.
This allows to not compile the decoder code for a specific codec.
But where is it defined? This is extracted by configure with this command line:

sed -n 's/^[^#]*DEC.*, *\(.*\)).*/\1_decoder/p' libavcodec/allcodecs.c

So adding a REGISTER_DECODER(NEW, new) entry in allcodecs.c and reconfigure is enough to add the needed define.
One more thing to note is that cook.c isn't included in allcodecs.c so the symbol cook_decoder can't be
found. Thus it has to be declared somewhere, that happens in avcodec.h and it is declared as an external symbol.

Now we have everything to hookup a codec now we will see how the codec. For this we look into libavformat.

== libavformat/rm.c ==
If we think of an imaginary rm file that ffmpeg is about to process, the first thing that happens is that it is identified
as a rm file. It is passed on to the rm demuxer (rm.c). The rm demuxer looks through the file and finds out that it is a
cook file.

...
} else if (!strcmp(buf, "cook")) {
st->codec->codec_id = CODEC_ID_COOK;
...

Now ffmpeg knows what codec to init and where to send the payload from the container. So back to cook.c and the initialization process.

== libavcodec/cook.c Init ==
After ffmpeg knows what codec to use, it calls the declared initialization function pointer declared in the codecs AVCodec struct. In
cook.c it is called cook_decode_init. Here we setup as much as we can before we start decoding. The following things should be handled in the init, vlc table initialization, table generation, memory allocation and extradata parsing.

== libavcodec/cook.c Close ==
The cook_decode_close function is the codec clean-up call. All memory, vlc tables, etc. should be freed here.

== libavcodec/cook.c Decode ==
In cook.c the name of the decode call is cook_decode_frame.

static int cook_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
uint8_t *buf, int buf_size) {
...

The function has 5 arguments:
* avctx is a pointer to a AVCodecContext
* data is the pointer to the outbuffer
* data_size is a variable that should be set to the outbuffer size in bytes
* buf is the pointer to the inbuffer
* buf_size is the size of the inbuffer

The decode function shall return the amount of bytes consumed from the inbuffer.

That's how it works without too much detail.

== The Glue codec template ==
The imaginary Glue audio codec will serve as a base to exhibit bitstream reading, vlc decoding and other things.
The code is purely fictional and is sometimes written purely for the sake of example. No attempt is made to prevent invalid
data manipulation.

The Glue codec follows.

/* First we include some default includes */
#include <math.h>
#include <stddef.h>
#include <stdio.h>

/* The following includes have the bitstream reader, various dsp functions and the various defaults */
#define ALT_BITSTREAM_READER
#include "avcodec.h"
#include "bitstream.h"
#include "dsputil.h"

/* This includes the tables needed for the Glue codec template */
#include "gluedata.h"

/* Here we declare the struct used for the codec private data */
typedef struct {
GetBitContext gb;
FFTContext fft_ctx;
VLC vlc_table;
MDCTContext mdct_ctx;
float* sample_buffer;
} GLUEContext;

/* The init function */
static int glue_decode_init(AVCodecContext *avctx)
{
GLUEContext *q = avctx->priv_data;

/* This imaginary codec uses one fft, one mdct and one vlc table. */
ff_mdct_init(&q->mdct_ctx, 10, 1); // 2^10 == size of mdct, 1 == inverse mdct
ff_fft_init(&q->fft_ctx, 9, 1); // 2^9 == size of fft, 0 == inverse fft
init_vlc (&q->vlc_table, 9, 24,
vlctable_huffbits, 1, 1,
vlctable_huffcodes, 2, 2, 0); // look in bitstream.h for the meaning of the arguments

/* We also need to allocate a sample buffer */
q->sample_buffer = av_mallocz(sizeof(float)*1024); // here we used av_mallocz instead of av_malloc
// av_mallocz memsets the whole buffer to 0

/* Check if the allocation was successful */
if(q->sample_buffer == NULL)
return -1;

/* return 0 for a successful init, -1 for failure */
return 0;
}

/* This is the main decode function */
static int glue_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
uint8_t *buf, int buf_size)
{
GLUEContext *q = avctx->priv_data;
int16_t *outbuffer = data;

/* We know what the arguments for this function are from above
now we just have to decode this imaginary codec, the made up
bitstream format is as follows:
12 bits representing the amount of samples
1 bit fft or mdct coded coeffs, 0 for fft/1 for mdct
read 13 bits representing the amount of vlc coded fft data coeffs
read 10 bits representing the amount of vlc coded mdct data coeffs
(...bits representing the coeffs...)
5 bits of dummy data that should be ignored
32 bits the hex value 0x12345678, used for integrity check
*/

/* Declare the needed variables */
int samples, coeffs, i, fft;
float mdct_tmp[1024];

/* Now we init the bitstream reader, we start at the beginning of the inbuffer */
init_get_bits(&q->gb, buf, buf_size*8); //the buf_size is in bytes but we need bits

/* Now we take 12 bits to get the amount of samples the current frame has */
samples = get_bits(&q->gb, 12);

/* Now we check if we have fft or mdct coeffs */
fft = get_bits1(&q->gb);
if (fft) {
//fft coeffs, get how many
coeffs = get_bits(&q->gb, 13);
} else {
//mdct coeffs, get how many
coeffs = get_bits(&q->gb, 10);
}

/* Now decode the vlc coded coeffs to the sample_buffer */
for (i=0 ; i<coeffs ; i++)
q->sample_buffer[i] = get_vlc2(&q->gb, q->vlc_table.table, vlc_table.bits, 3); //read about the arguments in bitstream.h

/* Now we need to transform the coeffs to samples */
if (fft) {
//The fft is done inplace
ff_fft_permute(&q->fft_ctx, (FFTComplex *) q->sample_buffer);
ff_fft_calc(&q->fft_ctx, (FFTComplex *) q->sample_buffer);
} else {
//And we pretend that the mdct is also inplace
ff_imdct_calc(&q->mdct_ctx, q->sample_buffer, q->sample_buffer, mdct_tmp);
}

/* To make it easy the stream can only be 16 bits mono, so let's convert it to that */
for (i=0 ; i<samples ; i++)
outbuffer[i] = (int16_t)q->sample_buffer[i];

/* Report how many samples we got */
*data_size = samples;

/* Skip the dummy data bits */
skip_bits(&q->gb, 5);

/* Check if the buffer was consumed ok */
if (get_bits(&q->gb,32) != 0x12345678) {
av_log(avctx,AV_LOG_ERROR,"Stream error, integrity check failed!\n");
return -1;
}

/* Return the amount of bytes consumed if everything was ok */
return *data_size*sizeof(int16_t);
}

/* the uninit function, here we just do the inverse of the init */
static int glue_decode_close(AVCodecContext *avctx)
{
GLUEContext *q = avctx->priv_data;

/* Free allocated memory buffer */
av_free(q->sample_buffer);

/* Free the fft transform */
ff_fft_end(&q->fft_ctx);

/* Free the mdct transform */
ff_mdct_end(&q->mdct_ctx);

/* Free the vlc table */
free_vlc(&q->vlc_table);

/* Return 0 if everything is ok, -1 if not */
return 0;
}

AVCodec glue_decoder =
{
.name = "glue",
.type = CODEC_TYPE_AUDIO,
.id = CODEC_ID_GLUE,
.priv_data_size = sizeof(GLUEContext),
.init = glue_decode_init,
.close = glue_decode_close,
.decode = glue_decode_frame,
};

AVS

2007-01-29T23:29:29Z

Aurel: fix samples link

There is also new format from China called [[Chinese AVS]]

''This page is based on the document 'Description of the AVS Format' by Mike Melanson and Vladimir "VAG" Gneushev found at [http://multimedia.cx/avs-format.txt http://multimedia.cx/avs-format.txt]''.

* Samples: [http://samples.mplayerhq.hu/game-formats/avs/ http://samples.mplayerhq.hu/game-formats/avs/]

AVS is a full motion video (FMV) file format that is used in the game [http://www.mobygames.com/game/creature-shock Creature Shock] developed by [[Argonaut Games]] and published by [[Virgin Interactive]] in 1994. The game is an FMV-based shooting game that relies on this file format for much of its graphics.

== File Format ==

All multi-byte numbers are little-endian.

An AVS file starts with a header and is followed by a series of frames. The file header has the following layout:

bytes 0-1 file signature - 0x77 0x57
bytes 2-3 size of main header (should be 0x0010)
bytes 4-5 frame width
bytes 6-7 frame height
bytes 8-9 color depth? (always 8)
bytes 10-11 frames per second
bytes 12-15 frame count

After the file header is a series of frames. Each frame has the following layout:

bytes 0-1 data present; if this is zero then the file is finished;
otherwise, there is data in the payload
bytes 2-3 length of entire frame, including this 4-byte preamble
block 1
..
..
block n

Each block has the following layout:

bytes 0-1 block type
bytes 2-3 block length (including this 4-byte preamble)
bytes 4.. block payload

Keep processing blocks until the entire frame is depleted. These are the various block types:

0x0100: video intraframe (keyframe) with 3x3 vectors
0x0101: video interframe with 3x3 vectors
0x0102: video interframe with 2x2 vectors
0x0103: video interframe with 2x3 vectors
0x0200: audio frame
0x0300: palette
0x0400: game-related data; disregard
0x0401: game-related data; disregard

The next sections describe the video and audio formats in detail.

== Palette Format ==

Block type 0x0300 denotes a palette chunk. The decoder maintains a 256-element array of palette entries. Each palette entry consists of a red value, a green value, and a blue value. Each of these R, G, and B
components is a 6-bit VGA value with a range limited to 0..63. This is important to understand if the video will be decoded and rendered in more common formats that expect 8-bit components (0..255).

Palette data has the following format:

bytes 0-1 index of first palette entry to replace
bytes 2-3 number of palette entries to replace
bytes 4.. RGB byte triplets

For example, if the index of the first entry is 0x0001 and the number of palette entries to replace is 0x0077 then the decoder would iterate through palette indices 1..0x77 and read the RGB entries out of the
encoded palette.

== Video Format ==

AVS uses a very simplistic vector quantizer video coding scheme. Possible vector sizes include 2x2, 2x3, and 3x3 depending on block type. The codec was designed to operate on the standard IBM VGA 320x200
256-color video mode. However, the videos always appear to be encoded at a resolution of 318x198. Each of the video modes specifies that only one vector size is used. This is the total number of vectors comprising a frame for each vector size:

vector size vectors in a 318x198 frame
----------- --------------------------
2x2 15741
2x3 10494
3x3 6996

An intraframe is always painted with 3x3 vectors. An encoded intraframe consists of a 256-entry vector codebook followed by a vector map instructing the decoder where to place the vectors in the final frame.
In fact, an intraframe will always have the same size: 9300 (0x2454) bytes. This is the intraframe layout:

bytes 0..2303 256 9-pixel vectors
bytes 2304..9299 6996 codebook indices

An interframe is painted with varying vector sizes depending on the block type:

type 0x0101 3x3 vectors
type 0x0102 2x2 vectors
type 0x0103 2x3 vectors

An encoded interframe has the following layout:

vector codebook
vector change bitmap
codebook indices

The vector codebook consists of 256 pixel vectors. The size of each vector (either 4, 6, or 9 bytes) depends on which size vector the current interframe type uses. The size of the vector change bitmap is
defined as:

size_of_change_bitmap = ((319 / vector_width + 7) / 8) *
(199 / vector_height)

The interframe decoding algorithm is:

initialize pointers to the codebook, change bitmap, and indices
read the next byte from the change bitmap
for each vector position in image, left -> right, top -> bottom
if bit 7 of change byte is 1 then
read next codebook index from index portion of stream
copy the vector at codebook[index] into the current vector position
if bit 7 of change byte is 0 then
vector is unchanged from previous frame
shift the change byte left by 1
if the change byte has been exhausted (shifted 8 times)
read the next byte from the change bitmap

== Audio Format ==

The AVS audio format is actually taken from the [[Creative_Voice|Creative VOC format]]. A VOC chunk has the following layout:

byte 0 chunk type (should be 1)
bytes 1-3 chunk length (including 4-byte payload but not next 2 bytes)
byte 4 frequency divisor
byte 5 data packing field (should be 0 which indicates unpacked)
bytes 6.. audio data

The caveat when processing audio blocks (type 0x0200) is that the block may or be a complete VOC chunk (with a header and complete data), or may be the beginning of a VOC chunk (with header and some data), or a continuation of a VOC chunk started in a previous frame along with the start of a new VOC chunk. For example, one audio block may contain an entire VOC chunk:

frame
block 0x200, length = 8196
voc-header, chunk_length = 8188
samples -> 8188 samples
frame
block 0x200, length = 50
voc-header, chunk_length = 90
samples -> to the end of the subblock (50 - 6 VOC header bytes)
...
frame
block 0x200, length = 50
samples -> the rest of the data as counted by previous chunk_length
(90 - (50-6))
voc-header
samples
...

The frequency divisor, which should ideally remain constant through playback, is an unsigned byte that is fed directly into the classic Creative Sound Blaster to initialize the DAC for digital audio output.
The formula to calculate the playback sample rate is:

sample_rate = 1000000 / (256 - frequency_divisor)

A common divisor is 0xA6/166 which yields a sample rate of 11111 Hz.

The audio data is single-channel, unsigned, 8-bit, [[PCM]] audio data.

[[Category:Game Formats]]
[[Category:Video Codecs]]

On2 VP5

2006-09-03T15:06:39Z

Aurel:

* FourCC: VP50
* Company: [[On2]]
* Samples: http://samples.mplayerhq.hu/V-codecs/VP5/

== Format ==

The aim here is to open this standard with a full description of the bitstream format and decoding process. Contributors from On2 especially encouraged here, but it is anticipated that this section will be completed through reverse engineering.

Please do not submit any copyrighted text or code here.

=== Introduction ===

VP5 uses unidirectional ("P-frame") and intra-frame (within the current frame) prediction. Entropy coding is performed using range coding and an 8x8 iDCT is used. The format supports dynamic adjustment of encoded video resolution.

=== Macroblock types ===

Each video frame is composed of an array of 16x16 macroblocks, just like [[MPEG-2]], [[MPEG-4]] parts 2 and 10. Each [[MB]] (macroblock) takes one of the following modes ("[[MV]]" means "motion vector"):

* INTRA (1): Intra [[MB]]
* INTER_NOVEC_PF (0): Inter [[MB]], null [[MV]], previous frame reference
* INTER_DELTA_PF (2): Inter [[MB]], differential [[MV]], previous frame reference
* INTER_4V (7): Inter [[MB]], four [[MV]]s, previous frame reference
* INTER_V1_PF (3): Inter [[MB]], [[MV]] 1, previous frame reference
* INTER_V2_PF (4): Inter [[MB]], [[MV]] 2, previous frame reference
* INTER_NOVEC_GF (5): Inter [[MB]], null [[MV]], golden frame reference
* INTER_DELTA_GF (6): Inter [[MB]], differential [[MV]], golden frame reference
* INTER_V1_GF (8): Inter [[MB]], [[MV]] 1, golden frame reference
* INTER_V2_GF (9): Inter [[MB]], [[MV]] 2, golden frame reference

=== Frame Header ===

Range coding commences at the very begining of this frame header.

{| border="1"
! Syntax !! Number of bits !! Probability || Semantics
|-
| frame_mode || 1 || 128 || 0 signifies an intra frame
|-
| value0 || 1 || 128 || unused
|-
| qp || 6 || 128 || Quantization parameter valid range 0..63
|-
| if ([[#frame_mode|frame_mode]] == 0) { || || || 0 signifies intra frame
|-
| version_minor || 8 || 128 || should be 0
|-
| version_major || 5 || 128 || should be 5
|-
| value3 || 2 || 128 || unknown
|-
| interlace || 1 || 128 || true (1) means interlace will be used
|-
| dim_y || 8 || 128 || Macroblock height of video
|-
| dim_x || 8 || 128 || Macroblock width of video
|-
| render_y || 8 || 128 || Displayed macroblock height of video
|-
| render_x || 8 || 128 || Displayed macroblock width of video
|-
| value4 || 2 || 128 || unknown
|-
| } || || ||
|}

If dim_x or dim_y have values different from the previous intra frame, then the resolution of the encoded image has changed.

=== Model for macroblock type parsing ===

This section allows to calculate a model used to parse macroblock type. This model is stored in the mb_type_model[3][10][10] table. To calculate this model, an intermediate table (mb_types_stats[3][10][2]) is extracted from the input stream. The macroblock type model is useful only for non-key frames (ie. frames which can contain macroblock type other than intra). So this procedure is not used for intra frame, which instead reset the value of mb_types_stats to the content of [[#def_mb_types_stats|def_mb_types_stats]].

So first here is how the input stream must be parsed:

{| border="1"
! Syntax !! Number of bits !! Probability || Semantics
|-
| for (ctx=0; ctx<3; ctx++) {
|-
| if (flag1) { || 1 || 174 ||
|-
| index || 4 || 128 ||
|-
| mb_types_stats[ctx] = [[#pre_def_mb_type_stats|pre_def_mb_type_stats]][index][ctx]
|-
| }
|-
| if (flag2) { || 1 || 254 ||
|-
| for (type=0; type<10; type++) {
|-
| for(i=0; i<2; i++) {
|-
| if (flag3) { || 1 || 205 ||
|-
| sign || 1 || 128 ||
|-
| if (flag4) { || 1 || 171 ||
|-
| if (flag5) { || 1 || 199 ||
|-
| delta || 7 || 128 || quater of delta...
|-
| } else if (flag6) { || 1 || 140 ||
|-
| delta = 12
|-
| } else if (flag7) { || 1 || 125 ||
|-
| delta = 16
|-
| } else if (flag8) { || 1 || 104 ||
|-
| delta = 20
|-
| } else {
|-
| delta = 24
|-
| }
|-
| } else {
|-
| if (flag9) { || 1 || 83 ||
|-
| delta = 4
|-
| } else {
|-
| delta = 8
|-
| }
|-
| }
|-
| if (sign) {
|-
| delta = -delta
|-
| }
|-
| mb_types_stats[ctx][type][i] += delta
|-
| }
|-
| }
|-
| }
|-
| }
|-
| }
|}

Then mb_type_model is derived from mb_types_stats. The first index of mb_type_model is the number of predictors (0, 1 or 2). The second index is the type of the previous macroblock. A probablity is associated to each value of the third index as follow:

* 0 : probability for [[MB]] type to be the same as previous [[MB]] type
* 1 : probability for [[MB]] type to be in {[[#mb_inter_novec_pf|INTER_NOVEC_PF]], [[#mb_inter_delta_pf|INTER_DELTA_PF]], [[#mb_inter_v1_pf|INTER_V1_PF]], [[#mb_inter_v2_pf|INTER_V2_PF]]}
* 2 : probability for [[MB]] type to be in {[[#mb_inter_novec_pf|INTER_NOVEC_PF]], [[#mb_inter_delta_pf|INTER_DELTA_PF]]} knowing it's in {[[#mb_inter_novec_pf|INTER_NOVEC_PF]], [[#mb_inter_delta_pf|INTER_DELTA_PF]], [[#mb_inter_v1_pf|INTER_V1_PF]], [[#mb_inter_v2_pf|INTER_V2_PF]]}
* 3 : probability for [[MB]] type to be in {[[#mb_intra|INTRA]], [[#mb_inter_4v|INTER_4V]]} knowing it's in {[[#mb_intra|INTRA]], [[#mb_inter_novec_gf|INTER_NOVEC_GF]], [[#mb_inter_delta_gf|INTER_DELTA_GF]], [[#mb_inter_4v|INTER_4V]], [[#mb_inter_v1_gf|INTER_V1_GF]], [[#mb_inter_v2_gf|INTER_V2_GF]]}
* 4 : probability for [[MB]] type to be in {[[#mb_inter_novec_pf|INTER_NOVEC_PF]]} knowing it's in {[[#mb_inter_novec_pf|INTER_NOVEC_PF]], [[#mb_inter_delta_pf|INTER_DELTA_PF]]}
* 5 : probability for [[MB]] type to be in {[[#mb_inter_v1_pf|INTER_V1_PF]]} knowing it's in {[[#mb_inter_v1_pf|INTER_V1_PF]], [[#mb_inter_v2_pf|INTER_V2_PF]]}
* 6 : probability for [[MB]] type to be in {[[#mb_intra|INTRA]]} knowing it's in {[[#mb_intra|INTRA]], [[#mb_inter_4v|INTER_4V]]}
* 7 : probability for [[MB]] type to be in {[[#mb_inter_novec_gf|INTER_NOVEC_GF]], [[#mb_inter_delta_gf|INTER_DELTA_GF]]} knowing it's in {[[#mb_inter_novec_gf|INTER_NOVEC_GF]], [[#mb_inter_delta_gf|INTER_DELTA_GF]], [[#mb_inter_v1_gf|INTER_V1_GF]], [[#mb_inter_v2_gf|INTER_V2_GF]]}
* 8 : probability for [[MB]] type to be in {[[#mb_inter_novec_gf|INTER_NOVEC_GF]]} knowing it's in {[[#mb_inter_novec_gf|INTER_NOVEC_GF]], [[#mb_inter_delta_gf|INTER_DELTA_GF]]}
* 9 : probability for [[MB]] type to be in {[[#mb_inter_v1_gf|INTER_V1_GF]]} knowing it's in {[[#mb_inter_v1_gf|INTER_V1_GF]], [[#mb_inter_v2_gf|INTER_V2_GF]]}

mb_type_model[ctx][type][0] is calculated with the following formula:
255 - (255 * mb_types_stats[ctx][type][0]) / (1 + mb_types_stats[ctx][type][0] + mb_types_stats[ctx][type][1])

All the other probabilities are conditional probabilities noted P(A|B) and are calculated with:
1 + 255 * P(A) / (1+P(B))

For each macroblock type, it's probability is noted P(A) and calculated with:
100 * mb_types_stats[ctx][type][1]
with one exception: when calculating mb_type_model[ctx][type][i], P(type) is 0.

=== Models for macroblock type parsing ===

This header contains various models used to parse motion vectors. It is only present in non-key frames. For key frames, all those modeles are filled with 0x80 instead, except vector_model_pdi[comp][0] which is filled with 0x55.

{| border="1"
! Syntax !! Number of bits !! Probability || Semantics
|-
| for (comp=0; comp<2; comp++) {
|-
| if (flag1) { || 1 || [[#vmc_pct|vmc_pct]][comp][0] ||
|-
| vector_model_dct[comp] || 7 || 128 ||
|-
| }
|-
| if (flag2) { || 1 || [[#vmc_pct|vmc_pct]][comp][1] ||
|-
| vector_model_sig[comp] || 7 || 128 ||
|-
| }
|-
| if (flag3) { || 1 || [[#vmc_pct|vmc_pct]][comp][2] ||
|-
| vector_model_pdi[comp][0] || 7 || 128 ||
|-
| }
|-
| if (flag4) { || 1 || [[#vmc_pct|vmc_pct]][comp][3] ||
|-
| vector_model_pdi[comp][1] || 7 || 128 ||
|-
| }
|-
| }
|-
| for (comp=0; comp<2; comp++) {
|-
| for (node=0; node<7; node++) {
|-
| if (flag5) { || 1 || [[#vmc_pct|vmc_pct]][comp][4+node] ||
|-
| vector_model_pdv[comp][node] || 7 || 128 ||
|-
| }
|-
| }
|-
| }
|}

All the value in thoses models must be multiplied by 2. Those models can't contain a 0 value, so every 0 must then be replaced by a 1.

=== Models for DCT coefficient parsing ===

This header contains various models used to parse DCT coefficient. Theses parsing are using a default_probability table which is initially filled with 0x80. The value read from the bitstream must be multiplied by 2. If the value is 0, it must be replaced by 1.
The last two models are derived from the first two.

==== DC coefficient model ====

{| border="1"
! Syntax !! Number of bits !! Probability || Semantics
|-
| for (pt=0; pt<2; pt++) {
|-
| for (node=0; node<11; node++) {
|-
| if (flag1) { || 1 || [[#dccv_pct|dccv_pct]][pt][node] ||
|-
| coeff_model_dccv[pt][node] = default_probability[node] || 7 || 128 ||
|-
| } else if ([[#frame_mode|frame_mode]] == 0) {
|-
| coeff_model_dccv[pt][node] = default_probability[node]
|-
| }
|-
| }
|-
| }
|}

==== AC coefficient model ====

The value read from the bitstream must be multiplied by 2. If the value is 0, it must be replaced by 1.

{| border="1"
! Syntax !! Number of bits !! Probability || Semantics
|-
| for (ct=0; ct<3; ct++) {
|-
| for (pt=0; pt<2; pt++) {
|-
| for (cg=0; cg<6; cg++) {
|-
| for (node=0; node<11; node++) {
|-
| if (flag1) { || 1 || [[#ract_pct|ract_pct]][ct][pt][cg][node] ||
|-
| coeff_model_ract[pt][ct][cg][node] = default_probability[node] || 7 || 128 ||
|-
| } else if ([[#frame_mode|frame_mode]] == 0) {
|-
| coeff_model_ract[pt][ct][cg][node] = default_probability[node]
|-
| }
|-
| }
|-
| }
|-
| }
|-
| }
|}

==== DC coefficient coding type model ====

Every value in this model is calculated with the folowing formula:

coeff_model_dcct[pt][ctx][node] = ceil((coeff_model_dccv[pt][node] * [[#dccv_lc|dccv_lc]][node][ctx][0]) / 256)
+ [[#dccv_lc|dccv_lc]][node][ctx][1];

All the values in this model must be clipped between 1 and 254.

==== AC coefficient coding type model ====

Every value in this model is calculated with the folowing formula:

coeff_model_act[pt][ct][cg][ctx][node] = ceil((coeff_model_ract[pt][ct][cg][node] * [[#ract_lc|ract_lc]][ct][cg][node][ctx][0]) / 256)
+ [[#ract_lc|ract_lc]][ct][cg][node][ctx][1];

All the values in this model must be clipped between 1 and 254.

=== Macroblocks ===

Here starts the main macroblocks parsing loop. Macroblocks are coded from left to right and from top to bottom of the final picture.

==== MB type ====

For non-key frames, [[MB]] parsing begin with the decoding of the type of the [[MB]].

First we need to get the ctx value from [[#vector_predictor|vector_predictor]] with frame_type set to FRAME_PREVIOUS. Then we select the proper model which is [[#mb_type_model|mb_type_model]][ctx][prev_type] (prev_type is the type of the [[MB]] which was parsed just before this one).
The [[MB]] type parsing itself is done according to the selected mb_type_model which defines a binary tree of probabilities. This tree is described right below. In this tree, each [x] means get 1 bit in the input stream using mb_type_model[x] as probability for this bit. If bit is 0, go to the top branch, if it's 1, go to the bottom branch. The leaf indicate the final type of this MB.

+-- [[#mb_inter_novec_pf|INTER_NOVEC_PF]]
|
+-- [4] --+
| |
| +-- [[#mb_inter_delta_pf|INTER_DELTA_PF]]
|
+-- [2] --+
| |
| | +-- [[#mb_inter_v1_pf|INTER_V1_PF]]
| | |
| +-- [5] --+
| |
| +-- [[#mb_inter_v2_pf|INTER_V2_PF]]
|
+-- [1] --+
| |
| | +-- [[#mb_intra|INTRA]]
| | |
| | +-- [6] --+
| | | |
| | | +-- [[#mb_inter_4v|INTER_4V]]
| | |
| +-- [3] --+
| |
| | +-- [[#mb_inter_novec_gf|INTER_NOVEC_GF]]
| | |
| | +-- [8] --+
| | | |
| | | +-- [[#mb_inter_delta_gf|INTER_DELTA_GF]]
| | |
| +-- [7] --+
| |
| | +-- [[#mb_inter_v1_gf|INTER_V1_GF]]
| | |
| +-- [9] --+
| |
| +-- [[#mb_inter_v2_gf|INTER_V2_GF]]
|
-- [0] --+
|
+-- prev_type

==== Motion vector ====

The motion vector applies to all the blocks in the [[MB]] except in the case of [[#Four motion vectors|four motion vectors]]
There are different kind of [[MV]] decoding depending on [[MB]] type :

===== Straight vector candidate =====
Apply to the following [[MB]] types: [[#mb_inter_v1_pf|INTER_V1_PF]], [[#mb_inter_v2_pf|INTER_V2_PF]], [[#mb_inter_v1_gf|INTER_V1_GF]], [[#mb_inter_v2_gf|INTER_V2_GF]]

The motion vector is the first (for V1) or second (for V2) candidate from [[#vector_predictor|vector_predictor]] with frame_type set either to FRAME_PREVIOUS (for PF) or to FRAME_GOLDEN (for GF).

===== Delta vector =====
Apply to the following [[MB]] types: [[#mb_inter_delta_pf|INTER_DELTA_PF]], [[#mb_inter_delta_gf|INTER_DELTA_GF]]

Default delta, di1, di2 and neg value is 0.
You then need to apply the following parsing first with comp = 0 (for component x of the vector) and then with comp = 1 (for component y of the vector):

{| border="1"
! Syntax !! Number of bits !! Probability || Semantics
|-
| if (flag1) { || 1 || vector_model_dct[comp] ||
|-
| neg || 1 || vector_model_sig[comp] ||
|-
| di1 || 1 || vector_model_pdi[comp][0] ||
|-
| di2 || 1 || vector_model_pdi[comp][1] ||
|-
| delta || || || here a binary tree parsing happens (see below)
|-
| }
|}

The delta parsing itself is done according to vector_model_pdv[comp] which defines a binary tree of probabilities. This tree is described right below. In this tree, each [x] means get 1 bit in the input stream using vector_model_pdv[comp][x] as probability for this bit. If bit is 0, go to the top branch, if it's 1, go to the bottom branch. The leaf indicate the final value of delta.

+-- 0
+-- [2] --+
| +-- 1
+-- [1] --+
| | +-- 2
| +-- [3] --+
| +-- 3
-- [0] --+
| +-- 4
| +-- [5] --+
| | +-- 5
+-- [4] --+
| +-- 6
+-- [6] --+
+-- 7

When the value of delta, di1, di2 and neg are parsed, the value of the current vector component can be calculated this way:
component = (1-2*neg) * (di1 | (di2 << 1) | (delta << 2))

===== Four motion vectors =====
Apply to the following [[MB]] types: [[#mb_inter_4v|INTER_4V]]

For this type of [[MB]] each of the 4 luma block of the [[MB]] use a different [[MV]]. So each of this 4 luma block has it's own block type. This block type can only be one which refers to PREVIOUS_FRAME (ie. [[#mb_inter_v1_pf|INTER_V1_PF]], [[#mb_inter_v2_pf|INTER_V2_PF]], [[#mb_inter_delta_pf|INTER_DELTA_PF]], [[#mb_inter_novec_pf|INTER_NOVEC_PF]]).

Those 4 block types should be parsed this way:
{| border="1"
! Syntax !! Number of bits !! Probability || Semantics
|-
| for (block=0; block<4; block++) {
|-
| type[block] || 2 || 128 ||
|-
| if (type[block] != INTER_NOVEC_PF) {
|-
| type[block]++
|-
| }
|-
| }
|}

Then for each of the 4 luma blocks it's [[MV]] is calculated the same way as if it were a full [[MB]], according to it's block type.

The [[MV]] of the 2 chroma block is then calculated as the average of the 4 luma [[MV]].

===== Zero vector =====
Apply to all the other [[MB]] types.

This is simply a null vector.

==== MB coefficients ====

This is the real content of the [[MB]], ie. the data which will be feeded to the [[#Inverse DCT|Inverse DCT]].

This procedure is repeated 6 times (for each block in the [[MB]], with block_num being the num of the block in the [[MB]] between 0 and 5). It uses several initialized variables :
* ct: code type, initialized to 1
* pt: plane type, initialized to 0 for luma blocks and 1 for chroma blocks
* ctx_last: initialized to the maximum coeff_idx of previous block on the same row and normalized to a maximal value of 24 (initialized to 24 at the start of a row).
* above_block_ndc: initialized to 0 if the DC coefficient of the block just above the current one is null, 1 else
* bi: initialized to 0 for blocks 0 and 1, 1 for blocks 2 and 3, 2 for block 4, and 3 for block 5
* coeff_ctx: this array is filled with 0 at the begining of each macroblock row

for (coeff_idx=0; coeff_idx<64; coeff_idx++) {
/* select the correct models */
if (coeff_idx == 0) { /* DC coeff */
ctx = 6*coeff_ctx[bi][0] + above_block_ndc;
m1 = coeff_model_dccv[pt];
m2 = coeff_model_dcct[pt][ctx];
} else { /* AC coeff */
int cg = coeff_groups[coeff_idx];
ctx = coeff_ctx[bi][coeff_idx];
m1 = coeff_model_ract[pt][ct][cg];
m2 = cg > 2 ? model : coeff_model_act[pt][ct][cg][ctx];
}

/*
* Here applies a binary tree parssing as defined below.
*/

block_coeff[block_num][coeff_idx] = (coeff ^ -sign) + sign;
coeff_ctx[bi][coeff_idx] = cctx;
}

if (coeff_idx < ctx_last) {
for (i=coeff_idx; i<=ctx_last; i++)
coeff_ctx[bi][i] = 5;
}

The following binary tree parsing allows to extract coefficients of the block plus other parameters useful for the decoding procedure itself. In this tree, each m1[x] or m2[x] means get 1 bit in the input stream using m1[x] or m2[x] as probability for this bit. If bit is 0, go to the top branch, if it's 1, go to the bottom branch. The leaf indicate the value extracted at the end of this tree parsing.

+-- end of this block (break out of the loop)
|
+- m2[1] -+
| |
| if !ct |
+---------+-- ct=0, cctx=0
|
- m2[0] -+
|
| +-- ct=1, cctx=1, sign=get_bit(), coeff=1
| |
+- m2[2] -+
| +-- ct=2, cctx=2, sign=get_bit(), coeff=2
| |
| +- m2[4] -+
| | | +-- ct=2, cctx=3, sign=get_bit(), coeff=3
| | | |
| | +- m2[5] -+
| | |
| | +-- ct=2, cctx=3, sign=get_bit(), coeff=4
+- m2[3] -+
|
|
| +-- ct=2, cctx=4, sign=get_bit(), coeff=[[#coeff_parse|coeff_parse]](0)
| |
| +- m1[7] -+
| | |
| | +-- ct=2, cctx=4, sign=get_bit(), coeff=[[#coeff_parse|coeff_parse]](1)
| |
+- m1[6] -+
|
| +-- ct=2, cctx=4, sign=get_bit(), coeff=[[#coeff_parse|coeff_parse]](2)
| |
| +- m1[9] -+
| | |
| | +-- ct=2, cctx=4, sign=get_bit(), coeff=[[#coeff_parse|coeff_parse]](3)
| |
+- m1[8] -+
|
| +-- ct=2, cctx=4, sign=get_bit(), coeff=[[#coeff_parse|coeff_parse]](4)
| |
+- m1[10] +
|
+-- ct=2, cctx=4, sign=get_bit(), coeff=[[#coeff_parse|coeff_parse]](5)

The coeff_parse algorithm used by the previous binary tree parsing takes one parameter called idx and behave like this :
{| border="1"
! Syntax !! Number of bits !! Probability || Semantics
|-
| coeff = [[#coeff_bias|coeff_bias]][idx]
|-
| for (i=[[#coeff_bit_length|coeff_bit_length]][idx]; i>=0; i--) {
|-
| v || 1 || [[#coeff_parse_table|coeff_parse_table]][idx][i] ||
|-
| coeff += v << i
|-
| }
|}

== Algorithms ==

=== Entropy Coding ===

Described here is the decoding process for the arithmetically-coded (AC) parts of the bitstream. VP5 uses a 16-bit [http://en.wikipedia.org/wiki/Range_encoding range coding] scheme to code binary symbols.

The AC decoder maintains three state variables: ''code'', ''mask'' and ''high''.

==== Initialization ====

At initialization, the first two bytes of the AC bitstream are shifted into ''code''. The variable ''high'' is set to 0xff00. The variable ''mask'' is set to 0xffff.

==== Decoding a Binary Value ====

Each binary symbol has an associated probability ''p'' in the range 0 to 0xff.

A threshold, ''t'', is computed thus:

: ''t'' = 0x100 + ( 0xff00 & ( ( (''high''-0x100) * ''p'' ) >> 8 ) )

Equiprobable binary symbols are treated somewhat differently:

: ''t'' = 0xff00 & ( (''high''+0x100) >> 1 )

The binary value may then be decoded by comparing ''code'' and ''t''. If ''code'' is less than ''t'', the binary value is decoded as 0. If ''code'' is equal to or greater than ''t'', the binary value is decoded as 1.

If a 1 was decoded, then

: ''high'' = ''high'' - ''t''
: ''code'' = ''code'' - ''t''

If a 0 was decoded, then

: ''high'' = ''t''

The following renormalization is now repeated while (''high'' & 0x8000) is non-zero.

: ''high'' = 2 * ''high''
: ''code'' = 2 * ''code''
: ''mask'' = 2 * ''mask''
: if ((''mask'' & 0xff) == 0x00) {
:: ''code'' = ''code'' | next byte from bitstream
:: ''mask'' = ''mask'' | 0xff
:}

==== Decoding an Equiprobable n-bit Integer Value ====

Integer values are coded as a big-endian sequence of equiprobable binary values. To decode an n-bit equiprobable integer value, n equiprobable binary values should be decoded using the sequence above and left-shifted into an integral result variable.

=== Inverse DCT ===

Inverse DCT is performed on 8x8 blocks of pixels. The algorithm used is the same than the one used for the [[On2 VP3|VP3]] decoder in [[FFmpeg]] [http://svn.mplayerhq.hu/ffmpeg/trunk/libavcodec/vp3dsp.c?view=markup], the original vp3 iDCT code is here [http://svn.xiph.org/trunk/vp32/CoreLibs/CDXV/Vp31/dx/generic/IDctPart.c].

=== vector_predictor ===

This algorithm allows to get the valid candidate [[MV]] for current [[MB]] regarding frame_type (which is a parameter of this algorithm).

It checks all the candidate macroblocks for motion compensation. Store in nb_predictor the number of candidate [[MB]] whose last type was refering to frame_type and whose last [[MV]] was not null (no need to check for more than 2 valid candidate). The first 2 valid candidate [[MV]] are stored in the vector_candidate table.

ctx is then derived from nb_predictor with the following formula:

ctx = (nb_predictor + 1) % 3

The candidate [MB]] are defined as (x,y) positions relative to current [[MB]]. All those possible relative position are defined in [[#candidate_predictor_pos|candidate_predictor_pos]].

The last [[MB]] type and [[MV]] are stored in an array of size [[#dim_x|dim_x]] by [[#dim_y|dim_y]]. This array is updated as soon a we parse a new [[MB]].

== Data tables ==

=== def_mb_types_stats ===
{ { { 69, 42 }, { 1, 2 }, { 1, 7 }, { 44, 42 }, { 6, 22 },
{ 1, 3 }, { 0, 2 }, { 1, 5 }, { 0, 1 }, { 0, 0 }, },
{ { 229, 8 }, { 1, 1 }, { 0, 8 }, { 0, 0 }, { 0, 0 },
{ 1, 2 }, { 0, 1 }, { 0, 0 }, { 1, 1 }, { 0, 0 }, },
{ { 122, 35 }, { 1, 1 }, { 1, 6 }, { 46, 34 }, { 0, 0 },
{ 1, 2 }, { 0, 1 }, { 0, 1 }, { 1, 1 }, { 0, 0 }, }, }

=== pre_def_mb_type_stats ===
{ { { { 9, 15 }, { 32, 25 }, { 7, 19 }, { 9, 21 }, { 1, 12 },
{ 14, 12 }, { 3, 18 }, { 14, 23 }, { 3, 10 }, { 0, 4 }, },
{ { 41, 22 }, { 1, 0 }, { 1, 31 }, { 0, 0 }, { 0, 0 },
{ 0, 1 }, { 1, 7 }, { 0, 1 }, { 98, 25 }, { 4, 10 }, },
{ { 2, 3 }, { 2, 3 }, { 0, 2 }, { 0, 2 }, { 0, 0 },
{ 11, 4 }, { 1, 4 }, { 0, 2 }, { 3, 2 }, { 0, 4 }, }, },
{ { { 48, 39 }, { 1, 2 }, { 11, 27 }, { 29, 44 }, { 7, 27 },
{ 1, 4 }, { 0, 3 }, { 1, 6 }, { 1, 2 }, { 0, 0 }, },
{ { 123, 37 }, { 6, 4 }, { 1, 27 }, { 0, 0 }, { 0, 0 },
{ 5, 8 }, { 1, 7 }, { 0, 1 }, { 12, 10 }, { 0, 2 }, },
{ { 49, 46 }, { 3, 4 }, { 7, 31 }, { 42, 41 }, { 0, 0 },
{ 2, 6 }, { 1, 7 }, { 1, 4 }, { 2, 4 }, { 0, 1 }, }, },
{ { { 21, 32 }, { 1, 2 }, { 4, 10 }, { 32, 43 }, { 6, 23 },
{ 2, 3 }, { 1, 19 }, { 1, 6 }, { 12, 21 }, { 0, 7 }, },
{ { 26, 14 }, { 14, 12 }, { 0, 24 }, { 0, 0 }, { 0, 0 },
{ 55, 17 }, { 1, 9 }, { 0, 36 }, { 5, 7 }, { 1, 3 }, },
{ { 26, 25 }, { 1, 1 }, { 2, 10 }, { 67, 39 }, { 0, 0 },
{ 1, 1 }, { 0, 14 }, { 0, 2 }, { 31, 26 }, { 1, 6 }, }, },
{ { { 69, 83 }, { 0, 0 }, { 0, 2 }, { 10, 29 }, { 3, 12 },
{ 0, 1 }, { 0, 3 }, { 0, 3 }, { 2, 2 }, { 0, 0 }, },
{ { 209, 5 }, { 0, 0 }, { 0, 27 }, { 0, 0 }, { 0, 0 },
{ 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 0 }, { 0, 0 }, },
{ { 103, 46 }, { 1, 2 }, { 2, 10 }, { 33, 42 }, { 0, 0 },
{ 1, 4 }, { 0, 3 }, { 0, 1 }, { 1, 3 }, { 0, 0 }, }, },
{ { { 11, 20 }, { 1, 4 }, { 18, 36 }, { 43, 48 }, { 13, 35 },
{ 0, 2 }, { 0, 5 }, { 3, 12 }, { 1, 2 }, { 0, 0 }, },
{ { 2, 5 }, { 4, 5 }, { 0, 121 }, { 0, 0 }, { 0, 0 },
{ 0, 3 }, { 2, 4 }, { 1, 4 }, { 2, 2 }, { 0, 1 }, },
{ { 14, 31 }, { 9, 13 }, { 14, 54 }, { 22, 29 }, { 0, 0 },
{ 2, 6 }, { 4, 18 }, { 6, 13 }, { 1, 5 }, { 0, 1 }, }, },
{ { { 70, 44 }, { 0, 1 }, { 2, 10 }, { 37, 46 }, { 8, 26 },
{ 0, 2 }, { 0, 2 }, { 0, 2 }, { 0, 1 }, { 0, 0 }, },
{ { 175, 5 }, { 0, 1 }, { 0, 48 }, { 0, 0 }, { 0, 0 },
{ 0, 2 }, { 0, 1 }, { 0, 2 }, { 0, 1 }, { 0, 0 }, },
{ { 85, 39 }, { 0, 0 }, { 1, 9 }, { 69, 40 }, { 0, 0 },
{ 0, 1 }, { 0, 3 }, { 0, 1 }, { 2, 3 }, { 0, 0 }, }, },
{ { { 8, 15 }, { 0, 1 }, { 8, 21 }, { 74, 53 }, { 22, 42 },
{ 0, 1 }, { 0, 2 }, { 0, 3 }, { 1, 2 }, { 0, 0 }, },
{ { 83, 5 }, { 2, 3 }, { 0, 102 }, { 0, 0 }, { 0, 0 },
{ 1, 3 }, { 0, 2 }, { 0, 1 }, { 0, 0 }, { 0, 0 }, },
{ { 31, 28 }, { 0, 0 }, { 3, 14 }, { 130, 34 }, { 0, 0 },
{ 0, 1 }, { 0, 3 }, { 0, 1 }, { 3, 3 }, { 0, 1 }, }, },
{ { { 141, 42 }, { 0, 0 }, { 1, 4 }, { 11, 24 }, { 1, 11 },
{ 0, 1 }, { 0, 1 }, { 0, 2 }, { 0, 0 }, { 0, 0 }, },
{ { 233, 6 }, { 0, 0 }, { 0, 8 }, { 0, 0 }, { 0, 0 },
{ 0, 1 }, { 0, 1 }, { 0, 0 }, { 0, 1 }, { 0, 0 }, },
{ { 171, 25 }, { 0, 0 }, { 1, 5 }, { 25, 21 }, { 0, 0 },
{ 0, 1 }, { 0, 1 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, }, },
{ { { 8, 19 }, { 4, 10 }, { 24, 45 }, { 21, 37 }, { 9, 29 },
{ 0, 3 }, { 1, 7 }, { 11, 25 }, { 0, 2 }, { 0, 1 }, },
{ { 34, 16 }, { 112, 21 }, { 1, 28 }, { 0, 0 }, { 0, 0 },
{ 6, 8 }, { 1, 7 }, { 0, 3 }, { 2, 5 }, { 0, 2 }, },
{ { 17, 21 }, { 68, 29 }, { 6, 15 }, { 13, 22 }, { 0, 0 },
{ 6, 12 }, { 3, 14 }, { 4, 10 }, { 1, 7 }, { 0, 3 }, }, },
{ { { 46, 42 }, { 0, 1 }, { 2, 10 }, { 54, 51 }, { 10, 30 },
{ 0, 2 }, { 0, 2 }, { 0, 1 }, { 0, 1 }, { 0, 0 }, },
{ { 159, 35 }, { 2, 2 }, { 0, 25 }, { 0, 0 }, { 0, 0 },
{ 3, 6 }, { 0, 5 }, { 0, 1 }, { 4, 4 }, { 0, 1 }, },
{ { 51, 39 }, { 0, 1 }, { 2, 12 }, { 91, 44 }, { 0, 0 },
{ 0, 2 }, { 0, 3 }, { 0, 1 }, { 2, 3 }, { 0, 1 }, }, },
{ { { 28, 32 }, { 0, 0 }, { 3, 10 }, { 75, 51 }, { 14, 33 },
{ 0, 1 }, { 0, 2 }, { 0, 1 }, { 1, 2 }, { 0, 0 }, },
{ { 75, 39 }, { 5, 7 }, { 2, 48 }, { 0, 0 }, { 0, 0 },
{ 3, 11 }, { 2, 16 }, { 1, 4 }, { 7, 10 }, { 0, 2 }, },
{ { 81, 25 }, { 0, 0 }, { 2, 9 }, { 106, 26 }, { 0, 0 },
{ 0, 1 }, { 0, 1 }, { 0, 1 }, { 1, 1 }, { 0, 0 }, }, },
{ { { 100, 46 }, { 0, 1 }, { 3, 9 }, { 21, 37 }, { 5, 20 },
{ 0, 1 }, { 0, 2 }, { 1, 2 }, { 0, 1 }, { 0, 0 }, },
{ { 212, 21 }, { 0, 1 }, { 0, 9 }, { 0, 0 }, { 0, 0 },
{ 1, 2 }, { 0, 2 }, { 0, 0 }, { 2, 2 }, { 0, 0 }, },
{ { 140, 37 }, { 0, 1 }, { 1, 8 }, { 24, 33 }, { 0, 0 },
{ 1, 2 }, { 0, 2 }, { 0, 1 }, { 1, 2 }, { 0, 0 }, }, },
{ { { 27, 29 }, { 0, 1 }, { 9, 25 }, { 53, 51 }, { 12, 34 },
{ 0, 1 }, { 0, 3 }, { 1, 5 }, { 0, 2 }, { 0, 0 }, },
{ { 4, 2 }, { 0, 0 }, { 0, 172 }, { 0, 0 }, { 0, 0 },
{ 0, 1 }, { 0, 2 }, { 0, 0 }, { 2, 0 }, { 0, 0 }, },
{ { 14, 23 }, { 1, 3 }, { 11, 53 }, { 90, 31 }, { 0, 0 },
{ 0, 3 }, { 1, 5 }, { 2, 6 }, { 1, 2 }, { 0, 0 }, }, },
{ { { 80, 38 }, { 0, 0 }, { 1, 4 }, { 69, 33 }, { 5, 16 },
{ 0, 1 }, { 0, 1 }, { 0, 0 }, { 0, 1 }, { 0, 0 }, },
{ { 187, 22 }, { 1, 1 }, { 0, 17 }, { 0, 0 }, { 0, 0 },
{ 3, 6 }, { 0, 4 }, { 0, 1 }, { 4, 4 }, { 0, 1 }, },
{ { 123, 29 }, { 0, 0 }, { 1, 7 }, { 57, 30 }, { 0, 0 },
{ 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 0 }, }, },
{ { { 16, 20 }, { 0, 0 }, { 2, 8 }, { 104, 49 }, { 15, 33 },
{ 0, 1 }, { 0, 1 }, { 0, 1 }, { 1, 1 }, { 0, 0 }, },
{ { 133, 6 }, { 1, 2 }, { 1, 70 }, { 0, 0 }, { 0, 0 },
{ 0, 2 }, { 0, 4 }, { 0, 3 }, { 1, 1 }, { 0, 0 }, },
{ { 13, 14 }, { 0, 0 }, { 4, 20 }, { 175, 20 }, { 0, 0 },
{ 0, 1 }, { 0, 1 }, { 0, 1 }, { 1, 1 }, { 0, 0 }, }, },
{ { { 194, 16 }, { 0, 0 }, { 1, 1 }, { 1, 9 }, { 1, 3 },
{ 0, 0 }, { 0, 1 }, { 0, 1 }, { 0, 0 }, { 0, 0 }, },
{ { 251, 1 }, { 0, 0 }, { 0, 2 }, { 0, 0 }, { 0, 0 },
{ 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 }, },
{ { 202, 23 }, { 0, 0 }, { 1, 3 }, { 2, 9 }, { 0, 0 },
{ 0, 1 }, { 0, 1 }, { 0, 1 }, { 0, 0 }, { 0, 0 }, }, }, }

=== vmc_pct ===
{ { 243, 220, 251, 253, 237, 232, 241, 245, 247, 251, 253 },
{ 235, 211, 246, 249, 234, 231, 248, 249, 252, 252, 254 }, }

=== dccv_pct ===
{ { 146, 197, 181, 207, 232, 243, 238, 251, 244, 250, 249 },
{ 179, 219, 214, 240, 250, 254, 244, 254, 254, 254, 254 }, }

=== ract_pct ===
{ { { { 227, 246, 230, 247, 244, 254, 254, 254, 254, 254, 254 },
{ 202, 254, 209, 231, 231, 249, 249, 253, 254, 254, 254 },
{ 206, 254, 225, 242, 241, 251, 253, 254, 254, 254, 254 },
{ 235, 254, 241, 253, 252, 254, 254, 254, 254, 254, 254 },
{ 234, 254, 248, 254, 254, 254, 254, 254, 254, 254, 254 },
{ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 }, },
{ { 240, 254, 248, 254, 254, 254, 254, 254, 254, 254, 254 },
{ 238, 254, 240, 253, 254, 254, 254, 254, 254, 254, 254 },
{ 244, 254, 251, 254, 254, 254, 254, 254, 254, 254, 254 },
{ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 },
{ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 },
{ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 }, }, },
{ { { 206, 203, 227, 239, 247, 254, 253, 254, 254, 254, 254 },
{ 207, 199, 220, 236, 243, 252, 252, 254, 254, 254, 254 },
{ 212, 219, 230, 243, 244, 253, 252, 254, 254, 254, 254 },
{ 236, 237, 247, 252, 253, 254, 254, 254, 254, 254, 254 },
{ 240, 240, 248, 254, 254, 254, 254, 254, 254, 254, 254 },
{ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 }, },
{ { 230, 233, 249, 254, 254, 254, 254, 254, 254, 254, 254 },
{ 238, 238, 250, 254, 254, 254, 254, 254, 254, 254, 254 },
{ 248, 251, 254, 254, 254, 254, 254, 254, 254, 254, 254 },
{ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 },
{ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 },
{ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 }, }, },
{ { { 225, 239, 227, 231, 244, 253, 243, 254, 254, 253, 254 },
{ 232, 234, 224, 228, 242, 249, 242, 252, 251, 251, 254 },
{ 235, 249, 238, 240, 251, 254, 249, 254, 253, 253, 254 },
{ 249, 253, 251, 250, 254, 254, 254, 254, 254, 254, 254 },
{ 251, 250, 249, 254, 254, 254, 254, 254, 254, 254, 254 },
{ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 }, },
{ { 243, 244, 250, 250, 254, 254, 254, 254, 254, 254, 254 },
{ 249, 248, 250, 253, 254, 254, 254, 254, 254, 254, 254 },
{ 253, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 },
{ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 },
{ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 },
{ 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254 }, }, }, }

=== dccv_lc ===
{ { {154, 61}, {141, 54}, { 90, 45}, { 54, 34}, { 54, 13}, {128, 109},
{136, 54}, {148, 45}, { 92, 41}, { 54, 33}, { 51, 15}, { 87, 113},
{ 87, 44}, { 97, 40}, { 67, 36}, { 46, 29}, { 41, 15}, { 64, 80},
{ 59, 33}, { 61, 31}, { 51, 28}, { 44, 22}, { 33, 12}, { 49, 63},
{ 69, 12}, { 59, 16}, { 46, 14}, { 31, 13}, { 26, 6}, { 92, 26},
{128, 108}, { 77, 119}, { 54, 84}, { 26, 71}, { 87, 19}, { 95, 155}, },
{ {154, 4}, {182, 0}, {159, -8}, {128, -5}, {143, -5}, {187, 55},
{182, 0}, {228, -3}, {187, -7}, {174, -9}, {189, -11}, {169, 79},
{161, -9}, {192, -8}, {187, -9}, {169, -10}, {136, -9}, {184, 40},
{164, -11}, {179, -10}, {174, -10}, {161, -10}, {115, -7}, {197, 20},
{195, -11}, {195, -11}, {146, -10}, {110, -6}, { 95, -4}, {195, 39},
{182, 55}, {172, 77}, {177, 37}, {169, 29}, {172, 52}, { 92, 162}, },
{ {174, 80}, {164, 80}, { 95, 80}, { 46, 66}, { 56, 24}, { 36, 193},
{164, 80}, {166, 77}, {105, 76}, { 49, 68}, { 46, 31}, { 49, 186},
{ 97, 78}, {110, 74}, { 72, 72}, { 44, 60}, { 33, 30}, { 69, 131},
{ 61, 61}, { 69, 63}, { 51, 57}, { 31, 48}, { 26, 27}, { 64, 89},
{ 67, 23}, { 51, 32}, { 36, 33}, { 26, 28}, { 20, 12}, { 44, 68},
{ 26, 197}, { 41, 189}, { 61, 129}, { 28, 103}, { 49, 52}, {-12, 245}, },
{ {102, 141}, { 79, 166}, { 72, 162}, { 97, 125}, {179, 4}, {307, 0},
{ 72, 168}, { 69, 175}, { 84, 160}, {105, 127}, {148, 34}, {310, 0},
{ 84, 151}, { 82, 161}, { 87, 153}, { 87, 135}, {115, 51}, {317, 0},
{ 97, 125}, {102, 131}, {105, 125}, { 87, 122}, { 84, 64}, { 54, 184},
{166, 18}, {146, 43}, {125, 51}, { 90, 64}, { 95, 7}, { 38, 154},
{294, 0}, { 13, 225}, { 10, 225}, { 67, 168}, { 0, 167}, {161, 94}, },
{ {172, 76}, {172, 75}, {136, 80}, { 64, 98}, { 74, 67}, {315, 0},
{169, 76}, {207, 56}, {164, 66}, { 97, 80}, { 67, 72}, {328, 0},
{136, 80}, {187, 53}, {154, 62}, { 72, 85}, { -2, 105}, {305, 0},
{ 74, 91}, {128, 64}, {113, 64}, { 61, 77}, { 41, 75}, {259, 0},
{ 46, 84}, { 51, 81}, { 28, 89}, { 31, 78}, { 23, 77}, {202, 0},
{323, 0}, {323, 0}, {300, 0}, {236, 0}, {195, 0}, {328, 0}, }, }

=== ract_lc ===
{ { { { {276, 0}, {238, 0}, {195, 0}, {156, 0}, {113, 0}, {274, 0} },
{ { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1} },
{ {192, 59}, {182, 50}, {141, 48}, {110, 40}, { 92, 19}, {125,128} },
{ {169, 87}, {169, 83}, {184, 62}, {220, 16}, {184, 0}, {264, 0} },
{ {212, 40}, {212, 36}, {169, 49}, {174, 27}, { 8,120}, {182, 71} }, },
{ { {259, 10}, {197, 19}, {143, 22}, {123, 16}, {110, 8}, {133, 88} },
{ { 0, 1}, {256, 0}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1} },
{ {207, 46}, {187, 50}, { 97, 83}, { 23,100}, { 41, 56}, { 56,188} },
{ {166, 90}, {146,108}, {161, 88}, {136, 95}, {174, 0}, {266, 0} },
{ {264, 7}, {243, 18}, {184, 43}, {-14,154}, { 20,112}, { 20,199} }, },
{ { {230, 26}, {197, 22}, {159, 20}, {146, 12}, {136, 4}, { 54,162} },
{ { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1}, { 0, 1} },
{ {192, 59}, {156, 72}, { 84,101}, { 49,101}, { 79, 47}, { 79,167} },
{ {138,115}, {136,116}, {166, 80}, {238, 0}, {195, 0}, {261, 0} },
{ {225, 33}, {205, 42}, {159, 61}, { 79, 96}, { 92, 66}, { 28,195} }, },
}, {
{ { {200, 37}, {197, 18}, {159, 13}, {143, 7}, {102, 5}, {123,126} },
{ {197, 3}, {220, -9}, {210,-12}, {187, -6}, {151, -2}, {174, 80} },
{ {200, 53}, {187, 47}, {159, 40}, {118, 38}, {100, 18}, {141,111} },
{ {179, 78}, {166, 86}, {197, 50}, {207, 27}, {187, 0}, {115,139} },
{ {218, 34}, {220, 29}, {174, 46}, {128, 61}, { 54, 89}, {187, 65} }, },
{ { {238, 14}, {197, 18}, {125, 26}, { 90, 25}, { 82, 13}, {161, 86} },
{ {189, 1}, {205, -2}, {156, -4}, {143, -4}, {146, -4}, {172, 72} },
{ {230, 31}, {192, 45}, {102, 76}, { 38, 85}, { 56, 41}, { 64,173} },
{ {166, 91}, {141,111}, {128,116}, {118,109}, {177, 0}, { 23,222} },
{ {253, 14}, {236, 21}, {174, 49}, { 33,118}, { 44, 93}, { 23,187} }, },
{ { {218, 28}, {179, 28}, {118, 35}, { 95, 30}, { 72, 24}, {128,108} },
{ {187, 1}, {174, -1}, {125, -1}, {110, -1}, {108, -1}, {202, 52} },
{ {197, 53}, {146, 75}, { 46,118}, { 33,103}, { 64, 50}, {118,126} },
{ {138,114}, {128,122}, {161, 86}, {243, -6}, {195, 0}, { 38,210} },
{ {215, 39}, {179, 58}, { 97,101}, { 95, 85}, { 87, 70}, { 69,152} }, },
}, {
{ { {236, 24}, {205, 18}, {172, 12}, {154, 6}, {125, 1}, {169, 75} },
{ {187, 4}, {230, -2}, {228, -4}, {236, -4}, {241, -2}, {192, 66} },
{ {200, 46}, {187, 42}, {159, 34}, {136, 25}, {105, 10}, {179, 62} },
{ {207, 55}, {192, 63}, {192, 54}, {195, 36}, {177, 1}, {143, 98} },
{ {225, 27}, {207, 34}, {200, 30}, {131, 57}, { 97, 60}, {197, 45} }, },
{ { {271, 8}, {218, 13}, {133, 19}, { 90, 19}, { 72, 7}, {182, 51} },
{ {179, 1}, {225, -1}, {154, -2}, {110, -1}, { 92, 0}, {195, 41} },
{ {241, 26}, {189, 40}, { 82, 64}, { 33, 60}, { 67, 17}, {120, 94} },
{ {192, 68}, {151, 94}, {146, 90}, {143, 72}, {161, 0}, {113,128} },
{ {256, 12}, {218, 29}, {166, 48}, { 44, 99}, { 31, 87}, {148, 78} }, },
{ { {238, 20}, {184, 22}, {113, 27}, { 90, 22}, { 74, 9}, {192, 37} },
{ {184, 0}, {215, -1}, {141, -1}, { 97, 0}, { 49, 0}, {264, 13} },
{ {182, 51}, {138, 61}, { 95, 63}, { 54, 59}, { 64, 25}, {200, 45} },
{ {179, 75}, {156, 87}, {174, 65}, {177, 44}, {174, 0}, {164, 85} },
{ {195, 45}, {148, 65}, {105, 79}, { 95, 72}, { 87, 60}, {169, 63} }, }, }
};

=== coeff_groups ===
{ -1, 0, 1, 1, 2, 1, 1, 2,
2, 1, 1, 2, 2, 2, 1, 2,
2, 2, 2, 2, 1, 1, 2, 2,
3, 3, 4, 3, 4, 4, 4, 3,
3, 3, 3, 3, 4, 3, 3, 3,
4, 4, 4, 4, 4, 3, 3, 4,
4, 4, 3, 4, 4, 4, 4, 4,
4, 4, 5, 5, 5, 5, 5, 5, }

=== coeff_bias ===
{ 5, 7, 11, 19, 35, 67 }

=== coeff_bit_length ===
{ 0, 1, 2, 3, 4, 10 }

=== coeff_parse_table ===
{ { 159, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 145, 165, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 140, 148, 173, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 135, 140, 155, 176, 0, 0, 0, 0, 0, 0, 0 },
{ 130, 134, 141, 157, 180, 0, 0, 0, 0, 0, 0 },
{ 129, 130, 133, 140, 153, 177, 196, 230, 243, 254, 254 }, }

=== candidate_predictor_pos ===
{ { 0, -1 },
{ -1, 0 },
{ -1, -1 },
{ 1, -1 },
{ 0, -2 },
{ -2, 0 },
{ -2, -1 },
{ -1, -2 },
{ 1, -2 },
{ 2, -1 },
{ -2, -2 },
{ 2, -2 }, }

[[Category:Video Codecs]]

Indeo 5

2006-02-21T00:46:10Z

Aurel:

* FOURCCs: IV50
* Company: [[Intel]], then [[Ligos]]

== General description ==

=== Frame layout ===

The general indeo5 frames layout is composed of one global header, followed by the content of the three YUV plans.

In this document, the global header is split into 3 parts:
* [[#Frame_header|Frame header]]: describe the kind of frame (I/P/B)
* [[#GOP_header|GOP header]]: some data which is true for all the frame in this GOP (present only in the first (I) frame of the GOP)
* [[#More_header|More header]]: some more data which is true only for this single frame

Each YUV plan begin with a [[#Plan_header|Plan header]], containing values which are valid only for this single plan.

=== Encoding ===

This codec is based on the slant transform. Other used standard techniques are huffman coding and motion compensation.

=== Conventions ===

Headers are described in some tables. Each row of those tables describes a value which may be read from the frame. Those tables and rows are presented in the order of appearance in the frame.

Here are the meaning of each columns:
* '''size''': The size of this value in bits. Bits are counted in MSB to LSB order. As an example, with the byte 01110000b, reading 3 bits then 5 bits will return 011b then 10000b.
* '''name''': Kind of variable name, used to reference the value. When a value is named valueX, it generally means we don't know it's purpose. Lines named alignmentX means that bits reader need to skip bits until next byte boundary.
* '''condition''': The value is present in the frame only if this condition is matched. No condition means that the value is always present.
* '''nb times''': How many times the value is repeated.
* '''comments''': Some details about the content of the value. It may also explain that a value is repeated until a certain condition is reached.

== Headers ==

=== Frame header ===

{| border="1" cellpadding="5" style="border-collapse: collapse; border-style: dashed; border-color: #2f6fab;"
|- bgcolor="#f0f0f0" |
! size !! name !! condition !! nb times !! comments
|-
| 3 || frame_flags || || ||
* frame_flags & 0x01 => backward predictive
* frame_flags & 0x02 => forward predictive
* frame_flags & 0x04 => null frame
common values:
* 0 => I frame
* 1 => P frame
* 3 => B frame
|-
| 5 || const1 || || || = 0x1F always
|-
| 8 || id_in_gop || || || frame number in GOP (0 for I frame)
|}

null frames don't contain anything else than this header.

=== GOP header ===

This header is present in I frames only. The values in this header are valid during the whole GOP starting at this frame.

{| border="1" cellpadding="5" style="border-collapse: collapse; border-style: dashed; border-color: #2f6fab;"
|- bgcolor="#f0f0f0" |
! size !! name !! condition !! nb times !! comments
|-
| align="right" | 8 || gh_flags || || || [[#gh_flags|gh_flags]] & 0x02 => YV12 (default YVU9)
|-
| align="right" | 16 || value1 || [[#gh_flags|gh_flags]] & 0x01 || ||
|-
| align="right" | 32 || value2 || [[#gh_flags|gh_flags]] & 0x20 || ||
|-
| align="right" | 2 || value3 || [[#gh_flags|gh_flags]] & 0x40 || ||
|-
| align="right" | 3 || value4 || || ||
|-
| align="right" | 4 || res_id || || || see [[#Resolution_table|Resolution table]]
|-
| align="right" | 13 || height || rowspan="2" | [[#res_id|res_id]] == 15 || || frame height
|-
| align="right" | 13 || width || || frame width
|-
| align="right" | 6 || value5 || || rowspan="2" | 2*n (n == 1 always?) ||
|-
| align="right" | 2 || value6 || [[#value5|value5]] >> 3 || need to be = 0
|-
| align="right" | 4 || value7 || rowspan="2" | [[#gh_flags|gh_flags]] & 0x08 || ||
|-
| align="right" | 24 || value8 || ||
|-
| align="right" | ?? || alignment1 || || || align bits reader on next byte
|-
| align="right" | 24 || value9 || || ||
|-
| align="right" | 16 || value10 || [[#value9|value9]] & 0x800000 || || loops while value10 & 0x8000 (probably some kind of VLC ?)
|}

=== More header ===

This header is present in all kinds of frame except null.

{| border="1" cellpadding="5" style="border-collapse: collapse; border-style: dashed; border-color: #2f6fab;"
|- bgcolor="#f0f0f0" |
! size !! name !! condition !! nb times !! comments
|-
| align="right" | 8 || mh_flags || || ||
|-
| align="right" | 24 || frame_size || [[#mh_flags|mh_flags]] & 0x01 || || tolal size of frame data
|-
| align="right" | 16 || value11 || [[#mh_flags|mh_flags]] & 0x10 || ||
|-
| align="right" | 8 || counter1 || rowspan="2" | [[#mh_flags|mh_flags]] & 0x20 || || rowspan="2" | this whole block loops while [[#counter1|counter1]] != 0
|-
| align="right" | 8 || value12 || [[#counter1|counter1]]
|-
| align="right" | 3 || value13 || [[#mh_flags|mh_flags]] & 0x40 || ||
|-
| align="right" | 4 || counter2 || rowspan="2" | [[#value13|value13]] == 7 || ||
|-
| align="right" | 4 || value14 || [[#counter2|counter2]] ||
|-
| align="right" | 3 || value15 || || ||
|-
| align="right" | ?? || alignment2 || || || align bits reader on next byte
|}

=== Plan header ===

This header is present at the beginning of every plan.

{| border="1" cellpadding="5" style="border-collapse: collapse; border-style: dashed; border-color: #2f6fab;"
|- bgcolor="#f0f0f0" |
! size !! name !! condition !! nb times !! comments
|-
| align="right" | 8 || ph_flags || || ||
|-
| align="right" | 24 || plan_size || [[#mh_flags|mh_flags]] & 0x80 || || tolal size of plan data
|-
| align="right" | 8 || counter3 || rowspan="3" | [[#ph_flags|ph_flags]] & 0x10 || || must be < 0x3E
|-
| align="right" | 8 || value16 || rowspan="2" | [[#counter3|counter3]] ||
|-
| align="right" | 8 || value17 ||
|-
| align="right" | 3 || value18 || [[#ph_flags|ph_flags]] & 0x40 || ||
|-
| align="right" | 3 || table1_id || [[#ph_flags|ph_flags]] & 0x80 || || see [[#Table_1|Table 1]]
|-
| align="right" | 4 || counter4 || rowspan="2" | [[#table1_id|table1_id]] == 7 || || rowspan="2" | used instead of [[#Table1|Table1]]
|-
| align="right" | 4 || value19 || [[#counter4|counter4]]
|-
| align="right" | 1 || value20 || || ||
|-
| align="right" | 16 || value21 || [[#value20|value20]] || ||
|-
| align="right" | 5 || value22 || || ||
|-
| align="right" | ?? || alignment3 || || || align bits reader on next byte
|-
| align="right" | 8 || counter5 || rowspan="4" | [[#ph_flags|ph_flags]] & 0x20 || || rowspan="3" | all of this is repeated as long as [[#value23|value23]] is true
|-
| align="right" | 8 || skip1 || [[#counter5|counter5]]
|-
| align="right" | 1 || value23 ||
|-
| align="right" | ?? || alignment4 || || align bits reader on next byte
|}

== Plan data ==

This is where the actual data is, but this still need to be reverse engineered :-(

{| border="1" cellpadding="5" style="border-collapse: collapse; border-style: dashed; border-color: #2f6fab;"
|- bgcolor="#f0f0f0" |
! size !! name !! condition !! nb times !! comments
|-
| align="right" | 1 || value24 || || ||
|-
| align="right" | 1 || value25 || ! [[#value24|value24]] || || plan_data_size = value25
|-
| align="right" | 8 || value26 || [[#value25|value25]] == 1 || || plan_data_size = value26
|-
| align="right" | 24 || value27 || [[#value26|value26]] == 0xFF || || plan_data_size = value27
|-
| align="right" | ?? || ... || || || more data to analyze
|}

== Annexes ==

=== Resolution table ===

{| border="1" cellpadding="5" style="border-collapse: collapse; border-style: dashed; border-color: #2f6fab;"
! bgcolor="#f0f0f0" | res_id
| 0 || 1 || 2 || 3 || 4 || 5 || 6 || 7 || 8 || 9 || 10 || 11
|-
! bgcolor="#f0f0f0" | width
| 640 || 320 || 160 || 704 || 352 || 352 || 176 || 240 || 640 || 704 || 80 || 88
|-
! bgcolor="#f0f0f0" | height
| 480 || 240 || 120 || 224 || 240 || 288 || 144 || 180 || 240 || 240 || 60 || 72
|}

=== Table 1 ===

{| border="1" cellpadding="5" style="border-collapse: collapse; border-style: dashed; border-color: #2f6fab;"
! bgcolor="#f0f0f0" | table1_id
| 0 || 1 || 2 || 3 || 4 || 5 || 6 || default
|-
! bgcolor="#f0f0f0" | counter4
| 10 || 11 || 12 || 13 || 11 || 13 || 13 || 9
|-
! valign="top" bgcolor="#f0f0f0" | value19
| valign="top" |
{| border="0"
| 1
|-
| 2
|-
| 3
|-
| 4
|-
| 4
|-
| 7
|-
| 5
|-
| 5
|-
| 4
|-
| 1
|}
| valign="top" |
{| border="0"
| 2
|-
| 3
|-
| 4
|-
| 4
|-
| 4
|-
| 7
|-
| 5
|-
| 4
|-
| 3
|-
| 3
|-
| 2
|}
| valign="top" |
{| border="0"
| 2
|-
| 4
|-
| 5
|-
| 5
|-
| 5
|-
| 5
|-
| 6
|-
| 4
|-
| 4
|-
| 3
|-
| 1
|-
| 1
|}
| valign="top" |
{| border="0"
| 3
|-
| 3
|-
| 4
|-
| 4
|-
| 5
|-
| 6
|-
| 6
|-
| 4
|-
| 4
|-
| 3
|-
| 2
|-
| 1
|-
| 1
|}
| valign="top" |
{| border="0"
| 3
|-
| 4
|-
| 4
|-
| 5
|-
| 5
|-
| 5
|-
| 6
|-
| 5
|-
| 4
|-
| 2
|-
| 2
|}
| valign="top" |
{| border="0"
| 3
|-
| 4
|-
| 5
|-
| 5
|-
| 5
|-
| 5
|-
| 6
|-
| 4
|-
| 3
|-
| 3
|-
| 2
|-
| 1
|-
| 1
|}
| valign="top" |
{| border="0"
| 3
|-
| 4
|-
| 5
|-
| 5
|-
| 5
|-
| 6
|-
| 5
|-
| 4
|-
| 3
|-
| 3
|-
| 2
|-
| 1
|-
| 1
|}
| valign="top" |
{| border="0"
| 3
|-
| 4
|-
| 4
|-
| 5
|-
| 5
|-
| 5
|-
| 6
|-
| 5
|-
| 5
|}
|}

default is used when !([[#ph_flags|ph_flags]] & 0x80)

[[Category:Undiscovered Video Codecs]]
[[Category:Video Codecs]]

Creative ADPCM

2006-02-14T00:53:23Z

Aurel: confirm it is also used in Creative Voice

* Format tag: 0x200
* Company: [[Creative]]

This is variation of [[IMA ADPCM]], which is also used in [[Creative Voice]].

== Decoding Process ==

get new nibble from stream
sign = nibble & 8
delta = nibble & 7
diff = ((2 * delta + 1) * step) / 8
if sign > 0
newval = (oldval * 254 / 256) - diff
else
newval = (oldval * 254 / 256) + diff
step = (ct_table[delta] * step) >> 8
step = clip(step, 511, 32767)
newval = clip(newval, -32769, 32767)
output newval as 16-bit sample

And here is the table used in step modification:

const int ct_table[8] = {
0x00E6, 0x00E6, 0x00E6, 0x00E6,
0x0133, 0x0199, 0x0200, 0x0266
}

[[Category: Audio Codecs]]

Creative 8 bits ADPCM

2006-02-14T00:49:43Z

Aurel:

* Company: [[Creative]]

These ADPCM schemes are used in [[Creative_Voice|Creative VOC]] files. The only reference decoder is a hardware one: the Creative Sound Blaster (Pro). So this documentation is not based on reverse engineering. It's based on wild guessing and empirical tests but gives good enough results.

There are three different variation of this codec, which pack samples to either 4, 2.6 or 2 bits. The 2.6 scheme means that every byte is composed of 3 samples of 3 bits for the first and the second and 2 bits for the last.

The three different schemes use the same algorithm with different initial parameters.

=== Initialization ===

The first byte is a raw (not compressed) sample, used as the initial value for prdiction.

step is initialized to 0.

shift is initialized to 2 for 2 bits scheme and to 0 else.

limit is initialized to 5 for 4 bits samples, 3 for 3 bits samples and 1 for 2 bits samples.

=== Decoding ===

Every packed sample is composed of a sign bit (the most significant bit), and a value (the other bits). Let's define sign as 1 when the sign bit is 0 and -1 when the sign bit is 1. Now you can decode a packed sample with the following operation
sample = prediction + sign * (value << (step + shift))
sample have to be clamped to fit into an unsigned byte.

Then prediction is updated to the new sample value, and step is updated using this algorithm:
if (value >= limit)
step++;
else if (value == 0)
step--;
step must be clamped into the 0..3 range.

[[Category:Audio Codecs]]

Creative Voice

2006-02-14T00:48:56Z

Aurel: add links to codecs

* Extension: voc
* Company: [[Creative]]

The VOC file format was created by Creative and is generally associated with their 8-bit line of cards (Sound Blaster, Sound Blaster Pro). While initially limited to unsigned 8-bit PCM and ADPCM data, the VOC format was eventually expanded to handle 16-bit formats with the introduction of Creative's 16-bit cards, as well as a-law and u-law companded formats.

This file format is composed of a file header followed by one or more data block.
All integers are Little Endian.

== Main header ==

bytes 0-18 Identifier string containing: Creative Voice File
byte 19 0x1A (EOF). This is belived to be used to abort printing of file
bytes 20-21 Total size of this main header (usually 0x001A)
bytes 22-23 Version number, calculated as (major<<8)|minor
major is usually 0x01
minor is usually 0x0A or 0x14
bytes 24-25 Validity check. This must be equal to ~version + 0x1234

== Data blocks ==

All the different data blocks begin with a common header:

byte 0 block type
bytes 1-3 block size (NOT including this common header)

The data following this common block header depends on the block type.

=== Block type 0x00: Terminator ===

This is a special block type as it's common header don't contain any size field. It indicate the end of the file. It is not mandatory (you can reach EOF without encountering this block type).

=== Block type 0x01: Sound data ===

byte 0 frequency divisor
byte 1 codec id
bytes 2..n the audio data

The sample rate is defined as
1000000/(256 - frequency_divisor)

=== Block type 0x02: Sound data continuation ===

bytes 2..n the audio data

This block uses the same codec parameters as the previous "Sound data" block.

=== Block type 0x03: Silence ===

bytes 0-1 length of the silence - 1 (unit is sample)
byte 2 frequency divisor

The sample rate is defined as
1000000/(256 - frequency_divisor)

=== Block type 0x04: Marker ===

bytes 0-1 the mark value

This can be used by the software to synchronize the sound with an animation.

=== Block type 0x05: Text ===

bytes 0..n zero terminated string

=== Block type 0x06: Repeat start ===

bytes 0-1 repeat count - 1

The sound data following this block and up to the next Repeat end block is repeated count+1 times.
When count == 0xFFFF this means endless repetitions.

=== Block type 0x07: Repeat end ===

Empty block which terminate a repeat section.

=== Block type 0x08: Extra info ===

bytes 0-1 frequency divisor
byte 2 codec id
byte 3 channels number - 1

The sample rate is defined as
256000000/(nb_channels * (65536 - frequency_divisor))

This block must be followed by a "Sound data" block, and it supercedes its codec parameters.

=== Block type 0x09: Sound data (New format) ===

This block type is probably only valid in version 1.20 (0x0114) or greater files.

bytes 0-3 sample rate
byte 4 bits per sample
byte 5 channels number
bytes 6-7 codec_id
bytes 8-11 reserved
bytes 12..n the audio data

== Supported codec ids ==

0x00 [[PCM|8 bits unsigned PCM]]
0x01 [[Creative 8 bits ADPCM|4 bits to 8 bits Creative ADPCM]]
0x02 [[Creative 8 bits ADPCM|3 bits to 8 bits Creative ADPCM]] (AKA 2.6 bits)
0x03 [[Creative 8 bits ADPCM|2 bits to 8 bits Creative ADPCM]]
0x04 [[PCM|16 bits signed PCM]]
0x06 [[PCM#Logarithmic PCM|alaw]]
0x07 [[PCM#Logarithmic PCM|ulaw]]
0x0200 [[Creative ADPCM|4 bits to 16 bits Creative ADPCM]] (only valid in block type 0x09)

[[Category:Container Formats]]

Creative Voice

2006-02-09T00:03:49Z

Aurel:

The VOC file format was created by Creative and is generally associated to their 8bits Sound Blaster Pro sound card.
This file format is composed of a file header followed by one or more data block.
All integers are Little Endian.

== Main header ==

bytes 0-18 Identifier string containing: Creative Voice File
byte 19 0x1A (EOF). This is belived to be used to abort printing of file
bytes 20-21 Total size of this main header (usually 0x001A)
bytes 22-23 Version number, calculated as (major<<8)|minor
major is usually 0x01
minor is usually 0x0A or 0x14
bytes 24-25 Validity check. This must be equal to ~version + 0x1234

== Data blocks ==

All the different data blocks begin with a common header:

byte 0 block type
bytes 1-3 block size (NOT including this common header)

The data following this common block header depends on the block type.

=== Block type 0x00: Terminator ===

This is a special block type as it's common header don't contain any size field. It indicate the end of the file. It is not mandatory (you can reach EOF without encountering this block type).

=== Block type 0x01: Sound data ===

byte 0 frequency divisor
byte 1 codec id
bytes 2..n the audio data

The sample rate is defined as
1000000/(256 - frequency_divisor)

=== Block type 0x02: Sound data continuation ===

bytes 2..n the audio data

This block uses the same codec parameters as the previous "Sound data" block.

=== Block type 0x03: Silence ===

bytes 0-1 length of the silence - 1 (unit is sample)
byte 2 frequency divisor

The sample rate is defined as
1000000/(256 - frequency_divisor)

=== Block type 0x04: Marker ===

bytes 0-1 the mark value

This can be used by the software to synchronize the sound with an animation.

=== Block type 0x05: Text ===

bytes 0..n zero terminated string

=== Block type 0x06: Repeat start ===

bytes 0-1 repeat count - 1

The sound data following this block and up to the next Repeat end block is repeated count+1 times.
When count == 0xFFFF this means endless repetitions.

=== Block type 0x07: Repeat end ===

Empty block which terminate a repeat section.

=== Block type 0x08: Extra info ===

bytes 0-1 frequency divisor
byte 2 codec id
byte 3 channels number - 1

The sample rate is defined as
256000000/(nb_channels * (65536 - frequency_divisor))

This block must be followed by a "Sound data" block, and it super-seeds its codec parameters.

=== Block type 0x09: Sound data (New format) ===

This block type is probably only valid in version 1.20 (0x0114) or greater files.

bytes 0-3 sample rate
byte 4 bits per sample
byte 5 channels number
bytes 6-7 codec_id
bytes 8-11 reserved
bytes 12..n the audio data

== Supported codec ids ==

0x00 8 bits unsigned PCM
0x01 4 bits to 8 bits Creative ADPCM
0x02 3 bits to 8 bits Creative ADPCM (AKA 2.6 bits)
0x03 2 bits to 8 bits Creative ADPCM
0x04 16 bits signed PCM
0x06 alaw
0x07 ulaw
0x0200 4 bits to 16 bits Creative ADPCM (only valid in block type 0x09)