初始化仓库

.gitignore

@@ -0,0 +1 @@
+/cmake-build*

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/.name

@@ -0,0 +1 @@
+DXGI

.idea/_DXGI.iml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module classpath="CMake" type="CPP_MODULE" version="4" />

.idea/cmake.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="CMakeSharedSettings">
+    <configurations>
+      <configuration PROFILE_NAME="Release-Visual Studio" ENABLED="true" CONFIG_NAME="Release" TOOLCHAIN_NAME="Visual Studio" GENERATION_OPTIONS="-G Ninja" />
+      <configuration PROFILE_NAME="Debug-Visual Studio" ENABLED="true" CONFIG_NAME="Debug" TOOLCHAIN_NAME="Visual Studio" GENERATION_OPTIONS="-G Ninja" />
+    </configurations>
+  </component>
+</project>

.idea/misc.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="CMakePythonSetting">
+    <option name="pythonIntegrationState" value="YES" />
+  </component>
+  <component name="CMakeWorkspace" PROJECT_DIR="$PROJECT_DIR$" />
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/_DXGI.iml" filepath="$PROJECT_DIR$/.idea/_DXGI.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

CMakeLists.txt

@@ -0,0 +1,43 @@
+cmake_minimum_required(VERSION 3.20)
+
+set(PROJECT_NAME DXGI)
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_BUILD_TYPE Ninja)
+#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3")
+project(${PROJECT_NAME})
+
+include_directories(ffmpeg-n4.3.2-win64-gpl-shared-4.3\\include)
+link_directories(ffmpeg-n4.3.2-win64-gpl-shared-4.3\\lib)
+
+add_executable(
+        ${PROJECT_NAME}
+        WIN32
+        DesktopDuplication.cpp
+        DisplayManager.cpp
+        DuplicationManager.cpp
+        ffvideo.cpp
+        OutputManager.cpp
+        ThreadManager.cpp
+)
+
+target_link_libraries(
+        ${PROJECT_NAME}
+        avformat
+        avcodec
+        avdevice
+        avfilter
+        avutil
+        postproc
+        swresample
+        swscale
+        d3d11
+)
+
+# 复制dll
+set(DLL_SOURCE_DIR ${CMAKE_SOURCE_DIR}/ffmpeg-n4.3.2-win64-gpl-shared-4.3/bin)
+set(DLL_DEST_DIR $<TARGET_FILE_DIR:${PROJECT_NAME}>)
+file(GLOB DLL_FILES "${DLL_SOURCE_DIR}/*.dll")
+add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different
+        ${DLL_FILES} ${DLL_DEST_DIR}
+)

CommonTypes.h

@@ -0,0 +1,115 @@
+// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
+// PARTICULAR PURPOSE.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved
+
+#ifndef _COMMONTYPES_H_
+#define _COMMONTYPES_H_
+
+#include <windows.h>
+#include <d3d11.h>
+#include <dxgi1_2.h>
+#include <sal.h>
+#include <new>
+#include <warning.h>
+#include <DirectXMath.h>
+
+#include "PixelShader.h"
+#include "VertexShader.h"
+
+#define NUMVERTICES 6
+#define BPP         4
+
+#define OCCLUSION_STATUS_MSG WM_USER
+
+extern HRESULT SystemTransitionsExpectedErrors[];
+extern HRESULT CreateDuplicationExpectedErrors[];
+extern HRESULT FrameInfoExpectedErrors[];
+extern HRESULT AcquireFrameExpectedError[];
+extern HRESULT EnumOutputsExpectedErrors[];
+
+typedef _Return_type_success_(return == DUPL_RETURN_SUCCESS) enum
+{
+    DUPL_RETURN_SUCCESS             = 0,
+    DUPL_RETURN_ERROR_EXPECTED      = 1,
+    DUPL_RETURN_ERROR_UNEXPECTED    = 2
+}DUPL_RETURN;
+
+_Post_satisfies_(return != DUPL_RETURN_SUCCESS)
+DUPL_RETURN ProcessFailure(_In_opt_ ID3D11Device* Device, _In_ LPCWSTR Str, _In_ LPCWSTR Title, HRESULT hr, _In_opt_z_ HRESULT* ExpectedErrors = nullptr);
+
+void DisplayMsg(_In_ LPCWSTR Str, _In_ LPCWSTR Title, HRESULT hr);
+
+//
+// Holds info about the pointer/cursor
+//
+typedef struct _PTR_INFO
+{
+    _Field_size_bytes_(BufferSize) BYTE* PtrShapeBuffer;
+    DXGI_OUTDUPL_POINTER_SHAPE_INFO ShapeInfo;
+    POINT Position;
+    bool Visible;
+    UINT BufferSize;
+    UINT WhoUpdatedPositionLast;
+    LARGE_INTEGER LastTimeStamp;
+} PTR_INFO;
+
+//
+// Structure that holds D3D resources not directly tied to any one thread
+//
+typedef struct _DX_RESOURCES
+{
+    ID3D11Device* Device;
+    ID3D11DeviceContext* Context;
+    ID3D11VertexShader* VertexShader;
+    ID3D11PixelShader* PixelShader;
+    ID3D11InputLayout* InputLayout;
+    ID3D11SamplerState* SamplerLinear;
+} DX_RESOURCES;
+
+//
+// Structure to pass to a new thread
+//
+typedef struct _THREAD_DATA
+{
+    // Used to indicate abnormal error condition
+    HANDLE UnexpectedErrorEvent;
+
+    // Used to indicate a transition event occurred e.g. PnpStop, PnpStart, mode change, TDR, desktop switch and the application needs to recreate the duplication interface
+    HANDLE ExpectedErrorEvent;
+
+    // Used by WinProc to signal to threads to exit
+    HANDLE TerminateThreadsEvent;
+
+    HANDLE TexSharedHandle;
+    UINT Output;
+    INT OffsetX;
+    INT OffsetY;
+    PTR_INFO* PtrInfo;
+    DX_RESOURCES DxRes;
+} THREAD_DATA;
+
+//
+// FRAME_DATA holds information about an acquired frame
+//
+typedef struct _FRAME_DATA
+{
+    ID3D11Texture2D* Frame;
+    DXGI_OUTDUPL_FRAME_INFO FrameInfo;
+    _Field_size_bytes_((MoveCount * sizeof(DXGI_OUTDUPL_MOVE_RECT)) + (DirtyCount * sizeof(RECT))) BYTE* MetaData;
+    UINT DirtyCount;
+    UINT MoveCount;
+} FRAME_DATA;
+
+//
+// A vertex with a position and texture coordinate
+//
+typedef struct _VERTEX
+{
+    DirectX::XMFLOAT3 Pos;
+    DirectX::XMFLOAT2 TexCoord;
+} VERTEX;
+
+#endif

DesktopDuplication.cpp

@@ -0,0 +1,644 @@
+// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
+// PARTICULAR PURPOSE.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved
+
+#include <limits.h>
+
+#include "DisplayManager.h"
+#include "DuplicationManager.h"
+#include "OutputManager.h"
+#include "ThreadManager.h"
+
+//#include <D3Dx11tex.h>
+#include <algorithm>
+#include <d3d11_1.h>
+#include <memory>
+
+//
+// Globals
+//
+OUTPUTMANAGER OutMgr;
+
+// Below are lists of errors expect from Dxgi API calls when a transition event like mode change, PnpStop, PnpStart
+// desktop switch, TDR or session disconnect/reconnect. In all these cases we want the application to clean up the threads that process
+// the desktop updates and attempt to recreate them.
+// If we get an error that is not on the appropriate list then we exit the application
+
+// These are the errors we expect from general Dxgi API due to a transition
+HRESULT SystemTransitionsExpectedErrors[] = {
+												DXGI_ERROR_DEVICE_REMOVED,
+												DXGI_ERROR_ACCESS_LOST,
+												static_cast<HRESULT>(WAIT_ABANDONED),
+												S_OK                                    // Terminate list with zero valued HRESULT
+};
+
+// These are the errors we expect from IDXGIOutput1::DuplicateOutput due to a transition
+HRESULT CreateDuplicationExpectedErrors[] = {
+												DXGI_ERROR_DEVICE_REMOVED,
+												static_cast<HRESULT>(E_ACCESSDENIED),
+												DXGI_ERROR_UNSUPPORTED,
+												DXGI_ERROR_SESSION_DISCONNECTED,
+												S_OK                                    // Terminate list with zero valued HRESULT
+};
+
+// These are the errors we expect from IDXGIOutputDuplication methods due to a transition
+HRESULT FrameInfoExpectedErrors[] = {
+										DXGI_ERROR_DEVICE_REMOVED,
+										DXGI_ERROR_ACCESS_LOST,
+										S_OK                                    // Terminate list with zero valued HRESULT
+};
+
+// These are the errors we expect from IDXGIAdapter::EnumOutputs methods due to outputs becoming stale during a transition
+HRESULT EnumOutputsExpectedErrors[] = {
+										  DXGI_ERROR_NOT_FOUND,
+										  S_OK                                    // Terminate list with zero valued HRESULT
+};
+
+
+//
+// Forward Declarations
+//
+DWORD WINAPI DDProc(_In_ void* Param);
+LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
+bool ProcessCmdline(_Out_ INT* Output);
+void ShowHelp();
+
+//
+// Class for progressive waits
+//
+typedef struct {
+	UINT    WaitTime;
+	UINT    WaitCount;
+}WAIT_BAND;
+
+#define WAIT_BAND_COUNT 3
+#define WAIT_BAND_STOP 0
+
+class DYNAMIC_WAIT {
+public:
+	DYNAMIC_WAIT();
+	~DYNAMIC_WAIT();
+
+	void Wait();
+
+private:
+
+	static const WAIT_BAND   m_WaitBands[WAIT_BAND_COUNT];
+
+	// Period in seconds that a new wait call is considered part of the same wait sequence
+	static const UINT       m_WaitSequenceTimeInSeconds = 2;
+
+	UINT                    m_CurrentWaitBandIdx;
+	UINT                    m_WaitCountInCurrentBand;
+	LARGE_INTEGER           m_QPCFrequency;
+	LARGE_INTEGER           m_LastWakeUpTime;
+	BOOL                    m_QPCValid;
+};
+const WAIT_BAND DYNAMIC_WAIT::m_WaitBands[WAIT_BAND_COUNT] = {
+																 {250, 20},
+																 {2000, 60},
+																 {5000, WAIT_BAND_STOP}   // Never move past this band
+};
+
+DYNAMIC_WAIT::DYNAMIC_WAIT() : m_CurrentWaitBandIdx(0), m_WaitCountInCurrentBand(0) {
+	m_QPCValid = QueryPerformanceFrequency(&m_QPCFrequency);
+	m_LastWakeUpTime.QuadPart = 0L;
+}
+
+DYNAMIC_WAIT::~DYNAMIC_WAIT() {
+}
+
+void DYNAMIC_WAIT::Wait() {
+	LARGE_INTEGER CurrentQPC = { 0 };
+
+	// Is this wait being called with the period that we consider it to be part of the same wait sequence
+	QueryPerformanceCounter(&CurrentQPC);
+	if (m_QPCValid && (CurrentQPC.QuadPart <= (m_LastWakeUpTime.QuadPart + (m_QPCFrequency.QuadPart * m_WaitSequenceTimeInSeconds)))) {
+		// We are still in the same wait sequence, lets check if we should move to the next band
+		if ((m_WaitBands[m_CurrentWaitBandIdx].WaitCount != WAIT_BAND_STOP) && (m_WaitCountInCurrentBand > m_WaitBands[m_CurrentWaitBandIdx].WaitCount)) {
+			m_CurrentWaitBandIdx++;
+			m_WaitCountInCurrentBand = 0;
+		}
+	}
+	else {
+		// Either we could not get the current time or we are starting a new wait sequence
+		m_WaitCountInCurrentBand = 0;
+		m_CurrentWaitBandIdx = 0;
+	}
+
+	// Sleep for the required period of time
+	Sleep(m_WaitBands[m_CurrentWaitBandIdx].WaitTime);
+
+	// Record the time we woke up so we can detect wait sequences
+	QueryPerformanceCounter(&m_LastWakeUpTime);
+	m_WaitCountInCurrentBand++;
+}
+
+
+//
+// Program entry point
+//
+int WINAPI WinMain(_In_ HINSTANCE hInstance, _In_opt_ HINSTANCE hPrevInstance, _In_ LPSTR lpCmdLine, _In_ INT nCmdShow) {
+	UNREFERENCED_PARAMETER(hPrevInstance);
+	UNREFERENCED_PARAMETER(lpCmdLine);
+
+	INT SingleOutput;
+
+	// Synchronization
+	HANDLE UnexpectedErrorEvent = nullptr;
+	HANDLE ExpectedErrorEvent = nullptr;
+	HANDLE TerminateThreadsEvent = nullptr;
+
+	// Window
+	HWND WindowHandle = nullptr;
+
+	bool CmdResult = ProcessCmdline(&SingleOutput);
+	if (!CmdResult) {
+		ShowHelp();
+		return 0;
+	}
+
+	// Event used by the threads to signal an unexpected error and we want to quit the app
+	UnexpectedErrorEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr);
+	if (!UnexpectedErrorEvent) {
+		ProcessFailure(nullptr, L"UnexpectedErrorEvent creation failed", L"Error", E_UNEXPECTED);
+		return 0;
+	}
+
+	// Event for when a thread encounters an expected error
+	ExpectedErrorEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr);
+	if (!ExpectedErrorEvent) {
+		ProcessFailure(nullptr, L"ExpectedErrorEvent creation failed", L"Error", E_UNEXPECTED);
+		return 0;
+	}
+
+	// Event to tell spawned threads to quit
+	TerminateThreadsEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr);
+	if (!TerminateThreadsEvent) {
+		ProcessFailure(nullptr, L"TerminateThreadsEvent creation failed", L"Error", E_UNEXPECTED);
+		return 0;
+	}
+
+	// Load simple cursor
+	HCURSOR Cursor = nullptr;
+	Cursor = LoadCursor(nullptr, IDC_ARROW);
+	if (!Cursor) {
+		ProcessFailure(nullptr, L"Cursor load failed", L"Error", E_UNEXPECTED);
+		return 0;
+	}
+
+	// Register class
+	WNDCLASSEXW Wc;
+	Wc.cbSize = sizeof(WNDCLASSEXW);
+	Wc.style = CS_HREDRAW | CS_VREDRAW;
+	Wc.lpfnWndProc = WndProc;
+	Wc.cbClsExtra = 0;
+	Wc.cbWndExtra = 0;
+	Wc.hInstance = hInstance;
+	Wc.hIcon = nullptr;
+	Wc.hCursor = Cursor;
+	Wc.hbrBackground = nullptr;
+	Wc.lpszMenuName = nullptr;
+	Wc.lpszClassName = L"ddasample";
+	Wc.hIconSm = nullptr;
+	if (!RegisterClassExW(&Wc)) {
+		ProcessFailure(nullptr, L"Window class registration failed", L"Error", E_UNEXPECTED);
+		return 0;
+	}
+
+	// Create window
+	RECT WindowRect = { 0, 0, 960, 540 };
+	AdjustWindowRect(&WindowRect, WS_OVERLAPPEDWINDOW, FALSE);
+	WindowHandle = CreateWindowW(L"ddasample", L"DXGI desktop duplication sample",
+		WS_OVERLAPPEDWINDOW,
+		0, 0,
+		WindowRect.right - WindowRect.left, WindowRect.bottom - WindowRect.top,
+		nullptr, nullptr, hInstance, nullptr);
+	if (!WindowHandle) {
+		ProcessFailure(nullptr, L"Window creation failed", L"Error", E_FAIL);
+		return 0;
+	}
+
+	DestroyCursor(Cursor);
+
+	ShowWindow(WindowHandle, nCmdShow);
+	UpdateWindow(WindowHandle);
+
+	THREADMANAGER ThreadMgr;
+	RECT DeskBounds;
+	UINT OutputCount;
+
+	// Message loop (attempts to update screen when no other messages to process)
+	MSG msg = { 0 };
+	bool FirstTime = true;
+	bool Occluded = true;
+	DYNAMIC_WAIT DynamicWait;
+
+	while (WM_QUIT != msg.message) {
+		DUPL_RETURN Ret = DUPL_RETURN_SUCCESS;
+		if (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE)) {
+			if (msg.message == OCCLUSION_STATUS_MSG) {
+				// Present may not be occluded now so try again
+				Occluded = false;
+			}
+			else {
+				// Process window messages
+				TranslateMessage(&msg);
+				DispatchMessage(&msg);
+			}
+		}
+		else if (WaitForSingleObjectEx(UnexpectedErrorEvent, 0, FALSE) == WAIT_OBJECT_0) {
+			// Unexpected error occurred so exit the application
+			break;
+		}
+		else if (FirstTime || WaitForSingleObjectEx(ExpectedErrorEvent, 0, FALSE) == WAIT_OBJECT_0) {
+			if (!FirstTime) {
+				// Terminate other threads
+				SetEvent(TerminateThreadsEvent);
+				ThreadMgr.WaitForThreadTermination();
+				ResetEvent(TerminateThreadsEvent);
+				ResetEvent(ExpectedErrorEvent);
+
+				// Clean up
+				ThreadMgr.Clean();
+				OutMgr.CleanRefs();
+
+				// As we have encountered an error due to a system transition we wait before trying again, using this dynamic wait
+				// the wait periods will get progressively long to avoid wasting too much system resource if this state lasts a long time
+				DynamicWait.Wait();
+			}
+			else {
+				// First time through the loop so nothing to clean up
+				FirstTime = false;
+			}
+
+			// Re-initialize
+			Ret = OutMgr.InitOutput(WindowHandle, SingleOutput, &OutputCount, &DeskBounds);
+			if (Ret == DUPL_RETURN_SUCCESS) {
+				HANDLE SharedHandle = OutMgr.GetSharedHandle();
+				if (SharedHandle) {
+					Ret = ThreadMgr.Initialize(SingleOutput, OutputCount, UnexpectedErrorEvent, ExpectedErrorEvent, TerminateThreadsEvent, SharedHandle, &DeskBounds);
+				}
+				else {
+					DisplayMsg(L"Failed to get handle of shared surface", L"Error", S_OK);
+					Ret = DUPL_RETURN_ERROR_UNEXPECTED;
+				}
+			}
+
+			// We start off in occluded state and we should immediate get a occlusion status window message
+			Occluded = true;
+		}
+		else {
+			// Nothing else to do, so try to present to write out to window if not occluded
+			if (!Occluded) {
+				Ret = OutMgr.UpdateApplicationWindow(ThreadMgr.GetPointerInfo(), &Occluded);
+			}
+		}
+
+		// Check if for errors
+		if (Ret != DUPL_RETURN_SUCCESS) {
+			if (Ret == DUPL_RETURN_ERROR_EXPECTED) {
+				// Some type of system transition is occurring so retry
+				SetEvent(ExpectedErrorEvent);
+			}
+			else {
+				// Unexpected error so exit
+				break;
+			}
+		}
+	}
+
+	// Make sure all other threads have exited
+	if (SetEvent(TerminateThreadsEvent)) {
+		ThreadMgr.WaitForThreadTermination();
+	}
+
+	// Clean up
+	CloseHandle(UnexpectedErrorEvent);
+	CloseHandle(ExpectedErrorEvent);
+	CloseHandle(TerminateThreadsEvent);
+
+	if (msg.message == WM_QUIT) {
+		// For a WM_QUIT message we should return the wParam value
+		return static_cast<INT>(msg.wParam);
+	}
+
+	return 0;
+}
+
+//
+// Shows help
+//
+void ShowHelp() {
+	DisplayMsg(L"The following optional parameters can be used -\n  /output [all | n]\t\tto duplicate all outputs or the nth output\n  /?\t\t\tto display this help section",
+		L"Proper usage", S_OK);
+}
+
+//
+// Process command line parameters
+//
+bool ProcessCmdline(_Out_ INT* Output) {
+	*Output = -1;
+
+	// __argv and __argc are global vars set by system
+	for (UINT i = 1; i < static_cast<UINT>(__argc); ++i) {
+		if ((strcmp(__argv[i], "-output") == 0) ||
+			(strcmp(__argv[i], "/output") == 0)) {
+			if (++i >= static_cast<UINT>(__argc)) {
+				return false;
+			}
+
+			if (strcmp(__argv[i], "all") == 0) {
+				*Output = -1;
+			}
+			else {
+				*Output = atoi(__argv[i]);
+			}
+			continue;
+		}
+		else {
+			return false;
+		}
+	}
+	return true;
+}
+
+//
+// Window message processor
+//
+LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {
+	switch (message) {
+	case WM_DESTROY:
+	{
+		PostQuitMessage(0);
+		break;
+	}
+	case WM_SIZE:
+	{
+		// Tell output manager that window size has changed
+		OutMgr.WindowResize();
+		break;
+	}
+	default:
+		return DefWindowProc(hWnd, message, wParam, lParam);
+	}
+
+	return 0;
+}
+
+
+
+
+//
+// Entry point for new duplication threads
+//
+DWORD WINAPI DDProc(_In_ void* Param) {
+	// Classes
+	DISPLAYMANAGER DispMgr;
+	DUPLICATIONMANAGER DuplMgr;
+
+	// D3D objects
+	ID3D11Texture2D* SharedSurf = nullptr;
+	IDXGIKeyedMutex* KeyMutex = nullptr;
+
+	// Data passed in from thread creation
+	THREAD_DATA* TData = reinterpret_cast<THREAD_DATA*>(Param);
+
+	// Get desktop
+	DUPL_RETURN Ret;
+	HDESK CurrentDesktop = nullptr;
+	CurrentDesktop = OpenInputDesktop(0, FALSE, GENERIC_ALL);
+	if (!CurrentDesktop) {
+		// We do not have access to the desktop so request a retry
+		SetEvent(TData->ExpectedErrorEvent);
+		Ret = DUPL_RETURN_ERROR_EXPECTED;
+		goto Exit;
+	}
+
+	// Attach desktop to this thread
+    bool DesktopAttached;
+    DesktopAttached = SetThreadDesktop(CurrentDesktop) != 0;
+	CloseDesktop(CurrentDesktop);
+	CurrentDesktop = nullptr;
+	if (!DesktopAttached) {
+		// We do not have access to the desktop so request a retry
+		Ret = DUPL_RETURN_ERROR_EXPECTED;
+		goto Exit;
+	}
+
+	// New display manager
+	DispMgr.InitD3D(&TData->DxRes);
+
+	// Obtain handle to sync shared Surface
+    HRESULT hr;
+    hr = TData->DxRes.Device->OpenSharedResource(TData->TexSharedHandle, __uuidof(ID3D11Texture2D),
+                                                 reinterpret_cast<void **>(&SharedSurf));
+	if (FAILED(hr)) {
+		Ret = ProcessFailure(TData->DxRes.Device, L"Opening shared texture failed", L"Error", hr, SystemTransitionsExpectedErrors);
+		goto Exit;
+	}
+
+	hr = SharedSurf->QueryInterface(__uuidof(IDXGIKeyedMutex), reinterpret_cast<void**>(&KeyMutex));
+	if (FAILED(hr)) {
+		Ret = ProcessFailure(nullptr, L"Failed to get keyed mutex interface in spawned thread", L"Error", hr);
+		goto Exit;
+	}
+
+	// Make duplication manager
+	Ret = DuplMgr.InitDupl(TData->DxRes.Device, TData->Output);
+	if (Ret != DUPL_RETURN_SUCCESS) {
+		goto Exit;
+	}
+
+	// Get output description
+	DXGI_OUTPUT_DESC DesktopDesc;
+	RtlZeroMemory(&DesktopDesc, sizeof(DXGI_OUTPUT_DESC));
+	DuplMgr.GetOutputDesc(&DesktopDesc);
+
+	// Main duplication loop
+    bool WaitToProcessCurrentFrame;
+    WaitToProcessCurrentFrame = false;
+	FRAME_DATA CurrentData;
+
+	while ((WaitForSingleObjectEx(TData->TerminateThreadsEvent, 0, FALSE) == WAIT_TIMEOUT)) {
+		if (!WaitToProcessCurrentFrame) {
+			// Get new frame from desktop duplication
+			bool TimeOut;
+			Ret = DuplMgr.GetFrame(&CurrentData, &TimeOut);
+			if (Ret != DUPL_RETURN_SUCCESS) {
+				// An error occurred getting the next frame drop out of loop which
+				// will check if it was expected or not
+				break;
+			}
+
+			// Check for timeout
+			if (TimeOut) {
+				// No new frame at the moment
+				continue;
+			}
+		}
+
+		static int tim = 0;
+
+		if (tim == 0) {
+			tim = 1;
+
+			ID3D11Texture2D* t2d = CurrentData.Frame;
+			ID3D11DeviceContext* ctx;
+			DuplMgr.m_Device->GetImmediateContext(&ctx);
+			//extractImageData(DuplMgr.m_DeskDupl, ctx, t2d);
+		}
+
+		// We have a new frame so try and process it
+		// Try to acquire keyed mutex in order to access shared surface
+		hr = KeyMutex->AcquireSync(0, 1000);
+		if (hr == static_cast<HRESULT>(WAIT_TIMEOUT)) {
+			// Can't use shared surface right now, try again later
+			WaitToProcessCurrentFrame = true;
+			continue;
+		}
+		else if (FAILED(hr)) {
+			// Generic unknown failure
+			Ret = ProcessFailure(TData->DxRes.Device, L"Unexpected error acquiring KeyMutex", L"Error", hr, SystemTransitionsExpectedErrors);
+			DuplMgr.DoneWithFrame();
+			break;
+		}
+
+		// We can now process the current frame
+		WaitToProcessCurrentFrame = false;
+
+		// Get mouse info
+		Ret = DuplMgr.GetMouse(TData->PtrInfo, &(CurrentData.FrameInfo), TData->OffsetX, TData->OffsetY);
+		if (Ret != DUPL_RETURN_SUCCESS) {
+			DuplMgr.DoneWithFrame();
+			KeyMutex->ReleaseSync(1);
+			break;
+		}
+
+		// Process new frame
+		Ret = DispMgr.ProcessFrame(&CurrentData, SharedSurf, TData->OffsetX, TData->OffsetY, &DesktopDesc);
+		if (Ret != DUPL_RETURN_SUCCESS) {
+			DuplMgr.DoneWithFrame();
+			KeyMutex->ReleaseSync(1);
+			break;
+		}
+
+		// Release acquired keyed mutex
+		hr = KeyMutex->ReleaseSync(1);
+		if (FAILED(hr)) {
+			Ret = ProcessFailure(TData->DxRes.Device, L"Unexpected error releasing the keyed mutex", L"Error", hr, SystemTransitionsExpectedErrors);
+			DuplMgr.DoneWithFrame();
+			break;
+		}
+
+		// Release frame back to desktop duplication
+		Ret = DuplMgr.DoneWithFrame();
+		if (Ret != DUPL_RETURN_SUCCESS) {
+			break;
+		}
+	}
+
+Exit:
+	if (Ret != DUPL_RETURN_SUCCESS) {
+		if (Ret == DUPL_RETURN_ERROR_EXPECTED) {
+			// The system is in a transition state so request the duplication be restarted
+			SetEvent(TData->ExpectedErrorEvent);
+		}
+		else {
+			// Unexpected error so exit the application
+			SetEvent(TData->UnexpectedErrorEvent);
+		}
+	}
+
+	if (SharedSurf) {
+		SharedSurf->Release();
+		SharedSurf = nullptr;
+	}
+
+	if (KeyMutex) {
+		KeyMutex->Release();
+		KeyMutex = nullptr;
+	}
+
+	return 0;
+}
+
+_Post_satisfies_(return != DUPL_RETURN_SUCCESS)
+DUPL_RETURN ProcessFailure(_In_opt_ ID3D11Device * Device, _In_ LPCWSTR Str, _In_ LPCWSTR Title, HRESULT hr, _In_opt_z_ HRESULT * ExpectedErrors) {
+	HRESULT TranslatedHr;
+
+	// On an error check if the DX device is lost
+	if (Device) {
+		HRESULT DeviceRemovedReason = Device->GetDeviceRemovedReason();
+
+		switch (DeviceRemovedReason) {
+		case DXGI_ERROR_DEVICE_REMOVED:
+		case DXGI_ERROR_DEVICE_RESET:
+			case static_cast<HRESULT>(E_OUTOFMEMORY) :
+			{
+				// Our device has been stopped due to an external event on the GPU so map them all to
+				// device removed and continue processing the condition
+				TranslatedHr = DXGI_ERROR_DEVICE_REMOVED;
+				break;
+			}
+
+			case S_OK:
+			{
+				// Device is not removed so use original error
+				TranslatedHr = hr;
+				break;
+			}
+
+			default:
+			{
+				// Device is removed but not a error we want to remap
+				TranslatedHr = DeviceRemovedReason;
+			}
+		}
+	}
+	else {
+		TranslatedHr = hr;
+	}
+
+	// Check if this error was expected or not
+	if (ExpectedErrors) {
+		HRESULT* CurrentResult = ExpectedErrors;
+
+		while (*CurrentResult != S_OK) {
+			if (*(CurrentResult++) == TranslatedHr) {
+				return DUPL_RETURN_ERROR_EXPECTED;
+			}
+		}
+	}
+
+	// Error was not expected so display the message box
+	DisplayMsg(Str, Title, TranslatedHr);
+
+	return DUPL_RETURN_ERROR_UNEXPECTED;
+}
+
+//
+// Displays a message
+//
+void DisplayMsg(_In_ LPCWSTR Str, _In_ LPCWSTR Title, HRESULT hr) {
+	if (SUCCEEDED(hr)) {
+		MessageBoxW(nullptr, Str, Title, MB_OK);
+		return;
+	}
+
+	const UINT StringLen = (UINT)(wcslen(Str) + sizeof(" with HRESULT 0x########."));
+	wchar_t* OutStr = new wchar_t[StringLen];
+	if (!OutStr) {
+		return;
+	}
+
+	INT LenWritten = swprintf_s(OutStr, StringLen, L"%s with 0x%X.", Str, hr);
+	if (LenWritten != -1) {
+		MessageBoxW(nullptr, OutStr, Title, MB_OK);
+	}
+
+	delete[] OutStr;
+}

DisplayManager.cpp

@@ -0,0 +1,478 @@
+// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
+// PARTICULAR PURPOSE.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved
+
+#include "DisplayManager.h"
+using namespace DirectX;
+
+//
+// Constructor NULLs out vars
+//
+DISPLAYMANAGER::DISPLAYMANAGER() : m_Device(nullptr),
+                                   m_DeviceContext(nullptr),
+                                   m_MoveSurf(nullptr),
+                                   m_VertexShader(nullptr),
+                                   m_PixelShader(nullptr),
+                                   m_InputLayout(nullptr),
+                                   m_RTV(nullptr),
+                                   m_SamplerLinear(nullptr),
+                                   m_DirtyVertexBufferAlloc(nullptr),
+                                   m_DirtyVertexBufferAllocSize(0)
+{
+}
+
+//
+// Destructor calls CleanRefs to destroy everything
+//
+DISPLAYMANAGER::~DISPLAYMANAGER()
+{
+    CleanRefs();
+
+    if (m_DirtyVertexBufferAlloc)
+    {
+        delete [] m_DirtyVertexBufferAlloc;
+        m_DirtyVertexBufferAlloc = nullptr;
+    }
+}
+
+//
+// Initialize D3D variables
+//
+void DISPLAYMANAGER::InitD3D(DX_RESOURCES* Data)
+{
+    m_Device = Data->Device;
+    m_DeviceContext = Data->Context;
+    m_VertexShader = Data->VertexShader;
+    m_PixelShader = Data->PixelShader;
+    m_InputLayout = Data->InputLayout;
+    m_SamplerLinear = Data->SamplerLinear;
+
+    m_Device->AddRef();
+    m_DeviceContext->AddRef();
+    m_VertexShader->AddRef();
+    m_PixelShader->AddRef();
+    m_InputLayout->AddRef();
+    m_SamplerLinear->AddRef();
+}
+
+//
+// Process a given frame and its metadata
+//
+DUPL_RETURN DISPLAYMANAGER::ProcessFrame(_In_ FRAME_DATA* Data, _Inout_ ID3D11Texture2D* SharedSurf, INT OffsetX, INT OffsetY, _In_ DXGI_OUTPUT_DESC* DeskDesc)
+{
+    DUPL_RETURN Ret = DUPL_RETURN_SUCCESS;
+
+    // Process dirties and moves
+    if (Data->FrameInfo.TotalMetadataBufferSize)
+    {
+        D3D11_TEXTURE2D_DESC Desc;
+        Data->Frame->GetDesc(&Desc);
+
+        if (Data->MoveCount)
+        {
+            Ret = CopyMove(SharedSurf, reinterpret_cast<DXGI_OUTDUPL_MOVE_RECT*>(Data->MetaData), Data->MoveCount, OffsetX, OffsetY, DeskDesc, Desc.Width, Desc.Height);
+            if (Ret != DUPL_RETURN_SUCCESS)
+            {
+                return Ret;
+            }
+        }
+
+        if (Data->DirtyCount)
+        {
+            Ret = CopyDirty(Data->Frame, SharedSurf, reinterpret_cast<RECT*>(Data->MetaData + (Data->MoveCount * sizeof(DXGI_OUTDUPL_MOVE_RECT))), Data->DirtyCount, OffsetX, OffsetY, DeskDesc);
+        }
+    }
+
+    return Ret;
+}
+
+//
+// Returns D3D device being used
+//
+ID3D11Device* DISPLAYMANAGER::GetDevice()
+{
+    return m_Device;
+}
+
+//
+// Set appropriate source and destination rects for move rects
+//
+void DISPLAYMANAGER::SetMoveRect(_Out_ RECT* SrcRect, _Out_ RECT* DestRect, _In_ DXGI_OUTPUT_DESC* DeskDesc, _In_ DXGI_OUTDUPL_MOVE_RECT* MoveRect, INT TexWidth, INT TexHeight)
+{
+    switch (DeskDesc->Rotation)
+    {
+        case DXGI_MODE_ROTATION_UNSPECIFIED:
+        case DXGI_MODE_ROTATION_IDENTITY:
+        {
+            SrcRect->left = MoveRect->SourcePoint.x;
+            SrcRect->top = MoveRect->SourcePoint.y;
+            SrcRect->right = MoveRect->SourcePoint.x + MoveRect->DestinationRect.right - MoveRect->DestinationRect.left;
+            SrcRect->bottom = MoveRect->SourcePoint.y + MoveRect->DestinationRect.bottom - MoveRect->DestinationRect.top;
+
+            *DestRect = MoveRect->DestinationRect;
+            break;
+        }
+        case DXGI_MODE_ROTATION_ROTATE90:
+        {
+            SrcRect->left = TexHeight - (MoveRect->SourcePoint.y + MoveRect->DestinationRect.bottom - MoveRect->DestinationRect.top);
+            SrcRect->top = MoveRect->SourcePoint.x;
+            SrcRect->right = TexHeight - MoveRect->SourcePoint.y;
+            SrcRect->bottom = MoveRect->SourcePoint.x + MoveRect->DestinationRect.right - MoveRect->DestinationRect.left;
+
+            DestRect->left = TexHeight - MoveRect->DestinationRect.bottom;
+            DestRect->top = MoveRect->DestinationRect.left;
+            DestRect->right = TexHeight - MoveRect->DestinationRect.top;
+            DestRect->bottom = MoveRect->DestinationRect.right;
+            break;
+        }
+        case DXGI_MODE_ROTATION_ROTATE180:
+        {
+            SrcRect->left = TexWidth - (MoveRect->SourcePoint.x + MoveRect->DestinationRect.right - MoveRect->DestinationRect.left);
+            SrcRect->top = TexHeight - (MoveRect->SourcePoint.y + MoveRect->DestinationRect.bottom - MoveRect->DestinationRect.top);
+            SrcRect->right = TexWidth - MoveRect->SourcePoint.x;
+            SrcRect->bottom = TexHeight - MoveRect->SourcePoint.y;
+
+            DestRect->left = TexWidth - MoveRect->DestinationRect.right;
+            DestRect->top = TexHeight - MoveRect->DestinationRect.bottom;
+            DestRect->right = TexWidth - MoveRect->DestinationRect.left;
+            DestRect->bottom =  TexHeight - MoveRect->DestinationRect.top;
+            break;
+        }
+        case DXGI_MODE_ROTATION_ROTATE270:
+        {
+            SrcRect->left = MoveRect->SourcePoint.x;
+            SrcRect->top = TexWidth - (MoveRect->SourcePoint.x + MoveRect->DestinationRect.right - MoveRect->DestinationRect.left);
+            SrcRect->right = MoveRect->SourcePoint.y + MoveRect->DestinationRect.bottom - MoveRect->DestinationRect.top;
+            SrcRect->bottom = TexWidth - MoveRect->SourcePoint.x;
+
+            DestRect->left = MoveRect->DestinationRect.top;
+            DestRect->top = TexWidth - MoveRect->DestinationRect.right;
+            DestRect->right = MoveRect->DestinationRect.bottom;
+            DestRect->bottom =  TexWidth - MoveRect->DestinationRect.left;
+            break;
+        }
+        default:
+        {
+            RtlZeroMemory(DestRect, sizeof(RECT));
+            RtlZeroMemory(SrcRect, sizeof(RECT));
+            break;
+        }
+    }
+}
+
+//
+// Copy move rectangles
+//
+DUPL_RETURN DISPLAYMANAGER::CopyMove(_Inout_ ID3D11Texture2D* SharedSurf, _In_reads_(MoveCount) DXGI_OUTDUPL_MOVE_RECT* MoveBuffer, UINT MoveCount, INT OffsetX, INT OffsetY, _In_ DXGI_OUTPUT_DESC* DeskDesc, INT TexWidth, INT TexHeight)
+{
+    D3D11_TEXTURE2D_DESC FullDesc;
+    SharedSurf->GetDesc(&FullDesc);
+
+    // Make new intermediate surface to copy into for moving
+    if (!m_MoveSurf)
+    {
+        D3D11_TEXTURE2D_DESC MoveDesc;
+        MoveDesc = FullDesc;
+        MoveDesc.Width = DeskDesc->DesktopCoordinates.right - DeskDesc->DesktopCoordinates.left;
+        MoveDesc.Height = DeskDesc->DesktopCoordinates.bottom - DeskDesc->DesktopCoordinates.top;
+        MoveDesc.BindFlags = D3D11_BIND_RENDER_TARGET;
+        MoveDesc.MiscFlags = 0;
+        HRESULT hr = m_Device->CreateTexture2D(&MoveDesc, nullptr, &m_MoveSurf);
+        if (FAILED(hr))
+        {
+            return ProcessFailure(m_Device, L"Failed to create staging texture for move rects", L"Error", hr, SystemTransitionsExpectedErrors);
+        }
+    }
+
+    for (UINT i = 0; i < MoveCount; ++i)
+    {
+        RECT SrcRect;
+        RECT DestRect;
+
+        SetMoveRect(&SrcRect, &DestRect, DeskDesc, &(MoveBuffer[i]), TexWidth, TexHeight);
+
+        // Copy rect out of shared surface
+        D3D11_BOX Box;
+        Box.left = SrcRect.left + DeskDesc->DesktopCoordinates.left - OffsetX;
+        Box.top = SrcRect.top + DeskDesc->DesktopCoordinates.top - OffsetY;
+        Box.front = 0;
+        Box.right = SrcRect.right + DeskDesc->DesktopCoordinates.left - OffsetX;
+        Box.bottom = SrcRect.bottom + DeskDesc->DesktopCoordinates.top - OffsetY;
+        Box.back = 1;
+        m_DeviceContext->CopySubresourceRegion(m_MoveSurf, 0, SrcRect.left, SrcRect.top, 0, SharedSurf, 0, &Box);
+
+        // Copy back to shared surface
+        Box.left = SrcRect.left;
+        Box.top = SrcRect.top;
+        Box.front = 0;
+        Box.right = SrcRect.right;
+        Box.bottom = SrcRect.bottom;
+        Box.back = 1;
+        m_DeviceContext->CopySubresourceRegion(SharedSurf, 0, DestRect.left + DeskDesc->DesktopCoordinates.left - OffsetX, DestRect.top + DeskDesc->DesktopCoordinates.top - OffsetY, 0, m_MoveSurf, 0, &Box);
+    }
+
+    return DUPL_RETURN_SUCCESS;
+}
+
+//
+// Sets up vertices for dirty rects for rotated desktops
+//
+#pragma warning(push)
+#pragma warning(disable:__WARNING_USING_UNINIT_VAR) // false positives in SetDirtyVert due to tool bug
+
+void DISPLAYMANAGER::SetDirtyVert(_Out_writes_(NUMVERTICES) VERTEX* Vertices, _In_ RECT* Dirty, INT OffsetX, INT OffsetY, _In_ DXGI_OUTPUT_DESC* DeskDesc, _In_ D3D11_TEXTURE2D_DESC* FullDesc, _In_ D3D11_TEXTURE2D_DESC* ThisDesc)
+{
+    INT CenterX = FullDesc->Width / 2;
+    INT CenterY = FullDesc->Height / 2;
+
+    INT Width = DeskDesc->DesktopCoordinates.right - DeskDesc->DesktopCoordinates.left;
+    INT Height = DeskDesc->DesktopCoordinates.bottom - DeskDesc->DesktopCoordinates.top;
+
+    // Rotation compensated destination rect
+    RECT DestDirty = *Dirty;
+
+    // Set appropriate coordinates compensated for rotation
+    switch (DeskDesc->Rotation)
+    {
+        case DXGI_MODE_ROTATION_ROTATE90:
+        {
+            DestDirty.left = Width - Dirty->bottom;
+            DestDirty.top = Dirty->left;
+            DestDirty.right = Width - Dirty->top;
+            DestDirty.bottom = Dirty->right;
+
+            Vertices[0].TexCoord = XMFLOAT2(Dirty->right / static_cast<FLOAT>(ThisDesc->Width), Dirty->bottom / static_cast<FLOAT>(ThisDesc->Height));
+            Vertices[1].TexCoord = XMFLOAT2(Dirty->left / static_cast<FLOAT>(ThisDesc->Width), Dirty->bottom / static_cast<FLOAT>(ThisDesc->Height));
+            Vertices[2].TexCoord = XMFLOAT2(Dirty->right / static_cast<FLOAT>(ThisDesc->Width), Dirty->top / static_cast<FLOAT>(ThisDesc->Height));
+            Vertices[5].TexCoord = XMFLOAT2(Dirty->left / static_cast<FLOAT>(ThisDesc->Width), Dirty->top / static_cast<FLOAT>(ThisDesc->Height));
+            break;
+        }
+        case DXGI_MODE_ROTATION_ROTATE180:
+        {
+            DestDirty.left = Width - Dirty->right;
+            DestDirty.top = Height - Dirty->bottom;
+            DestDirty.right = Width - Dirty->left;
+            DestDirty.bottom = Height - Dirty->top;
+
+            Vertices[0].TexCoord = XMFLOAT2(Dirty->right / static_cast<FLOAT>(ThisDesc->Width), Dirty->top / static_cast<FLOAT>(ThisDesc->Height));
+            Vertices[1].TexCoord = XMFLOAT2(Dirty->right / static_cast<FLOAT>(ThisDesc->Width), Dirty->bottom / static_cast<FLOAT>(ThisDesc->Height));
+            Vertices[2].TexCoord = XMFLOAT2(Dirty->left / static_cast<FLOAT>(ThisDesc->Width), Dirty->top / static_cast<FLOAT>(ThisDesc->Height));
+            Vertices[5].TexCoord = XMFLOAT2(Dirty->left / static_cast<FLOAT>(ThisDesc->Width), Dirty->bottom / static_cast<FLOAT>(ThisDesc->Height));
+            break;
+        }
+        case DXGI_MODE_ROTATION_ROTATE270:
+        {
+            DestDirty.left = Dirty->top;
+            DestDirty.top = Height - Dirty->right;
+            DestDirty.right = Dirty->bottom;
+            DestDirty.bottom = Height - Dirty->left;
+
+            Vertices[0].TexCoord = XMFLOAT2(Dirty->left / static_cast<FLOAT>(ThisDesc->Width), Dirty->top / static_cast<FLOAT>(ThisDesc->Height));
+            Vertices[1].TexCoord = XMFLOAT2(Dirty->right / static_cast<FLOAT>(ThisDesc->Width), Dirty->top / static_cast<FLOAT>(ThisDesc->Height));
+            Vertices[2].TexCoord = XMFLOAT2(Dirty->left / static_cast<FLOAT>(ThisDesc->Width), Dirty->bottom / static_cast<FLOAT>(ThisDesc->Height));
+            Vertices[5].TexCoord = XMFLOAT2(Dirty->right / static_cast<FLOAT>(ThisDesc->Width), Dirty->bottom / static_cast<FLOAT>(ThisDesc->Height));
+            break;
+        }
+        default:
+            assert(false); // drop through
+        case DXGI_MODE_ROTATION_UNSPECIFIED:
+        case DXGI_MODE_ROTATION_IDENTITY:
+        {
+            Vertices[0].TexCoord = XMFLOAT2(Dirty->left / static_cast<FLOAT>(ThisDesc->Width), Dirty->bottom / static_cast<FLOAT>(ThisDesc->Height));
+            Vertices[1].TexCoord = XMFLOAT2(Dirty->left / static_cast<FLOAT>(ThisDesc->Width), Dirty->top / static_cast<FLOAT>(ThisDesc->Height));
+            Vertices[2].TexCoord = XMFLOAT2(Dirty->right / static_cast<FLOAT>(ThisDesc->Width), Dirty->bottom / static_cast<FLOAT>(ThisDesc->Height));
+            Vertices[5].TexCoord = XMFLOAT2(Dirty->right / static_cast<FLOAT>(ThisDesc->Width), Dirty->top / static_cast<FLOAT>(ThisDesc->Height));
+            break;
+        }
+    }
+
+    // Set positions
+    Vertices[0].Pos = XMFLOAT3((DestDirty.left + DeskDesc->DesktopCoordinates.left - OffsetX - CenterX) / static_cast<FLOAT>(CenterX),
+                             -1 * (DestDirty.bottom + DeskDesc->DesktopCoordinates.top - OffsetY - CenterY) / static_cast<FLOAT>(CenterY),
+                             0.0f);
+    Vertices[1].Pos = XMFLOAT3((DestDirty.left + DeskDesc->DesktopCoordinates.left - OffsetX - CenterX) / static_cast<FLOAT>(CenterX),
+                             -1 * (DestDirty.top + DeskDesc->DesktopCoordinates.top - OffsetY - CenterY) / static_cast<FLOAT>(CenterY),
+                             0.0f);
+    Vertices[2].Pos = XMFLOAT3((DestDirty.right + DeskDesc->DesktopCoordinates.left - OffsetX - CenterX) / static_cast<FLOAT>(CenterX),
+                             -1 * (DestDirty.bottom + DeskDesc->DesktopCoordinates.top - OffsetY - CenterY) / static_cast<FLOAT>(CenterY),
+                             0.0f);
+    Vertices[3].Pos = Vertices[2].Pos;
+    Vertices[4].Pos = Vertices[1].Pos;
+    Vertices[5].Pos = XMFLOAT3((DestDirty.right + DeskDesc->DesktopCoordinates.left - OffsetX - CenterX) / static_cast<FLOAT>(CenterX),
+                             -1 * (DestDirty.top + DeskDesc->DesktopCoordinates.top - OffsetY - CenterY) / static_cast<FLOAT>(CenterY),
+                             0.0f);
+
+    Vertices[3].TexCoord = Vertices[2].TexCoord;
+    Vertices[4].TexCoord = Vertices[1].TexCoord;
+}
+
+#pragma warning(pop) // re-enable __WARNING_USING_UNINIT_VAR
+
+//
+// Copies dirty rectangles
+//
+DUPL_RETURN DISPLAYMANAGER::CopyDirty(_In_ ID3D11Texture2D* SrcSurface, _Inout_ ID3D11Texture2D* SharedSurf, _In_reads_(DirtyCount) RECT* DirtyBuffer, UINT DirtyCount, INT OffsetX, INT OffsetY, _In_ DXGI_OUTPUT_DESC* DeskDesc)
+{
+    HRESULT hr;
+
+    D3D11_TEXTURE2D_DESC FullDesc;
+    SharedSurf->GetDesc(&FullDesc);
+
+    D3D11_TEXTURE2D_DESC ThisDesc;
+    SrcSurface->GetDesc(&ThisDesc);
+
+    if (!m_RTV)
+    {
+        hr = m_Device->CreateRenderTargetView(SharedSurf, nullptr, &m_RTV);
+        if (FAILED(hr))
+        {
+            return ProcessFailure(m_Device, L"Failed to create render target view for dirty rects", L"Error", hr, SystemTransitionsExpectedErrors);
+        }
+    }
+
+    D3D11_SHADER_RESOURCE_VIEW_DESC ShaderDesc;
+    ShaderDesc.Format = ThisDesc.Format;
+    ShaderDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
+    ShaderDesc.Texture2D.MostDetailedMip = ThisDesc.MipLevels - 1;
+    ShaderDesc.Texture2D.MipLevels = ThisDesc.MipLevels;
+
+    // Create new shader resource view
+    ID3D11ShaderResourceView* ShaderResource = nullptr;
+    hr = m_Device->CreateShaderResourceView(SrcSurface, &ShaderDesc, &ShaderResource);
+    if (FAILED(hr))
+    {
+        return ProcessFailure(m_Device, L"Failed to create shader resource view for dirty rects", L"Error", hr, SystemTransitionsExpectedErrors);
+    }
+
+    FLOAT BlendFactor[4] = {0.f, 0.f, 0.f, 0.f};
+    m_DeviceContext->OMSetBlendState(nullptr, BlendFactor, 0xFFFFFFFF);
+    m_DeviceContext->OMSetRenderTargets(1, &m_RTV, nullptr);
+    m_DeviceContext->VSSetShader(m_VertexShader, nullptr, 0);
+    m_DeviceContext->PSSetShader(m_PixelShader, nullptr, 0);
+    m_DeviceContext->PSSetShaderResources(0, 1, &ShaderResource);
+    m_DeviceContext->PSSetSamplers(0, 1, &m_SamplerLinear);
+    m_DeviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
+
+    // Create space for vertices for the dirty rects if the current space isn't large enough
+    UINT BytesNeeded = sizeof(VERTEX) * NUMVERTICES * DirtyCount;
+    if (BytesNeeded > m_DirtyVertexBufferAllocSize)
+    {
+        if (m_DirtyVertexBufferAlloc)
+        {
+            delete [] m_DirtyVertexBufferAlloc;
+        }
+
+        m_DirtyVertexBufferAlloc = new (std::nothrow) BYTE[BytesNeeded];
+        if (!m_DirtyVertexBufferAlloc)
+        {
+            m_DirtyVertexBufferAllocSize = 0;
+            return ProcessFailure(nullptr, L"Failed to allocate memory for dirty vertex buffer.", L"Error", E_OUTOFMEMORY);
+        }
+
+        m_DirtyVertexBufferAllocSize = BytesNeeded;
+    }
+
+    // Fill them in
+    VERTEX* DirtyVertex = reinterpret_cast<VERTEX*>(m_DirtyVertexBufferAlloc);
+    for (UINT i = 0; i < DirtyCount; ++i, DirtyVertex += NUMVERTICES)
+    {
+        SetDirtyVert(DirtyVertex, &(DirtyBuffer[i]), OffsetX, OffsetY, DeskDesc, &FullDesc, &ThisDesc);
+    }
+
+    // Create vertex buffer
+    D3D11_BUFFER_DESC BufferDesc;
+    RtlZeroMemory(&BufferDesc, sizeof(BufferDesc));
+    BufferDesc.Usage = D3D11_USAGE_DEFAULT;
+    BufferDesc.ByteWidth = BytesNeeded;
+    BufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
+    BufferDesc.CPUAccessFlags = 0;
+    D3D11_SUBRESOURCE_DATA InitData;
+    RtlZeroMemory(&InitData, sizeof(InitData));
+    InitData.pSysMem = m_DirtyVertexBufferAlloc;
+
+    ID3D11Buffer* VertBuf = nullptr;
+    hr = m_Device->CreateBuffer(&BufferDesc, &InitData, &VertBuf);
+    if (FAILED(hr))
+    {
+        return ProcessFailure(m_Device, L"Failed to create vertex buffer in dirty rect processing", L"Error", hr, SystemTransitionsExpectedErrors);
+    }
+    UINT Stride = sizeof(VERTEX);
+    UINT Offset = 0;
+    m_DeviceContext->IASetVertexBuffers(0, 1, &VertBuf, &Stride, &Offset);
+
+    D3D11_VIEWPORT VP;
+    VP.Width = static_cast<FLOAT>(FullDesc.Width);
+    VP.Height = static_cast<FLOAT>(FullDesc.Height);
+    VP.MinDepth = 0.0f;
+    VP.MaxDepth = 1.0f;
+    VP.TopLeftX = 0.0f;
+    VP.TopLeftY = 0.0f;
+    m_DeviceContext->RSSetViewports(1, &VP);
+
+    m_DeviceContext->Draw(NUMVERTICES * DirtyCount, 0);
+
+    VertBuf->Release();
+    VertBuf = nullptr;
+
+    ShaderResource->Release();
+    ShaderResource = nullptr;
+
+    return DUPL_RETURN_SUCCESS;
+}
+
+//
+// Clean all references
+//
+void DISPLAYMANAGER::CleanRefs()
+{
+    if (m_DeviceContext)
+    {
+        m_DeviceContext->Release();
+        m_DeviceContext = nullptr;
+    }
+
+    if (m_Device)
+    {
+        m_Device->Release();
+        m_Device = nullptr;
+    }
+
+    if (m_MoveSurf)
+    {
+        m_MoveSurf->Release();
+        m_MoveSurf = nullptr;
+    }
+
+    if (m_VertexShader)
+    {
+        m_VertexShader->Release();
+        m_VertexShader = nullptr;
+    }
+
+    if (m_PixelShader)
+    {
+        m_PixelShader->Release();
+        m_PixelShader = nullptr;
+    }
+
+    if (m_InputLayout)
+    {
+        m_InputLayout->Release();
+        m_InputLayout = nullptr;
+    }
+
+    if (m_SamplerLinear)
+    {
+        m_SamplerLinear->Release();
+        m_SamplerLinear = nullptr;
+    }
+
+    if (m_RTV)
+    {
+        m_RTV->Release();
+        m_RTV = nullptr;
+    }
+}

DisplayManager.h

@@ -0,0 +1,46 @@
+// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
+// PARTICULAR PURPOSE.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved
+
+#ifndef _DISPLAYMANAGER_H_
+#define _DISPLAYMANAGER_H_
+
+#include "CommonTypes.h"
+
+//
+// Handles the task of processing frames
+//
+class DISPLAYMANAGER
+{
+    public:
+        DISPLAYMANAGER();
+        ~DISPLAYMANAGER();
+        void InitD3D(DX_RESOURCES* Data);
+        ID3D11Device* GetDevice();
+        DUPL_RETURN ProcessFrame(_In_ FRAME_DATA* Data, _Inout_ ID3D11Texture2D* SharedSurf, INT OffsetX, INT OffsetY, _In_ DXGI_OUTPUT_DESC* DeskDesc);
+        void CleanRefs();
+
+    private:
+    // methods
+        DUPL_RETURN CopyDirty(_In_ ID3D11Texture2D* SrcSurface, _Inout_ ID3D11Texture2D* SharedSurf, _In_reads_(DirtyCount) RECT* DirtyBuffer, UINT DirtyCount, INT OffsetX, INT OffsetY, _In_ DXGI_OUTPUT_DESC* DeskDesc);
+        DUPL_RETURN CopyMove(_Inout_ ID3D11Texture2D* SharedSurf, _In_reads_(MoveCount) DXGI_OUTDUPL_MOVE_RECT* MoveBuffer, UINT MoveCount, INT OffsetX, INT OffsetY, _In_ DXGI_OUTPUT_DESC* DeskDesc, INT TexWidth, INT TexHeight);
+        void SetDirtyVert(_Out_writes_(NUMVERTICES) VERTEX* Vertices, _In_ RECT* Dirty, INT OffsetX, INT OffsetY, _In_ DXGI_OUTPUT_DESC* DeskDesc, _In_ D3D11_TEXTURE2D_DESC* FullDesc, _In_ D3D11_TEXTURE2D_DESC* ThisDesc);
+        void SetMoveRect(_Out_ RECT* SrcRect, _Out_ RECT* DestRect, _In_ DXGI_OUTPUT_DESC* DeskDesc, _In_ DXGI_OUTDUPL_MOVE_RECT* MoveRect, INT TexWidth, INT TexHeight);
+
+    // variables
+        ID3D11Device* m_Device;
+        ID3D11DeviceContext* m_DeviceContext;
+        ID3D11Texture2D* m_MoveSurf;
+        ID3D11VertexShader* m_VertexShader;
+        ID3D11PixelShader* m_PixelShader;
+        ID3D11InputLayout* m_InputLayout;
+        ID3D11RenderTargetView* m_RTV;
+        ID3D11SamplerState* m_SamplerLinear;
+        BYTE* m_DirtyVertexBufferAlloc;
+        UINT m_DirtyVertexBufferAllocSize;
+};
+
+#endif

DuplicationManager.cpp

@@ -0,0 +1,421 @@
+// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
+// PARTICULAR PURPOSE.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved
+
+#include "DuplicationManager.h"
+
+#include <algorithm>
+#include <cstdio>
+#include <iostream>
+#include <memory>
+
+//
+// Constructor sets up references / variables
+//
+DUPLICATIONMANAGER::DUPLICATIONMANAGER() : m_DeskDupl(nullptr),
+                                           m_AcquiredDesktopImage(nullptr),
+                                           m_MetaDataBuffer(nullptr),
+                                           m_MetaDataSize(0),
+                                           m_OutputNumber(0),
+                                           m_Device(nullptr) {
+	RtlZeroMemory(&m_OutputDesc, sizeof(m_OutputDesc));
+}
+
+//
+// Destructor simply calls CleanRefs to destroy everything
+//
+DUPLICATIONMANAGER::~DUPLICATIONMANAGER() {
+	if (m_DeskDupl) {
+		m_DeskDupl->Release();
+		m_DeskDupl = nullptr;
+	}
+
+	if (m_AcquiredDesktopImage) {
+		m_AcquiredDesktopImage->Release();
+		m_AcquiredDesktopImage = nullptr;
+	}
+
+	if (m_MetaDataBuffer) {
+		delete[] m_MetaDataBuffer;
+		m_MetaDataBuffer = nullptr;
+	}
+
+	if (m_Device) {
+		m_Device->Release();
+		m_Device = nullptr;
+	}
+}
+
+//
+// Initialize duplication interfaces
+//
+DUPL_RETURN DUPLICATIONMANAGER::InitDupl(_In_ ID3D11Device* Device, UINT Output) {
+	m_OutputNumber = Output;
+
+	// Take a reference on the device
+	m_Device = Device;
+	m_Device->AddRef();
+
+	// Get DXGI device
+	IDXGIDevice* DxgiDevice = nullptr;
+	HRESULT hr = m_Device->QueryInterface(__uuidof(IDXGIDevice), reinterpret_cast<void**>(&DxgiDevice));
+	if (FAILED(hr)) {
+		return ProcessFailure(nullptr, L"Failed to QI for DXGI Device", L"Error", hr);
+	}
+
+	// Get DXGI adapter
+	IDXGIAdapter* DxgiAdapter = nullptr;
+	hr = DxgiDevice->GetParent(__uuidof(IDXGIAdapter), reinterpret_cast<void**>(&DxgiAdapter));
+	DxgiDevice->Release();
+	DxgiDevice = nullptr;
+	if (FAILED(hr)) {
+		return ProcessFailure(m_Device, L"Failed to get parent DXGI Adapter", L"Error", hr,
+		                      SystemTransitionsExpectedErrors);
+	}
+
+	// Get output
+	IDXGIOutput* DxgiOutput = nullptr;
+	hr = DxgiAdapter->EnumOutputs(Output, &DxgiOutput);
+	DxgiAdapter->Release();
+	DxgiAdapter = nullptr;
+	if (FAILED(hr)) {
+		return ProcessFailure(m_Device, L"Failed to get specified output in DUPLICATIONMANAGER", L"Error", hr,
+		                      EnumOutputsExpectedErrors);
+	}
+
+	DxgiOutput->GetDesc(&m_OutputDesc);
+
+	// QI for Output 1
+	IDXGIOutput1* DxgiOutput1 = nullptr;
+	hr = DxgiOutput->QueryInterface(__uuidof(DxgiOutput1), reinterpret_cast<void**>(&DxgiOutput1));
+	DxgiOutput->Release();
+	DxgiOutput = nullptr;
+	if (FAILED(hr)) {
+		return ProcessFailure(nullptr, L"Failed to QI for DxgiOutput1 in DUPLICATIONMANAGER", L"Error", hr);
+	}
+
+	// Create desktop duplication
+	hr = DxgiOutput1->DuplicateOutput(m_Device, &m_DeskDupl);
+	DxgiOutput1->Release();
+	DxgiOutput1 = nullptr;
+	if (FAILED(hr)) {
+		if (hr == DXGI_ERROR_NOT_CURRENTLY_AVAILABLE) {
+			MessageBoxW(
+				nullptr,
+				L"There is already the maximum number of applications using the Desktop Duplication API running, please close one of those applications and then try again.",
+				L"Error", MB_OK);
+			return DUPL_RETURN_ERROR_UNEXPECTED;
+		}
+		return ProcessFailure(m_Device, L"Failed to get duplicate output in DUPLICATIONMANAGER", L"Error", hr,
+		                      CreateDuplicationExpectedErrors);
+	}
+
+	return DUPL_RETURN_SUCCESS;
+}
+
+//
+// Retrieves mouse info and write it into PtrInfo
+//
+DUPL_RETURN DUPLICATIONMANAGER::GetMouse(_Inout_ PTR_INFO* PtrInfo, _In_ DXGI_OUTDUPL_FRAME_INFO* FrameInfo,
+                                         INT OffsetX, INT OffsetY) {
+	// A non-zero mouse update timestamp indicates that there is a mouse position update and optionally a shape change
+	if (FrameInfo->LastMouseUpdateTime.QuadPart == 0) {
+		return DUPL_RETURN_SUCCESS;
+	}
+
+	bool UpdatePosition = true;
+
+	// Make sure we don't update pointer position wrongly
+	// If pointer is invisible, make sure we did not get an update from another output that the last time that said pointer
+	// was visible, if so, don't set it to invisible or update.
+	if (!FrameInfo->PointerPosition.Visible && (PtrInfo->WhoUpdatedPositionLast != m_OutputNumber)) {
+		UpdatePosition = false;
+	}
+
+	// If two outputs both say they have a visible, only update if new update has newer timestamp
+	if (FrameInfo->PointerPosition.Visible && PtrInfo->Visible && (PtrInfo->WhoUpdatedPositionLast != m_OutputNumber) &&
+		(PtrInfo->LastTimeStamp.QuadPart > FrameInfo->LastMouseUpdateTime.QuadPart)) {
+		UpdatePosition = false;
+	}
+
+	// Update position
+	if (UpdatePosition) {
+		PtrInfo->Position.x = FrameInfo->PointerPosition.Position.x + m_OutputDesc.DesktopCoordinates.left - OffsetX;
+		PtrInfo->Position.y = FrameInfo->PointerPosition.Position.y + m_OutputDesc.DesktopCoordinates.top - OffsetY;
+		PtrInfo->WhoUpdatedPositionLast = m_OutputNumber;
+		PtrInfo->LastTimeStamp = FrameInfo->LastMouseUpdateTime;
+		PtrInfo->Visible = FrameInfo->PointerPosition.Visible != 0;
+	}
+
+	// No new shape
+	if (FrameInfo->PointerShapeBufferSize == 0) {
+		return DUPL_RETURN_SUCCESS;
+	}
+
+	// Old buffer too small
+	if (FrameInfo->PointerShapeBufferSize > PtrInfo->BufferSize) {
+		if (PtrInfo->PtrShapeBuffer) {
+			delete[] PtrInfo->PtrShapeBuffer;
+			PtrInfo->PtrShapeBuffer = nullptr;
+		}
+		PtrInfo->PtrShapeBuffer = new(std::nothrow) BYTE[FrameInfo->PointerShapeBufferSize];
+		if (!PtrInfo->PtrShapeBuffer) {
+			PtrInfo->BufferSize = 0;
+			return ProcessFailure(nullptr, L"Failed to allocate memory for pointer shape in DUPLICATIONMANAGER",
+			                      L"Error", E_OUTOFMEMORY);
+		}
+
+		// Update buffer size
+		PtrInfo->BufferSize = FrameInfo->PointerShapeBufferSize;
+	}
+
+	// Get shape
+	UINT BufferSizeRequired;
+	HRESULT hr = m_DeskDupl->GetFramePointerShape(FrameInfo->PointerShapeBufferSize,
+	                                              reinterpret_cast<VOID*>(PtrInfo->PtrShapeBuffer), &BufferSizeRequired,
+	                                              &(PtrInfo->ShapeInfo));
+	if (FAILED(hr)) {
+		delete[] PtrInfo->PtrShapeBuffer;
+		PtrInfo->PtrShapeBuffer = nullptr;
+		PtrInfo->BufferSize = 0;
+		return ProcessFailure(m_Device, L"Failed to get frame pointer shape in DUPLICATIONMANAGER", L"Error", hr,
+		                      FrameInfoExpectedErrors);
+	}
+
+	return DUPL_RETURN_SUCCESS;
+}
+
+int bmp_write(unsigned char* image, int imageWidth, int imageHeight, char* filename) {
+	unsigned char header[54] = {
+		0x42, 0x4d, 0, 0, 0, 0, 0, 0, 0, 0,
+		54, 0, 0, 0, 40, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 32, 0,
+		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0
+	};
+
+	long file_size = (long)imageWidth * (long)imageHeight * 4 + 54;
+	header[2] = (unsigned char)(file_size & 0x000000ff);
+	header[3] = (file_size >> 8) & 0x000000ff;
+	header[4] = (file_size >> 16) & 0x000000ff;
+	header[5] = (file_size >> 24) & 0x000000ff;
+
+	long width = imageWidth;
+	header[18] = width & 0x000000ff;
+	header[19] = (width >> 8) & 0x000000ff;
+	header[20] = (width >> 16) & 0x000000ff;
+	header[21] = (width >> 24) & 0x000000ff;
+
+	long height = imageHeight;
+	header[22] = height & 0x000000ff;
+	header[23] = (height >> 8) & 0x000000ff;
+	header[24] = (height >> 16) & 0x000000ff;
+	header[25] = (height >> 24) & 0x000000ff;
+
+	char fname_bmp[128];
+	sprintf(fname_bmp, "%s", filename);
+
+	FILE* fp;
+	if (!(fp = fopen(fname_bmp, "wb")))
+		return -1;
+
+	fwrite(header, sizeof(unsigned char), 54, fp);
+	fwrite(image, sizeof(unsigned char), (size_t)(long)imageWidth * imageHeight * 4, fp);
+
+	fclose(fp);
+	return 0;
+}
+
+ffvideo* play = nullptr;
+int pts = 0;
+FILE* ff;
+
+void output(ffvideo* ctx) {
+	if (ff == nullptr) {
+		ff = fopen("a.h264", "wb"); //sps pps
+		fwrite(ctx->encoder_ctx->extradata, sizeof(uint8_t), ctx->encoder_ctx->extradata_size, ff);
+	}
+
+	fwrite(ctx->dst_packet->data, sizeof(uint8_t), ctx->dst_packet->size, ff);
+
+	std::cout << "ENCODE_SUCCESS: size = " << ctx->dst_packet->size << std::endl;
+}
+
+void extract_pixel(ID3D11Device* m_Device, ID3D11Texture2D* m_AcquiredDesktopImage) {
+
+	if (pts > 500) return;
+	if (pts == 500) {
+		fclose(ff);
+		exit(0);
+	}
+
+	ID3D11DeviceContext* ctx;
+	m_Device->GetImmediateContext(&ctx);
+
+	ID3D11Texture2D* copy_tex = nullptr;
+
+	D3D11_TEXTURE2D_DESC desc;
+	m_AcquiredDesktopImage->GetDesc(&desc);
+	desc.MipLevels = 1;
+	desc.ArraySize = 1;
+	desc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
+	desc.Usage = D3D11_USAGE_STAGING;
+	desc.SampleDesc.Count = 1;
+	desc.SampleDesc.Quality = 0;
+	desc.BindFlags = 0;
+	desc.MiscFlags = 0;
+	desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
+	int hr = m_Device->CreateTexture2D(&desc, nullptr, &copy_tex);
+	if (FAILED(hr) || copy_tex == nullptr) {
+		return;
+	}
+	ctx->CopyResource(copy_tex, m_AcquiredDesktopImage);
+
+
+	D3D11_MAPPED_SUBRESOURCE resource;
+	ctx->Map(copy_tex, 0, D3D11_MAP_READ, 0, &resource);
+
+	if (!pts) {
+		play = new ffvideo();
+		play->info = {
+			1920, 1080, AV_PIX_FMT_BGRA,
+			1920 / 2, 1080 / 2, AV_PIX_FMT_YUV420P,
+			30, 2 * 1024 * 1024, 30
+		};
+		play->initSws();
+		play->initH264();
+	}
+
+	play->src_buffer = (uint8_t*)resource.pData;
+	for (int i = 0; i < 4; i++)
+		play->line_size[i] = resource.RowPitch;
+	play->process_data(pts, pts, output);
+
+	ctx->Unmap(copy_tex, 0);
+	pts++;
+}
+
+//
+// Get next frame and write it into Data
+//
+_Success_(*Timeout == false && return == DUPL_RETURN_SUCCESS)
+
+DUPL_RETURN DUPLICATIONMANAGER::GetFrame(_Out_ FRAME_DATA* Data, _Out_ bool* Timeout) {
+	IDXGIResource* DesktopResource = nullptr;
+	DXGI_OUTDUPL_FRAME_INFO FrameInfo;
+
+	// Get new frame
+	HRESULT hr = m_DeskDupl->AcquireNextFrame(500, &FrameInfo, &DesktopResource);
+	if (hr == DXGI_ERROR_WAIT_TIMEOUT) {
+		*Timeout = true;
+		return DUPL_RETURN_SUCCESS;
+	}
+	*Timeout = false;
+
+
+	if (FAILED(hr)) {
+		return ProcessFailure(m_Device, L"Failed to acquire next frame in DUPLICATIONMANAGER", L"Error", hr,
+		                      FrameInfoExpectedErrors);
+	}
+
+	// If still holding old frame, destroy it
+	if (m_AcquiredDesktopImage) {
+		m_AcquiredDesktopImage->Release();
+		m_AcquiredDesktopImage = nullptr;
+	}
+
+	// QI for IDXGIResource
+	hr = DesktopResource->QueryInterface(__uuidof(ID3D11Texture2D), reinterpret_cast<void**>(&m_AcquiredDesktopImage));
+	DesktopResource->Release();
+	DesktopResource = nullptr;
+	if (FAILED(hr)) {
+		return ProcessFailure(
+			nullptr, L"Failed to QI for ID3D11Texture2D from acquired IDXGIResource in DUPLICATIONMANAGER", L"Error",
+			hr);
+	}
+
+	static int tx = 0;
+	if (tx == 100) { }
+	extract_pixel(m_Device, m_AcquiredDesktopImage);
+	tx++;
+
+	// Get metadata
+	if (FrameInfo.TotalMetadataBufferSize) {
+		// Old buffer too small
+		if (FrameInfo.TotalMetadataBufferSize > m_MetaDataSize) {
+			if (m_MetaDataBuffer) {
+				delete[] m_MetaDataBuffer;
+				m_MetaDataBuffer = nullptr;
+			}
+			m_MetaDataBuffer = new(std::nothrow) BYTE[FrameInfo.TotalMetadataBufferSize];
+			if (!m_MetaDataBuffer) {
+				m_MetaDataSize = 0;
+				Data->MoveCount = 0;
+				Data->DirtyCount = 0;
+				return ProcessFailure(nullptr, L"Failed to allocate memory for metadata in DUPLICATIONMANAGER",
+				                      L"Error", E_OUTOFMEMORY);
+			}
+			m_MetaDataSize = FrameInfo.TotalMetadataBufferSize;
+		}
+
+		UINT BufSize = FrameInfo.TotalMetadataBufferSize;
+
+		// Get move rectangles
+		hr = m_DeskDupl->GetFrameMoveRects(BufSize, reinterpret_cast<DXGI_OUTDUPL_MOVE_RECT*>(m_MetaDataBuffer),
+		                                   &BufSize);
+		if (FAILED(hr)) {
+			Data->MoveCount = 0;
+			Data->DirtyCount = 0;
+			return ProcessFailure(nullptr, L"Failed to get frame move rects in DUPLICATIONMANAGER", L"Error", hr,
+			                      FrameInfoExpectedErrors);
+		}
+		Data->MoveCount = BufSize / sizeof(DXGI_OUTDUPL_MOVE_RECT);
+
+		BYTE* DirtyRects = m_MetaDataBuffer + BufSize;
+		BufSize = FrameInfo.TotalMetadataBufferSize - BufSize;
+
+		// Get dirty rectangles
+		hr = m_DeskDupl->GetFrameDirtyRects(BufSize, reinterpret_cast<RECT*>(DirtyRects), &BufSize);
+		if (FAILED(hr)) {
+			Data->MoveCount = 0;
+			Data->DirtyCount = 0;
+			return ProcessFailure(nullptr, L"Failed to get frame dirty rects in DUPLICATIONMANAGER", L"Error", hr,
+			                      FrameInfoExpectedErrors);
+		}
+		Data->DirtyCount = BufSize / sizeof(RECT);
+
+		Data->MetaData = m_MetaDataBuffer;
+	}
+
+	Data->Frame = m_AcquiredDesktopImage;
+	Data->FrameInfo = FrameInfo;
+
+	return DUPL_RETURN_SUCCESS;
+}
+
+//
+// Release frame
+//
+DUPL_RETURN DUPLICATIONMANAGER::DoneWithFrame() {
+	HRESULT hr = m_DeskDupl->ReleaseFrame();
+	if (FAILED(hr)) {
+		return ProcessFailure(m_Device, L"Failed to release frame in DUPLICATIONMANAGER", L"Error", hr,
+		                      FrameInfoExpectedErrors);
+	}
+
+	if (m_AcquiredDesktopImage) {
+		m_AcquiredDesktopImage->Release();
+		m_AcquiredDesktopImage = nullptr;
+	}
+
+	return DUPL_RETURN_SUCCESS;
+}
+
+//
+// Gets output desc into DescPtr
+//
+void DUPLICATIONMANAGER::GetOutputDesc(_Out_ DXGI_OUTPUT_DESC* DescPtr) {
+	*DescPtr = m_OutputDesc;
+}

DuplicationManager.h

@@ -0,0 +1,40 @@
+// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
+// PARTICULAR PURPOSE.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved
+
+#ifndef _DUPLICATIONMANAGER_H_
+#define _DUPLICATIONMANAGER_H_
+
+#include "CommonTypes.h"
+#include "ffvideo.h"
+
+//
+// Handles the task of duplicating an output.
+//
+class DUPLICATIONMANAGER
+{
+    public:
+        DUPLICATIONMANAGER();
+        ~DUPLICATIONMANAGER();
+        _Success_(*Timeout == false && return == DUPL_RETURN_SUCCESS) DUPL_RETURN GetFrame(_Out_ FRAME_DATA* Data, _Out_ bool* Timeout);
+        DUPL_RETURN DoneWithFrame();
+        DUPL_RETURN InitDupl(_In_ ID3D11Device* Device, UINT Output);
+        DUPL_RETURN GetMouse(_Inout_ PTR_INFO* PtrInfo, _In_ DXGI_OUTDUPL_FRAME_INFO* FrameInfo, INT OffsetX, INT OffsetY);
+        void GetOutputDesc(_Out_ DXGI_OUTPUT_DESC* DescPtr);
+
+    //private:
+
+    // vars
+        IDXGIOutputDuplication* m_DeskDupl;
+        ID3D11Texture2D* m_AcquiredDesktopImage;
+        _Field_size_bytes_(m_MetaDataSize) BYTE* m_MetaDataBuffer;
+        UINT m_MetaDataSize;
+        UINT m_OutputNumber;
+        DXGI_OUTPUT_DESC m_OutputDesc;
+        ID3D11Device* m_Device;
+};
+
+#endif

OutputManager.h

@@ -0,0 +1,61 @@
+// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
+// PARTICULAR PURPOSE.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved
+
+#ifndef _OUTPUTMANAGER_H_
+#define _OUTPUTMANAGER_H_
+
+#include <stdio.h>
+
+#include "CommonTypes.h"
+#include "warning.h"
+
+//
+// Handles the task of drawing into a window.
+// Has the functionality to draw the mouse given a mouse shape buffer and position
+//
+class OUTPUTMANAGER
+{
+    public:
+        OUTPUTMANAGER();
+        ~OUTPUTMANAGER();
+        DUPL_RETURN InitOutput(HWND Window, INT SingleOutput, _Out_ UINT* OutCount, _Out_ RECT* DeskBounds);
+        DUPL_RETURN UpdateApplicationWindow(_In_ PTR_INFO* PointerInfo, _Inout_ bool* Occluded);
+        void CleanRefs();
+        HANDLE GetSharedHandle();
+        void WindowResize();
+
+    private:
+    // Methods
+        DUPL_RETURN ProcessMonoMask(bool IsMono, _Inout_ PTR_INFO* PtrInfo, _Out_ INT* PtrWidth, _Out_ INT* PtrHeight, _Out_ INT* PtrLeft, _Out_ INT* PtrTop, _Outptr_result_bytebuffer_(*PtrHeight * *PtrWidth * BPP) BYTE** InitBuffer, _Out_ D3D11_BOX* Box);
+        DUPL_RETURN MakeRTV();
+        void SetViewPort(UINT Width, UINT Height);
+        DUPL_RETURN InitShaders();
+        DUPL_RETURN InitGeometry();
+        DUPL_RETURN CreateSharedSurf(INT SingleOutput, _Out_ UINT* OutCount, _Out_ RECT* DeskBounds);
+        DUPL_RETURN DrawFrame();
+        DUPL_RETURN DrawMouse(_In_ PTR_INFO* PtrInfo);
+        DUPL_RETURN ResizeSwapChain();
+
+    // Vars
+        IDXGISwapChain1* m_SwapChain;
+        ID3D11Device* m_Device;
+        IDXGIFactory2* m_Factory;
+        ID3D11DeviceContext* m_DeviceContext;
+        ID3D11RenderTargetView* m_RTV;
+        ID3D11SamplerState* m_SamplerLinear;
+        ID3D11BlendState* m_BlendState;
+        ID3D11VertexShader* m_VertexShader;
+        ID3D11PixelShader* m_PixelShader;
+        ID3D11InputLayout* m_InputLayout;
+        ID3D11Texture2D* m_SharedSurf;
+        IDXGIKeyedMutex* m_KeyMutex;
+        HWND m_WindowHandle;
+        bool m_NeedsResize;
+        DWORD m_OcclusionCookie;
+};
+
+#endif

PixelShader.hlsl

@@ -0,0 +1,24 @@
+// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
+// PARTICULAR PURPOSE.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved
+//----------------------------------------------------------------------
+
+Texture2D tx : register( t0 );
+SamplerState samLinear : register( s0 );
+
+struct PS_INPUT
+{
+    float4 Pos : SV_POSITION;
+    float2 Tex : TEXCOORD;
+};
+
+//--------------------------------------------------------------------------------------
+// Pixel Shader
+//--------------------------------------------------------------------------------------
+float4 PS(PS_INPUT input) : SV_Target
+{
+    return tx.Sample( samLinear, input.Tex );
+}

ThreadManager.cpp

@@ -0,0 +1,258 @@
+// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
+// PARTICULAR PURPOSE.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved
+
+#include "ThreadManager.h"
+
+DWORD WINAPI DDProc(_In_ void* Param);
+
+THREADMANAGER::THREADMANAGER() : m_ThreadCount(0),
+                                 m_ThreadHandles(nullptr),
+                                 m_ThreadData(nullptr)
+{
+    RtlZeroMemory(&m_PtrInfo, sizeof(m_PtrInfo));
+}
+
+THREADMANAGER::~THREADMANAGER()
+{
+    Clean();
+}
+
+//
+// Clean up resources
+//
+void THREADMANAGER::Clean()
+{
+    if (m_PtrInfo.PtrShapeBuffer)
+    {
+        delete [] m_PtrInfo.PtrShapeBuffer;
+        m_PtrInfo.PtrShapeBuffer = nullptr;
+    }
+    RtlZeroMemory(&m_PtrInfo, sizeof(m_PtrInfo));
+
+    if (m_ThreadHandles)
+    {
+        for (UINT i = 0; i < m_ThreadCount; ++i)
+        {
+            if (m_ThreadHandles[i])
+            {
+                CloseHandle(m_ThreadHandles[i]);
+            }
+        }
+        delete [] m_ThreadHandles;
+        m_ThreadHandles = nullptr;
+    }
+
+    if (m_ThreadData)
+    {
+        for (UINT i = 0; i < m_ThreadCount; ++i)
+        {
+            CleanDx(&m_ThreadData[i].DxRes);
+        }
+        delete [] m_ThreadData;
+        m_ThreadData = nullptr;
+    }
+
+    m_ThreadCount = 0;
+}
+
+//
+// Clean up DX_RESOURCES
+//
+void THREADMANAGER::CleanDx(_Inout_ DX_RESOURCES* Data)
+{
+    if (Data->Device)
+    {
+        Data->Device->Release();
+        Data->Device = nullptr;
+    }
+
+    if (Data->Context)
+    {
+        Data->Context->Release();
+        Data->Context = nullptr;
+    }
+
+    if (Data->VertexShader)
+    {
+        Data->VertexShader->Release();
+        Data->VertexShader = nullptr;
+    }
+
+    if (Data->PixelShader)
+    {
+        Data->PixelShader->Release();
+        Data->PixelShader = nullptr;
+    }
+
+    if (Data->InputLayout)
+    {
+        Data->InputLayout->Release();
+        Data->InputLayout = nullptr;
+    }
+
+    if (Data->SamplerLinear)
+    {
+        Data->SamplerLinear->Release();
+        Data->SamplerLinear = nullptr;
+    }
+}
+
+//
+// Start up threads for DDA
+//
+DUPL_RETURN THREADMANAGER::Initialize(INT SingleOutput, UINT OutputCount, HANDLE UnexpectedErrorEvent, HANDLE ExpectedErrorEvent, HANDLE TerminateThreadsEvent, HANDLE SharedHandle, _In_ RECT* DesktopDim)
+{
+    m_ThreadCount = OutputCount;
+    m_ThreadHandles = new (std::nothrow) HANDLE[m_ThreadCount];
+    m_ThreadData = new (std::nothrow) THREAD_DATA[m_ThreadCount];
+    if (!m_ThreadHandles || !m_ThreadData)
+    {
+        return ProcessFailure(nullptr, L"Failed to allocate array for threads", L"Error", E_OUTOFMEMORY);
+    }
+
+    // Create appropriate # of threads for duplication
+    DUPL_RETURN Ret = DUPL_RETURN_SUCCESS;
+    for (UINT i = 0; i < m_ThreadCount; ++i)
+    {
+        m_ThreadData[i].UnexpectedErrorEvent = UnexpectedErrorEvent;
+        m_ThreadData[i].ExpectedErrorEvent = ExpectedErrorEvent;
+        m_ThreadData[i].TerminateThreadsEvent = TerminateThreadsEvent;
+        m_ThreadData[i].Output = (SingleOutput < 0) ? i : SingleOutput;
+        m_ThreadData[i].TexSharedHandle = SharedHandle;
+        m_ThreadData[i].OffsetX = DesktopDim->left;
+        m_ThreadData[i].OffsetY = DesktopDim->top;
+        m_ThreadData[i].PtrInfo = &m_PtrInfo;
+
+        RtlZeroMemory(&m_ThreadData[i].DxRes, sizeof(DX_RESOURCES));
+        Ret = InitializeDx(&m_ThreadData[i].DxRes);
+        if (Ret != DUPL_RETURN_SUCCESS)
+        {
+            return Ret;
+        }
+
+        DWORD ThreadId;
+        m_ThreadHandles[i] = CreateThread(nullptr, 0, DDProc, &m_ThreadData[i], 0, &ThreadId);
+        if (m_ThreadHandles[i] == nullptr)
+        {
+            return ProcessFailure(nullptr, L"Failed to create thread", L"Error", E_FAIL);
+        }
+    }
+
+    return Ret;
+}
+
+//
+// Get DX_RESOURCES
+//
+DUPL_RETURN THREADMANAGER::InitializeDx(_Out_ DX_RESOURCES* Data)
+{
+    HRESULT hr = S_OK;
+
+    // Driver types supported
+    D3D_DRIVER_TYPE DriverTypes[] =
+    {
+        D3D_DRIVER_TYPE_HARDWARE,
+        D3D_DRIVER_TYPE_WARP,
+        D3D_DRIVER_TYPE_REFERENCE,
+    };
+    UINT NumDriverTypes = ARRAYSIZE(DriverTypes);
+
+    // Feature levels supported
+    D3D_FEATURE_LEVEL FeatureLevels[] =
+    {
+        D3D_FEATURE_LEVEL_11_0,
+        D3D_FEATURE_LEVEL_10_1,
+        D3D_FEATURE_LEVEL_10_0,
+        D3D_FEATURE_LEVEL_9_1
+    };
+    UINT NumFeatureLevels = ARRAYSIZE(FeatureLevels);
+
+    D3D_FEATURE_LEVEL FeatureLevel;
+
+    // Create device
+    for (UINT DriverTypeIndex = 0; DriverTypeIndex < NumDriverTypes; ++DriverTypeIndex)
+    {
+        hr = D3D11CreateDevice(nullptr, DriverTypes[DriverTypeIndex], nullptr, 0, FeatureLevels, NumFeatureLevels,
+                                D3D11_SDK_VERSION, &Data->Device, &FeatureLevel, &Data->Context);
+        if (SUCCEEDED(hr))
+        {
+            // Device creation success, no need to loop anymore
+            break;
+        }
+    }
+    if (FAILED(hr))
+    {
+        return ProcessFailure(nullptr, L"Failed to create device in InitializeDx", L"Error", hr);
+    }
+
+    // VERTEX shader
+    UINT Size = ARRAYSIZE(g_VS);
+    hr = Data->Device->CreateVertexShader(g_VS, Size, nullptr, &Data->VertexShader);
+    if (FAILED(hr))
+    {
+        return ProcessFailure(Data->Device, L"Failed to create vertex shader in InitializeDx", L"Error", hr, SystemTransitionsExpectedErrors);
+    }
+
+    // Input layout
+    D3D11_INPUT_ELEMENT_DESC Layout[] =
+    {
+        {"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0},
+        {"TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0}
+    };
+    UINT NumElements = ARRAYSIZE(Layout);
+    hr = Data->Device->CreateInputLayout(Layout, NumElements, g_VS, Size, &Data->InputLayout);
+    if (FAILED(hr))
+    {
+        return ProcessFailure(Data->Device, L"Failed to create input layout in InitializeDx", L"Error", hr, SystemTransitionsExpectedErrors);
+    }
+    Data->Context->IASetInputLayout(Data->InputLayout);
+
+    // Pixel shader
+    Size = ARRAYSIZE(g_PS);
+    hr = Data->Device->CreatePixelShader(g_PS, Size, nullptr, &Data->PixelShader);
+    if (FAILED(hr))
+    {
+        return ProcessFailure(Data->Device, L"Failed to create pixel shader in InitializeDx", L"Error", hr, SystemTransitionsExpectedErrors);
+    }
+
+    // Set up sampler
+    D3D11_SAMPLER_DESC SampDesc;
+    RtlZeroMemory(&SampDesc, sizeof(SampDesc));
+    SampDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
+    SampDesc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;
+    SampDesc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;
+    SampDesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
+    SampDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;
+    SampDesc.MinLOD = 0;
+    SampDesc.MaxLOD = D3D11_FLOAT32_MAX;
+    hr = Data->Device->CreateSamplerState(&SampDesc, &Data->SamplerLinear);
+    if (FAILED(hr))
+    {
+        return ProcessFailure(Data->Device, L"Failed to create sampler state in InitializeDx", L"Error", hr, SystemTransitionsExpectedErrors);
+    }
+
+    return DUPL_RETURN_SUCCESS;
+}
+
+//
+// Getter for the PTR_INFO structure
+//
+PTR_INFO* THREADMANAGER::GetPointerInfo()
+{
+    return &m_PtrInfo;
+}
+
+//
+// Waits infinitely for all spawned threads to terminate
+//
+void THREADMANAGER::WaitForThreadTermination()
+{
+    if (m_ThreadCount != 0)
+    {
+        WaitForMultipleObjectsEx(m_ThreadCount, m_ThreadHandles, TRUE, INFINITE, FALSE);
+    }
+}

ThreadManager.h

@@ -0,0 +1,33 @@
+// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
+// PARTICULAR PURPOSE.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved
+
+#ifndef _THREADMANAGER_H_
+#define _THREADMANAGER_H_
+
+#include "CommonTypes.h"
+
+class THREADMANAGER
+{
+    public:
+        THREADMANAGER();
+        ~THREADMANAGER();
+        void Clean();
+        DUPL_RETURN Initialize(INT SingleOutput, UINT OutputCount, HANDLE UnexpectedErrorEvent, HANDLE ExpectedErrorEvent, HANDLE TerminateThreadsEvent, HANDLE SharedHandle, _In_ RECT* DesktopDim);
+        PTR_INFO* GetPointerInfo();
+        void WaitForThreadTermination();
+
+    private:
+        DUPL_RETURN InitializeDx(_Out_ DX_RESOURCES* Data);
+        void CleanDx(_Inout_ DX_RESOURCES* Data);
+
+        PTR_INFO m_PtrInfo;
+        UINT m_ThreadCount;
+        _Field_size_(m_ThreadCount) HANDLE* m_ThreadHandles;
+        _Field_size_(m_ThreadCount) THREAD_DATA* m_ThreadData;
+};
+
+#endif

VertexShader.hlsl

@@ -0,0 +1,28 @@
+// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
+// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
+// PARTICULAR PURPOSE.
+//
+// Copyright (c) Microsoft Corporation. All rights reserved
+//----------------------------------------------------------------------
+
+struct VS_INPUT
+{
+    float4 Pos : POSITION;
+    float2 Tex : TEXCOORD;
+};
+
+struct VS_OUTPUT
+{
+    float4 Pos : SV_POSITION;
+    float2 Tex : TEXCOORD;
+};
+
+
+//--------------------------------------------------------------------------------------
+// Vertex Shader
+//--------------------------------------------------------------------------------------
+VS_OUTPUT VS(VS_INPUT input)
+{
+    return input;
+}

ffmpeg-n4.3.2-win64-gpl-shared-4.3/doc/developer.html

@@ -0,0 +1,863 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
+  <head>
+    <meta charset="utf-8">
+    <title>
+      Developer Documentation
+    </title>
+    <meta name="viewport" content="width=device-width,initial-scale=1.0">
+    <link rel="stylesheet" type="text/css" href="bootstrap.min.css">
+    <link rel="stylesheet" type="text/css" href="style.min.css">
+  </head>
+  <body>
+    <div class="container">
+      <h1>
+      Developer Documentation
+      </h1>
+<div align="center">
+</div>
+
+
+<a name="SEC_Top"></a>
+
+<span id="SEC_Contents"></span>
+<h2 class="contents-heading">Table of Contents</h2>
+
+<div class="contents">
+
+<ul class="no-bullet">
+  <li><a id="toc-Notes-for-external-developers" href="#Notes-for-external-developers">1 Notes for external developers</a></li>
+  <li><a id="toc-Contributing" href="#Contributing">2 Contributing</a></li>
+  <li><a id="toc-Coding-Rules-1" href="#Coding-Rules-1">3 Coding Rules</a>
+  <ul class="no-bullet">
+    <li><a id="toc-Code-formatting-conventions" href="#Code-formatting-conventions">3.1 Code formatting conventions</a></li>
+    <li><a id="toc-Comments" href="#Comments">3.2 Comments</a></li>
+    <li><a id="toc-C-language-features" href="#C-language-features">3.3 C language features</a></li>
+    <li><a id="toc-Naming-conventions" href="#Naming-conventions">3.4 Naming conventions</a></li>
+    <li><a id="toc-Miscellaneous-conventions" href="#Miscellaneous-conventions">3.5 Miscellaneous conventions</a></li>
+    <li><a id="toc-Editor-configuration" href="#Editor-configuration">3.6 Editor configuration</a></li>
+  </ul></li>
+  <li><a id="toc-Development-Policy" href="#Development-Policy">4 Development Policy</a>
+  <ul class="no-bullet">
+    <li><a id="toc-Patches_002fCommitting" href="#Patches_002fCommitting">4.1 Patches/Committing</a></li>
+    <li><a id="toc-Code" href="#Code">4.2 Code</a></li>
+    <li><a id="toc-Documentation_002fOther" href="#Documentation_002fOther">4.3 Documentation/Other</a></li>
+  </ul></li>
+  <li><a id="toc-Code-of-conduct" href="#Code-of-conduct">5 Code of conduct</a></li>
+  <li><a id="toc-Submitting-patches-1" href="#Submitting-patches-1">6 Submitting patches</a></li>
+  <li><a id="toc-New-codecs-or-formats-checklist" href="#New-codecs-or-formats-checklist">7 New codecs or formats checklist</a></li>
+  <li><a id="toc-Patch-submission-checklist" href="#Patch-submission-checklist">8 Patch submission checklist</a></li>
+  <li><a id="toc-Patch-review-process" href="#Patch-review-process">9 Patch review process</a></li>
+  <li><a id="toc-Regression-tests-1" href="#Regression-tests-1">10 Regression tests</a>
+  <ul class="no-bullet">
+    <li><a id="toc-Adding-files-to-the-fate_002dsuite-dataset" href="#Adding-files-to-the-fate_002dsuite-dataset">10.1 Adding files to the fate-suite dataset</a></li>
+    <li><a id="toc-Visualizing-Test-Coverage" href="#Visualizing-Test-Coverage">10.2 Visualizing Test Coverage</a></li>
+    <li><a id="toc-Using-Valgrind" href="#Using-Valgrind">10.3 Using Valgrind</a></li>
+  </ul></li>
+  <li><a id="toc-Release-process-1" href="#Release-process-1">11 Release process</a>
+  <ul class="no-bullet">
+    <li><a id="toc-Criteria-for-Point-Releases-1" href="#Criteria-for-Point-Releases-1">11.1 Criteria for Point Releases</a></li>
+    <li><a id="toc-Release-Checklist" href="#Release-Checklist">11.2 Release Checklist</a></li>
+  </ul></li>
+</ul>
+</div>
+
+
+<a name="Notes-for-external-developers"></a>
+<h2 class="chapter">1 Notes for external developers<span class="pull-right"><a class="anchor hidden-xs" href="#Notes-for-external-developers" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Notes-for-external-developers" aria-hidden="true">TOC</a></span></h2>
+
+<p>This document is mostly useful for internal FFmpeg developers.
+External developers who need to use the API in their application should
+refer to the API doxygen documentation in the public headers, and
+check the examples in <samp>doc/examples</samp> and in the source code to
+see how the public API is employed.
+</p>
+<p>You can use the FFmpeg libraries in your commercial program, but you
+are encouraged to <em>publish any patch you make</em>. In this case the
+best way to proceed is to send your patches to the ffmpeg-devel
+mailing list following the guidelines illustrated in the remainder of
+this document.
+</p>
+<p>For more detailed legal information about the use of FFmpeg in
+external programs read the <samp>LICENSE</samp> file in the source tree and
+consult <a href="https://ffmpeg.org/legal.html">https://ffmpeg.org/legal.html</a>.
+</p>
+<a name="Contributing"></a>
+<h2 class="chapter">2 Contributing<span class="pull-right"><a class="anchor hidden-xs" href="#Contributing" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Contributing" aria-hidden="true">TOC</a></span></h2>
+
+<p>There are 2 ways by which code gets into FFmpeg:
+</p><ul>
+<li> Submitting patches to the ffmpeg-devel mailing list.
+      See <a href="#Submitting-patches">Submitting patches</a> for details.
+</li><li> Directly committing changes to the main tree.
+</li></ul>
+
+<p>Whichever way, changes should be reviewed by the maintainer of the code
+before they are committed. And they should follow the <a href="#Coding-Rules">Coding Rules</a>.
+The developer making the commit and the author are responsible for their changes
+and should try to fix issues their commit causes.
+</p>
+<span id="Coding-Rules"></span><a name="Coding-Rules-1"></a>
+<h2 class="chapter">3 Coding Rules<span class="pull-right"><a class="anchor hidden-xs" href="#Coding-Rules-1" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Coding-Rules-1" aria-hidden="true">TOC</a></span></h2>
+
+<a name="Code-formatting-conventions"></a>
+<h3 class="section">3.1 Code formatting conventions<span class="pull-right"><a class="anchor hidden-xs" href="#Code-formatting-conventions" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Code-formatting-conventions" aria-hidden="true">TOC</a></span></h3>
+
+<p>There are the following guidelines regarding the indentation in files:
+</p>
+<ul>
+<li> Indent size is 4.
+
+</li><li> The TAB character is forbidden outside of Makefiles as is any
+form of trailing whitespace. Commits containing either will be
+rejected by the git repository.
+
+</li><li> You should try to limit your code lines to 80 characters; however, do so if
+and only if this improves readability.
+
+</li><li> K&amp;R coding style is used.
+</li></ul>
+<p>The presentation is one inspired by &rsquo;indent -i4 -kr -nut&rsquo;.
+</p>
+<p>The main priority in FFmpeg is simplicity and small code size in order to
+minimize the bug count.
+</p>
+<a name="Comments"></a>
+<h3 class="section">3.2 Comments<span class="pull-right"><a class="anchor hidden-xs" href="#Comments" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Comments" aria-hidden="true">TOC</a></span></h3>
+<p>Use the JavaDoc/Doxygen  format (see examples below) so that code documentation
+can be generated automatically. All nontrivial functions should have a comment
+above them explaining what the function does, even if it is just one sentence.
+All structures and their member variables should be documented, too.
+</p>
+<p>Avoid Qt-style and similar Doxygen syntax with <code>!</code> in it, i.e. replace
+<code>//!</code> with <code>///</code> and similar.  Also @ syntax should be employed
+for markup commands, i.e. use <code>@param</code> and not <code>\param</code>.
+</p>
+<div class="example">
+<pre class="example">/**
+ * @file
+ * MPEG codec.
+ * @author ...
+ */
+
+/**
+ * Summary sentence.
+ * more text ...
+ * ...
+ */
+typedef struct Foobar {
+    int var1; /**&lt; var1 description */
+    int var2; ///&lt; var2 description
+    /** var3 description */
+    int var3;
+} Foobar;
+
+/**
+ * Summary sentence.
+ * more text ...
+ * ...
+ * @param my_parameter description of my_parameter
+ * @return return value description
+ */
+int myfunc(int my_parameter)
+...
+</pre></div>
+
+<a name="C-language-features"></a>
+<h3 class="section">3.3 C language features<span class="pull-right"><a class="anchor hidden-xs" href="#C-language-features" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-C-language-features" aria-hidden="true">TOC</a></span></h3>
+
+<p>FFmpeg is programmed in the ISO C90 language with a few additional
+features from ISO C99, namely:
+</p>
+<ul>
+<li> the &lsquo;<samp>inline</samp>&rsquo; keyword;
+
+</li><li> &lsquo;<samp>//</samp>&rsquo; comments;
+
+</li><li> designated struct initializers (&lsquo;<samp>struct s x = { .i = 17 };</samp>&rsquo;);
+
+</li><li> compound literals (&lsquo;<samp>x = (struct s) { 17, 23 };</samp>&rsquo;).
+
+</li><li> for loops with variable definition (&lsquo;<samp>for (int i = 0; i &lt; 8; i++)</samp>&rsquo;);
+
+</li><li> Variadic macros (&lsquo;<samp>#define ARRAY(nb, ...) (int[nb + 1]){ nb, __VA_ARGS__ }</samp>&rsquo;);
+
+</li><li> Implementation defined behavior for signed integers is assumed to match the
+expected behavior for two&rsquo;s complement. Non representable values in integer
+casts are binary truncated. Shift right of signed values uses sign extension.
+</li></ul>
+
+<p>These features are supported by all compilers we care about, so we will not
+accept patches to remove their use unless they absolutely do not impair
+clarity and performance.
+</p>
+<p>All code must compile with recent versions of GCC and a number of other
+currently supported compilers. To ensure compatibility, please do not use
+additional C99 features or GCC extensions. Especially watch out for:
+</p>
+<ul>
+<li> mixing statements and declarations;
+
+</li><li> &lsquo;<samp>long long</samp>&rsquo; (use &lsquo;<samp>int64_t</samp>&rsquo; instead);
+
+</li><li> &lsquo;<samp>__attribute__</samp>&rsquo; not protected by &lsquo;<samp>#ifdef __GNUC__</samp>&rsquo; or similar;
+
+</li><li> GCC statement expressions (&lsquo;<samp>(x = ({ int y = 4; y; })</samp>&rsquo;).
+</li></ul>
+
+<a name="Naming-conventions"></a>
+<h3 class="section">3.4 Naming conventions<span class="pull-right"><a class="anchor hidden-xs" href="#Naming-conventions" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Naming-conventions" aria-hidden="true">TOC</a></span></h3>
+<p>All names should be composed with underscores (_), not CamelCase. For example,
+&lsquo;<samp>avfilter_get_video_buffer</samp>&rsquo; is an acceptable function name and
+&lsquo;<samp>AVFilterGetVideo</samp>&rsquo; is not. The exception from this are type names, like
+for example structs and enums; they should always be in CamelCase.
+</p>
+<p>There are the following conventions for naming variables and functions:
+</p>
+<ul>
+<li> For local variables no prefix is required.
+
+</li><li> For file-scope variables and functions declared as <code>static</code>, no prefix
+is required.
+
+</li><li> For variables and functions visible outside of file scope, but only used
+internally by a library, an <code>ff_</code> prefix should be used,
+e.g. &lsquo;<samp>ff_w64_demuxer</samp>&rsquo;.
+
+</li><li> For variables and functions visible outside of file scope, used internally
+across multiple libraries, use <code>avpriv_</code> as prefix, for example,
+&lsquo;<samp>avpriv_report_missing_feature</samp>&rsquo;.
+
+</li><li> Each library has its own prefix for public symbols, in addition to the
+commonly used <code>av_</code> (<code>avformat_</code> for libavformat,
+<code>avcodec_</code> for libavcodec, <code>swr_</code> for libswresample, etc).
+Check the existing code and choose names accordingly.
+Note that some symbols without these prefixes are also exported for
+retro-compatibility reasons. These exceptions are declared in the
+<code>lib&lt;name&gt;/lib&lt;name&gt;.v</code> files.
+</li></ul>
+
+<p>Furthermore, name space reserved for the system should not be invaded.
+Identifiers ending in <code>_t</code> are reserved by
+<a href="http://pubs.opengroup.org/onlinepubs/007904975/functions/xsh_chap02_02.html#tag_02_02_02">POSIX</a>.
+Also avoid names starting with <code>__</code> or <code>_</code> followed by an uppercase
+letter as they are reserved by the C standard. Names starting with <code>_</code>
+are reserved at the file level and may not be used for externally visible
+symbols. If in doubt, just avoid names starting with <code>_</code> altogether.
+</p>
+<a name="Miscellaneous-conventions"></a>
+<h3 class="section">3.5 Miscellaneous conventions<span class="pull-right"><a class="anchor hidden-xs" href="#Miscellaneous-conventions" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Miscellaneous-conventions" aria-hidden="true">TOC</a></span></h3>
+
+<ul>
+<li> fprintf and printf are forbidden in libavformat and libavcodec,
+please use av_log() instead.
+
+</li><li> Casts should be used only when necessary. Unneeded parentheses
+should also be avoided if they don&rsquo;t make the code easier to understand.
+</li></ul>
+
+<a name="Editor-configuration"></a>
+<h3 class="section">3.6 Editor configuration<span class="pull-right"><a class="anchor hidden-xs" href="#Editor-configuration" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Editor-configuration" aria-hidden="true">TOC</a></span></h3>
+<p>In order to configure Vim to follow FFmpeg formatting conventions, paste
+the following snippet into your <samp>.vimrc</samp>:
+</p><div class="example">
+<pre class="example">&quot; indentation rules for FFmpeg: 4 spaces, no tabs
+set expandtab
+set shiftwidth=4
+set softtabstop=4
+set cindent
+set cinoptions=(0
+&quot; Allow tabs in Makefiles.
+autocmd FileType make,automake set noexpandtab shiftwidth=8 softtabstop=8
+&quot; Trailing whitespace and tabs are forbidden, so highlight them.
+highlight ForbiddenWhitespace ctermbg=red guibg=red
+match ForbiddenWhitespace /\s\+$\|\t/
+&quot; Do not highlight spaces at the end of line while typing on that line.
+autocmd InsertEnter * match ForbiddenWhitespace /\t\|\s\+\%#\@&lt;!$/
+</pre></div>
+
+<p>For Emacs, add these roughly equivalent lines to your <samp>.emacs.d/init.el</samp>:
+</p><div class="lisp">
+<pre class="lisp">(c-add-style &quot;ffmpeg&quot;
+             '(&quot;k&amp;r&quot;
+               (c-basic-offset . 4)
+               (indent-tabs-mode . nil)
+               (show-trailing-whitespace . t)
+               (c-offsets-alist
+                (statement-cont . (c-lineup-assignments +)))
+               )
+             )
+(setq c-default-style &quot;ffmpeg&quot;)
+</pre></div>
+
+<a name="Development-Policy"></a>
+<h2 class="chapter">4 Development Policy<span class="pull-right"><a class="anchor hidden-xs" href="#Development-Policy" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Development-Policy" aria-hidden="true">TOC</a></span></h2>
+
+<a name="Patches_002fCommitting"></a>
+<h3 class="section">4.1 Patches/Committing<span class="pull-right"><a class="anchor hidden-xs" href="#Patches_002fCommitting" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Patches_002fCommitting" aria-hidden="true">TOC</a></span></h3>
+<a name="Licenses-for-patches-must-be-compatible-with-FFmpeg_002e"></a>
+<p>Contributions should be licensed under the
+<a href="http://www.gnu.org/licenses/lgpl-2.1.html">LGPL 2.1</a>,
+including an &quot;or any later version&quot; clause, or, if you prefer
+a gift-style license, the
+<a href="http://opensource.org/licenses/isc-license.txt">ISC</a> or
+<a href="http://mit-license.org/">MIT</a> license.
+<a href="http://www.gnu.org/licenses/gpl-2.0.html">GPL 2</a> including
+an &quot;or any later version&quot; clause is also acceptable, but LGPL is
+preferred.
+If you add a new file, give it a proper license header. Do not copy and
+paste it from a random place, use an existing file as template.
+</p>
+<a name="You-must-not-commit-code-which-breaks-FFmpeg_0021"></a>
+<p>This means unfinished code which is enabled and breaks compilation,
+or compiles but does not work/breaks the regression tests. Code which
+is unfinished but disabled may be permitted under-circumstances, like
+missing samples or an implementation with a small subset of features.
+Always check the mailing list for any reviewers with issues and test
+FATE before you push.
+</p>
+<a name="Keep-the-main-commit-message-short-with-an-extended-description-below_002e"></a>
+<p>The commit message should have a short first line in the form of
+a &lsquo;<samp>topic: short description</samp>&rsquo; as a header, separated by a newline
+from the body consisting of an explanation of why the change is necessary.
+If the commit fixes a known bug on the bug tracker, the commit message
+should include its bug ID. Referring to the issue on the bug tracker does
+not exempt you from writing an excerpt of the bug in the commit message.
+</p>
+<a name="Testing-must-be-adequate-but-not-excessive_002e"></a>
+<p>If it works for you, others, and passes FATE then it should be OK to commit
+it, provided it fits the other committing criteria. You should not worry about
+over-testing things. If your code has problems (portability, triggers
+compiler bugs, unusual environment etc) they will be reported and eventually
+fixed.
+</p>
+<a name="Do-not-commit-unrelated-changes-together_002e"></a>
+<p>They should be split them into self-contained pieces. Also do not forget
+that if part B depends on part A, but A does not depend on B, then A can
+and should be committed first and separate from B. Keeping changes well
+split into self-contained parts makes reviewing and understanding them on
+the commit log mailing list easier. This also helps in case of debugging
+later on.
+Also if you have doubts about splitting or not splitting, do not hesitate to
+ask/discuss it on the developer mailing list.
+</p>
+<a name="Ask-before-you-change-the-build-system-_0028configure_002c-etc_0029_002e"></a>
+<p>Do not commit changes to the build system (Makefiles, configure script)
+which change behavior, defaults etc, without asking first. The same
+applies to compiler warning fixes, trivial looking fixes and to code
+maintained by other developers. We usually have a reason for doing things
+the way we do. Send your changes as patches to the ffmpeg-devel mailing
+list, and if the code maintainers say OK, you may commit. This does not
+apply to files you wrote and/or maintain.
+</p>
+<a name="Cosmetic-changes-should-be-kept-in-separate-patches_002e"></a>
+<p>We refuse source indentation and other cosmetic changes if they are mixed
+with functional changes, such commits will be rejected and removed. Every
+developer has his own indentation style, you should not change it. Of course
+if you (re)write something, you can use your own style, even though we would
+prefer if the indentation throughout FFmpeg was consistent (Many projects
+force a given indentation style - we do not.). If you really need to make
+indentation changes (try to avoid this), separate them strictly from real
+changes.
+</p>
+<p>NOTE: If you had to put if(){ .. } over a large (&gt; 5 lines) chunk of code,
+then either do NOT change the indentation of the inner part within (do not
+move it to the right)! or do so in a separate commit
+</p>
+<a name="Commit-messages-should-always-be-filled-out-properly_002e"></a>
+<p>Always fill out the commit log message. Describe in a few lines what you
+changed and why. You can refer to mailing list postings if you fix a
+particular bug. Comments such as &quot;fixed!&quot; or &quot;Changed it.&quot; are unacceptable.
+Recommended format:
+</p>
+<div class="example">
+<pre class="example">area changed: Short 1 line description
+
+details describing what and why and giving references.
+</pre></div>
+
+<a name="Credit-the-author-of-the-patch_002e"></a>
+<p>Make sure the author of the commit is set correctly. (see git commit &ndash;author)
+If you apply a patch, send an
+answer to ffmpeg-devel (or wherever you got the patch from) saying that
+you applied the patch.
+</p>
+<a name="Complex-patches-should-refer-to-discussion-surrounding-them_002e"></a>
+<p>When applying patches that have been discussed (at length) on the mailing
+list, reference the thread in the log message.
+</p>
+<a name="Always-wait-long-enough-before-pushing-changes"></a>
+<p>Do NOT commit to code actively maintained by others without permission.
+Send a patch to ffmpeg-devel. If no one answers within a reasonable
+time-frame (12h for build failures and security fixes, 3 days small changes,
+1 week for big patches) then commit your patch if you think it is OK.
+Also note, the maintainer can simply ask for more time to review!
+</p>
+<a name="Code"></a>
+<h3 class="section">4.2 Code<span class="pull-right"><a class="anchor hidden-xs" href="#Code" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Code" aria-hidden="true">TOC</a></span></h3>
+<a name="API_002fABI-changes-should-be-discussed-before-they-are-made_002e"></a>
+<p>Do not change behavior of the programs (renaming options etc) or public
+API or ABI without first discussing it on the ffmpeg-devel mailing list.
+Do not remove widely used functionality or features (redundant code can be removed).
+</p>
+<a name="Remember-to-check-if-you-need-to-bump-versions-for-libav_002a_002e"></a>
+<p>Depending on the change, you may need to change the version integer.
+Incrementing the first component means no backward compatibility to
+previous versions (e.g. removal of a function from the public API).
+Incrementing the second component means backward compatible change
+(e.g. addition of a function to the public API or extension of an
+existing data structure).
+Incrementing the third component means a noteworthy binary compatible
+change (e.g. encoder bug fix that matters for the decoder). The third
+component always starts at 100 to distinguish FFmpeg from Libav.
+</p>
+<a name="Warnings-for-correct-code-may-be-disabled-if-there-is-no-other-option_002e"></a>
+<p>Compiler warnings indicate potential bugs or code with bad style. If a type of
+warning always points to correct and clean code, that warning should
+be disabled, not the code changed.
+Thus the remaining warnings can either be bugs or correct code.
+If it is a bug, the bug has to be fixed. If it is not, the code should
+be changed to not generate a warning unless that causes a slowdown
+or obfuscates the code.
+</p>
+<a name="Check-untrusted-input-properly_002e"></a>
+<p>Never write to unallocated memory, never write over the end of arrays,
+always check values read from some untrusted source before using them
+as array index or other risky things.
+</p>
+<a name="Documentation_002fOther"></a>
+<h3 class="section">4.3 Documentation/Other<span class="pull-right"><a class="anchor hidden-xs" href="#Documentation_002fOther" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Documentation_002fOther" aria-hidden="true">TOC</a></span></h3>
+<a name="Subscribe-to-the-ffmpeg_002ddevel-mailing-list_002e"></a>
+<p>It is important to be subscribed to the
+<a href="https://lists.ffmpeg.org/mailman/listinfo/ffmpeg-devel">ffmpeg-devel</a>
+mailing list. Almost any non-trivial patch is to be sent there for review.
+Other developers may have comments about your contribution. We expect you see
+those comments, and to improve it if requested. (N.B. Experienced committers
+have other channels, and may sometimes skip review for trivial fixes.) Also,
+discussion here about bug fixes and FFmpeg improvements by other developers may
+be helpful information for you. Finally, by being a list subscriber, your
+contribution will be posted immediately to the list, without the moderation
+hold which messages from non-subscribers experience.
+</p>
+<p>However, it is more important to the project that we receive your patch than
+that you be subscribed to the ffmpeg-devel list. If you have a patch, and don&rsquo;t
+want to subscribe and discuss the patch, then please do send it to the list
+anyway.
+</p>
+<a name="Subscribe-to-the-ffmpeg_002dcvslog-mailing-list_002e"></a>
+<p>Diffs of all commits are sent to the
+<a href="https://lists.ffmpeg.org/mailman/listinfo/ffmpeg-cvslog">ffmpeg-cvslog</a>
+mailing list. Some developers read this list to review all code base changes
+from all sources. Subscribing to this list is not mandatory.
+</p>
+<a name="Keep-the-documentation-up-to-date_002e"></a>
+<p>Update the documentation if you change behavior or add features. If you are
+unsure how best to do this, send a patch to ffmpeg-devel, the documentation
+maintainer(s) will review and commit your stuff.
+</p>
+<a name="Important-discussions-should-be-accessible-to-all_002e"></a>
+<p>Try to keep important discussions and requests (also) on the public
+developer mailing list, so that all developers can benefit from them.
+</p>
+<a name="Check-your-entries-in-MAINTAINERS_002e"></a>
+<p>Make sure that no parts of the codebase that you maintain are missing from the
+<samp>MAINTAINERS</samp> file. If something that you want to maintain is missing add it with
+your name after it.
+If at some point you no longer want to maintain some code, then please help in
+finding a new maintainer and also don&rsquo;t forget to update the <samp>MAINTAINERS</samp> file.
+</p>
+<p>We think our rules are not too hard. If you have comments, contact us.
+</p>
+<a name="Code-of-conduct"></a>
+<h2 class="chapter">5 Code of conduct<span class="pull-right"><a class="anchor hidden-xs" href="#Code-of-conduct" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Code-of-conduct" aria-hidden="true">TOC</a></span></h2>
+
+<p>Be friendly and respectful towards others and third parties.
+Treat others the way you yourself want to be treated.
+</p>
+<p>Be considerate. Not everyone shares the same viewpoint and priorities as you do.
+Different opinions and interpretations help the project.
+Looking at issues from a different perspective assists development.
+</p>
+<p>Do not assume malice for things that can be attributed to incompetence. Even if
+it is malice, it&rsquo;s rarely good to start with that as initial assumption.
+</p>
+<p>Stay friendly even if someone acts contrarily. Everyone has a bad day
+once in a while.
+If you yourself have a bad day or are angry then try to take a break and reply
+once you are calm and without anger if you have to.
+</p>
+<p>Try to help other team members and cooperate if you can.
+</p>
+<p>The goal of software development is to create technical excellence, not for any
+individual to be better and &quot;win&quot; against the others. Large software projects
+are only possible and successful through teamwork.
+</p>
+<p>If someone struggles do not put them down. Give them a helping hand
+instead and point them in the right direction.
+</p>
+<p>Finally, keep in mind the immortal words of Bill and Ted,
+&quot;Be excellent to each other.&quot;
+</p>
+<span id="Submitting-patches"></span><a name="Submitting-patches-1"></a>
+<h2 class="chapter">6 Submitting patches<span class="pull-right"><a class="anchor hidden-xs" href="#Submitting-patches-1" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Submitting-patches-1" aria-hidden="true">TOC</a></span></h2>
+
+<p>First, read the <a href="#Coding-Rules">Coding Rules</a> above if you did not yet, in particular
+the rules regarding patch submission.
+</p>
+<p>When you submit your patch, please use <code>git format-patch</code> or
+<code>git send-email</code>. We cannot read other diffs :-).
+</p>
+<p>Also please do not submit a patch which contains several unrelated changes.
+Split it into separate, self-contained pieces. This does not mean splitting
+file by file. Instead, make the patch as small as possible while still
+keeping it as a logical unit that contains an individual change, even
+if it spans multiple files. This makes reviewing your patches much easier
+for us and greatly increases your chances of getting your patch applied.
+</p>
+<p>Use the patcheck tool of FFmpeg to check your patch.
+The tool is located in the tools directory.
+</p>
+<p>Run the <a href="#Regression-tests">Regression tests</a> before submitting a patch in order to verify
+it does not cause unexpected problems.
+</p>
+<p>It also helps quite a bit if you tell us what the patch does (for example
+&rsquo;replaces lrint by lrintf&rsquo;), and why (for example &rsquo;*BSD isn&rsquo;t C99 compliant
+and has no lrint()&rsquo;)
+</p>
+<p>Also please if you send several patches, send each patch as a separate mail,
+do not attach several unrelated patches to the same mail.
+</p>
+<p>Patches should be posted to the
+<a href="https://lists.ffmpeg.org/mailman/listinfo/ffmpeg-devel">ffmpeg-devel</a>
+mailing list. Use <code>git send-email</code> when possible since it will properly
+send patches without requiring extra care. If you cannot, then send patches
+as base64-encoded attachments, so your patch is not trashed during
+transmission. Also ensure the correct mime type is used
+(text/x-diff or text/x-patch or at least text/plain) and that only one
+patch is inline or attached per mail.
+You can check <a href="https://patchwork.ffmpeg.org">https://patchwork.ffmpeg.org</a>, if your patch does not show up, its mime type
+likely was wrong.
+</p>
+<p>Your patch will be reviewed on the mailing list. You will likely be asked
+to make some changes and are expected to send in an improved version that
+incorporates the requests from the review. This process may go through
+several iterations. Once your patch is deemed good enough, some developer
+will pick it up and commit it to the official FFmpeg tree.
+</p>
+<p>Give us a few days to react. But if some time passes without reaction,
+send a reminder by email. Your patch should eventually be dealt with.
+</p>
+
+<a name="New-codecs-or-formats-checklist"></a>
+<h2 class="chapter">7 New codecs or formats checklist<span class="pull-right"><a class="anchor hidden-xs" href="#New-codecs-or-formats-checklist" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-New-codecs-or-formats-checklist" aria-hidden="true">TOC</a></span></h2>
+
+<ol>
+<li> Did you use av_cold for codec initialization and close functions?
+
+</li><li> Did you add a long_name under NULL_IF_CONFIG_SMALL to the AVCodec or
+AVInputFormat/AVOutputFormat struct?
+
+</li><li> Did you bump the minor version number (and reset the micro version
+number) in <samp>libavcodec/version.h</samp> or <samp>libavformat/version.h</samp>?
+
+</li><li> Did you register it in <samp>allcodecs.c</samp> or <samp>allformats.c</samp>?
+
+</li><li> Did you add the AVCodecID to <samp>avcodec.h</samp>?
+When adding new codec IDs, also add an entry to the codec descriptor
+list in <samp>libavcodec/codec_desc.c</samp>.
+
+</li><li> If it has a FourCC, did you add it to <samp>libavformat/riff.c</samp>,
+even if it is only a decoder?
+
+</li><li> Did you add a rule to compile the appropriate files in the Makefile?
+Remember to do this even if you&rsquo;re just adding a format to a file that is
+already being compiled by some other rule, like a raw demuxer.
+
+</li><li> Did you add an entry to the table of supported formats or codecs in
+<samp>doc/general.texi</samp>?
+
+</li><li> Did you add an entry in the Changelog?
+
+</li><li> If it depends on a parser or a library, did you add that dependency in
+configure?
+
+</li><li> Did you <code>git add</code> the appropriate files before committing?
+
+</li><li> Did you make sure it compiles standalone, i.e. with
+<code>configure --disable-everything --enable-decoder=foo</code>
+(or <code>--enable-demuxer</code> or whatever your component is)?
+</li></ol>
+
+
+<a name="Patch-submission-checklist"></a>
+<h2 class="chapter">8 Patch submission checklist<span class="pull-right"><a class="anchor hidden-xs" href="#Patch-submission-checklist" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Patch-submission-checklist" aria-hidden="true">TOC</a></span></h2>
+
+<ol>
+<li> Does <code>make fate</code> pass with the patch applied?
+
+</li><li> Was the patch generated with git format-patch or send-email?
+
+</li><li> Did you sign-off your patch? (<code>git commit -s</code>)
+See <a href="https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/plain/Documentation/process/submitting-patches.rst">Sign your work</a> for the meaning
+of <em>sign-off</em>.
+
+</li><li> Did you provide a clear git commit log message?
+
+</li><li> Is the patch against latest FFmpeg git master branch?
+
+</li><li> Are you subscribed to ffmpeg-devel?
+(the list is subscribers only due to spam)
+
+</li><li> Have you checked that the changes are minimal, so that the same cannot be
+achieved with a smaller patch and/or simpler final code?
+
+</li><li> If the change is to speed critical code, did you benchmark it?
+
+</li><li> If you did any benchmarks, did you provide them in the mail?
+
+</li><li> Have you checked that the patch does not introduce buffer overflows or
+other security issues?
+
+</li><li> Did you test your decoder or demuxer against damaged data? If no, see
+tools/trasher, the noise bitstream filter, and
+<a href="http://caca.zoy.org/wiki/zzuf">zzuf</a>. Your decoder or demuxer
+should not crash, end in a (near) infinite loop, or allocate ridiculous
+amounts of memory when fed damaged data.
+
+</li><li> Did you test your decoder or demuxer against sample files?
+Samples may be obtained at <a href="https://samples.ffmpeg.org">https://samples.ffmpeg.org</a>.
+
+</li><li> Does the patch not mix functional and cosmetic changes?
+
+</li><li> Did you add tabs or trailing whitespace to the code? Both are forbidden.
+
+</li><li> Is the patch attached to the email you send?
+
+</li><li> Is the mime type of the patch correct? It should be text/x-diff or
+text/x-patch or at least text/plain and not application/octet-stream.
+
+</li><li> If the patch fixes a bug, did you provide a verbose analysis of the bug?
+
+</li><li> If the patch fixes a bug, did you provide enough information, including
+a sample, so the bug can be reproduced and the fix can be verified?
+Note please do not attach samples &gt;100k to mails but rather provide a
+URL, you can upload to <a href="https://streams.videolan.org/upload/">https://streams.videolan.org/upload/</a>.
+
+</li><li> Did you provide a verbose summary about what the patch does change?
+
+</li><li> Did you provide a verbose explanation why it changes things like it does?
+
+</li><li> Did you provide a verbose summary of the user visible advantages and
+disadvantages if the patch is applied?
+
+</li><li> Did you provide an example so we can verify the new feature added by the
+patch easily?
+
+</li><li> If you added a new file, did you insert a license header? It should be
+taken from FFmpeg, not randomly copied and pasted from somewhere else.
+
+</li><li> You should maintain alphabetical order in alphabetically ordered lists as
+long as doing so does not break API/ABI compatibility.
+
+</li><li> Lines with similar content should be aligned vertically when doing so
+improves readability.
+
+</li><li> Consider adding a regression test for your code.
+
+</li><li> If you added YASM code please check that things still work with &ndash;disable-yasm.
+
+</li><li> Make sure you check the return values of function and return appropriate
+error codes. Especially memory allocation functions like <code>av_malloc()</code>
+are notoriously left unchecked, which is a serious problem.
+
+</li><li> Test your code with valgrind and or Address Sanitizer to ensure it&rsquo;s free
+of leaks, out of array accesses, etc.
+</li></ol>
+
+<a name="Patch-review-process"></a>
+<h2 class="chapter">9 Patch review process<span class="pull-right"><a class="anchor hidden-xs" href="#Patch-review-process" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Patch-review-process" aria-hidden="true">TOC</a></span></h2>
+
+<p>All patches posted to ffmpeg-devel will be reviewed, unless they contain a
+clear note that the patch is not for the git master branch.
+Reviews and comments will be posted as replies to the patch on the
+mailing list. The patch submitter then has to take care of every comment,
+that can be by resubmitting a changed patch or by discussion. Resubmitted
+patches will themselves be reviewed like any other patch. If at some point
+a patch passes review with no comments then it is approved, that can for
+simple and small patches happen immediately while large patches will generally
+have to be changed and reviewed many times before they are approved.
+After a patch is approved it will be committed to the repository.
+</p>
+<p>We will review all submitted patches, but sometimes we are quite busy so
+especially for large patches this can take several weeks.
+</p>
+<p>If you feel that the review process is too slow and you are willing to try to
+take over maintainership of the area of code you change then just clone
+git master and maintain the area of code there. We will merge each area from
+where its best maintained.
+</p>
+<p>When resubmitting patches, please do not make any significant changes
+not related to the comments received during review. Such patches will
+be rejected. Instead, submit significant changes or new features as
+separate patches.
+</p>
+<p>Everyone is welcome to review patches. Also if you are waiting for your patch
+to be reviewed, please consider helping to review other patches, that is a great
+way to get everyone&rsquo;s patches reviewed sooner.
+</p>
+<span id="Regression-tests"></span><a name="Regression-tests-1"></a>
+<h2 class="chapter">10 Regression tests<span class="pull-right"><a class="anchor hidden-xs" href="#Regression-tests-1" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Regression-tests-1" aria-hidden="true">TOC</a></span></h2>
+
+<p>Before submitting a patch (or committing to the repository), you should at least
+test that you did not break anything.
+</p>
+<p>Running &rsquo;make fate&rsquo; accomplishes this, please see <a href="fate.html">fate.html</a> for details.
+</p>
+<p>[Of course, some patches may change the results of the regression tests. In
+this case, the reference results of the regression tests shall be modified
+accordingly].
+</p>
+<a name="Adding-files-to-the-fate_002dsuite-dataset"></a>
+<h3 class="section">10.1 Adding files to the fate-suite dataset<span class="pull-right"><a class="anchor hidden-xs" href="#Adding-files-to-the-fate_002dsuite-dataset" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Adding-files-to-the-fate_002dsuite-dataset" aria-hidden="true">TOC</a></span></h3>
+
+<p>When there is no muxer or encoder available to generate test media for a
+specific test then the media has to be included in the fate-suite.
+First please make sure that the sample file is as small as possible to test the
+respective decoder or demuxer sufficiently. Large files increase network
+bandwidth and disk space requirements.
+Once you have a working fate test and fate sample, provide in the commit
+message or introductory message for the patch series that you post to
+the ffmpeg-devel mailing list, a direct link to download the sample media.
+</p>
+<a name="Visualizing-Test-Coverage"></a>
+<h3 class="section">10.2 Visualizing Test Coverage<span class="pull-right"><a class="anchor hidden-xs" href="#Visualizing-Test-Coverage" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Visualizing-Test-Coverage" aria-hidden="true">TOC</a></span></h3>
+
+<p>The FFmpeg build system allows visualizing the test coverage in an easy
+manner with the coverage tools <code>gcov</code>/<code>lcov</code>.  This involves
+the following steps:
+</p>
+<ol>
+<li> Configure to compile with instrumentation enabled:
+    <code>configure --toolchain=gcov</code>.
+
+</li><li> Run your test case, either manually or via FATE. This can be either
+    the full FATE regression suite, or any arbitrary invocation of any
+    front-end tool provided by FFmpeg, in any combination.
+
+</li><li> Run <code>make lcov</code> to generate coverage data in HTML format.
+
+</li><li> View <code>lcov/index.html</code> in your preferred HTML viewer.
+</li></ol>
+
+<p>You can use the command <code>make lcov-reset</code> to reset the coverage
+measurements. You will need to rerun <code>make lcov</code> after running a
+new test.
+</p>
+<a name="Using-Valgrind"></a>
+<h3 class="section">10.3 Using Valgrind<span class="pull-right"><a class="anchor hidden-xs" href="#Using-Valgrind" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Using-Valgrind" aria-hidden="true">TOC</a></span></h3>
+
+<p>The configure script provides a shortcut for using valgrind to spot bugs
+related to memory handling. Just add the option
+<code>--toolchain=valgrind-memcheck</code> or <code>--toolchain=valgrind-massif</code>
+to your configure line, and reasonable defaults will be set for running
+FATE under the supervision of either the <strong>memcheck</strong> or the
+<strong>massif</strong> tool of the valgrind suite.
+</p>
+<p>In case you need finer control over how valgrind is invoked, use the
+<code>--target-exec='valgrind &lt;your_custom_valgrind_options&gt;</code> option in
+your configure line instead.
+</p>
+<span id="Release-process"></span><a name="Release-process-1"></a>
+<h2 class="chapter">11 Release process<span class="pull-right"><a class="anchor hidden-xs" href="#Release-process-1" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Release-process-1" aria-hidden="true">TOC</a></span></h2>
+
+<p>FFmpeg maintains a set of <strong>release branches</strong>, which are the
+recommended deliverable for system integrators and distributors (such as
+Linux distributions, etc.). At regular times, a <strong>release
+manager</strong> prepares, tests and publishes tarballs on the
+<a href="https://ffmpeg.org">https://ffmpeg.org</a> website.
+</p>
+<p>There are two kinds of releases:
+</p>
+<ol>
+<li> <strong>Major releases</strong> always include the latest and greatest
+features and functionality.
+
+</li><li> <strong>Point releases</strong> are cut from <strong>release</strong> branches,
+which are named <code>release/X</code>, with <code>X</code> being the release
+version number.
+</li></ol>
+
+<p>Note that we promise to our users that shared libraries from any FFmpeg
+release never break programs that have been <strong>compiled</strong> against
+previous versions of <strong>the same release series</strong> in any case!
+</p>
+<p>However, from time to time, we do make API changes that require adaptations
+in applications. Such changes are only allowed in (new) major releases and
+require further steps such as bumping library version numbers and/or
+adjustments to the symbol versioning file. Please discuss such changes
+on the <strong>ffmpeg-devel</strong> mailing list in time to allow forward planning.
+</p>
+<span id="Criteria-for-Point-Releases"></span><a name="Criteria-for-Point-Releases-1"></a>
+<h3 class="section">11.1 Criteria for Point Releases<span class="pull-right"><a class="anchor hidden-xs" href="#Criteria-for-Point-Releases-1" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Criteria-for-Point-Releases-1" aria-hidden="true">TOC</a></span></h3>
+
+<p>Changes that match the following criteria are valid candidates for
+inclusion into a point release:
+</p>
+<ol>
+<li> Fixes a security issue, preferably identified by a <strong>CVE
+number</strong> issued by <a href="http://cve.mitre.org/">http://cve.mitre.org/</a>.
+
+</li><li> Fixes a documented bug in <a href="https://trac.ffmpeg.org">https://trac.ffmpeg.org</a>.
+
+</li><li> Improves the included documentation.
+
+</li><li> Retains both source code and binary compatibility with previous
+point releases of the same release branch.
+</li></ol>
+
+<p>The order for checking the rules is (1 OR 2 OR 3) AND 4.
+</p>
+
+<a name="Release-Checklist"></a>
+<h3 class="section">11.2 Release Checklist<span class="pull-right"><a class="anchor hidden-xs" href="#Release-Checklist" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Release-Checklist" aria-hidden="true">TOC</a></span></h3>
+
+<p>The release process involves the following steps:
+</p>
+<ol>
+<li> Ensure that the <samp>RELEASE</samp> file contains the version number for
+the upcoming release.
+
+</li><li> Add the release at <a href="https://trac.ffmpeg.org/admin/ticket/versions">https://trac.ffmpeg.org/admin/ticket/versions</a>.
+
+</li><li> Announce the intent to do a release to the mailing list.
+
+</li><li> Make sure all relevant security fixes have been backported. See
+<a href="https://ffmpeg.org/security.html">https://ffmpeg.org/security.html</a>.
+
+</li><li> Ensure that the FATE regression suite still passes in the release
+branch on at least <strong>i386</strong> and <strong>amd64</strong>
+(cf. <a href="#Regression-tests">Regression tests</a>).
+
+</li><li> Prepare the release tarballs in <code>bz2</code> and <code>gz</code> formats, and
+supplementing files that contain <code>gpg</code> signatures
+
+</li><li> Publish the tarballs at <a href="https://ffmpeg.org/releases">https://ffmpeg.org/releases</a>. Create and
+push an annotated tag in the form <code>nX</code>, with <code>X</code>
+containing the version number.
+
+</li><li> Propose and send a patch to the <strong>ffmpeg-devel</strong> mailing list
+with a news entry for the website.
+
+</li><li> Publish the news entry.
+
+</li><li> Send an announcement to the mailing list.
+</li></ol>
+
+
+      <p style="font-size: small;">
+        This document was generated using <a href="http://www.gnu.org/software/texinfo/"><em>makeinfo</em></a>.
+      </p>
+    </div>
+  </body>
+</html>

ffmpeg-n4.3.2-win64-gpl-shared-4.3/doc/faq.html

@@ -0,0 +1,824 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
+  <head>
+    <meta charset="utf-8">
+    <title>
+      FFmpeg FAQ
+    </title>
+    <meta name="viewport" content="width=device-width,initial-scale=1.0">
+    <link rel="stylesheet" type="text/css" href="bootstrap.min.css">
+    <link rel="stylesheet" type="text/css" href="style.min.css">
+  </head>
+  <body>
+    <div class="container">
+      <h1>
+      FFmpeg FAQ
+      </h1>
+<div align="center">
+</div>
+
+
+<a name="SEC_Top"></a>
+
+<span id="SEC_Contents"></span>
+<h2 class="contents-heading">Table of Contents</h2>
+
+<div class="contents">
+
+<ul class="no-bullet">
+  <li><a id="toc-General-Questions" href="#General-Questions">1 General Questions</a>
+  <ul class="no-bullet">
+    <li><a id="toc-Why-doesn_0027t-FFmpeg-support-feature-_005bxyz_005d_003f" href="#Why-doesn_0027t-FFmpeg-support-feature-_005bxyz_005d_003f">1.1 Why doesn&rsquo;t FFmpeg support feature [xyz]?</a></li>
+    <li><a id="toc-FFmpeg-does-not-support-codec-XXX_002e-Can-you-include-a-Windows-DLL-loader-to-support-it_003f" href="#FFmpeg-does-not-support-codec-XXX_002e-Can-you-include-a-Windows-DLL-loader-to-support-it_003f">1.2 FFmpeg does not support codec XXX. Can you include a Windows DLL loader to support it?</a></li>
+    <li><a id="toc-I-cannot-read-this-file-although-this-format-seems-to-be-supported-by-ffmpeg_002e" href="#I-cannot-read-this-file-although-this-format-seems-to-be-supported-by-ffmpeg_002e">1.3 I cannot read this file although this format seems to be supported by ffmpeg.</a></li>
+    <li><a id="toc-Which-codecs-are-supported-by-Windows_003f" href="#Which-codecs-are-supported-by-Windows_003f">1.4 Which codecs are supported by Windows?</a></li>
+  </ul></li>
+  <li><a id="toc-Compilation" href="#Compilation">2 Compilation</a>
+  <ul class="no-bullet">
+    <li><a id="toc-error_003a-can_0027t-find-a-register-in-class-_0027GENERAL_005fREGS_0027-while-reloading-_0027asm_0027" href="#error_003a-can_0027t-find-a-register-in-class-_0027GENERAL_005fREGS_0027-while-reloading-_0027asm_0027">2.1 <code>error: can't find a register in class 'GENERAL_REGS' while reloading 'asm'</code></a></li>
+    <li><a id="toc-I-have-installed-this-library-with-my-distro_0027s-package-manager_002e-Why-does-configure-not-see-it_003f" href="#I-have-installed-this-library-with-my-distro_0027s-package-manager_002e-Why-does-configure-not-see-it_003f">2.2 I have installed this library with my distro&rsquo;s package manager. Why does <code>configure</code> not see it?</a></li>
+    <li><a id="toc-How-do-I-make-pkg_002dconfig-find-my-libraries_003f" href="#How-do-I-make-pkg_002dconfig-find-my-libraries_003f">2.3 How do I make <code>pkg-config</code> find my libraries?</a></li>
+    <li><a id="toc-How-do-I-use-pkg_002dconfig-when-cross_002dcompiling_003f" href="#How-do-I-use-pkg_002dconfig-when-cross_002dcompiling_003f">2.4 How do I use <code>pkg-config</code> when cross-compiling?</a></li>
+  </ul></li>
+  <li><a id="toc-Usage" href="#Usage">3 Usage</a>
+  <ul class="no-bullet">
+    <li><a id="toc-ffmpeg-does-not-work_003b-what-is-wrong_003f" href="#ffmpeg-does-not-work_003b-what-is-wrong_003f">3.1 ffmpeg does not work; what is wrong?</a></li>
+    <li><a id="toc-How-do-I-encode-single-pictures-into-movies_003f" href="#How-do-I-encode-single-pictures-into-movies_003f">3.2 How do I encode single pictures into movies?</a></li>
+    <li><a id="toc-How-do-I-encode-movie-to-single-pictures_003f" href="#How-do-I-encode-movie-to-single-pictures_003f">3.3 How do I encode movie to single pictures?</a></li>
+    <li><a id="toc-Why-do-I-see-a-slight-quality-degradation-with-multithreaded-MPEG_002a-encoding_003f" href="#Why-do-I-see-a-slight-quality-degradation-with-multithreaded-MPEG_002a-encoding_003f">3.4 Why do I see a slight quality degradation with multithreaded MPEG* encoding?</a></li>
+    <li><a id="toc-How-can-I-read-from-the-standard-input-or-write-to-the-standard-output_003f" href="#How-can-I-read-from-the-standard-input-or-write-to-the-standard-output_003f">3.5 How can I read from the standard input or write to the standard output?</a></li>
+    <li><a id="toc-_002df-jpeg-doesn_0027t-work_002e" href="#g_t_002df-jpeg-doesn_0027t-work_002e">3.6 -f jpeg doesn&rsquo;t work.</a></li>
+    <li><a id="toc-Why-can-I-not-change-the-frame-rate_003f" href="#Why-can-I-not-change-the-frame-rate_003f">3.7 Why can I not change the frame rate?</a></li>
+    <li><a id="toc-How-do-I-encode-Xvid-or-DivX-video-with-ffmpeg_003f" href="#How-do-I-encode-Xvid-or-DivX-video-with-ffmpeg_003f">3.8 How do I encode Xvid or DivX video with ffmpeg?</a></li>
+    <li><a id="toc-Which-are-good-parameters-for-encoding-high-quality-MPEG_002d4_003f" href="#Which-are-good-parameters-for-encoding-high-quality-MPEG_002d4_003f">3.9 Which are good parameters for encoding high quality MPEG-4?</a></li>
+    <li><a id="toc-Which-are-good-parameters-for-encoding-high-quality-MPEG_002d1_002fMPEG_002d2_003f" href="#Which-are-good-parameters-for-encoding-high-quality-MPEG_002d1_002fMPEG_002d2_003f">3.10 Which are good parameters for encoding high quality MPEG-1/MPEG-2?</a></li>
+    <li><a id="toc-Interlaced-video-looks-very-bad-when-encoded-with-ffmpeg_002c-what-is-wrong_003f" href="#Interlaced-video-looks-very-bad-when-encoded-with-ffmpeg_002c-what-is-wrong_003f">3.11 Interlaced video looks very bad when encoded with ffmpeg, what is wrong?</a></li>
+    <li><a id="toc-How-can-I-read-DirectShow-files_003f" href="#How-can-I-read-DirectShow-files_003f">3.12 How can I read DirectShow files?</a></li>
+    <li><a id="toc-How-can-I-join-video-files_003f" href="#How-can-I-join-video-files_003f">3.13 How can I join video files?</a></li>
+    <li><a id="toc-How-can-I-concatenate-video-files_003f" href="#How-can-I-concatenate-video-files_003f">3.14 How can I concatenate video files?</a>
+    <ul class="no-bullet">
+      <li><a id="toc-Concatenating-using-the-concat-filter" href="#Concatenating-using-the-concat-filter">3.14.1 Concatenating using the concat <em>filter</em></a></li>
+      <li><a id="toc-Concatenating-using-the-concat-demuxer" href="#Concatenating-using-the-concat-demuxer">3.14.2 Concatenating using the concat <em>demuxer</em></a></li>
+      <li><a id="toc-Concatenating-using-the-concat-protocol-_0028file-level_0029" href="#Concatenating-using-the-concat-protocol-_0028file-level_0029">3.14.3 Concatenating using the concat <em>protocol</em> (file level)</a></li>
+      <li><a id="toc-Concatenating-using-raw-audio-and-video" href="#Concatenating-using-raw-audio-and-video">3.14.4 Concatenating using raw audio and video</a></li>
+    </ul></li>
+    <li><a id="toc-Using-_002df-lavfi_002c-audio-becomes-mono-for-no-apparent-reason_002e" href="#Using-_002df-lavfi_002c-audio-becomes-mono-for-no-apparent-reason_002e">3.15 Using <samp>-f lavfi</samp>, audio becomes mono for no apparent reason.</a></li>
+    <li><a id="toc-Why-does-FFmpeg-not-see-the-subtitles-in-my-VOB-file_003f" href="#Why-does-FFmpeg-not-see-the-subtitles-in-my-VOB-file_003f">3.16 Why does FFmpeg not see the subtitles in my VOB file?</a></li>
+    <li><a id="toc-Why-was-the-ffmpeg-_002dsameq-option-removed_003f-What-to-use-instead_003f" href="#Why-was-the-ffmpeg-_002dsameq-option-removed_003f-What-to-use-instead_003f">3.17 Why was the <code>ffmpeg</code> <samp>-sameq</samp> option removed? What to use instead?</a></li>
+    <li><a id="toc-I-have-a-stretched-video_002c-why-does-scaling-does-not-fix-it_003f" href="#I-have-a-stretched-video_002c-why-does-scaling-does-not-fix-it_003f">3.18 I have a stretched video, why does scaling does not fix it?</a></li>
+    <li><a id="toc-How-do-I-run-ffmpeg-as-a-background-task_003f" href="#How-do-I-run-ffmpeg-as-a-background-task_003f">3.19 How do I run ffmpeg as a background task?</a></li>
+    <li><a id="toc-How-do-I-prevent-ffmpeg-from-suspending-with-a-message-like-suspended-_0028tty-output_0029_003f" href="#How-do-I-prevent-ffmpeg-from-suspending-with-a-message-like-suspended-_0028tty-output_0029_003f">3.20 How do I prevent ffmpeg from suspending with a message like <em>suspended (tty output)</em>?</a></li>
+  </ul></li>
+  <li><a id="toc-Development" href="#Development">4 Development</a>
+  <ul class="no-bullet">
+    <li><a id="toc-Are-there-examples-illustrating-how-to-use-the-FFmpeg-libraries_002c-particularly-libavcodec-and-libavformat_003f" href="#Are-there-examples-illustrating-how-to-use-the-FFmpeg-libraries_002c-particularly-libavcodec-and-libavformat_003f">4.1 Are there examples illustrating how to use the FFmpeg libraries, particularly libavcodec and libavformat?</a></li>
+    <li><a id="toc-Can-you-support-my-C-compiler-XXX_003f" href="#Can-you-support-my-C-compiler-XXX_003f">4.2 Can you support my C compiler XXX?</a></li>
+    <li><a id="toc-Is-Microsoft-Visual-C_002b_002b-supported_003f" href="#Is-Microsoft-Visual-C_002b_002b-supported_003f">4.3 Is Microsoft Visual C++ supported?</a></li>
+    <li><a id="toc-Can-you-add-automake_002c-libtool-or-autoconf-support_003f" href="#Can-you-add-automake_002c-libtool-or-autoconf-support_003f">4.4 Can you add automake, libtool or autoconf support?</a></li>
+    <li><a id="toc-Why-not-rewrite-FFmpeg-in-object_002doriented-C_002b_002b_003f" href="#Why-not-rewrite-FFmpeg-in-object_002doriented-C_002b_002b_003f">4.5 Why not rewrite FFmpeg in object-oriented C++?</a></li>
+    <li><a id="toc-Why-are-the-ffmpeg-programs-devoid-of-debugging-symbols_003f" href="#Why-are-the-ffmpeg-programs-devoid-of-debugging-symbols_003f">4.6 Why are the ffmpeg programs devoid of debugging symbols?</a></li>
+    <li><a id="toc-I-do-not-like-the-LGPL_002c-can-I-contribute-code-under-the-GPL-instead_003f" href="#I-do-not-like-the-LGPL_002c-can-I-contribute-code-under-the-GPL-instead_003f">4.7 I do not like the LGPL, can I contribute code under the GPL instead?</a></li>
+    <li><a id="toc-I_0027m-using-FFmpeg-from-within-my-C-application-but-the-linker-complains-about-missing-symbols-from-the-libraries-themselves_002e" href="#I_0027m-using-FFmpeg-from-within-my-C-application-but-the-linker-complains-about-missing-symbols-from-the-libraries-themselves_002e">4.8 I&rsquo;m using FFmpeg from within my C application but the linker complains about missing symbols from the libraries themselves.</a></li>
+    <li><a id="toc-I_0027m-using-FFmpeg-from-within-my-C_002b_002b-application-but-the-linker-complains-about-missing-symbols-which-seem-to-be-available_002e" href="#I_0027m-using-FFmpeg-from-within-my-C_002b_002b-application-but-the-linker-complains-about-missing-symbols-which-seem-to-be-available_002e">4.9 I&rsquo;m using FFmpeg from within my C++ application but the linker complains about missing symbols which seem to be available.</a></li>
+    <li><a id="toc-I_0027m-using-libavutil-from-within-my-C_002b_002b-application-but-the-compiler-complains-about-_0027UINT64_005fC_0027-was-not-declared-in-this-scope" href="#I_0027m-using-libavutil-from-within-my-C_002b_002b-application-but-the-compiler-complains-about-_0027UINT64_005fC_0027-was-not-declared-in-this-scope">4.10 I&rsquo;m using libavutil from within my C++ application but the compiler complains about &rsquo;UINT64_C&rsquo; was not declared in this scope</a></li>
+    <li><a id="toc-I-have-a-file-in-memory-_002f-a-API-different-from-_002aopen_002f_002aread_002f-libc-how-do-I-use-it-with-libavformat_003f" href="#I-have-a-file-in-memory-_002f-a-API-different-from-_002aopen_002f_002aread_002f-libc-how-do-I-use-it-with-libavformat_003f">4.11 I have a file in memory / a API different from *open/*read/ libc how do I use it with libavformat?</a></li>
+    <li><a id="toc-Where-is-the-documentation-about-ffv1_002c-msmpeg4_002c-asv1_002c-4xm_003f" href="#Where-is-the-documentation-about-ffv1_002c-msmpeg4_002c-asv1_002c-4xm_003f">4.12 Where is the documentation about ffv1, msmpeg4, asv1, 4xm?</a></li>
+    <li><a id="toc-How-do-I-feed-H_002e263_002dRTP-_0028and-other-codecs-in-RTP_0029-to-libavcodec_003f" href="#How-do-I-feed-H_002e263_002dRTP-_0028and-other-codecs-in-RTP_0029-to-libavcodec_003f">4.13 How do I feed H.263-RTP (and other codecs in RTP) to libavcodec?</a></li>
+    <li><a id="toc-AVStream_002er_005fframe_005frate-is-wrong_002c-it-is-much-larger-than-the-frame-rate_002e" href="#AVStream_002er_005fframe_005frate-is-wrong_002c-it-is-much-larger-than-the-frame-rate_002e">4.14 AVStream.r_frame_rate is wrong, it is much larger than the frame rate.</a></li>
+    <li><a id="toc-Why-is-make-fate-not-running-all-tests_003f" href="#Why-is-make-fate-not-running-all-tests_003f">4.15 Why is <code>make fate</code> not running all tests?</a></li>
+    <li><a id="toc-Why-is-make-fate-not-finding-the-samples_003f" href="#Why-is-make-fate-not-finding-the-samples_003f">4.16 Why is <code>make fate</code> not finding the samples?</a></li>
+  </ul></li>
+</ul>
+</div>
+
+
+<a name="General-Questions"></a>
+<h2 class="chapter">1 General Questions<span class="pull-right"><a class="anchor hidden-xs" href="#General-Questions" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-General-Questions" aria-hidden="true">TOC</a></span></h2>
+
+<a name="Why-doesn_0027t-FFmpeg-support-feature-_005bxyz_005d_003f"></a>
+<h3 class="section">1.1 Why doesn&rsquo;t FFmpeg support feature [xyz]?<span class="pull-right"><a class="anchor hidden-xs" href="#Why-doesn_0027t-FFmpeg-support-feature-_005bxyz_005d_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Why-doesn_0027t-FFmpeg-support-feature-_005bxyz_005d_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>Because no one has taken on that task yet. FFmpeg development is
+driven by the tasks that are important to the individual developers.
+If there is a feature that is important to you, the best way to get
+it implemented is to undertake the task yourself or sponsor a developer.
+</p>
+<a name="FFmpeg-does-not-support-codec-XXX_002e-Can-you-include-a-Windows-DLL-loader-to-support-it_003f"></a>
+<h3 class="section">1.2 FFmpeg does not support codec XXX. Can you include a Windows DLL loader to support it?<span class="pull-right"><a class="anchor hidden-xs" href="#FFmpeg-does-not-support-codec-XXX_002e-Can-you-include-a-Windows-DLL-loader-to-support-it_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-FFmpeg-does-not-support-codec-XXX_002e-Can-you-include-a-Windows-DLL-loader-to-support-it_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>No. Windows DLLs are not portable, bloated and often slow.
+Moreover FFmpeg strives to support all codecs natively.
+A DLL loader is not conducive to that goal.
+</p>
+<a name="I-cannot-read-this-file-although-this-format-seems-to-be-supported-by-ffmpeg_002e"></a>
+<h3 class="section">1.3 I cannot read this file although this format seems to be supported by ffmpeg.<span class="pull-right"><a class="anchor hidden-xs" href="#I-cannot-read-this-file-although-this-format-seems-to-be-supported-by-ffmpeg_002e" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-I-cannot-read-this-file-although-this-format-seems-to-be-supported-by-ffmpeg_002e" aria-hidden="true">TOC</a></span></h3>
+
+<p>Even if ffmpeg can read the container format, it may not support all its
+codecs. Please consult the supported codec list in the ffmpeg
+documentation.
+</p>
+<a name="Which-codecs-are-supported-by-Windows_003f"></a>
+<h3 class="section">1.4 Which codecs are supported by Windows?<span class="pull-right"><a class="anchor hidden-xs" href="#Which-codecs-are-supported-by-Windows_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Which-codecs-are-supported-by-Windows_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>Windows does not support standard formats like MPEG very well, unless you
+install some additional codecs.
+</p>
+<p>The following list of video codecs should work on most Windows systems:
+</p><dl compact="compact">
+<dt><samp>msmpeg4v2</samp></dt>
+<dd><p>.avi/.asf
+</p></dd>
+<dt><samp>msmpeg4</samp></dt>
+<dd><p>.asf only
+</p></dd>
+<dt><samp>wmv1</samp></dt>
+<dd><p>.asf only
+</p></dd>
+<dt><samp>wmv2</samp></dt>
+<dd><p>.asf only
+</p></dd>
+<dt><samp>mpeg4</samp></dt>
+<dd><p>Only if you have some MPEG-4 codec like ffdshow or Xvid installed.
+</p></dd>
+<dt><samp>mpeg1video</samp></dt>
+<dd><p>.mpg only
+</p></dd>
+</dl>
+<p>Note, ASF files often have .wmv or .wma extensions in Windows. It should also
+be mentioned that Microsoft claims a patent on the ASF format, and may sue
+or threaten users who create ASF files with non-Microsoft software. It is
+strongly advised to avoid ASF where possible.
+</p>
+<p>The following list of audio codecs should work on most Windows systems:
+</p><dl compact="compact">
+<dt><samp>adpcm_ima_wav</samp></dt>
+<dt><samp>adpcm_ms</samp></dt>
+<dt><samp>pcm_s16le</samp></dt>
+<dd><p>always
+</p></dd>
+<dt><samp>libmp3lame</samp></dt>
+<dd><p>If some MP3 codec like LAME is installed.
+</p></dd>
+</dl>
+
+
+<a name="Compilation"></a>
+<h2 class="chapter">2 Compilation<span class="pull-right"><a class="anchor hidden-xs" href="#Compilation" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Compilation" aria-hidden="true">TOC</a></span></h2>
+
+<a name="error_003a-can_0027t-find-a-register-in-class-_0027GENERAL_005fREGS_0027-while-reloading-_0027asm_0027"></a>
+<h3 class="section">2.1 <code>error: can't find a register in class 'GENERAL_REGS' while reloading 'asm'</code><span class="pull-right"><a class="anchor hidden-xs" href="#error_003a-can_0027t-find-a-register-in-class-_0027GENERAL_005fREGS_0027-while-reloading-_0027asm_0027" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-error_003a-can_0027t-find-a-register-in-class-_0027GENERAL_005fREGS_0027-while-reloading-_0027asm_0027" aria-hidden="true">TOC</a></span></h3>
+
+<p>This is a bug in gcc. Do not report it to us. Instead, please report it to
+the gcc developers. Note that we will not add workarounds for gcc bugs.
+</p>
+<p>Also note that (some of) the gcc developers believe this is not a bug or
+not a bug they should fix:
+<a href="https://gcc.gnu.org/bugzilla/show_bug.cgi?id=11203">https://gcc.gnu.org/bugzilla/show_bug.cgi?id=11203</a>.
+Then again, some of them do not know the difference between an undecidable
+problem and an NP-hard problem...
+</p>
+<a name="I-have-installed-this-library-with-my-distro_0027s-package-manager_002e-Why-does-configure-not-see-it_003f"></a>
+<h3 class="section">2.2 I have installed this library with my distro&rsquo;s package manager. Why does <code>configure</code> not see it?<span class="pull-right"><a class="anchor hidden-xs" href="#I-have-installed-this-library-with-my-distro_0027s-package-manager_002e-Why-does-configure-not-see-it_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-I-have-installed-this-library-with-my-distro_0027s-package-manager_002e-Why-does-configure-not-see-it_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>Distributions usually split libraries in several packages. The main package
+contains the files necessary to run programs using the library. The
+development package contains the files necessary to build programs using the
+library. Sometimes, docs and/or data are in a separate package too.
+</p>
+<p>To build FFmpeg, you need to install the development package. It is usually
+called <samp>libfoo-dev</samp> or <samp>libfoo-devel</samp>. You can remove it after the
+build is finished, but be sure to keep the main package.
+</p>
+<a name="How-do-I-make-pkg_002dconfig-find-my-libraries_003f"></a>
+<h3 class="section">2.3 How do I make <code>pkg-config</code> find my libraries?<span class="pull-right"><a class="anchor hidden-xs" href="#How-do-I-make-pkg_002dconfig-find-my-libraries_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-How-do-I-make-pkg_002dconfig-find-my-libraries_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>Somewhere along with your libraries, there is a <samp>.pc</samp> file (or several)
+in a <samp>pkgconfig</samp> directory. You need to set environment variables to
+point <code>pkg-config</code> to these files.
+</p>
+<p>If you need to <em>add</em> directories to <code>pkg-config</code>&rsquo;s search list
+(typical use case: library installed separately), add it to
+<code>$PKG_CONFIG_PATH</code>:
+</p>
+<div class="example">
+<pre class="example">export PKG_CONFIG_PATH=/opt/x264/lib/pkgconfig:/opt/opus/lib/pkgconfig
+</pre></div>
+
+<p>If you need to <em>replace</em> <code>pkg-config</code>&rsquo;s search list
+(typical use case: cross-compiling), set it in
+<code>$PKG_CONFIG_LIBDIR</code>:
+</p>
+<div class="example">
+<pre class="example">export PKG_CONFIG_LIBDIR=/home/me/cross/usr/lib/pkgconfig:/home/me/cross/usr/local/lib/pkgconfig
+</pre></div>
+
+<p>If you need to know the library&rsquo;s internal dependencies (typical use: static
+linking), add the <code>--static</code> option to <code>pkg-config</code>:
+</p>
+<div class="example">
+<pre class="example">./configure --pkg-config-flags=--static
+</pre></div>
+
+<a name="How-do-I-use-pkg_002dconfig-when-cross_002dcompiling_003f"></a>
+<h3 class="section">2.4 How do I use <code>pkg-config</code> when cross-compiling?<span class="pull-right"><a class="anchor hidden-xs" href="#How-do-I-use-pkg_002dconfig-when-cross_002dcompiling_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-How-do-I-use-pkg_002dconfig-when-cross_002dcompiling_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>The best way is to install <code>pkg-config</code> in your cross-compilation
+environment. It will automatically use the cross-compilation libraries.
+</p>
+<p>You can also use <code>pkg-config</code> from the host environment by
+specifying explicitly <code>--pkg-config=pkg-config</code> to <code>configure</code>.
+In that case, you must point <code>pkg-config</code> to the correct directories
+using the <code>PKG_CONFIG_LIBDIR</code>, as explained in the previous entry.
+</p>
+<p>As an intermediate solution, you can place in your cross-compilation
+environment a script that calls the host <code>pkg-config</code> with
+<code>PKG_CONFIG_LIBDIR</code> set. That script can look like that:
+</p>
+<div class="example">
+<pre class="example">#!/bin/sh
+PKG_CONFIG_LIBDIR=/path/to/cross/lib/pkgconfig
+export PKG_CONFIG_LIBDIR
+exec /usr/bin/pkg-config &quot;$@&quot;
+</pre></div>
+
+<a name="Usage"></a>
+<h2 class="chapter">3 Usage<span class="pull-right"><a class="anchor hidden-xs" href="#Usage" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Usage" aria-hidden="true">TOC</a></span></h2>
+
+<a name="ffmpeg-does-not-work_003b-what-is-wrong_003f"></a>
+<h3 class="section">3.1 ffmpeg does not work; what is wrong?<span class="pull-right"><a class="anchor hidden-xs" href="#ffmpeg-does-not-work_003b-what-is-wrong_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-ffmpeg-does-not-work_003b-what-is-wrong_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>Try a <code>make distclean</code> in the ffmpeg source directory before the build.
+If this does not help see
+(<a href="https://ffmpeg.org/bugreports.html">https://ffmpeg.org/bugreports.html</a>).
+</p>
+<a name="How-do-I-encode-single-pictures-into-movies_003f"></a>
+<h3 class="section">3.2 How do I encode single pictures into movies?<span class="pull-right"><a class="anchor hidden-xs" href="#How-do-I-encode-single-pictures-into-movies_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-How-do-I-encode-single-pictures-into-movies_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>First, rename your pictures to follow a numerical sequence.
+For example, img1.jpg, img2.jpg, img3.jpg,...
+Then you may run:
+</p>
+<div class="example">
+<pre class="example">ffmpeg -f image2 -i img%d.jpg /tmp/a.mpg
+</pre></div>
+
+<p>Notice that &lsquo;<samp>%d</samp>&rsquo; is replaced by the image number.
+</p>
+<p><samp>img%03d.jpg</samp> means the sequence <samp>img001.jpg</samp>, <samp>img002.jpg</samp>, etc.
+</p>
+<p>Use the <samp>-start_number</samp> option to declare a starting number for
+the sequence. This is useful if your sequence does not start with
+<samp>img001.jpg</samp> but is still in a numerical order. The following
+example will start with <samp>img100.jpg</samp>:
+</p>
+<div class="example">
+<pre class="example">ffmpeg -f image2 -start_number 100 -i img%d.jpg /tmp/a.mpg
+</pre></div>
+
+<p>If you have large number of pictures to rename, you can use the
+following command to ease the burden. The command, using the bourne
+shell syntax, symbolically links all files in the current directory
+that match <code>*jpg</code> to the <samp>/tmp</samp> directory in the sequence of
+<samp>img001.jpg</samp>, <samp>img002.jpg</samp> and so on.
+</p>
+<div class="example">
+<pre class="example">x=1; for i in *jpg; do counter=$(printf %03d $x); ln -s &quot;$i&quot; /tmp/img&quot;$counter&quot;.jpg; x=$(($x+1)); done
+</pre></div>
+
+<p>If you want to sequence them by oldest modified first, substitute
+<code>$(ls -r -t *jpg)</code> in place of <code>*jpg</code>.
+</p>
+<p>Then run:
+</p>
+<div class="example">
+<pre class="example">ffmpeg -f image2 -i /tmp/img%03d.jpg /tmp/a.mpg
+</pre></div>
+
+<p>The same logic is used for any image format that ffmpeg reads.
+</p>
+<p>You can also use <code>cat</code> to pipe images to ffmpeg:
+</p>
+<div class="example">
+<pre class="example">cat *.jpg | ffmpeg -f image2pipe -c:v mjpeg -i - output.mpg
+</pre></div>
+
+<a name="How-do-I-encode-movie-to-single-pictures_003f"></a>
+<h3 class="section">3.3 How do I encode movie to single pictures?<span class="pull-right"><a class="anchor hidden-xs" href="#How-do-I-encode-movie-to-single-pictures_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-How-do-I-encode-movie-to-single-pictures_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>Use:
+</p>
+<div class="example">
+<pre class="example">ffmpeg -i movie.mpg movie%d.jpg
+</pre></div>
+
+<p>The <samp>movie.mpg</samp> used as input will be converted to
+<samp>movie1.jpg</samp>, <samp>movie2.jpg</samp>, etc...
+</p>
+<p>Instead of relying on file format self-recognition, you may also use
+</p><dl compact="compact">
+<dt><samp>-c:v ppm</samp></dt>
+<dt><samp>-c:v png</samp></dt>
+<dt><samp>-c:v mjpeg</samp></dt>
+</dl>
+<p>to force the encoding.
+</p>
+<p>Applying that to the previous example:
+</p><div class="example">
+<pre class="example">ffmpeg -i movie.mpg -f image2 -c:v mjpeg menu%d.jpg
+</pre></div>
+
+<p>Beware that there is no &quot;jpeg&quot; codec. Use &quot;mjpeg&quot; instead.
+</p>
+<a name="Why-do-I-see-a-slight-quality-degradation-with-multithreaded-MPEG_002a-encoding_003f"></a>
+<h3 class="section">3.4 Why do I see a slight quality degradation with multithreaded MPEG* encoding?<span class="pull-right"><a class="anchor hidden-xs" href="#Why-do-I-see-a-slight-quality-degradation-with-multithreaded-MPEG_002a-encoding_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Why-do-I-see-a-slight-quality-degradation-with-multithreaded-MPEG_002a-encoding_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>For multithreaded MPEG* encoding, the encoded slices must be independent,
+otherwise thread n would practically have to wait for n-1 to finish, so it&rsquo;s
+quite logical that there is a small reduction of quality. This is not a bug.
+</p>
+<a name="How-can-I-read-from-the-standard-input-or-write-to-the-standard-output_003f"></a>
+<h3 class="section">3.5 How can I read from the standard input or write to the standard output?<span class="pull-right"><a class="anchor hidden-xs" href="#How-can-I-read-from-the-standard-input-or-write-to-the-standard-output_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-How-can-I-read-from-the-standard-input-or-write-to-the-standard-output_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>Use <samp>-</samp> as file name.
+</p>
+<a name="g_t_002df-jpeg-doesn_0027t-work_002e"></a>
+<h3 class="section">3.6 -f jpeg doesn&rsquo;t work.<span class="pull-right"><a class="anchor hidden-xs" href="#_002df-jpeg-doesn_0027t-work_002e" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-_002df-jpeg-doesn_0027t-work_002e" aria-hidden="true">TOC</a></span></h3>
+
+<p>Try &rsquo;-f image2 test%d.jpg&rsquo;.
+</p>
+<a name="Why-can-I-not-change-the-frame-rate_003f"></a>
+<h3 class="section">3.7 Why can I not change the frame rate?<span class="pull-right"><a class="anchor hidden-xs" href="#Why-can-I-not-change-the-frame-rate_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Why-can-I-not-change-the-frame-rate_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>Some codecs, like MPEG-1/2, only allow a small number of fixed frame rates.
+Choose a different codec with the -c:v command line option.
+</p>
+<a name="How-do-I-encode-Xvid-or-DivX-video-with-ffmpeg_003f"></a>
+<h3 class="section">3.8 How do I encode Xvid or DivX video with ffmpeg?<span class="pull-right"><a class="anchor hidden-xs" href="#How-do-I-encode-Xvid-or-DivX-video-with-ffmpeg_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-How-do-I-encode-Xvid-or-DivX-video-with-ffmpeg_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>Both Xvid and DivX (version 4+) are implementations of the ISO MPEG-4
+standard (note that there are many other coding formats that use this
+same standard). Thus, use &rsquo;-c:v mpeg4&rsquo; to encode in these formats. The
+default fourcc stored in an MPEG-4-coded file will be &rsquo;FMP4&rsquo;. If you want
+a different fourcc, use the &rsquo;-vtag&rsquo; option. E.g., &rsquo;-vtag xvid&rsquo; will
+force the fourcc &rsquo;xvid&rsquo; to be stored as the video fourcc rather than the
+default.
+</p>
+<a name="Which-are-good-parameters-for-encoding-high-quality-MPEG_002d4_003f"></a>
+<h3 class="section">3.9 Which are good parameters for encoding high quality MPEG-4?<span class="pull-right"><a class="anchor hidden-xs" href="#Which-are-good-parameters-for-encoding-high-quality-MPEG_002d4_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Which-are-good-parameters-for-encoding-high-quality-MPEG_002d4_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>&rsquo;-mbd rd -flags +mv4+aic -trellis 2 -cmp 2 -subcmp 2 -g 300 -pass 1/2&rsquo;,
+things to try: &rsquo;-bf 2&rsquo;, &rsquo;-mpv_flags qp_rd&rsquo;, &rsquo;-mpv_flags mv0&rsquo;, &rsquo;-mpv_flags skip_rd&rsquo;.
+</p>
+<a name="Which-are-good-parameters-for-encoding-high-quality-MPEG_002d1_002fMPEG_002d2_003f"></a>
+<h3 class="section">3.10 Which are good parameters for encoding high quality MPEG-1/MPEG-2?<span class="pull-right"><a class="anchor hidden-xs" href="#Which-are-good-parameters-for-encoding-high-quality-MPEG_002d1_002fMPEG_002d2_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Which-are-good-parameters-for-encoding-high-quality-MPEG_002d1_002fMPEG_002d2_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>&rsquo;-mbd rd -trellis 2 -cmp 2 -subcmp 2 -g 100 -pass 1/2&rsquo;
+but beware the &rsquo;-g 100&rsquo; might cause problems with some decoders.
+Things to try: &rsquo;-bf 2&rsquo;, &rsquo;-mpv_flags qp_rd&rsquo;, &rsquo;-mpv_flags mv0&rsquo;, &rsquo;-mpv_flags skip_rd&rsquo;.
+</p>
+<a name="Interlaced-video-looks-very-bad-when-encoded-with-ffmpeg_002c-what-is-wrong_003f"></a>
+<h3 class="section">3.11 Interlaced video looks very bad when encoded with ffmpeg, what is wrong?<span class="pull-right"><a class="anchor hidden-xs" href="#Interlaced-video-looks-very-bad-when-encoded-with-ffmpeg_002c-what-is-wrong_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Interlaced-video-looks-very-bad-when-encoded-with-ffmpeg_002c-what-is-wrong_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>You should use &rsquo;-flags +ilme+ildct&rsquo; and maybe &rsquo;-flags +alt&rsquo; for interlaced
+material, and try &rsquo;-top 0/1&rsquo; if the result looks really messed-up.
+</p>
+<a name="How-can-I-read-DirectShow-files_003f"></a>
+<h3 class="section">3.12 How can I read DirectShow files?<span class="pull-right"><a class="anchor hidden-xs" href="#How-can-I-read-DirectShow-files_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-How-can-I-read-DirectShow-files_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>If you have built FFmpeg with <code>./configure --enable-avisynth</code>
+(only possible on MinGW/Cygwin platforms),
+then you may use any file that DirectShow can read as input.
+</p>
+<p>Just create an &quot;input.avs&quot; text file with this single line ...
+</p><div class="example">
+<pre class="example">DirectShowSource(&quot;C:\path to your file\yourfile.asf&quot;)
+</pre></div>
+<p>... and then feed that text file to ffmpeg:
+</p><div class="example">
+<pre class="example">ffmpeg -i input.avs
+</pre></div>
+
+<p>For ANY other help on AviSynth, please visit the
+<a href="http://www.avisynth.org/">AviSynth homepage</a>.
+</p>
+<a name="How-can-I-join-video-files_003f"></a>
+<h3 class="section">3.13 How can I join video files?<span class="pull-right"><a class="anchor hidden-xs" href="#How-can-I-join-video-files_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-How-can-I-join-video-files_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>To &quot;join&quot; video files is quite ambiguous. The following list explains the
+different kinds of &quot;joining&quot; and points out how those are addressed in
+FFmpeg. To join video files may mean:
+</p>
+<ul>
+<li> To put them one after the other: this is called to <em>concatenate</em> them
+(in short: concat) and is addressed
+<a href="#How-can-I-concatenate-video-files">in this very faq</a>.
+
+</li><li> To put them together in the same file, to let the user choose between the
+different versions (example: different audio languages): this is called to
+<em>multiplex</em> them together (in short: mux), and is done by simply
+invoking ffmpeg with several <samp>-i</samp> options.
+
+</li><li> For audio, to put all channels together in a single stream (example: two
+mono streams into one stereo stream): this is sometimes called to
+<em>merge</em> them, and can be done using the
+<a href="ffmpeg-filters.html#amerge"><code>amerge</code></a> filter.
+
+</li><li> For audio, to play one on top of the other: this is called to <em>mix</em>
+them, and can be done by first merging them into a single stream and then
+using the <a href="ffmpeg-filters.html#pan"><code>pan</code></a> filter to mix
+the channels at will.
+
+</li><li> For video, to display both together, side by side or one on top of a part of
+the other; it can be done using the
+<a href="ffmpeg-filters.html#overlay"><code>overlay</code></a> video filter.
+
+</li></ul>
+
+<span id="How-can-I-concatenate-video-files"></span><a name="How-can-I-concatenate-video-files_003f"></a>
+<h3 class="section">3.14 How can I concatenate video files?<span class="pull-right"><a class="anchor hidden-xs" href="#How-can-I-concatenate-video-files_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-How-can-I-concatenate-video-files_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>There are several solutions, depending on the exact circumstances.
+</p>
+<a name="Concatenating-using-the-concat-filter"></a>
+<h4 class="subsection">3.14.1 Concatenating using the concat <em>filter</em><span class="pull-right"><a class="anchor hidden-xs" href="#Concatenating-using-the-concat-filter" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Concatenating-using-the-concat-filter" aria-hidden="true">TOC</a></span></h4>
+
+<p>FFmpeg has a <a href="ffmpeg-filters.html#concat"><code>concat</code></a> filter designed specifically for that, with examples in the
+documentation. This operation is recommended if you need to re-encode.
+</p>
+<a name="Concatenating-using-the-concat-demuxer"></a>
+<h4 class="subsection">3.14.2 Concatenating using the concat <em>demuxer</em><span class="pull-right"><a class="anchor hidden-xs" href="#Concatenating-using-the-concat-demuxer" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Concatenating-using-the-concat-demuxer" aria-hidden="true">TOC</a></span></h4>
+
+<p>FFmpeg has a <a href="ffmpeg-formats.html#concat"><code>concat</code></a> demuxer which you can use when you want to avoid a re-encode and
+your format doesn&rsquo;t support file level concatenation.
+</p>
+<a name="Concatenating-using-the-concat-protocol-_0028file-level_0029"></a>
+<h4 class="subsection">3.14.3 Concatenating using the concat <em>protocol</em> (file level)<span class="pull-right"><a class="anchor hidden-xs" href="#Concatenating-using-the-concat-protocol-_0028file-level_0029" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Concatenating-using-the-concat-protocol-_0028file-level_0029" aria-hidden="true">TOC</a></span></h4>
+
+<p>FFmpeg has a <a href="ffmpeg-protocols.html#concat"><code>concat</code></a> protocol designed specifically for that, with examples in the
+documentation.
+</p>
+<p>A few multimedia containers (MPEG-1, MPEG-2 PS, DV) allow one to concatenate
+video by merely concatenating the files containing them.
+</p>
+<p>Hence you may concatenate your multimedia files by first transcoding them to
+these privileged formats, then using the humble <code>cat</code> command (or the
+equally humble <code>copy</code> under Windows), and finally transcoding back to your
+format of choice.
+</p>
+<div class="example">
+<pre class="example">ffmpeg -i input1.avi -qscale:v 1 intermediate1.mpg
+ffmpeg -i input2.avi -qscale:v 1 intermediate2.mpg
+cat intermediate1.mpg intermediate2.mpg &gt; intermediate_all.mpg
+ffmpeg -i intermediate_all.mpg -qscale:v 2 output.avi
+</pre></div>
+
+<p>Additionally, you can use the <code>concat</code> protocol instead of <code>cat</code> or
+<code>copy</code> which will avoid creation of a potentially huge intermediate file.
+</p>
+<div class="example">
+<pre class="example">ffmpeg -i input1.avi -qscale:v 1 intermediate1.mpg
+ffmpeg -i input2.avi -qscale:v 1 intermediate2.mpg
+ffmpeg -i concat:&quot;intermediate1.mpg|intermediate2.mpg&quot; -c copy intermediate_all.mpg
+ffmpeg -i intermediate_all.mpg -qscale:v 2 output.avi
+</pre></div>
+
+<p>Note that you may need to escape the character &quot;|&quot; which is special for many
+shells.
+</p>
+<p>Another option is usage of named pipes, should your platform support it:
+</p>
+<div class="example">
+<pre class="example">mkfifo intermediate1.mpg
+mkfifo intermediate2.mpg
+ffmpeg -i input1.avi -qscale:v 1 -y intermediate1.mpg &lt; /dev/null &amp;
+ffmpeg -i input2.avi -qscale:v 1 -y intermediate2.mpg &lt; /dev/null &amp;
+cat intermediate1.mpg intermediate2.mpg |\
+ffmpeg -f mpeg -i - -c:v mpeg4 -c:a libmp3lame output.avi
+</pre></div>
+
+<a name="Concatenating-using-raw-audio-and-video"></a>
+<h4 class="subsection">3.14.4 Concatenating using raw audio and video<span class="pull-right"><a class="anchor hidden-xs" href="#Concatenating-using-raw-audio-and-video" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Concatenating-using-raw-audio-and-video" aria-hidden="true">TOC</a></span></h4>
+
+<p>Similarly, the yuv4mpegpipe format, and the raw video, raw audio codecs also
+allow concatenation, and the transcoding step is almost lossless.
+When using multiple yuv4mpegpipe(s), the first line needs to be discarded
+from all but the first stream. This can be accomplished by piping through
+<code>tail</code> as seen below. Note that when piping through <code>tail</code> you
+must use command grouping, <code>{  ;}</code>, to background properly.
+</p>
+<p>For example, let&rsquo;s say we want to concatenate two FLV files into an
+output.flv file:
+</p>
+<div class="example">
+<pre class="example">mkfifo temp1.a
+mkfifo temp1.v
+mkfifo temp2.a
+mkfifo temp2.v
+mkfifo all.a
+mkfifo all.v
+ffmpeg -i input1.flv -vn -f u16le -c:a pcm_s16le -ac 2 -ar 44100 - &gt; temp1.a &lt; /dev/null &amp;
+ffmpeg -i input2.flv -vn -f u16le -c:a pcm_s16le -ac 2 -ar 44100 - &gt; temp2.a &lt; /dev/null &amp;
+ffmpeg -i input1.flv -an -f yuv4mpegpipe - &gt; temp1.v &lt; /dev/null &amp;
+{ ffmpeg -i input2.flv -an -f yuv4mpegpipe - &lt; /dev/null | tail -n +2 &gt; temp2.v ; } &amp;
+cat temp1.a temp2.a &gt; all.a &amp;
+cat temp1.v temp2.v &gt; all.v &amp;
+ffmpeg -f u16le -c:a pcm_s16le -ac 2 -ar 44100 -i all.a \
+       -f yuv4mpegpipe -i all.v \
+       -y output.flv
+rm temp[12].[av] all.[av]
+</pre></div>
+
+<a name="Using-_002df-lavfi_002c-audio-becomes-mono-for-no-apparent-reason_002e"></a>
+<h3 class="section">3.15 Using <samp>-f lavfi</samp>, audio becomes mono for no apparent reason.<span class="pull-right"><a class="anchor hidden-xs" href="#Using-_002df-lavfi_002c-audio-becomes-mono-for-no-apparent-reason_002e" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Using-_002df-lavfi_002c-audio-becomes-mono-for-no-apparent-reason_002e" aria-hidden="true">TOC</a></span></h3>
+
+<p>Use <samp>-dumpgraph -</samp> to find out exactly where the channel layout is
+lost.
+</p>
+<p>Most likely, it is through <code>auto-inserted aresample</code>. Try to understand
+why the converting filter was needed at that place.
+</p>
+<p>Just before the output is a likely place, as <samp>-f lavfi</samp> currently
+only support packed S16.
+</p>
+<p>Then insert the correct <code>aformat</code> explicitly in the filtergraph,
+specifying the exact format.
+</p>
+<div class="example">
+<pre class="example">aformat=sample_fmts=s16:channel_layouts=stereo
+</pre></div>
+
+<a name="Why-does-FFmpeg-not-see-the-subtitles-in-my-VOB-file_003f"></a>
+<h3 class="section">3.16 Why does FFmpeg not see the subtitles in my VOB file?<span class="pull-right"><a class="anchor hidden-xs" href="#Why-does-FFmpeg-not-see-the-subtitles-in-my-VOB-file_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Why-does-FFmpeg-not-see-the-subtitles-in-my-VOB-file_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>VOB and a few other formats do not have a global header that describes
+everything present in the file. Instead, applications are supposed to scan
+the file to see what it contains. Since VOB files are frequently large, only
+the beginning is scanned. If the subtitles happen only later in the file,
+they will not be initially detected.
+</p>
+<p>Some applications, including the <code>ffmpeg</code> command-line tool, can only
+work with streams that were detected during the initial scan; streams that
+are detected later are ignored.
+</p>
+<p>The size of the initial scan is controlled by two options: <code>probesize</code>
+(default ~5 Mo) and <code>analyzeduration</code> (default 5,000,000 µs = 5 s). For
+the subtitle stream to be detected, both values must be large enough.
+</p>
+<a name="Why-was-the-ffmpeg-_002dsameq-option-removed_003f-What-to-use-instead_003f"></a>
+<h3 class="section">3.17 Why was the <code>ffmpeg</code> <samp>-sameq</samp> option removed? What to use instead?<span class="pull-right"><a class="anchor hidden-xs" href="#Why-was-the-ffmpeg-_002dsameq-option-removed_003f-What-to-use-instead_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Why-was-the-ffmpeg-_002dsameq-option-removed_003f-What-to-use-instead_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>The <samp>-sameq</samp> option meant &quot;same quantizer&quot;, and made sense only in a
+very limited set of cases. Unfortunately, a lot of people mistook it for
+&quot;same quality&quot; and used it in places where it did not make sense: it had
+roughly the expected visible effect, but achieved it in a very inefficient
+way.
+</p>
+<p>Each encoder has its own set of options to set the quality-vs-size balance,
+use the options for the encoder you are using to set the quality level to a
+point acceptable for your tastes. The most common options to do that are
+<samp>-qscale</samp> and <samp>-qmax</samp>, but you should peruse the documentation
+of the encoder you chose.
+</p>
+<a name="I-have-a-stretched-video_002c-why-does-scaling-does-not-fix-it_003f"></a>
+<h3 class="section">3.18 I have a stretched video, why does scaling does not fix it?<span class="pull-right"><a class="anchor hidden-xs" href="#I-have-a-stretched-video_002c-why-does-scaling-does-not-fix-it_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-I-have-a-stretched-video_002c-why-does-scaling-does-not-fix-it_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>A lot of video codecs and formats can store the <em>aspect ratio</em> of the
+video: this is the ratio between the width and the height of either the full
+image (DAR, display aspect ratio) or individual pixels (SAR, sample aspect
+ratio). For example, EGA screens at resolution 640×350 had 4:3 DAR and 35:48
+SAR.
+</p>
+<p>Most still image processing work with square pixels, i.e. 1:1 SAR, but a lot
+of video standards, especially from the analogic-numeric transition era, use
+non-square pixels.
+</p>
+<p>Most processing filters in FFmpeg handle the aspect ratio to avoid
+stretching the image: cropping adjusts the DAR to keep the SAR constant,
+scaling adjusts the SAR to keep the DAR constant.
+</p>
+<p>If you want to stretch, or “unstretch”, the image, you need to override the
+information with the
+<a href="ffmpeg-filters.html#setdar_002c-setsar"><code>setdar or setsar filters</code></a>.
+</p>
+<p>Do not forget to examine carefully the original video to check whether the
+stretching comes from the image or from the aspect ratio information.
+</p>
+<p>For example, to fix a badly encoded EGA capture, use the following commands,
+either the first one to upscale to square pixels or the second one to set
+the correct aspect ratio or the third one to avoid transcoding (may not work
+depending on the format / codec / player / phase of the moon):
+</p>
+<div class="example">
+<pre class="example">ffmpeg -i ega_screen.nut -vf scale=640:480,setsar=1 ega_screen_scaled.nut
+ffmpeg -i ega_screen.nut -vf setdar=4/3 ega_screen_anamorphic.nut
+ffmpeg -i ega_screen.nut -aspect 4/3 -c copy ega_screen_overridden.nut
+</pre></div>
+
+<span id="background-task"></span><a name="How-do-I-run-ffmpeg-as-a-background-task_003f"></a>
+<h3 class="section">3.19 How do I run ffmpeg as a background task?<span class="pull-right"><a class="anchor hidden-xs" href="#How-do-I-run-ffmpeg-as-a-background-task_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-How-do-I-run-ffmpeg-as-a-background-task_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>ffmpeg normally checks the console input, for entries like &quot;q&quot; to stop
+and &quot;?&quot; to give help, while performing operations. ffmpeg does not have a way of
+detecting when it is running as a background task.
+When it checks the console input, that can cause the process running ffmpeg
+in the background to suspend.
+</p>
+<p>To prevent those input checks, allowing ffmpeg to run as a background task,
+use the <a href="ffmpeg.html#stdin-option"><code>-nostdin</code> option</a>
+in the ffmpeg invocation. This is effective whether you run ffmpeg in a shell
+or invoke ffmpeg in its own process via an operating system API.
+</p>
+<p>As an alternative, when you are running ffmpeg in a shell, you can redirect
+standard input to <code>/dev/null</code> (on Linux and macOS)
+or <code>NUL</code> (on Windows). You can do this redirect either
+on the ffmpeg invocation, or from a shell script which calls ffmpeg.
+</p>
+<p>For example:
+</p>
+<div class="example">
+<pre class="example">ffmpeg -nostdin -i INPUT OUTPUT
+</pre></div>
+
+<p>or (on Linux, macOS, and other UNIX-like shells):
+</p>
+<div class="example">
+<pre class="example">ffmpeg -i INPUT OUTPUT &lt;/dev/null
+</pre></div>
+
+<p>or (on Windows):
+</p>
+<div class="example">
+<pre class="example">ffmpeg -i INPUT OUTPUT &lt;NUL
+</pre></div>
+
+<a name="How-do-I-prevent-ffmpeg-from-suspending-with-a-message-like-suspended-_0028tty-output_0029_003f"></a>
+<h3 class="section">3.20 How do I prevent ffmpeg from suspending with a message like <em>suspended (tty output)</em>?<span class="pull-right"><a class="anchor hidden-xs" href="#How-do-I-prevent-ffmpeg-from-suspending-with-a-message-like-suspended-_0028tty-output_0029_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-How-do-I-prevent-ffmpeg-from-suspending-with-a-message-like-suspended-_0028tty-output_0029_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>If you run ffmpeg in the background, you may find that its process suspends.
+There may be a message like <em>suspended (tty output)</em>. The question is how
+to prevent the process from being suspended.
+</p>
+<p>For example:
+</p>
+<div class="example">
+<pre class="example">% ffmpeg -i INPUT OUTPUT &amp;&gt; ~/tmp/log.txt &amp;
+[1] 93352
+%
+[1]  + suspended (tty output)  ffmpeg -i INPUT OUTPUT &amp;&gt;
+</pre></div>
+
+<p>The message &quot;tty output&quot; notwithstanding, the problem here is that
+ffmpeg normally checks the console input when it runs. The operating system
+detects this, and suspends the process until you can bring it to the
+foreground and attend to it.
+</p>
+<p>The solution is to use the right techniques to tell ffmpeg not to consult
+console input. You can use the
+<a href="ffmpeg.html#stdin-option"><code>-nostdin</code> option</a>,
+or redirect standard input with <code>&lt; /dev/null</code>.
+See FAQ
+<a href="#background-task"><em>How do I run ffmpeg as a background task?</em></a>
+for details.
+</p>
+<a name="Development"></a>
+<h2 class="chapter">4 Development<span class="pull-right"><a class="anchor hidden-xs" href="#Development" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Development" aria-hidden="true">TOC</a></span></h2>
+
+<a name="Are-there-examples-illustrating-how-to-use-the-FFmpeg-libraries_002c-particularly-libavcodec-and-libavformat_003f"></a>
+<h3 class="section">4.1 Are there examples illustrating how to use the FFmpeg libraries, particularly libavcodec and libavformat?<span class="pull-right"><a class="anchor hidden-xs" href="#Are-there-examples-illustrating-how-to-use-the-FFmpeg-libraries_002c-particularly-libavcodec-and-libavformat_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Are-there-examples-illustrating-how-to-use-the-FFmpeg-libraries_002c-particularly-libavcodec-and-libavformat_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>Yes. Check the <samp>doc/examples</samp> directory in the source
+repository, also available online at:
+<a href="https://github.com/FFmpeg/FFmpeg/tree/master/doc/examples">https://github.com/FFmpeg/FFmpeg/tree/master/doc/examples</a>.
+</p>
+<p>Examples are also installed by default, usually in
+<code>$PREFIX/share/ffmpeg/examples</code>.
+</p>
+<p>Also you may read the Developers Guide of the FFmpeg documentation. Alternatively,
+examine the source code for one of the many open source projects that
+already incorporate FFmpeg at (<a href="projects.html">projects.html</a>).
+</p>
+<a name="Can-you-support-my-C-compiler-XXX_003f"></a>
+<h3 class="section">4.2 Can you support my C compiler XXX?<span class="pull-right"><a class="anchor hidden-xs" href="#Can-you-support-my-C-compiler-XXX_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Can-you-support-my-C-compiler-XXX_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>It depends. If your compiler is C99-compliant, then patches to support
+it are likely to be welcome if they do not pollute the source code
+with <code>#ifdef</code>s related to the compiler.
+</p>
+<a name="Is-Microsoft-Visual-C_002b_002b-supported_003f"></a>
+<h3 class="section">4.3 Is Microsoft Visual C++ supported?<span class="pull-right"><a class="anchor hidden-xs" href="#Is-Microsoft-Visual-C_002b_002b-supported_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Is-Microsoft-Visual-C_002b_002b-supported_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>Yes. Please see the <a href="platform.html">Microsoft Visual C++</a>
+section in the FFmpeg documentation.
+</p>
+<a name="Can-you-add-automake_002c-libtool-or-autoconf-support_003f"></a>
+<h3 class="section">4.4 Can you add automake, libtool or autoconf support?<span class="pull-right"><a class="anchor hidden-xs" href="#Can-you-add-automake_002c-libtool-or-autoconf-support_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Can-you-add-automake_002c-libtool-or-autoconf-support_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>No. These tools are too bloated and they complicate the build.
+</p>
+<a name="Why-not-rewrite-FFmpeg-in-object_002doriented-C_002b_002b_003f"></a>
+<h3 class="section">4.5 Why not rewrite FFmpeg in object-oriented C++?<span class="pull-right"><a class="anchor hidden-xs" href="#Why-not-rewrite-FFmpeg-in-object_002doriented-C_002b_002b_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Why-not-rewrite-FFmpeg-in-object_002doriented-C_002b_002b_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>FFmpeg is already organized in a highly modular manner and does not need to
+be rewritten in a formal object language. Further, many of the developers
+favor straight C; it works for them. For more arguments on this matter,
+read <a href="https://web.archive.org/web/20111004021423/http://kernel.org/pub/linux/docs/lkml/#s15">&quot;Programming Religion&quot;</a>.
+</p>
+<a name="Why-are-the-ffmpeg-programs-devoid-of-debugging-symbols_003f"></a>
+<h3 class="section">4.6 Why are the ffmpeg programs devoid of debugging symbols?<span class="pull-right"><a class="anchor hidden-xs" href="#Why-are-the-ffmpeg-programs-devoid-of-debugging-symbols_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Why-are-the-ffmpeg-programs-devoid-of-debugging-symbols_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>The build process creates <code>ffmpeg_g</code>, <code>ffplay_g</code>, etc. which
+contain full debug information. Those binaries are stripped to create
+<code>ffmpeg</code>, <code>ffplay</code>, etc. If you need the debug information, use
+the *_g versions.
+</p>
+<a name="I-do-not-like-the-LGPL_002c-can-I-contribute-code-under-the-GPL-instead_003f"></a>
+<h3 class="section">4.7 I do not like the LGPL, can I contribute code under the GPL instead?<span class="pull-right"><a class="anchor hidden-xs" href="#I-do-not-like-the-LGPL_002c-can-I-contribute-code-under-the-GPL-instead_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-I-do-not-like-the-LGPL_002c-can-I-contribute-code-under-the-GPL-instead_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>Yes, as long as the code is optional and can easily and cleanly be placed
+under #if CONFIG_GPL without breaking anything. So, for example, a new codec
+or filter would be OK under GPL while a bug fix to LGPL code would not.
+</p>
+<a name="I_0027m-using-FFmpeg-from-within-my-C-application-but-the-linker-complains-about-missing-symbols-from-the-libraries-themselves_002e"></a>
+<h3 class="section">4.8 I&rsquo;m using FFmpeg from within my C application but the linker complains about missing symbols from the libraries themselves.<span class="pull-right"><a class="anchor hidden-xs" href="#I_0027m-using-FFmpeg-from-within-my-C-application-but-the-linker-complains-about-missing-symbols-from-the-libraries-themselves_002e" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-I_0027m-using-FFmpeg-from-within-my-C-application-but-the-linker-complains-about-missing-symbols-from-the-libraries-themselves_002e" aria-hidden="true">TOC</a></span></h3>
+
+<p>FFmpeg builds static libraries by default. In static libraries, dependencies
+are not handled. That has two consequences. First, you must specify the
+libraries in dependency order: <code>-lavdevice</code> must come before
+<code>-lavformat</code>, <code>-lavutil</code> must come after everything else, etc.
+Second, external libraries that are used in FFmpeg have to be specified too.
+</p>
+<p>An easy way to get the full list of required libraries in dependency order
+is to use <code>pkg-config</code>.
+</p>
+<div class="example">
+<pre class="example">c99 -o program program.c $(pkg-config --cflags --libs libavformat libavcodec)
+</pre></div>
+
+<p>See <samp>doc/example/Makefile</samp> and <samp>doc/example/pc-uninstalled</samp> for
+more details.
+</p>
+<a name="I_0027m-using-FFmpeg-from-within-my-C_002b_002b-application-but-the-linker-complains-about-missing-symbols-which-seem-to-be-available_002e"></a>
+<h3 class="section">4.9 I&rsquo;m using FFmpeg from within my C++ application but the linker complains about missing symbols which seem to be available.<span class="pull-right"><a class="anchor hidden-xs" href="#I_0027m-using-FFmpeg-from-within-my-C_002b_002b-application-but-the-linker-complains-about-missing-symbols-which-seem-to-be-available_002e" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-I_0027m-using-FFmpeg-from-within-my-C_002b_002b-application-but-the-linker-complains-about-missing-symbols-which-seem-to-be-available_002e" aria-hidden="true">TOC</a></span></h3>
+
+<p>FFmpeg is a pure C project, so to use the libraries within your C++ application
+you need to explicitly state that you are using a C library. You can do this by
+encompassing your FFmpeg includes using <code>extern &quot;C&quot;</code>.
+</p>
+<p>See <a href="http://www.parashift.com/c++-faq-lite/mixing-c-and-cpp.html#faq-32.3">http://www.parashift.com/c++-faq-lite/mixing-c-and-cpp.html#faq-32.3</a>
+</p>
+<a name="I_0027m-using-libavutil-from-within-my-C_002b_002b-application-but-the-compiler-complains-about-_0027UINT64_005fC_0027-was-not-declared-in-this-scope"></a>
+<h3 class="section">4.10 I&rsquo;m using libavutil from within my C++ application but the compiler complains about &rsquo;UINT64_C&rsquo; was not declared in this scope<span class="pull-right"><a class="anchor hidden-xs" href="#I_0027m-using-libavutil-from-within-my-C_002b_002b-application-but-the-compiler-complains-about-_0027UINT64_005fC_0027-was-not-declared-in-this-scope" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-I_0027m-using-libavutil-from-within-my-C_002b_002b-application-but-the-compiler-complains-about-_0027UINT64_005fC_0027-was-not-declared-in-this-scope" aria-hidden="true">TOC</a></span></h3>
+
+<p>FFmpeg is a pure C project using C99 math features, in order to enable C++
+to use them you have to append -D__STDC_CONSTANT_MACROS to your CXXFLAGS
+</p>
+<a name="I-have-a-file-in-memory-_002f-a-API-different-from-_002aopen_002f_002aread_002f-libc-how-do-I-use-it-with-libavformat_003f"></a>
+<h3 class="section">4.11 I have a file in memory / a API different from *open/*read/ libc how do I use it with libavformat?<span class="pull-right"><a class="anchor hidden-xs" href="#I-have-a-file-in-memory-_002f-a-API-different-from-_002aopen_002f_002aread_002f-libc-how-do-I-use-it-with-libavformat_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-I-have-a-file-in-memory-_002f-a-API-different-from-_002aopen_002f_002aread_002f-libc-how-do-I-use-it-with-libavformat_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>You have to create a custom AVIOContext using <code>avio_alloc_context</code>,
+see <samp>libavformat/aviobuf.c</samp> in FFmpeg and <samp>libmpdemux/demux_lavf.c</samp> in MPlayer or MPlayer2 sources.
+</p>
+<a name="Where-is-the-documentation-about-ffv1_002c-msmpeg4_002c-asv1_002c-4xm_003f"></a>
+<h3 class="section">4.12 Where is the documentation about ffv1, msmpeg4, asv1, 4xm?<span class="pull-right"><a class="anchor hidden-xs" href="#Where-is-the-documentation-about-ffv1_002c-msmpeg4_002c-asv1_002c-4xm_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Where-is-the-documentation-about-ffv1_002c-msmpeg4_002c-asv1_002c-4xm_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>see <a href="https://www.ffmpeg.org/~michael/">https://www.ffmpeg.org/~michael/</a>
+</p>
+<a name="How-do-I-feed-H_002e263_002dRTP-_0028and-other-codecs-in-RTP_0029-to-libavcodec_003f"></a>
+<h3 class="section">4.13 How do I feed H.263-RTP (and other codecs in RTP) to libavcodec?<span class="pull-right"><a class="anchor hidden-xs" href="#How-do-I-feed-H_002e263_002dRTP-_0028and-other-codecs-in-RTP_0029-to-libavcodec_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-How-do-I-feed-H_002e263_002dRTP-_0028and-other-codecs-in-RTP_0029-to-libavcodec_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>Even if peculiar since it is network oriented, RTP is a container like any
+other. You have to <em>demux</em> RTP before feeding the payload to libavcodec.
+In this specific case please look at RFC 4629 to see how it should be done.
+</p>
+<a name="AVStream_002er_005fframe_005frate-is-wrong_002c-it-is-much-larger-than-the-frame-rate_002e"></a>
+<h3 class="section">4.14 AVStream.r_frame_rate is wrong, it is much larger than the frame rate.<span class="pull-right"><a class="anchor hidden-xs" href="#AVStream_002er_005fframe_005frate-is-wrong_002c-it-is-much-larger-than-the-frame-rate_002e" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-AVStream_002er_005fframe_005frate-is-wrong_002c-it-is-much-larger-than-the-frame-rate_002e" aria-hidden="true">TOC</a></span></h3>
+
+<p><code>r_frame_rate</code> is NOT the average frame rate, it is the smallest frame rate
+that can accurately represent all timestamps. So no, it is not
+wrong if it is larger than the average!
+For example, if you have mixed 25 and 30 fps content, then <code>r_frame_rate</code>
+will be 150 (it is the least common multiple).
+If you are looking for the average frame rate, see <code>AVStream.avg_frame_rate</code>.
+</p>
+<a name="Why-is-make-fate-not-running-all-tests_003f"></a>
+<h3 class="section">4.15 Why is <code>make fate</code> not running all tests?<span class="pull-right"><a class="anchor hidden-xs" href="#Why-is-make-fate-not-running-all-tests_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Why-is-make-fate-not-running-all-tests_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>Make sure you have the fate-suite samples and the <code>SAMPLES</code> Make variable
+or <code>FATE_SAMPLES</code> environment variable or the <code>--samples</code>
+<code>configure</code> option is set to the right path.
+</p>
+<a name="Why-is-make-fate-not-finding-the-samples_003f"></a>
+<h3 class="section">4.16 Why is <code>make fate</code> not finding the samples?<span class="pull-right"><a class="anchor hidden-xs" href="#Why-is-make-fate-not-finding-the-samples_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Why-is-make-fate-not-finding-the-samples_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>Do you happen to have a <code>~</code> character in the samples path to indicate a
+home directory? The value is used in ways where the shell cannot expand it,
+causing FATE to not find files. Just replace <code>~</code> by the full path.
+</p>
+
+      <p style="font-size: small;">
+        This document was generated using <a href="http://www.gnu.org/software/texinfo/"><em>makeinfo</em></a>.
+      </p>
+    </div>
+  </body>
+</html>

ffmpeg-n4.3.2-win64-gpl-shared-4.3/doc/fate.html

@@ -0,0 +1,331 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
+  <head>
+    <meta charset="utf-8">
+    <title>
+      FFmpeg Automated Testing Environment
+    </title>
+    <meta name="viewport" content="width=device-width,initial-scale=1.0">
+    <link rel="stylesheet" type="text/css" href="bootstrap.min.css">
+    <link rel="stylesheet" type="text/css" href="style.min.css">
+  </head>
+  <body>
+    <div class="container">
+      <h1>
+      FFmpeg Automated Testing Environment
+      </h1>
+<div align="center">
+</div>
+
+
+<a name="Top"></a>
+<a name="SEC_Top"></a>
+
+<span id="SEC_Contents"></span>
+<h2 class="contents-heading">Table of Contents</h2>
+
+<div class="contents">
+
+<ul class="no-bullet">
+  <li><a id="toc-Introduction" href="#Introduction">1 Introduction</a></li>
+  <li><a id="toc-Using-FATE-from-your-FFmpeg-source-directory" href="#Using-FATE-from-your-FFmpeg-source-directory">2 Using FATE from your FFmpeg source directory</a></li>
+  <li><a id="toc-Submitting-the-results-to-the-FFmpeg-result-aggregation-server" href="#Submitting-the-results-to-the-FFmpeg-result-aggregation-server">3 Submitting the results to the FFmpeg result aggregation server</a></li>
+  <li><a id="toc-Uploading-new-samples-to-the-fate-suite" href="#Uploading-new-samples-to-the-fate-suite">4 Uploading new samples to the fate suite</a></li>
+  <li><a id="toc-FATE-makefile-targets-and-variables" href="#FATE-makefile-targets-and-variables">5 FATE makefile targets and variables</a>
+  <ul class="no-bullet">
+    <li><a id="toc-Makefile-targets" href="#Makefile-targets">5.1 Makefile targets</a></li>
+    <li><a id="toc-Makefile-variables" href="#Makefile-variables">5.2 Makefile variables</a></li>
+    <li><a id="toc-Examples" href="#Examples">5.3 Examples</a></li>
+  </ul></li>
+</ul>
+</div>
+
+
+<a name="Introduction"></a>
+<h2 class="chapter">1 Introduction<span class="pull-right"><a class="anchor hidden-xs" href="#Introduction" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Introduction" aria-hidden="true">TOC</a></span></h2>
+
+<p>FATE is an extended regression suite on the client-side and a means
+for results aggregation and presentation on the server-side.
+</p>
+<p>The first part of this document explains how you can use FATE from
+your FFmpeg source directory to test your ffmpeg binary. The second
+part describes how you can run FATE to submit the results to FFmpeg&rsquo;s
+FATE server.
+</p>
+<p>In any way you can have a look at the publicly viewable FATE results
+by visiting this website:
+</p>
+<p><a href="http://fate.ffmpeg.org/">http://fate.ffmpeg.org/</a>
+</p>
+<p>This is especially recommended for all people contributing source
+code to FFmpeg, as it can be seen if some test on some platform broke
+with their recent contribution. This usually happens on the platforms
+the developers could not test on.
+</p>
+<p>The second part of this document describes how you can run FATE to
+submit your results to FFmpeg&rsquo;s FATE server. If you want to submit your
+results be sure to check that your combination of CPU, OS and compiler
+is not already listed on the above mentioned website.
+</p>
+<p>In the third part you can find a comprehensive listing of FATE makefile
+targets and variables.
+</p>
+
+<a name="Using-FATE-from-your-FFmpeg-source-directory"></a>
+<h2 class="chapter">2 Using FATE from your FFmpeg source directory<span class="pull-right"><a class="anchor hidden-xs" href="#Using-FATE-from-your-FFmpeg-source-directory" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Using-FATE-from-your-FFmpeg-source-directory" aria-hidden="true">TOC</a></span></h2>
+
+<p>If you want to run FATE on your machine you need to have the samples
+in place. You can get the samples via the build target fate-rsync.
+Use this command from the top-level source directory:
+</p>
+<div class="example">
+<pre class="example">make fate-rsync SAMPLES=fate-suite/
+make fate       SAMPLES=fate-suite/
+</pre></div>
+
+<p>The above commands set the samples location by passing a makefile
+variable via command line. It is also possible to set the samples
+location at source configuration time by invoking configure with
+<samp>--samples=&lt;path to the samples directory&gt;</samp>. Afterwards you can
+invoke the makefile targets without setting the <var>SAMPLES</var> makefile
+variable. This is illustrated by the following commands:
+</p>
+<div class="example">
+<pre class="example">./configure --samples=fate-suite/
+make fate-rsync
+make fate
+</pre></div>
+
+<p>Yet another way to tell FATE about the location of the sample
+directory is by making sure the environment variable FATE_SAMPLES
+contains the path to your samples directory. This can be achieved
+by e.g. putting that variable in your shell profile or by setting
+it in your interactive session.
+</p>
+<div class="example">
+<pre class="example">FATE_SAMPLES=fate-suite/ make fate
+</pre></div>
+
+<div class="info">
+<p>Do not put a &rsquo;~&rsquo; character in the samples path to indicate a home
+directory. Because of shell nuances, this will cause FATE to fail.
+</p></div>
+<p>To use a custom wrapper to run the test, pass <samp>--target-exec</samp> to
+<code>configure</code> or set the <var>TARGET_EXEC</var> Make variable.
+</p>
+
+<a name="Submitting-the-results-to-the-FFmpeg-result-aggregation-server"></a>
+<h2 class="chapter">3 Submitting the results to the FFmpeg result aggregation server<span class="pull-right"><a class="anchor hidden-xs" href="#Submitting-the-results-to-the-FFmpeg-result-aggregation-server" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Submitting-the-results-to-the-FFmpeg-result-aggregation-server" aria-hidden="true">TOC</a></span></h2>
+
+<p>To submit your results to the server you should run fate through the
+shell script <samp>tests/fate.sh</samp> from the FFmpeg sources. This script needs
+to be invoked with a configuration file as its first argument.
+</p>
+<div class="example">
+<pre class="example">tests/fate.sh /path/to/fate_config
+</pre></div>
+
+<p>A configuration file template with comments describing the individual
+configuration variables can be found at <samp>doc/fate_config.sh.template</samp>.
+</p>
+<p>The mentioned configuration template is also available here:
+</p><pre class="verbatim">slot=                                    # some unique identifier
+repo=git://source.ffmpeg.org/ffmpeg.git  # the source repository
+#branch=release/2.6                       # the branch to test
+samples=                                 # path to samples directory
+workdir=                                 # directory in which to do all the work
+#fate_recv=&quot;ssh -T fate@fate.ffmpeg.org&quot; # command to submit report
+comment=                                 # optional description
+build_only=     # set to &quot;yes&quot; for a compile-only instance that skips tests
+ignore_tests=
+
+# the following are optional and map to configure options
+arch=
+cpu=
+cross_prefix=
+as=
+cc=
+ld=
+target_os=
+sysroot=
+target_exec=
+target_path=
+target_samples=
+extra_cflags=
+extra_ldflags=
+extra_libs=
+extra_conf=     # extra configure options not covered above
+
+#make=          # name of GNU make if not 'make'
+makeopts=       # extra options passed to 'make'
+#makeopts_fate= # extra options passed to 'make' when running tests,
+                # defaulting to makeopts above if this is not set
+#tar=           # command to create a tar archive from its arguments on stdout,
+                # defaults to 'tar c'
+</pre>
+<p>Create a configuration that suits your needs, based on the configuration
+template. The <code>slot</code> configuration variable can be any string that is not
+yet used, but it is suggested that you name it adhering to the following
+pattern &lsquo;<samp><var>arch</var>-<var>os</var>-<var>compiler</var>-<var>compiler version</var></samp>&rsquo;. The
+configuration file itself will be sourced in a shell script, therefore all
+shell features may be used. This enables you to setup the environment as you
+need it for your build.
+</p>
+<p>For your first test runs the <code>fate_recv</code> variable should be empty or
+commented out. This will run everything as normal except that it will omit
+the submission of the results to the server. The following files should be
+present in $workdir as specified in the configuration file:
+</p>
+<ul>
+<li> configure.log
+    </li><li> compile.log
+    </li><li> test.log
+    </li><li> report
+    </li><li> version
+</li></ul>
+
+<p>When you have everything working properly you can create an SSH key pair
+and send the public key to the FATE server administrator who can be contacted
+at the email address <a href="mailto:fate-admin@ffmpeg.org">fate-admin@ffmpeg.org</a>.
+</p>
+<p>Configure your SSH client to use public key authentication with that key
+when connecting to the FATE server. Also do not forget to check the identity
+of the server and to accept its host key. This can usually be achieved by
+running your SSH client manually and killing it after you accepted the key.
+The FATE server&rsquo;s fingerprint is:
+</p>
+<dl compact="compact">
+<dt>&lsquo;<samp>RSA</samp>&rsquo;</dt>
+<dd><p>d3:f1:83:97:a4:75:2b:a6:fb:d6:e8:aa:81:93:97:51
+</p></dd>
+<dt>&lsquo;<samp>ECDSA</samp>&rsquo;</dt>
+<dd><p>76:9f:68:32:04:1e:d5:d4:ec:47:3f:dc:fc:18:17:86
+</p></dd>
+</dl>
+
+<p>If you have problems connecting to the FATE server, it may help to try out
+the <code>ssh</code> command with one or more <samp>-v</samp> options. You should
+get detailed output concerning your SSH configuration and the authentication
+process.
+</p>
+<p>The only thing left is to automate the execution of the fate.sh script and
+the synchronisation of the samples directory.
+</p>
+<a name="Uploading-new-samples-to-the-fate-suite"></a>
+<h2 class="chapter">4 Uploading new samples to the fate suite<span class="pull-right"><a class="anchor hidden-xs" href="#Uploading-new-samples-to-the-fate-suite" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Uploading-new-samples-to-the-fate-suite" aria-hidden="true">TOC</a></span></h2>
+
+<p>If you need a sample uploaded send a mail to samples-request.
+</p>
+<p>This is for developers who have an account on the fate suite server.
+If you upload new samples, please make sure they are as small as possible,
+space on each client, network bandwidth and so on benefit from smaller test cases.
+Also keep in mind older checkouts use existing sample files, that means in
+practice generally do not replace, remove or overwrite files as it likely would
+break older checkouts or releases.
+Also all needed samples for a commit should be uploaded, ideally 24
+hours, before the push.
+If you need an account for frequently uploading samples or you wish to help
+others by doing that send a mail to ffmpeg-devel.
+</p>
+<div class="example">
+<pre class="example">#First update your local samples copy:
+rsync -vauL --chmod=Dg+s,Duo+x,ug+rw,o+r,o-w,+X fate-suite.ffmpeg.org:/home/samples/fate-suite/ ~/fate-suite
+
+#Then do a dry run checking what would be uploaded:
+rsync -vanL --no-g --chmod=Dg+s,Duo+x,ug+rw,o+r,o-w,+X ~/fate-suite/ fate-suite.ffmpeg.org:/home/samples/fate-suite
+
+#Upload the files:
+rsync -vaL  --no-g --chmod=Dg+s,Duo+x,ug+rw,o+r,o-w,+X ~/fate-suite/ fate-suite.ffmpeg.org:/home/samples/fate-suite
+</pre></div>
+
+
+<a name="FATE-makefile-targets-and-variables"></a>
+<h2 class="chapter">5 FATE makefile targets and variables<span class="pull-right"><a class="anchor hidden-xs" href="#FATE-makefile-targets-and-variables" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-FATE-makefile-targets-and-variables" aria-hidden="true">TOC</a></span></h2>
+
+<a name="Makefile-targets"></a>
+<h3 class="section">5.1 Makefile targets<span class="pull-right"><a class="anchor hidden-xs" href="#Makefile-targets" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Makefile-targets" aria-hidden="true">TOC</a></span></h3>
+
+<dl compact="compact">
+<dt><samp>fate-rsync</samp></dt>
+<dd><p>Download/synchronize sample files to the configured samples directory.
+</p>
+</dd>
+<dt><samp>fate-list</samp></dt>
+<dd><p>Will list all fate/regression test targets.
+</p>
+</dd>
+<dt><samp>fate</samp></dt>
+<dd><p>Run the FATE test suite (requires the fate-suite dataset).
+</p></dd>
+</dl>
+
+<a name="Makefile-variables"></a>
+<h3 class="section">5.2 Makefile variables<span class="pull-right"><a class="anchor hidden-xs" href="#Makefile-variables" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Makefile-variables" aria-hidden="true">TOC</a></span></h3>
+
+<dl compact="compact">
+<dt><code>V</code></dt>
+<dd><p>Verbosity level, can be set to 0, 1 or 2.
+    </p><ul>
+<li> 0: show just the test arguments
+        </li><li> 1: show just the command used in the test
+        </li><li> 2: show everything
+    </li></ul>
+
+</dd>
+<dt><code>SAMPLES</code></dt>
+<dd><p>Specify or override the path to the FATE samples at make time, it has a
+meaning only while running the regression tests.
+</p>
+</dd>
+<dt><code>THREADS</code></dt>
+<dd><p>Specify how many threads to use while running regression tests, it is
+quite useful to detect thread-related regressions.
+</p>
+</dd>
+<dt><code>THREAD_TYPE</code></dt>
+<dd><p>Specify which threading strategy test, either &lsquo;<samp>slice</samp>&rsquo; or &lsquo;<samp>frame</samp>&rsquo;,
+by default &lsquo;<samp>slice+frame</samp>&rsquo;
+</p>
+</dd>
+<dt><code>CPUFLAGS</code></dt>
+<dd><p>Specify CPU flags.
+</p>
+</dd>
+<dt><code>TARGET_EXEC</code></dt>
+<dd><p>Specify or override the wrapper used to run the tests.
+The <code>TARGET_EXEC</code> option provides a way to run FATE wrapped in
+<code>valgrind</code>, <code>qemu-user</code> or <code>wine</code> or on remote targets
+through <code>ssh</code>.
+</p>
+</dd>
+<dt><code>GEN</code></dt>
+<dd><p>Set to &lsquo;<samp>1</samp>&rsquo; to generate the missing or mismatched references.
+</p>
+</dd>
+<dt><code>HWACCEL</code></dt>
+<dd><p>Specify which hardware acceleration to use while running regression tests,
+by default &lsquo;<samp>none</samp>&rsquo; is used.
+</p>
+</dd>
+<dt><code>KEEP</code></dt>
+<dd><p>Set to &lsquo;<samp>1</samp>&rsquo; to keep temp files generated by fate test(s) when test is successful.
+Default is &lsquo;<samp>0</samp>&rsquo;, which removes these files. Files are always kept when a test
+fails.
+</p>
+</dd>
+</dl>
+
+<a name="Examples"></a>
+<h3 class="section">5.3 Examples<span class="pull-right"><a class="anchor hidden-xs" href="#Examples" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Examples" aria-hidden="true">TOC</a></span></h3>
+
+<div class="example">
+<pre class="example">make V=1 SAMPLES=/var/fate/samples THREADS=2 CPUFLAGS=mmx fate
+</pre></div>
+
+      <p style="font-size: small;">
+        This document was generated using <a href="http://www.gnu.org/software/texinfo/"><em>makeinfo</em></a>.
+      </p>
+    </div>
+  </body>
+</html>

ffmpeg-n4.3.2-win64-gpl-shared-4.3/doc/ffmpeg-bitstream-filters.html

@@ -0,0 +1,953 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
+  <head>
+    <meta charset="utf-8">
+    <title>
+      FFmpeg Bitstream Filters Documentation
+    </title>
+    <meta name="viewport" content="width=device-width,initial-scale=1.0">
+    <link rel="stylesheet" type="text/css" href="bootstrap.min.css">
+    <link rel="stylesheet" type="text/css" href="style.min.css">
+  </head>
+  <body>
+    <div class="container">
+      <h1>
+      FFmpeg Bitstream Filters Documentation
+      </h1>
+<div align="center">
+</div>
+
+
+<a name="SEC_Top"></a>
+
+<span id="SEC_Contents"></span>
+<h2 class="contents-heading">Table of Contents</h2>
+
+<div class="contents">
+
+<ul class="no-bullet">
+  <li><a id="toc-Description" href="#Description">1 Description</a></li>
+  <li><a id="toc-Bitstream-Filters" href="#Bitstream-Filters">2 Bitstream Filters</a>
+  <ul class="no-bullet">
+    <li><a id="toc-aac_005fadtstoasc" href="#aac_005fadtstoasc">2.1 aac_adtstoasc</a></li>
+    <li><a id="toc-av1_005fmetadata" href="#av1_005fmetadata">2.2 av1_metadata</a></li>
+    <li><a id="toc-chomp" href="#chomp">2.3 chomp</a></li>
+    <li><a id="toc-dca_005fcore" href="#dca_005fcore">2.4 dca_core</a></li>
+    <li><a id="toc-dump_005fextra" href="#dump_005fextra">2.5 dump_extra</a></li>
+    <li><a id="toc-eac3_005fcore" href="#eac3_005fcore">2.6 eac3_core</a></li>
+    <li><a id="toc-extract_005fextradata" href="#extract_005fextradata">2.7 extract_extradata</a></li>
+    <li><a id="toc-filter_005funits" href="#filter_005funits">2.8 filter_units</a></li>
+    <li><a id="toc-hapqa_005fextract" href="#hapqa_005fextract">2.9 hapqa_extract</a></li>
+    <li><a id="toc-h264_005fmetadata" href="#h264_005fmetadata">2.10 h264_metadata</a></li>
+    <li><a id="toc-h264_005fmp4toannexb" href="#h264_005fmp4toannexb">2.11 h264_mp4toannexb</a></li>
+    <li><a id="toc-h264_005fredundant_005fpps" href="#h264_005fredundant_005fpps">2.12 h264_redundant_pps</a></li>
+    <li><a id="toc-hevc_005fmetadata" href="#hevc_005fmetadata">2.13 hevc_metadata</a></li>
+    <li><a id="toc-hevc_005fmp4toannexb" href="#hevc_005fmp4toannexb">2.14 hevc_mp4toannexb</a></li>
+    <li><a id="toc-imxdump" href="#imxdump">2.15 imxdump</a></li>
+    <li><a id="toc-mjpeg2jpeg" href="#mjpeg2jpeg">2.16 mjpeg2jpeg</a></li>
+    <li><a id="toc-mjpegadump" href="#mjpegadump">2.17 mjpegadump</a></li>
+    <li><a id="toc-mov2textsub-1" href="#mov2textsub-1">2.18 mov2textsub</a></li>
+    <li><a id="toc-mp3decomp" href="#mp3decomp">2.19 mp3decomp</a></li>
+    <li><a id="toc-mpeg2_005fmetadata" href="#mpeg2_005fmetadata">2.20 mpeg2_metadata</a></li>
+    <li><a id="toc-mpeg4_005funpack_005fbframes" href="#mpeg4_005funpack_005fbframes">2.21 mpeg4_unpack_bframes</a></li>
+    <li><a id="toc-noise" href="#noise">2.22 noise</a></li>
+    <li><a id="toc-null" href="#null">2.23 null</a></li>
+    <li><a id="toc-pcm_005frechunk" href="#pcm_005frechunk">2.24 pcm_rechunk</a></li>
+    <li><a id="toc-prores_005fmetadata" href="#prores_005fmetadata">2.25 prores_metadata</a></li>
+    <li><a id="toc-remove_005fextra" href="#remove_005fextra">2.26 remove_extra</a></li>
+    <li><a id="toc-text2movsub-1" href="#text2movsub-1">2.27 text2movsub</a></li>
+    <li><a id="toc-trace_005fheaders" href="#trace_005fheaders">2.28 trace_headers</a></li>
+    <li><a id="toc-truehd_005fcore" href="#truehd_005fcore">2.29 truehd_core</a></li>
+    <li><a id="toc-vp9_005fmetadata" href="#vp9_005fmetadata">2.30 vp9_metadata</a></li>
+    <li><a id="toc-vp9_005fsuperframe" href="#vp9_005fsuperframe">2.31 vp9_superframe</a></li>
+    <li><a id="toc-vp9_005fsuperframe_005fsplit" href="#vp9_005fsuperframe_005fsplit">2.32 vp9_superframe_split</a></li>
+    <li><a id="toc-vp9_005fraw_005freorder" href="#vp9_005fraw_005freorder">2.33 vp9_raw_reorder</a></li>
+  </ul></li>
+  <li><a id="toc-See-Also" href="#See-Also">3 See Also</a></li>
+  <li><a id="toc-Authors" href="#Authors">4 Authors</a></li>
+</ul>
+</div>
+
+
+<a name="Description"></a>
+<h2 class="chapter">1 Description<span class="pull-right"><a class="anchor hidden-xs" href="#Description" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Description" aria-hidden="true">TOC</a></span></h2>
+
+<p>This document describes the bitstream filters provided by the
+libavcodec library.
+</p>
+<p>A bitstream filter operates on the encoded stream data, and performs
+bitstream level modifications without performing decoding.
+</p>
+
+<a name="Bitstream-Filters"></a>
+<h2 class="chapter">2 Bitstream Filters<span class="pull-right"><a class="anchor hidden-xs" href="#Bitstream-Filters" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Bitstream-Filters" aria-hidden="true">TOC</a></span></h2>
+
+<p>When you configure your FFmpeg build, all the supported bitstream
+filters are enabled by default. You can list all available ones using
+the configure option <code>--list-bsfs</code>.
+</p>
+<p>You can disable all the bitstream filters using the configure option
+<code>--disable-bsfs</code>, and selectively enable any bitstream filter using
+the option <code>--enable-bsf=BSF</code>, or you can disable a particular
+bitstream filter using the option <code>--disable-bsf=BSF</code>.
+</p>
+<p>The option <code>-bsfs</code> of the ff* tools will display the list of
+all the supported bitstream filters included in your build.
+</p>
+<p>The ff* tools have a -bsf option applied per stream, taking a
+comma-separated list of filters, whose parameters follow the filter
+name after a &rsquo;=&rsquo;.
+</p>
+<div class="example">
+<pre class="example">ffmpeg -i INPUT -c:v copy -bsf:v filter1[=opt1=str1:opt2=str2][,filter2] OUTPUT
+</pre></div>
+
+<p>Below is a description of the currently available bitstream filters,
+with their parameters, if any.
+</p>
+<a name="aac_005fadtstoasc"></a>
+<h3 class="section">2.1 aac_adtstoasc<span class="pull-right"><a class="anchor hidden-xs" href="#aac_005fadtstoasc" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-aac_005fadtstoasc" aria-hidden="true">TOC</a></span></h3>
+
+<p>Convert MPEG-2/4 AAC ADTS to an MPEG-4 Audio Specific Configuration
+bitstream.
+</p>
+<p>This filter creates an MPEG-4 AudioSpecificConfig from an MPEG-2/4
+ADTS header and removes the ADTS header.
+</p>
+<p>This filter is required for example when copying an AAC stream from a
+raw ADTS AAC or an MPEG-TS container to MP4A-LATM, to an FLV file, or
+to MOV/MP4 files and related formats such as 3GP or M4A. Please note
+that it is auto-inserted for MP4A-LATM and MOV/MP4 and related formats.
+</p>
+<a name="av1_005fmetadata"></a>
+<h3 class="section">2.2 av1_metadata<span class="pull-right"><a class="anchor hidden-xs" href="#av1_005fmetadata" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-av1_005fmetadata" aria-hidden="true">TOC</a></span></h3>
+
+<p>Modify metadata embedded in an AV1 stream.
+</p>
+<dl compact="compact">
+<dt><samp>td</samp></dt>
+<dd><p>Insert or remove temporal delimiter OBUs in all temporal units of the
+stream.
+</p>
+<dl compact="compact">
+<dt>&lsquo;<samp>insert</samp>&rsquo;</dt>
+<dd><p>Insert a TD at the beginning of every TU which does not already have one.
+</p></dd>
+<dt>&lsquo;<samp>remove</samp>&rsquo;</dt>
+<dd><p>Remove the TD from the beginning of every TU which has one.
+</p></dd>
+</dl>
+
+</dd>
+<dt><samp>color_primaries</samp></dt>
+<dt><samp>transfer_characteristics</samp></dt>
+<dt><samp>matrix_coefficients</samp></dt>
+<dd><p>Set the color description fields in the stream (see AV1 section 6.4.2).
+</p>
+</dd>
+<dt><samp>color_range</samp></dt>
+<dd><p>Set the color range in the stream (see AV1 section 6.4.2; note that
+this cannot be set for streams using BT.709 primaries, sRGB transfer
+characteristic and identity (RGB) matrix coefficients).
+</p><dl compact="compact">
+<dt>&lsquo;<samp>tv</samp>&rsquo;</dt>
+<dd><p>Limited range.
+</p></dd>
+<dt>&lsquo;<samp>pc</samp>&rsquo;</dt>
+<dd><p>Full range.
+</p></dd>
+</dl>
+
+</dd>
+<dt><samp>chroma_sample_position</samp></dt>
+<dd><p>Set the chroma sample location in the stream (see AV1 section 6.4.2).
+This can only be set for 4:2:0 streams.
+</p>
+<dl compact="compact">
+<dt>&lsquo;<samp>vertical</samp>&rsquo;</dt>
+<dd><p>Left position (matching the default in MPEG-2 and H.264).
+</p></dd>
+<dt>&lsquo;<samp>colocated</samp>&rsquo;</dt>
+<dd><p>Top-left position.
+</p></dd>
+</dl>
+
+</dd>
+<dt><samp>tick_rate</samp></dt>
+<dd><p>Set the tick rate (<em>num_units_in_display_tick / time_scale</em>) in
+the timing info in the sequence header.
+</p></dd>
+<dt><samp>num_ticks_per_picture</samp></dt>
+<dd><p>Set the number of ticks in each picture, to indicate that the stream
+has a fixed framerate.  Ignored if <samp>tick_rate</samp> is not also set.
+</p>
+</dd>
+<dt><samp>delete_padding</samp></dt>
+<dd><p>Deletes Padding OBUs.
+</p>
+</dd>
+</dl>
+
+<a name="chomp"></a>
+<h3 class="section">2.3 chomp<span class="pull-right"><a class="anchor hidden-xs" href="#chomp" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-chomp" aria-hidden="true">TOC</a></span></h3>
+
+<p>Remove zero padding at the end of a packet.
+</p>
+<a name="dca_005fcore"></a>
+<h3 class="section">2.4 dca_core<span class="pull-right"><a class="anchor hidden-xs" href="#dca_005fcore" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-dca_005fcore" aria-hidden="true">TOC</a></span></h3>
+
+<p>Extract the core from a DCA/DTS stream, dropping extensions such as
+DTS-HD.
+</p>
+<a name="dump_005fextra"></a>
+<h3 class="section">2.5 dump_extra<span class="pull-right"><a class="anchor hidden-xs" href="#dump_005fextra" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-dump_005fextra" aria-hidden="true">TOC</a></span></h3>
+
+<p>Add extradata to the beginning of the filtered packets except when
+said packets already exactly begin with the extradata that is intended
+to be added.
+</p>
+<dl compact="compact">
+<dt><samp>freq</samp></dt>
+<dd><p>The additional argument specifies which packets should be filtered.
+It accepts the values:
+</p><dl compact="compact">
+<dt>&lsquo;<samp>k</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>keyframe</samp>&rsquo;</dt>
+<dd><p>add extradata to all key packets
+</p>
+</dd>
+<dt>&lsquo;<samp>e</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>all</samp>&rsquo;</dt>
+<dd><p>add extradata to all packets
+</p></dd>
+</dl>
+</dd>
+</dl>
+
+<p>If not specified it is assumed &lsquo;<samp>k</samp>&rsquo;.
+</p>
+<p>For example the following <code>ffmpeg</code> command forces a global
+header (thus disabling individual packet headers) in the H.264 packets
+generated by the <code>libx264</code> encoder, but corrects them by adding
+the header stored in extradata to the key packets:
+</p><div class="example">
+<pre class="example">ffmpeg -i INPUT -map 0 -flags:v +global_header -c:v libx264 -bsf:v dump_extra out.ts
+</pre></div>
+
+<a name="eac3_005fcore"></a>
+<h3 class="section">2.6 eac3_core<span class="pull-right"><a class="anchor hidden-xs" href="#eac3_005fcore" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-eac3_005fcore" aria-hidden="true">TOC</a></span></h3>
+
+<p>Extract the core from a E-AC-3 stream, dropping extra channels.
+</p>
+<a name="extract_005fextradata"></a>
+<h3 class="section">2.7 extract_extradata<span class="pull-right"><a class="anchor hidden-xs" href="#extract_005fextradata" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-extract_005fextradata" aria-hidden="true">TOC</a></span></h3>
+
+<p>Extract the in-band extradata.
+</p>
+<p>Certain codecs allow the long-term headers (e.g. MPEG-2 sequence headers,
+or H.264/HEVC (VPS/)SPS/PPS) to be transmitted either &quot;in-band&quot; (i.e. as a part
+of the bitstream containing the coded frames) or &quot;out of band&quot; (e.g. on the
+container level). This latter form is called &quot;extradata&quot; in FFmpeg terminology.
+</p>
+<p>This bitstream filter detects the in-band headers and makes them available as
+extradata.
+</p>
+<dl compact="compact">
+<dt><samp>remove</samp></dt>
+<dd><p>When this option is enabled, the long-term headers are removed from the
+bitstream after extraction.
+</p></dd>
+</dl>
+
+<a name="filter_005funits"></a>
+<h3 class="section">2.8 filter_units<span class="pull-right"><a class="anchor hidden-xs" href="#filter_005funits" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-filter_005funits" aria-hidden="true">TOC</a></span></h3>
+
+<p>Remove units with types in or not in a given set from the stream.
+</p>
+<dl compact="compact">
+<dt><samp>pass_types</samp></dt>
+<dd><p>List of unit types or ranges of unit types to pass through while removing
+all others.  This is specified as a &rsquo;|&rsquo;-separated list of unit type values
+or ranges of values with &rsquo;-&rsquo;.
+</p>
+</dd>
+<dt><samp>remove_types</samp></dt>
+<dd><p>Identical to <samp>pass_types</samp>, except the units in the given set
+removed and all others passed through.
+</p></dd>
+</dl>
+
+<p>Extradata is unchanged by this transformation, but note that if the stream
+contains inline parameter sets then the output may be unusable if they are
+removed.
+</p>
+<p>For example, to remove all non-VCL NAL units from an H.264 stream:
+</p><div class="example">
+<pre class="example">ffmpeg -i INPUT -c:v copy -bsf:v 'filter_units=pass_types=1-5' OUTPUT
+</pre></div>
+
+<p>To remove all AUDs, SEI and filler from an H.265 stream:
+</p><div class="example">
+<pre class="example">ffmpeg -i INPUT -c:v copy -bsf:v 'filter_units=remove_types=35|38-40' OUTPUT
+</pre></div>
+
+<a name="hapqa_005fextract"></a>
+<h3 class="section">2.9 hapqa_extract<span class="pull-right"><a class="anchor hidden-xs" href="#hapqa_005fextract" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-hapqa_005fextract" aria-hidden="true">TOC</a></span></h3>
+
+<p>Extract Rgb or Alpha part of an HAPQA file, without recompression, in order to create an HAPQ or an HAPAlphaOnly file.
+</p>
+<dl compact="compact">
+<dt><samp>texture</samp></dt>
+<dd><p>Specifies the texture to keep.
+</p>
+<dl compact="compact">
+<dt><samp>color</samp></dt>
+<dt><samp>alpha</samp></dt>
+</dl>
+
+</dd>
+</dl>
+
+<p>Convert HAPQA to HAPQ
+</p><div class="example">
+<pre class="example">ffmpeg -i hapqa_inputfile.mov -c copy -bsf:v hapqa_extract=texture=color -tag:v HapY -metadata:s:v:0 encoder=&quot;HAPQ&quot; hapq_file.mov
+</pre></div>
+
+<p>Convert HAPQA to HAPAlphaOnly
+</p><div class="example">
+<pre class="example">ffmpeg -i hapqa_inputfile.mov -c copy -bsf:v hapqa_extract=texture=alpha -tag:v HapA -metadata:s:v:0 encoder=&quot;HAPAlpha Only&quot; hapalphaonly_file.mov
+</pre></div>
+
+<a name="h264_005fmetadata"></a>
+<h3 class="section">2.10 h264_metadata<span class="pull-right"><a class="anchor hidden-xs" href="#h264_005fmetadata" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-h264_005fmetadata" aria-hidden="true">TOC</a></span></h3>
+
+<p>Modify metadata embedded in an H.264 stream.
+</p>
+<dl compact="compact">
+<dt><samp>aud</samp></dt>
+<dd><p>Insert or remove AUD NAL units in all access units of the stream.
+</p>
+<dl compact="compact">
+<dt>&lsquo;<samp>insert</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>remove</samp>&rsquo;</dt>
+</dl>
+
+</dd>
+<dt><samp>sample_aspect_ratio</samp></dt>
+<dd><p>Set the sample aspect ratio of the stream in the VUI parameters.
+</p>
+</dd>
+<dt><samp>overscan_appropriate_flag</samp></dt>
+<dd><p>Set whether the stream is suitable for display using overscan
+or not (see H.264 section E.2.1).
+</p>
+</dd>
+<dt><samp>video_format</samp></dt>
+<dt><samp>video_full_range_flag</samp></dt>
+<dd><p>Set the video format in the stream (see H.264 section E.2.1 and
+table E-2).
+</p>
+</dd>
+<dt><samp>colour_primaries</samp></dt>
+<dt><samp>transfer_characteristics</samp></dt>
+<dt><samp>matrix_coefficients</samp></dt>
+<dd><p>Set the colour description in the stream (see H.264 section E.2.1
+and tables E-3, E-4 and E-5).
+</p>
+</dd>
+<dt><samp>chroma_sample_loc_type</samp></dt>
+<dd><p>Set the chroma sample location in the stream (see H.264 section
+E.2.1 and figure E-1).
+</p>
+</dd>
+<dt><samp>tick_rate</samp></dt>
+<dd><p>Set the tick rate (num_units_in_tick / time_scale) in the VUI
+parameters.  This is the smallest time unit representable in the
+stream, and in many cases represents the field rate of the stream
+(double the frame rate).
+</p></dd>
+<dt><samp>fixed_frame_rate_flag</samp></dt>
+<dd><p>Set whether the stream has fixed framerate - typically this indicates
+that the framerate is exactly half the tick rate, but the exact
+meaning is dependent on interlacing and the picture structure (see
+H.264 section E.2.1 and table E-6).
+</p>
+</dd>
+<dt><samp>crop_left</samp></dt>
+<dt><samp>crop_right</samp></dt>
+<dt><samp>crop_top</samp></dt>
+<dt><samp>crop_bottom</samp></dt>
+<dd><p>Set the frame cropping offsets in the SPS.  These values will replace
+the current ones if the stream is already cropped.
+</p>
+<p>These fields are set in pixels.  Note that some sizes may not be
+representable if the chroma is subsampled or the stream is interlaced
+(see H.264 section 7.4.2.1.1).
+</p>
+</dd>
+<dt><samp>sei_user_data</samp></dt>
+<dd><p>Insert a string as SEI unregistered user data.  The argument must
+be of the form <em>UUID+string</em>, where the UUID is as hex digits
+possibly separated by hyphens, and the string can be anything.
+</p>
+<p>For example, &lsquo;<samp>086f3693-b7b3-4f2c-9653-21492feee5b8+hello</samp>&rsquo; will
+insert the string &ldquo;hello&rdquo; associated with the given UUID.
+</p>
+</dd>
+<dt><samp>delete_filler</samp></dt>
+<dd><p>Deletes both filler NAL units and filler SEI messages.
+</p>
+</dd>
+<dt><samp>level</samp></dt>
+<dd><p>Set the level in the SPS.  Refer to H.264 section A.3 and tables A-1
+to A-5.
+</p>
+<p>The argument must be the name of a level (for example, &lsquo;<samp>4.2</samp>&rsquo;), a
+level_idc value (for example, &lsquo;<samp>42</samp>&rsquo;), or the special name &lsquo;<samp>auto</samp>&rsquo;
+indicating that the filter should attempt to guess the level from the
+input stream properties.
+</p>
+</dd>
+</dl>
+
+<a name="h264_005fmp4toannexb"></a>
+<h3 class="section">2.11 h264_mp4toannexb<span class="pull-right"><a class="anchor hidden-xs" href="#h264_005fmp4toannexb" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-h264_005fmp4toannexb" aria-hidden="true">TOC</a></span></h3>
+
+<p>Convert an H.264 bitstream from length prefixed mode to start code
+prefixed mode (as defined in the Annex B of the ITU-T H.264
+specification).
+</p>
+<p>This is required by some streaming formats, typically the MPEG-2
+transport stream format (muxer <code>mpegts</code>).
+</p>
+<p>For example to remux an MP4 file containing an H.264 stream to mpegts
+format with <code>ffmpeg</code>, you can use the command:
+</p>
+<div class="example">
+<pre class="example">ffmpeg -i INPUT.mp4 -codec copy -bsf:v h264_mp4toannexb OUTPUT.ts
+</pre></div>
+
+<p>Please note that this filter is auto-inserted for MPEG-TS (muxer
+<code>mpegts</code>) and raw H.264 (muxer <code>h264</code>) output formats.
+</p>
+<a name="h264_005fredundant_005fpps"></a>
+<h3 class="section">2.12 h264_redundant_pps<span class="pull-right"><a class="anchor hidden-xs" href="#h264_005fredundant_005fpps" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-h264_005fredundant_005fpps" aria-hidden="true">TOC</a></span></h3>
+
+<p>This applies a specific fixup to some Blu-ray streams which contain
+redundant PPSs modifying irrelevant parameters of the stream which
+confuse other transformations which require correct extradata.
+</p>
+<p>A new single global PPS is created, and all of the redundant PPSs
+within the stream are removed.
+</p>
+<a name="hevc_005fmetadata"></a>
+<h3 class="section">2.13 hevc_metadata<span class="pull-right"><a class="anchor hidden-xs" href="#hevc_005fmetadata" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-hevc_005fmetadata" aria-hidden="true">TOC</a></span></h3>
+
+<p>Modify metadata embedded in an HEVC stream.
+</p>
+<dl compact="compact">
+<dt><samp>aud</samp></dt>
+<dd><p>Insert or remove AUD NAL units in all access units of the stream.
+</p>
+<dl compact="compact">
+<dt>&lsquo;<samp>insert</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>remove</samp>&rsquo;</dt>
+</dl>
+
+</dd>
+<dt><samp>sample_aspect_ratio</samp></dt>
+<dd><p>Set the sample aspect ratio in the stream in the VUI parameters.
+</p>
+</dd>
+<dt><samp>video_format</samp></dt>
+<dt><samp>video_full_range_flag</samp></dt>
+<dd><p>Set the video format in the stream (see H.265 section E.3.1 and
+table E.2).
+</p>
+</dd>
+<dt><samp>colour_primaries</samp></dt>
+<dt><samp>transfer_characteristics</samp></dt>
+<dt><samp>matrix_coefficients</samp></dt>
+<dd><p>Set the colour description in the stream (see H.265 section E.3.1
+and tables E.3, E.4 and E.5).
+</p>
+</dd>
+<dt><samp>chroma_sample_loc_type</samp></dt>
+<dd><p>Set the chroma sample location in the stream (see H.265 section
+E.3.1 and figure E.1).
+</p>
+</dd>
+<dt><samp>tick_rate</samp></dt>
+<dd><p>Set the tick rate in the VPS and VUI parameters (num_units_in_tick /
+time_scale).  Combined with <samp>num_ticks_poc_diff_one</samp>, this can
+set a constant framerate in the stream.  Note that it is likely to be
+overridden by container parameters when the stream is in a container.
+</p>
+</dd>
+<dt><samp>num_ticks_poc_diff_one</samp></dt>
+<dd><p>Set poc_proportional_to_timing_flag in VPS and VUI and use this value
+to set num_ticks_poc_diff_one_minus1 (see H.265 sections 7.4.3.1 and
+E.3.1).  Ignored if <samp>tick_rate</samp> is not also set.
+</p>
+</dd>
+<dt><samp>crop_left</samp></dt>
+<dt><samp>crop_right</samp></dt>
+<dt><samp>crop_top</samp></dt>
+<dt><samp>crop_bottom</samp></dt>
+<dd><p>Set the conformance window cropping offsets in the SPS.  These values
+will replace the current ones if the stream is already cropped.
+</p>
+<p>These fields are set in pixels.  Note that some sizes may not be
+representable if the chroma is subsampled (H.265 section 7.4.3.2.1).
+</p>
+</dd>
+<dt><samp>level</samp></dt>
+<dd><p>Set the level in the VPS and SPS.  See H.265 section A.4 and tables
+A.6 and A.7.
+</p>
+<p>The argument must be the name of a level (for example, &lsquo;<samp>5.1</samp>&rsquo;), a
+<em>general_level_idc</em> value (for example, &lsquo;<samp>153</samp>&rsquo; for level 5.1),
+or the special name &lsquo;<samp>auto</samp>&rsquo; indicating that the filter should
+attempt to guess the level from the input stream properties.
+</p>
+</dd>
+</dl>
+
+<a name="hevc_005fmp4toannexb"></a>
+<h3 class="section">2.14 hevc_mp4toannexb<span class="pull-right"><a class="anchor hidden-xs" href="#hevc_005fmp4toannexb" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-hevc_005fmp4toannexb" aria-hidden="true">TOC</a></span></h3>
+
+<p>Convert an HEVC/H.265 bitstream from length prefixed mode to start code
+prefixed mode (as defined in the Annex B of the ITU-T H.265
+specification).
+</p>
+<p>This is required by some streaming formats, typically the MPEG-2
+transport stream format (muxer <code>mpegts</code>).
+</p>
+<p>For example to remux an MP4 file containing an HEVC stream to mpegts
+format with <code>ffmpeg</code>, you can use the command:
+</p>
+<div class="example">
+<pre class="example">ffmpeg -i INPUT.mp4 -codec copy -bsf:v hevc_mp4toannexb OUTPUT.ts
+</pre></div>
+
+<p>Please note that this filter is auto-inserted for MPEG-TS (muxer
+<code>mpegts</code>) and raw HEVC/H.265 (muxer <code>h265</code> or
+<code>hevc</code>) output formats.
+</p>
+<a name="imxdump"></a>
+<h3 class="section">2.15 imxdump<span class="pull-right"><a class="anchor hidden-xs" href="#imxdump" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-imxdump" aria-hidden="true">TOC</a></span></h3>
+
+<p>Modifies the bitstream to fit in MOV and to be usable by the Final Cut
+Pro decoder. This filter only applies to the mpeg2video codec, and is
+likely not needed for Final Cut Pro 7 and newer with the appropriate
+<samp>-tag:v</samp>.
+</p>
+<p>For example, to remux 30 MB/sec NTSC IMX to MOV:
+</p>
+<div class="example">
+<pre class="example">ffmpeg -i input.mxf -c copy -bsf:v imxdump -tag:v mx3n output.mov
+</pre></div>
+
+<a name="mjpeg2jpeg"></a>
+<h3 class="section">2.16 mjpeg2jpeg<span class="pull-right"><a class="anchor hidden-xs" href="#mjpeg2jpeg" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-mjpeg2jpeg" aria-hidden="true">TOC</a></span></h3>
+
+<p>Convert MJPEG/AVI1 packets to full JPEG/JFIF packets.
+</p>
+<p>MJPEG is a video codec wherein each video frame is essentially a
+JPEG image. The individual frames can be extracted without loss,
+e.g. by
+</p>
+<div class="example">
+<pre class="example">ffmpeg -i ../some_mjpeg.avi -c:v copy frames_%d.jpg
+</pre></div>
+
+<p>Unfortunately, these chunks are incomplete JPEG images, because
+they lack the DHT segment required for decoding. Quoting from
+<a href="http://www.digitalpreservation.gov/formats/fdd/fdd000063.shtml">http://www.digitalpreservation.gov/formats/fdd/fdd000063.shtml</a>:
+</p>
+<p>Avery Lee, writing in the rec.video.desktop newsgroup in 2001,
+commented that &quot;MJPEG, or at least the MJPEG in AVIs having the
+MJPG fourcc, is restricted JPEG with a fixed &ndash; and *omitted* &ndash;
+Huffman table. The JPEG must be YCbCr colorspace, it must be 4:2:2,
+and it must use basic Huffman encoding, not arithmetic or
+progressive. . . . You can indeed extract the MJPEG frames and
+decode them with a regular JPEG decoder, but you have to prepend
+the DHT segment to them, or else the decoder won&rsquo;t have any idea
+how to decompress the data. The exact table necessary is given in
+the OpenDML spec.&quot;
+</p>
+<p>This bitstream filter patches the header of frames extracted from an MJPEG
+stream (carrying the AVI1 header ID and lacking a DHT segment) to
+produce fully qualified JPEG images.
+</p>
+<div class="example">
+<pre class="example">ffmpeg -i mjpeg-movie.avi -c:v copy -bsf:v mjpeg2jpeg frame_%d.jpg
+exiftran -i -9 frame*.jpg
+ffmpeg -i frame_%d.jpg -c:v copy rotated.avi
+</pre></div>
+
+<a name="mjpegadump"></a>
+<h3 class="section">2.17 mjpegadump<span class="pull-right"><a class="anchor hidden-xs" href="#mjpegadump" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-mjpegadump" aria-hidden="true">TOC</a></span></h3>
+
+<p>Add an MJPEG A header to the bitstream, to enable decoding by
+Quicktime.
+</p>
+<span id="mov2textsub"></span><a name="mov2textsub-1"></a>
+<h3 class="section">2.18 mov2textsub<span class="pull-right"><a class="anchor hidden-xs" href="#mov2textsub-1" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-mov2textsub-1" aria-hidden="true">TOC</a></span></h3>
+
+<p>Extract a representable text file from MOV subtitles, stripping the
+metadata header from each subtitle packet.
+</p>
+<p>See also the <a href="#text2movsub">text2movsub</a> filter.
+</p>
+<a name="mp3decomp"></a>
+<h3 class="section">2.19 mp3decomp<span class="pull-right"><a class="anchor hidden-xs" href="#mp3decomp" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-mp3decomp" aria-hidden="true">TOC</a></span></h3>
+
+<p>Decompress non-standard compressed MP3 audio headers.
+</p>
+<a name="mpeg2_005fmetadata"></a>
+<h3 class="section">2.20 mpeg2_metadata<span class="pull-right"><a class="anchor hidden-xs" href="#mpeg2_005fmetadata" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-mpeg2_005fmetadata" aria-hidden="true">TOC</a></span></h3>
+
+<p>Modify metadata embedded in an MPEG-2 stream.
+</p>
+<dl compact="compact">
+<dt><samp>display_aspect_ratio</samp></dt>
+<dd><p>Set the display aspect ratio in the stream.
+</p>
+<p>The following fixed values are supported:
+</p><dl compact="compact">
+<dt><samp>4/3</samp></dt>
+<dt><samp>16/9</samp></dt>
+<dt><samp>221/100</samp></dt>
+</dl>
+<p>Any other value will result in square pixels being signalled instead
+(see H.262 section 6.3.3 and table 6-3).
+</p>
+</dd>
+<dt><samp>frame_rate</samp></dt>
+<dd><p>Set the frame rate in the stream.  This is constructed from a table
+of known values combined with a small multiplier and divisor - if
+the supplied value is not exactly representable, the nearest
+representable value will be used instead (see H.262 section 6.3.3
+and table 6-4).
+</p>
+</dd>
+<dt><samp>video_format</samp></dt>
+<dd><p>Set the video format in the stream (see H.262 section 6.3.6 and
+table 6-6).
+</p>
+</dd>
+<dt><samp>colour_primaries</samp></dt>
+<dt><samp>transfer_characteristics</samp></dt>
+<dt><samp>matrix_coefficients</samp></dt>
+<dd><p>Set the colour description in the stream (see H.262 section 6.3.6
+and tables 6-7, 6-8 and 6-9).
+</p>
+</dd>
+</dl>
+
+<a name="mpeg4_005funpack_005fbframes"></a>
+<h3 class="section">2.21 mpeg4_unpack_bframes<span class="pull-right"><a class="anchor hidden-xs" href="#mpeg4_005funpack_005fbframes" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-mpeg4_005funpack_005fbframes" aria-hidden="true">TOC</a></span></h3>
+
+<p>Unpack DivX-style packed B-frames.
+</p>
+<p>DivX-style packed B-frames are not valid MPEG-4 and were only a
+workaround for the broken Video for Windows subsystem.
+They use more space, can cause minor AV sync issues, require more
+CPU power to decode (unless the player has some decoded picture queue
+to compensate the 2,0,2,0 frame per packet style) and cause
+trouble if copied into a standard container like mp4 or mpeg-ps/ts,
+because MPEG-4 decoders may not be able to decode them, since they are
+not valid MPEG-4.
+</p>
+<p>For example to fix an AVI file containing an MPEG-4 stream with
+DivX-style packed B-frames using <code>ffmpeg</code>, you can use the command:
+</p>
+<div class="example">
+<pre class="example">ffmpeg -i INPUT.avi -codec copy -bsf:v mpeg4_unpack_bframes OUTPUT.avi
+</pre></div>
+
+<a name="noise"></a>
+<h3 class="section">2.22 noise<span class="pull-right"><a class="anchor hidden-xs" href="#noise" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-noise" aria-hidden="true">TOC</a></span></h3>
+
+<p>Damages the contents of packets or simply drops them without damaging the
+container. Can be used for fuzzing or testing error resilience/concealment.
+</p>
+<p>Parameters:
+</p><dl compact="compact">
+<dt><samp>amount</samp></dt>
+<dd><p>A numeral string, whose value is related to how often output bytes will
+be modified. Therefore, values below or equal to 0 are forbidden, and
+the lower the more frequent bytes will be modified, with 1 meaning
+every byte is modified.
+</p></dd>
+<dt><samp>dropamount</samp></dt>
+<dd><p>A numeral string, whose value is related to how often packets will be dropped.
+Therefore, values below or equal to 0 are forbidden, and the lower the more
+frequent packets will be dropped, with 1 meaning every packet is dropped.
+</p></dd>
+</dl>
+
+<p>The following example applies the modification to every byte but does not drop
+any packets.
+</p><div class="example">
+<pre class="example">ffmpeg -i INPUT -c copy -bsf noise[=1] output.mkv
+</pre></div>
+
+<a name="null"></a>
+<h3 class="section">2.23 null<span class="pull-right"><a class="anchor hidden-xs" href="#null" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-null" aria-hidden="true">TOC</a></span></h3>
+<p>This bitstream filter passes the packets through unchanged.
+</p>
+<a name="pcm_005frechunk"></a>
+<h3 class="section">2.24 pcm_rechunk<span class="pull-right"><a class="anchor hidden-xs" href="#pcm_005frechunk" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-pcm_005frechunk" aria-hidden="true">TOC</a></span></h3>
+
+<p>Repacketize PCM audio to a fixed number of samples per packet or a fixed packet
+rate per second. This is similar to the <a href="ffmpeg-filters.html#asetnsamples">(ffmpeg-filters)asetnsamples audio
+filter</a> but works on audio packets instead of audio frames.
+</p>
+<dl compact="compact">
+<dt><samp>nb_out_samples, n</samp></dt>
+<dd><p>Set the number of samples per each output audio packet. The number is intended
+as the number of samples <em>per each channel</em>. Default value is 1024.
+</p>
+</dd>
+<dt><samp>pad, p</samp></dt>
+<dd><p>If set to 1, the filter will pad the last audio packet with silence, so that it
+will contain the same number of samples (or roughly the same number of samples,
+see <samp>frame_rate</samp>) as the previous ones. Default value is 1.
+</p>
+</dd>
+<dt><samp>frame_rate, r</samp></dt>
+<dd><p>This option makes the filter output a fixed number of packets per second instead
+of a fixed number of samples per packet. If the audio sample rate is not
+divisible by the frame rate then the number of samples will not be constant but
+will vary slightly so that each packet will start as close to the frame
+boundary as possible. Using this option has precedence over <samp>nb_out_samples</samp>.
+</p></dd>
+</dl>
+
+<p>You can generate the well known 1602-1601-1602-1601-1602 pattern of 48kHz audio
+for NTSC frame rate using the <samp>frame_rate</samp> option.
+</p><div class="example">
+<pre class="example">ffmpeg -f lavfi -i sine=r=48000:d=1 -c pcm_s16le -bsf pcm_rechunk=r=30000/1001 -f framecrc -
+</pre></div>
+
+<a name="prores_005fmetadata"></a>
+<h3 class="section">2.25 prores_metadata<span class="pull-right"><a class="anchor hidden-xs" href="#prores_005fmetadata" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-prores_005fmetadata" aria-hidden="true">TOC</a></span></h3>
+
+<p>Modify color property metadata embedded in prores stream.
+</p>
+<dl compact="compact">
+<dt><samp>color_primaries</samp></dt>
+<dd><p>Set the color primaries.
+Available values are:
+</p>
+<dl compact="compact">
+<dt>&lsquo;<samp>auto</samp>&rsquo;</dt>
+<dd><p>Keep the same color primaries property (default).
+</p>
+</dd>
+<dt>&lsquo;<samp>unknown</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>bt709</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>bt470bg</samp>&rsquo;</dt>
+<dd><p>BT601 625
+</p>
+</dd>
+<dt>&lsquo;<samp>smpte170m</samp>&rsquo;</dt>
+<dd><p>BT601 525
+</p>
+</dd>
+<dt>&lsquo;<samp>bt2020</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>smpte431</samp>&rsquo;</dt>
+<dd><p>DCI P3
+</p>
+</dd>
+<dt>&lsquo;<samp>smpte432</samp>&rsquo;</dt>
+<dd><p>P3 D65
+</p>
+</dd>
+</dl>
+
+</dd>
+<dt><samp>transfer_characteristics</samp></dt>
+<dd><p>Set the color transfer.
+Available values are:
+</p>
+<dl compact="compact">
+<dt>&lsquo;<samp>auto</samp>&rsquo;</dt>
+<dd><p>Keep the same transfer characteristics property (default).
+</p>
+</dd>
+<dt>&lsquo;<samp>unknown</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>bt709</samp>&rsquo;</dt>
+<dd><p>BT 601, BT 709, BT 2020
+</p></dd>
+<dt>&lsquo;<samp>smpte2084</samp>&rsquo;</dt>
+<dd><p>SMPTE ST 2084
+</p></dd>
+<dt>&lsquo;<samp>arib-std-b67</samp>&rsquo;</dt>
+<dd><p>ARIB STD-B67
+</p></dd>
+</dl>
+
+
+</dd>
+<dt><samp>matrix_coefficients</samp></dt>
+<dd><p>Set the matrix coefficient.
+Available values are:
+</p>
+<dl compact="compact">
+<dt>&lsquo;<samp>auto</samp>&rsquo;</dt>
+<dd><p>Keep the same colorspace property (default).
+</p>
+</dd>
+<dt>&lsquo;<samp>unknown</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>bt709</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>smpte170m</samp>&rsquo;</dt>
+<dd><p>BT 601
+</p>
+</dd>
+<dt>&lsquo;<samp>bt2020nc</samp>&rsquo;</dt>
+</dl>
+</dd>
+</dl>
+
+<p>Set Rec709 colorspace for each frame of the file
+</p><div class="example">
+<pre class="example">ffmpeg -i INPUT -c copy -bsf:v prores_metadata=color_primaries=bt709:color_trc=bt709:colorspace=bt709 output.mov
+</pre></div>
+
+<p>Set Hybrid Log-Gamma parameters for each frame of the file
+</p><div class="example">
+<pre class="example">ffmpeg -i INPUT -c copy -bsf:v prores_metadata=color_primaries=bt2020:color_trc=arib-std-b67:colorspace=bt2020nc output.mov
+</pre></div>
+
+<a name="remove_005fextra"></a>
+<h3 class="section">2.26 remove_extra<span class="pull-right"><a class="anchor hidden-xs" href="#remove_005fextra" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-remove_005fextra" aria-hidden="true">TOC</a></span></h3>
+
+<p>Remove extradata from packets.
+</p>
+<p>It accepts the following parameter:
+</p><dl compact="compact">
+<dt><samp>freq</samp></dt>
+<dd><p>Set which frame types to remove extradata from.
+</p>
+<dl compact="compact">
+<dt>&lsquo;<samp>k</samp>&rsquo;</dt>
+<dd><p>Remove extradata from non-keyframes only.
+</p>
+</dd>
+<dt>&lsquo;<samp>keyframe</samp>&rsquo;</dt>
+<dd><p>Remove extradata from keyframes only.
+</p>
+</dd>
+<dt>&lsquo;<samp>e, all</samp>&rsquo;</dt>
+<dd><p>Remove extradata from all frames.
+</p>
+</dd>
+</dl>
+</dd>
+</dl>
+
+<span id="text2movsub"></span><a name="text2movsub-1"></a>
+<h3 class="section">2.27 text2movsub<span class="pull-right"><a class="anchor hidden-xs" href="#text2movsub-1" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-text2movsub-1" aria-hidden="true">TOC</a></span></h3>
+
+<p>Convert text subtitles to MOV subtitles (as used by the <code>mov_text</code>
+codec) with metadata headers.
+</p>
+<p>See also the <a href="#mov2textsub">mov2textsub</a> filter.
+</p>
+<a name="trace_005fheaders"></a>
+<h3 class="section">2.28 trace_headers<span class="pull-right"><a class="anchor hidden-xs" href="#trace_005fheaders" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-trace_005fheaders" aria-hidden="true">TOC</a></span></h3>
+
+<p>Log trace output containing all syntax elements in the coded stream
+headers (everything above the level of individual coded blocks).
+This can be useful for debugging low-level stream issues.
+</p>
+<p>Supports AV1, H.264, H.265, (M)JPEG, MPEG-2 and VP9, but depending
+on the build only a subset of these may be available.
+</p>
+<a name="truehd_005fcore"></a>
+<h3 class="section">2.29 truehd_core<span class="pull-right"><a class="anchor hidden-xs" href="#truehd_005fcore" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-truehd_005fcore" aria-hidden="true">TOC</a></span></h3>
+
+<p>Extract the core from a TrueHD stream, dropping ATMOS data.
+</p>
+<a name="vp9_005fmetadata"></a>
+<h3 class="section">2.30 vp9_metadata<span class="pull-right"><a class="anchor hidden-xs" href="#vp9_005fmetadata" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-vp9_005fmetadata" aria-hidden="true">TOC</a></span></h3>
+
+<p>Modify metadata embedded in a VP9 stream.
+</p>
+<dl compact="compact">
+<dt><samp>color_space</samp></dt>
+<dd><p>Set the color space value in the frame header.  Note that any frame
+set to RGB will be implicitly set to PC range and that RGB is
+incompatible with profiles 0 and 2.
+</p><dl compact="compact">
+<dt>&lsquo;<samp>unknown</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>bt601</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>bt709</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>smpte170</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>smpte240</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>bt2020</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>rgb</samp>&rsquo;</dt>
+</dl>
+
+</dd>
+<dt><samp>color_range</samp></dt>
+<dd><p>Set the color range value in the frame header.  Note that any value
+imposed by the color space will take precedence over this value.
+</p><dl compact="compact">
+<dt>&lsquo;<samp>tv</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>pc</samp>&rsquo;</dt>
+</dl>
+</dd>
+</dl>
+
+<a name="vp9_005fsuperframe"></a>
+<h3 class="section">2.31 vp9_superframe<span class="pull-right"><a class="anchor hidden-xs" href="#vp9_005fsuperframe" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-vp9_005fsuperframe" aria-hidden="true">TOC</a></span></h3>
+
+<p>Merge VP9 invisible (alt-ref) frames back into VP9 superframes. This
+fixes merging of split/segmented VP9 streams where the alt-ref frame
+was split from its visible counterpart.
+</p>
+<a name="vp9_005fsuperframe_005fsplit"></a>
+<h3 class="section">2.32 vp9_superframe_split<span class="pull-right"><a class="anchor hidden-xs" href="#vp9_005fsuperframe_005fsplit" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-vp9_005fsuperframe_005fsplit" aria-hidden="true">TOC</a></span></h3>
+
+<p>Split VP9 superframes into single frames.
+</p>
+<a name="vp9_005fraw_005freorder"></a>
+<h3 class="section">2.33 vp9_raw_reorder<span class="pull-right"><a class="anchor hidden-xs" href="#vp9_005fraw_005freorder" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-vp9_005fraw_005freorder" aria-hidden="true">TOC</a></span></h3>
+
+<p>Given a VP9 stream with correct timestamps but possibly out of order,
+insert additional show-existing-frame packets to correct the ordering.
+</p>
+
+<a name="See-Also"></a>
+<h2 class="chapter">3 See Also<span class="pull-right"><a class="anchor hidden-xs" href="#See-Also" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-See-Also" aria-hidden="true">TOC</a></span></h2>
+
+<p><a href="ffmpeg.html">ffmpeg</a>, <a href="ffplay.html">ffplay</a>, <a href="ffprobe.html">ffprobe</a>,
+<a href="libavcodec.html">libavcodec</a>
+</p>
+
+<a name="Authors"></a>
+<h2 class="chapter">4 Authors<span class="pull-right"><a class="anchor hidden-xs" href="#Authors" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Authors" aria-hidden="true">TOC</a></span></h2>
+
+<p>The FFmpeg developers.
+</p>
+<p>For details about the authorship, see the Git history of the project
+(git://source.ffmpeg.org/ffmpeg), e.g. by typing the command
+<code>git log</code> in the FFmpeg source directory, or browsing the
+online repository at <a href="http://source.ffmpeg.org">http://source.ffmpeg.org</a>.
+</p>
+<p>Maintainers for the specific components are listed in the file
+<samp>MAINTAINERS</samp> in the source code tree.
+</p>
+
+
+      <p style="font-size: small;">
+        This document was generated using <a href="http://www.gnu.org/software/texinfo/"><em>makeinfo</em></a>.
+      </p>
+    </div>
+  </body>
+</html>

ffmpeg-n4.3.2-win64-gpl-shared-4.3/doc/ffmpeg-resampler.html

@@ -0,0 +1,365 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
+  <head>
+    <meta charset="utf-8">
+    <title>
+      FFmpeg Resampler Documentation
+    </title>
+    <meta name="viewport" content="width=device-width,initial-scale=1.0">
+    <link rel="stylesheet" type="text/css" href="bootstrap.min.css">
+    <link rel="stylesheet" type="text/css" href="style.min.css">
+  </head>
+  <body>
+    <div class="container">
+      <h1>
+      FFmpeg Resampler Documentation
+      </h1>
+<div align="center">
+</div>
+
+
+<a name="SEC_Top"></a>
+
+<span id="SEC_Contents"></span>
+<h2 class="contents-heading">Table of Contents</h2>
+
+<div class="contents">
+
+<ul class="no-bullet">
+  <li><a id="toc-Description" href="#Description">1 Description</a></li>
+  <li><a id="toc-Resampler-Options" href="#Resampler-Options">2 Resampler Options</a></li>
+  <li><a id="toc-See-Also" href="#See-Also">3 See Also</a></li>
+  <li><a id="toc-Authors" href="#Authors">4 Authors</a></li>
+</ul>
+</div>
+
+
+<a name="Description"></a>
+<h2 class="chapter">1 Description<span class="pull-right"><a class="anchor hidden-xs" href="#Description" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Description" aria-hidden="true">TOC</a></span></h2>
+
+<p>The FFmpeg resampler provides a high-level interface to the
+libswresample library audio resampling utilities. In particular it
+allows one to perform audio resampling, audio channel layout rematrixing,
+and convert audio format and packing layout.
+</p>
+
+<a name="Resampler-Options"></a>
+<h2 class="chapter">2 Resampler Options<span class="pull-right"><a class="anchor hidden-xs" href="#Resampler-Options" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Resampler-Options" aria-hidden="true">TOC</a></span></h2>
+
+<p>The audio resampler supports the following named options.
+</p>
+<p>Options may be set by specifying -<var>option</var> <var>value</var> in the
+FFmpeg tools, <var>option</var>=<var>value</var> for the aresample filter,
+by setting the value explicitly in the
+<code>SwrContext</code> options or using the <samp>libavutil/opt.h</samp> API for
+programmatic use.
+</p>
+<dl compact="compact">
+<dt><samp>ich, in_channel_count</samp></dt>
+<dd><p>Set the number of input channels. Default value is 0. Setting this
+value is not mandatory if the corresponding channel layout
+<samp>in_channel_layout</samp> is set.
+</p>
+</dd>
+<dt><samp>och, out_channel_count</samp></dt>
+<dd><p>Set the number of output channels. Default value is 0. Setting this
+value is not mandatory if the corresponding channel layout
+<samp>out_channel_layout</samp> is set.
+</p>
+</dd>
+<dt><samp>uch, used_channel_count</samp></dt>
+<dd><p>Set the number of used input channels. Default value is 0. This option is
+only used for special remapping.
+</p>
+</dd>
+<dt><samp>isr, in_sample_rate</samp></dt>
+<dd><p>Set the input sample rate. Default value is 0.
+</p>
+</dd>
+<dt><samp>osr, out_sample_rate</samp></dt>
+<dd><p>Set the output sample rate. Default value is 0.
+</p>
+</dd>
+<dt><samp>isf, in_sample_fmt</samp></dt>
+<dd><p>Specify the input sample format. It is set by default to <code>none</code>.
+</p>
+</dd>
+<dt><samp>osf, out_sample_fmt</samp></dt>
+<dd><p>Specify the output sample format. It is set by default to <code>none</code>.
+</p>
+</dd>
+<dt><samp>tsf, internal_sample_fmt</samp></dt>
+<dd><p>Set the internal sample format. Default value is <code>none</code>.
+This will automatically be chosen when it is not explicitly set.
+</p>
+</dd>
+<dt><samp>icl, in_channel_layout</samp></dt>
+<dt><samp>ocl, out_channel_layout</samp></dt>
+<dd><p>Set the input/output channel layout.
+</p>
+<p>See <a href="ffmpeg-utils.html#channel-layout-syntax">(ffmpeg-utils)the Channel Layout section in the ffmpeg-utils(1) manual</a>
+for the required syntax.
+</p>
+</dd>
+<dt><samp>clev, center_mix_level</samp></dt>
+<dd><p>Set the center mix level. It is a value expressed in deciBel, and must be
+in the interval [-32,32].
+</p>
+</dd>
+<dt><samp>slev, surround_mix_level</samp></dt>
+<dd><p>Set the surround mix level. It is a value expressed in deciBel, and must
+be in the interval [-32,32].
+</p>
+</dd>
+<dt><samp>lfe_mix_level</samp></dt>
+<dd><p>Set LFE mix into non LFE level. It is used when there is a LFE input but no
+LFE output. It is a value expressed in deciBel, and must
+be in the interval [-32,32].
+</p>
+</dd>
+<dt><samp>rmvol, rematrix_volume</samp></dt>
+<dd><p>Set rematrix volume. Default value is 1.0.
+</p>
+</dd>
+<dt><samp>rematrix_maxval</samp></dt>
+<dd><p>Set maximum output value for rematrixing.
+This can be used to prevent clipping vs. preventing volume reduction.
+A value of 1.0 prevents clipping.
+</p>
+</dd>
+<dt><samp>flags, swr_flags</samp></dt>
+<dd><p>Set flags used by the converter. Default value is 0.
+</p>
+<p>It supports the following individual flags:
+</p><dl compact="compact">
+<dt><samp>res</samp></dt>
+<dd><p>force resampling, this flag forces resampling to be used even when the
+input and output sample rates match.
+</p></dd>
+</dl>
+
+</dd>
+<dt><samp>dither_scale</samp></dt>
+<dd><p>Set the dither scale. Default value is 1.
+</p>
+</dd>
+<dt><samp>dither_method</samp></dt>
+<dd><p>Set dither method. Default value is 0.
+</p>
+<p>Supported values:
+</p><dl compact="compact">
+<dt>&lsquo;<samp>rectangular</samp>&rsquo;</dt>
+<dd><p>select rectangular dither
+</p></dd>
+<dt>&lsquo;<samp>triangular</samp>&rsquo;</dt>
+<dd><p>select triangular dither
+</p></dd>
+<dt>&lsquo;<samp>triangular_hp</samp>&rsquo;</dt>
+<dd><p>select triangular dither with high pass
+</p></dd>
+<dt>&lsquo;<samp>lipshitz</samp>&rsquo;</dt>
+<dd><p>select Lipshitz noise shaping dither.
+</p></dd>
+<dt>&lsquo;<samp>shibata</samp>&rsquo;</dt>
+<dd><p>select Shibata noise shaping dither.
+</p></dd>
+<dt>&lsquo;<samp>low_shibata</samp>&rsquo;</dt>
+<dd><p>select low Shibata noise shaping dither.
+</p></dd>
+<dt>&lsquo;<samp>high_shibata</samp>&rsquo;</dt>
+<dd><p>select high Shibata noise shaping dither.
+</p></dd>
+<dt>&lsquo;<samp>f_weighted</samp>&rsquo;</dt>
+<dd><p>select f-weighted noise shaping dither
+</p></dd>
+<dt>&lsquo;<samp>modified_e_weighted</samp>&rsquo;</dt>
+<dd><p>select modified-e-weighted noise shaping dither
+</p></dd>
+<dt>&lsquo;<samp>improved_e_weighted</samp>&rsquo;</dt>
+<dd><p>select improved-e-weighted noise shaping dither
+</p>
+</dd>
+</dl>
+
+</dd>
+<dt><samp>resampler</samp></dt>
+<dd><p>Set resampling engine. Default value is swr.
+</p>
+<p>Supported values:
+</p><dl compact="compact">
+<dt>&lsquo;<samp>swr</samp>&rsquo;</dt>
+<dd><p>select the native SW Resampler; filter options precision and cheby are not
+applicable in this case.
+</p></dd>
+<dt>&lsquo;<samp>soxr</samp>&rsquo;</dt>
+<dd><p>select the SoX Resampler (where available); compensation, and filter options
+filter_size, phase_shift, exact_rational, filter_type &amp; kaiser_beta, are not
+applicable in this case.
+</p></dd>
+</dl>
+
+</dd>
+<dt><samp>filter_size</samp></dt>
+<dd><p>For swr only, set resampling filter size, default value is 32.
+</p>
+</dd>
+<dt><samp>phase_shift</samp></dt>
+<dd><p>For swr only, set resampling phase shift, default value is 10, and must be in
+the interval [0,30].
+</p>
+</dd>
+<dt><samp>linear_interp</samp></dt>
+<dd><p>Use linear interpolation when enabled (the default). Disable it if you want
+to preserve speed instead of quality when exact_rational fails.
+</p>
+</dd>
+<dt><samp>exact_rational</samp></dt>
+<dd><p>For swr only, when enabled, try to use exact phase_count based on input and
+output sample rate. However, if it is larger than <code>1 &lt;&lt; phase_shift</code>,
+the phase_count will be <code>1 &lt;&lt; phase_shift</code> as fallback. Default is enabled.
+</p>
+</dd>
+<dt><samp>cutoff</samp></dt>
+<dd><p>Set cutoff frequency (swr: 6dB point; soxr: 0dB point) ratio; must be a float
+value between 0 and 1.  Default value is 0.97 with swr, and 0.91 with soxr
+(which, with a sample-rate of 44100, preserves the entire audio band to 20kHz).
+</p>
+</dd>
+<dt><samp>precision</samp></dt>
+<dd><p>For soxr only, the precision in bits to which the resampled signal will be
+calculated.  The default value of 20 (which, with suitable dithering, is
+appropriate for a destination bit-depth of 16) gives SoX&rsquo;s &rsquo;High Quality&rsquo;; a
+value of 28 gives SoX&rsquo;s &rsquo;Very High Quality&rsquo;.
+</p>
+</dd>
+<dt><samp>cheby</samp></dt>
+<dd><p>For soxr only, selects passband rolloff none (Chebyshev) &amp; higher-precision
+approximation for &rsquo;irrational&rsquo; ratios. Default value is 0.
+</p>
+</dd>
+<dt><samp>async</samp></dt>
+<dd><p>For swr only, simple 1 parameter audio sync to timestamps using stretching,
+squeezing, filling and trimming. Setting this to 1 will enable filling and
+trimming, larger values represent the maximum amount in samples that the data
+may be stretched or squeezed for each second.
+Default value is 0, thus no compensation is applied to make the samples match
+the audio timestamps.
+</p>
+</dd>
+<dt><samp>first_pts</samp></dt>
+<dd><p>For swr only, assume the first pts should be this value. The time unit is 1 / sample rate.
+This allows for padding/trimming at the start of stream. By default, no
+assumption is made about the first frame&rsquo;s expected pts, so no padding or
+trimming is done. For example, this could be set to 0 to pad the beginning with
+silence if an audio stream starts after the video stream or to trim any samples
+with a negative pts due to encoder delay.
+</p>
+</dd>
+<dt><samp>min_comp</samp></dt>
+<dd><p>For swr only, set the minimum difference between timestamps and audio data (in
+seconds) to trigger stretching/squeezing/filling or trimming of the
+data to make it match the timestamps. The default is that
+stretching/squeezing/filling and trimming is disabled
+(<samp>min_comp</samp> = <code>FLT_MAX</code>).
+</p>
+</dd>
+<dt><samp>min_hard_comp</samp></dt>
+<dd><p>For swr only, set the minimum difference between timestamps and audio data (in
+seconds) to trigger adding/dropping samples to make it match the
+timestamps.  This option effectively is a threshold to select between
+hard (trim/fill) and soft (squeeze/stretch) compensation. Note that
+all compensation is by default disabled through <samp>min_comp</samp>.
+The default is 0.1.
+</p>
+</dd>
+<dt><samp>comp_duration</samp></dt>
+<dd><p>For swr only, set duration (in seconds) over which data is stretched/squeezed
+to make it match the timestamps. Must be a non-negative double float value,
+default value is 1.0.
+</p>
+</dd>
+<dt><samp>max_soft_comp</samp></dt>
+<dd><p>For swr only, set maximum factor by which data is stretched/squeezed to make it
+match the timestamps. Must be a non-negative double float value, default value
+is 0.
+</p>
+</dd>
+<dt><samp>matrix_encoding</samp></dt>
+<dd><p>Select matrixed stereo encoding.
+</p>
+<p>It accepts the following values:
+</p><dl compact="compact">
+<dt>&lsquo;<samp>none</samp>&rsquo;</dt>
+<dd><p>select none
+</p></dd>
+<dt>&lsquo;<samp>dolby</samp>&rsquo;</dt>
+<dd><p>select Dolby
+</p></dd>
+<dt>&lsquo;<samp>dplii</samp>&rsquo;</dt>
+<dd><p>select Dolby Pro Logic II
+</p></dd>
+</dl>
+
+<p>Default value is <code>none</code>.
+</p>
+</dd>
+<dt><samp>filter_type</samp></dt>
+<dd><p>For swr only, select resampling filter type. This only affects resampling
+operations.
+</p>
+<p>It accepts the following values:
+</p><dl compact="compact">
+<dt>&lsquo;<samp>cubic</samp>&rsquo;</dt>
+<dd><p>select cubic
+</p></dd>
+<dt>&lsquo;<samp>blackman_nuttall</samp>&rsquo;</dt>
+<dd><p>select Blackman Nuttall windowed sinc
+</p></dd>
+<dt>&lsquo;<samp>kaiser</samp>&rsquo;</dt>
+<dd><p>select Kaiser windowed sinc
+</p></dd>
+</dl>
+
+</dd>
+<dt><samp>kaiser_beta</samp></dt>
+<dd><p>For swr only, set Kaiser window beta value. Must be a double float value in the
+interval [2,16], default value is 9.
+</p>
+</dd>
+<dt><samp>output_sample_bits</samp></dt>
+<dd><p>For swr only, set number of used output sample bits for dithering. Must be an integer in the
+interval [0,64], default value is 0, which means it&rsquo;s not used.
+</p>
+</dd>
+</dl>
+
+
+<a name="See-Also"></a>
+<h2 class="chapter">3 See Also<span class="pull-right"><a class="anchor hidden-xs" href="#See-Also" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-See-Also" aria-hidden="true">TOC</a></span></h2>
+
+<p><a href="ffmpeg.html">ffmpeg</a>, <a href="ffplay.html">ffplay</a>, <a href="ffprobe.html">ffprobe</a>,
+<a href="libswresample.html">libswresample</a>
+</p>
+
+<a name="Authors"></a>
+<h2 class="chapter">4 Authors<span class="pull-right"><a class="anchor hidden-xs" href="#Authors" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Authors" aria-hidden="true">TOC</a></span></h2>
+
+<p>The FFmpeg developers.
+</p>
+<p>For details about the authorship, see the Git history of the project
+(git://source.ffmpeg.org/ffmpeg), e.g. by typing the command
+<code>git log</code> in the FFmpeg source directory, or browsing the
+online repository at <a href="http://source.ffmpeg.org">http://source.ffmpeg.org</a>.
+</p>
+<p>Maintainers for the specific components are listed in the file
+<samp>MAINTAINERS</samp> in the source code tree.
+</p>
+
+
+      <p style="font-size: small;">
+        This document was generated using <a href="http://www.gnu.org/software/texinfo/"><em>makeinfo</em></a>.
+      </p>
+    </div>
+  </body>
+</html>

ffmpeg-n4.3.2-win64-gpl-shared-4.3/doc/ffmpeg-scaler.html

@@ -0,0 +1,257 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
+  <head>
+    <meta charset="utf-8">
+    <title>
+      FFmpeg Scaler Documentation
+    </title>
+    <meta name="viewport" content="width=device-width,initial-scale=1.0">
+    <link rel="stylesheet" type="text/css" href="bootstrap.min.css">
+    <link rel="stylesheet" type="text/css" href="style.min.css">
+  </head>
+  <body>
+    <div class="container">
+      <h1>
+      FFmpeg Scaler Documentation
+      </h1>
+<div align="center">
+</div>
+
+
+<a name="SEC_Top"></a>
+
+<span id="SEC_Contents"></span>
+<h2 class="contents-heading">Table of Contents</h2>
+
+<div class="contents">
+
+<ul class="no-bullet">
+  <li><a id="toc-Description" href="#Description">1 Description</a></li>
+  <li><a id="toc-Scaler-Options" href="#Scaler-Options">2 Scaler Options</a></li>
+  <li><a id="toc-See-Also" href="#See-Also">3 See Also</a></li>
+  <li><a id="toc-Authors" href="#Authors">4 Authors</a></li>
+</ul>
+</div>
+
+
+<a name="Description"></a>
+<h2 class="chapter">1 Description<span class="pull-right"><a class="anchor hidden-xs" href="#Description" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Description" aria-hidden="true">TOC</a></span></h2>
+
+<p>The FFmpeg rescaler provides a high-level interface to the libswscale
+library image conversion utilities. In particular it allows one to perform
+image rescaling and pixel format conversion.
+</p>
+
+<span id="scaler_005foptions"></span><a name="Scaler-Options"></a>
+<h2 class="chapter">2 Scaler Options<span class="pull-right"><a class="anchor hidden-xs" href="#Scaler-Options" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Scaler-Options" aria-hidden="true">TOC</a></span></h2>
+
+<p>The video scaler supports the following named options.
+</p>
+<p>Options may be set by specifying -<var>option</var> <var>value</var> in the
+FFmpeg tools, with a few API-only exceptions noted below.
+For programmatic use, they can be set explicitly in the
+<code>SwsContext</code> options or through the <samp>libavutil/opt.h</samp> API.
+</p>
+<dl compact="compact">
+<dd>
+<span id="sws_005fflags"></span></dd>
+<dt><samp>sws_flags</samp></dt>
+<dd><p>Set the scaler flags. This is also used to set the scaling
+algorithm. Only a single algorithm should be selected. Default
+value is &lsquo;<samp>bicubic</samp>&rsquo;.
+</p>
+<p>It accepts the following values:
+</p><dl compact="compact">
+<dt>&lsquo;<samp>fast_bilinear</samp>&rsquo;</dt>
+<dd><p>Select fast bilinear scaling algorithm.
+</p>
+</dd>
+<dt>&lsquo;<samp>bilinear</samp>&rsquo;</dt>
+<dd><p>Select bilinear scaling algorithm.
+</p>
+</dd>
+<dt>&lsquo;<samp>bicubic</samp>&rsquo;</dt>
+<dd><p>Select bicubic scaling algorithm.
+</p>
+</dd>
+<dt>&lsquo;<samp>experimental</samp>&rsquo;</dt>
+<dd><p>Select experimental scaling algorithm.
+</p>
+</dd>
+<dt>&lsquo;<samp>neighbor</samp>&rsquo;</dt>
+<dd><p>Select nearest neighbor rescaling algorithm.
+</p>
+</dd>
+<dt>&lsquo;<samp>area</samp>&rsquo;</dt>
+<dd><p>Select averaging area rescaling algorithm.
+</p>
+</dd>
+<dt>&lsquo;<samp>bicublin</samp>&rsquo;</dt>
+<dd><p>Select bicubic scaling algorithm for the luma component, bilinear for
+chroma components.
+</p>
+</dd>
+<dt>&lsquo;<samp>gauss</samp>&rsquo;</dt>
+<dd><p>Select Gaussian rescaling algorithm.
+</p>
+</dd>
+<dt>&lsquo;<samp>sinc</samp>&rsquo;</dt>
+<dd><p>Select sinc rescaling algorithm.
+</p>
+</dd>
+<dt>&lsquo;<samp>lanczos</samp>&rsquo;</dt>
+<dd><p>Select Lanczos rescaling algorithm. The default width (alpha) is 3 and can be
+changed by setting <code>param0</code>.
+</p>
+</dd>
+<dt>&lsquo;<samp>spline</samp>&rsquo;</dt>
+<dd><p>Select natural bicubic spline rescaling algorithm.
+</p>
+</dd>
+<dt>&lsquo;<samp>print_info</samp>&rsquo;</dt>
+<dd><p>Enable printing/debug logging.
+</p>
+</dd>
+<dt>&lsquo;<samp>accurate_rnd</samp>&rsquo;</dt>
+<dd><p>Enable accurate rounding.
+</p>
+</dd>
+<dt>&lsquo;<samp>full_chroma_int</samp>&rsquo;</dt>
+<dd><p>Enable full chroma interpolation.
+</p>
+</dd>
+<dt>&lsquo;<samp>full_chroma_inp</samp>&rsquo;</dt>
+<dd><p>Select full chroma input.
+</p>
+</dd>
+<dt>&lsquo;<samp>bitexact</samp>&rsquo;</dt>
+<dd><p>Enable bitexact output.
+</p></dd>
+</dl>
+
+</dd>
+<dt><samp>srcw <var>(API only)</var></samp></dt>
+<dd><p>Set source width.
+</p>
+</dd>
+<dt><samp>srch <var>(API only)</var></samp></dt>
+<dd><p>Set source height.
+</p>
+</dd>
+<dt><samp>dstw <var>(API only)</var></samp></dt>
+<dd><p>Set destination width.
+</p>
+</dd>
+<dt><samp>dsth <var>(API only)</var></samp></dt>
+<dd><p>Set destination height.
+</p>
+</dd>
+<dt><samp>src_format <var>(API only)</var></samp></dt>
+<dd><p>Set source pixel format (must be expressed as an integer).
+</p>
+</dd>
+<dt><samp>dst_format <var>(API only)</var></samp></dt>
+<dd><p>Set destination pixel format (must be expressed as an integer).
+</p>
+</dd>
+<dt><samp>src_range <var>(boolean)</var></samp></dt>
+<dd><p>If value is set to <code>1</code>, indicates source is full range. Default value is
+<code>0</code>, which indicates source is limited range.
+</p>
+</dd>
+<dt><samp>dst_range <var>(boolean)</var></samp></dt>
+<dd><p>If value is set to <code>1</code>, enable full range for destination. Default value
+is <code>0</code>, which enables limited range.
+</p>
+<span id="sws_005fparams"></span></dd>
+<dt><samp>param0, param1</samp></dt>
+<dd><p>Set scaling algorithm parameters. The specified values are specific of
+some scaling algorithms and ignored by others. The specified values
+are floating point number values.
+</p>
+</dd>
+<dt><samp>sws_dither</samp></dt>
+<dd><p>Set the dithering algorithm. Accepts one of the following
+values. Default value is &lsquo;<samp>auto</samp>&rsquo;.
+</p>
+<dl compact="compact">
+<dt>&lsquo;<samp>auto</samp>&rsquo;</dt>
+<dd><p>automatic choice
+</p>
+</dd>
+<dt>&lsquo;<samp>none</samp>&rsquo;</dt>
+<dd><p>no dithering
+</p>
+</dd>
+<dt>&lsquo;<samp>bayer</samp>&rsquo;</dt>
+<dd><p>bayer dither
+</p>
+</dd>
+<dt>&lsquo;<samp>ed</samp>&rsquo;</dt>
+<dd><p>error diffusion dither
+</p>
+</dd>
+<dt>&lsquo;<samp>a_dither</samp>&rsquo;</dt>
+<dd><p>arithmetic dither, based using addition
+</p>
+</dd>
+<dt>&lsquo;<samp>x_dither</samp>&rsquo;</dt>
+<dd><p>arithmetic dither, based using xor (more random/less apparent patterning that
+a_dither).
+</p>
+</dd>
+</dl>
+
+</dd>
+<dt><samp>alphablend</samp></dt>
+<dd><p>Set the alpha blending to use when the input has alpha but the output does not.
+Default value is &lsquo;<samp>none</samp>&rsquo;.
+</p>
+<dl compact="compact">
+<dt>&lsquo;<samp>uniform_color</samp>&rsquo;</dt>
+<dd><p>Blend onto a uniform background color
+</p>
+</dd>
+<dt>&lsquo;<samp>checkerboard</samp>&rsquo;</dt>
+<dd><p>Blend onto a checkerboard
+</p>
+</dd>
+<dt>&lsquo;<samp>none</samp>&rsquo;</dt>
+<dd><p>No blending
+</p>
+</dd>
+</dl>
+
+</dd>
+</dl>
+
+
+<a name="See-Also"></a>
+<h2 class="chapter">3 See Also<span class="pull-right"><a class="anchor hidden-xs" href="#See-Also" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-See-Also" aria-hidden="true">TOC</a></span></h2>
+
+<p><a href="ffmpeg.html">ffmpeg</a>, <a href="ffplay.html">ffplay</a>, <a href="ffprobe.html">ffprobe</a>,
+<a href="libswscale.html">libswscale</a>
+</p>
+
+<a name="Authors"></a>
+<h2 class="chapter">4 Authors<span class="pull-right"><a class="anchor hidden-xs" href="#Authors" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Authors" aria-hidden="true">TOC</a></span></h2>
+
+<p>The FFmpeg developers.
+</p>
+<p>For details about the authorship, see the Git history of the project
+(git://source.ffmpeg.org/ffmpeg), e.g. by typing the command
+<code>git log</code> in the FFmpeg source directory, or browsing the
+online repository at <a href="http://source.ffmpeg.org">http://source.ffmpeg.org</a>.
+</p>
+<p>Maintainers for the specific components are listed in the file
+<samp>MAINTAINERS</samp> in the source code tree.
+</p>
+
+
+      <p style="font-size: small;">
+        This document was generated using <a href="http://www.gnu.org/software/texinfo/"><em>makeinfo</em></a>.
+      </p>
+    </div>
+  </body>
+</html>

ffmpeg-n4.3.2-win64-gpl-shared-4.3/doc/ffplay.html

@@ -0,0 +1,852 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
+  <head>
+    <meta charset="utf-8">
+    <title>
+      ffplay Documentation
+    </title>
+    <meta name="viewport" content="width=device-width,initial-scale=1.0">
+    <link rel="stylesheet" type="text/css" href="bootstrap.min.css">
+    <link rel="stylesheet" type="text/css" href="style.min.css">
+  </head>
+  <body>
+    <div class="container">
+      <h1>
+      ffplay Documentation
+      </h1>
+<div align="center">
+</div>
+
+
+<a name="SEC_Top"></a>
+
+<span id="SEC_Contents"></span>
+<h2 class="contents-heading">Table of Contents</h2>
+
+<div class="contents">
+
+<ul class="no-bullet">
+  <li><a id="toc-Synopsis" href="#Synopsis">1 Synopsis</a></li>
+  <li><a id="toc-Description" href="#Description">2 Description</a></li>
+  <li><a id="toc-Options" href="#Options">3 Options</a>
+  <ul class="no-bullet">
+    <li><a id="toc-Stream-specifiers-1" href="#Stream-specifiers-1">3.1 Stream specifiers</a></li>
+    <li><a id="toc-Generic-options" href="#Generic-options">3.2 Generic options</a></li>
+    <li><a id="toc-AVOptions" href="#AVOptions">3.3 AVOptions</a></li>
+    <li><a id="toc-Main-options" href="#Main-options">3.4 Main options</a></li>
+    <li><a id="toc-Advanced-options" href="#Advanced-options">3.5 Advanced options</a></li>
+    <li><a id="toc-While-playing" href="#While-playing">3.6 While playing</a></li>
+  </ul></li>
+  <li><a id="toc-See-Also" href="#See-Also">4 See Also</a></li>
+  <li><a id="toc-Authors" href="#Authors">5 Authors</a></li>
+</ul>
+</div>
+
+
+<a name="Synopsis"></a>
+<h2 class="chapter">1 Synopsis<span class="pull-right"><a class="anchor hidden-xs" href="#Synopsis" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Synopsis" aria-hidden="true">TOC</a></span></h2>
+
+<p>ffplay [<var>options</var>] [<samp>input_url</samp>]
+</p>
+<a name="Description"></a>
+<h2 class="chapter">2 Description<span class="pull-right"><a class="anchor hidden-xs" href="#Description" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Description" aria-hidden="true">TOC</a></span></h2>
+
+<p>FFplay is a very simple and portable media player using the FFmpeg
+libraries and the SDL library. It is mostly used as a testbed for the
+various FFmpeg APIs.
+</p>
+<a name="Options"></a>
+<h2 class="chapter">3 Options<span class="pull-right"><a class="anchor hidden-xs" href="#Options" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Options" aria-hidden="true">TOC</a></span></h2>
+
+<p>All the numerical options, if not specified otherwise, accept a string
+representing a number as input, which may be followed by one of the SI
+unit prefixes, for example: &rsquo;K&rsquo;, &rsquo;M&rsquo;, or &rsquo;G&rsquo;.
+</p>
+<p>If &rsquo;i&rsquo; is appended to the SI unit prefix, the complete prefix will be
+interpreted as a unit prefix for binary multiples, which are based on
+powers of 1024 instead of powers of 1000. Appending &rsquo;B&rsquo; to the SI unit
+prefix multiplies the value by 8. This allows using, for example:
+&rsquo;KB&rsquo;, &rsquo;MiB&rsquo;, &rsquo;G&rsquo; and &rsquo;B&rsquo; as number suffixes.
+</p>
+<p>Options which do not take arguments are boolean options, and set the
+corresponding value to true. They can be set to false by prefixing
+the option name with &quot;no&quot;. For example using &quot;-nofoo&quot;
+will set the boolean option with name &quot;foo&quot; to false.
+</p>
+<span id="Stream-specifiers"></span><a name="Stream-specifiers-1"></a>
+<h3 class="section">3.1 Stream specifiers<span class="pull-right"><a class="anchor hidden-xs" href="#Stream-specifiers-1" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Stream-specifiers-1" aria-hidden="true">TOC</a></span></h3>
+<p>Some options are applied per-stream, e.g. bitrate or codec. Stream specifiers
+are used to precisely specify which stream(s) a given option belongs to.
+</p>
+<p>A stream specifier is a string generally appended to the option name and
+separated from it by a colon. E.g. <code>-codec:a:1 ac3</code> contains the
+<code>a:1</code> stream specifier, which matches the second audio stream. Therefore, it
+would select the ac3 codec for the second audio stream.
+</p>
+<p>A stream specifier can match several streams, so that the option is applied to all
+of them. E.g. the stream specifier in <code>-b:a 128k</code> matches all audio
+streams.
+</p>
+<p>An empty stream specifier matches all streams. For example, <code>-codec copy</code>
+or <code>-codec: copy</code> would copy all the streams without reencoding.
+</p>
+<p>Possible forms of stream specifiers are:
+</p><dl compact="compact">
+<dt><samp><var>stream_index</var></samp></dt>
+<dd><p>Matches the stream with this index. E.g. <code>-threads:1 4</code> would set the
+thread count for the second stream to 4. If <var>stream_index</var> is used as an
+additional stream specifier (see below), then it selects stream number
+<var>stream_index</var> from the matching streams. Stream numbering is based on the
+order of the streams as detected by libavformat except when a program ID is
+also specified. In this case it is based on the ordering of the streams in the
+program.
+</p></dd>
+<dt><samp><var>stream_type</var>[:<var>additional_stream_specifier</var>]</samp></dt>
+<dd><p><var>stream_type</var> is one of following: &rsquo;v&rsquo; or &rsquo;V&rsquo; for video, &rsquo;a&rsquo; for audio, &rsquo;s&rsquo;
+for subtitle, &rsquo;d&rsquo; for data, and &rsquo;t&rsquo; for attachments. &rsquo;v&rsquo; matches all video
+streams, &rsquo;V&rsquo; only matches video streams which are not attached pictures, video
+thumbnails or cover arts. If <var>additional_stream_specifier</var> is used, then
+it matches streams which both have this type and match the
+<var>additional_stream_specifier</var>. Otherwise, it matches all streams of the
+specified type.
+</p></dd>
+<dt><samp>p:<var>program_id</var>[:<var>additional_stream_specifier</var>]</samp></dt>
+<dd><p>Matches streams which are in the program with the id <var>program_id</var>. If
+<var>additional_stream_specifier</var> is used, then it matches streams which both
+are part of the program and match the <var>additional_stream_specifier</var>.
+</p>
+</dd>
+<dt><samp>#<var>stream_id</var> or i:<var>stream_id</var></samp></dt>
+<dd><p>Match the stream by stream id (e.g. PID in MPEG-TS container).
+</p></dd>
+<dt><samp>m:<var>key</var>[:<var>value</var>]</samp></dt>
+<dd><p>Matches streams with the metadata tag <var>key</var> having the specified value. If
+<var>value</var> is not given, matches streams that contain the given tag with any
+value.
+</p></dd>
+<dt><samp>u</samp></dt>
+<dd><p>Matches streams with usable configuration, the codec must be defined and the
+essential information such as video dimension or audio sample rate must be present.
+</p>
+<p>Note that in <code>ffmpeg</code>, matching by metadata will only work properly for
+input files.
+</p></dd>
+</dl>
+
+<a name="Generic-options"></a>
+<h3 class="section">3.2 Generic options<span class="pull-right"><a class="anchor hidden-xs" href="#Generic-options" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Generic-options" aria-hidden="true">TOC</a></span></h3>
+
+<p>These options are shared amongst the ff* tools.
+</p>
+<dl compact="compact">
+<dt><samp>-L</samp></dt>
+<dd><p>Show license.
+</p>
+</dd>
+<dt><samp>-h, -?, -help, --help [<var>arg</var>]</samp></dt>
+<dd><p>Show help. An optional parameter may be specified to print help about a specific
+item. If no argument is specified, only basic (non advanced) tool
+options are shown.
+</p>
+<p>Possible values of <var>arg</var> are:
+</p><dl compact="compact">
+<dt><samp>long</samp></dt>
+<dd><p>Print advanced tool options in addition to the basic tool options.
+</p>
+</dd>
+<dt><samp>full</samp></dt>
+<dd><p>Print complete list of options, including shared and private options
+for encoders, decoders, demuxers, muxers, filters, etc.
+</p>
+</dd>
+<dt><samp>decoder=<var>decoder_name</var></samp></dt>
+<dd><p>Print detailed information about the decoder named <var>decoder_name</var>. Use the
+<samp>-decoders</samp> option to get a list of all decoders.
+</p>
+</dd>
+<dt><samp>encoder=<var>encoder_name</var></samp></dt>
+<dd><p>Print detailed information about the encoder named <var>encoder_name</var>. Use the
+<samp>-encoders</samp> option to get a list of all encoders.
+</p>
+</dd>
+<dt><samp>demuxer=<var>demuxer_name</var></samp></dt>
+<dd><p>Print detailed information about the demuxer named <var>demuxer_name</var>. Use the
+<samp>-formats</samp> option to get a list of all demuxers and muxers.
+</p>
+</dd>
+<dt><samp>muxer=<var>muxer_name</var></samp></dt>
+<dd><p>Print detailed information about the muxer named <var>muxer_name</var>. Use the
+<samp>-formats</samp> option to get a list of all muxers and demuxers.
+</p>
+</dd>
+<dt><samp>filter=<var>filter_name</var></samp></dt>
+<dd><p>Print detailed information about the filter name <var>filter_name</var>. Use the
+<samp>-filters</samp> option to get a list of all filters.
+</p>
+</dd>
+<dt><samp>bsf=<var>bitstream_filter_name</var></samp></dt>
+<dd><p>Print detailed information about the bitstream filter name <var>bitstream_filter_name</var>.
+Use the <samp>-bsfs</samp> option to get a list of all bitstream filters.
+</p></dd>
+</dl>
+
+</dd>
+<dt><samp>-version</samp></dt>
+<dd><p>Show version.
+</p>
+</dd>
+<dt><samp>-formats</samp></dt>
+<dd><p>Show available formats (including devices).
+</p>
+</dd>
+<dt><samp>-demuxers</samp></dt>
+<dd><p>Show available demuxers.
+</p>
+</dd>
+<dt><samp>-muxers</samp></dt>
+<dd><p>Show available muxers.
+</p>
+</dd>
+<dt><samp>-devices</samp></dt>
+<dd><p>Show available devices.
+</p>
+</dd>
+<dt><samp>-codecs</samp></dt>
+<dd><p>Show all codecs known to libavcodec.
+</p>
+<p>Note that the term &rsquo;codec&rsquo; is used throughout this documentation as a shortcut
+for what is more correctly called a media bitstream format.
+</p>
+</dd>
+<dt><samp>-decoders</samp></dt>
+<dd><p>Show available decoders.
+</p>
+</dd>
+<dt><samp>-encoders</samp></dt>
+<dd><p>Show all available encoders.
+</p>
+</dd>
+<dt><samp>-bsfs</samp></dt>
+<dd><p>Show available bitstream filters.
+</p>
+</dd>
+<dt><samp>-protocols</samp></dt>
+<dd><p>Show available protocols.
+</p>
+</dd>
+<dt><samp>-filters</samp></dt>
+<dd><p>Show available libavfilter filters.
+</p>
+</dd>
+<dt><samp>-pix_fmts</samp></dt>
+<dd><p>Show available pixel formats.
+</p>
+</dd>
+<dt><samp>-sample_fmts</samp></dt>
+<dd><p>Show available sample formats.
+</p>
+</dd>
+<dt><samp>-layouts</samp></dt>
+<dd><p>Show channel names and standard channel layouts.
+</p>
+</dd>
+<dt><samp>-colors</samp></dt>
+<dd><p>Show recognized color names.
+</p>
+</dd>
+<dt><samp>-sources <var>device</var>[,<var>opt1</var>=<var>val1</var>[,<var>opt2</var>=<var>val2</var>]...]</samp></dt>
+<dd><p>Show autodetected sources of the input device.
+Some devices may provide system-dependent source names that cannot be autodetected.
+The returned list cannot be assumed to be always complete.
+</p><div class="example">
+<pre class="example">ffmpeg -sources pulse,server=192.168.0.4
+</pre></div>
+
+</dd>
+<dt><samp>-sinks <var>device</var>[,<var>opt1</var>=<var>val1</var>[,<var>opt2</var>=<var>val2</var>]...]</samp></dt>
+<dd><p>Show autodetected sinks of the output device.
+Some devices may provide system-dependent sink names that cannot be autodetected.
+The returned list cannot be assumed to be always complete.
+</p><div class="example">
+<pre class="example">ffmpeg -sinks pulse,server=192.168.0.4
+</pre></div>
+
+</dd>
+<dt><samp>-loglevel [<var>flags</var>+]<var>loglevel</var> | -v [<var>flags</var>+]<var>loglevel</var></samp></dt>
+<dd><p>Set logging level and flags used by the library.
+</p>
+<p>The optional <var>flags</var> prefix can consist of the following values:
+</p><dl compact="compact">
+<dt>&lsquo;<samp>repeat</samp>&rsquo;</dt>
+<dd><p>Indicates that repeated log output should not be compressed to the first line
+and the &quot;Last message repeated n times&quot; line will be omitted.
+</p></dd>
+<dt>&lsquo;<samp>level</samp>&rsquo;</dt>
+<dd><p>Indicates that log output should add a <code>[level]</code> prefix to each message
+line. This can be used as an alternative to log coloring, e.g. when dumping the
+log to file.
+</p></dd>
+</dl>
+<p>Flags can also be used alone by adding a &rsquo;+&rsquo;/&rsquo;-&rsquo; prefix to set/reset a single
+flag without affecting other <var>flags</var> or changing <var>loglevel</var>. When
+setting both <var>flags</var> and <var>loglevel</var>, a &rsquo;+&rsquo; separator is expected
+between the last <var>flags</var> value and before <var>loglevel</var>.
+</p>
+<p><var>loglevel</var> is a string or a number containing one of the following values:
+</p><dl compact="compact">
+<dt>&lsquo;<samp>quiet, -8</samp>&rsquo;</dt>
+<dd><p>Show nothing at all; be silent.
+</p></dd>
+<dt>&lsquo;<samp>panic, 0</samp>&rsquo;</dt>
+<dd><p>Only show fatal errors which could lead the process to crash, such as
+an assertion failure. This is not currently used for anything.
+</p></dd>
+<dt>&lsquo;<samp>fatal, 8</samp>&rsquo;</dt>
+<dd><p>Only show fatal errors. These are errors after which the process absolutely
+cannot continue.
+</p></dd>
+<dt>&lsquo;<samp>error, 16</samp>&rsquo;</dt>
+<dd><p>Show all errors, including ones which can be recovered from.
+</p></dd>
+<dt>&lsquo;<samp>warning, 24</samp>&rsquo;</dt>
+<dd><p>Show all warnings and errors. Any message related to possibly
+incorrect or unexpected events will be shown.
+</p></dd>
+<dt>&lsquo;<samp>info, 32</samp>&rsquo;</dt>
+<dd><p>Show informative messages during processing. This is in addition to
+warnings and errors. This is the default value.
+</p></dd>
+<dt>&lsquo;<samp>verbose, 40</samp>&rsquo;</dt>
+<dd><p>Same as <code>info</code>, except more verbose.
+</p></dd>
+<dt>&lsquo;<samp>debug, 48</samp>&rsquo;</dt>
+<dd><p>Show everything, including debugging information.
+</p></dd>
+<dt>&lsquo;<samp>trace, 56</samp>&rsquo;</dt>
+</dl>
+
+<p>For example to enable repeated log output, add the <code>level</code> prefix, and set
+<var>loglevel</var> to <code>verbose</code>:
+</p><div class="example">
+<pre class="example">ffmpeg -loglevel repeat+level+verbose -i input output
+</pre></div>
+<p>Another example that enables repeated log output without affecting current
+state of <code>level</code> prefix flag or <var>loglevel</var>:
+</p><div class="example">
+<pre class="example">ffmpeg [...] -loglevel +repeat
+</pre></div>
+
+<p>By default the program logs to stderr. If coloring is supported by the
+terminal, colors are used to mark errors and warnings. Log coloring
+can be disabled setting the environment variable
+<code>AV_LOG_FORCE_NOCOLOR</code>, or can be forced setting
+the environment variable <code>AV_LOG_FORCE_COLOR</code>.
+</p>
+</dd>
+<dt><samp>-report</samp></dt>
+<dd><p>Dump full command line and log output to a file named
+<code><var>program</var>-<var>YYYYMMDD</var>-<var>HHMMSS</var>.log</code> in the current
+directory.
+This file can be useful for bug reports.
+It also implies <code>-loglevel debug</code>.
+</p>
+<p>Setting the environment variable <code>FFREPORT</code> to any value has the
+same effect. If the value is a &rsquo;:&rsquo;-separated key=value sequence, these
+options will affect the report; option values must be escaped if they
+contain special characters or the options delimiter &rsquo;:&rsquo; (see the
+&ldquo;Quoting and escaping&rdquo; section in the ffmpeg-utils manual).
+</p>
+<p>The following options are recognized:
+</p><dl compact="compact">
+<dt><samp>file</samp></dt>
+<dd><p>set the file name to use for the report; <code>%p</code> is expanded to the name
+of the program, <code>%t</code> is expanded to a timestamp, <code>%%</code> is expanded
+to a plain <code>%</code>
+</p></dd>
+<dt><samp>level</samp></dt>
+<dd><p>set the log verbosity level using a numerical value (see <code>-loglevel</code>).
+</p></dd>
+</dl>
+
+<p>For example, to output a report to a file named <samp>ffreport.log</samp>
+using a log level of <code>32</code> (alias for log level <code>info</code>):
+</p>
+<div class="example">
+<pre class="example">FFREPORT=file=ffreport.log:level=32 ffmpeg -i input output
+</pre></div>
+
+<p>Errors in parsing the environment variable are not fatal, and will not
+appear in the report.
+</p>
+</dd>
+<dt><samp>-hide_banner</samp></dt>
+<dd><p>Suppress printing banner.
+</p>
+<p>All FFmpeg tools will normally show a copyright notice, build options
+and library versions. This option can be used to suppress printing
+this information.
+</p>
+</dd>
+<dt><samp>-cpuflags flags (<em>global</em>)</samp></dt>
+<dd><p>Allows setting and clearing cpu flags. This option is intended
+for testing. Do not use it unless you know what you&rsquo;re doing.
+</p><div class="example">
+<pre class="example">ffmpeg -cpuflags -sse+mmx ...
+ffmpeg -cpuflags mmx ...
+ffmpeg -cpuflags 0 ...
+</pre></div>
+<p>Possible flags for this option are:
+</p><dl compact="compact">
+<dt>&lsquo;<samp>x86</samp>&rsquo;</dt>
+<dd><dl compact="compact">
+<dt>&lsquo;<samp>mmx</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>mmxext</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>sse</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>sse2</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>sse2slow</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>sse3</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>sse3slow</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>ssse3</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>atom</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>sse4.1</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>sse4.2</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>avx</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>avx2</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>xop</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>fma3</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>fma4</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>3dnow</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>3dnowext</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>bmi1</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>bmi2</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>cmov</samp>&rsquo;</dt>
+</dl>
+</dd>
+<dt>&lsquo;<samp>ARM</samp>&rsquo;</dt>
+<dd><dl compact="compact">
+<dt>&lsquo;<samp>armv5te</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>armv6</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>armv6t2</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>vfp</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>vfpv3</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>neon</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>setend</samp>&rsquo;</dt>
+</dl>
+</dd>
+<dt>&lsquo;<samp>AArch64</samp>&rsquo;</dt>
+<dd><dl compact="compact">
+<dt>&lsquo;<samp>armv8</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>vfp</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>neon</samp>&rsquo;</dt>
+</dl>
+</dd>
+<dt>&lsquo;<samp>PowerPC</samp>&rsquo;</dt>
+<dd><dl compact="compact">
+<dt>&lsquo;<samp>altivec</samp>&rsquo;</dt>
+</dl>
+</dd>
+<dt>&lsquo;<samp>Specific Processors</samp>&rsquo;</dt>
+<dd><dl compact="compact">
+<dt>&lsquo;<samp>pentium2</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>pentium3</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>pentium4</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>k6</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>k62</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>athlon</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>athlonxp</samp>&rsquo;</dt>
+<dt>&lsquo;<samp>k8</samp>&rsquo;</dt>
+</dl>
+</dd>
+</dl>
+</dd>
+</dl>
+
+<a name="AVOptions"></a>
+<h3 class="section">3.3 AVOptions<span class="pull-right"><a class="anchor hidden-xs" href="#AVOptions" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-AVOptions" aria-hidden="true">TOC</a></span></h3>
+
+<p>These options are provided directly by the libavformat, libavdevice and
+libavcodec libraries. To see the list of available AVOptions, use the
+<samp>-help</samp> option. They are separated into two categories:
+</p><dl compact="compact">
+<dt><samp>generic</samp></dt>
+<dd><p>These options can be set for any container, codec or device. Generic options
+are listed under AVFormatContext options for containers/devices and under
+AVCodecContext options for codecs.
+</p></dd>
+<dt><samp>private</samp></dt>
+<dd><p>These options are specific to the given container, device or codec. Private
+options are listed under their corresponding containers/devices/codecs.
+</p></dd>
+</dl>
+
+<p>For example to write an ID3v2.3 header instead of a default ID3v2.4 to
+an MP3 file, use the <samp>id3v2_version</samp> private option of the MP3
+muxer:
+</p><div class="example">
+<pre class="example">ffmpeg -i input.flac -id3v2_version 3 out.mp3
+</pre></div>
+
+<p>All codec AVOptions are per-stream, and thus a stream specifier
+should be attached to them:
+</p><div class="example">
+<pre class="example">ffmpeg -i multichannel.mxf -map 0:v:0 -map 0:a:0 -map 0:a:0 -c:a:0 ac3 -b:a:0 640k -ac:a:1 2 -c:a:1 aac -b:2 128k out.mp4
+</pre></div>
+
+<p>In the above example, a multichannel audio stream is mapped twice for output.
+The first instance is encoded with codec ac3 and bitrate 640k.
+The second instance is downmixed to 2 channels and encoded with codec aac. A bitrate of 128k is specified for it using
+absolute index of the output stream.
+</p>
+<p>Note: the <samp>-nooption</samp> syntax cannot be used for boolean
+AVOptions, use <samp>-option 0</samp>/<samp>-option 1</samp>.
+</p>
+<p>Note: the old undocumented way of specifying per-stream AVOptions by
+prepending v/a/s to the options name is now obsolete and will be
+removed soon.
+</p>
+<a name="Main-options"></a>
+<h3 class="section">3.4 Main options<span class="pull-right"><a class="anchor hidden-xs" href="#Main-options" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Main-options" aria-hidden="true">TOC</a></span></h3>
+
+<dl compact="compact">
+<dt><samp>-x <var>width</var></samp></dt>
+<dd><p>Force displayed width.
+</p></dd>
+<dt><samp>-y <var>height</var></samp></dt>
+<dd><p>Force displayed height.
+</p></dd>
+<dt><samp>-s <var>size</var></samp></dt>
+<dd><p>Set frame size (WxH or abbreviation), needed for videos which do
+not contain a header with the frame size like raw YUV.  This option
+has been deprecated in favor of private options, try -video_size.
+</p></dd>
+<dt><samp>-fs</samp></dt>
+<dd><p>Start in fullscreen mode.
+</p></dd>
+<dt><samp>-an</samp></dt>
+<dd><p>Disable audio.
+</p></dd>
+<dt><samp>-vn</samp></dt>
+<dd><p>Disable video.
+</p></dd>
+<dt><samp>-sn</samp></dt>
+<dd><p>Disable subtitles.
+</p></dd>
+<dt><samp>-ss <var>pos</var></samp></dt>
+<dd><p>Seek to <var>pos</var>. Note that in most formats it is not possible to seek
+exactly, so <code>ffplay</code> will seek to the nearest seek point to
+<var>pos</var>.
+</p>
+<p><var>pos</var> must be a time duration specification,
+see <a href="ffmpeg-utils.html#time-duration-syntax">(ffmpeg-utils)the Time duration section in the ffmpeg-utils(1) manual</a>.
+</p></dd>
+<dt><samp>-t <var>duration</var></samp></dt>
+<dd><p>Play <var>duration</var> seconds of audio/video.
+</p>
+<p><var>duration</var> must be a time duration specification,
+see <a href="ffmpeg-utils.html#time-duration-syntax">(ffmpeg-utils)the Time duration section in the ffmpeg-utils(1) manual</a>.
+</p></dd>
+<dt><samp>-bytes</samp></dt>
+<dd><p>Seek by bytes.
+</p></dd>
+<dt><samp>-seek_interval</samp></dt>
+<dd><p>Set custom interval, in seconds, for seeking using left/right keys. Default is 10 seconds.
+</p></dd>
+<dt><samp>-nodisp</samp></dt>
+<dd><p>Disable graphical display.
+</p></dd>
+<dt><samp>-noborder</samp></dt>
+<dd><p>Borderless window.
+</p></dd>
+<dt><samp>-alwaysontop</samp></dt>
+<dd><p>Window always on top. Available on: X11 with SDL &gt;= 2.0.5, Windows SDL &gt;= 2.0.6.
+</p></dd>
+<dt><samp>-volume</samp></dt>
+<dd><p>Set the startup volume. 0 means silence, 100 means no volume reduction or
+amplification. Negative values are treated as 0, values above 100 are treated
+as 100.
+</p></dd>
+<dt><samp>-f <var>fmt</var></samp></dt>
+<dd><p>Force format.
+</p></dd>
+<dt><samp>-window_title <var>title</var></samp></dt>
+<dd><p>Set window title (default is the input filename).
+</p></dd>
+<dt><samp>-left <var>title</var></samp></dt>
+<dd><p>Set the x position for the left of the window (default is a centered window).
+</p></dd>
+<dt><samp>-top <var>title</var></samp></dt>
+<dd><p>Set the y position for the top of the window (default is a centered window).
+</p></dd>
+<dt><samp>-loop <var>number</var></samp></dt>
+<dd><p>Loops movie playback &lt;number&gt; times. 0 means forever.
+</p></dd>
+<dt><samp>-showmode <var>mode</var></samp></dt>
+<dd><p>Set the show mode to use.
+Available values for <var>mode</var> are:
+</p><dl compact="compact">
+<dt>&lsquo;<samp>0, video</samp>&rsquo;</dt>
+<dd><p>show video
+</p></dd>
+<dt>&lsquo;<samp>1, waves</samp>&rsquo;</dt>
+<dd><p>show audio waves
+</p></dd>
+<dt>&lsquo;<samp>2, rdft</samp>&rsquo;</dt>
+<dd><p>show audio frequency band using RDFT ((Inverse) Real Discrete Fourier Transform)
+</p></dd>
+</dl>
+
+<p>Default value is &quot;video&quot;, if video is not present or cannot be played
+&quot;rdft&quot; is automatically selected.
+</p>
+<p>You can interactively cycle through the available show modes by
+pressing the key <tt class="key">w</tt>.
+</p>
+</dd>
+<dt><samp>-vf <var>filtergraph</var></samp></dt>
+<dd><p>Create the filtergraph specified by <var>filtergraph</var> and use it to
+filter the video stream.
+</p>
+<p><var>filtergraph</var> is a description of the filtergraph to apply to
+the stream, and must have a single video input and a single video
+output. In the filtergraph, the input is associated to the label
+<code>in</code>, and the output to the label <code>out</code>. See the
+ffmpeg-filters manual for more information about the filtergraph
+syntax.
+</p>
+<p>You can specify this parameter multiple times and cycle through the specified
+filtergraphs along with the show modes by pressing the key <tt class="key">w</tt>.
+</p>
+</dd>
+<dt><samp>-af <var>filtergraph</var></samp></dt>
+<dd><p><var>filtergraph</var> is a description of the filtergraph to apply to
+the input audio.
+Use the option &quot;-filters&quot; to show all the available filters (including
+sources and sinks).
+</p>
+</dd>
+<dt><samp>-i <var>input_url</var></samp></dt>
+<dd><p>Read <var>input_url</var>.
+</p></dd>
+</dl>
+
+<a name="Advanced-options"></a>
+<h3 class="section">3.5 Advanced options<span class="pull-right"><a class="anchor hidden-xs" href="#Advanced-options" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Advanced-options" aria-hidden="true">TOC</a></span></h3>
+<dl compact="compact">
+<dt><samp>-pix_fmt <var>format</var></samp></dt>
+<dd><p>Set pixel format.
+This option has been deprecated in favor of private options, try -pixel_format.
+</p>
+</dd>
+<dt><samp>-stats</samp></dt>
+<dd><p>Print several playback statistics, in particular show the stream
+duration, the codec parameters, the current position in the stream and
+the audio/video synchronisation drift. It is shown by default, unless the
+log level is lower than <code>info</code>. Its display can be forced by manually
+specifying this option. To disable it, you need to specify <code>-nostats</code>.
+</p>
+</dd>
+<dt><samp>-fast</samp></dt>
+<dd><p>Non-spec-compliant optimizations.
+</p></dd>
+<dt><samp>-genpts</samp></dt>
+<dd><p>Generate pts.
+</p></dd>
+<dt><samp>-sync <var>type</var></samp></dt>
+<dd><p>Set the master clock to audio (<code>type=audio</code>), video
+(<code>type=video</code>) or external (<code>type=ext</code>). Default is audio. The
+master clock is used to control audio-video synchronization. Most media
+players use audio as master clock, but in some cases (streaming or high
+quality broadcast) it is necessary to change that. This option is mainly
+used for debugging purposes.
+</p></dd>
+<dt><samp>-ast <var>audio_stream_specifier</var></samp></dt>
+<dd><p>Select the desired audio stream using the given stream specifier. The stream
+specifiers are described in the <a href="#Stream-specifiers">Stream specifiers</a> chapter. If this option
+is not specified, the &quot;best&quot; audio stream is selected in the program of the
+already selected video stream.
+</p></dd>
+<dt><samp>-vst <var>video_stream_specifier</var></samp></dt>
+<dd><p>Select the desired video stream using the given stream specifier. The stream
+specifiers are described in the <a href="#Stream-specifiers">Stream specifiers</a> chapter. If this option
+is not specified, the &quot;best&quot; video stream is selected.
+</p></dd>
+<dt><samp>-sst <var>subtitle_stream_specifier</var></samp></dt>
+<dd><p>Select the desired subtitle stream using the given stream specifier. The stream
+specifiers are described in the <a href="#Stream-specifiers">Stream specifiers</a> chapter. If this option
+is not specified, the &quot;best&quot; subtitle stream is selected in the program of the
+already selected video or audio stream.
+</p></dd>
+<dt><samp>-autoexit</samp></dt>
+<dd><p>Exit when video is done playing.
+</p></dd>
+<dt><samp>-exitonkeydown</samp></dt>
+<dd><p>Exit if any key is pressed.
+</p></dd>
+<dt><samp>-exitonmousedown</samp></dt>
+<dd><p>Exit if any mouse button is pressed.
+</p>
+</dd>
+<dt><samp>-codec:<var>media_specifier</var> <var>codec_name</var></samp></dt>
+<dd><p>Force a specific decoder implementation for the stream identified by
+<var>media_specifier</var>, which can assume the values <code>a</code> (audio),
+<code>v</code> (video), and <code>s</code> subtitle.
+</p>
+</dd>
+<dt><samp>-acodec <var>codec_name</var></samp></dt>
+<dd><p>Force a specific audio decoder.
+</p>
+</dd>
+<dt><samp>-vcodec <var>codec_name</var></samp></dt>
+<dd><p>Force a specific video decoder.
+</p>
+</dd>
+<dt><samp>-scodec <var>codec_name</var></samp></dt>
+<dd><p>Force a specific subtitle decoder.
+</p>
+</dd>
+<dt><samp>-autorotate</samp></dt>
+<dd><p>Automatically rotate the video according to file metadata. Enabled by
+default, use <samp>-noautorotate</samp> to disable it.
+</p>
+</dd>
+<dt><samp>-framedrop</samp></dt>
+<dd><p>Drop video frames if video is out of sync. Enabled by default if the master
+clock is not set to video. Use this option to enable frame dropping for all
+master clock sources, use <samp>-noframedrop</samp> to disable it.
+</p>
+</dd>
+<dt><samp>-infbuf</samp></dt>
+<dd><p>Do not limit the input buffer size, read as much data as possible from the
+input as soon as possible. Enabled by default for realtime streams, where data
+may be dropped if not read in time. Use this option to enable infinite buffers
+for all inputs, use <samp>-noinfbuf</samp> to disable it.
+</p>
+</dd>
+<dt><samp>-filter_threads <var>nb_threads</var></samp></dt>
+<dd><p>Defines how many threads are used to process a filter pipeline. Each pipeline
+will produce a thread pool with this many threads available for parallel
+processing. The default is 0 which means that the thread count will be
+determined by the number of available CPUs.
+</p>
+</dd>
+</dl>
+
+<a name="While-playing"></a>
+<h3 class="section">3.6 While playing<span class="pull-right"><a class="anchor hidden-xs" href="#While-playing" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-While-playing" aria-hidden="true">TOC</a></span></h3>
+
+<dl compact="compact">
+<dt><tt class="key">q, ESC</tt></dt>
+<dd><p>Quit.
+</p>
+</dd>
+<dt><tt class="key">f</tt></dt>
+<dd><p>Toggle full screen.
+</p>
+</dd>
+<dt><tt class="key">p, SPC</tt></dt>
+<dd><p>Pause.
+</p>
+</dd>
+<dt><tt class="key">m</tt></dt>
+<dd><p>Toggle mute.
+</p>
+</dd>
+<dt><tt class="key">9, 0</tt></dt>
+<dd><p>Decrease and increase volume respectively.
+</p>
+</dd>
+<dt><tt class="key">/, *</tt></dt>
+<dd><p>Decrease and increase volume respectively.
+</p>
+</dd>
+<dt><tt class="key">a</tt></dt>
+<dd><p>Cycle audio channel in the current program.
+</p>
+</dd>
+<dt><tt class="key">v</tt></dt>
+<dd><p>Cycle video channel.
+</p>
+</dd>
+<dt><tt class="key">t</tt></dt>
+<dd><p>Cycle subtitle channel in the current program.
+</p>
+</dd>
+<dt><tt class="key">c</tt></dt>
+<dd><p>Cycle program.
+</p>
+</dd>
+<dt><tt class="key">w</tt></dt>
+<dd><p>Cycle video filters or show modes.
+</p>
+</dd>
+<dt><tt class="key">s</tt></dt>
+<dd><p>Step to the next frame.
+</p>
+<p>Pause if the stream is not already paused, step to the next video
+frame, and pause.
+</p>
+</dd>
+<dt><tt class="key">left/right</tt></dt>
+<dd><p>Seek backward/forward 10 seconds.
+</p>
+</dd>
+<dt><tt class="key">down/up</tt></dt>
+<dd><p>Seek backward/forward 1 minute.
+</p>
+</dd>
+<dt><tt class="key">page down/page up</tt></dt>
+<dd><p>Seek to the previous/next chapter.
+or if there are no chapters
+Seek backward/forward 10 minutes.
+</p>
+</dd>
+<dt><tt class="key">right mouse click</tt></dt>
+<dd><p>Seek to percentage in file corresponding to fraction of width.
+</p>
+</dd>
+<dt><tt class="key">left mouse double-click</tt></dt>
+<dd><p>Toggle full screen.
+</p>
+</dd>
+</dl>
+
+
+
+<a name="See-Also"></a>
+<h2 class="chapter">4 See Also<span class="pull-right"><a class="anchor hidden-xs" href="#See-Also" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-See-Also" aria-hidden="true">TOC</a></span></h2>
+
+<p><a href="ffplay-all.html">ffmpeg-all</a>,
+<a href="ffmpeg.html">ffmpeg</a>, <a href="ffprobe.html">ffprobe</a>,
+<a href="ffmpeg-utils.html">ffmpeg-utils</a>,
+<a href="ffmpeg-scaler.html">ffmpeg-scaler</a>,
+<a href="ffmpeg-resampler.html">ffmpeg-resampler</a>,
+<a href="ffmpeg-codecs.html">ffmpeg-codecs</a>,
+<a href="ffmpeg-bitstream-filters.html">ffmpeg-bitstream-filters</a>,
+<a href="ffmpeg-formats.html">ffmpeg-formats</a>,
+<a href="ffmpeg-devices.html">ffmpeg-devices</a>,
+<a href="ffmpeg-protocols.html">ffmpeg-protocols</a>,
+<a href="ffmpeg-filters.html">ffmpeg-filters</a>
+</p>
+
+<a name="Authors"></a>
+<h2 class="chapter">5 Authors<span class="pull-right"><a class="anchor hidden-xs" href="#Authors" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Authors" aria-hidden="true">TOC</a></span></h2>
+
+<p>The FFmpeg developers.
+</p>
+<p>For details about the authorship, see the Git history of the project
+(git://source.ffmpeg.org/ffmpeg), e.g. by typing the command
+<code>git log</code> in the FFmpeg source directory, or browsing the
+online repository at <a href="http://source.ffmpeg.org">http://source.ffmpeg.org</a>.
+</p>
+<p>Maintainers for the specific components are listed in the file
+<samp>MAINTAINERS</samp> in the source code tree.
+</p>
+
+
+      <p style="font-size: small;">
+        This document was generated using <a href="http://www.gnu.org/software/texinfo/"><em>makeinfo</em></a>.
+      </p>
+    </div>
+  </body>
+</html>

ffmpeg-n4.3.2-win64-gpl-shared-4.3/doc/git-howto.html

@@ -0,0 +1,512 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
+  <head>
+    <meta charset="utf-8">
+    <title>
+      Using Git to develop FFmpeg
+    </title>
+    <meta name="viewport" content="width=device-width,initial-scale=1.0">
+    <link rel="stylesheet" type="text/css" href="bootstrap.min.css">
+    <link rel="stylesheet" type="text/css" href="style.min.css">
+  </head>
+  <body>
+    <div class="container">
+      <h1>
+      Using Git to develop FFmpeg
+      </h1>
+<div align="center">
+</div>
+
+
+
+<a name="SEC_Top"></a>
+
+<span id="SEC_Contents"></span>
+<h2 class="contents-heading">Table of Contents</h2>
+
+<div class="contents">
+
+<ul class="no-bullet">
+  <li><a id="toc-Introduction" href="#Introduction">1 Introduction</a></li>
+  <li><a id="toc-Basics-Usage" href="#Basics-Usage">2 Basics Usage</a>
+  <ul class="no-bullet">
+    <li><a id="toc-Get-Git" href="#Get-Git">2.1 Get Git</a></li>
+    <li><a id="toc-Cloning-the-source-tree" href="#Cloning-the-source-tree">2.2 Cloning the source tree</a></li>
+    <li><a id="toc-Updating-the-source-tree-to-the-latest-revision-1" href="#Updating-the-source-tree-to-the-latest-revision-1">2.3 Updating the source tree to the latest revision</a></li>
+    <li><a id="toc-Rebasing-your-local-branches" href="#Rebasing-your-local-branches">2.4 Rebasing your local branches</a></li>
+    <li><a id="toc-Adding_002fremoving-files_002fdirectories" href="#Adding_002fremoving-files_002fdirectories">2.5 Adding/removing files/directories</a></li>
+    <li><a id="toc-Showing-modifications" href="#Showing-modifications">2.6 Showing modifications</a></li>
+    <li><a id="toc-Inspecting-the-changelog" href="#Inspecting-the-changelog">2.7 Inspecting the changelog</a></li>
+    <li><a id="toc-Checking-source-tree-status" href="#Checking-source-tree-status">2.8 Checking source tree status</a></li>
+    <li><a id="toc-Committing" href="#Committing">2.9 Committing</a></li>
+    <li><a id="toc-Preparing-a-patchset" href="#Preparing-a-patchset">2.10 Preparing a patchset</a></li>
+    <li><a id="toc-Sending-patches-for-review" href="#Sending-patches-for-review">2.11 Sending patches for review</a></li>
+    <li><a id="toc-Renaming_002fmoving_002fcopying-files-or-contents-of-files" href="#Renaming_002fmoving_002fcopying-files-or-contents-of-files">2.12 Renaming/moving/copying files or contents of files</a></li>
+  </ul></li>
+  <li><a id="toc-Git-configuration" href="#Git-configuration">3 Git configuration</a>
+  <ul class="no-bullet">
+    <li><a id="toc-Personal-Git-installation" href="#Personal-Git-installation">3.1 Personal Git installation</a></li>
+    <li><a id="toc-Repository-configuration" href="#Repository-configuration">3.2 Repository configuration</a></li>
+  </ul></li>
+  <li><a id="toc-FFmpeg-specific" href="#FFmpeg-specific">4 FFmpeg specific</a>
+  <ul class="no-bullet">
+    <li><a id="toc-Reverting-broken-commits" href="#Reverting-broken-commits">4.1 Reverting broken commits</a></li>
+    <li><a id="toc-Pushing-changes-to-remote-trees" href="#Pushing-changes-to-remote-trees">4.2 Pushing changes to remote trees</a></li>
+    <li><a id="toc-Finding-a-specific-svn-revision" href="#Finding-a-specific-svn-revision">4.3 Finding a specific svn revision</a></li>
+  </ul></li>
+  <li><a id="toc-Pre_002dpush-checklist" href="#Pre_002dpush-checklist">5 Pre-push checklist</a></li>
+  <li><a id="toc-Server-Issues" href="#Server-Issues">6 Server Issues</a></li>
+</ul>
+</div>
+
+
+<a name="Introduction"></a>
+<h2 class="chapter">1 Introduction<span class="pull-right"><a class="anchor hidden-xs" href="#Introduction" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Introduction" aria-hidden="true">TOC</a></span></h2>
+
+<p>This document aims in giving some quick references on a set of useful Git
+commands. You should always use the extensive and detailed documentation
+provided directly by Git:
+</p>
+<div class="example">
+<pre class="example">git --help
+man git
+</pre></div>
+
+<p>shows you the available subcommands,
+</p>
+<div class="example">
+<pre class="example">git &lt;command&gt; --help
+man git-&lt;command&gt;
+</pre></div>
+
+<p>shows information about the subcommand &lt;command&gt;.
+</p>
+<p>Additional information could be found on the
+<a href="http://gitref.org">Git Reference</a> website.
+</p>
+<p>For more information about the Git project, visit the
+<a href="http://git-scm.com/">Git website</a>.
+</p>
+<p>Consult these resources whenever you have problems, they are quite exhaustive.
+</p>
+<p>What follows now is a basic introduction to Git and some FFmpeg-specific
+guidelines to ease the contribution to the project.
+</p>
+<a name="Basics-Usage"></a>
+<h2 class="chapter">2 Basics Usage<span class="pull-right"><a class="anchor hidden-xs" href="#Basics-Usage" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Basics-Usage" aria-hidden="true">TOC</a></span></h2>
+
+<a name="Get-Git"></a>
+<h3 class="section">2.1 Get Git<span class="pull-right"><a class="anchor hidden-xs" href="#Get-Git" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Get-Git" aria-hidden="true">TOC</a></span></h3>
+
+<p>You can get Git from <a href="http://git-scm.com/">http://git-scm.com/</a>
+Most distribution and operating system provide a package for it.
+</p>
+
+<a name="Cloning-the-source-tree"></a>
+<h3 class="section">2.2 Cloning the source tree<span class="pull-right"><a class="anchor hidden-xs" href="#Cloning-the-source-tree" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Cloning-the-source-tree" aria-hidden="true">TOC</a></span></h3>
+
+<div class="example">
+<pre class="example">git clone git://source.ffmpeg.org/ffmpeg &lt;target&gt;
+</pre></div>
+
+<p>This will put the FFmpeg sources into the directory <var>&lt;target&gt;</var>.
+</p>
+<div class="example">
+<pre class="example">git clone git@source.ffmpeg.org:ffmpeg &lt;target&gt;
+</pre></div>
+
+<p>This will put the FFmpeg sources into the directory <var>&lt;target&gt;</var> and let
+you push back your changes to the remote repository.
+</p>
+<div class="example">
+<pre class="example">git clone gil@ffmpeg.org:ffmpeg-web &lt;target&gt;
+</pre></div>
+
+<p>This will put the source of the FFmpeg website into the directory
+<var>&lt;target&gt;</var> and let you push back your changes to the remote repository.
+(Note that <var>gil</var> stands for GItoLite and is not a typo of <var>git</var>.)
+</p>
+<p>If you don&rsquo;t have write-access to the ffmpeg-web repository, you can
+create patches after making a read-only ffmpeg-web clone:
+</p>
+<div class="example">
+<pre class="example">git clone git://ffmpeg.org/ffmpeg-web &lt;target&gt;
+</pre></div>
+
+<p>Make sure that you do not have Windows line endings in your checkouts,
+otherwise you may experience spurious compilation failures. One way to
+achieve this is to run
+</p>
+<div class="example">
+<pre class="example">git config --global core.autocrlf false
+</pre></div>
+
+
+<span id="Updating-the-source-tree-to-the-latest-revision"></span><a name="Updating-the-source-tree-to-the-latest-revision-1"></a>
+<h3 class="section">2.3 Updating the source tree to the latest revision<span class="pull-right"><a class="anchor hidden-xs" href="#Updating-the-source-tree-to-the-latest-revision-1" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Updating-the-source-tree-to-the-latest-revision-1" aria-hidden="true">TOC</a></span></h3>
+
+<div class="example">
+<pre class="example">git pull (--rebase)
+</pre></div>
+
+<p>pulls in the latest changes from the tracked branch. The tracked branch
+can be remote. By default the master branch tracks the branch master in
+the remote origin.
+</p>
+<div class="warning">
+<p><code>--rebase</code> (see below) is recommended.
+</p></div>
+<a name="Rebasing-your-local-branches"></a>
+<h3 class="section">2.4 Rebasing your local branches<span class="pull-right"><a class="anchor hidden-xs" href="#Rebasing-your-local-branches" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Rebasing-your-local-branches" aria-hidden="true">TOC</a></span></h3>
+
+<div class="example">
+<pre class="example">git pull --rebase
+</pre></div>
+
+<p>fetches the changes from the main repository and replays your local commits
+over it. This is required to keep all your local changes at the top of
+FFmpeg&rsquo;s master tree. The master tree will reject pushes with merge commits.
+</p>
+
+<a name="Adding_002fremoving-files_002fdirectories"></a>
+<h3 class="section">2.5 Adding/removing files/directories<span class="pull-right"><a class="anchor hidden-xs" href="#Adding_002fremoving-files_002fdirectories" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Adding_002fremoving-files_002fdirectories" aria-hidden="true">TOC</a></span></h3>
+
+<div class="example">
+<pre class="example">git add [-A] &lt;filename/dirname&gt;
+git rm [-r] &lt;filename/dirname&gt;
+</pre></div>
+
+<p>Git needs to get notified of all changes you make to your working
+directory that makes files appear or disappear.
+Line moves across files are automatically tracked.
+</p>
+
+<a name="Showing-modifications"></a>
+<h3 class="section">2.6 Showing modifications<span class="pull-right"><a class="anchor hidden-xs" href="#Showing-modifications" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Showing-modifications" aria-hidden="true">TOC</a></span></h3>
+
+<div class="example">
+<pre class="example">git diff &lt;filename(s)&gt;
+</pre></div>
+
+<p>will show all local modifications in your working directory as unified diff.
+</p>
+
+<a name="Inspecting-the-changelog"></a>
+<h3 class="section">2.7 Inspecting the changelog<span class="pull-right"><a class="anchor hidden-xs" href="#Inspecting-the-changelog" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Inspecting-the-changelog" aria-hidden="true">TOC</a></span></h3>
+
+<div class="example">
+<pre class="example">git log &lt;filename(s)&gt;
+</pre></div>
+
+<p>You may also use the graphical tools like <code>gitview</code> or <code>gitk</code>
+or the web interface available at <a href="http://source.ffmpeg.org/">http://source.ffmpeg.org/</a>.
+</p>
+<a name="Checking-source-tree-status"></a>
+<h3 class="section">2.8 Checking source tree status<span class="pull-right"><a class="anchor hidden-xs" href="#Checking-source-tree-status" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Checking-source-tree-status" aria-hidden="true">TOC</a></span></h3>
+
+<div class="example">
+<pre class="example">git status
+</pre></div>
+
+<p>detects all the changes you made and lists what actions will be taken in case
+of a commit (additions, modifications, deletions, etc.).
+</p>
+
+<a name="Committing"></a>
+<h3 class="section">2.9 Committing<span class="pull-right"><a class="anchor hidden-xs" href="#Committing" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Committing" aria-hidden="true">TOC</a></span></h3>
+
+<div class="example">
+<pre class="example">git diff --check
+</pre></div>
+
+<p>to double check your changes before committing them to avoid trouble later
+on. All experienced developers do this on each and every commit, no matter
+how small.
+</p>
+<p>Every one of them has been saved from looking like a fool by this many times.
+It&rsquo;s very easy for stray debug output or cosmetic modifications to slip in,
+please avoid problems through this extra level of scrutiny.
+</p>
+<p>For cosmetics-only commits you should get (almost) empty output from
+</p>
+<div class="example">
+<pre class="example">git diff -w -b &lt;filename(s)&gt;
+</pre></div>
+
+<p>Also check the output of
+</p>
+<div class="example">
+<pre class="example">git status
+</pre></div>
+
+<p>to make sure you don&rsquo;t have untracked files or deletions.
+</p>
+<div class="example">
+<pre class="example">git add [-i|-p|-A] &lt;filenames/dirnames&gt;
+</pre></div>
+
+<p>Make sure you have told Git your name and email address
+</p>
+<div class="example">
+<pre class="example">git config --global user.name &quot;My Name&quot;
+git config --global user.email my@email.invalid
+</pre></div>
+
+<p>Use <samp>--global</samp> to set the global configuration for all your Git checkouts.
+</p>
+<p>Git will select the changes to the files for commit. Optionally you can use
+the interactive or the patch mode to select hunk by hunk what should be
+added to the commit.
+</p>
+
+<div class="example">
+<pre class="example">git commit
+</pre></div>
+
+<p>Git will commit the selected changes to your current local branch.
+</p>
+<p>You will be prompted for a log message in an editor, which is either
+set in your personal configuration file through
+</p>
+<div class="example">
+<pre class="example">git config --global core.editor
+</pre></div>
+
+<p>or set by one of the following environment variables:
+<var>GIT_EDITOR</var>, <var>VISUAL</var> or <var>EDITOR</var>.
+</p>
+<p>Log messages should be concise but descriptive. Explain why you made a change,
+what you did will be obvious from the changes themselves most of the time.
+Saying just &quot;bug fix&quot; or &quot;10l&quot; is bad. Remember that people of varying skill
+levels look at and educate themselves while reading through your code. Don&rsquo;t
+include filenames in log messages, Git provides that information.
+</p>
+<p>Possibly make the commit message have a terse, descriptive first line, an
+empty line and then a full description. The first line will be used to name
+the patch by <code>git format-patch</code>.
+</p>
+<a name="Preparing-a-patchset"></a>
+<h3 class="section">2.10 Preparing a patchset<span class="pull-right"><a class="anchor hidden-xs" href="#Preparing-a-patchset" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Preparing-a-patchset" aria-hidden="true">TOC</a></span></h3>
+
+<div class="example">
+<pre class="example">git format-patch &lt;commit&gt; [-o directory]
+</pre></div>
+
+<p>will generate a set of patches for each commit between <var>&lt;commit&gt;</var> and
+current <var>HEAD</var>. E.g.
+</p>
+<div class="example">
+<pre class="example">git format-patch origin/master
+</pre></div>
+
+<p>will generate patches for all commits on current branch which are not
+present in upstream.
+A useful shortcut is also
+</p>
+<div class="example">
+<pre class="example">git format-patch -n
+</pre></div>
+
+<p>which will generate patches from last <var>n</var> commits.
+By default the patches are created in the current directory.
+</p>
+<a name="Sending-patches-for-review"></a>
+<h3 class="section">2.11 Sending patches for review<span class="pull-right"><a class="anchor hidden-xs" href="#Sending-patches-for-review" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Sending-patches-for-review" aria-hidden="true">TOC</a></span></h3>
+
+<div class="example">
+<pre class="example">git send-email &lt;commit list|directory&gt;
+</pre></div>
+
+<p>will send the patches created by <code>git format-patch</code> or directly
+generates them. All the email fields can be configured in the global/local
+configuration or overridden by command line.
+Note that this tool must often be installed separately (e.g. <var>git-email</var>
+package on Debian-based distros).
+</p>
+
+<a name="Renaming_002fmoving_002fcopying-files-or-contents-of-files"></a>
+<h3 class="section">2.12 Renaming/moving/copying files or contents of files<span class="pull-right"><a class="anchor hidden-xs" href="#Renaming_002fmoving_002fcopying-files-or-contents-of-files" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Renaming_002fmoving_002fcopying-files-or-contents-of-files" aria-hidden="true">TOC</a></span></h3>
+
+<p>Git automatically tracks such changes, making those normal commits.
+</p>
+<div class="example">
+<pre class="example">mv/cp path/file otherpath/otherfile
+git add [-A] .
+git commit
+</pre></div>
+
+
+<a name="Git-configuration"></a>
+<h2 class="chapter">3 Git configuration<span class="pull-right"><a class="anchor hidden-xs" href="#Git-configuration" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Git-configuration" aria-hidden="true">TOC</a></span></h2>
+
+<p>In order to simplify a few workflows, it is advisable to configure both
+your personal Git installation and your local FFmpeg repository.
+</p>
+<a name="Personal-Git-installation"></a>
+<h3 class="section">3.1 Personal Git installation<span class="pull-right"><a class="anchor hidden-xs" href="#Personal-Git-installation" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Personal-Git-installation" aria-hidden="true">TOC</a></span></h3>
+
+<p>Add the following to your <samp>~/.gitconfig</samp> to help <code>git send-email</code>
+and <code>git format-patch</code> detect renames:
+</p>
+<div class="example">
+<pre class="example">[diff]
+        renames = copy
+</pre></div>
+
+<a name="Repository-configuration"></a>
+<h3 class="section">3.2 Repository configuration<span class="pull-right"><a class="anchor hidden-xs" href="#Repository-configuration" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Repository-configuration" aria-hidden="true">TOC</a></span></h3>
+
+<p>In order to have <code>git send-email</code> automatically send patches
+to the ffmpeg-devel mailing list, add the following stanza
+to <samp>/path/to/ffmpeg/repository/.git/config</samp>:
+</p>
+<div class="example">
+<pre class="example">[sendemail]
+        to = ffmpeg-devel@ffmpeg.org
+</pre></div>
+
+<a name="FFmpeg-specific"></a>
+<h2 class="chapter">4 FFmpeg specific<span class="pull-right"><a class="anchor hidden-xs" href="#FFmpeg-specific" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-FFmpeg-specific" aria-hidden="true">TOC</a></span></h2>
+
+<a name="Reverting-broken-commits"></a>
+<h3 class="section">4.1 Reverting broken commits<span class="pull-right"><a class="anchor hidden-xs" href="#Reverting-broken-commits" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Reverting-broken-commits" aria-hidden="true">TOC</a></span></h3>
+
+<div class="example">
+<pre class="example">git reset &lt;commit&gt;
+</pre></div>
+
+<p><code>git reset</code> will uncommit the changes till <var>&lt;commit&gt;</var> rewriting
+the current branch history.
+</p>
+<div class="example">
+<pre class="example">git commit --amend
+</pre></div>
+
+<p>allows one to amend the last commit details quickly.
+</p>
+<div class="example">
+<pre class="example">git rebase -i origin/master
+</pre></div>
+
+<p>will replay local commits over the main repository allowing to edit, merge
+or remove some of them in the process.
+</p>
+<div class="info">
+<p><code>git reset</code>, <code>git commit --amend</code> and <code>git rebase</code>
+rewrite history, so you should use them ONLY on your local or topic branches.
+The main repository will reject those changes.
+</p></div>
+<div class="example">
+<pre class="example">git revert &lt;commit&gt;
+</pre></div>
+
+<p><code>git revert</code> will generate a revert commit. This will not make the
+faulty commit disappear from the history.
+</p>
+<a name="Pushing-changes-to-remote-trees"></a>
+<h3 class="section">4.2 Pushing changes to remote trees<span class="pull-right"><a class="anchor hidden-xs" href="#Pushing-changes-to-remote-trees" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Pushing-changes-to-remote-trees" aria-hidden="true">TOC</a></span></h3>
+
+<div class="example">
+<pre class="example">git push origin master --dry-run
+</pre></div>
+
+<p>Will simulate a push of the local master branch to the default remote
+(<var>origin</var>). And list which branches and ranges or commits would have been
+pushed.
+Git will prevent you from pushing changes if the local and remote trees are
+out of sync. Refer to <a href="#Updating-the-source-tree-to-the-latest-revision">Updating the source tree to the latest revision</a>.
+</p>
+<div class="example">
+<pre class="example">git remote add &lt;name&gt; &lt;url&gt;
+</pre></div>
+
+<p>Will add additional remote with a name reference, it is useful if you want
+to push your local branch for review on a remote host.
+</p>
+<div class="example">
+<pre class="example">git push &lt;remote&gt; &lt;refspec&gt;
+</pre></div>
+
+<p>Will push the changes to the <var>&lt;remote&gt;</var> repository.
+Omitting <var>&lt;refspec&gt;</var> makes <code>git push</code> update all the remote
+branches matching the local ones.
+</p>
+<a name="Finding-a-specific-svn-revision"></a>
+<h3 class="section">4.3 Finding a specific svn revision<span class="pull-right"><a class="anchor hidden-xs" href="#Finding-a-specific-svn-revision" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Finding-a-specific-svn-revision" aria-hidden="true">TOC</a></span></h3>
+
+<p>Since version 1.7.1 Git supports &lsquo;<samp>:/foo</samp>&rsquo; syntax for specifying commits
+based on a regular expression. see man gitrevisions
+</p>
+<div class="example">
+<pre class="example">git show :/'as revision 23456'
+</pre></div>
+
+<p>will show the svn changeset &lsquo;<samp>r23456</samp>&rsquo;. With older Git versions searching in
+the <code>git log</code> output is the easiest option (especially if a pager with
+search capabilities is used).
+</p>
+<p>This commit can be checked out with
+</p>
+<div class="example">
+<pre class="example">git checkout -b svn_23456 :/'as revision 23456'
+</pre></div>
+
+<p>or for Git &lt; 1.7.1 with
+</p>
+<div class="example">
+<pre class="example">git checkout -b svn_23456 $SHA1
+</pre></div>
+
+<p>where <var>$SHA1</var> is the commit hash from the <code>git log</code> output.
+</p>
+
+<a name="Pre_002dpush-checklist"></a>
+<h2 class="chapter">5 Pre-push checklist<span class="pull-right"><a class="anchor hidden-xs" href="#Pre_002dpush-checklist" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Pre_002dpush-checklist" aria-hidden="true">TOC</a></span></h2>
+
+<p>Once you have a set of commits that you feel are ready for pushing,
+work through the following checklist to doublecheck everything is in
+proper order. This list tries to be exhaustive. In case you are just
+pushing a typo in a comment, some of the steps may be unnecessary.
+Apply your common sense, but if in doubt, err on the side of caution.
+</p>
+<p>First, make sure that the commits and branches you are going to push
+match what you want pushed and that nothing is missing, extraneous or
+wrong. You can see what will be pushed by running the git push command
+with <samp>--dry-run</samp> first. And then inspecting the commits listed with
+<code>git log -p 1234567..987654</code>. The <code>git status</code> command
+may help in finding local changes that have been forgotten to be added.
+</p>
+<p>Next let the code pass through a full run of our test suite.
+</p>
+<ul>
+<li> <code>make distclean</code>
+</li><li> <code>/path/to/ffmpeg/configure</code>
+</li><li> <code>make fate</code>
+</li><li> if fate fails due to missing samples run <code>make fate-rsync</code> and retry
+</li></ul>
+
+<p>Make sure all your changes have been checked before pushing them, the
+test suite only checks against regressions and that only to some extend. It does
+obviously not check newly added features/code to be working unless you have
+added a test for that (which is recommended).
+</p>
+<p>Also note that every single commit should pass the test suite, not just
+the result of a series of patches.
+</p>
+<p>Once everything passed, push the changes to your public ffmpeg clone and post a
+merge request to ffmpeg-devel. You can also push them directly but this is not
+recommended.
+</p>
+<a name="Server-Issues"></a>
+<h2 class="chapter">6 Server Issues<span class="pull-right"><a class="anchor hidden-xs" href="#Server-Issues" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Server-Issues" aria-hidden="true">TOC</a></span></h2>
+
+<p>Contact the project admins at <a href="mailto:root@ffmpeg.org">root@ffmpeg.org</a> if you have technical
+problems with the Git server.
+</p>
+      <p style="font-size: small;">
+        This document was generated using <a href="http://www.gnu.org/software/texinfo/"><em>makeinfo</em></a>.
+      </p>
+    </div>
+  </body>
+</html>

ffmpeg-n4.3.2-win64-gpl-shared-4.3/doc/libavcodec.html

@@ -0,0 +1,77 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
+  <head>
+    <meta charset="utf-8">
+    <title>
+      Libavcodec Documentation
+    </title>
+    <meta name="viewport" content="width=device-width,initial-scale=1.0">
+    <link rel="stylesheet" type="text/css" href="bootstrap.min.css">
+    <link rel="stylesheet" type="text/css" href="style.min.css">
+  </head>
+  <body>
+    <div class="container">
+      <h1>
+      Libavcodec Documentation
+      </h1>
+<div align="center">
+</div>
+
+
+<a name="SEC_Top"></a>
+
+<span id="SEC_Contents"></span>
+<h2 class="contents-heading">Table of Contents</h2>
+
+<div class="contents">
+
+<ul class="no-bullet">
+  <li><a id="toc-Description" href="#Description">1 Description</a></li>
+  <li><a id="toc-See-Also" href="#See-Also">2 See Also</a></li>
+  <li><a id="toc-Authors" href="#Authors">3 Authors</a></li>
+</ul>
+</div>
+
+
+<a name="Description"></a>
+<h2 class="chapter">1 Description<span class="pull-right"><a class="anchor hidden-xs" href="#Description" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Description" aria-hidden="true">TOC</a></span></h2>
+
+<p>The libavcodec library provides a generic encoding/decoding framework
+and contains multiple decoders and encoders for audio, video and
+subtitle streams, and several bitstream filters.
+</p>
+<p>The shared architecture provides various services ranging from bit
+stream I/O to DSP optimizations, and makes it suitable for
+implementing robust and fast codecs as well as for experimentation.
+</p>
+
+<a name="See-Also"></a>
+<h2 class="chapter">2 See Also<span class="pull-right"><a class="anchor hidden-xs" href="#See-Also" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-See-Also" aria-hidden="true">TOC</a></span></h2>
+
+<p><a href="ffmpeg.html">ffmpeg</a>, <a href="ffplay.html">ffplay</a>, <a href="ffprobe.html">ffprobe</a>,
+<a href="ffmpeg-codecs.html">ffmpeg-codecs</a>, <a href="ffmpeg-bitstream-filters.html">bitstream-filters</a>,
+<a href="libavutil.html">libavutil</a>
+</p>
+
+<a name="Authors"></a>
+<h2 class="chapter">3 Authors<span class="pull-right"><a class="anchor hidden-xs" href="#Authors" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Authors" aria-hidden="true">TOC</a></span></h2>
+
+<p>The FFmpeg developers.
+</p>
+<p>For details about the authorship, see the Git history of the project
+(git://source.ffmpeg.org/ffmpeg), e.g. by typing the command
+<code>git log</code> in the FFmpeg source directory, or browsing the
+online repository at <a href="http://source.ffmpeg.org">http://source.ffmpeg.org</a>.
+</p>
+<p>Maintainers for the specific components are listed in the file
+<samp>MAINTAINERS</samp> in the source code tree.
+</p>
+
+
+      <p style="font-size: small;">
+        This document was generated using <a href="http://www.gnu.org/software/texinfo/"><em>makeinfo</em></a>.
+      </p>
+    </div>
+  </body>
+</html>

ffmpeg-n4.3.2-win64-gpl-shared-4.3/doc/libavdevice.html

@@ -0,0 +1,74 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
+  <head>
+    <meta charset="utf-8">
+    <title>
+      Libavdevice Documentation
+    </title>
+    <meta name="viewport" content="width=device-width,initial-scale=1.0">
+    <link rel="stylesheet" type="text/css" href="bootstrap.min.css">
+    <link rel="stylesheet" type="text/css" href="style.min.css">
+  </head>
+  <body>
+    <div class="container">
+      <h1>
+      Libavdevice Documentation
+      </h1>
+<div align="center">
+</div>
+
+
+<a name="SEC_Top"></a>
+
+<span id="SEC_Contents"></span>
+<h2 class="contents-heading">Table of Contents</h2>
+
+<div class="contents">
+
+<ul class="no-bullet">
+  <li><a id="toc-Description" href="#Description">1 Description</a></li>
+  <li><a id="toc-See-Also" href="#See-Also">2 See Also</a></li>
+  <li><a id="toc-Authors" href="#Authors">3 Authors</a></li>
+</ul>
+</div>
+
+
+<a name="Description"></a>
+<h2 class="chapter">1 Description<span class="pull-right"><a class="anchor hidden-xs" href="#Description" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Description" aria-hidden="true">TOC</a></span></h2>
+
+<p>The libavdevice library provides a generic framework for grabbing from
+and rendering to many common multimedia input/output devices, and
+supports several input and output devices, including Video4Linux2,
+VfW, DShow, and ALSA.
+</p>
+
+<a name="See-Also"></a>
+<h2 class="chapter">2 See Also<span class="pull-right"><a class="anchor hidden-xs" href="#See-Also" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-See-Also" aria-hidden="true">TOC</a></span></h2>
+
+<p><a href="ffmpeg.html">ffmpeg</a>, <a href="ffplay.html">ffplay</a>, <a href="ffprobe.html">ffprobe</a>,
+<a href="ffmpeg-devices.html">ffmpeg-devices</a>,
+<a href="libavutil.html">libavutil</a>, <a href="libavcodec.html">libavcodec</a>, <a href="libavformat.html">libavformat</a>
+</p>
+
+<a name="Authors"></a>
+<h2 class="chapter">3 Authors<span class="pull-right"><a class="anchor hidden-xs" href="#Authors" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Authors" aria-hidden="true">TOC</a></span></h2>
+
+<p>The FFmpeg developers.
+</p>
+<p>For details about the authorship, see the Git history of the project
+(git://source.ffmpeg.org/ffmpeg), e.g. by typing the command
+<code>git log</code> in the FFmpeg source directory, or browsing the
+online repository at <a href="http://source.ffmpeg.org">http://source.ffmpeg.org</a>.
+</p>
+<p>Maintainers for the specific components are listed in the file
+<samp>MAINTAINERS</samp> in the source code tree.
+</p>
+
+
+      <p style="font-size: small;">
+        This document was generated using <a href="http://www.gnu.org/software/texinfo/"><em>makeinfo</em></a>.
+      </p>
+    </div>
+  </body>
+</html>

ffmpeg-n4.3.2-win64-gpl-shared-4.3/doc/libavfilter.html

@@ -0,0 +1,73 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
+  <head>
+    <meta charset="utf-8">
+    <title>
+      Libavfilter Documentation
+    </title>
+    <meta name="viewport" content="width=device-width,initial-scale=1.0">
+    <link rel="stylesheet" type="text/css" href="bootstrap.min.css">
+    <link rel="stylesheet" type="text/css" href="style.min.css">
+  </head>
+  <body>
+    <div class="container">
+      <h1>
+      Libavfilter Documentation
+      </h1>
+<div align="center">
+</div>
+
+
+<a name="SEC_Top"></a>
+
+<span id="SEC_Contents"></span>
+<h2 class="contents-heading">Table of Contents</h2>
+
+<div class="contents">
+
+<ul class="no-bullet">
+  <li><a id="toc-Description" href="#Description">1 Description</a></li>
+  <li><a id="toc-See-Also" href="#See-Also">2 See Also</a></li>
+  <li><a id="toc-Authors" href="#Authors">3 Authors</a></li>
+</ul>
+</div>
+
+
+<a name="Description"></a>
+<h2 class="chapter">1 Description<span class="pull-right"><a class="anchor hidden-xs" href="#Description" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Description" aria-hidden="true">TOC</a></span></h2>
+
+<p>The libavfilter library provides a generic audio/video filtering
+framework containing several filters, sources and sinks.
+</p>
+
+<a name="See-Also"></a>
+<h2 class="chapter">2 See Also<span class="pull-right"><a class="anchor hidden-xs" href="#See-Also" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-See-Also" aria-hidden="true">TOC</a></span></h2>
+
+<p><a href="ffmpeg.html">ffmpeg</a>, <a href="ffplay.html">ffplay</a>, <a href="ffprobe.html">ffprobe</a>,
+<a href="ffmpeg-filters.html">ffmpeg-filters</a>,
+<a href="libavutil.html">libavutil</a>, <a href="libswscale.html">libswscale</a>, <a href="libswresample.html">libswresample</a>,
+<a href="libavcodec.html">libavcodec</a>, <a href="libavformat.html">libavformat</a>, <a href="libavdevice.html">libavdevice</a>
+</p>
+
+<a name="Authors"></a>
+<h2 class="chapter">3 Authors<span class="pull-right"><a class="anchor hidden-xs" href="#Authors" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Authors" aria-hidden="true">TOC</a></span></h2>
+
+<p>The FFmpeg developers.
+</p>
+<p>For details about the authorship, see the Git history of the project
+(git://source.ffmpeg.org/ffmpeg), e.g. by typing the command
+<code>git log</code> in the FFmpeg source directory, or browsing the
+online repository at <a href="http://source.ffmpeg.org">http://source.ffmpeg.org</a>.
+</p>
+<p>Maintainers for the specific components are listed in the file
+<samp>MAINTAINERS</samp> in the source code tree.
+</p>
+
+
+      <p style="font-size: small;">
+        This document was generated using <a href="http://www.gnu.org/software/texinfo/"><em>makeinfo</em></a>.
+      </p>
+    </div>
+  </body>
+</html>

ffmpeg-n4.3.2-win64-gpl-shared-4.3/doc/libavformat.html

@@ -0,0 +1,77 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
+  <head>
+    <meta charset="utf-8">
+    <title>
+      Libavformat Documentation
+    </title>
+    <meta name="viewport" content="width=device-width,initial-scale=1.0">
+    <link rel="stylesheet" type="text/css" href="bootstrap.min.css">
+    <link rel="stylesheet" type="text/css" href="style.min.css">
+  </head>
+  <body>
+    <div class="container">
+      <h1>
+      Libavformat Documentation
+      </h1>
+<div align="center">
+</div>
+
+
+<a name="SEC_Top"></a>
+
+<span id="SEC_Contents"></span>
+<h2 class="contents-heading">Table of Contents</h2>
+
+<div class="contents">
+
+<ul class="no-bullet">
+  <li><a id="toc-Description" href="#Description">1 Description</a></li>
+  <li><a id="toc-See-Also" href="#See-Also">2 See Also</a></li>
+  <li><a id="toc-Authors" href="#Authors">3 Authors</a></li>
+</ul>
+</div>
+
+
+<a name="Description"></a>
+<h2 class="chapter">1 Description<span class="pull-right"><a class="anchor hidden-xs" href="#Description" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Description" aria-hidden="true">TOC</a></span></h2>
+
+<p>The libavformat library provides a generic framework for multiplexing
+and demultiplexing (muxing and demuxing) audio, video and subtitle
+streams. It encompasses multiple muxers and demuxers for multimedia
+container formats.
+</p>
+<p>It also supports several input and output protocols to access a media
+resource.
+</p>
+
+<a name="See-Also"></a>
+<h2 class="chapter">2 See Also<span class="pull-right"><a class="anchor hidden-xs" href="#See-Also" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-See-Also" aria-hidden="true">TOC</a></span></h2>
+
+<p><a href="ffmpeg.html">ffmpeg</a>, <a href="ffplay.html">ffplay</a>, <a href="ffprobe.html">ffprobe</a>,
+<a href="ffmpeg-formats.html">ffmpeg-formats</a>, <a href="ffmpeg-protocols.html">ffmpeg-protocols</a>,
+<a href="libavutil.html">libavutil</a>, <a href="libavcodec.html">libavcodec</a>
+</p>
+
+<a name="Authors"></a>
+<h2 class="chapter">3 Authors<span class="pull-right"><a class="anchor hidden-xs" href="#Authors" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Authors" aria-hidden="true">TOC</a></span></h2>
+
+<p>The FFmpeg developers.
+</p>
+<p>For details about the authorship, see the Git history of the project
+(git://source.ffmpeg.org/ffmpeg), e.g. by typing the command
+<code>git log</code> in the FFmpeg source directory, or browsing the
+online repository at <a href="http://source.ffmpeg.org">http://source.ffmpeg.org</a>.
+</p>
+<p>Maintainers for the specific components are listed in the file
+<samp>MAINTAINERS</samp> in the source code tree.
+</p>
+
+
+      <p style="font-size: small;">
+        This document was generated using <a href="http://www.gnu.org/software/texinfo/"><em>makeinfo</em></a>.
+      </p>
+    </div>
+  </body>
+</html>

ffmpeg-n4.3.2-win64-gpl-shared-4.3/doc/libavutil.html

@@ -0,0 +1,96 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
+  <head>
+    <meta charset="utf-8">
+    <title>
+      Libavutil Documentation
+    </title>
+    <meta name="viewport" content="width=device-width,initial-scale=1.0">
+    <link rel="stylesheet" type="text/css" href="bootstrap.min.css">
+    <link rel="stylesheet" type="text/css" href="style.min.css">
+  </head>
+  <body>
+    <div class="container">
+      <h1>
+      Libavutil Documentation
+      </h1>
+<div align="center">
+</div>
+
+
+<a name="SEC_Top"></a>
+
+<span id="SEC_Contents"></span>
+<h2 class="contents-heading">Table of Contents</h2>
+
+<div class="contents">
+
+<ul class="no-bullet">
+  <li><a id="toc-Description" href="#Description">1 Description</a></li>
+  <li><a id="toc-See-Also" href="#See-Also">2 See Also</a></li>
+  <li><a id="toc-Authors" href="#Authors">3 Authors</a></li>
+</ul>
+</div>
+
+
+<a name="Description"></a>
+<h2 class="chapter">1 Description<span class="pull-right"><a class="anchor hidden-xs" href="#Description" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Description" aria-hidden="true">TOC</a></span></h2>
+
+<p>The libavutil library is a utility library to aid portable
+multimedia programming. It contains safe portable string functions,
+random number generators, data structures, additional mathematics
+functions, cryptography and multimedia related functionality (like
+enumerations for pixel and sample formats). It is not a library for
+code needed by both libavcodec and libavformat.
+</p>
+<p>The goals for this library is to be:
+</p>
+<dl compact="compact">
+<dt><strong>Modular</strong></dt>
+<dd><p>It should have few interdependencies and the possibility of disabling individual
+parts during <code>./configure</code>.
+</p>
+</dd>
+<dt><strong>Small</strong></dt>
+<dd><p>Both sources and objects should be small.
+</p>
+</dd>
+<dt><strong>Efficient</strong></dt>
+<dd><p>It should have low CPU and memory usage.
+</p>
+</dd>
+<dt><strong>Useful</strong></dt>
+<dd><p>It should avoid useless features that almost no one needs.
+</p></dd>
+</dl>
+
+
+<a name="See-Also"></a>
+<h2 class="chapter">2 See Also<span class="pull-right"><a class="anchor hidden-xs" href="#See-Also" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-See-Also" aria-hidden="true">TOC</a></span></h2>
+
+<p><a href="ffmpeg.html">ffmpeg</a>, <a href="ffplay.html">ffplay</a>, <a href="ffprobe.html">ffprobe</a>,
+<a href="ffmpeg-utils.html">ffmpeg-utils</a>
+</p>
+
+<a name="Authors"></a>
+<h2 class="chapter">3 Authors<span class="pull-right"><a class="anchor hidden-xs" href="#Authors" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Authors" aria-hidden="true">TOC</a></span></h2>
+
+<p>The FFmpeg developers.
+</p>
+<p>For details about the authorship, see the Git history of the project
+(git://source.ffmpeg.org/ffmpeg), e.g. by typing the command
+<code>git log</code> in the FFmpeg source directory, or browsing the
+online repository at <a href="http://source.ffmpeg.org">http://source.ffmpeg.org</a>.
+</p>
+<p>Maintainers for the specific components are listed in the file
+<samp>MAINTAINERS</samp> in the source code tree.
+</p>
+
+
+      <p style="font-size: small;">
+        This document was generated using <a href="http://www.gnu.org/software/texinfo/"><em>makeinfo</em></a>.
+      </p>
+    </div>
+  </body>
+</html>

ffmpeg-n4.3.2-win64-gpl-shared-4.3/doc/libswresample.html

@@ -0,0 +1,96 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
+  <head>
+    <meta charset="utf-8">
+    <title>
+      Libswresample Documentation
+    </title>
+    <meta name="viewport" content="width=device-width,initial-scale=1.0">
+    <link rel="stylesheet" type="text/css" href="bootstrap.min.css">
+    <link rel="stylesheet" type="text/css" href="style.min.css">
+  </head>
+  <body>
+    <div class="container">
+      <h1>
+      Libswresample Documentation
+      </h1>
+<div align="center">
+</div>
+
+
+<a name="SEC_Top"></a>
+
+<span id="SEC_Contents"></span>
+<h2 class="contents-heading">Table of Contents</h2>
+
+<div class="contents">
+
+<ul class="no-bullet">
+  <li><a id="toc-Description" href="#Description">1 Description</a></li>
+  <li><a id="toc-See-Also" href="#See-Also">2 See Also</a></li>
+  <li><a id="toc-Authors" href="#Authors">3 Authors</a></li>
+</ul>
+</div>
+
+
+<a name="Description"></a>
+<h2 class="chapter">1 Description<span class="pull-right"><a class="anchor hidden-xs" href="#Description" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Description" aria-hidden="true">TOC</a></span></h2>
+
+<p>The libswresample library performs highly optimized audio resampling,
+rematrixing and sample format conversion operations.
+</p>
+<p>Specifically, this library performs the following conversions:
+</p>
+<ul>
+<li> <em>Resampling</em>: is the process of changing the audio rate, for
+example from a high sample rate of 44100Hz to 8000Hz. Audio
+conversion from high to low sample rate is a lossy process. Several
+resampling options and algorithms are available.
+
+</li><li> <em>Format conversion</em>: is the process of converting the type of
+samples, for example from 16-bit signed samples to unsigned 8-bit or
+float samples. It also handles packing conversion, when passing from
+packed layout (all samples belonging to distinct channels interleaved
+in the same buffer), to planar layout (all samples belonging to the
+same channel stored in a dedicated buffer or &quot;plane&quot;).
+
+</li><li> <em>Rematrixing</em>: is the process of changing the channel layout, for
+example from stereo to mono. When the input channels cannot be mapped
+to the output streams, the process is lossy, since it involves
+different gain factors and mixing.
+</li></ul>
+
+<p>Various other audio conversions (e.g. stretching and padding) are
+enabled through dedicated options.
+</p>
+
+<a name="See-Also"></a>
+<h2 class="chapter">2 See Also<span class="pull-right"><a class="anchor hidden-xs" href="#See-Also" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-See-Also" aria-hidden="true">TOC</a></span></h2>
+
+<p><a href="ffmpeg.html">ffmpeg</a>, <a href="ffplay.html">ffplay</a>, <a href="ffprobe.html">ffprobe</a>,
+<a href="ffmpeg-resampler.html">ffmpeg-resampler</a>,
+<a href="libavutil.html">libavutil</a>
+</p>
+
+<a name="Authors"></a>
+<h2 class="chapter">3 Authors<span class="pull-right"><a class="anchor hidden-xs" href="#Authors" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Authors" aria-hidden="true">TOC</a></span></h2>
+
+<p>The FFmpeg developers.
+</p>
+<p>For details about the authorship, see the Git history of the project
+(git://source.ffmpeg.org/ffmpeg), e.g. by typing the command
+<code>git log</code> in the FFmpeg source directory, or browsing the
+online repository at <a href="http://source.ffmpeg.org">http://source.ffmpeg.org</a>.
+</p>
+<p>Maintainers for the specific components are listed in the file
+<samp>MAINTAINERS</samp> in the source code tree.
+</p>
+
+
+      <p style="font-size: small;">
+        This document was generated using <a href="http://www.gnu.org/software/texinfo/"><em>makeinfo</em></a>.
+      </p>
+    </div>
+  </body>
+</html>

ffmpeg-n4.3.2-win64-gpl-shared-4.3/doc/libswscale.html

@@ -0,0 +1,90 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
+  <head>
+    <meta charset="utf-8">
+    <title>
+      Libswscale Documentation
+    </title>
+    <meta name="viewport" content="width=device-width,initial-scale=1.0">
+    <link rel="stylesheet" type="text/css" href="bootstrap.min.css">
+    <link rel="stylesheet" type="text/css" href="style.min.css">
+  </head>
+  <body>
+    <div class="container">
+      <h1>
+      Libswscale Documentation
+      </h1>
+<div align="center">
+</div>
+
+
+<a name="SEC_Top"></a>
+
+<span id="SEC_Contents"></span>
+<h2 class="contents-heading">Table of Contents</h2>
+
+<div class="contents">
+
+<ul class="no-bullet">
+  <li><a id="toc-Description" href="#Description">1 Description</a></li>
+  <li><a id="toc-See-Also" href="#See-Also">2 See Also</a></li>
+  <li><a id="toc-Authors" href="#Authors">3 Authors</a></li>
+</ul>
+</div>
+
+
+<a name="Description"></a>
+<h2 class="chapter">1 Description<span class="pull-right"><a class="anchor hidden-xs" href="#Description" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Description" aria-hidden="true">TOC</a></span></h2>
+
+<p>The libswscale library performs highly optimized image scaling and
+colorspace and pixel format conversion operations.
+</p>
+<p>Specifically, this library performs the following conversions:
+</p>
+<ul>
+<li> <em>Rescaling</em>: is the process of changing the video size. Several
+rescaling options and algorithms are available. This is usually a
+lossy process.
+
+</li><li> <em>Pixel format conversion</em>: is the process of converting the image
+format and colorspace of the image, for example from planar YUV420P to
+RGB24 packed. It also handles packing conversion, that is converts
+from packed layout (all pixels belonging to distinct planes
+interleaved in the same buffer), to planar layout (all samples
+belonging to the same plane stored in a dedicated buffer or &quot;plane&quot;).
+
+<p>This is usually a lossy process in case the source and destination
+colorspaces differ.
+</p></li></ul>
+
+
+<a name="See-Also"></a>
+<h2 class="chapter">2 See Also<span class="pull-right"><a class="anchor hidden-xs" href="#See-Also" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-See-Also" aria-hidden="true">TOC</a></span></h2>
+
+<p><a href="ffmpeg.html">ffmpeg</a>, <a href="ffplay.html">ffplay</a>, <a href="ffprobe.html">ffprobe</a>,
+<a href="ffmpeg-scaler.html">ffmpeg-scaler</a>,
+<a href="libavutil.html">libavutil</a>
+</p>
+
+<a name="Authors"></a>
+<h2 class="chapter">3 Authors<span class="pull-right"><a class="anchor hidden-xs" href="#Authors" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Authors" aria-hidden="true">TOC</a></span></h2>
+
+<p>The FFmpeg developers.
+</p>
+<p>For details about the authorship, see the Git history of the project
+(git://source.ffmpeg.org/ffmpeg), e.g. by typing the command
+<code>git log</code> in the FFmpeg source directory, or browsing the
+online repository at <a href="http://source.ffmpeg.org">http://source.ffmpeg.org</a>.
+</p>
+<p>Maintainers for the specific components are listed in the file
+<samp>MAINTAINERS</samp> in the source code tree.
+</p>
+
+
+      <p style="font-size: small;">
+        This document was generated using <a href="http://www.gnu.org/software/texinfo/"><em>makeinfo</em></a>.
+      </p>
+    </div>
+  </body>
+</html>

ffmpeg-n4.3.2-win64-gpl-shared-4.3/doc/mailing-list-faq.html

@@ -0,0 +1,449 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
+  <head>
+    <meta charset="utf-8">
+    <title>
+      FFmpeg Mailing List FAQ
+    </title>
+    <meta name="viewport" content="width=device-width,initial-scale=1.0">
+    <link rel="stylesheet" type="text/css" href="bootstrap.min.css">
+    <link rel="stylesheet" type="text/css" href="style.min.css">
+  </head>
+  <body>
+    <div class="container">
+      <h1>
+      FFmpeg Mailing List FAQ
+      </h1>
+<div align="center">
+</div>
+
+
+<a name="SEC_Top"></a>
+
+<span id="SEC_Contents"></span>
+<h2 class="contents-heading">Table of Contents</h2>
+
+<div class="contents">
+
+<ul class="no-bullet">
+  <li><a id="toc-General-Questions" href="#General-Questions">1 General Questions</a>
+  <ul class="no-bullet">
+    <li><a id="toc-What-is-a-mailing-list_003f" href="#What-is-a-mailing-list_003f">1.1 What is a mailing list?</a></li>
+    <li><a id="toc-What-type-of-questions-can-I-ask_003f" href="#What-type-of-questions-can-I-ask_003f">1.2 What type of questions can I ask?</a></li>
+    <li><a id="toc-How-do-I-ask-a-question-or-send-a-message-to-a-mailing-list_003f-1" href="#How-do-I-ask-a-question-or-send-a-message-to-a-mailing-list_003f-1">1.3 How do I ask a question or send a message to a mailing list?</a></li>
+  </ul></li>
+  <li><a id="toc-Subscribing-_002f-Unsubscribing" href="#Subscribing-_002f-Unsubscribing">2 Subscribing / Unsubscribing</a>
+  <ul class="no-bullet">
+    <li><a id="toc-How-do-I-subscribe_003f-1" href="#How-do-I-subscribe_003f-1">2.1 How do I subscribe?</a></li>
+    <li><a id="toc-How-do-I-unsubscribe_003f" href="#How-do-I-unsubscribe_003f">2.2 How do I unsubscribe?</a></li>
+  </ul></li>
+  <li><a id="toc-Moderation-Queue" href="#Moderation-Queue">3 Moderation Queue</a>
+  <ul class="no-bullet">
+    <li><a id="toc-Why-is-my-message-awaiting-moderator-approval_003f-1" href="#Why-is-my-message-awaiting-moderator-approval_003f-1">3.1 Why is my message awaiting moderator approval?</a></li>
+    <li><a id="toc-How-long-does-it-take-for-my-message-in-the-moderation-queue-to-be-approved_003f" href="#How-long-does-it-take-for-my-message-in-the-moderation-queue-to-be-approved_003f">3.2 How long does it take for my message in the moderation queue to be approved?</a></li>
+    <li><a id="toc-How-do-I-delete-my-message-in-the-moderation-queue_003f-1" href="#How-do-I-delete-my-message-in-the-moderation-queue_003f-1">3.3 How do I delete my message in the moderation queue?</a></li>
+  </ul></li>
+  <li><a id="toc-Archives" href="#Archives">4 Archives</a>
+  <ul class="no-bullet">
+    <li><a id="toc-Where-are-the-archives_003f-1" href="#Where-are-the-archives_003f-1">4.1 Where are the archives?</a></li>
+    <li><a id="toc-How-do-I-reply-to-a-message-in-the-archives_003f" href="#How-do-I-reply-to-a-message-in-the-archives_003f">4.2 How do I reply to a message in the archives?</a></li>
+    <li><a id="toc-How-do-I-search-the-archives_003f" href="#How-do-I-search-the-archives_003f">4.3 How do I search the archives?</a></li>
+  </ul></li>
+  <li><a id="toc-Other" href="#Other">5 Other</a>
+  <ul class="no-bullet">
+    <li><a id="toc-Is-there-an-alternative-to-the-mailing-list_003f" href="#Is-there-an-alternative-to-the-mailing-list_003f">5.1 Is there an alternative to the mailing list?</a></li>
+    <li><a id="toc-What-is-top_002dposting_003f-1" href="#What-is-top_002dposting_003f-1">5.2 What is top-posting?</a></li>
+    <li><a id="toc-What-is-the-message-size-limit_003f-1" href="#What-is-the-message-size-limit_003f-1">5.3 What is the message size limit?</a></li>
+    <li><a id="toc-Where-can-I-upload-sample-files_003f" href="#Where-can-I-upload-sample-files_003f">5.4 Where can I upload sample files?</a></li>
+    <li><a id="toc-Will-I-receive-spam-if-I-send-and_002for-subscribe-to-a-mailing-list_003f" href="#Will-I-receive-spam-if-I-send-and_002for-subscribe-to-a-mailing-list_003f">5.5 Will I receive spam if I send and/or subscribe to a mailing list?</a></li>
+    <li><a id="toc-How-do-I-filter-mailing-list-messages_003f" href="#How-do-I-filter-mailing-list-messages_003f">5.6 How do I filter mailing list messages?</a></li>
+    <li><a id="toc-How-do-I-disable-mail-delivery-without-unsubscribing_003f-1" href="#How-do-I-disable-mail-delivery-without-unsubscribing_003f-1">5.7 How do I disable mail delivery without unsubscribing?</a></li>
+    <li><a id="toc-Why-is-the-mailing-list-munging-my-address_003f-1" href="#Why-is-the-mailing-list-munging-my-address_003f-1">5.8 Why is the mailing list munging my address?</a></li>
+  </ul></li>
+  <li><a id="toc-Rules-and-Etiquette" href="#Rules-and-Etiquette">6 Rules and Etiquette</a>
+  <ul class="no-bullet">
+    <li><a id="toc-What-are-the-rules-and-the-proper-etiquette_003f" href="#What-are-the-rules-and-the-proper-etiquette_003f">6.1 What are the rules and the proper etiquette?</a></li>
+  </ul></li>
+  <li><a id="toc-Help" href="#Help">7 Help</a>
+  <ul class="no-bullet">
+    <li><a id="toc-Why-am-I-not-receiving-any-messages_003f" href="#Why-am-I-not-receiving-any-messages_003f">7.1 Why am I not receiving any messages?</a></li>
+    <li><a id="toc-Why-are-my-sent-messages-not-showing-up_003f" href="#Why-are-my-sent-messages-not-showing-up_003f">7.2 Why are my sent messages not showing up?</a></li>
+    <li><a id="toc-Why-do-I-keep-getting-unsubscribed-from-ffmpeg_002ddevel_003f-1" href="#Why-do-I-keep-getting-unsubscribed-from-ffmpeg_002ddevel_003f-1">7.3 Why do I keep getting unsubscribed from ffmpeg-devel?</a></li>
+    <li><a id="toc-Who-do-I-contact-if-I-have-a-problem-with-the-mailing-list_003f-1" href="#Who-do-I-contact-if-I-have-a-problem-with-the-mailing-list_003f-1">7.4 Who do I contact if I have a problem with the mailing list?</a></li>
+  </ul></li>
+</ul>
+</div>
+
+
+<a name="General-Questions"></a>
+<h2 class="chapter">1 General Questions<span class="pull-right"><a class="anchor hidden-xs" href="#General-Questions" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-General-Questions" aria-hidden="true">TOC</a></span></h2>
+
+<a name="What-is-a-mailing-list_003f"></a>
+<h3 class="section">1.1 What is a mailing list?<span class="pull-right"><a class="anchor hidden-xs" href="#What-is-a-mailing-list_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-What-is-a-mailing-list_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>A mailing list is not much different than emailing someone, but the
+main difference is that your message is received by everyone who
+subscribes to the list. It is somewhat like a forum but in email form.
+</p>
+<p>See the <a href="https://lists.ffmpeg.org/pipermail/ffmpeg-user/">ffmpeg-user archives</a>
+for examples.
+</p>
+<a name="What-type-of-questions-can-I-ask_003f"></a>
+<h3 class="section">1.2 What type of questions can I ask?<span class="pull-right"><a class="anchor hidden-xs" href="#What-type-of-questions-can-I-ask_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-What-type-of-questions-can-I-ask_003f" aria-hidden="true">TOC</a></span></h3>
+
+<ul>
+<li> <a href="https://lists.ffmpeg.org/mailman/listinfo/ffmpeg-user/">ffmpeg-user</a>:
+For questions involving unscripted usage or compilation of the FFmpeg
+command-line tools (<code>ffmpeg</code>, <code>ffprobe</code>, <code>ffplay</code>).
+
+</li><li> <a href="https://lists.ffmpeg.org/mailman/listinfo/libav-user/">libav-user</a>:
+For questions involving the FFmpeg libav* libraries (libavcodec,
+libavformat, libavfilter, etc).
+
+</li><li> <a href="https://lists.ffmpeg.org/mailman/listinfo/ffmpeg-devel/">ffmpeg-devel</a>:
+For discussions involving the development of FFmpeg and for submitting
+patches. User questions should be asked at ffmpeg-user or libav-user.
+</li></ul>
+
+<p>To report a bug see <a href="https://ffmpeg.org/bugreports.html">https://ffmpeg.org/bugreports.html</a>.
+</p>
+<p>We cannot provide help for scripts and/or third-party tools.
+</p>
+<span id="How-do-I-ask-a-question-or-send-a-message-to-a-mailing-list_003f"></span><a name="How-do-I-ask-a-question-or-send-a-message-to-a-mailing-list_003f-1"></a>
+<h3 class="section">1.3 How do I ask a question or send a message to a mailing list?<span class="pull-right"><a class="anchor hidden-xs" href="#How-do-I-ask-a-question-or-send-a-message-to-a-mailing-list_003f-1" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-How-do-I-ask-a-question-or-send-a-message-to-a-mailing-list_003f-1" aria-hidden="true">TOC</a></span></h3>
+
+<p>First you must <a href="#How-do-I-subscribe_003f">subscribe</a>. Then all you have to do is
+send an email:
+</p>
+<ul>
+<li> Email <a href="mailto:ffmpeg-user@ffmpeg.org">ffmpeg-user@ffmpeg.org</a> to send a message to the
+ffmpeg-user mailing list.
+
+</li><li> Email <a href="mailto:libav-user@ffmpeg.org">libav-user@ffmpeg.org</a> to send a message to the
+libav-user mailing list.
+
+</li><li> Email <a href="mailto:ffmpeg-devel@ffmpeg.org">ffmpeg-devel@ffmpeg.org</a> to send a message to the
+ffmpeg-devel mailing list.
+</li></ul>
+
+<a name="Subscribing-_002f-Unsubscribing"></a>
+<h2 class="chapter">2 Subscribing / Unsubscribing<span class="pull-right"><a class="anchor hidden-xs" href="#Subscribing-_002f-Unsubscribing" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Subscribing-_002f-Unsubscribing" aria-hidden="true">TOC</a></span></h2>
+
+<span id="How-do-I-subscribe_003f"></span><a name="How-do-I-subscribe_003f-1"></a>
+<h3 class="section">2.1 How do I subscribe?<span class="pull-right"><a class="anchor hidden-xs" href="#How-do-I-subscribe_003f-1" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-How-do-I-subscribe_003f-1" aria-hidden="true">TOC</a></span></h3>
+
+<p>Email <a href="mailto:ffmpeg-user-request@ffmpeg.org">ffmpeg-user-request@ffmpeg.org</a> with the subject
+<em>subscribe</em>.
+</p>
+<p>Or visit the <a href="https://lists.ffmpeg.org/mailman/listinfo/ffmpeg-user/">ffmpeg-user mailing list info page</a>
+and refer to the <em>Subscribing to ffmpeg-user</em> section.
+</p>
+<p>The process is the same for the other mailing lists.
+</p>
+<a name="How-do-I-unsubscribe_003f"></a>
+<h3 class="section">2.2 How do I unsubscribe?<span class="pull-right"><a class="anchor hidden-xs" href="#How-do-I-unsubscribe_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-How-do-I-unsubscribe_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>Email <a href="mailto:ffmpeg-user-request@ffmpeg.org">ffmpeg-user-request@ffmpeg.org</a> with subject <em>unsubscribe</em>.
+</p>
+<p>Or visit the <a href="https://lists.ffmpeg.org/mailman/listinfo/ffmpeg-user/">ffmpeg-user mailing list info page</a>,
+scroll to bottom of page, enter your email address in the box, and click
+the <em>Unsubscribe or edit options</em> button.
+</p>
+<p>The process is the same for the other mailing lists.
+</p>
+<p>Please avoid asking a mailing list admin to unsubscribe you unless you
+are absolutely unable to do so by yourself. See <a href="#Who-do-I-contact-if-I-have-a-problem-with-the-mailing-list_003f">Who do I contact if I have a problem with the mailing list?</a>
+</p>
+<p>Note that it is possible to temporarily halt message delivery (vacation mode).
+See <a href="#How-do-I-disable-mail-delivery-without-unsubscribing_003f">How do I disable mail delivery without unsubscribing?</a>
+</p>
+<a name="Moderation-Queue"></a>
+<h2 class="chapter">3 Moderation Queue<span class="pull-right"><a class="anchor hidden-xs" href="#Moderation-Queue" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Moderation-Queue" aria-hidden="true">TOC</a></span></h2>
+<span id="Why-is-my-message-awaiting-moderator-approval_003f"></span><a name="Why-is-my-message-awaiting-moderator-approval_003f-1"></a>
+<h3 class="section">3.1 Why is my message awaiting moderator approval?<span class="pull-right"><a class="anchor hidden-xs" href="#Why-is-my-message-awaiting-moderator-approval_003f-1" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Why-is-my-message-awaiting-moderator-approval_003f-1" aria-hidden="true">TOC</a></span></h3>
+
+<p>Some messages are automatically held in the <em>moderation queue</em> and
+must be manually approved by a mailing list admin:
+</p>
+<p>These are:
+</p>
+<ul>
+<li> Messages that exceed the <a href="#What-is-the-message-size-limit_003f">message size limit</a>.
+
+</li><li> Messages from users whose accounts have been set with the <em>moderation flag</em>
+(very rarely occurs, but may if a user repeatedly ignores the rules
+or is abusive towards others).
+</li></ul>
+
+<a name="How-long-does-it-take-for-my-message-in-the-moderation-queue-to-be-approved_003f"></a>
+<h3 class="section">3.2 How long does it take for my message in the moderation queue to be approved?<span class="pull-right"><a class="anchor hidden-xs" href="#How-long-does-it-take-for-my-message-in-the-moderation-queue-to-be-approved_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-How-long-does-it-take-for-my-message-in-the-moderation-queue-to-be-approved_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>The queue is not checked on a regular basis. You can ask on the
+<tt>#ffmpeg-devel</tt> IRC channel on Freenode for someone to approve your message.
+</p>
+<span id="How-do-I-delete-my-message-in-the-moderation-queue_003f"></span><a name="How-do-I-delete-my-message-in-the-moderation-queue_003f-1"></a>
+<h3 class="section">3.3 How do I delete my message in the moderation queue?<span class="pull-right"><a class="anchor hidden-xs" href="#How-do-I-delete-my-message-in-the-moderation-queue_003f-1" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-How-do-I-delete-my-message-in-the-moderation-queue_003f-1" aria-hidden="true">TOC</a></span></h3>
+
+<p>You should have received an email with the subject <em>Your message to &lt;mailing list name&gt; awaits moderator approval</em>.
+A link is in the message that will allow you to delete your message
+unless a mailing list admin already approved or rejected it.
+</p>
+<a name="Archives"></a>
+<h2 class="chapter">4 Archives<span class="pull-right"><a class="anchor hidden-xs" href="#Archives" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Archives" aria-hidden="true">TOC</a></span></h2>
+
+<span id="Where-are-the-archives_003f"></span><a name="Where-are-the-archives_003f-1"></a>
+<h3 class="section">4.1 Where are the archives?<span class="pull-right"><a class="anchor hidden-xs" href="#Where-are-the-archives_003f-1" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Where-are-the-archives_003f-1" aria-hidden="true">TOC</a></span></h3>
+
+<p>See the <em>Archives</em> section on the <a href="https://ffmpeg.org/contact.html">FFmpeg Contact</a>
+page for links to all FFmpeg mailing list archives.
+</p>
+<p>Note that the archives are split by month. Discussions that span
+several months will be split into separate months in the archives.
+</p>
+<a name="How-do-I-reply-to-a-message-in-the-archives_003f"></a>
+<h3 class="section">4.2 How do I reply to a message in the archives?<span class="pull-right"><a class="anchor hidden-xs" href="#How-do-I-reply-to-a-message-in-the-archives_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-How-do-I-reply-to-a-message-in-the-archives_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>Click the email link at the top of the message just under the subject
+title. The link will provide the proper headers to keep the message
+within the thread.
+</p>
+<p>Note that you must be subscribed to send a message to the ffmpeg-user or
+libav-user mailing lists.
+</p>
+<a name="How-do-I-search-the-archives_003f"></a>
+<h3 class="section">4.3 How do I search the archives?<span class="pull-right"><a class="anchor hidden-xs" href="#How-do-I-search-the-archives_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-How-do-I-search-the-archives_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>Perform a site search using your favorite search engine. Example:
+</p>
+<p><tt>site:lists.ffmpeg.org/pipermail/ffmpeg-user/ &quot;search term&quot;</tt>
+</p>
+<a name="Other"></a>
+<h2 class="chapter">5 Other<span class="pull-right"><a class="anchor hidden-xs" href="#Other" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Other" aria-hidden="true">TOC</a></span></h2>
+
+<a name="Is-there-an-alternative-to-the-mailing-list_003f"></a>
+<h3 class="section">5.1 Is there an alternative to the mailing list?<span class="pull-right"><a class="anchor hidden-xs" href="#Is-there-an-alternative-to-the-mailing-list_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Is-there-an-alternative-to-the-mailing-list_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>You can ask for help in the official <tt>#ffmpeg</tt> IRC channel on Freenode.
+</p>
+<p>Some users prefer the third-party <a href="http://www.ffmpeg-archive.org/">Nabble</a>
+interface which presents the mailing lists in a typical forum layout.
+</p>
+<p>There are also numerous third-party help sites such as
+<a href="https://superuser.com/tags/ffmpeg">Super User</a> and
+<a href="https://www.reddit.com/r/ffmpeg/">r/ffmpeg on reddit</a>.
+</p>
+<span id="What-is-top_002dposting_003f"></span><a name="What-is-top_002dposting_003f-1"></a>
+<h3 class="section">5.2 What is top-posting?<span class="pull-right"><a class="anchor hidden-xs" href="#What-is-top_002dposting_003f-1" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-What-is-top_002dposting_003f-1" aria-hidden="true">TOC</a></span></h3>
+
+<p>See <a href="https://en.wikipedia.org/wiki/Posting_style#Top-posting">https://en.wikipedia.org/wiki/Posting_style#Top-posting</a>.
+</p>
+<p>Instead, use trimmed interleaved/inline replies (<a href="https://lists.ffmpeg.org/pipermail/ffmpeg-user/2017-April/035849.html">example</a>).
+</p>
+<span id="What-is-the-message-size-limit_003f"></span><a name="What-is-the-message-size-limit_003f-1"></a>
+<h3 class="section">5.3 What is the message size limit?<span class="pull-right"><a class="anchor hidden-xs" href="#What-is-the-message-size-limit_003f-1" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-What-is-the-message-size-limit_003f-1" aria-hidden="true">TOC</a></span></h3>
+
+<p>The message size limit is 1000 kilobytes. Please provide links to larger files
+instead of attaching them.
+</p>
+<a name="Where-can-I-upload-sample-files_003f"></a>
+<h3 class="section">5.4 Where can I upload sample files?<span class="pull-right"><a class="anchor hidden-xs" href="#Where-can-I-upload-sample-files_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Where-can-I-upload-sample-files_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>Anywhere that is not too annoying for us to use.
+</p>
+<p>Google Drive and Dropbox are acceptable if you need a file host, and
+<a href="https://0x0.st/">0x0.st</a> is good for files under 256 MiB.
+</p>
+<p>Small, short samples are preferred if possible.
+</p>
+<a name="Will-I-receive-spam-if-I-send-and_002for-subscribe-to-a-mailing-list_003f"></a>
+<h3 class="section">5.5 Will I receive spam if I send and/or subscribe to a mailing list?<span class="pull-right"><a class="anchor hidden-xs" href="#Will-I-receive-spam-if-I-send-and_002for-subscribe-to-a-mailing-list_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Will-I-receive-spam-if-I-send-and_002for-subscribe-to-a-mailing-list_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>Highly unlikely.
+</p>
+<ul>
+<li> The list of subscribed users is not public.
+
+</li><li> Email addresses in the archives are obfuscated.
+
+</li><li> Several unique test email accounts were utilized and none have yet
+received any spam.
+</li></ul>
+
+<p>However, you may see a spam in the mailing lists on rare occasions:
+</p>
+<ul>
+<li> Spam in the moderation queue may be accidentally approved due to human
+error.
+
+</li><li> There have been a few messages from subscribed users who had their own
+email addresses hacked and spam messages from (or appearing to be from)
+the hacked account were sent to their contacts (a mailing list being a
+contact in these cases).
+
+</li><li> If you are subscribed to the bug tracker mailing list (ffmpeg-trac) you
+may see the occasional spam as a false bug report, but we take measures
+to try to prevent this.
+</li></ul>
+
+<a name="How-do-I-filter-mailing-list-messages_003f"></a>
+<h3 class="section">5.6 How do I filter mailing list messages?<span class="pull-right"><a class="anchor hidden-xs" href="#How-do-I-filter-mailing-list-messages_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-How-do-I-filter-mailing-list-messages_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>Use the <em>List-Id</em>. For example, the ffmpeg-user mailing list is
+<tt>ffmpeg-user.ffmpeg.org</tt>. You can view the List-Id in the raw message
+or headers.
+</p>
+<p>You can then filter the mailing list messages to their own folder.
+</p>
+<span id="How-do-I-disable-mail-delivery-without-unsubscribing_003f"></span><a name="How-do-I-disable-mail-delivery-without-unsubscribing_003f-1"></a>
+<h3 class="section">5.7 How do I disable mail delivery without unsubscribing?<span class="pull-right"><a class="anchor hidden-xs" href="#How-do-I-disable-mail-delivery-without-unsubscribing_003f-1" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-How-do-I-disable-mail-delivery-without-unsubscribing_003f-1" aria-hidden="true">TOC</a></span></h3>
+
+<p>Sometimes you may want to temporarily stop receiving all mailing list
+messages. This &quot;vacation mode&quot; is simple to do:
+</p>
+<ol>
+<li> Go to the <a href="https://lists.ffmpeg.org/mailman/listinfo/ffmpeg-user/">ffmpeg-user mailing list info page</a>
+
+</li><li> Enter your email address in the box at very bottom of the page and click the
+<em>Unsubscribe or edit options</em> box.
+
+</li><li> Enter your password and click the <em>Log in</em> button.
+
+</li><li> Look for the <em>Mail delivery</em> option. Here you can disable/enable mail
+delivery. If you check <em>Set globally</em> it will apply your choice to all
+other FFmpeg mailing lists you are subscribed to.
+</li></ol>
+
+<p>Alternatively, from your subscribed address, send a message to <a href="mailto:ffmpeg-user-request@ffmpeg.org">ffmpeg-user-request@ffmpeg.org</a>
+with the subject <em>set delivery off</em>. To re-enable mail delivery send a
+message to <a href="mailto:ffmpeg-user-request@ffmpeg.org">ffmpeg-user-request@ffmpeg.org</a> with the subject
+<em>set delivery on</em>.
+</p>
+<span id="Why-is-the-mailing-list-munging-my-address_003f"></span><a name="Why-is-the-mailing-list-munging-my-address_003f-1"></a>
+<h3 class="section">5.8 Why is the mailing list munging my address?<span class="pull-right"><a class="anchor hidden-xs" href="#Why-is-the-mailing-list-munging-my-address_003f-1" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Why-is-the-mailing-list-munging-my-address_003f-1" aria-hidden="true">TOC</a></span></h3>
+
+<p>This is due to subscribers that use an email service with a DMARC reject policy
+which adds difficulties to mailing list operators.
+</p>
+<p>The mailing list must re-write (munge) the <em>From:</em> header for such users;
+otherwise their email service will reject and bounce the message resulting in
+automatic unsubscribing from the mailing list.
+</p>
+<p>When sending a message these users will see <em>via &lt;mailing list name&gt;</em>
+added to their name and the <em>From:</em> address munged to the address of
+the particular mailing list.
+</p>
+<p>If you want to avoid this then please use a different email service.
+</p>
+<p>Note that ffmpeg-devel does not apply any munging as it causes issues with
+patch authorship. As a result users with an email service with a DMARC reject
+policy may be automatically unsubscribed due to rejected and bounced messages.
+</p>
+<a name="Rules-and-Etiquette"></a>
+<h2 class="chapter">6 Rules and Etiquette<span class="pull-right"><a class="anchor hidden-xs" href="#Rules-and-Etiquette" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Rules-and-Etiquette" aria-hidden="true">TOC</a></span></h2>
+
+<a name="What-are-the-rules-and-the-proper-etiquette_003f"></a>
+<h3 class="section">6.1 What are the rules and the proper etiquette?<span class="pull-right"><a class="anchor hidden-xs" href="#What-are-the-rules-and-the-proper-etiquette_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-What-are-the-rules-and-the-proper-etiquette_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>There may seem to be many things to remember, but we want to help and
+following these guidelines will allow you to get answers more quickly
+and help avoid getting ignored.
+</p>
+<ul>
+<li> Always show your actual, unscripted <code>ffmpeg</code> command and the
+complete, uncut console output from your command.
+
+</li><li> Use the most simple and minimal command that still shows the issue you
+are encountering.
+
+</li><li> Provide all necessary information so others can attempt to duplicate
+your issue. This includes the actual command, complete uncut console
+output, and any inputs that are required to duplicate the issue.
+
+</li><li> Use the latest <code>ffmpeg</code> build you can get. See the <a href="https://ffmpeg.org/download.html">FFmpeg Download</a>
+page for links to recent builds for Linux, macOS, and Windows. Or
+compile from the current git master branch.
+
+</li><li> Avoid <a href="https://en.wikipedia.org/wiki/Posting_style#Top-posting">top-posting</a>.
+Also see <a href="#What-is-top_002dposting_003f">What is top-posting?</a>
+
+</li><li> Avoid hijacking threads. Thread hijacking is replying to a message and
+changing the subject line to something unrelated to the original thread.
+Most email clients will still show the renamed message under the
+original thread. This can be confusing and these types of messages are
+often ignored.
+
+</li><li> Do not send screenshots. Copy and paste console text instead of making
+screenshots of the text.
+
+</li><li> Avoid sending email disclaimers and legalese if possible as this is a
+public list.
+
+</li><li> Avoid using the <code>-loglevel debug</code>, <code>-loglevel quiet</code>, and
+<code>-hide_banner</code> options unless requested to do so.
+
+</li><li> If you attach files avoid compressing small files. Uncompressed is
+preferred.
+
+</li><li> Please do not send HTML-only messages. The mailing list will ignore the
+HTML component of your message. Most mail clients will automatically
+include a text component: this is what the mailing list will use.
+
+</li><li> Configuring your mail client to break lines after 70 or so characters is
+recommended.
+
+</li><li> Avoid sending the same message to multiple mailing lists.
+
+</li><li> Please follow our <a href="https://ffmpeg.org/developer.html#Code-of-conduct">Code of Conduct</a>.
+</li></ul>
+
+<a name="Help"></a>
+<h2 class="chapter">7 Help<span class="pull-right"><a class="anchor hidden-xs" href="#Help" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Help" aria-hidden="true">TOC</a></span></h2>
+
+<a name="Why-am-I-not-receiving-any-messages_003f"></a>
+<h3 class="section">7.1 Why am I not receiving any messages?<span class="pull-right"><a class="anchor hidden-xs" href="#Why-am-I-not-receiving-any-messages_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Why-am-I-not-receiving-any-messages_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>Some email providers have blacklists or spam filters that block or mark
+the mailing list messages as false positives. Unfortunately, the user is
+often not aware of this and is often out of their control.
+</p>
+<p>When possible we attempt to notify the provider to be removed from the
+blacklists or filters.
+</p>
+<a name="Why-are-my-sent-messages-not-showing-up_003f"></a>
+<h3 class="section">7.2 Why are my sent messages not showing up?<span class="pull-right"><a class="anchor hidden-xs" href="#Why-are-my-sent-messages-not-showing-up_003f" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Why-are-my-sent-messages-not-showing-up_003f" aria-hidden="true">TOC</a></span></h3>
+
+<p>Excluding <a href="#Why-is-my-message-awaiting-moderator-approval_003f">messages that are held in the moderation queue</a>
+there are a few other reasons why your messages may fail to appear:
+</p>
+<ul>
+<li> HTML-only messages are ignored by the mailing lists. Most mail clients
+automatically include a text component alongside HTML email: this is what
+the mailing list will use. If it does not then consider your client to be
+broken, because sending a text component along with the HTML component to
+form a multi-part message is recommended by email standards.
+
+</li><li> Check your spam folder.
+</li></ul>
+
+<span id="Why-do-I-keep-getting-unsubscribed-from-ffmpeg_002ddevel_003f"></span><a name="Why-do-I-keep-getting-unsubscribed-from-ffmpeg_002ddevel_003f-1"></a>
+<h3 class="section">7.3 Why do I keep getting unsubscribed from ffmpeg-devel?<span class="pull-right"><a class="anchor hidden-xs" href="#Why-do-I-keep-getting-unsubscribed-from-ffmpeg_002ddevel_003f-1" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Why-do-I-keep-getting-unsubscribed-from-ffmpeg_002ddevel_003f-1" aria-hidden="true">TOC</a></span></h3>
+
+<p>Users with an email service that has a DMARC reject or quarantine policy may be
+automatically unsubscribed from the ffmpeg-devel mailing list due to the mailing
+list messages being continuously rejected and bounced back.
+</p>
+<p>Consider using a different email service.
+</p>
+<span id="Who-do-I-contact-if-I-have-a-problem-with-the-mailing-list_003f"></span><a name="Who-do-I-contact-if-I-have-a-problem-with-the-mailing-list_003f-1"></a>
+<h3 class="section">7.4 Who do I contact if I have a problem with the mailing list?<span class="pull-right"><a class="anchor hidden-xs" href="#Who-do-I-contact-if-I-have-a-problem-with-the-mailing-list_003f-1" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Who-do-I-contact-if-I-have-a-problem-with-the-mailing-list_003f-1" aria-hidden="true">TOC</a></span></h3>
+
+<p>Send a message to <a href="mailto:ffmpeg-user-owner@ffmpeg.org">ffmpeg-user-owner@ffmpeg.org</a>.
+</p>
+
+      <p style="font-size: small;">
+        This document was generated using <a href="http://www.gnu.org/software/texinfo/"><em>makeinfo</em></a>.
+      </p>
+    </div>
+  </body>
+</html>

ffmpeg-n4.3.2-win64-gpl-shared-4.3/doc/nut.html

@@ -0,0 +1,212 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
+  <head>
+    <meta charset="utf-8">
+    <title>
+      NUT
+    </title>
+    <meta name="viewport" content="width=device-width,initial-scale=1.0">
+    <link rel="stylesheet" type="text/css" href="bootstrap.min.css">
+    <link rel="stylesheet" type="text/css" href="style.min.css">
+  </head>
+  <body>
+    <div class="container">
+      <h1>
+      NUT
+      </h1>
+<div align="center">
+</div>
+
+
+
+<a name="SEC_Top"></a>
+
+<span id="SEC_Contents"></span>
+<h2 class="contents-heading">Table of Contents</h2>
+
+<div class="contents">
+
+<ul class="no-bullet">
+  <li><a id="toc-Description" href="#Description">1 Description</a></li>
+  <li><a id="toc-Modes" href="#Modes">2 Modes</a>
+  <ul class="no-bullet">
+    <li><a id="toc-BROADCAST" href="#BROADCAST">2.1 BROADCAST</a></li>
+    <li><a id="toc-PIPE" href="#PIPE">2.2 PIPE</a></li>
+  </ul></li>
+  <li><a id="toc-Container_002dspecific-codec-tags" href="#Container_002dspecific-codec-tags">3 Container-specific codec tags</a>
+  <ul class="no-bullet">
+    <li><a id="toc-Generic-raw-YUVA-formats" href="#Generic-raw-YUVA-formats">3.1 Generic raw YUVA formats</a></li>
+    <li><a id="toc-Raw-Audio" href="#Raw-Audio">3.2 Raw Audio</a></li>
+    <li><a id="toc-Subtitles" href="#Subtitles">3.3 Subtitles</a></li>
+    <li><a id="toc-Raw-Data" href="#Raw-Data">3.4 Raw Data</a></li>
+    <li><a id="toc-Codecs" href="#Codecs">3.5 Codecs</a></li>
+  </ul></li>
+</ul>
+</div>
+
+
+<a name="Description"></a>
+<h2 class="chapter">1 Description<span class="pull-right"><a class="anchor hidden-xs" href="#Description" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Description" aria-hidden="true">TOC</a></span></h2>
+<p>NUT is a low overhead generic container format. It stores audio, video,
+subtitle and user-defined streams in a simple, yet efficient, way.
+</p>
+<p>It was created by a group of FFmpeg and MPlayer developers in 2003
+and was finalized in 2008.
+</p>
+<p>The official nut specification is at svn://svn.mplayerhq.hu/nut
+In case of any differences between this text and the official specification,
+the official specification shall prevail.
+</p>
+<a name="Modes"></a>
+<h2 class="chapter">2 Modes<span class="pull-right"><a class="anchor hidden-xs" href="#Modes" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Modes" aria-hidden="true">TOC</a></span></h2>
+<p>NUT has some variants signaled by using the flags field in its main header.
+</p>
+<table>
+<tr><td width="40%">BROADCAST</td><td width="40%">Extend the syncpoint to report the sender wallclock</td></tr>
+<tr><td width="40%">PIPE</td><td width="40%">Omit completely the syncpoint</td></tr>
+</table>
+
+<a name="BROADCAST"></a>
+<h3 class="section">2.1 BROADCAST<span class="pull-right"><a class="anchor hidden-xs" href="#BROADCAST" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-BROADCAST" aria-hidden="true">TOC</a></span></h3>
+
+<p>The BROADCAST variant provides a secondary time reference to facilitate
+detecting endpoint latency and network delays.
+It assumes all the endpoint clocks are synchronized.
+To be used in real-time scenarios.
+</p>
+<a name="PIPE"></a>
+<h3 class="section">2.2 PIPE<span class="pull-right"><a class="anchor hidden-xs" href="#PIPE" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-PIPE" aria-hidden="true">TOC</a></span></h3>
+
+<p>The PIPE variant assumes NUT is used as non-seekable intermediate container,
+by not using syncpoint removes unneeded overhead and reduces the overall
+memory usage.
+</p>
+<a name="Container_002dspecific-codec-tags"></a>
+<h2 class="chapter">3 Container-specific codec tags<span class="pull-right"><a class="anchor hidden-xs" href="#Container_002dspecific-codec-tags" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Container_002dspecific-codec-tags" aria-hidden="true">TOC</a></span></h2>
+
+<a name="Generic-raw-YUVA-formats"></a>
+<h3 class="section">3.1 Generic raw YUVA formats<span class="pull-right"><a class="anchor hidden-xs" href="#Generic-raw-YUVA-formats" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Generic-raw-YUVA-formats" aria-hidden="true">TOC</a></span></h3>
+
+<p>Since many exotic planar YUVA pixel formats are not considered by
+the AVI/QuickTime FourCC lists, the following scheme is adopted for
+representing them.
+</p>
+<p>The first two bytes can contain the values:
+Y1 = only Y
+Y2 = Y+A
+Y3 = YUV
+Y4 = YUVA
+</p>
+<p>The third byte represents the width and height chroma subsampling
+values for the UV planes, that is the amount to shift the luma
+width/height right to find the chroma width/height.
+</p>
+<p>The fourth byte is the number of bits used (8, 16, ...).
+</p>
+<p>If the order of bytes is inverted, that means that each component has
+to be read big-endian.
+</p>
+<a name="Raw-Audio"></a>
+<h3 class="section">3.2 Raw Audio<span class="pull-right"><a class="anchor hidden-xs" href="#Raw-Audio" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Raw-Audio" aria-hidden="true">TOC</a></span></h3>
+
+<table>
+<tr><td width="40%">ALAW</td><td width="40%">A-LAW</td></tr>
+<tr><td width="40%">ULAW</td><td width="40%">MU-LAW</td></tr>
+<tr><td width="40%">P&lt;type&gt;&lt;interleaving&gt;&lt;bits&gt;</td><td width="40%">little-endian PCM</td></tr>
+<tr><td width="40%">&lt;bits&gt;&lt;interleaving&gt;&lt;type&gt;P</td><td width="40%">big-endian PCM</td></tr>
+</table>
+
+<p>&lt;type&gt; is S for signed integer, U for unsigned integer, F for IEEE float
+&lt;interleaving&gt; is D for default, P is for planar.
+&lt;bits&gt; is 8/16/24/32
+</p>
+<div class="example">
+<pre class="example">PFD[32]   would for example be signed 32 bit little-endian IEEE float
+</pre></div>
+
+<a name="Subtitles"></a>
+<h3 class="section">3.3 Subtitles<span class="pull-right"><a class="anchor hidden-xs" href="#Subtitles" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Subtitles" aria-hidden="true">TOC</a></span></h3>
+
+<table>
+<tr><td width="40%">UTF8</td><td width="40%">Raw UTF-8</td></tr>
+<tr><td width="40%">SSA[0]</td><td width="40%">SubStation Alpha</td></tr>
+<tr><td width="40%">DVDS</td><td width="40%">DVD subtitles</td></tr>
+<tr><td width="40%">DVBS</td><td width="40%">DVB subtitles</td></tr>
+</table>
+
+<a name="Raw-Data"></a>
+<h3 class="section">3.4 Raw Data<span class="pull-right"><a class="anchor hidden-xs" href="#Raw-Data" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Raw-Data" aria-hidden="true">TOC</a></span></h3>
+
+<table>
+<tr><td width="40%">UTF8</td><td width="40%">Raw UTF-8</td></tr>
+</table>
+
+<a name="Codecs"></a>
+<h3 class="section">3.5 Codecs<span class="pull-right"><a class="anchor hidden-xs" href="#Codecs" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Codecs" aria-hidden="true">TOC</a></span></h3>
+
+<table>
+<tr><td width="40%">3IV1</td><td width="40%">non-compliant MPEG-4 generated by old 3ivx</td></tr>
+<tr><td width="40%">ASV1</td><td width="40%">Asus Video</td></tr>
+<tr><td width="40%">ASV2</td><td width="40%">Asus Video 2</td></tr>
+<tr><td width="40%">CVID</td><td width="40%">Cinepak</td></tr>
+<tr><td width="40%">CYUV</td><td width="40%">Creative YUV</td></tr>
+<tr><td width="40%">DIVX</td><td width="40%">non-compliant MPEG-4 generated by old DivX</td></tr>
+<tr><td width="40%">DUCK</td><td width="40%">Truemotion 1</td></tr>
+<tr><td width="40%">FFV1</td><td width="40%">FFmpeg video 1</td></tr>
+<tr><td width="40%">FFVH</td><td width="40%">FFmpeg Huffyuv</td></tr>
+<tr><td width="40%">H261</td><td width="40%">ITU H.261</td></tr>
+<tr><td width="40%">H262</td><td width="40%">ITU H.262</td></tr>
+<tr><td width="40%">H263</td><td width="40%">ITU H.263</td></tr>
+<tr><td width="40%">H264</td><td width="40%">ITU H.264</td></tr>
+<tr><td width="40%">HFYU</td><td width="40%">Huffyuv</td></tr>
+<tr><td width="40%">I263</td><td width="40%">Intel H.263</td></tr>
+<tr><td width="40%">IV31</td><td width="40%">Indeo 3.1</td></tr>
+<tr><td width="40%">IV32</td><td width="40%">Indeo 3.2</td></tr>
+<tr><td width="40%">IV50</td><td width="40%">Indeo 5.0</td></tr>
+<tr><td width="40%">LJPG</td><td width="40%">ITU JPEG (lossless)</td></tr>
+<tr><td width="40%">MJLS</td><td width="40%">ITU JPEG-LS</td></tr>
+<tr><td width="40%">MJPG</td><td width="40%">ITU JPEG</td></tr>
+<tr><td width="40%">MPG4</td><td width="40%">MS MPEG-4v1 (not ISO MPEG-4)</td></tr>
+<tr><td width="40%">MP42</td><td width="40%">MS MPEG-4v2</td></tr>
+<tr><td width="40%">MP43</td><td width="40%">MS MPEG-4v3</td></tr>
+<tr><td width="40%">MP4V</td><td width="40%">ISO MPEG-4 Part 2 Video (from old encoders)</td></tr>
+<tr><td width="40%">mpg1</td><td width="40%">ISO MPEG-1 Video</td></tr>
+<tr><td width="40%">mpg2</td><td width="40%">ISO MPEG-2 Video</td></tr>
+<tr><td width="40%">MRLE</td><td width="40%">MS RLE</td></tr>
+<tr><td width="40%">MSVC</td><td width="40%">MS Video 1</td></tr>
+<tr><td width="40%">RT21</td><td width="40%">Indeo 2.1</td></tr>
+<tr><td width="40%">RV10</td><td width="40%">RealVideo 1.0</td></tr>
+<tr><td width="40%">RV20</td><td width="40%">RealVideo 2.0</td></tr>
+<tr><td width="40%">RV30</td><td width="40%">RealVideo 3.0</td></tr>
+<tr><td width="40%">RV40</td><td width="40%">RealVideo 4.0</td></tr>
+<tr><td width="40%">SNOW</td><td width="40%">FFmpeg Snow</td></tr>
+<tr><td width="40%">SVQ1</td><td width="40%">Sorenson Video 1</td></tr>
+<tr><td width="40%">SVQ3</td><td width="40%">Sorenson Video 3</td></tr>
+<tr><td width="40%">theo</td><td width="40%">Xiph Theora</td></tr>
+<tr><td width="40%">TM20</td><td width="40%">Truemotion 2.0</td></tr>
+<tr><td width="40%">UMP4</td><td width="40%">non-compliant MPEG-4 generated by UB Video MPEG-4</td></tr>
+<tr><td width="40%">VCR1</td><td width="40%">ATI VCR1</td></tr>
+<tr><td width="40%">VP30</td><td width="40%">VP 3.0</td></tr>
+<tr><td width="40%">VP31</td><td width="40%">VP 3.1</td></tr>
+<tr><td width="40%">VP50</td><td width="40%">VP 5.0</td></tr>
+<tr><td width="40%">VP60</td><td width="40%">VP 6.0</td></tr>
+<tr><td width="40%">VP61</td><td width="40%">VP 6.1</td></tr>
+<tr><td width="40%">VP62</td><td width="40%">VP 6.2</td></tr>
+<tr><td width="40%">VP70</td><td width="40%">VP 7.0</td></tr>
+<tr><td width="40%">WMV1</td><td width="40%">MS WMV7</td></tr>
+<tr><td width="40%">WMV2</td><td width="40%">MS WMV8</td></tr>
+<tr><td width="40%">WMV3</td><td width="40%">MS WMV9</td></tr>
+<tr><td width="40%">WV1F</td><td width="40%">non-compliant MPEG-4 generated by ?</td></tr>
+<tr><td width="40%">WVC1</td><td width="40%">VC-1</td></tr>
+<tr><td width="40%">XVID</td><td width="40%">non-compliant MPEG-4 generated by old Xvid</td></tr>
+<tr><td width="40%">XVIX</td><td width="40%">non-compliant MPEG-4 generated by old Xvid with interlacing bug</td></tr>
+</table>
+
+
+      <p style="font-size: small;">
+        This document was generated using <a href="http://www.gnu.org/software/texinfo/"><em>makeinfo</em></a>.
+      </p>
+    </div>
+  </body>
+</html>

ffmpeg-n4.3.2-win64-gpl-shared-4.3/doc/platform.html

@@ -0,0 +1,396 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<!-- Created by GNU Texinfo 6.7, http://www.gnu.org/software/texinfo/ -->
+  <head>
+    <meta charset="utf-8">
+    <title>
+      Platform Specific Information
+    </title>
+    <meta name="viewport" content="width=device-width,initial-scale=1.0">
+    <link rel="stylesheet" type="text/css" href="bootstrap.min.css">
+    <link rel="stylesheet" type="text/css" href="style.min.css">
+  </head>
+  <body>
+    <div class="container">
+      <h1>
+      Platform Specific Information
+      </h1>
+<div align="center">
+</div>
+
+
+<a name="SEC_Top"></a>
+
+<span id="SEC_Contents"></span>
+<h2 class="contents-heading">Table of Contents</h2>
+
+<div class="contents">
+
+<ul class="no-bullet">
+  <li><a id="toc-Unix_002dlike" href="#Unix_002dlike">1 Unix-like</a>
+  <ul class="no-bullet">
+    <li><a id="toc-Advanced-linking-configuration" href="#Advanced-linking-configuration">1.1 Advanced linking configuration</a></li>
+    <li><a id="toc-BSD" href="#BSD">1.2 BSD</a></li>
+    <li><a id="toc-_0028Open_0029Solaris" href="#g_t_0028Open_0029Solaris">1.3 (Open)Solaris</a></li>
+    <li><a id="toc-Darwin-_0028Mac-OS-X_002c-iPhone_0029" href="#Darwin-_0028Mac-OS-X_002c-iPhone_0029">1.4 Darwin (Mac OS X, iPhone)</a></li>
+  </ul></li>
+  <li><a id="toc-DOS" href="#DOS">2 DOS</a></li>
+  <li><a id="toc-OS_002f2" href="#OS_002f2">3 OS/2</a></li>
+  <li><a id="toc-Windows" href="#Windows">4 Windows</a>
+  <ul class="no-bullet">
+    <li><a id="toc-Native-Windows-compilation-using-MinGW-or-MinGW_002dw64" href="#Native-Windows-compilation-using-MinGW-or-MinGW_002dw64">4.1 Native Windows compilation using MinGW or MinGW-w64</a>
+    <ul class="no-bullet">
+      <li><a id="toc-Native-Windows-compilation-using-MSYS2" href="#Native-Windows-compilation-using-MSYS2">4.1.1 Native Windows compilation using MSYS2</a></li>
+    </ul></li>
+    <li><a id="toc-Microsoft-Visual-C_002b_002b-or-Intel-C_002b_002b-Compiler-for-Windows" href="#Microsoft-Visual-C_002b_002b-or-Intel-C_002b_002b-Compiler-for-Windows">4.2 Microsoft Visual C++ or Intel C++ Compiler for Windows</a>
+    <ul class="no-bullet">
+      <li><a id="toc-Linking-to-FFmpeg-with-Microsoft-Visual-C_002b_002b" href="#Linking-to-FFmpeg-with-Microsoft-Visual-C_002b_002b">4.2.1 Linking to FFmpeg with Microsoft Visual C++</a></li>
+    </ul></li>
+    <li><a id="toc-Cross-compilation-for-Windows-with-Linux-1" href="#Cross-compilation-for-Windows-with-Linux-1">4.3 Cross compilation for Windows with Linux</a></li>
+    <li><a id="toc-Compilation-under-Cygwin" href="#Compilation-under-Cygwin">4.4 Compilation under Cygwin</a></li>
+    <li><a id="toc-Crosscompilation-for-Windows-under-Cygwin" href="#Crosscompilation-for-Windows-under-Cygwin">4.5 Crosscompilation for Windows under Cygwin</a></li>
+  </ul></li>
+</ul>
+</div>
+
+
+<a name="Unix_002dlike"></a>
+<h2 class="chapter">1 Unix-like<span class="pull-right"><a class="anchor hidden-xs" href="#Unix_002dlike" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Unix_002dlike" aria-hidden="true">TOC</a></span></h2>
+
+<p>Some parts of FFmpeg cannot be built with version 2.15 of the GNU
+assembler which is still provided by a few AMD64 distributions. To
+make sure your compiler really uses the required version of gas
+after a binutils upgrade, run:
+</p>
+<div class="example">
+<pre class="example">$(gcc -print-prog-name=as) --version
+</pre></div>
+
+<p>If not, then you should install a different compiler that has no
+hard-coded path to gas. In the worst case pass <code>--disable-asm</code>
+to configure.
+</p>
+<a name="Advanced-linking-configuration"></a>
+<h3 class="section">1.1 Advanced linking configuration<span class="pull-right"><a class="anchor hidden-xs" href="#Advanced-linking-configuration" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Advanced-linking-configuration" aria-hidden="true">TOC</a></span></h3>
+
+<p>If you compiled FFmpeg libraries statically and you want to use them to
+build your own shared library, you may need to force PIC support (with
+<code>--enable-pic</code> during FFmpeg configure) and add the following option
+to your project LDFLAGS:
+</p>
+<div class="example">
+<pre class="example">-Wl,-Bsymbolic
+</pre></div>
+
+<p>If your target platform requires position independent binaries, you should
+pass the correct linking flag (e.g. <code>-pie</code>) to <code>--extra-ldexeflags</code>.
+</p>
+<a name="BSD"></a>
+<h3 class="section">1.2 BSD<span class="pull-right"><a class="anchor hidden-xs" href="#BSD" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-BSD" aria-hidden="true">TOC</a></span></h3>
+
+<p>BSD make will not build FFmpeg, you need to install and use GNU Make
+(<code>gmake</code>).
+</p>
+<a name="g_t_0028Open_0029Solaris"></a>
+<h3 class="section">1.3 (Open)Solaris<span class="pull-right"><a class="anchor hidden-xs" href="#_0028Open_0029Solaris" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-_0028Open_0029Solaris" aria-hidden="true">TOC</a></span></h3>
+
+<p>GNU Make is required to build FFmpeg, so you have to invoke (<code>gmake</code>),
+standard Solaris Make will not work. When building with a non-c99 front-end
+(gcc, generic suncc) add either <code>--extra-libs=/usr/lib/values-xpg6.o</code>
+or <code>--extra-libs=/usr/lib/64/values-xpg6.o</code> to the configure options
+since the libc is not c99-compliant by default. The probes performed by
+configure may raise an exception leading to the death of configure itself
+due to a bug in the system shell. Simply invoke a different shell such as
+bash directly to work around this:
+</p>
+<div class="example">
+<pre class="example">bash ./configure
+</pre></div>
+
+<span id="Darwin"></span><a name="Darwin-_0028Mac-OS-X_002c-iPhone_0029"></a>
+<h3 class="section">1.4 Darwin (Mac OS X, iPhone)<span class="pull-right"><a class="anchor hidden-xs" href="#Darwin-_0028Mac-OS-X_002c-iPhone_0029" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Darwin-_0028Mac-OS-X_002c-iPhone_0029" aria-hidden="true">TOC</a></span></h3>
+
+<p>The toolchain provided with Xcode is sufficient to build the basic
+unaccelerated code.
+</p>
+<p>Mac OS X on PowerPC or ARM (iPhone) requires a preprocessor from
+<a href="https://github.com/FFmpeg/gas-preprocessor">https://github.com/FFmpeg/gas-preprocessor</a> or
+<a href="https://github.com/yuvi/gas-preprocessor">https://github.com/yuvi/gas-preprocessor</a>(currently outdated) to build the optimized
+assembly functions. Put the Perl script somewhere
+in your PATH, FFmpeg&rsquo;s configure will pick it up automatically.
+</p>
+<p>Mac OS X on amd64 and x86 requires <code>nasm</code> to build most of the
+optimized assembly functions. <a href="http://www.finkproject.org/">Fink</a>,
+<a href="https://wiki.gentoo.org/wiki/Project:Prefix">Gentoo Prefix</a>,
+<a href="https://mxcl.github.com/homebrew/">Homebrew</a>
+or <a href="http://www.macports.org">MacPorts</a> can easily provide it.
+</p>
+
+<a name="DOS"></a>
+<h2 class="chapter">2 DOS<span class="pull-right"><a class="anchor hidden-xs" href="#DOS" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-DOS" aria-hidden="true">TOC</a></span></h2>
+
+<p>Using a cross-compiler is preferred for various reasons.
+<a href="http://www.delorie.com/howto/djgpp/linux-x-djgpp.html">http://www.delorie.com/howto/djgpp/linux-x-djgpp.html</a>
+</p>
+
+<a name="OS_002f2"></a>
+<h2 class="chapter">3 OS/2<span class="pull-right"><a class="anchor hidden-xs" href="#OS_002f2" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-OS_002f2" aria-hidden="true">TOC</a></span></h2>
+
+<p>For information about compiling FFmpeg on OS/2 see
+<a href="http://www.edm2.com/index.php/FFmpeg">http://www.edm2.com/index.php/FFmpeg</a>.
+</p>
+
+<a name="Windows"></a>
+<h2 class="chapter">4 Windows<span class="pull-right"><a class="anchor hidden-xs" href="#Windows" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Windows" aria-hidden="true">TOC</a></span></h2>
+
+<p>To get help and instructions for building FFmpeg under Windows, check out
+the FFmpeg Windows Help Forum at <a href="http://ffmpeg.zeranoe.com/forum/">http://ffmpeg.zeranoe.com/forum/</a>.
+</p>
+<a name="Native-Windows-compilation-using-MinGW-or-MinGW_002dw64"></a>
+<h3 class="section">4.1 Native Windows compilation using MinGW or MinGW-w64<span class="pull-right"><a class="anchor hidden-xs" href="#Native-Windows-compilation-using-MinGW-or-MinGW_002dw64" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Native-Windows-compilation-using-MinGW-or-MinGW_002dw64" aria-hidden="true">TOC</a></span></h3>
+
+<p>FFmpeg can be built to run natively on Windows using the MinGW-w64
+toolchain. Install the latest versions of MSYS2 and MinGW-w64 from
+<a href="http://msys2.github.io/">http://msys2.github.io/</a> and/or <a href="http://mingw-w64.sourceforge.net/">http://mingw-w64.sourceforge.net/</a>.
+You can find detailed installation instructions in the download section and
+the FAQ.
+</p>
+<p>Notes:
+</p>
+<ul>
+<li> Building for the MSYS environment is discouraged, MSYS2 provides a full
+MinGW-w64 environment through <samp>mingw64_shell.bat</samp> or
+<samp>mingw32_shell.bat</samp> that should be used instead of the environment
+provided by <samp>msys2_shell.bat</samp>.
+
+</li><li> Building using MSYS2 can be sped up by disabling implicit rules in the
+Makefile by calling <code>make -r</code> instead of plain <code>make</code>. This
+speed up is close to non-existent for normal one-off builds and is only
+noticeable when running make for a second time (for example during
+<code>make install</code>).
+
+</li><li> In order to compile FFplay, you must have the MinGW development library
+of <a href="http://www.libsdl.org/">SDL</a> and <code>pkg-config</code> installed.
+
+</li><li> By using <code>./configure --enable-shared</code> when configuring FFmpeg,
+you can build the FFmpeg libraries (e.g. libavutil, libavcodec,
+libavformat) as DLLs.
+
+</li></ul>
+
+<a name="Native-Windows-compilation-using-MSYS2"></a>
+<h4 class="subsection">4.1.1 Native Windows compilation using MSYS2<span class="pull-right"><a class="anchor hidden-xs" href="#Native-Windows-compilation-using-MSYS2" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Native-Windows-compilation-using-MSYS2" aria-hidden="true">TOC</a></span></h4>
+
+<p>The MSYS2 MinGW-w64 environment provides ready to use toolchains and dependencies
+through <code>pacman</code>.
+</p>
+<p>Make sure to use <samp>mingw64_shell.bat</samp> or <samp>mingw32_shell.bat</samp> to have
+the correct MinGW-w64 environment. The default install provides shortcuts to
+them under <code>MinGW-w64 Win64 Shell</code> and <code>MinGW-w64 Win32 Shell</code>.
+</p>
+<div class="example">
+<pre class="example"># normal msys2 packages
+pacman -S make pkgconf diffutils
+
+# mingw-w64 packages and toolchains
+pacman -S mingw-w64-x86_64-nasm mingw-w64-x86_64-gcc mingw-w64-x86_64-SDL2
+</pre></div>
+
+<p>To target 32 bits replace <code>x86_64</code> with <code>i686</code> in the command above.
+</p>
+<a name="Microsoft-Visual-C_002b_002b-or-Intel-C_002b_002b-Compiler-for-Windows"></a>
+<h3 class="section">4.2 Microsoft Visual C++ or Intel C++ Compiler for Windows<span class="pull-right"><a class="anchor hidden-xs" href="#Microsoft-Visual-C_002b_002b-or-Intel-C_002b_002b-Compiler-for-Windows" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Microsoft-Visual-C_002b_002b-or-Intel-C_002b_002b-Compiler-for-Windows" aria-hidden="true">TOC</a></span></h3>
+
+<p>FFmpeg can be built with MSVC 2013 or later.
+</p>
+<p>You will need the following prerequisites:
+</p>
+<ul>
+<li> <a href="http://msys2.github.io/">MSYS2</a>
+</li><li> <a href="http://www.nasm.us/">NASM</a>
+(Also available via MSYS2&rsquo;s package manager.)
+</li></ul>
+
+<p>To set up a proper environment in MSYS2, you need to run <code>msys_shell.bat</code> from
+the Visual Studio or Intel Compiler command prompt.
+</p>
+<p>Place <code>yasm.exe</code> somewhere in your <code>PATH</code>.
+</p>
+<p>Next, make sure any other headers and libs you want to use, such as zlib, are
+located in a spot that the compiler can see. Do so by modifying the <code>LIB</code>
+and <code>INCLUDE</code> environment variables to include the <strong>Windows-style</strong>
+paths to these directories. Alternatively, you can try to use the
+<code>--extra-cflags</code>/<code>--extra-ldflags</code> configure options.
+</p>
+<p>Finally, run:
+</p>
+<div class="example">
+<pre class="example">For MSVC:
+./configure --toolchain=msvc
+
+For ICL:
+./configure --toolchain=icl
+
+make
+make install
+</pre></div>
+
+<p>If you wish to compile shared libraries, add <code>--enable-shared</code> to your
+configure options. Note that due to the way MSVC and ICL handle DLL imports and
+exports, you cannot compile static and shared libraries at the same time, and
+enabling shared libraries will automatically disable the static ones.
+</p>
+<p>Notes:
+</p>
+<ul>
+<li> If you wish to build with zlib support, you will have to grab a compatible
+zlib binary from somewhere, with an MSVC import lib, or if you wish to link
+statically, you can follow the instructions below to build a compatible
+<code>zlib.lib</code> with MSVC. Regardless of which method you use, you must still
+follow step 3, or compilation will fail.
+<ol>
+<li> Grab the <a href="http://zlib.net/">zlib sources</a>.
+</li><li> Edit <code>win32/Makefile.msc</code> so that it uses -MT instead of -MD, since
+this is how FFmpeg is built as well.
+</li><li> Edit <code>zconf.h</code> and remove its inclusion of <code>unistd.h</code>. This gets
+erroneously included when building FFmpeg.
+</li><li> Run <code>nmake -f win32/Makefile.msc</code>.
+</li><li> Move <code>zlib.lib</code>, <code>zconf.h</code>, and <code>zlib.h</code> to somewhere MSVC
+can see.
+</li></ol>
+
+</li><li> FFmpeg has been tested with the following on i686 and x86_64:
+<ul>
+<li> Visual Studio 2013 Pro and Express
+</li><li> Intel Composer XE 2013
+</li><li> Intel Composer XE 2013 SP1
+</li></ul>
+<p>Anything else is not officially supported.
+</p>
+</li></ul>
+
+<a name="Linking-to-FFmpeg-with-Microsoft-Visual-C_002b_002b"></a>
+<h4 class="subsection">4.2.1 Linking to FFmpeg with Microsoft Visual C++<span class="pull-right"><a class="anchor hidden-xs" href="#Linking-to-FFmpeg-with-Microsoft-Visual-C_002b_002b" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Linking-to-FFmpeg-with-Microsoft-Visual-C_002b_002b" aria-hidden="true">TOC</a></span></h4>
+
+<p>If you plan to link with MSVC-built static libraries, you will need
+to make sure you have <code>Runtime Library</code> set to
+<code>Multi-threaded (/MT)</code> in your project&rsquo;s settings.
+</p>
+<p>You will need to define <code>inline</code> to something MSVC understands:
+</p><div class="example">
+<pre class="example">#define inline __inline
+</pre></div>
+
+<p>Also note, that as stated in <strong>Microsoft Visual C++</strong>, you will need
+an MSVC-compatible <a href="http://code.google.com/p/msinttypes/">inttypes.h</a>.
+</p>
+<p>If you plan on using import libraries created by dlltool, you must
+set <code>References</code> to <code>No (/OPT:NOREF)</code> under the linker optimization
+settings, otherwise the resulting binaries will fail during runtime.
+This is not required when using import libraries generated by <code>lib.exe</code>.
+This issue is reported upstream at
+<a href="http://sourceware.org/bugzilla/show_bug.cgi?id=12633">http://sourceware.org/bugzilla/show_bug.cgi?id=12633</a>.
+</p>
+<p>To create import libraries that work with the <code>/OPT:REF</code> option
+(which is enabled by default in Release mode), follow these steps:
+</p>
+<ol>
+<li> Open the <em>Visual Studio Command Prompt</em>.
+
+<p>Alternatively, in a normal command line prompt, call <samp>vcvars32.bat</samp>
+which sets up the environment variables for the Visual C++ tools
+(the standard location for this file is something like
+<samp>C:\Program Files (x86_\Microsoft Visual Studio 10.0\VC\bin\vcvars32.bat</samp>).
+</p>
+</li><li> Enter the <samp>bin</samp> directory where the created LIB and DLL files
+are stored.
+
+</li><li> Generate new import libraries with <code>lib.exe</code>:
+
+<div class="example">
+<pre class="example">lib /machine:i386 /def:..\lib\foo-version.def  /out:foo.lib
+</pre></div>
+
+<p>Replace <code>foo-version</code> and <code>foo</code> with the respective library names.
+</p>
+</li></ol>
+
+<span id="Cross-compilation-for-Windows-with-Linux"></span><a name="Cross-compilation-for-Windows-with-Linux-1"></a>
+<h3 class="section">4.3 Cross compilation for Windows with Linux<span class="pull-right"><a class="anchor hidden-xs" href="#Cross-compilation-for-Windows-with-Linux-1" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Cross-compilation-for-Windows-with-Linux-1" aria-hidden="true">TOC</a></span></h3>
+
+<p>You must use the MinGW cross compilation tools available at
+<a href="http://www.mingw.org/">http://www.mingw.org/</a>.
+</p>
+<p>Then configure FFmpeg with the following options:
+</p><div class="example">
+<pre class="example">./configure --target-os=mingw32 --cross-prefix=i386-mingw32msvc-
+</pre></div>
+<p>(you can change the cross-prefix according to the prefix chosen for the
+MinGW tools).
+</p>
+<p>Then you can easily test FFmpeg with <a href="http://www.winehq.com/">Wine</a>.
+</p>
+<a name="Compilation-under-Cygwin"></a>
+<h3 class="section">4.4 Compilation under Cygwin<span class="pull-right"><a class="anchor hidden-xs" href="#Compilation-under-Cygwin" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Compilation-under-Cygwin" aria-hidden="true">TOC</a></span></h3>
+
+<p>Please use Cygwin 1.7.x as the obsolete 1.5.x Cygwin versions lack
+llrint() in its C library.
+</p>
+<p>Install your Cygwin with all the &quot;Base&quot; packages, plus the
+following &quot;Devel&quot; ones:
+</p><div class="example">
+<pre class="example">binutils, gcc4-core, make, git, mingw-runtime, texinfo
+</pre></div>
+
+<p>In order to run FATE you will also need the following &quot;Utils&quot; packages:
+</p><div class="example">
+<pre class="example">diffutils
+</pre></div>
+
+<p>If you want to build FFmpeg with additional libraries, download Cygwin
+&quot;Devel&quot; packages for Ogg and Vorbis from any Cygwin packages repository:
+</p><div class="example">
+<pre class="example">libogg-devel, libvorbis-devel
+</pre></div>
+
+<p>These library packages are only available from
+<a href="http://sourceware.org/cygwinports/">Cygwin Ports</a>:
+</p>
+<div class="example">
+<pre class="example">yasm, libSDL-devel, libgsm-devel, libmp3lame-devel,
+speex-devel, libtheora-devel, libxvidcore-devel
+</pre></div>
+
+<p>The recommendation for x264 is to build it from source, as it evolves too
+quickly for Cygwin Ports to be up to date.
+</p>
+<a name="Crosscompilation-for-Windows-under-Cygwin"></a>
+<h3 class="section">4.5 Crosscompilation for Windows under Cygwin<span class="pull-right"><a class="anchor hidden-xs" href="#Crosscompilation-for-Windows-under-Cygwin" aria-hidden="true">#</a> <a class="anchor hidden-xs"href="#toc-Crosscompilation-for-Windows-under-Cygwin" aria-hidden="true">TOC</a></span></h3>
+
+<p>With Cygwin you can create Windows binaries that do not need the cygwin1.dll.
+</p>
+<p>Just install your Cygwin as explained before, plus these additional
+&quot;Devel&quot; packages:
+</p><div class="example">
+<pre class="example">gcc-mingw-core, mingw-runtime, mingw-zlib
+</pre></div>
+
+<p>and add some special flags to your configure invocation.
+</p>
+<p>For a static build run
+</p><div class="example">
+<pre class="example">./configure --target-os=mingw32 --extra-cflags=-mno-cygwin --extra-libs=-mno-cygwin
+</pre></div>
+
+<p>and for a build with shared libraries
+</p><div class="example">
+<pre class="example">./configure --target-os=mingw32 --enable-shared --disable-static --extra-cflags=-mno-cygwin --extra-libs=-mno-cygwin
+</pre></div>
+
+
+      <p style="font-size: small;">
+        This document was generated using <a href="http://www.gnu.org/software/texinfo/"><em>makeinfo</em></a>.
+      </p>
+    </div>
+  </body>
+</html>

ffmpeg-n4.3.2-win64-gpl-shared-4.3/include/libavcodec/ac3_parser.h

@@ -0,0 +1,36 @@
+/*
+ * AC-3 parser prototypes
+ * Copyright (c) 2003 Fabrice Bellard
+ * Copyright (c) 2003 Michael Niedermayer
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_AC3_PARSER_H
+#define AVCODEC_AC3_PARSER_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+/**
+ * Extract the bitstream ID and the frame size from AC-3 data.
+ */
+int av_ac3_parse_header(const uint8_t *buf, size_t size,
+                        uint8_t *bitstream_id, uint16_t *frame_size);
+
+
+#endif /* AVCODEC_AC3_PARSER_H */

ffmpeg-n4.3.2-win64-gpl-shared-4.3/include/libavcodec/adts_parser.h

@@ -0,0 +1,37 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_ADTS_PARSER_H
+#define AVCODEC_ADTS_PARSER_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#define AV_AAC_ADTS_HEADER_SIZE 7
+
+/**
+ * Extract the number of samples and frames from AAC data.
+ * @param[in]  buf     pointer to AAC data buffer
+ * @param[out] samples Pointer to where number of samples is written
+ * @param[out] frames  Pointer to where number of frames is written
+ * @return Returns 0 on success, error code on failure.
+ */
+int av_adts_header_parse(const uint8_t *buf, uint32_t *samples,
+                         uint8_t *frames);
+
+#endif /* AVCODEC_ADTS_PARSER_H */

ffmpeg-n4.3.2-win64-gpl-shared-4.3/include/libavcodec/avdct.h

@@ -0,0 +1,88 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_AVDCT_H
+#define AVCODEC_AVDCT_H
+
+#include "libavutil/opt.h"
+
+/**
+ * AVDCT context.
+ * @note function pointers can be NULL if the specific features have been
+ *       disabled at build time.
+ */
+typedef struct AVDCT {
+    const AVClass *av_class;
+
+    void (*idct)(int16_t *block /* align 16 */);
+
+    /**
+     * IDCT input permutation.
+     * Several optimized IDCTs need a permutated input (relative to the
+     * normal order of the reference IDCT).
+     * This permutation must be performed before the idct_put/add.
+     * Note, normally this can be merged with the zigzag/alternate scan<br>
+     * An example to avoid confusion:
+     * - (->decode coeffs -> zigzag reorder -> dequant -> reference IDCT -> ...)
+     * - (x -> reference DCT -> reference IDCT -> x)
+     * - (x -> reference DCT -> simple_mmx_perm = idct_permutation
+     *    -> simple_idct_mmx -> x)
+     * - (-> decode coeffs -> zigzag reorder -> simple_mmx_perm -> dequant
+     *    -> simple_idct_mmx -> ...)
+     */
+    uint8_t idct_permutation[64];
+
+    void (*fdct)(int16_t *block /* align 16 */);
+
+
+    /**
+     * DCT algorithm.
+     * must use AVOptions to set this field.
+     */
+    int dct_algo;
+
+    /**
+     * IDCT algorithm.
+     * must use AVOptions to set this field.
+     */
+    int idct_algo;
+
+    void (*get_pixels)(int16_t *block /* align 16 */,
+                       const uint8_t *pixels /* align 8 */,
+                       ptrdiff_t line_size);
+
+    int bits_per_sample;
+
+    void (*get_pixels_unaligned)(int16_t *block /* align 16 */,
+                       const uint8_t *pixels,
+                       ptrdiff_t line_size);
+} AVDCT;
+
+/**
+ * Allocates a AVDCT context.
+ * This needs to be initialized with avcodec_dct_init() after optionally
+ * configuring it with AVOptions.
+ *
+ * To free it use av_free()
+ */
+AVDCT *avcodec_dct_alloc(void);
+int avcodec_dct_init(AVDCT *);
+
+const AVClass *avcodec_dct_get_class(void);
+
+#endif /* AVCODEC_AVDCT_H */

ffmpeg-n4.3.2-win64-gpl-shared-4.3/include/libavcodec/avfft.h

@@ -0,0 +1,118 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_AVFFT_H
+#define AVCODEC_AVFFT_H
+
+/**
+ * @file
+ * @ingroup lavc_fft
+ * FFT functions
+ */
+
+/**
+ * @defgroup lavc_fft FFT functions
+ * @ingroup lavc_misc
+ *
+ * @{
+ */
+
+typedef float FFTSample;
+
+typedef struct FFTComplex {
+    FFTSample re, im;
+} FFTComplex;
+
+typedef struct FFTContext FFTContext;
+
+/**
+ * Set up a complex FFT.
+ * @param nbits           log2 of the length of the input array
+ * @param inverse         if 0 perform the forward transform, if 1 perform the inverse
+ */
+FFTContext *av_fft_init(int nbits, int inverse);
+
+/**
+ * Do the permutation needed BEFORE calling ff_fft_calc().
+ */
+void av_fft_permute(FFTContext *s, FFTComplex *z);
+
+/**
+ * Do a complex FFT with the parameters defined in av_fft_init(). The
+ * input data must be permuted before. No 1.0/sqrt(n) normalization is done.
+ */
+void av_fft_calc(FFTContext *s, FFTComplex *z);
+
+void av_fft_end(FFTContext *s);
+
+FFTContext *av_mdct_init(int nbits, int inverse, double scale);
+void av_imdct_calc(FFTContext *s, FFTSample *output, const FFTSample *input);
+void av_imdct_half(FFTContext *s, FFTSample *output, const FFTSample *input);
+void av_mdct_calc(FFTContext *s, FFTSample *output, const FFTSample *input);
+void av_mdct_end(FFTContext *s);
+
+/* Real Discrete Fourier Transform */
+
+enum RDFTransformType {
+    DFT_R2C,
+    IDFT_C2R,
+    IDFT_R2C,
+    DFT_C2R,
+};
+
+typedef struct RDFTContext RDFTContext;
+
+/**
+ * Set up a real FFT.
+ * @param nbits           log2 of the length of the input array
+ * @param trans           the type of transform
+ */
+RDFTContext *av_rdft_init(int nbits, enum RDFTransformType trans);
+void av_rdft_calc(RDFTContext *s, FFTSample *data);
+void av_rdft_end(RDFTContext *s);
+
+/* Discrete Cosine Transform */
+
+typedef struct DCTContext DCTContext;
+
+enum DCTTransformType {
+    DCT_II = 0,
+    DCT_III,
+    DCT_I,
+    DST_I,
+};
+
+/**
+ * Set up DCT.
+ *
+ * @param nbits           size of the input array:
+ *                        (1 << nbits)     for DCT-II, DCT-III and DST-I
+ *                        (1 << nbits) + 1 for DCT-I
+ * @param type            the type of transform
+ *
+ * @note the first element of the input of DST-I is ignored
+ */
+DCTContext *av_dct_init(int nbits, enum DCTTransformType type);
+void av_dct_calc(DCTContext *s, FFTSample *data);
+void av_dct_end (DCTContext *s);
+
+/**
+ * @}
+ */
+
+#endif /* AVCODEC_AVFFT_H */

ffmpeg-n4.3.2-win64-gpl-shared-4.3/include/libavcodec/bsf.h

@@ -0,0 +1,325 @@
+/*
+ * Bitstream filters public API
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_BSF_H
+#define AVCODEC_BSF_H
+
+#include "libavutil/dict.h"
+#include "libavutil/log.h"
+#include "libavutil/rational.h"
+
+#include "codec_id.h"
+#include "codec_par.h"
+#include "packet.h"
+
+/**
+ * @addtogroup lavc_core
+ * @{
+ */
+
+typedef struct AVBSFInternal AVBSFInternal;
+
+/**
+ * The bitstream filter state.
+ *
+ * This struct must be allocated with av_bsf_alloc() and freed with
+ * av_bsf_free().
+ *
+ * The fields in the struct will only be changed (by the caller or by the
+ * filter) as described in their documentation, and are to be considered
+ * immutable otherwise.
+ */
+typedef struct AVBSFContext {
+    /**
+     * A class for logging and AVOptions
+     */
+    const AVClass *av_class;
+
+    /**
+     * The bitstream filter this context is an instance of.
+     */
+    const struct AVBitStreamFilter *filter;
+
+    /**
+     * Opaque libavcodec internal data. Must not be touched by the caller in any
+     * way.
+     */
+    AVBSFInternal *internal;
+
+    /**
+     * Opaque filter-specific private data. If filter->priv_class is non-NULL,
+     * this is an AVOptions-enabled struct.
+     */
+    void *priv_data;
+
+    /**
+     * Parameters of the input stream. This field is allocated in
+     * av_bsf_alloc(), it needs to be filled by the caller before
+     * av_bsf_init().
+     */
+    AVCodecParameters *par_in;
+
+    /**
+     * Parameters of the output stream. This field is allocated in
+     * av_bsf_alloc(), it is set by the filter in av_bsf_init().
+     */
+    AVCodecParameters *par_out;
+
+    /**
+     * The timebase used for the timestamps of the input packets. Set by the
+     * caller before av_bsf_init().
+     */
+    AVRational time_base_in;
+
+    /**
+     * The timebase used for the timestamps of the output packets. Set by the
+     * filter in av_bsf_init().
+     */
+    AVRational time_base_out;
+} AVBSFContext;
+
+typedef struct AVBitStreamFilter {
+    const char *name;
+
+    /**
+     * A list of codec ids supported by the filter, terminated by
+     * AV_CODEC_ID_NONE.
+     * May be NULL, in that case the bitstream filter works with any codec id.
+     */
+    const enum AVCodecID *codec_ids;
+
+    /**
+     * A class for the private data, used to declare bitstream filter private
+     * AVOptions. This field is NULL for bitstream filters that do not declare
+     * any options.
+     *
+     * If this field is non-NULL, the first member of the filter private data
+     * must be a pointer to AVClass, which will be set by libavcodec generic
+     * code to this class.
+     */
+    const AVClass *priv_class;
+
+    /*****************************************************************
+     * No fields below this line are part of the public API. They
+     * may not be used outside of libavcodec and can be changed and
+     * removed at will.
+     * New public fields should be added right above.
+     *****************************************************************
+     */
+
+    int priv_data_size;
+    int (*init)(AVBSFContext *ctx);
+    int (*filter)(AVBSFContext *ctx, AVPacket *pkt);
+    void (*close)(AVBSFContext *ctx);
+    void (*flush)(AVBSFContext *ctx);
+} AVBitStreamFilter;
+
+/**
+ * @return a bitstream filter with the specified name or NULL if no such
+ *         bitstream filter exists.
+ */
+const AVBitStreamFilter *av_bsf_get_by_name(const char *name);
+
+/**
+ * Iterate over all registered bitstream filters.
+ *
+ * @param opaque a pointer where libavcodec will store the iteration state. Must
+ *               point to NULL to start the iteration.
+ *
+ * @return the next registered bitstream filter or NULL when the iteration is
+ *         finished
+ */
+const AVBitStreamFilter *av_bsf_iterate(void **opaque);
+
+/**
+ * Allocate a context for a given bitstream filter. The caller must fill in the
+ * context parameters as described in the documentation and then call
+ * av_bsf_init() before sending any data to the filter.
+ *
+ * @param filter the filter for which to allocate an instance.
+ * @param ctx a pointer into which the pointer to the newly-allocated context
+ *            will be written. It must be freed with av_bsf_free() after the
+ *            filtering is done.
+ *
+ * @return 0 on success, a negative AVERROR code on failure
+ */
+int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **ctx);
+
+/**
+ * Prepare the filter for use, after all the parameters and options have been
+ * set.
+ */
+int av_bsf_init(AVBSFContext *ctx);
+
+/**
+ * Submit a packet for filtering.
+ *
+ * After sending each packet, the filter must be completely drained by calling
+ * av_bsf_receive_packet() repeatedly until it returns AVERROR(EAGAIN) or
+ * AVERROR_EOF.
+ *
+ * @param pkt the packet to filter. The bitstream filter will take ownership of
+ * the packet and reset the contents of pkt. pkt is not touched if an error occurs.
+ * If pkt is empty (i.e. NULL, or pkt->data is NULL and pkt->side_data_elems zero),
+ * it signals the end of the stream (i.e. no more non-empty packets will be sent;
+ * sending more empty packets does nothing) and will cause the filter to output
+ * any packets it may have buffered internally.
+ *
+ * @return 0 on success. AVERROR(EAGAIN) if packets need to be retrieved from the
+ * filter (using av_bsf_receive_packet()) before new input can be consumed. Another
+ * negative AVERROR value if an error occurs.
+ */
+int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt);
+
+/**
+ * Retrieve a filtered packet.
+ *
+ * @param[out] pkt this struct will be filled with the contents of the filtered
+ *                 packet. It is owned by the caller and must be freed using
+ *                 av_packet_unref() when it is no longer needed.
+ *                 This parameter should be "clean" (i.e. freshly allocated
+ *                 with av_packet_alloc() or unreffed with av_packet_unref())
+ *                 when this function is called. If this function returns
+ *                 successfully, the contents of pkt will be completely
+ *                 overwritten by the returned data. On failure, pkt is not
+ *                 touched.
+ *
+ * @return 0 on success. AVERROR(EAGAIN) if more packets need to be sent to the
+ * filter (using av_bsf_send_packet()) to get more output. AVERROR_EOF if there
+ * will be no further output from the filter. Another negative AVERROR value if
+ * an error occurs.
+ *
+ * @note one input packet may result in several output packets, so after sending
+ * a packet with av_bsf_send_packet(), this function needs to be called
+ * repeatedly until it stops returning 0. It is also possible for a filter to
+ * output fewer packets than were sent to it, so this function may return
+ * AVERROR(EAGAIN) immediately after a successful av_bsf_send_packet() call.
+ */
+int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt);
+
+/**
+ * Reset the internal bitstream filter state / flush internal buffers.
+ */
+void av_bsf_flush(AVBSFContext *ctx);
+
+/**
+ * Free a bitstream filter context and everything associated with it; write NULL
+ * into the supplied pointer.
+ */
+void av_bsf_free(AVBSFContext **ctx);
+
+/**
+ * Get the AVClass for AVBSFContext. It can be used in combination with
+ * AV_OPT_SEARCH_FAKE_OBJ for examining options.
+ *
+ * @see av_opt_find().
+ */
+const AVClass *av_bsf_get_class(void);
+
+/**
+ * Structure for chain/list of bitstream filters.
+ * Empty list can be allocated by av_bsf_list_alloc().
+ */
+typedef struct AVBSFList AVBSFList;
+
+/**
+ * Allocate empty list of bitstream filters.
+ * The list must be later freed by av_bsf_list_free()
+ * or finalized by av_bsf_list_finalize().
+ *
+ * @return Pointer to @ref AVBSFList on success, NULL in case of failure
+ */
+AVBSFList *av_bsf_list_alloc(void);
+
+/**
+ * Free list of bitstream filters.
+ *
+ * @param lst Pointer to pointer returned by av_bsf_list_alloc()
+ */
+void av_bsf_list_free(AVBSFList **lst);
+
+/**
+ * Append bitstream filter to the list of bitstream filters.
+ *
+ * @param lst List to append to
+ * @param bsf Filter context to be appended
+ *
+ * @return >=0 on success, negative AVERROR in case of failure
+ */
+int av_bsf_list_append(AVBSFList *lst, AVBSFContext *bsf);
+
+/**
+ * Construct new bitstream filter context given it's name and options
+ * and append it to the list of bitstream filters.
+ *
+ * @param lst      List to append to
+ * @param bsf_name Name of the bitstream filter
+ * @param options  Options for the bitstream filter, can be set to NULL
+ *
+ * @return >=0 on success, negative AVERROR in case of failure
+ */
+int av_bsf_list_append2(AVBSFList *lst, const char * bsf_name, AVDictionary **options);
+/**
+ * Finalize list of bitstream filters.
+ *
+ * This function will transform @ref AVBSFList to single @ref AVBSFContext,
+ * so the whole chain of bitstream filters can be treated as single filter
+ * freshly allocated by av_bsf_alloc().
+ * If the call is successful, @ref AVBSFList structure is freed and lst
+ * will be set to NULL. In case of failure, caller is responsible for
+ * freeing the structure by av_bsf_list_free()
+ *
+ * @param      lst Filter list structure to be transformed
+ * @param[out] bsf Pointer to be set to newly created @ref AVBSFContext structure
+ *                 representing the chain of bitstream filters
+ *
+ * @return >=0 on success, negative AVERROR in case of failure
+ */
+int av_bsf_list_finalize(AVBSFList **lst, AVBSFContext **bsf);
+
+/**
+ * Parse string describing list of bitstream filters and create single
+ * @ref AVBSFContext describing the whole chain of bitstream filters.
+ * Resulting @ref AVBSFContext can be treated as any other @ref AVBSFContext freshly
+ * allocated by av_bsf_alloc().
+ *
+ * @param      str String describing chain of bitstream filters in format
+ *                 `bsf1[=opt1=val1:opt2=val2][,bsf2]`
+ * @param[out] bsf Pointer to be set to newly created @ref AVBSFContext structure
+ *                 representing the chain of bitstream filters
+ *
+ * @return >=0 on success, negative AVERROR in case of failure
+ */
+int av_bsf_list_parse_str(const char *str, AVBSFContext **bsf);
+
+/**
+ * Get null/pass-through bitstream filter.
+ *
+ * @param[out] bsf Pointer to be set to new instance of pass-through bitstream filter
+ *
+ * @return
+ */
+int av_bsf_get_null_filter(AVBSFContext **bsf);
+
+/**
+ * @}
+ */
+
+#endif // AVCODEC_BSF_H

ffmpeg-n4.3.2-win64-gpl-shared-4.3/include/libavcodec/codec.h

@@ -0,0 +1,462 @@
+/*
+ * AVCodec public API
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_CODEC_H
+#define AVCODEC_CODEC_H
+
+#include <stdint.h>
+
+#include "libavutil/avutil.h"
+#include "libavutil/hwcontext.h"
+#include "libavutil/log.h"
+#include "libavutil/pixfmt.h"
+#include "libavutil/rational.h"
+#include "libavutil/samplefmt.h"
+
+#include "libavcodec/codec_id.h"
+#include "libavcodec/version.h"
+
+/**
+ * @addtogroup lavc_core
+ * @{
+ */
+
+/**
+ * Decoder can use draw_horiz_band callback.
+ */
+#define AV_CODEC_CAP_DRAW_HORIZ_BAND     (1 <<  0)
+/**
+ * Codec uses get_buffer() for allocating buffers and supports custom allocators.
+ * If not set, it might not use get_buffer() at all or use operations that
+ * assume the buffer was allocated by avcodec_default_get_buffer.
+ */
+#define AV_CODEC_CAP_DR1                 (1 <<  1)
+#define AV_CODEC_CAP_TRUNCATED           (1 <<  3)
+/**
+ * Encoder or decoder requires flushing with NULL input at the end in order to
+ * give the complete and correct output.
+ *
+ * NOTE: If this flag is not set, the codec is guaranteed to never be fed with
+ *       with NULL data. The user can still send NULL data to the public encode
+ *       or decode function, but libavcodec will not pass it along to the codec
+ *       unless this flag is set.
+ *
+ * Decoders:
+ * The decoder has a non-zero delay and needs to be fed with avpkt->data=NULL,
+ * avpkt->size=0 at the end to get the delayed data until the decoder no longer
+ * returns frames.
+ *
+ * Encoders:
+ * The encoder needs to be fed with NULL data at the end of encoding until the
+ * encoder no longer returns data.
+ *
+ * NOTE: For encoders implementing the AVCodec.encode2() function, setting this
+ *       flag also means that the encoder must set the pts and duration for
+ *       each output packet. If this flag is not set, the pts and duration will
+ *       be determined by libavcodec from the input frame.
+ */
+#define AV_CODEC_CAP_DELAY               (1 <<  5)
+/**
+ * Codec can be fed a final frame with a smaller size.
+ * This can be used to prevent truncation of the last audio samples.
+ */
+#define AV_CODEC_CAP_SMALL_LAST_FRAME    (1 <<  6)
+
+/**
+ * Codec can output multiple frames per AVPacket
+ * Normally demuxers return one frame at a time, demuxers which do not do
+ * are connected to a parser to split what they return into proper frames.
+ * This flag is reserved to the very rare category of codecs which have a
+ * bitstream that cannot be split into frames without timeconsuming
+ * operations like full decoding. Demuxers carrying such bitstreams thus
+ * may return multiple frames in a packet. This has many disadvantages like
+ * prohibiting stream copy in many cases thus it should only be considered
+ * as a last resort.
+ */
+#define AV_CODEC_CAP_SUBFRAMES           (1 <<  8)
+/**
+ * Codec is experimental and is thus avoided in favor of non experimental
+ * encoders
+ */
+#define AV_CODEC_CAP_EXPERIMENTAL        (1 <<  9)
+/**
+ * Codec should fill in channel configuration and samplerate instead of container
+ */
+#define AV_CODEC_CAP_CHANNEL_CONF        (1 << 10)
+/**
+ * Codec supports frame-level multithreading.
+ */
+#define AV_CODEC_CAP_FRAME_THREADS       (1 << 12)
+/**
+ * Codec supports slice-based (or partition-based) multithreading.
+ */
+#define AV_CODEC_CAP_SLICE_THREADS       (1 << 13)
+/**
+ * Codec supports changed parameters at any point.
+ */
+#define AV_CODEC_CAP_PARAM_CHANGE        (1 << 14)
+/**
+ * Codec supports avctx->thread_count == 0 (auto).
+ */
+#define AV_CODEC_CAP_AUTO_THREADS        (1 << 15)
+/**
+ * Audio encoder supports receiving a different number of samples in each call.
+ */
+#define AV_CODEC_CAP_VARIABLE_FRAME_SIZE (1 << 16)
+/**
+ * Decoder is not a preferred choice for probing.
+ * This indicates that the decoder is not a good choice for probing.
+ * It could for example be an expensive to spin up hardware decoder,
+ * or it could simply not provide a lot of useful information about
+ * the stream.
+ * A decoder marked with this flag should only be used as last resort
+ * choice for probing.
+ */
+#define AV_CODEC_CAP_AVOID_PROBING       (1 << 17)
+
+#if FF_API_UNUSED_CODEC_CAPS
+/**
+ * Deprecated and unused. Use AVCodecDescriptor.props instead
+ */
+#define AV_CODEC_CAP_INTRA_ONLY       0x40000000
+/**
+ * Deprecated and unused. Use AVCodecDescriptor.props instead
+ */
+#define AV_CODEC_CAP_LOSSLESS         0x80000000
+#endif
+
+/**
+ * Codec is backed by a hardware implementation. Typically used to
+ * identify a non-hwaccel hardware decoder. For information about hwaccels, use
+ * avcodec_get_hw_config() instead.
+ */
+#define AV_CODEC_CAP_HARDWARE            (1 << 18)
+
+/**
+ * Codec is potentially backed by a hardware implementation, but not
+ * necessarily. This is used instead of AV_CODEC_CAP_HARDWARE, if the
+ * implementation provides some sort of internal fallback.
+ */
+#define AV_CODEC_CAP_HYBRID              (1 << 19)
+
+/**
+ * This codec takes the reordered_opaque field from input AVFrames
+ * and returns it in the corresponding field in AVCodecContext after
+ * encoding.
+ */
+#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE (1 << 20)
+
+/**
+ * This encoder can be flushed using avcodec_flush_buffers(). If this flag is
+ * not set, the encoder must be closed and reopened to ensure that no frames
+ * remain pending.
+ */
+#define AV_CODEC_CAP_ENCODER_FLUSH   (1 << 21)
+
+/**
+ * AVProfile.
+ */
+typedef struct AVProfile {
+    int profile;
+    const char *name; ///< short name for the profile
+} AVProfile;
+
+typedef struct AVCodecDefault AVCodecDefault;
+
+struct AVCodecContext;
+struct AVSubtitle;
+struct AVPacket;
+
+/**
+ * AVCodec.
+ */
+typedef struct AVCodec {
+    /**
+     * Name of the codec implementation.
+     * The name is globally unique among encoders and among decoders (but an
+     * encoder and a decoder can share the same name).
+     * This is the primary way to find a codec from the user perspective.
+     */
+    const char *name;
+    /**
+     * Descriptive name for the codec, meant to be more human readable than name.
+     * You should use the NULL_IF_CONFIG_SMALL() macro to define it.
+     */
+    const char *long_name;
+    enum AVMediaType type;
+    enum AVCodecID id;
+    /**
+     * Codec capabilities.
+     * see AV_CODEC_CAP_*
+     */
+    int capabilities;
+    const AVRational *supported_framerates; ///< array of supported framerates, or NULL if any, array is terminated by {0,0}
+    const enum AVPixelFormat *pix_fmts;     ///< array of supported pixel formats, or NULL if unknown, array is terminated by -1
+    const int *supported_samplerates;       ///< array of supported audio samplerates, or NULL if unknown, array is terminated by 0
+    const enum AVSampleFormat *sample_fmts; ///< array of supported sample formats, or NULL if unknown, array is terminated by -1
+    const uint64_t *channel_layouts;         ///< array of support channel layouts, or NULL if unknown. array is terminated by 0
+    uint8_t max_lowres;                     ///< maximum value for lowres supported by the decoder
+    const AVClass *priv_class;              ///< AVClass for the private context
+    const AVProfile *profiles;              ///< array of recognized profiles, or NULL if unknown, array is terminated by {FF_PROFILE_UNKNOWN}
+
+    /**
+     * Group name of the codec implementation.
+     * This is a short symbolic name of the wrapper backing this codec. A
+     * wrapper uses some kind of external implementation for the codec, such
+     * as an external library, or a codec implementation provided by the OS or
+     * the hardware.
+     * If this field is NULL, this is a builtin, libavcodec native codec.
+     * If non-NULL, this will be the suffix in AVCodec.name in most cases
+     * (usually AVCodec.name will be of the form "<codec_name>_<wrapper_name>").
+     */
+    const char *wrapper_name;
+
+    /*****************************************************************
+     * No fields below this line are part of the public API. They
+     * may not be used outside of libavcodec and can be changed and
+     * removed at will.
+     * New public fields should be added right above.
+     *****************************************************************
+     */
+    int priv_data_size;
+    struct AVCodec *next;
+    /**
+     * @name Frame-level threading support functions
+     * @{
+     */
+    /**
+     * Copy necessary context variables from a previous thread context to the current one.
+     * If not defined, the next thread will start automatically; otherwise, the codec
+     * must call ff_thread_finish_setup().
+     *
+     * dst and src will (rarely) point to the same context, in which case memcpy should be skipped.
+     */
+    int (*update_thread_context)(struct AVCodecContext *dst, const struct AVCodecContext *src);
+    /** @} */
+
+    /**
+     * Private codec-specific defaults.
+     */
+    const AVCodecDefault *defaults;
+
+    /**
+     * Initialize codec static data, called from avcodec_register().
+     *
+     * This is not intended for time consuming operations as it is
+     * run for every codec regardless of that codec being used.
+     */
+    void (*init_static_data)(struct AVCodec *codec);
+
+    int (*init)(struct AVCodecContext *);
+    int (*encode_sub)(struct AVCodecContext *, uint8_t *buf, int buf_size,
+                      const struct AVSubtitle *sub);
+    /**
+     * Encode data to an AVPacket.
+     *
+     * @param      avctx          codec context
+     * @param      avpkt          output AVPacket (may contain a user-provided buffer)
+     * @param[in]  frame          AVFrame containing the raw data to be encoded
+     * @param[out] got_packet_ptr encoder sets to 0 or 1 to indicate that a
+     *                            non-empty packet was returned in avpkt.
+     * @return 0 on success, negative error code on failure
+     */
+    int (*encode2)(struct AVCodecContext *avctx, struct AVPacket *avpkt,
+                   const struct AVFrame *frame, int *got_packet_ptr);
+    int (*decode)(struct AVCodecContext *, void *outdata, int *outdata_size, struct AVPacket *avpkt);
+    int (*close)(struct AVCodecContext *);
+    /**
+     * Encode API with decoupled packet/frame dataflow. The API is the
+     * same as the avcodec_ prefixed APIs (avcodec_send_frame() etc.), except
+     * that:
+     * - never called if the codec is closed or the wrong type,
+     * - if AV_CODEC_CAP_DELAY is not set, drain frames are never sent,
+     * - only one drain frame is ever passed down,
+     */
+    int (*send_frame)(struct AVCodecContext *avctx, const struct AVFrame *frame);
+    int (*receive_packet)(struct AVCodecContext *avctx, struct AVPacket *avpkt);
+
+    /**
+     * Decode API with decoupled packet/frame dataflow. This function is called
+     * to get one output frame. It should call ff_decode_get_packet() to obtain
+     * input data.
+     */
+    int (*receive_frame)(struct AVCodecContext *avctx, struct AVFrame *frame);
+    /**
+     * Flush buffers.
+     * Will be called when seeking
+     */
+    void (*flush)(struct AVCodecContext *);
+    /**
+     * Internal codec capabilities.
+     * See FF_CODEC_CAP_* in internal.h
+     */
+    int caps_internal;
+
+    /**
+     * Decoding only, a comma-separated list of bitstream filters to apply to
+     * packets before decoding.
+     */
+    const char *bsfs;
+
+    /**
+     * Array of pointers to hardware configurations supported by the codec,
+     * or NULL if no hardware supported.  The array is terminated by a NULL
+     * pointer.
+     *
+     * The user can only access this field via avcodec_get_hw_config().
+     */
+    const struct AVCodecHWConfigInternal **hw_configs;
+
+    /**
+     * List of supported codec_tags, terminated by FF_CODEC_TAGS_END.
+     */
+    const uint32_t *codec_tags;
+} AVCodec;
+
+/**
+ * Iterate over all registered codecs.
+ *
+ * @param opaque a pointer where libavcodec will store the iteration state. Must
+ *               point to NULL to start the iteration.
+ *
+ * @return the next registered codec or NULL when the iteration is
+ *         finished
+ */
+const AVCodec *av_codec_iterate(void **opaque);
+
+/**
+ * Find a registered decoder with a matching codec ID.
+ *
+ * @param id AVCodecID of the requested decoder
+ * @return A decoder if one was found, NULL otherwise.
+ */
+AVCodec *avcodec_find_decoder(enum AVCodecID id);
+
+/**
+ * Find a registered decoder with the specified name.
+ *
+ * @param name name of the requested decoder
+ * @return A decoder if one was found, NULL otherwise.
+ */
+AVCodec *avcodec_find_decoder_by_name(const char *name);
+
+/**
+ * Find a registered encoder with a matching codec ID.
+ *
+ * @param id AVCodecID of the requested encoder
+ * @return An encoder if one was found, NULL otherwise.
+ */
+AVCodec *avcodec_find_encoder(enum AVCodecID id);
+
+/**
+ * Find a registered encoder with the specified name.
+ *
+ * @param name name of the requested encoder
+ * @return An encoder if one was found, NULL otherwise.
+ */
+AVCodec *avcodec_find_encoder_by_name(const char *name);
+/**
+ * @return a non-zero number if codec is an encoder, zero otherwise
+ */
+int av_codec_is_encoder(const AVCodec *codec);
+
+/**
+ * @return a non-zero number if codec is a decoder, zero otherwise
+ */
+int av_codec_is_decoder(const AVCodec *codec);
+
+enum {
+    /**
+     * The codec supports this format via the hw_device_ctx interface.
+     *
+     * When selecting this format, AVCodecContext.hw_device_ctx should
+     * have been set to a device of the specified type before calling
+     * avcodec_open2().
+     */
+    AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX = 0x01,
+    /**
+     * The codec supports this format via the hw_frames_ctx interface.
+     *
+     * When selecting this format for a decoder,
+     * AVCodecContext.hw_frames_ctx should be set to a suitable frames
+     * context inside the get_format() callback.  The frames context
+     * must have been created on a device of the specified type.
+     *
+     * When selecting this format for an encoder,
+     * AVCodecContext.hw_frames_ctx should be set to the context which
+     * will be used for the input frames before calling avcodec_open2().
+     */
+    AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX = 0x02,
+    /**
+     * The codec supports this format by some internal method.
+     *
+     * This format can be selected without any additional configuration -
+     * no device or frames context is required.
+     */
+    AV_CODEC_HW_CONFIG_METHOD_INTERNAL      = 0x04,
+    /**
+     * The codec supports this format by some ad-hoc method.
+     *
+     * Additional settings and/or function calls are required.  See the
+     * codec-specific documentation for details.  (Methods requiring
+     * this sort of configuration are deprecated and others should be
+     * used in preference.)
+     */
+    AV_CODEC_HW_CONFIG_METHOD_AD_HOC        = 0x08,
+};
+
+typedef struct AVCodecHWConfig {
+    /**
+     * For decoders, a hardware pixel format which that decoder may be
+     * able to decode to if suitable hardware is available.
+     *
+     * For encoders, a pixel format which the encoder may be able to
+     * accept.  If set to AV_PIX_FMT_NONE, this applies to all pixel
+     * formats supported by the codec.
+     */
+    enum AVPixelFormat pix_fmt;
+    /**
+     * Bit set of AV_CODEC_HW_CONFIG_METHOD_* flags, describing the possible
+     * setup methods which can be used with this configuration.
+     */
+    int methods;
+    /**
+     * The device type associated with the configuration.
+     *
+     * Must be set for AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX and
+     * AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX, otherwise unused.
+     */
+    enum AVHWDeviceType device_type;
+} AVCodecHWConfig;
+
+/**
+ * Retrieve supported hardware configurations for a codec.
+ *
+ * Values of index from zero to some maximum return the indexed configuration
+ * descriptor; all other values return NULL.  If the codec does not support
+ * any hardware configurations then it will always return NULL.
+ */
+const AVCodecHWConfig *avcodec_get_hw_config(const AVCodec *codec, int index);
+
+/**
+ * @}
+ */
+
+#endif /* AVCODEC_CODEC_H */

ffmpeg-n4.3.2-win64-gpl-shared-4.3/include/libavcodec/codec_desc.h

@@ -0,0 +1,128 @@
+/*
+ * Codec descriptors public API
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_CODEC_DESC_H
+#define AVCODEC_CODEC_DESC_H
+
+#include "libavutil/avutil.h"
+
+#include "codec_id.h"
+
+/**
+ * @addtogroup lavc_core
+ * @{
+ */
+
+/**
+ * This struct describes the properties of a single codec described by an
+ * AVCodecID.
+ * @see avcodec_descriptor_get()
+ */
+typedef struct AVCodecDescriptor {
+    enum AVCodecID     id;
+    enum AVMediaType type;
+    /**
+     * Name of the codec described by this descriptor. It is non-empty and
+     * unique for each codec descriptor. It should contain alphanumeric
+     * characters and '_' only.
+     */
+    const char      *name;
+    /**
+     * A more descriptive name for this codec. May be NULL.
+     */
+    const char *long_name;
+    /**
+     * Codec properties, a combination of AV_CODEC_PROP_* flags.
+     */
+    int             props;
+    /**
+     * MIME type(s) associated with the codec.
+     * May be NULL; if not, a NULL-terminated array of MIME types.
+     * The first item is always non-NULL and is the preferred MIME type.
+     */
+    const char *const *mime_types;
+    /**
+     * If non-NULL, an array of profiles recognized for this codec.
+     * Terminated with FF_PROFILE_UNKNOWN.
+     */
+    const struct AVProfile *profiles;
+} AVCodecDescriptor;
+
+/**
+ * Codec uses only intra compression.
+ * Video and audio codecs only.
+ */
+#define AV_CODEC_PROP_INTRA_ONLY    (1 << 0)
+/**
+ * Codec supports lossy compression. Audio and video codecs only.
+ * @note a codec may support both lossy and lossless
+ * compression modes
+ */
+#define AV_CODEC_PROP_LOSSY         (1 << 1)
+/**
+ * Codec supports lossless compression. Audio and video codecs only.
+ */
+#define AV_CODEC_PROP_LOSSLESS      (1 << 2)
+/**
+ * Codec supports frame reordering. That is, the coded order (the order in which
+ * the encoded packets are output by the encoders / stored / input to the
+ * decoders) may be different from the presentation order of the corresponding
+ * frames.
+ *
+ * For codecs that do not have this property set, PTS and DTS should always be
+ * equal.
+ */
+#define AV_CODEC_PROP_REORDER       (1 << 3)
+/**
+ * Subtitle codec is bitmap based
+ * Decoded AVSubtitle data can be read from the AVSubtitleRect->pict field.
+ */
+#define AV_CODEC_PROP_BITMAP_SUB    (1 << 16)
+/**
+ * Subtitle codec is text based.
+ * Decoded AVSubtitle data can be read from the AVSubtitleRect->ass field.
+ */
+#define AV_CODEC_PROP_TEXT_SUB      (1 << 17)
+
+/**
+ * @return descriptor for given codec ID or NULL if no descriptor exists.
+ */
+const AVCodecDescriptor *avcodec_descriptor_get(enum AVCodecID id);
+
+/**
+ * Iterate over all codec descriptors known to libavcodec.
+ *
+ * @param prev previous descriptor. NULL to get the first descriptor.
+ *
+ * @return next descriptor or NULL after the last descriptor
+ */
+const AVCodecDescriptor *avcodec_descriptor_next(const AVCodecDescriptor *prev);
+
+/**
+ * @return codec descriptor with the given name or NULL if no such descriptor
+ *         exists.
+ */
+const AVCodecDescriptor *avcodec_descriptor_get_by_name(const char *name);
+
+/**
+ * @}
+ */
+
+#endif // AVCODEC_CODEC_DESC_H

ffmpeg-n4.3.2-win64-gpl-shared-4.3/include/libavcodec/codec_id.h

@@ -0,0 +1,577 @@
+/*
+ * Codec IDs
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_CODEC_ID_H
+#define AVCODEC_CODEC_ID_H
+
+#include "libavutil/avutil.h"
+
+/**
+ * @addtogroup lavc_core
+ * @{
+ */
+
+/**
+ * Identify the syntax and semantics of the bitstream.
+ * The principle is roughly:
+ * Two decoders with the same ID can decode the same streams.
+ * Two encoders with the same ID can encode compatible streams.
+ * There may be slight deviations from the principle due to implementation
+ * details.
+ *
+ * If you add a codec ID to this list, add it so that
+ * 1. no value of an existing codec ID changes (that would break ABI),
+ * 2. it is as close as possible to similar codecs
+ *
+ * After adding new codec IDs, do not forget to add an entry to the codec
+ * descriptor list and bump libavcodec minor version.
+ */
+enum AVCodecID {
+    AV_CODEC_ID_NONE,
+
+    /* video codecs */
+    AV_CODEC_ID_MPEG1VIDEO,
+    AV_CODEC_ID_MPEG2VIDEO, ///< preferred ID for MPEG-1/2 video decoding
+    AV_CODEC_ID_H261,
+    AV_CODEC_ID_H263,
+    AV_CODEC_ID_RV10,
+    AV_CODEC_ID_RV20,
+    AV_CODEC_ID_MJPEG,
+    AV_CODEC_ID_MJPEGB,
+    AV_CODEC_ID_LJPEG,
+    AV_CODEC_ID_SP5X,
+    AV_CODEC_ID_JPEGLS,
+    AV_CODEC_ID_MPEG4,
+    AV_CODEC_ID_RAWVIDEO,
+    AV_CODEC_ID_MSMPEG4V1,
+    AV_CODEC_ID_MSMPEG4V2,
+    AV_CODEC_ID_MSMPEG4V3,
+    AV_CODEC_ID_WMV1,
+    AV_CODEC_ID_WMV2,
+    AV_CODEC_ID_H263P,
+    AV_CODEC_ID_H263I,
+    AV_CODEC_ID_FLV1,
+    AV_CODEC_ID_SVQ1,
+    AV_CODEC_ID_SVQ3,
+    AV_CODEC_ID_DVVIDEO,
+    AV_CODEC_ID_HUFFYUV,
+    AV_CODEC_ID_CYUV,
+    AV_CODEC_ID_H264,
+    AV_CODEC_ID_INDEO3,
+    AV_CODEC_ID_VP3,
+    AV_CODEC_ID_THEORA,
+    AV_CODEC_ID_ASV1,
+    AV_CODEC_ID_ASV2,
+    AV_CODEC_ID_FFV1,
+    AV_CODEC_ID_4XM,
+    AV_CODEC_ID_VCR1,
+    AV_CODEC_ID_CLJR,
+    AV_CODEC_ID_MDEC,
+    AV_CODEC_ID_ROQ,
+    AV_CODEC_ID_INTERPLAY_VIDEO,
+    AV_CODEC_ID_XAN_WC3,
+    AV_CODEC_ID_XAN_WC4,
+    AV_CODEC_ID_RPZA,
+    AV_CODEC_ID_CINEPAK,
+    AV_CODEC_ID_WS_VQA,
+    AV_CODEC_ID_MSRLE,
+    AV_CODEC_ID_MSVIDEO1,
+    AV_CODEC_ID_IDCIN,
+    AV_CODEC_ID_8BPS,
+    AV_CODEC_ID_SMC,
+    AV_CODEC_ID_FLIC,
+    AV_CODEC_ID_TRUEMOTION1,
+    AV_CODEC_ID_VMDVIDEO,
+    AV_CODEC_ID_MSZH,
+    AV_CODEC_ID_ZLIB,
+    AV_CODEC_ID_QTRLE,
+    AV_CODEC_ID_TSCC,
+    AV_CODEC_ID_ULTI,
+    AV_CODEC_ID_QDRAW,
+    AV_CODEC_ID_VIXL,
+    AV_CODEC_ID_QPEG,
+    AV_CODEC_ID_PNG,
+    AV_CODEC_ID_PPM,
+    AV_CODEC_ID_PBM,
+    AV_CODEC_ID_PGM,
+    AV_CODEC_ID_PGMYUV,
+    AV_CODEC_ID_PAM,
+    AV_CODEC_ID_FFVHUFF,
+    AV_CODEC_ID_RV30,
+    AV_CODEC_ID_RV40,
+    AV_CODEC_ID_VC1,
+    AV_CODEC_ID_WMV3,
+    AV_CODEC_ID_LOCO,
+    AV_CODEC_ID_WNV1,
+    AV_CODEC_ID_AASC,
+    AV_CODEC_ID_INDEO2,
+    AV_CODEC_ID_FRAPS,
+    AV_CODEC_ID_TRUEMOTION2,
+    AV_CODEC_ID_BMP,
+    AV_CODEC_ID_CSCD,
+    AV_CODEC_ID_MMVIDEO,
+    AV_CODEC_ID_ZMBV,
+    AV_CODEC_ID_AVS,
+    AV_CODEC_ID_SMACKVIDEO,
+    AV_CODEC_ID_NUV,
+    AV_CODEC_ID_KMVC,
+    AV_CODEC_ID_FLASHSV,
+    AV_CODEC_ID_CAVS,
+    AV_CODEC_ID_JPEG2000,
+    AV_CODEC_ID_VMNC,
+    AV_CODEC_ID_VP5,
+    AV_CODEC_ID_VP6,
+    AV_CODEC_ID_VP6F,
+    AV_CODEC_ID_TARGA,
+    AV_CODEC_ID_DSICINVIDEO,
+    AV_CODEC_ID_TIERTEXSEQVIDEO,
+    AV_CODEC_ID_TIFF,
+    AV_CODEC_ID_GIF,
+    AV_CODEC_ID_DXA,
+    AV_CODEC_ID_DNXHD,
+    AV_CODEC_ID_THP,
+    AV_CODEC_ID_SGI,
+    AV_CODEC_ID_C93,
+    AV_CODEC_ID_BETHSOFTVID,
+    AV_CODEC_ID_PTX,
+    AV_CODEC_ID_TXD,
+    AV_CODEC_ID_VP6A,
+    AV_CODEC_ID_AMV,
+    AV_CODEC_ID_VB,
+    AV_CODEC_ID_PCX,
+    AV_CODEC_ID_SUNRAST,
+    AV_CODEC_ID_INDEO4,
+    AV_CODEC_ID_INDEO5,
+    AV_CODEC_ID_MIMIC,
+    AV_CODEC_ID_RL2,
+    AV_CODEC_ID_ESCAPE124,
+    AV_CODEC_ID_DIRAC,
+    AV_CODEC_ID_BFI,
+    AV_CODEC_ID_CMV,
+    AV_CODEC_ID_MOTIONPIXELS,
+    AV_CODEC_ID_TGV,
+    AV_CODEC_ID_TGQ,
+    AV_CODEC_ID_TQI,
+    AV_CODEC_ID_AURA,
+    AV_CODEC_ID_AURA2,
+    AV_CODEC_ID_V210X,
+    AV_CODEC_ID_TMV,
+    AV_CODEC_ID_V210,
+    AV_CODEC_ID_DPX,
+    AV_CODEC_ID_MAD,
+    AV_CODEC_ID_FRWU,
+    AV_CODEC_ID_FLASHSV2,
+    AV_CODEC_ID_CDGRAPHICS,
+    AV_CODEC_ID_R210,
+    AV_CODEC_ID_ANM,
+    AV_CODEC_ID_BINKVIDEO,
+    AV_CODEC_ID_IFF_ILBM,
+#define AV_CODEC_ID_IFF_BYTERUN1 AV_CODEC_ID_IFF_ILBM
+    AV_CODEC_ID_KGV1,
+    AV_CODEC_ID_YOP,
+    AV_CODEC_ID_VP8,
+    AV_CODEC_ID_PICTOR,
+    AV_CODEC_ID_ANSI,
+    AV_CODEC_ID_A64_MULTI,
+    AV_CODEC_ID_A64_MULTI5,
+    AV_CODEC_ID_R10K,
+    AV_CODEC_ID_MXPEG,
+    AV_CODEC_ID_LAGARITH,
+    AV_CODEC_ID_PRORES,
+    AV_CODEC_ID_JV,
+    AV_CODEC_ID_DFA,
+    AV_CODEC_ID_WMV3IMAGE,
+    AV_CODEC_ID_VC1IMAGE,
+    AV_CODEC_ID_UTVIDEO,
+    AV_CODEC_ID_BMV_VIDEO,
+    AV_CODEC_ID_VBLE,
+    AV_CODEC_ID_DXTORY,
+    AV_CODEC_ID_V410,
+    AV_CODEC_ID_XWD,
+    AV_CODEC_ID_CDXL,
+    AV_CODEC_ID_XBM,
+    AV_CODEC_ID_ZEROCODEC,
+    AV_CODEC_ID_MSS1,
+    AV_CODEC_ID_MSA1,
+    AV_CODEC_ID_TSCC2,
+    AV_CODEC_ID_MTS2,
+    AV_CODEC_ID_CLLC,
+    AV_CODEC_ID_MSS2,
+    AV_CODEC_ID_VP9,
+    AV_CODEC_ID_AIC,
+    AV_CODEC_ID_ESCAPE130,
+    AV_CODEC_ID_G2M,
+    AV_CODEC_ID_WEBP,
+    AV_CODEC_ID_HNM4_VIDEO,
+    AV_CODEC_ID_HEVC,
+#define AV_CODEC_ID_H265 AV_CODEC_ID_HEVC
+    AV_CODEC_ID_FIC,
+    AV_CODEC_ID_ALIAS_PIX,
+    AV_CODEC_ID_BRENDER_PIX,
+    AV_CODEC_ID_PAF_VIDEO,
+    AV_CODEC_ID_EXR,
+    AV_CODEC_ID_VP7,
+    AV_CODEC_ID_SANM,
+    AV_CODEC_ID_SGIRLE,
+    AV_CODEC_ID_MVC1,
+    AV_CODEC_ID_MVC2,
+    AV_CODEC_ID_HQX,
+    AV_CODEC_ID_TDSC,
+    AV_CODEC_ID_HQ_HQA,
+    AV_CODEC_ID_HAP,
+    AV_CODEC_ID_DDS,
+    AV_CODEC_ID_DXV,
+    AV_CODEC_ID_SCREENPRESSO,
+    AV_CODEC_ID_RSCC,
+    AV_CODEC_ID_AVS2,
+
+    AV_CODEC_ID_Y41P = 0x8000,
+    AV_CODEC_ID_AVRP,
+    AV_CODEC_ID_012V,
+    AV_CODEC_ID_AVUI,
+    AV_CODEC_ID_AYUV,
+    AV_CODEC_ID_TARGA_Y216,
+    AV_CODEC_ID_V308,
+    AV_CODEC_ID_V408,
+    AV_CODEC_ID_YUV4,
+    AV_CODEC_ID_AVRN,
+    AV_CODEC_ID_CPIA,
+    AV_CODEC_ID_XFACE,
+    AV_CODEC_ID_SNOW,
+    AV_CODEC_ID_SMVJPEG,
+    AV_CODEC_ID_APNG,
+    AV_CODEC_ID_DAALA,
+    AV_CODEC_ID_CFHD,
+    AV_CODEC_ID_TRUEMOTION2RT,
+    AV_CODEC_ID_M101,
+    AV_CODEC_ID_MAGICYUV,
+    AV_CODEC_ID_SHEERVIDEO,
+    AV_CODEC_ID_YLC,
+    AV_CODEC_ID_PSD,
+    AV_CODEC_ID_PIXLET,
+    AV_CODEC_ID_SPEEDHQ,
+    AV_CODEC_ID_FMVC,
+    AV_CODEC_ID_SCPR,
+    AV_CODEC_ID_CLEARVIDEO,
+    AV_CODEC_ID_XPM,
+    AV_CODEC_ID_AV1,
+    AV_CODEC_ID_BITPACKED,
+    AV_CODEC_ID_MSCC,
+    AV_CODEC_ID_SRGC,
+    AV_CODEC_ID_SVG,
+    AV_CODEC_ID_GDV,
+    AV_CODEC_ID_FITS,
+    AV_CODEC_ID_IMM4,
+    AV_CODEC_ID_PROSUMER,
+    AV_CODEC_ID_MWSC,
+    AV_CODEC_ID_WCMV,
+    AV_CODEC_ID_RASC,
+    AV_CODEC_ID_HYMT,
+    AV_CODEC_ID_ARBC,
+    AV_CODEC_ID_AGM,
+    AV_CODEC_ID_LSCR,
+    AV_CODEC_ID_VP4,
+    AV_CODEC_ID_IMM5,
+    AV_CODEC_ID_MVDV,
+    AV_CODEC_ID_MVHA,
+    AV_CODEC_ID_CDTOONS,
+    AV_CODEC_ID_MV30,
+    AV_CODEC_ID_NOTCHLC,
+    AV_CODEC_ID_PFM,
+
+    /* various PCM "codecs" */
+    AV_CODEC_ID_FIRST_AUDIO = 0x10000,     ///< A dummy id pointing at the start of audio codecs
+    AV_CODEC_ID_PCM_S16LE = 0x10000,
+    AV_CODEC_ID_PCM_S16BE,
+    AV_CODEC_ID_PCM_U16LE,
+    AV_CODEC_ID_PCM_U16BE,
+    AV_CODEC_ID_PCM_S8,
+    AV_CODEC_ID_PCM_U8,
+    AV_CODEC_ID_PCM_MULAW,
+    AV_CODEC_ID_PCM_ALAW,
+    AV_CODEC_ID_PCM_S32LE,
+    AV_CODEC_ID_PCM_S32BE,
+    AV_CODEC_ID_PCM_U32LE,
+    AV_CODEC_ID_PCM_U32BE,
+    AV_CODEC_ID_PCM_S24LE,
+    AV_CODEC_ID_PCM_S24BE,
+    AV_CODEC_ID_PCM_U24LE,
+    AV_CODEC_ID_PCM_U24BE,
+    AV_CODEC_ID_PCM_S24DAUD,
+    AV_CODEC_ID_PCM_ZORK,
+    AV_CODEC_ID_PCM_S16LE_PLANAR,
+    AV_CODEC_ID_PCM_DVD,
+    AV_CODEC_ID_PCM_F32BE,
+    AV_CODEC_ID_PCM_F32LE,
+    AV_CODEC_ID_PCM_F64BE,
+    AV_CODEC_ID_PCM_F64LE,
+    AV_CODEC_ID_PCM_BLURAY,
+    AV_CODEC_ID_PCM_LXF,
+    AV_CODEC_ID_S302M,
+    AV_CODEC_ID_PCM_S8_PLANAR,
+    AV_CODEC_ID_PCM_S24LE_PLANAR,
+    AV_CODEC_ID_PCM_S32LE_PLANAR,
+    AV_CODEC_ID_PCM_S16BE_PLANAR,
+
+    AV_CODEC_ID_PCM_S64LE = 0x10800,
+    AV_CODEC_ID_PCM_S64BE,
+    AV_CODEC_ID_PCM_F16LE,
+    AV_CODEC_ID_PCM_F24LE,
+    AV_CODEC_ID_PCM_VIDC,
+
+    /* various ADPCM codecs */
+    AV_CODEC_ID_ADPCM_IMA_QT = 0x11000,
+    AV_CODEC_ID_ADPCM_IMA_WAV,
+    AV_CODEC_ID_ADPCM_IMA_DK3,
+    AV_CODEC_ID_ADPCM_IMA_DK4,
+    AV_CODEC_ID_ADPCM_IMA_WS,
+    AV_CODEC_ID_ADPCM_IMA_SMJPEG,
+    AV_CODEC_ID_ADPCM_MS,
+    AV_CODEC_ID_ADPCM_4XM,
+    AV_CODEC_ID_ADPCM_XA,
+    AV_CODEC_ID_ADPCM_ADX,
+    AV_CODEC_ID_ADPCM_EA,
+    AV_CODEC_ID_ADPCM_G726,
+    AV_CODEC_ID_ADPCM_CT,
+    AV_CODEC_ID_ADPCM_SWF,
+    AV_CODEC_ID_ADPCM_YAMAHA,
+    AV_CODEC_ID_ADPCM_SBPRO_4,
+    AV_CODEC_ID_ADPCM_SBPRO_3,
+    AV_CODEC_ID_ADPCM_SBPRO_2,
+    AV_CODEC_ID_ADPCM_THP,
+    AV_CODEC_ID_ADPCM_IMA_AMV,
+    AV_CODEC_ID_ADPCM_EA_R1,
+    AV_CODEC_ID_ADPCM_EA_R3,
+    AV_CODEC_ID_ADPCM_EA_R2,
+    AV_CODEC_ID_ADPCM_IMA_EA_SEAD,
+    AV_CODEC_ID_ADPCM_IMA_EA_EACS,
+    AV_CODEC_ID_ADPCM_EA_XAS,
+    AV_CODEC_ID_ADPCM_EA_MAXIS_XA,
+    AV_CODEC_ID_ADPCM_IMA_ISS,
+    AV_CODEC_ID_ADPCM_G722,
+    AV_CODEC_ID_ADPCM_IMA_APC,
+    AV_CODEC_ID_ADPCM_VIMA,
+
+    AV_CODEC_ID_ADPCM_AFC = 0x11800,
+    AV_CODEC_ID_ADPCM_IMA_OKI,
+    AV_CODEC_ID_ADPCM_DTK,
+    AV_CODEC_ID_ADPCM_IMA_RAD,
+    AV_CODEC_ID_ADPCM_G726LE,
+    AV_CODEC_ID_ADPCM_THP_LE,
+    AV_CODEC_ID_ADPCM_PSX,
+    AV_CODEC_ID_ADPCM_AICA,
+    AV_CODEC_ID_ADPCM_IMA_DAT4,
+    AV_CODEC_ID_ADPCM_MTAF,
+    AV_CODEC_ID_ADPCM_AGM,
+    AV_CODEC_ID_ADPCM_ARGO,
+    AV_CODEC_ID_ADPCM_IMA_SSI,
+    AV_CODEC_ID_ADPCM_ZORK,
+    AV_CODEC_ID_ADPCM_IMA_APM,
+    AV_CODEC_ID_ADPCM_IMA_ALP,
+    AV_CODEC_ID_ADPCM_IMA_MTF,
+    AV_CODEC_ID_ADPCM_IMA_CUNNING,
+
+    /* AMR */
+    AV_CODEC_ID_AMR_NB = 0x12000,
+    AV_CODEC_ID_AMR_WB,
+
+    /* RealAudio codecs*/
+    AV_CODEC_ID_RA_144 = 0x13000,
+    AV_CODEC_ID_RA_288,
+
+    /* various DPCM codecs */
+    AV_CODEC_ID_ROQ_DPCM = 0x14000,
+    AV_CODEC_ID_INTERPLAY_DPCM,
+    AV_CODEC_ID_XAN_DPCM,
+    AV_CODEC_ID_SOL_DPCM,
+
+    AV_CODEC_ID_SDX2_DPCM = 0x14800,
+    AV_CODEC_ID_GREMLIN_DPCM,
+    AV_CODEC_ID_DERF_DPCM,
+
+    /* audio codecs */
+    AV_CODEC_ID_MP2 = 0x15000,
+    AV_CODEC_ID_MP3, ///< preferred ID for decoding MPEG audio layer 1, 2 or 3
+    AV_CODEC_ID_AAC,
+    AV_CODEC_ID_AC3,
+    AV_CODEC_ID_DTS,
+    AV_CODEC_ID_VORBIS,
+    AV_CODEC_ID_DVAUDIO,
+    AV_CODEC_ID_WMAV1,
+    AV_CODEC_ID_WMAV2,
+    AV_CODEC_ID_MACE3,
+    AV_CODEC_ID_MACE6,
+    AV_CODEC_ID_VMDAUDIO,
+    AV_CODEC_ID_FLAC,
+    AV_CODEC_ID_MP3ADU,
+    AV_CODEC_ID_MP3ON4,
+    AV_CODEC_ID_SHORTEN,
+    AV_CODEC_ID_ALAC,
+    AV_CODEC_ID_WESTWOOD_SND1,
+    AV_CODEC_ID_GSM, ///< as in Berlin toast format
+    AV_CODEC_ID_QDM2,
+    AV_CODEC_ID_COOK,
+    AV_CODEC_ID_TRUESPEECH,
+    AV_CODEC_ID_TTA,
+    AV_CODEC_ID_SMACKAUDIO,
+    AV_CODEC_ID_QCELP,
+    AV_CODEC_ID_WAVPACK,
+    AV_CODEC_ID_DSICINAUDIO,
+    AV_CODEC_ID_IMC,
+    AV_CODEC_ID_MUSEPACK7,
+    AV_CODEC_ID_MLP,
+    AV_CODEC_ID_GSM_MS, /* as found in WAV */
+    AV_CODEC_ID_ATRAC3,
+    AV_CODEC_ID_APE,
+    AV_CODEC_ID_NELLYMOSER,
+    AV_CODEC_ID_MUSEPACK8,
+    AV_CODEC_ID_SPEEX,
+    AV_CODEC_ID_WMAVOICE,
+    AV_CODEC_ID_WMAPRO,
+    AV_CODEC_ID_WMALOSSLESS,
+    AV_CODEC_ID_ATRAC3P,
+    AV_CODEC_ID_EAC3,
+    AV_CODEC_ID_SIPR,
+    AV_CODEC_ID_MP1,
+    AV_CODEC_ID_TWINVQ,
+    AV_CODEC_ID_TRUEHD,
+    AV_CODEC_ID_MP4ALS,
+    AV_CODEC_ID_ATRAC1,
+    AV_CODEC_ID_BINKAUDIO_RDFT,
+    AV_CODEC_ID_BINKAUDIO_DCT,
+    AV_CODEC_ID_AAC_LATM,
+    AV_CODEC_ID_QDMC,
+    AV_CODEC_ID_CELT,
+    AV_CODEC_ID_G723_1,
+    AV_CODEC_ID_G729,
+    AV_CODEC_ID_8SVX_EXP,
+    AV_CODEC_ID_8SVX_FIB,
+    AV_CODEC_ID_BMV_AUDIO,
+    AV_CODEC_ID_RALF,
+    AV_CODEC_ID_IAC,
+    AV_CODEC_ID_ILBC,
+    AV_CODEC_ID_OPUS,
+    AV_CODEC_ID_COMFORT_NOISE,
+    AV_CODEC_ID_TAK,
+    AV_CODEC_ID_METASOUND,
+    AV_CODEC_ID_PAF_AUDIO,
+    AV_CODEC_ID_ON2AVC,
+    AV_CODEC_ID_DSS_SP,
+    AV_CODEC_ID_CODEC2,
+
+    AV_CODEC_ID_FFWAVESYNTH = 0x15800,
+    AV_CODEC_ID_SONIC,
+    AV_CODEC_ID_SONIC_LS,
+    AV_CODEC_ID_EVRC,
+    AV_CODEC_ID_SMV,
+    AV_CODEC_ID_DSD_LSBF,
+    AV_CODEC_ID_DSD_MSBF,
+    AV_CODEC_ID_DSD_LSBF_PLANAR,
+    AV_CODEC_ID_DSD_MSBF_PLANAR,
+    AV_CODEC_ID_4GV,
+    AV_CODEC_ID_INTERPLAY_ACM,
+    AV_CODEC_ID_XMA1,
+    AV_CODEC_ID_XMA2,
+    AV_CODEC_ID_DST,
+    AV_CODEC_ID_ATRAC3AL,
+    AV_CODEC_ID_ATRAC3PAL,
+    AV_CODEC_ID_DOLBY_E,
+    AV_CODEC_ID_APTX,
+    AV_CODEC_ID_APTX_HD,
+    AV_CODEC_ID_SBC,
+    AV_CODEC_ID_ATRAC9,
+    AV_CODEC_ID_HCOM,
+    AV_CODEC_ID_ACELP_KELVIN,
+    AV_CODEC_ID_MPEGH_3D_AUDIO,
+    AV_CODEC_ID_SIREN,
+    AV_CODEC_ID_HCA,
+
+    /* subtitle codecs */
+    AV_CODEC_ID_FIRST_SUBTITLE = 0x17000,          ///< A dummy ID pointing at the start of subtitle codecs.
+    AV_CODEC_ID_DVD_SUBTITLE = 0x17000,
+    AV_CODEC_ID_DVB_SUBTITLE,
+    AV_CODEC_ID_TEXT,  ///< raw UTF-8 text
+    AV_CODEC_ID_XSUB,
+    AV_CODEC_ID_SSA,
+    AV_CODEC_ID_MOV_TEXT,
+    AV_CODEC_ID_HDMV_PGS_SUBTITLE,
+    AV_CODEC_ID_DVB_TELETEXT,
+    AV_CODEC_ID_SRT,
+
+    AV_CODEC_ID_MICRODVD   = 0x17800,
+    AV_CODEC_ID_EIA_608,
+    AV_CODEC_ID_JACOSUB,
+    AV_CODEC_ID_SAMI,
+    AV_CODEC_ID_REALTEXT,
+    AV_CODEC_ID_STL,
+    AV_CODEC_ID_SUBVIEWER1,
+    AV_CODEC_ID_SUBVIEWER,
+    AV_CODEC_ID_SUBRIP,
+    AV_CODEC_ID_WEBVTT,
+    AV_CODEC_ID_MPL2,
+    AV_CODEC_ID_VPLAYER,
+    AV_CODEC_ID_PJS,
+    AV_CODEC_ID_ASS,
+    AV_CODEC_ID_HDMV_TEXT_SUBTITLE,
+    AV_CODEC_ID_TTML,
+    AV_CODEC_ID_ARIB_CAPTION,
+
+    /* other specific kind of codecs (generally used for attachments) */
+    AV_CODEC_ID_FIRST_UNKNOWN = 0x18000,           ///< A dummy ID pointing at the start of various fake codecs.
+    AV_CODEC_ID_TTF = 0x18000,
+
+    AV_CODEC_ID_SCTE_35, ///< Contain timestamp estimated through PCR of program stream.
+    AV_CODEC_ID_EPG,
+    AV_CODEC_ID_BINTEXT    = 0x18800,
+    AV_CODEC_ID_XBIN,
+    AV_CODEC_ID_IDF,
+    AV_CODEC_ID_OTF,
+    AV_CODEC_ID_SMPTE_KLV,
+    AV_CODEC_ID_DVD_NAV,
+    AV_CODEC_ID_TIMED_ID3,
+    AV_CODEC_ID_BIN_DATA,
+
+
+    AV_CODEC_ID_PROBE = 0x19000, ///< codec_id is not known (like AV_CODEC_ID_NONE) but lavf should attempt to identify it
+
+    AV_CODEC_ID_MPEG2TS = 0x20000, /**< _FAKE_ codec to indicate a raw MPEG-2 TS
+                                * stream (only used by libavformat) */
+    AV_CODEC_ID_MPEG4SYSTEMS = 0x20001, /**< _FAKE_ codec to indicate a MPEG-4 Systems
+                                * stream (only used by libavformat) */
+    AV_CODEC_ID_FFMETADATA = 0x21000,   ///< Dummy codec for streams containing only metadata information.
+    AV_CODEC_ID_WRAPPED_AVFRAME = 0x21001, ///< Passthrough codec, AVFrames wrapped in AVPacket
+};
+
+/**
+ * Get the type of the given codec.
+ */
+enum AVMediaType avcodec_get_type(enum AVCodecID codec_id);
+
+/**
+ * Get the name of a codec.
+ * @return  a static string identifying the codec; never NULL
+ */
+const char *avcodec_get_name(enum AVCodecID id);
+
+/**
+ * @}
+ */
+
+#endif // AVCODEC_CODEC_ID_H

ffmpeg-n4.3.2-win64-gpl-shared-4.3/include/libavcodec/codec_par.h

@@ -0,0 +1,229 @@
+/*
+ * Codec parameters public API
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_CODEC_PAR_H
+#define AVCODEC_CODEC_PAR_H
+
+#include <stdint.h>
+
+#include "libavutil/avutil.h"
+#include "libavutil/rational.h"
+#include "libavutil/pixfmt.h"
+
+#include "codec_id.h"
+
+/**
+ * @addtogroup lavc_core
+ */
+
+enum AVFieldOrder {
+    AV_FIELD_UNKNOWN,
+    AV_FIELD_PROGRESSIVE,
+    AV_FIELD_TT,          //< Top coded_first, top displayed first
+    AV_FIELD_BB,          //< Bottom coded first, bottom displayed first
+    AV_FIELD_TB,          //< Top coded first, bottom displayed first
+    AV_FIELD_BT,          //< Bottom coded first, top displayed first
+};
+
+/**
+ * This struct describes the properties of an encoded stream.
+ *
+ * sizeof(AVCodecParameters) is not a part of the public ABI, this struct must
+ * be allocated with avcodec_parameters_alloc() and freed with
+ * avcodec_parameters_free().
+ */
+typedef struct AVCodecParameters {
+    /**
+     * General type of the encoded data.
+     */
+    enum AVMediaType codec_type;
+    /**
+     * Specific type of the encoded data (the codec used).
+     */
+    enum AVCodecID   codec_id;
+    /**
+     * Additional information about the codec (corresponds to the AVI FOURCC).
+     */
+    uint32_t         codec_tag;
+
+    /**
+     * Extra binary data needed for initializing the decoder, codec-dependent.
+     *
+     * Must be allocated with av_malloc() and will be freed by
+     * avcodec_parameters_free(). The allocated size of extradata must be at
+     * least extradata_size + AV_INPUT_BUFFER_PADDING_SIZE, with the padding
+     * bytes zeroed.
+     */
+    uint8_t *extradata;
+    /**
+     * Size of the extradata content in bytes.
+     */
+    int      extradata_size;
+
+    /**
+     * - video: the pixel format, the value corresponds to enum AVPixelFormat.
+     * - audio: the sample format, the value corresponds to enum AVSampleFormat.
+     */
+    int format;
+
+    /**
+     * The average bitrate of the encoded data (in bits per second).
+     */
+    int64_t bit_rate;
+
+    /**
+     * The number of bits per sample in the codedwords.
+     *
+     * This is basically the bitrate per sample. It is mandatory for a bunch of
+     * formats to actually decode them. It's the number of bits for one sample in
+     * the actual coded bitstream.
+     *
+     * This could be for example 4 for ADPCM
+     * For PCM formats this matches bits_per_raw_sample
+     * Can be 0
+     */
+    int bits_per_coded_sample;
+
+    /**
+     * This is the number of valid bits in each output sample. If the
+     * sample format has more bits, the least significant bits are additional
+     * padding bits, which are always 0. Use right shifts to reduce the sample
+     * to its actual size. For example, audio formats with 24 bit samples will
+     * have bits_per_raw_sample set to 24, and format set to AV_SAMPLE_FMT_S32.
+     * To get the original sample use "(int32_t)sample >> 8"."
+     *
+     * For ADPCM this might be 12 or 16 or similar
+     * Can be 0
+     */
+    int bits_per_raw_sample;
+
+    /**
+     * Codec-specific bitstream restrictions that the stream conforms to.
+     */
+    int profile;
+    int level;
+
+    /**
+     * Video only. The dimensions of the video frame in pixels.
+     */
+    int width;
+    int height;
+
+    /**
+     * Video only. The aspect ratio (width / height) which a single pixel
+     * should have when displayed.
+     *
+     * When the aspect ratio is unknown / undefined, the numerator should be
+     * set to 0 (the denominator may have any value).
+     */
+    AVRational sample_aspect_ratio;
+
+    /**
+     * Video only. The order of the fields in interlaced video.
+     */
+    enum AVFieldOrder                  field_order;
+
+    /**
+     * Video only. Additional colorspace characteristics.
+     */
+    enum AVColorRange                  color_range;
+    enum AVColorPrimaries              color_primaries;
+    enum AVColorTransferCharacteristic color_trc;
+    enum AVColorSpace                  color_space;
+    enum AVChromaLocation              chroma_location;
+
+    /**
+     * Video only. Number of delayed frames.
+     */
+    int video_delay;
+
+    /**
+     * Audio only. The channel layout bitmask. May be 0 if the channel layout is
+     * unknown or unspecified, otherwise the number of bits set must be equal to
+     * the channels field.
+     */
+    uint64_t channel_layout;
+    /**
+     * Audio only. The number of audio channels.
+     */
+    int      channels;
+    /**
+     * Audio only. The number of audio samples per second.
+     */
+    int      sample_rate;
+    /**
+     * Audio only. The number of bytes per coded audio frame, required by some
+     * formats.
+     *
+     * Corresponds to nBlockAlign in WAVEFORMATEX.
+     */
+    int      block_align;
+    /**
+     * Audio only. Audio frame size, if known. Required by some formats to be static.
+     */
+    int      frame_size;
+
+    /**
+     * Audio only. The amount of padding (in samples) inserted by the encoder at
+     * the beginning of the audio. I.e. this number of leading decoded samples
+     * must be discarded by the caller to get the original audio without leading
+     * padding.
+     */
+    int initial_padding;
+    /**
+     * Audio only. The amount of padding (in samples) appended by the encoder to
+     * the end of the audio. I.e. this number of decoded samples must be
+     * discarded by the caller from the end of the stream to get the original
+     * audio without any trailing padding.
+     */
+    int trailing_padding;
+    /**
+     * Audio only. Number of samples to skip after a discontinuity.
+     */
+    int seek_preroll;
+} AVCodecParameters;
+
+/**
+ * Allocate a new AVCodecParameters and set its fields to default values
+ * (unknown/invalid/0). The returned struct must be freed with
+ * avcodec_parameters_free().
+ */
+AVCodecParameters *avcodec_parameters_alloc(void);
+
+/**
+ * Free an AVCodecParameters instance and everything associated with it and
+ * write NULL to the supplied pointer.
+ */
+void avcodec_parameters_free(AVCodecParameters **par);
+
+/**
+ * Copy the contents of src to dst. Any allocated fields in dst are freed and
+ * replaced with newly allocated duplicates of the corresponding fields in src.
+ *
+ * @return >= 0 on success, a negative AVERROR code on failure.
+ */
+int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src);
+
+
+/**
+ * @}
+ */
+
+#endif // AVCODEC_CODEC_PAR_H

ffmpeg-n4.3.2-win64-gpl-shared-4.3/include/libavcodec/d3d11va.h

@@ -0,0 +1,112 @@
+/*
+ * Direct3D11 HW acceleration
+ *
+ * copyright (c) 2009 Laurent Aimar
+ * copyright (c) 2015 Steve Lhomme
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_D3D11VA_H
+#define AVCODEC_D3D11VA_H
+
+/**
+ * @file
+ * @ingroup lavc_codec_hwaccel_d3d11va
+ * Public libavcodec D3D11VA header.
+ */
+
+#if !defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0602
+#undef _WIN32_WINNT
+#define _WIN32_WINNT 0x0602
+#endif
+
+#include <stdint.h>
+#include <d3d11.h>
+
+/**
+ * @defgroup lavc_codec_hwaccel_d3d11va Direct3D11
+ * @ingroup lavc_codec_hwaccel
+ *
+ * @{
+ */
+
+#define FF_DXVA2_WORKAROUND_SCALING_LIST_ZIGZAG 1 ///< Work around for Direct3D11 and old UVD/UVD+ ATI video cards
+#define FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO    2 ///< Work around for Direct3D11 and old Intel GPUs with ClearVideo interface
+
+/**
+ * This structure is used to provides the necessary configurations and data
+ * to the Direct3D11 FFmpeg HWAccel implementation.
+ *
+ * The application must make it available as AVCodecContext.hwaccel_context.
+ *
+ * Use av_d3d11va_alloc_context() exclusively to allocate an AVD3D11VAContext.
+ */
+typedef struct AVD3D11VAContext {
+    /**
+     * D3D11 decoder object
+     */
+    ID3D11VideoDecoder *decoder;
+
+    /**
+      * D3D11 VideoContext
+      */
+    ID3D11VideoContext *video_context;
+
+    /**
+     * D3D11 configuration used to create the decoder
+     */
+    D3D11_VIDEO_DECODER_CONFIG *cfg;
+
+    /**
+     * The number of surface in the surface array
+     */
+    unsigned surface_count;
+
+    /**
+     * The array of Direct3D surfaces used to create the decoder
+     */
+    ID3D11VideoDecoderOutputView **surface;
+
+    /**
+     * A bit field configuring the workarounds needed for using the decoder
+     */
+    uint64_t workaround;
+
+    /**
+     * Private to the FFmpeg AVHWAccel implementation
+     */
+    unsigned report_id;
+
+    /**
+      * Mutex to access video_context
+      */
+    HANDLE  context_mutex;
+} AVD3D11VAContext;
+
+/**
+ * Allocate an AVD3D11VAContext.
+ *
+ * @return Newly-allocated AVD3D11VAContext or NULL on failure.
+ */
+AVD3D11VAContext *av_d3d11va_alloc_context(void);
+
+/**
+ * @}
+ */
+
+#endif /* AVCODEC_D3D11VA_H */

ffmpeg-n4.3.2-win64-gpl-shared-4.3/include/libavcodec/dirac.h

@@ -0,0 +1,131 @@
+/*
+ * Copyright (C) 2007 Marco Gerards <marco@gnu.org>
+ * Copyright (C) 2009 David Conrad
+ * Copyright (C) 2011 Jordi Ortiz
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_DIRAC_H
+#define AVCODEC_DIRAC_H
+
+/**
+ * @file
+ * Interface to Dirac Decoder/Encoder
+ * @author Marco Gerards <marco@gnu.org>
+ * @author David Conrad
+ * @author Jordi Ortiz
+ */
+
+#include "avcodec.h"
+
+/**
+ * The spec limits the number of wavelet decompositions to 4 for both
+ * level 1 (VC-2) and 128 (long-gop default).
+ * 5 decompositions is the maximum before >16-bit buffers are needed.
+ * Schroedinger allows this for DD 9,7 and 13,7 wavelets only, limiting
+ * the others to 4 decompositions (or 3 for the fidelity filter).
+ *
+ * We use this instead of MAX_DECOMPOSITIONS to save some memory.
+ */
+#define MAX_DWT_LEVELS 5
+
+/**
+ * Parse code values:
+ *
+ * Dirac Specification ->
+ * 9.6.1  Table 9.1
+ *
+ * VC-2 Specification  ->
+ * 10.4.1 Table 10.1
+ */
+
+enum DiracParseCodes {
+    DIRAC_PCODE_SEQ_HEADER      = 0x00,
+    DIRAC_PCODE_END_SEQ         = 0x10,
+    DIRAC_PCODE_AUX             = 0x20,
+    DIRAC_PCODE_PAD             = 0x30,
+    DIRAC_PCODE_PICTURE_CODED   = 0x08,
+    DIRAC_PCODE_PICTURE_RAW     = 0x48,
+    DIRAC_PCODE_PICTURE_LOW_DEL = 0xC8,
+    DIRAC_PCODE_PICTURE_HQ      = 0xE8,
+    DIRAC_PCODE_INTER_NOREF_CO1 = 0x0A,
+    DIRAC_PCODE_INTER_NOREF_CO2 = 0x09,
+    DIRAC_PCODE_INTER_REF_CO1   = 0x0D,
+    DIRAC_PCODE_INTER_REF_CO2   = 0x0E,
+    DIRAC_PCODE_INTRA_REF_CO    = 0x0C,
+    DIRAC_PCODE_INTRA_REF_RAW   = 0x4C,
+    DIRAC_PCODE_INTRA_REF_PICT  = 0xCC,
+    DIRAC_PCODE_MAGIC           = 0x42424344,
+};
+
+typedef struct DiracVersionInfo {
+    int major;
+    int minor;
+} DiracVersionInfo;
+
+typedef struct AVDiracSeqHeader {
+    unsigned width;
+    unsigned height;
+    uint8_t chroma_format;          ///< 0: 444  1: 422  2: 420
+
+    uint8_t interlaced;
+    uint8_t top_field_first;
+
+    uint8_t frame_rate_index;       ///< index into dirac_frame_rate[]
+    uint8_t aspect_ratio_index;     ///< index into dirac_aspect_ratio[]
+
+    uint16_t clean_width;
+    uint16_t clean_height;
+    uint16_t clean_left_offset;
+    uint16_t clean_right_offset;
+
+    uint8_t pixel_range_index;      ///< index into dirac_pixel_range_presets[]
+    uint8_t color_spec_index;       ///< index into dirac_color_spec_presets[]
+
+    int profile;
+    int level;
+
+    AVRational framerate;
+    AVRational sample_aspect_ratio;
+
+    enum AVPixelFormat pix_fmt;
+    enum AVColorRange color_range;
+    enum AVColorPrimaries color_primaries;
+    enum AVColorTransferCharacteristic color_trc;
+    enum AVColorSpace colorspace;
+
+    DiracVersionInfo version;
+    int bit_depth;
+} AVDiracSeqHeader;
+
+/**
+ * Parse a Dirac sequence header.
+ *
+ * @param dsh this function will allocate and fill an AVDiracSeqHeader struct
+ *            and write it into this pointer. The caller must free it with
+ *            av_free().
+ * @param buf the data buffer
+ * @param buf_size the size of the data buffer in bytes
+ * @param log_ctx if non-NULL, this function will log errors here
+ * @return 0 on success, a negative AVERROR code on failure
+ */
+int av_dirac_parse_sequence_header(AVDiracSeqHeader **dsh,
+                                   const uint8_t *buf, size_t buf_size,
+                                   void *log_ctx);
+
+#endif /* AVCODEC_DIRAC_H */

ffmpeg-n4.3.2-win64-gpl-shared-4.3/include/libavcodec/dv_profile.h

@@ -0,0 +1,83 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_DV_PROFILE_H
+#define AVCODEC_DV_PROFILE_H
+
+#include <stdint.h>
+
+#include "libavutil/pixfmt.h"
+#include "libavutil/rational.h"
+#include "avcodec.h"
+
+/* minimum number of bytes to read from a DV stream in order to
+ * determine the profile */
+#define DV_PROFILE_BYTES (6 * 80) /* 6 DIF blocks */
+
+
+/*
+ * AVDVProfile is used to express the differences between various
+ * DV flavors. For now it's primarily used for differentiating
+ * 525/60 and 625/50, but the plans are to use it for various
+ * DV specs as well (e.g. SMPTE314M vs. IEC 61834).
+ */
+typedef struct AVDVProfile {
+    int              dsf;                   /* value of the dsf in the DV header */
+    int              video_stype;           /* stype for VAUX source pack */
+    int              frame_size;            /* total size of one frame in bytes */
+    int              difseg_size;           /* number of DIF segments per DIF channel */
+    int              n_difchan;             /* number of DIF channels per frame */
+    AVRational       time_base;             /* 1/framerate */
+    int              ltc_divisor;           /* FPS from the LTS standpoint */
+    int              height;                /* picture height in pixels */
+    int              width;                 /* picture width in pixels */
+    AVRational       sar[2];                /* sample aspect ratios for 4:3 and 16:9 */
+    enum AVPixelFormat pix_fmt;             /* picture pixel format */
+    int              bpm;                   /* blocks per macroblock */
+    const uint8_t   *block_sizes;           /* AC block sizes, in bits */
+    int              audio_stride;          /* size of audio_shuffle table */
+    int              audio_min_samples[3];  /* min amount of audio samples */
+                                            /* for 48kHz, 44.1kHz and 32kHz */
+    int              audio_samples_dist[5]; /* how many samples are supposed to be */
+                                            /* in each frame in a 5 frames window */
+    const uint8_t  (*audio_shuffle)[9];     /* PCM shuffling table */
+} AVDVProfile;
+
+/**
+ * Get a DV profile for the provided compressed frame.
+ *
+ * @param sys the profile used for the previous frame, may be NULL
+ * @param frame the compressed data buffer
+ * @param buf_size size of the buffer in bytes
+ * @return the DV profile for the supplied data or NULL on failure
+ */
+const AVDVProfile *av_dv_frame_profile(const AVDVProfile *sys,
+                                       const uint8_t *frame, unsigned buf_size);
+
+/**
+ * Get a DV profile for the provided stream parameters.
+ */
+const AVDVProfile *av_dv_codec_profile(int width, int height, enum AVPixelFormat pix_fmt);
+
+/**
+ * Get a DV profile for the provided stream parameters.
+ * The frame rate is used as a best-effort parameter.
+ */
+const AVDVProfile *av_dv_codec_profile2(int width, int height, enum AVPixelFormat pix_fmt, AVRational frame_rate);
+
+#endif /* AVCODEC_DV_PROFILE_H */

ffmpeg-n4.3.2-win64-gpl-shared-4.3/include/libavcodec/dxva2.h

@@ -0,0 +1,93 @@
+/*
+ * DXVA2 HW acceleration
+ *
+ * copyright (c) 2009 Laurent Aimar
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_DXVA2_H
+#define AVCODEC_DXVA2_H
+
+/**
+ * @file
+ * @ingroup lavc_codec_hwaccel_dxva2
+ * Public libavcodec DXVA2 header.
+ */
+
+#if !defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0602
+#undef _WIN32_WINNT
+#define _WIN32_WINNT 0x0602
+#endif
+
+#include <stdint.h>
+#include <d3d9.h>
+#include <dxva2api.h>
+
+/**
+ * @defgroup lavc_codec_hwaccel_dxva2 DXVA2
+ * @ingroup lavc_codec_hwaccel
+ *
+ * @{
+ */
+
+#define FF_DXVA2_WORKAROUND_SCALING_LIST_ZIGZAG 1 ///< Work around for DXVA2 and old UVD/UVD+ ATI video cards
+#define FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO    2 ///< Work around for DXVA2 and old Intel GPUs with ClearVideo interface
+
+/**
+ * This structure is used to provides the necessary configurations and data
+ * to the DXVA2 FFmpeg HWAccel implementation.
+ *
+ * The application must make it available as AVCodecContext.hwaccel_context.
+ */
+struct dxva_context {
+    /**
+     * DXVA2 decoder object
+     */
+    IDirectXVideoDecoder *decoder;
+
+    /**
+     * DXVA2 configuration used to create the decoder
+     */
+    const DXVA2_ConfigPictureDecode *cfg;
+
+    /**
+     * The number of surface in the surface array
+     */
+    unsigned surface_count;
+
+    /**
+     * The array of Direct3D surfaces used to create the decoder
+     */
+    LPDIRECT3DSURFACE9 *surface;
+
+    /**
+     * A bit field configuring the workarounds needed for using the decoder
+     */
+    uint64_t workaround;
+
+    /**
+     * Private to the FFmpeg AVHWAccel implementation
+     */
+    unsigned report_id;
+};
+
+/**
+ * @}
+ */
+
+#endif /* AVCODEC_DXVA2_H */

ffmpeg-n4.3.2-win64-gpl-shared-4.3/include/libavcodec/jni.h

@@ -0,0 +1,46 @@
+/*
+ * JNI public API functions
+ *
+ * Copyright (c) 2015-2016 Matthieu Bouron <matthieu.bouron stupeflix.com>
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_JNI_H
+#define AVCODEC_JNI_H
+
+/*
+ * Manually set a Java virtual machine which will be used to retrieve the JNI
+ * environment. Once a Java VM is set it cannot be changed afterwards, meaning
+ * you can call multiple times av_jni_set_java_vm with the same Java VM pointer
+ * however it will error out if you try to set a different Java VM.
+ *
+ * @param vm Java virtual machine
+ * @param log_ctx context used for logging, can be NULL
+ * @return 0 on success, < 0 otherwise
+ */
+int av_jni_set_java_vm(void *vm, void *log_ctx);
+
+/*
+ * Get the Java virtual machine which has been set with av_jni_set_java_vm.
+ *
+ * @param vm Java virtual machine
+ * @return a pointer to the Java virtual machine
+ */
+void *av_jni_get_java_vm(void *log_ctx);
+
+#endif /* AVCODEC_JNI_H */

ffmpeg-n4.3.2-win64-gpl-shared-4.3/include/libavcodec/mediacodec.h

@@ -0,0 +1,101 @@
+/*
+ * Android MediaCodec public API
+ *
+ * Copyright (c) 2016 Matthieu Bouron <matthieu.bouron stupeflix.com>
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_MEDIACODEC_H
+#define AVCODEC_MEDIACODEC_H
+
+#include "libavcodec/avcodec.h"
+
+/**
+ * This structure holds a reference to a android/view/Surface object that will
+ * be used as output by the decoder.
+ *
+ */
+typedef struct AVMediaCodecContext {
+
+    /**
+     * android/view/Surface object reference.
+     */
+    void *surface;
+
+} AVMediaCodecContext;
+
+/**
+ * Allocate and initialize a MediaCodec context.
+ *
+ * When decoding with MediaCodec is finished, the caller must free the
+ * MediaCodec context with av_mediacodec_default_free.
+ *
+ * @return a pointer to a newly allocated AVMediaCodecContext on success, NULL otherwise
+ */
+AVMediaCodecContext *av_mediacodec_alloc_context(void);
+
+/**
+ * Convenience function that sets up the MediaCodec context.
+ *
+ * @param avctx codec context
+ * @param ctx MediaCodec context to initialize
+ * @param surface reference to an android/view/Surface
+ * @return 0 on success, < 0 otherwise
+ */
+int av_mediacodec_default_init(AVCodecContext *avctx, AVMediaCodecContext *ctx, void *surface);
+
+/**
+ * This function must be called to free the MediaCodec context initialized with
+ * av_mediacodec_default_init().
+ *
+ * @param avctx codec context
+ */
+void av_mediacodec_default_free(AVCodecContext *avctx);
+
+/**
+ * Opaque structure representing a MediaCodec buffer to render.
+ */
+typedef struct MediaCodecBuffer AVMediaCodecBuffer;
+
+/**
+ * Release a MediaCodec buffer and render it to the surface that is associated
+ * with the decoder. This function should only be called once on a given
+ * buffer, once released the underlying buffer returns to the codec, thus
+ * subsequent calls to this function will have no effect.
+ *
+ * @param buffer the buffer to render
+ * @param render 1 to release and render the buffer to the surface or 0 to
+ * discard the buffer
+ * @return 0 on success, < 0 otherwise
+ */
+int av_mediacodec_release_buffer(AVMediaCodecBuffer *buffer, int render);
+
+/**
+ * Release a MediaCodec buffer and render it at the given time to the surface
+ * that is associated with the decoder. The timestamp must be within one second
+ * of the current java/lang/System#nanoTime() (which is implemented using
+ * CLOCK_MONOTONIC on Android). See the Android MediaCodec documentation
+ * of android/media/MediaCodec#releaseOutputBuffer(int,long) for more details.
+ *
+ * @param buffer the buffer to render
+ * @param time timestamp in nanoseconds of when to render the buffer
+ * @return 0 on success, < 0 otherwise
+ */
+int av_mediacodec_render_buffer_at_time(AVMediaCodecBuffer *buffer, int64_t time);
+
+#endif /* AVCODEC_MEDIACODEC_H */

ffmpeg-n4.3.2-win64-gpl-shared-4.3/include/libavcodec/packet.h

@@ -0,0 +1,722 @@
+/*
+ * AVPacket public API
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_PACKET_H
+#define AVCODEC_PACKET_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "libavutil/attributes.h"
+#include "libavutil/buffer.h"
+#include "libavutil/dict.h"
+#include "libavutil/rational.h"
+
+#include "libavcodec/version.h"
+
+/**
+ * @defgroup lavc_packet AVPacket
+ *
+ * Types and functions for working with AVPacket.
+ * @{
+ */
+enum AVPacketSideDataType {
+    /**
+     * An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE
+     * bytes worth of palette. This side data signals that a new palette is
+     * present.
+     */
+    AV_PKT_DATA_PALETTE,
+
+    /**
+     * The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format
+     * that the extradata buffer was changed and the receiving side should
+     * act upon it appropriately. The new extradata is embedded in the side
+     * data buffer and should be immediately used for processing the current
+     * frame or packet.
+     */
+    AV_PKT_DATA_NEW_EXTRADATA,
+
+    /**
+     * An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows:
+     * @code
+     * u32le param_flags
+     * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT)
+     *     s32le channel_count
+     * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT)
+     *     u64le channel_layout
+     * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE)
+     *     s32le sample_rate
+     * if (param_flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS)
+     *     s32le width
+     *     s32le height
+     * @endcode
+     */
+    AV_PKT_DATA_PARAM_CHANGE,
+
+    /**
+     * An AV_PKT_DATA_H263_MB_INFO side data packet contains a number of
+     * structures with info about macroblocks relevant to splitting the
+     * packet into smaller packets on macroblock edges (e.g. as for RFC 2190).
+     * That is, it does not necessarily contain info about all macroblocks,
+     * as long as the distance between macroblocks in the info is smaller
+     * than the target payload size.
+     * Each MB info structure is 12 bytes, and is laid out as follows:
+     * @code
+     * u32le bit offset from the start of the packet
+     * u8    current quantizer at the start of the macroblock
+     * u8    GOB number
+     * u16le macroblock address within the GOB
+     * u8    horizontal MV predictor
+     * u8    vertical MV predictor
+     * u8    horizontal MV predictor for block number 3
+     * u8    vertical MV predictor for block number 3
+     * @endcode
+     */
+    AV_PKT_DATA_H263_MB_INFO,
+
+    /**
+     * This side data should be associated with an audio stream and contains
+     * ReplayGain information in form of the AVReplayGain struct.
+     */
+    AV_PKT_DATA_REPLAYGAIN,
+
+    /**
+     * This side data contains a 3x3 transformation matrix describing an affine
+     * transformation that needs to be applied to the decoded video frames for
+     * correct presentation.
+     *
+     * See libavutil/display.h for a detailed description of the data.
+     */
+    AV_PKT_DATA_DISPLAYMATRIX,
+
+    /**
+     * This side data should be associated with a video stream and contains
+     * Stereoscopic 3D information in form of the AVStereo3D struct.
+     */
+    AV_PKT_DATA_STEREO3D,
+
+    /**
+     * This side data should be associated with an audio stream and corresponds
+     * to enum AVAudioServiceType.
+     */
+    AV_PKT_DATA_AUDIO_SERVICE_TYPE,
+
+    /**
+     * This side data contains quality related information from the encoder.
+     * @code
+     * u32le quality factor of the compressed frame. Allowed range is between 1 (good) and FF_LAMBDA_MAX (bad).
+     * u8    picture type
+     * u8    error count
+     * u16   reserved
+     * u64le[error count] sum of squared differences between encoder in and output
+     * @endcode
+     */
+    AV_PKT_DATA_QUALITY_STATS,
+
+    /**
+     * This side data contains an integer value representing the stream index
+     * of a "fallback" track.  A fallback track indicates an alternate
+     * track to use when the current track can not be decoded for some reason.
+     * e.g. no decoder available for codec.
+     */
+    AV_PKT_DATA_FALLBACK_TRACK,
+
+    /**
+     * This side data corresponds to the AVCPBProperties struct.
+     */
+    AV_PKT_DATA_CPB_PROPERTIES,
+
+    /**
+     * Recommmends skipping the specified number of samples
+     * @code
+     * u32le number of samples to skip from start of this packet
+     * u32le number of samples to skip from end of this packet
+     * u8    reason for start skip
+     * u8    reason for end   skip (0=padding silence, 1=convergence)
+     * @endcode
+     */
+    AV_PKT_DATA_SKIP_SAMPLES,
+
+    /**
+     * An AV_PKT_DATA_JP_DUALMONO side data packet indicates that
+     * the packet may contain "dual mono" audio specific to Japanese DTV
+     * and if it is true, recommends only the selected channel to be used.
+     * @code
+     * u8    selected channels (0=mail/left, 1=sub/right, 2=both)
+     * @endcode
+     */
+    AV_PKT_DATA_JP_DUALMONO,
+
+    /**
+     * A list of zero terminated key/value strings. There is no end marker for
+     * the list, so it is required to rely on the side data size to stop.
+     */
+    AV_PKT_DATA_STRINGS_METADATA,
+
+    /**
+     * Subtitle event position
+     * @code
+     * u32le x1
+     * u32le y1
+     * u32le x2
+     * u32le y2
+     * @endcode
+     */
+    AV_PKT_DATA_SUBTITLE_POSITION,
+
+    /**
+     * Data found in BlockAdditional element of matroska container. There is
+     * no end marker for the data, so it is required to rely on the side data
+     * size to recognize the end. 8 byte id (as found in BlockAddId) followed
+     * by data.
+     */
+    AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL,
+
+    /**
+     * The optional first identifier line of a WebVTT cue.
+     */
+    AV_PKT_DATA_WEBVTT_IDENTIFIER,
+
+    /**
+     * The optional settings (rendering instructions) that immediately
+     * follow the timestamp specifier of a WebVTT cue.
+     */
+    AV_PKT_DATA_WEBVTT_SETTINGS,
+
+    /**
+     * A list of zero terminated key/value strings. There is no end marker for
+     * the list, so it is required to rely on the side data size to stop. This
+     * side data includes updated metadata which appeared in the stream.
+     */
+    AV_PKT_DATA_METADATA_UPDATE,
+
+    /**
+     * MPEGTS stream ID as uint8_t, this is required to pass the stream ID
+     * information from the demuxer to the corresponding muxer.
+     */
+    AV_PKT_DATA_MPEGTS_STREAM_ID,
+
+    /**
+     * Mastering display metadata (based on SMPTE-2086:2014). This metadata
+     * should be associated with a video stream and contains data in the form
+     * of the AVMasteringDisplayMetadata struct.
+     */
+    AV_PKT_DATA_MASTERING_DISPLAY_METADATA,
+
+    /**
+     * This side data should be associated with a video stream and corresponds
+     * to the AVSphericalMapping structure.
+     */
+    AV_PKT_DATA_SPHERICAL,
+
+    /**
+     * Content light level (based on CTA-861.3). This metadata should be
+     * associated with a video stream and contains data in the form of the
+     * AVContentLightMetadata struct.
+     */
+    AV_PKT_DATA_CONTENT_LIGHT_LEVEL,
+
+    /**
+     * ATSC A53 Part 4 Closed Captions. This metadata should be associated with
+     * a video stream. A53 CC bitstream is stored as uint8_t in AVPacketSideData.data.
+     * The number of bytes of CC data is AVPacketSideData.size.
+     */
+    AV_PKT_DATA_A53_CC,
+
+    /**
+     * This side data is encryption initialization data.
+     * The format is not part of ABI, use av_encryption_init_info_* methods to
+     * access.
+     */
+    AV_PKT_DATA_ENCRYPTION_INIT_INFO,
+
+    /**
+     * This side data contains encryption info for how to decrypt the packet.
+     * The format is not part of ABI, use av_encryption_info_* methods to access.
+     */
+    AV_PKT_DATA_ENCRYPTION_INFO,
+
+    /**
+     * Active Format Description data consisting of a single byte as specified
+     * in ETSI TS 101 154 using AVActiveFormatDescription enum.
+     */
+    AV_PKT_DATA_AFD,
+
+    /**
+     * Producer Reference Time data corresponding to the AVProducerReferenceTime struct,
+     * usually exported by some encoders (on demand through the prft flag set in the
+     * AVCodecContext export_side_data field).
+     */
+    AV_PKT_DATA_PRFT,
+
+    /**
+     * ICC profile data consisting of an opaque octet buffer following the
+     * format described by ISO 15076-1.
+     */
+    AV_PKT_DATA_ICC_PROFILE,
+
+    /**
+     * DOVI configuration
+     * ref:
+     * dolby-vision-bitstreams-within-the-iso-base-media-file-format-v2.1.2, section 2.2
+     * dolby-vision-bitstreams-in-mpeg-2-transport-stream-multiplex-v1.2, section 3.3
+     * Tags are stored in struct AVDOVIDecoderConfigurationRecord.
+     */
+    AV_PKT_DATA_DOVI_CONF,
+
+    /**
+     * The number of side data types.
+     * This is not part of the public API/ABI in the sense that it may
+     * change when new side data types are added.
+     * This must stay the last enum value.
+     * If its value becomes huge, some code using it
+     * needs to be updated as it assumes it to be smaller than other limits.
+     */
+    AV_PKT_DATA_NB
+};
+
+#define AV_PKT_DATA_QUALITY_FACTOR AV_PKT_DATA_QUALITY_STATS //DEPRECATED
+
+typedef struct AVPacketSideData {
+    uint8_t *data;
+    int      size;
+    enum AVPacketSideDataType type;
+} AVPacketSideData;
+
+/**
+ * This structure stores compressed data. It is typically exported by demuxers
+ * and then passed as input to decoders, or received as output from encoders and
+ * then passed to muxers.
+ *
+ * For video, it should typically contain one compressed frame. For audio it may
+ * contain several compressed frames. Encoders are allowed to output empty
+ * packets, with no compressed data, containing only side data
+ * (e.g. to update some stream parameters at the end of encoding).
+ *
+ * AVPacket is one of the few structs in FFmpeg, whose size is a part of public
+ * ABI. Thus it may be allocated on stack and no new fields can be added to it
+ * without libavcodec and libavformat major bump.
+ *
+ * The semantics of data ownership depends on the buf field.
+ * If it is set, the packet data is dynamically allocated and is
+ * valid indefinitely until a call to av_packet_unref() reduces the
+ * reference count to 0.
+ *
+ * If the buf field is not set av_packet_ref() would make a copy instead
+ * of increasing the reference count.
+ *
+ * The side data is always allocated with av_malloc(), copied by
+ * av_packet_ref() and freed by av_packet_unref().
+ *
+ * @see av_packet_ref
+ * @see av_packet_unref
+ */
+typedef struct AVPacket {
+    /**
+     * A reference to the reference-counted buffer where the packet data is
+     * stored.
+     * May be NULL, then the packet data is not reference-counted.
+     */
+    AVBufferRef *buf;
+    /**
+     * Presentation timestamp in AVStream->time_base units; the time at which
+     * the decompressed packet will be presented to the user.
+     * Can be AV_NOPTS_VALUE if it is not stored in the file.
+     * pts MUST be larger or equal to dts as presentation cannot happen before
+     * decompression, unless one wants to view hex dumps. Some formats misuse
+     * the terms dts and pts/cts to mean something different. Such timestamps
+     * must be converted to true pts/dts before they are stored in AVPacket.
+     */
+    int64_t pts;
+    /**
+     * Decompression timestamp in AVStream->time_base units; the time at which
+     * the packet is decompressed.
+     * Can be AV_NOPTS_VALUE if it is not stored in the file.
+     */
+    int64_t dts;
+    uint8_t *data;
+    int   size;
+    int   stream_index;
+    /**
+     * A combination of AV_PKT_FLAG values
+     */
+    int   flags;
+    /**
+     * Additional packet data that can be provided by the container.
+     * Packet can contain several types of side information.
+     */
+    AVPacketSideData *side_data;
+    int side_data_elems;
+
+    /**
+     * Duration of this packet in AVStream->time_base units, 0 if unknown.
+     * Equals next_pts - this_pts in presentation order.
+     */
+    int64_t duration;
+
+    int64_t pos;                            ///< byte position in stream, -1 if unknown
+
+#if FF_API_CONVERGENCE_DURATION
+    /**
+     * @deprecated Same as the duration field, but as int64_t. This was required
+     * for Matroska subtitles, whose duration values could overflow when the
+     * duration field was still an int.
+     */
+    attribute_deprecated
+    int64_t convergence_duration;
+#endif
+} AVPacket;
+
+#define AV_PKT_FLAG_KEY     0x0001 ///< The packet contains a keyframe
+#define AV_PKT_FLAG_CORRUPT 0x0002 ///< The packet content is corrupted
+/**
+ * Flag is used to discard packets which are required to maintain valid
+ * decoder state but are not required for output and should be dropped
+ * after decoding.
+ **/
+#define AV_PKT_FLAG_DISCARD   0x0004
+/**
+ * The packet comes from a trusted source.
+ *
+ * Otherwise-unsafe constructs such as arbitrary pointers to data
+ * outside the packet may be followed.
+ */
+#define AV_PKT_FLAG_TRUSTED   0x0008
+/**
+ * Flag is used to indicate packets that contain frames that can
+ * be discarded by the decoder.  I.e. Non-reference frames.
+ */
+#define AV_PKT_FLAG_DISPOSABLE 0x0010
+
+enum AVSideDataParamChangeFlags {
+    AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT  = 0x0001,
+    AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT = 0x0002,
+    AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE    = 0x0004,
+    AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS     = 0x0008,
+};
+
+/**
+ * Allocate an AVPacket and set its fields to default values.  The resulting
+ * struct must be freed using av_packet_free().
+ *
+ * @return An AVPacket filled with default values or NULL on failure.
+ *
+ * @note this only allocates the AVPacket itself, not the data buffers. Those
+ * must be allocated through other means such as av_new_packet.
+ *
+ * @see av_new_packet
+ */
+AVPacket *av_packet_alloc(void);
+
+/**
+ * Create a new packet that references the same data as src.
+ *
+ * This is a shortcut for av_packet_alloc()+av_packet_ref().
+ *
+ * @return newly created AVPacket on success, NULL on error.
+ *
+ * @see av_packet_alloc
+ * @see av_packet_ref
+ */
+AVPacket *av_packet_clone(const AVPacket *src);
+
+/**
+ * Free the packet, if the packet is reference counted, it will be
+ * unreferenced first.
+ *
+ * @param pkt packet to be freed. The pointer will be set to NULL.
+ * @note passing NULL is a no-op.
+ */
+void av_packet_free(AVPacket **pkt);
+
+/**
+ * Initialize optional fields of a packet with default values.
+ *
+ * Note, this does not touch the data and size members, which have to be
+ * initialized separately.
+ *
+ * @param pkt packet
+ */
+void av_init_packet(AVPacket *pkt);
+
+/**
+ * Allocate the payload of a packet and initialize its fields with
+ * default values.
+ *
+ * @param pkt packet
+ * @param size wanted payload size
+ * @return 0 if OK, AVERROR_xxx otherwise
+ */
+int av_new_packet(AVPacket *pkt, int size);
+
+/**
+ * Reduce packet size, correctly zeroing padding
+ *
+ * @param pkt packet
+ * @param size new size
+ */
+void av_shrink_packet(AVPacket *pkt, int size);
+
+/**
+ * Increase packet size, correctly zeroing padding
+ *
+ * @param pkt packet
+ * @param grow_by number of bytes by which to increase the size of the packet
+ */
+int av_grow_packet(AVPacket *pkt, int grow_by);
+
+/**
+ * Initialize a reference-counted packet from av_malloc()ed data.
+ *
+ * @param pkt packet to be initialized. This function will set the data, size,
+ *        and buf fields, all others are left untouched.
+ * @param data Data allocated by av_malloc() to be used as packet data. If this
+ *        function returns successfully, the data is owned by the underlying AVBuffer.
+ *        The caller may not access the data through other means.
+ * @param size size of data in bytes, without the padding. I.e. the full buffer
+ *        size is assumed to be size + AV_INPUT_BUFFER_PADDING_SIZE.
+ *
+ * @return 0 on success, a negative AVERROR on error
+ */
+int av_packet_from_data(AVPacket *pkt, uint8_t *data, int size);
+
+#if FF_API_AVPACKET_OLD_API
+/**
+ * @warning This is a hack - the packet memory allocation stuff is broken. The
+ * packet is allocated if it was not really allocated.
+ *
+ * @deprecated Use av_packet_ref or av_packet_make_refcounted
+ */
+attribute_deprecated
+int av_dup_packet(AVPacket *pkt);
+/**
+ * Copy packet, including contents
+ *
+ * @return 0 on success, negative AVERROR on fail
+ *
+ * @deprecated Use av_packet_ref
+ */
+attribute_deprecated
+int av_copy_packet(AVPacket *dst, const AVPacket *src);
+
+/**
+ * Copy packet side data
+ *
+ * @return 0 on success, negative AVERROR on fail
+ *
+ * @deprecated Use av_packet_copy_props
+ */
+attribute_deprecated
+int av_copy_packet_side_data(AVPacket *dst, const AVPacket *src);
+
+/**
+ * Free a packet.
+ *
+ * @deprecated Use av_packet_unref
+ *
+ * @param pkt packet to free
+ */
+attribute_deprecated
+void av_free_packet(AVPacket *pkt);
+#endif
+/**
+ * Allocate new information of a packet.
+ *
+ * @param pkt packet
+ * @param type side information type
+ * @param size side information size
+ * @return pointer to fresh allocated data or NULL otherwise
+ */
+uint8_t* av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
+                                 int size);
+
+/**
+ * Wrap an existing array as a packet side data.
+ *
+ * @param pkt packet
+ * @param type side information type
+ * @param data the side data array. It must be allocated with the av_malloc()
+ *             family of functions. The ownership of the data is transferred to
+ *             pkt.
+ * @param size side information size
+ * @return a non-negative number on success, a negative AVERROR code on
+ *         failure. On failure, the packet is unchanged and the data remains
+ *         owned by the caller.
+ */
+int av_packet_add_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
+                            uint8_t *data, size_t size);
+
+/**
+ * Shrink the already allocated side data buffer
+ *
+ * @param pkt packet
+ * @param type side information type
+ * @param size new side information size
+ * @return 0 on success, < 0 on failure
+ */
+int av_packet_shrink_side_data(AVPacket *pkt, enum AVPacketSideDataType type,
+                               int size);
+
+/**
+ * Get side information from packet.
+ *
+ * @param pkt packet
+ * @param type desired side information type
+ * @param size pointer for side information size to store (optional)
+ * @return pointer to data if present or NULL otherwise
+ */
+uint8_t* av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type,
+                                 int *size);
+
+#if FF_API_MERGE_SD_API
+attribute_deprecated
+int av_packet_merge_side_data(AVPacket *pkt);
+
+attribute_deprecated
+int av_packet_split_side_data(AVPacket *pkt);
+#endif
+
+const char *av_packet_side_data_name(enum AVPacketSideDataType type);
+
+/**
+ * Pack a dictionary for use in side_data.
+ *
+ * @param dict The dictionary to pack.
+ * @param size pointer to store the size of the returned data
+ * @return pointer to data if successful, NULL otherwise
+ */
+uint8_t *av_packet_pack_dictionary(AVDictionary *dict, int *size);
+/**
+ * Unpack a dictionary from side_data.
+ *
+ * @param data data from side_data
+ * @param size size of the data
+ * @param dict the metadata storage dictionary
+ * @return 0 on success, < 0 on failure
+ */
+int av_packet_unpack_dictionary(const uint8_t *data, int size, AVDictionary **dict);
+
+
+/**
+ * Convenience function to free all the side data stored.
+ * All the other fields stay untouched.
+ *
+ * @param pkt packet
+ */
+void av_packet_free_side_data(AVPacket *pkt);
+
+/**
+ * Setup a new reference to the data described by a given packet
+ *
+ * If src is reference-counted, setup dst as a new reference to the
+ * buffer in src. Otherwise allocate a new buffer in dst and copy the
+ * data from src into it.
+ *
+ * All the other fields are copied from src.
+ *
+ * @see av_packet_unref
+ *
+ * @param dst Destination packet. Will be completely overwritten.
+ * @param src Source packet
+ *
+ * @return 0 on success, a negative AVERROR on error. On error, dst
+ *         will be blank (as if returned by av_packet_alloc()).
+ */
+int av_packet_ref(AVPacket *dst, const AVPacket *src);
+
+/**
+ * Wipe the packet.
+ *
+ * Unreference the buffer referenced by the packet and reset the
+ * remaining packet fields to their default values.
+ *
+ * @param pkt The packet to be unreferenced.
+ */
+void av_packet_unref(AVPacket *pkt);
+
+/**
+ * Move every field in src to dst and reset src.
+ *
+ * @see av_packet_unref
+ *
+ * @param src Source packet, will be reset
+ * @param dst Destination packet
+ */
+void av_packet_move_ref(AVPacket *dst, AVPacket *src);
+
+/**
+ * Copy only "properties" fields from src to dst.
+ *
+ * Properties for the purpose of this function are all the fields
+ * beside those related to the packet data (buf, data, size)
+ *
+ * @param dst Destination packet
+ * @param src Source packet
+ *
+ * @return 0 on success AVERROR on failure.
+ */
+int av_packet_copy_props(AVPacket *dst, const AVPacket *src);
+
+/**
+ * Ensure the data described by a given packet is reference counted.
+ *
+ * @note This function does not ensure that the reference will be writable.
+ *       Use av_packet_make_writable instead for that purpose.
+ *
+ * @see av_packet_ref
+ * @see av_packet_make_writable
+ *
+ * @param pkt packet whose data should be made reference counted.
+ *
+ * @return 0 on success, a negative AVERROR on error. On failure, the
+ *         packet is unchanged.
+ */
+int av_packet_make_refcounted(AVPacket *pkt);
+
+/**
+ * Create a writable reference for the data described by a given packet,
+ * avoiding data copy if possible.
+ *
+ * @param pkt Packet whose data should be made writable.
+ *
+ * @return 0 on success, a negative AVERROR on failure. On failure, the
+ *         packet is unchanged.
+ */
+int av_packet_make_writable(AVPacket *pkt);
+
+/**
+ * Convert valid timing fields (timestamps / durations) in a packet from one
+ * timebase to another. Timestamps with unknown values (AV_NOPTS_VALUE) will be
+ * ignored.
+ *
+ * @param pkt packet on which the conversion will be performed
+ * @param tb_src source timebase, in which the timing fields in pkt are
+ *               expressed
+ * @param tb_dst destination timebase, to which the timing fields will be
+ *               converted
+ */
+void av_packet_rescale_ts(AVPacket *pkt, AVRational tb_src, AVRational tb_dst);
+
+/**
+ * @}
+ */
+
+#endif // AVCODEC_PACKET_H

ffmpeg-n4.3.2-win64-gpl-shared-4.3/include/libavcodec/qsv.h

@@ -0,0 +1,107 @@
+/*
+ * Intel MediaSDK QSV public API
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_QSV_H
+#define AVCODEC_QSV_H
+
+#include <mfx/mfxvideo.h>
+
+#include "libavutil/buffer.h"
+
+/**
+ * This struct is used for communicating QSV parameters between libavcodec and
+ * the caller. It is managed by the caller and must be assigned to
+ * AVCodecContext.hwaccel_context.
+ * - decoding: hwaccel_context must be set on return from the get_format()
+ *             callback
+ * - encoding: hwaccel_context must be set before avcodec_open2()
+ */
+typedef struct AVQSVContext {
+    /**
+     * If non-NULL, the session to use for encoding or decoding.
+     * Otherwise, libavcodec will try to create an internal session.
+     */
+    mfxSession session;
+
+    /**
+     * The IO pattern to use.
+     */
+    int iopattern;
+
+    /**
+     * Extra buffers to pass to encoder or decoder initialization.
+     */
+    mfxExtBuffer **ext_buffers;
+    int         nb_ext_buffers;
+
+    /**
+     * Encoding only. If this field is set to non-zero by the caller, libavcodec
+     * will create an mfxExtOpaqueSurfaceAlloc extended buffer and pass it to
+     * the encoder initialization. This only makes sense if iopattern is also
+     * set to MFX_IOPATTERN_IN_OPAQUE_MEMORY.
+     *
+     * The number of allocated opaque surfaces will be the sum of the number
+     * required by the encoder and the user-provided value nb_opaque_surfaces.
+     * The array of the opaque surfaces will be exported to the caller through
+     * the opaque_surfaces field.
+     */
+    int opaque_alloc;
+
+    /**
+     * Encoding only, and only if opaque_alloc is set to non-zero. Before
+     * calling avcodec_open2(), the caller should set this field to the number
+     * of extra opaque surfaces to allocate beyond what is required by the
+     * encoder.
+     *
+     * On return from avcodec_open2(), this field will be set by libavcodec to
+     * the total number of allocated opaque surfaces.
+     */
+    int nb_opaque_surfaces;
+
+    /**
+     * Encoding only, and only if opaque_alloc is set to non-zero. On return
+     * from avcodec_open2(), this field will be used by libavcodec to export the
+     * array of the allocated opaque surfaces to the caller, so they can be
+     * passed to other parts of the pipeline.
+     *
+     * The buffer reference exported here is owned and managed by libavcodec,
+     * the callers should make their own reference with av_buffer_ref() and free
+     * it with av_buffer_unref() when it is no longer needed.
+     *
+     * The buffer data is an nb_opaque_surfaces-sized array of mfxFrameSurface1.
+     */
+    AVBufferRef *opaque_surfaces;
+
+    /**
+     * Encoding only, and only if opaque_alloc is set to non-zero. On return
+     * from avcodec_open2(), this field will be set to the surface type used in
+     * the opaque allocation request.
+     */
+    int opaque_alloc_type;
+} AVQSVContext;
+
+/**
+ * Allocate a new context.
+ *
+ * It must be freed by the caller with av_free().
+ */
+AVQSVContext *av_qsv_alloc_context(void);
+
+#endif /* AVCODEC_QSV_H */

ffmpeg-n4.3.2-win64-gpl-shared-4.3/include/libavcodec/vaapi.h

@@ -0,0 +1,86 @@
+/*
+ * Video Acceleration API (shared data between FFmpeg and the video player)
+ * HW decode acceleration for MPEG-2, MPEG-4, H.264 and VC-1
+ *
+ * Copyright (C) 2008-2009 Splitted-Desktop Systems
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_VAAPI_H
+#define AVCODEC_VAAPI_H
+
+/**
+ * @file
+ * @ingroup lavc_codec_hwaccel_vaapi
+ * Public libavcodec VA API header.
+ */
+
+#include <stdint.h>
+#include "libavutil/attributes.h"
+#include "version.h"
+
+#if FF_API_STRUCT_VAAPI_CONTEXT
+
+/**
+ * @defgroup lavc_codec_hwaccel_vaapi VA API Decoding
+ * @ingroup lavc_codec_hwaccel
+ * @{
+ */
+
+/**
+ * This structure is used to share data between the FFmpeg library and
+ * the client video application.
+ * This shall be zero-allocated and available as
+ * AVCodecContext.hwaccel_context. All user members can be set once
+ * during initialization or through each AVCodecContext.get_buffer()
+ * function call. In any case, they must be valid prior to calling
+ * decoding functions.
+ *
+ * Deprecated: use AVCodecContext.hw_frames_ctx instead.
+ */
+struct attribute_deprecated vaapi_context {
+    /**
+     * Window system dependent data
+     *
+     * - encoding: unused
+     * - decoding: Set by user
+     */
+    void *display;
+
+    /**
+     * Configuration ID
+     *
+     * - encoding: unused
+     * - decoding: Set by user
+     */
+    uint32_t config_id;
+
+    /**
+     * Context ID (video decode pipeline)
+     *
+     * - encoding: unused
+     * - decoding: Set by user
+     */
+    uint32_t context_id;
+};
+
+/* @} */
+
+#endif /* FF_API_STRUCT_VAAPI_CONTEXT */
+
+#endif /* AVCODEC_VAAPI_H */

ffmpeg-n4.3.2-win64-gpl-shared-4.3/include/libavcodec/vdpau.h

@@ -0,0 +1,176 @@
+/*
+ * The Video Decode and Presentation API for UNIX (VDPAU) is used for
+ * hardware-accelerated decoding of MPEG-1/2, H.264 and VC-1.
+ *
+ * Copyright (C) 2008 NVIDIA
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_VDPAU_H
+#define AVCODEC_VDPAU_H
+
+/**
+ * @file
+ * @ingroup lavc_codec_hwaccel_vdpau
+ * Public libavcodec VDPAU header.
+ */
+
+
+/**
+ * @defgroup lavc_codec_hwaccel_vdpau VDPAU Decoder and Renderer
+ * @ingroup lavc_codec_hwaccel
+ *
+ * VDPAU hardware acceleration has two modules
+ * - VDPAU decoding
+ * - VDPAU presentation
+ *
+ * The VDPAU decoding module parses all headers using FFmpeg
+ * parsing mechanisms and uses VDPAU for the actual decoding.
+ *
+ * As per the current implementation, the actual decoding
+ * and rendering (API calls) are done as part of the VDPAU
+ * presentation (vo_vdpau.c) module.
+ *
+ * @{
+ */
+
+#include <vdpau/vdpau.h>
+
+#include "libavutil/avconfig.h"
+#include "libavutil/attributes.h"
+
+#include "avcodec.h"
+#include "version.h"
+
+struct AVCodecContext;
+struct AVFrame;
+
+typedef int (*AVVDPAU_Render2)(struct AVCodecContext *, struct AVFrame *,
+                               const VdpPictureInfo *, uint32_t,
+                               const VdpBitstreamBuffer *);
+
+/**
+ * This structure is used to share data between the libavcodec library and
+ * the client video application.
+ * The user shall allocate the structure via the av_alloc_vdpau_hwaccel
+ * function and make it available as
+ * AVCodecContext.hwaccel_context. Members can be set by the user once
+ * during initialization or through each AVCodecContext.get_buffer()
+ * function call. In any case, they must be valid prior to calling
+ * decoding functions.
+ *
+ * The size of this structure is not a part of the public ABI and must not
+ * be used outside of libavcodec. Use av_vdpau_alloc_context() to allocate an
+ * AVVDPAUContext.
+ */
+typedef struct AVVDPAUContext {
+    /**
+     * VDPAU decoder handle
+     *
+     * Set by user.
+     */
+    VdpDecoder decoder;
+
+    /**
+     * VDPAU decoder render callback
+     *
+     * Set by the user.
+     */
+    VdpDecoderRender *render;
+
+    AVVDPAU_Render2 render2;
+} AVVDPAUContext;
+
+/**
+ * @brief allocation function for AVVDPAUContext
+ *
+ * Allows extending the struct without breaking API/ABI
+ */
+AVVDPAUContext *av_alloc_vdpaucontext(void);
+
+AVVDPAU_Render2 av_vdpau_hwaccel_get_render2(const AVVDPAUContext *);
+void av_vdpau_hwaccel_set_render2(AVVDPAUContext *, AVVDPAU_Render2);
+
+/**
+ * Associate a VDPAU device with a codec context for hardware acceleration.
+ * This function is meant to be called from the get_format() codec callback,
+ * or earlier. It can also be called after avcodec_flush_buffers() to change
+ * the underlying VDPAU device mid-stream (e.g. to recover from non-transparent
+ * display preemption).
+ *
+ * @note get_format() must return AV_PIX_FMT_VDPAU if this function completes
+ * successfully.
+ *
+ * @param avctx decoding context whose get_format() callback is invoked
+ * @param device VDPAU device handle to use for hardware acceleration
+ * @param get_proc_address VDPAU device driver
+ * @param flags zero of more OR'd AV_HWACCEL_FLAG_* flags
+ *
+ * @return 0 on success, an AVERROR code on failure.
+ */
+int av_vdpau_bind_context(AVCodecContext *avctx, VdpDevice device,
+                          VdpGetProcAddress *get_proc_address, unsigned flags);
+
+/**
+ * Gets the parameters to create an adequate VDPAU video surface for the codec
+ * context using VDPAU hardware decoding acceleration.
+ *
+ * @note Behavior is undefined if the context was not successfully bound to a
+ * VDPAU device using av_vdpau_bind_context().
+ *
+ * @param avctx the codec context being used for decoding the stream
+ * @param type storage space for the VDPAU video surface chroma type
+ *              (or NULL to ignore)
+ * @param width storage space for the VDPAU video surface pixel width
+ *              (or NULL to ignore)
+ * @param height storage space for the VDPAU video surface pixel height
+ *              (or NULL to ignore)
+ *
+ * @return 0 on success, a negative AVERROR code on failure.
+ */
+int av_vdpau_get_surface_parameters(AVCodecContext *avctx, VdpChromaType *type,
+                                    uint32_t *width, uint32_t *height);
+
+/**
+ * Allocate an AVVDPAUContext.
+ *
+ * @return Newly-allocated AVVDPAUContext or NULL on failure.
+ */
+AVVDPAUContext *av_vdpau_alloc_context(void);
+
+#if FF_API_VDPAU_PROFILE
+/**
+ * Get a decoder profile that should be used for initializing a VDPAU decoder.
+ * Should be called from the AVCodecContext.get_format() callback.
+ *
+ * @deprecated Use av_vdpau_bind_context() instead.
+ *
+ * @param avctx the codec context being used for decoding the stream
+ * @param profile a pointer into which the result will be written on success.
+ *                The contents of profile are undefined if this function returns
+ *                an error.
+ *
+ * @return 0 on success (non-negative), a negative AVERROR on failure.
+ */
+attribute_deprecated
+int av_vdpau_get_profile(AVCodecContext *avctx, VdpDecoderProfile *profile);
+#endif
+
+/* @}*/
+
+#endif /* AVCODEC_VDPAU_H */

ffmpeg-n4.3.2-win64-gpl-shared-4.3/include/libavcodec/version.h

@@ -0,0 +1,149 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_VERSION_H
+#define AVCODEC_VERSION_H
+
+/**
+ * @file
+ * @ingroup libavc
+ * Libavcodec version macros.
+ */
+
+#include "libavutil/version.h"
+
+#define LIBAVCODEC_VERSION_MAJOR  58
+#define LIBAVCODEC_VERSION_MINOR  91
+#define LIBAVCODEC_VERSION_MICRO 100
+
+#define LIBAVCODEC_VERSION_INT  AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
+                                               LIBAVCODEC_VERSION_MINOR, \
+                                               LIBAVCODEC_VERSION_MICRO)
+#define LIBAVCODEC_VERSION      AV_VERSION(LIBAVCODEC_VERSION_MAJOR,    \
+                                           LIBAVCODEC_VERSION_MINOR,    \
+                                           LIBAVCODEC_VERSION_MICRO)
+#define LIBAVCODEC_BUILD        LIBAVCODEC_VERSION_INT
+
+#define LIBAVCODEC_IDENT        "Lavc" AV_STRINGIFY(LIBAVCODEC_VERSION)
+
+/**
+ * FF_API_* defines may be placed below to indicate public API that will be
+ * dropped at a future version bump. The defines themselves are not part of
+ * the public API and may change, break or disappear at any time.
+ *
+ * @note, when bumping the major version it is recommended to manually
+ * disable each FF_API_* in its own commit instead of disabling them all
+ * at once through the bump. This improves the git bisect-ability of the change.
+ */
+
+#ifndef FF_API_LOWRES
+#define FF_API_LOWRES            (LIBAVCODEC_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_DEBUG_MV
+#define FF_API_DEBUG_MV          (LIBAVCODEC_VERSION_MAJOR < 58)
+#endif
+#ifndef FF_API_AVCTX_TIMEBASE
+#define FF_API_AVCTX_TIMEBASE    (LIBAVCODEC_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_CODED_FRAME
+#define FF_API_CODED_FRAME       (LIBAVCODEC_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_SIDEDATA_ONLY_PKT
+#define FF_API_SIDEDATA_ONLY_PKT (LIBAVCODEC_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_VDPAU_PROFILE
+#define FF_API_VDPAU_PROFILE     (LIBAVCODEC_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_CONVERGENCE_DURATION
+#define FF_API_CONVERGENCE_DURATION (LIBAVCODEC_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_AVPICTURE
+#define FF_API_AVPICTURE         (LIBAVCODEC_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_AVPACKET_OLD_API
+#define FF_API_AVPACKET_OLD_API (LIBAVCODEC_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_RTP_CALLBACK
+#define FF_API_RTP_CALLBACK      (LIBAVCODEC_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_VBV_DELAY
+#define FF_API_VBV_DELAY         (LIBAVCODEC_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_CODER_TYPE
+#define FF_API_CODER_TYPE        (LIBAVCODEC_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_STAT_BITS
+#define FF_API_STAT_BITS         (LIBAVCODEC_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_PRIVATE_OPT
+#define FF_API_PRIVATE_OPT      (LIBAVCODEC_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_ASS_TIMING
+#define FF_API_ASS_TIMING       (LIBAVCODEC_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_OLD_BSF
+#define FF_API_OLD_BSF          (LIBAVCODEC_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_COPY_CONTEXT
+#define FF_API_COPY_CONTEXT     (LIBAVCODEC_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_GET_CONTEXT_DEFAULTS
+#define FF_API_GET_CONTEXT_DEFAULTS (LIBAVCODEC_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_NVENC_OLD_NAME
+#define FF_API_NVENC_OLD_NAME    (LIBAVCODEC_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_STRUCT_VAAPI_CONTEXT
+#define FF_API_STRUCT_VAAPI_CONTEXT (LIBAVCODEC_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_MERGE_SD_API
+#define FF_API_MERGE_SD_API      (LIBAVCODEC_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_TAG_STRING
+#define FF_API_TAG_STRING        (LIBAVCODEC_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_GETCHROMA
+#define FF_API_GETCHROMA         (LIBAVCODEC_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_CODEC_GET_SET
+#define FF_API_CODEC_GET_SET     (LIBAVCODEC_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_USER_VISIBLE_AVHWACCEL
+#define FF_API_USER_VISIBLE_AVHWACCEL (LIBAVCODEC_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_LOCKMGR
+#define FF_API_LOCKMGR (LIBAVCODEC_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_NEXT
+#define FF_API_NEXT              (LIBAVCODEC_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_UNSANITIZED_BITRATES
+#define FF_API_UNSANITIZED_BITRATES (LIBAVCODEC_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_OPENH264_SLICE_MODE
+#define FF_API_OPENH264_SLICE_MODE (LIBAVCODEC_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_OPENH264_CABAC
+#define FF_API_OPENH264_CABAC      (LIBAVCODEC_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_UNUSED_CODEC_CAPS
+#define FF_API_UNUSED_CODEC_CAPS   (LIBAVCODEC_VERSION_MAJOR < 59)
+#endif
+
+
+#endif /* AVCODEC_VERSION_H */

ffmpeg-n4.3.2-win64-gpl-shared-4.3/include/libavcodec/videotoolbox.h

@@ -0,0 +1,127 @@
+/*
+ * Videotoolbox hardware acceleration
+ *
+ * copyright (c) 2012 Sebastien Zwickert
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_VIDEOTOOLBOX_H
+#define AVCODEC_VIDEOTOOLBOX_H
+
+/**
+ * @file
+ * @ingroup lavc_codec_hwaccel_videotoolbox
+ * Public libavcodec Videotoolbox header.
+ */
+
+#include <stdint.h>
+
+#define Picture QuickdrawPicture
+#include <VideoToolbox/VideoToolbox.h>
+#undef Picture
+
+#include "libavcodec/avcodec.h"
+
+/**
+ * This struct holds all the information that needs to be passed
+ * between the caller and libavcodec for initializing Videotoolbox decoding.
+ * Its size is not a part of the public ABI, it must be allocated with
+ * av_videotoolbox_alloc_context() and freed with av_free().
+ */
+typedef struct AVVideotoolboxContext {
+    /**
+     * Videotoolbox decompression session object.
+     * Created and freed the caller.
+     */
+    VTDecompressionSessionRef session;
+
+    /**
+     * The output callback that must be passed to the session.
+     * Set by av_videottoolbox_default_init()
+     */
+    VTDecompressionOutputCallback output_callback;
+
+    /**
+     * CVPixelBuffer Format Type that Videotoolbox will use for decoded frames.
+     * set by the caller. If this is set to 0, then no specific format is
+     * requested from the decoder, and its native format is output.
+     */
+    OSType cv_pix_fmt_type;
+
+    /**
+     * CoreMedia Format Description that Videotoolbox will use to create the decompression session.
+     * Set by the caller.
+     */
+    CMVideoFormatDescriptionRef cm_fmt_desc;
+
+    /**
+     * CoreMedia codec type that Videotoolbox will use to create the decompression session.
+     * Set by the caller.
+     */
+    int cm_codec_type;
+} AVVideotoolboxContext;
+
+/**
+ * Allocate and initialize a Videotoolbox context.
+ *
+ * This function should be called from the get_format() callback when the caller
+ * selects the AV_PIX_FMT_VIDETOOLBOX format. The caller must then create
+ * the decoder object (using the output callback provided by libavcodec) that
+ * will be used for Videotoolbox-accelerated decoding.
+ *
+ * When decoding with Videotoolbox is finished, the caller must destroy the decoder
+ * object and free the Videotoolbox context using av_free().
+ *
+ * @return the newly allocated context or NULL on failure
+ */
+AVVideotoolboxContext *av_videotoolbox_alloc_context(void);
+
+/**
+ * This is a convenience function that creates and sets up the Videotoolbox context using
+ * an internal implementation.
+ *
+ * @param avctx the corresponding codec context
+ *
+ * @return >= 0 on success, a negative AVERROR code on failure
+ */
+int av_videotoolbox_default_init(AVCodecContext *avctx);
+
+/**
+ * This is a convenience function that creates and sets up the Videotoolbox context using
+ * an internal implementation.
+ *
+ * @param avctx the corresponding codec context
+ * @param vtctx the Videotoolbox context to use
+ *
+ * @return >= 0 on success, a negative AVERROR code on failure
+ */
+int av_videotoolbox_default_init2(AVCodecContext *avctx, AVVideotoolboxContext *vtctx);
+
+/**
+ * This function must be called to free the Videotoolbox context initialized with
+ * av_videotoolbox_default_init().
+ *
+ * @param avctx the corresponding codec context
+ */
+void av_videotoolbox_default_free(AVCodecContext *avctx);
+
+/**
+ * @}
+ */
+
+#endif /* AVCODEC_VIDEOTOOLBOX_H */

ffmpeg-n4.3.2-win64-gpl-shared-4.3/include/libavcodec/vorbis_parser.h

@@ -0,0 +1,74 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/**
+ * @file
+ * A public API for Vorbis parsing
+ *
+ * Determines the duration for each packet.
+ */
+
+#ifndef AVCODEC_VORBIS_PARSER_H
+#define AVCODEC_VORBIS_PARSER_H
+
+#include <stdint.h>
+
+typedef struct AVVorbisParseContext AVVorbisParseContext;
+
+/**
+ * Allocate and initialize the Vorbis parser using headers in the extradata.
+ */
+AVVorbisParseContext *av_vorbis_parse_init(const uint8_t *extradata,
+                                           int extradata_size);
+
+/**
+ * Free the parser and everything associated with it.
+ */
+void av_vorbis_parse_free(AVVorbisParseContext **s);
+
+#define VORBIS_FLAG_HEADER  0x00000001
+#define VORBIS_FLAG_COMMENT 0x00000002
+#define VORBIS_FLAG_SETUP   0x00000004
+
+/**
+ * Get the duration for a Vorbis packet.
+ *
+ * If @p flags is @c NULL,
+ * special frames are considered invalid.
+ *
+ * @param s        Vorbis parser context
+ * @param buf      buffer containing a Vorbis frame
+ * @param buf_size size of the buffer
+ * @param flags    flags for special frames
+ */
+int av_vorbis_parse_frame_flags(AVVorbisParseContext *s, const uint8_t *buf,
+                                int buf_size, int *flags);
+
+/**
+ * Get the duration for a Vorbis packet.
+ *
+ * @param s        Vorbis parser context
+ * @param buf      buffer containing a Vorbis frame
+ * @param buf_size size of the buffer
+ */
+int av_vorbis_parse_frame(AVVorbisParseContext *s, const uint8_t *buf,
+                          int buf_size);
+
+void av_vorbis_parse_reset(AVVorbisParseContext *s);
+
+#endif /* AVCODEC_VORBIS_PARSER_H */

ffmpeg-n4.3.2-win64-gpl-shared-4.3/include/libavcodec/xvmc.h

@@ -0,0 +1,170 @@
+/*
+ * Copyright (C) 2003 Ivan Kalvachev
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_XVMC_H
+#define AVCODEC_XVMC_H
+
+/**
+ * @file
+ * @ingroup lavc_codec_hwaccel_xvmc
+ * Public libavcodec XvMC header.
+ */
+
+#include <X11/extensions/XvMC.h>
+
+#include "libavutil/attributes.h"
+#include "version.h"
+#include "avcodec.h"
+
+/**
+ * @defgroup lavc_codec_hwaccel_xvmc XvMC
+ * @ingroup lavc_codec_hwaccel
+ *
+ * @{
+ */
+
+#define AV_XVMC_ID                    0x1DC711C0  /**< special value to ensure that regular pixel routines haven't corrupted the struct
+                                                       the number is 1337 speak for the letters IDCT MCo (motion compensation) */
+
+struct attribute_deprecated xvmc_pix_fmt {
+    /** The field contains the special constant value AV_XVMC_ID.
+        It is used as a test that the application correctly uses the API,
+        and that there is no corruption caused by pixel routines.
+        - application - set during initialization
+        - libavcodec  - unchanged
+    */
+    int             xvmc_id;
+
+    /** Pointer to the block array allocated by XvMCCreateBlocks().
+        The array has to be freed by XvMCDestroyBlocks().
+        Each group of 64 values represents one data block of differential
+        pixel information (in MoCo mode) or coefficients for IDCT.
+        - application - set the pointer during initialization
+        - libavcodec  - fills coefficients/pixel data into the array
+    */
+    short*          data_blocks;
+
+    /** Pointer to the macroblock description array allocated by
+        XvMCCreateMacroBlocks() and freed by XvMCDestroyMacroBlocks().
+        - application - set the pointer during initialization
+        - libavcodec  - fills description data into the array
+    */
+    XvMCMacroBlock* mv_blocks;
+
+    /** Number of macroblock descriptions that can be stored in the mv_blocks
+        array.
+        - application - set during initialization
+        - libavcodec  - unchanged
+    */
+    int             allocated_mv_blocks;
+
+    /** Number of blocks that can be stored at once in the data_blocks array.
+        - application - set during initialization
+        - libavcodec  - unchanged
+    */
+    int             allocated_data_blocks;
+
+    /** Indicate that the hardware would interpret data_blocks as IDCT
+        coefficients and perform IDCT on them.
+        - application - set during initialization
+        - libavcodec  - unchanged
+    */
+    int             idct;
+
+    /** In MoCo mode it indicates that intra macroblocks are assumed to be in
+        unsigned format; same as the XVMC_INTRA_UNSIGNED flag.
+        - application - set during initialization
+        - libavcodec  - unchanged
+    */
+    int             unsigned_intra;
+
+    /** Pointer to the surface allocated by XvMCCreateSurface().
+        It has to be freed by XvMCDestroySurface() on application exit.
+        It identifies the frame and its state on the video hardware.
+        - application - set during initialization
+        - libavcodec  - unchanged
+    */
+    XvMCSurface*    p_surface;
+
+/** Set by the decoder before calling ff_draw_horiz_band(),
+    needed by the XvMCRenderSurface function. */
+//@{
+    /** Pointer to the surface used as past reference
+        - application - unchanged
+        - libavcodec  - set
+    */
+    XvMCSurface*    p_past_surface;
+
+    /** Pointer to the surface used as future reference
+        - application - unchanged
+        - libavcodec  - set
+    */
+    XvMCSurface*    p_future_surface;
+
+    /** top/bottom field or frame
+        - application - unchanged
+        - libavcodec  - set
+    */
+    unsigned int    picture_structure;
+
+    /** XVMC_SECOND_FIELD - 1st or 2nd field in the sequence
+        - application - unchanged
+        - libavcodec  - set
+    */
+    unsigned int    flags;
+//}@
+
+    /** Number of macroblock descriptions in the mv_blocks array
+        that have already been passed to the hardware.
+        - application - zeroes it on get_buffer().
+                        A successful ff_draw_horiz_band() may increment it
+                        with filled_mb_block_num or zero both.
+        - libavcodec  - unchanged
+    */
+    int             start_mv_blocks_num;
+
+    /** Number of new macroblock descriptions in the mv_blocks array (after
+        start_mv_blocks_num) that are filled by libavcodec and have to be
+        passed to the hardware.
+        - application - zeroes it on get_buffer() or after successful
+                        ff_draw_horiz_band().
+        - libavcodec  - increment with one of each stored MB
+    */
+    int             filled_mv_blocks_num;
+
+    /** Number of the next free data block; one data block consists of
+        64 short values in the data_blocks array.
+        All blocks before this one have already been claimed by placing their
+        position into the corresponding block description structure field,
+        that are part of the mv_blocks array.
+        - application - zeroes it on get_buffer().
+                        A successful ff_draw_horiz_band() may zero it together
+                        with start_mb_blocks_num.
+        - libavcodec  - each decoded macroblock increases it by the number
+                        of coded blocks it contains.
+    */
+    int             next_free_data_block_num;
+};
+
+/**
+ * @}
+ */
+
+#endif /* AVCODEC_XVMC_H */

ffmpeg-n4.3.2-win64-gpl-shared-4.3/include/libavdevice/avdevice.h

@@ -0,0 +1,514 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVDEVICE_AVDEVICE_H
+#define AVDEVICE_AVDEVICE_H
+
+#include "version.h"
+
+/**
+ * @file
+ * @ingroup lavd
+ * Main libavdevice API header
+ */
+
+/**
+ * @defgroup lavd libavdevice
+ * Special devices muxing/demuxing library.
+ *
+ * Libavdevice is a complementary library to @ref libavf "libavformat". It
+ * provides various "special" platform-specific muxers and demuxers, e.g. for
+ * grabbing devices, audio capture and playback etc. As a consequence, the
+ * (de)muxers in libavdevice are of the AVFMT_NOFILE type (they use their own
+ * I/O functions). The filename passed to avformat_open_input() often does not
+ * refer to an actually existing file, but has some special device-specific
+ * meaning - e.g. for xcbgrab it is the display name.
+ *
+ * To use libavdevice, simply call avdevice_register_all() to register all
+ * compiled muxers and demuxers. They all use standard libavformat API.
+ *
+ * @{
+ */
+
+#include "libavutil/log.h"
+#include "libavutil/opt.h"
+#include "libavutil/dict.h"
+#include "libavformat/avformat.h"
+
+/**
+ * Return the LIBAVDEVICE_VERSION_INT constant.
+ */
+unsigned avdevice_version(void);
+
+/**
+ * Return the libavdevice build-time configuration.
+ */
+const char *avdevice_configuration(void);
+
+/**
+ * Return the libavdevice license.
+ */
+const char *avdevice_license(void);
+
+/**
+ * Initialize libavdevice and register all the input and output devices.
+ */
+void avdevice_register_all(void);
+
+/**
+ * Audio input devices iterator.
+ *
+ * If d is NULL, returns the first registered input audio/video device,
+ * if d is non-NULL, returns the next registered input audio/video device after d
+ * or NULL if d is the last one.
+ */
+AVInputFormat *av_input_audio_device_next(AVInputFormat  *d);
+
+/**
+ * Video input devices iterator.
+ *
+ * If d is NULL, returns the first registered input audio/video device,
+ * if d is non-NULL, returns the next registered input audio/video device after d
+ * or NULL if d is the last one.
+ */
+AVInputFormat *av_input_video_device_next(AVInputFormat  *d);
+
+/**
+ * Audio output devices iterator.
+ *
+ * If d is NULL, returns the first registered output audio/video device,
+ * if d is non-NULL, returns the next registered output audio/video device after d
+ * or NULL if d is the last one.
+ */
+AVOutputFormat *av_output_audio_device_next(AVOutputFormat *d);
+
+/**
+ * Video output devices iterator.
+ *
+ * If d is NULL, returns the first registered output audio/video device,
+ * if d is non-NULL, returns the next registered output audio/video device after d
+ * or NULL if d is the last one.
+ */
+AVOutputFormat *av_output_video_device_next(AVOutputFormat *d);
+
+typedef struct AVDeviceRect {
+    int x;      /**< x coordinate of top left corner */
+    int y;      /**< y coordinate of top left corner */
+    int width;  /**< width */
+    int height; /**< height */
+} AVDeviceRect;
+
+/**
+ * Message types used by avdevice_app_to_dev_control_message().
+ */
+enum AVAppToDevMessageType {
+    /**
+     * Dummy message.
+     */
+    AV_APP_TO_DEV_NONE = MKBETAG('N','O','N','E'),
+
+    /**
+     * Window size change message.
+     *
+     * Message is sent to the device every time the application changes the size
+     * of the window device renders to.
+     * Message should also be sent right after window is created.
+     *
+     * data: AVDeviceRect: new window size.
+     */
+    AV_APP_TO_DEV_WINDOW_SIZE = MKBETAG('G','E','O','M'),
+
+    /**
+     * Repaint request message.
+     *
+     * Message is sent to the device when window has to be repainted.
+     *
+     * data: AVDeviceRect: area required to be repainted.
+     *       NULL: whole area is required to be repainted.
+     */
+    AV_APP_TO_DEV_WINDOW_REPAINT = MKBETAG('R','E','P','A'),
+
+    /**
+     * Request pause/play.
+     *
+     * Application requests pause/unpause playback.
+     * Mostly usable with devices that have internal buffer.
+     * By default devices are not paused.
+     *
+     * data: NULL
+     */
+    AV_APP_TO_DEV_PAUSE        = MKBETAG('P', 'A', 'U', ' '),
+    AV_APP_TO_DEV_PLAY         = MKBETAG('P', 'L', 'A', 'Y'),
+    AV_APP_TO_DEV_TOGGLE_PAUSE = MKBETAG('P', 'A', 'U', 'T'),
+
+    /**
+     * Volume control message.
+     *
+     * Set volume level. It may be device-dependent if volume
+     * is changed per stream or system wide. Per stream volume
+     * change is expected when possible.
+     *
+     * data: double: new volume with range of 0.0 - 1.0.
+     */
+    AV_APP_TO_DEV_SET_VOLUME = MKBETAG('S', 'V', 'O', 'L'),
+
+    /**
+     * Mute control messages.
+     *
+     * Change mute state. It may be device-dependent if mute status
+     * is changed per stream or system wide. Per stream mute status
+     * change is expected when possible.
+     *
+     * data: NULL.
+     */
+    AV_APP_TO_DEV_MUTE        = MKBETAG(' ', 'M', 'U', 'T'),
+    AV_APP_TO_DEV_UNMUTE      = MKBETAG('U', 'M', 'U', 'T'),
+    AV_APP_TO_DEV_TOGGLE_MUTE = MKBETAG('T', 'M', 'U', 'T'),
+
+    /**
+     * Get volume/mute messages.
+     *
+     * Force the device to send AV_DEV_TO_APP_VOLUME_LEVEL_CHANGED or
+     * AV_DEV_TO_APP_MUTE_STATE_CHANGED command respectively.
+     *
+     * data: NULL.
+     */
+    AV_APP_TO_DEV_GET_VOLUME = MKBETAG('G', 'V', 'O', 'L'),
+    AV_APP_TO_DEV_GET_MUTE   = MKBETAG('G', 'M', 'U', 'T'),
+};
+
+/**
+ * Message types used by avdevice_dev_to_app_control_message().
+ */
+enum AVDevToAppMessageType {
+    /**
+     * Dummy message.
+     */
+    AV_DEV_TO_APP_NONE = MKBETAG('N','O','N','E'),
+
+    /**
+     * Create window buffer message.
+     *
+     * Device requests to create a window buffer. Exact meaning is device-
+     * and application-dependent. Message is sent before rendering first
+     * frame and all one-shot initializations should be done here.
+     * Application is allowed to ignore preferred window buffer size.
+     *
+     * @note: Application is obligated to inform about window buffer size
+     *        with AV_APP_TO_DEV_WINDOW_SIZE message.
+     *
+     * data: AVDeviceRect: preferred size of the window buffer.
+     *       NULL: no preferred size of the window buffer.
+     */
+    AV_DEV_TO_APP_CREATE_WINDOW_BUFFER = MKBETAG('B','C','R','E'),
+
+    /**
+     * Prepare window buffer message.
+     *
+     * Device requests to prepare a window buffer for rendering.
+     * Exact meaning is device- and application-dependent.
+     * Message is sent before rendering of each frame.
+     *
+     * data: NULL.
+     */
+    AV_DEV_TO_APP_PREPARE_WINDOW_BUFFER = MKBETAG('B','P','R','E'),
+
+    /**
+     * Display window buffer message.
+     *
+     * Device requests to display a window buffer.
+     * Message is sent when new frame is ready to be displayed.
+     * Usually buffers need to be swapped in handler of this message.
+     *
+     * data: NULL.
+     */
+    AV_DEV_TO_APP_DISPLAY_WINDOW_BUFFER = MKBETAG('B','D','I','S'),
+
+    /**
+     * Destroy window buffer message.
+     *
+     * Device requests to destroy a window buffer.
+     * Message is sent when device is about to be destroyed and window
+     * buffer is not required anymore.
+     *
+     * data: NULL.
+     */
+    AV_DEV_TO_APP_DESTROY_WINDOW_BUFFER = MKBETAG('B','D','E','S'),
+
+    /**
+     * Buffer fullness status messages.
+     *
+     * Device signals buffer overflow/underflow.
+     *
+     * data: NULL.
+     */
+    AV_DEV_TO_APP_BUFFER_OVERFLOW = MKBETAG('B','O','F','L'),
+    AV_DEV_TO_APP_BUFFER_UNDERFLOW = MKBETAG('B','U','F','L'),
+
+    /**
+     * Buffer readable/writable.
+     *
+     * Device informs that buffer is readable/writable.
+     * When possible, device informs how many bytes can be read/write.
+     *
+     * @warning Device may not inform when number of bytes than can be read/write changes.
+     *
+     * data: int64_t: amount of bytes available to read/write.
+     *       NULL: amount of bytes available to read/write is not known.
+     */
+    AV_DEV_TO_APP_BUFFER_READABLE = MKBETAG('B','R','D',' '),
+    AV_DEV_TO_APP_BUFFER_WRITABLE = MKBETAG('B','W','R',' '),
+
+    /**
+     * Mute state change message.
+     *
+     * Device informs that mute state has changed.
+     *
+     * data: int: 0 for not muted state, non-zero for muted state.
+     */
+    AV_DEV_TO_APP_MUTE_STATE_CHANGED = MKBETAG('C','M','U','T'),
+
+    /**
+     * Volume level change message.
+     *
+     * Device informs that volume level has changed.
+     *
+     * data: double: new volume with range of 0.0 - 1.0.
+     */
+    AV_DEV_TO_APP_VOLUME_LEVEL_CHANGED = MKBETAG('C','V','O','L'),
+};
+
+/**
+ * Send control message from application to device.
+ *
+ * @param s         device context.
+ * @param type      message type.
+ * @param data      message data. Exact type depends on message type.
+ * @param data_size size of message data.
+ * @return >= 0 on success, negative on error.
+ *         AVERROR(ENOSYS) when device doesn't implement handler of the message.
+ */
+int avdevice_app_to_dev_control_message(struct AVFormatContext *s,
+                                        enum AVAppToDevMessageType type,
+                                        void *data, size_t data_size);
+
+/**
+ * Send control message from device to application.
+ *
+ * @param s         device context.
+ * @param type      message type.
+ * @param data      message data. Can be NULL.
+ * @param data_size size of message data.
+ * @return >= 0 on success, negative on error.
+ *         AVERROR(ENOSYS) when application doesn't implement handler of the message.
+ */
+int avdevice_dev_to_app_control_message(struct AVFormatContext *s,
+                                        enum AVDevToAppMessageType type,
+                                        void *data, size_t data_size);
+
+/**
+ * Following API allows user to probe device capabilities (supported codecs,
+ * pixel formats, sample formats, resolutions, channel counts, etc).
+ * It is build on top op AVOption API.
+ * Queried capabilities make it possible to set up converters of video or audio
+ * parameters that fit to the device.
+ *
+ * List of capabilities that can be queried:
+ *  - Capabilities valid for both audio and video devices:
+ *    - codec:          supported audio/video codecs.
+ *                      type: AV_OPT_TYPE_INT (AVCodecID value)
+ *  - Capabilities valid for audio devices:
+ *    - sample_format:  supported sample formats.
+ *                      type: AV_OPT_TYPE_INT (AVSampleFormat value)
+ *    - sample_rate:    supported sample rates.
+ *                      type: AV_OPT_TYPE_INT
+ *    - channels:       supported number of channels.
+ *                      type: AV_OPT_TYPE_INT
+ *    - channel_layout: supported channel layouts.
+ *                      type: AV_OPT_TYPE_INT64
+ *  - Capabilities valid for video devices:
+ *    - pixel_format:   supported pixel formats.
+ *                      type: AV_OPT_TYPE_INT (AVPixelFormat value)
+ *    - window_size:    supported window sizes (describes size of the window size presented to the user).
+ *                      type: AV_OPT_TYPE_IMAGE_SIZE
+ *    - frame_size:     supported frame sizes (describes size of provided video frames).
+ *                      type: AV_OPT_TYPE_IMAGE_SIZE
+ *    - fps:            supported fps values
+ *                      type: AV_OPT_TYPE_RATIONAL
+ *
+ * Value of the capability may be set by user using av_opt_set() function
+ * and AVDeviceCapabilitiesQuery object. Following queries will
+ * limit results to the values matching already set capabilities.
+ * For example, setting a codec may impact number of formats or fps values
+ * returned during next query. Setting invalid value may limit results to zero.
+ *
+ * Example of the usage basing on opengl output device:
+ *
+ * @code
+ *  AVFormatContext *oc = NULL;
+ *  AVDeviceCapabilitiesQuery *caps = NULL;
+ *  AVOptionRanges *ranges;
+ *  int ret;
+ *
+ *  if ((ret = avformat_alloc_output_context2(&oc, NULL, "opengl", NULL)) < 0)
+ *      goto fail;
+ *  if (avdevice_capabilities_create(&caps, oc, NULL) < 0)
+ *      goto fail;
+ *
+ *  //query codecs
+ *  if (av_opt_query_ranges(&ranges, caps, "codec", AV_OPT_MULTI_COMPONENT_RANGE)) < 0)
+ *      goto fail;
+ *  //pick codec here and set it
+ *  av_opt_set(caps, "codec", AV_CODEC_ID_RAWVIDEO, 0);
+ *
+ *  //query format
+ *  if (av_opt_query_ranges(&ranges, caps, "pixel_format", AV_OPT_MULTI_COMPONENT_RANGE)) < 0)
+ *      goto fail;
+ *  //pick format here and set it
+ *  av_opt_set(caps, "pixel_format", AV_PIX_FMT_YUV420P, 0);
+ *
+ *  //query and set more capabilities
+ *
+ * fail:
+ *  //clean up code
+ *  avdevice_capabilities_free(&query, oc);
+ *  avformat_free_context(oc);
+ * @endcode
+ */
+
+/**
+ * Structure describes device capabilities.
+ *
+ * It is used by devices in conjunction with av_device_capabilities AVOption table
+ * to implement capabilities probing API based on AVOption API. Should not be used directly.
+ */
+typedef struct AVDeviceCapabilitiesQuery {
+    const AVClass *av_class;
+    AVFormatContext *device_context;
+    enum AVCodecID codec;
+    enum AVSampleFormat sample_format;
+    enum AVPixelFormat pixel_format;
+    int sample_rate;
+    int channels;
+    int64_t channel_layout;
+    int window_width;
+    int window_height;
+    int frame_width;
+    int frame_height;
+    AVRational fps;
+} AVDeviceCapabilitiesQuery;
+
+/**
+ * AVOption table used by devices to implement device capabilities API. Should not be used by a user.
+ */
+extern const AVOption av_device_capabilities[];
+
+/**
+ * Initialize capabilities probing API based on AVOption API.
+ *
+ * avdevice_capabilities_free() must be called when query capabilities API is
+ * not used anymore.
+ *
+ * @param[out] caps      Device capabilities data. Pointer to a NULL pointer must be passed.
+ * @param s              Context of the device.
+ * @param device_options An AVDictionary filled with device-private options.
+ *                       On return this parameter will be destroyed and replaced with a dict
+ *                       containing options that were not found. May be NULL.
+ *                       The same options must be passed later to avformat_write_header() for output
+ *                       devices or avformat_open_input() for input devices, or at any other place
+ *                       that affects device-private options.
+ *
+ * @return >= 0 on success, negative otherwise.
+ */
+int avdevice_capabilities_create(AVDeviceCapabilitiesQuery **caps, AVFormatContext *s,
+                                 AVDictionary **device_options);
+
+/**
+ * Free resources created by avdevice_capabilities_create()
+ *
+ * @param caps Device capabilities data to be freed.
+ * @param s    Context of the device.
+ */
+void avdevice_capabilities_free(AVDeviceCapabilitiesQuery **caps, AVFormatContext *s);
+
+/**
+ * Structure describes basic parameters of the device.
+ */
+typedef struct AVDeviceInfo {
+    char *device_name;                   /**< device name, format depends on device */
+    char *device_description;            /**< human friendly name */
+} AVDeviceInfo;
+
+/**
+ * List of devices.
+ */
+typedef struct AVDeviceInfoList {
+    AVDeviceInfo **devices;              /**< list of autodetected devices */
+    int nb_devices;                      /**< number of autodetected devices */
+    int default_device;                  /**< index of default device or -1 if no default */
+} AVDeviceInfoList;
+
+/**
+ * List devices.
+ *
+ * Returns available device names and their parameters.
+ *
+ * @note: Some devices may accept system-dependent device names that cannot be
+ *        autodetected. The list returned by this function cannot be assumed to
+ *        be always completed.
+ *
+ * @param s                device context.
+ * @param[out] device_list list of autodetected devices.
+ * @return count of autodetected devices, negative on error.
+ */
+int avdevice_list_devices(struct AVFormatContext *s, AVDeviceInfoList **device_list);
+
+/**
+ * Convenient function to free result of avdevice_list_devices().
+ *
+ * @param devices device list to be freed.
+ */
+void avdevice_free_list_devices(AVDeviceInfoList **device_list);
+
+/**
+ * List devices.
+ *
+ * Returns available device names and their parameters.
+ * These are convinient wrappers for avdevice_list_devices().
+ * Device context is allocated and deallocated internally.
+ *
+ * @param device           device format. May be NULL if device name is set.
+ * @param device_name      device name. May be NULL if device format is set.
+ * @param device_options   An AVDictionary filled with device-private options. May be NULL.
+ *                         The same options must be passed later to avformat_write_header() for output
+ *                         devices or avformat_open_input() for input devices, or at any other place
+ *                         that affects device-private options.
+ * @param[out] device_list list of autodetected devices
+ * @return count of autodetected devices, negative on error.
+ * @note device argument takes precedence over device_name when both are set.
+ */
+int avdevice_list_input_sources(struct AVInputFormat *device, const char *device_name,
+                                AVDictionary *device_options, AVDeviceInfoList **device_list);
+int avdevice_list_output_sinks(struct AVOutputFormat *device, const char *device_name,
+                               AVDictionary *device_options, AVDeviceInfoList **device_list);
+
+/**
+ * @}
+ */
+
+#endif /* AVDEVICE_AVDEVICE_H */

ffmpeg-n4.3.2-win64-gpl-shared-4.3/include/libavdevice/version.h

@@ -0,0 +1,50 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVDEVICE_VERSION_H
+#define AVDEVICE_VERSION_H
+
+/**
+ * @file
+ * @ingroup lavd
+ * Libavdevice version macros
+ */
+
+#include "libavutil/version.h"
+
+#define LIBAVDEVICE_VERSION_MAJOR  58
+#define LIBAVDEVICE_VERSION_MINOR  10
+#define LIBAVDEVICE_VERSION_MICRO 100
+
+#define LIBAVDEVICE_VERSION_INT AV_VERSION_INT(LIBAVDEVICE_VERSION_MAJOR, \
+                                               LIBAVDEVICE_VERSION_MINOR, \
+                                               LIBAVDEVICE_VERSION_MICRO)
+#define LIBAVDEVICE_VERSION     AV_VERSION(LIBAVDEVICE_VERSION_MAJOR, \
+                                           LIBAVDEVICE_VERSION_MINOR, \
+                                           LIBAVDEVICE_VERSION_MICRO)
+#define LIBAVDEVICE_BUILD       LIBAVDEVICE_VERSION_INT
+
+#define LIBAVDEVICE_IDENT       "Lavd" AV_STRINGIFY(LIBAVDEVICE_VERSION)
+
+/**
+ * FF_API_* defines may be placed below to indicate public API that will be
+ * dropped at a future version bump. The defines themselves are not part of
+ * the public API and may change, break or disappear at any time.
+ */
+
+#endif /* AVDEVICE_VERSION_H */

ffmpeg-n4.3.2-win64-gpl-shared-4.3/include/libavfilter/buffersink.h

@@ -0,0 +1,169 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVFILTER_BUFFERSINK_H
+#define AVFILTER_BUFFERSINK_H
+
+/**
+ * @file
+ * @ingroup lavfi_buffersink
+ * memory buffer sink API for audio and video
+ */
+
+#include "avfilter.h"
+
+/**
+ * @defgroup lavfi_buffersink Buffer sink API
+ * @ingroup lavfi
+ * @{
+ */
+
+/**
+ * Get a frame with filtered data from sink and put it in frame.
+ *
+ * @param ctx    pointer to a buffersink or abuffersink filter context.
+ * @param frame  pointer to an allocated frame that will be filled with data.
+ *               The data must be freed using av_frame_unref() / av_frame_free()
+ * @param flags  a combination of AV_BUFFERSINK_FLAG_* flags
+ *
+ * @return  >= 0 in for success, a negative AVERROR code for failure.
+ */
+int av_buffersink_get_frame_flags(AVFilterContext *ctx, AVFrame *frame, int flags);
+
+/**
+ * Tell av_buffersink_get_buffer_ref() to read video/samples buffer
+ * reference, but not remove it from the buffer. This is useful if you
+ * need only to read a video/samples buffer, without to fetch it.
+ */
+#define AV_BUFFERSINK_FLAG_PEEK 1
+
+/**
+ * Tell av_buffersink_get_buffer_ref() not to request a frame from its input.
+ * If a frame is already buffered, it is read (and removed from the buffer),
+ * but if no frame is present, return AVERROR(EAGAIN).
+ */
+#define AV_BUFFERSINK_FLAG_NO_REQUEST 2
+
+#if FF_API_NEXT
+/**
+ * Struct to use for initializing a buffersink context.
+ */
+typedef struct AVBufferSinkParams {
+    const enum AVPixelFormat *pixel_fmts; ///< list of allowed pixel formats, terminated by AV_PIX_FMT_NONE
+} AVBufferSinkParams;
+
+/**
+ * Create an AVBufferSinkParams structure.
+ *
+ * Must be freed with av_free().
+ */
+attribute_deprecated
+AVBufferSinkParams *av_buffersink_params_alloc(void);
+
+/**
+ * Struct to use for initializing an abuffersink context.
+ */
+typedef struct AVABufferSinkParams {
+    const enum AVSampleFormat *sample_fmts; ///< list of allowed sample formats, terminated by AV_SAMPLE_FMT_NONE
+    const int64_t *channel_layouts;         ///< list of allowed channel layouts, terminated by -1
+    const int *channel_counts;              ///< list of allowed channel counts, terminated by -1
+    int all_channel_counts;                 ///< if not 0, accept any channel count or layout
+    int *sample_rates;                      ///< list of allowed sample rates, terminated by -1
+} AVABufferSinkParams;
+
+/**
+ * Create an AVABufferSinkParams structure.
+ *
+ * Must be freed with av_free().
+ */
+attribute_deprecated
+AVABufferSinkParams *av_abuffersink_params_alloc(void);
+#endif
+
+/**
+ * Set the frame size for an audio buffer sink.
+ *
+ * All calls to av_buffersink_get_buffer_ref will return a buffer with
+ * exactly the specified number of samples, or AVERROR(EAGAIN) if there is
+ * not enough. The last buffer at EOF will be padded with 0.
+ */
+void av_buffersink_set_frame_size(AVFilterContext *ctx, unsigned frame_size);
+
+/**
+ * @defgroup lavfi_buffersink_accessors Buffer sink accessors
+ * Get the properties of the stream
+ * @{
+ */
+
+enum AVMediaType av_buffersink_get_type                (const AVFilterContext *ctx);
+AVRational       av_buffersink_get_time_base           (const AVFilterContext *ctx);
+int              av_buffersink_get_format              (const AVFilterContext *ctx);
+
+AVRational       av_buffersink_get_frame_rate          (const AVFilterContext *ctx);
+int              av_buffersink_get_w                   (const AVFilterContext *ctx);
+int              av_buffersink_get_h                   (const AVFilterContext *ctx);
+AVRational       av_buffersink_get_sample_aspect_ratio (const AVFilterContext *ctx);
+
+int              av_buffersink_get_channels            (const AVFilterContext *ctx);
+uint64_t         av_buffersink_get_channel_layout      (const AVFilterContext *ctx);
+int              av_buffersink_get_sample_rate         (const AVFilterContext *ctx);
+
+AVBufferRef *    av_buffersink_get_hw_frames_ctx       (const AVFilterContext *ctx);
+
+/** @} */
+
+/**
+ * Get a frame with filtered data from sink and put it in frame.
+ *
+ * @param ctx pointer to a context of a buffersink or abuffersink AVFilter.
+ * @param frame pointer to an allocated frame that will be filled with data.
+ *              The data must be freed using av_frame_unref() / av_frame_free()
+ *
+ * @return
+ *         - >= 0 if a frame was successfully returned.
+ *         - AVERROR(EAGAIN) if no frames are available at this point; more
+ *           input frames must be added to the filtergraph to get more output.
+ *         - AVERROR_EOF if there will be no more output frames on this sink.
+ *         - A different negative AVERROR code in other failure cases.
+ */
+int av_buffersink_get_frame(AVFilterContext *ctx, AVFrame *frame);
+
+/**
+ * Same as av_buffersink_get_frame(), but with the ability to specify the number
+ * of samples read. This function is less efficient than
+ * av_buffersink_get_frame(), because it copies the data around.
+ *
+ * @param ctx pointer to a context of the abuffersink AVFilter.
+ * @param frame pointer to an allocated frame that will be filled with data.
+ *              The data must be freed using av_frame_unref() / av_frame_free()
+ *              frame will contain exactly nb_samples audio samples, except at
+ *              the end of stream, when it can contain less than nb_samples.
+ *
+ * @return The return codes have the same meaning as for
+ *         av_buffersink_get_frame().
+ *
+ * @warning do not mix this function with av_buffersink_get_frame(). Use only one or
+ * the other with a single sink, not both.
+ */
+int av_buffersink_get_samples(AVFilterContext *ctx, AVFrame *frame, int nb_samples);
+
+/**
+ * @}
+ */
+
+#endif /* AVFILTER_BUFFERSINK_H */

ffmpeg-n4.3.2-win64-gpl-shared-4.3/include/libavfilter/buffersrc.h

@@ -0,0 +1,209 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVFILTER_BUFFERSRC_H
+#define AVFILTER_BUFFERSRC_H
+
+/**
+ * @file
+ * @ingroup lavfi_buffersrc
+ * Memory buffer source API.
+ */
+
+#include "avfilter.h"
+
+/**
+ * @defgroup lavfi_buffersrc Buffer source API
+ * @ingroup lavfi
+ * @{
+ */
+
+enum {
+
+    /**
+     * Do not check for format changes.
+     */
+    AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT = 1,
+
+    /**
+     * Immediately push the frame to the output.
+     */
+    AV_BUFFERSRC_FLAG_PUSH = 4,
+
+    /**
+     * Keep a reference to the frame.
+     * If the frame if reference-counted, create a new reference; otherwise
+     * copy the frame data.
+     */
+    AV_BUFFERSRC_FLAG_KEEP_REF = 8,
+
+};
+
+/**
+ * Get the number of failed requests.
+ *
+ * A failed request is when the request_frame method is called while no
+ * frame is present in the buffer.
+ * The number is reset when a frame is added.
+ */
+unsigned av_buffersrc_get_nb_failed_requests(AVFilterContext *buffer_src);
+
+/**
+ * This structure contains the parameters describing the frames that will be
+ * passed to this filter.
+ *
+ * It should be allocated with av_buffersrc_parameters_alloc() and freed with
+ * av_free(). All the allocated fields in it remain owned by the caller.
+ */
+typedef struct AVBufferSrcParameters {
+    /**
+     * video: the pixel format, value corresponds to enum AVPixelFormat
+     * audio: the sample format, value corresponds to enum AVSampleFormat
+     */
+    int format;
+    /**
+     * The timebase to be used for the timestamps on the input frames.
+     */
+    AVRational time_base;
+
+    /**
+     * Video only, the display dimensions of the input frames.
+     */
+    int width, height;
+
+    /**
+     * Video only, the sample (pixel) aspect ratio.
+     */
+    AVRational sample_aspect_ratio;
+
+    /**
+     * Video only, the frame rate of the input video. This field must only be
+     * set to a non-zero value if input stream has a known constant framerate
+     * and should be left at its initial value if the framerate is variable or
+     * unknown.
+     */
+    AVRational frame_rate;
+
+    /**
+     * Video with a hwaccel pixel format only. This should be a reference to an
+     * AVHWFramesContext instance describing the input frames.
+     */
+    AVBufferRef *hw_frames_ctx;
+
+    /**
+     * Audio only, the audio sampling rate in samples per second.
+     */
+    int sample_rate;
+
+    /**
+     * Audio only, the audio channel layout
+     */
+    uint64_t channel_layout;
+} AVBufferSrcParameters;
+
+/**
+ * Allocate a new AVBufferSrcParameters instance. It should be freed by the
+ * caller with av_free().
+ */
+AVBufferSrcParameters *av_buffersrc_parameters_alloc(void);
+
+/**
+ * Initialize the buffersrc or abuffersrc filter with the provided parameters.
+ * This function may be called multiple times, the later calls override the
+ * previous ones. Some of the parameters may also be set through AVOptions, then
+ * whatever method is used last takes precedence.
+ *
+ * @param ctx an instance of the buffersrc or abuffersrc filter
+ * @param param the stream parameters. The frames later passed to this filter
+ *              must conform to those parameters. All the allocated fields in
+ *              param remain owned by the caller, libavfilter will make internal
+ *              copies or references when necessary.
+ * @return 0 on success, a negative AVERROR code on failure.
+ */
+int av_buffersrc_parameters_set(AVFilterContext *ctx, AVBufferSrcParameters *param);
+
+/**
+ * Add a frame to the buffer source.
+ *
+ * @param ctx   an instance of the buffersrc filter
+ * @param frame frame to be added. If the frame is reference counted, this
+ * function will make a new reference to it. Otherwise the frame data will be
+ * copied.
+ *
+ * @return 0 on success, a negative AVERROR on error
+ *
+ * This function is equivalent to av_buffersrc_add_frame_flags() with the
+ * AV_BUFFERSRC_FLAG_KEEP_REF flag.
+ */
+av_warn_unused_result
+int av_buffersrc_write_frame(AVFilterContext *ctx, const AVFrame *frame);
+
+/**
+ * Add a frame to the buffer source.
+ *
+ * @param ctx   an instance of the buffersrc filter
+ * @param frame frame to be added. If the frame is reference counted, this
+ * function will take ownership of the reference(s) and reset the frame.
+ * Otherwise the frame data will be copied. If this function returns an error,
+ * the input frame is not touched.
+ *
+ * @return 0 on success, a negative AVERROR on error.
+ *
+ * @note the difference between this function and av_buffersrc_write_frame() is
+ * that av_buffersrc_write_frame() creates a new reference to the input frame,
+ * while this function takes ownership of the reference passed to it.
+ *
+ * This function is equivalent to av_buffersrc_add_frame_flags() without the
+ * AV_BUFFERSRC_FLAG_KEEP_REF flag.
+ */
+av_warn_unused_result
+int av_buffersrc_add_frame(AVFilterContext *ctx, AVFrame *frame);
+
+/**
+ * Add a frame to the buffer source.
+ *
+ * By default, if the frame is reference-counted, this function will take
+ * ownership of the reference(s) and reset the frame. This can be controlled
+ * using the flags.
+ *
+ * If this function returns an error, the input frame is not touched.
+ *
+ * @param buffer_src  pointer to a buffer source context
+ * @param frame       a frame, or NULL to mark EOF
+ * @param flags       a combination of AV_BUFFERSRC_FLAG_*
+ * @return            >= 0 in case of success, a negative AVERROR code
+ *                    in case of failure
+ */
+av_warn_unused_result
+int av_buffersrc_add_frame_flags(AVFilterContext *buffer_src,
+                                 AVFrame *frame, int flags);
+
+/**
+ * Close the buffer source after EOF.
+ *
+ * This is similar to passing NULL to av_buffersrc_add_frame_flags()
+ * except it takes the timestamp of the EOF, i.e. the timestamp of the end
+ * of the last frame.
+ */
+int av_buffersrc_close(AVFilterContext *ctx, int64_t pts, unsigned flags);
+
+/**
+ * @}
+ */
+
+#endif /* AVFILTER_BUFFERSRC_H */

ffmpeg-n4.3.2-win64-gpl-shared-4.3/include/libavfilter/version.h

@@ -0,0 +1,69 @@
+/*
+ * Version macros.
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVFILTER_VERSION_H
+#define AVFILTER_VERSION_H
+
+/**
+ * @file
+ * @ingroup lavfi
+ * Libavfilter version macros
+ */
+
+#include "libavutil/version.h"
+
+#define LIBAVFILTER_VERSION_MAJOR   7
+#define LIBAVFILTER_VERSION_MINOR  85
+#define LIBAVFILTER_VERSION_MICRO 100
+
+
+#define LIBAVFILTER_VERSION_INT AV_VERSION_INT(LIBAVFILTER_VERSION_MAJOR, \
+                                               LIBAVFILTER_VERSION_MINOR, \
+                                               LIBAVFILTER_VERSION_MICRO)
+#define LIBAVFILTER_VERSION     AV_VERSION(LIBAVFILTER_VERSION_MAJOR,   \
+                                           LIBAVFILTER_VERSION_MINOR,   \
+                                           LIBAVFILTER_VERSION_MICRO)
+#define LIBAVFILTER_BUILD       LIBAVFILTER_VERSION_INT
+
+#define LIBAVFILTER_IDENT       "Lavfi" AV_STRINGIFY(LIBAVFILTER_VERSION)
+
+/**
+ * FF_API_* defines may be placed below to indicate public API that will be
+ * dropped at a future version bump. The defines themselves are not part of
+ * the public API and may change, break or disappear at any time.
+ */
+
+#ifndef FF_API_OLD_FILTER_OPTS_ERROR
+#define FF_API_OLD_FILTER_OPTS_ERROR        (LIBAVFILTER_VERSION_MAJOR < 8)
+#endif
+#ifndef FF_API_LAVR_OPTS
+#define FF_API_LAVR_OPTS                    (LIBAVFILTER_VERSION_MAJOR < 8)
+#endif
+#ifndef FF_API_FILTER_GET_SET
+#define FF_API_FILTER_GET_SET               (LIBAVFILTER_VERSION_MAJOR < 8)
+#endif
+#ifndef FF_API_SWS_PARAM_OPTION
+#define FF_API_SWS_PARAM_OPTION             (LIBAVFILTER_VERSION_MAJOR < 8)
+#endif
+#ifndef FF_API_NEXT
+#define FF_API_NEXT                         (LIBAVFILTER_VERSION_MAJOR < 8)
+#endif
+
+#endif /* AVFILTER_VERSION_H */

ffmpeg-n4.3.2-win64-gpl-shared-4.3/include/libavformat/avio.h

@@ -0,0 +1,888 @@
+/*
+ * copyright (c) 2001 Fabrice Bellard
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+#ifndef AVFORMAT_AVIO_H
+#define AVFORMAT_AVIO_H
+
+/**
+ * @file
+ * @ingroup lavf_io
+ * Buffered I/O operations
+ */
+
+#include <stdint.h>
+
+#include "libavutil/common.h"
+#include "libavutil/dict.h"
+#include "libavutil/log.h"
+
+#include "libavformat/version.h"
+
+/**
+ * Seeking works like for a local file.
+ */
+#define AVIO_SEEKABLE_NORMAL (1 << 0)
+
+/**
+ * Seeking by timestamp with avio_seek_time() is possible.
+ */
+#define AVIO_SEEKABLE_TIME   (1 << 1)
+
+/**
+ * Callback for checking whether to abort blocking functions.
+ * AVERROR_EXIT is returned in this case by the interrupted
+ * function. During blocking operations, callback is called with
+ * opaque as parameter. If the callback returns 1, the
+ * blocking operation will be aborted.
+ *
+ * No members can be added to this struct without a major bump, if
+ * new elements have been added after this struct in AVFormatContext
+ * or AVIOContext.
+ */
+typedef struct AVIOInterruptCB {
+    int (*callback)(void*);
+    void *opaque;
+} AVIOInterruptCB;
+
+/**
+ * Directory entry types.
+ */
+enum AVIODirEntryType {
+    AVIO_ENTRY_UNKNOWN,
+    AVIO_ENTRY_BLOCK_DEVICE,
+    AVIO_ENTRY_CHARACTER_DEVICE,
+    AVIO_ENTRY_DIRECTORY,
+    AVIO_ENTRY_NAMED_PIPE,
+    AVIO_ENTRY_SYMBOLIC_LINK,
+    AVIO_ENTRY_SOCKET,
+    AVIO_ENTRY_FILE,
+    AVIO_ENTRY_SERVER,
+    AVIO_ENTRY_SHARE,
+    AVIO_ENTRY_WORKGROUP,
+};
+
+/**
+ * Describes single entry of the directory.
+ *
+ * Only name and type fields are guaranteed be set.
+ * Rest of fields are protocol or/and platform dependent and might be unknown.
+ */
+typedef struct AVIODirEntry {
+    char *name;                           /**< Filename */
+    int type;                             /**< Type of the entry */
+    int utf8;                             /**< Set to 1 when name is encoded with UTF-8, 0 otherwise.
+                                               Name can be encoded with UTF-8 even though 0 is set. */
+    int64_t size;                         /**< File size in bytes, -1 if unknown. */
+    int64_t modification_timestamp;       /**< Time of last modification in microseconds since unix
+                                               epoch, -1 if unknown. */
+    int64_t access_timestamp;             /**< Time of last access in microseconds since unix epoch,
+                                               -1 if unknown. */
+    int64_t status_change_timestamp;      /**< Time of last status change in microseconds since unix
+                                               epoch, -1 if unknown. */
+    int64_t user_id;                      /**< User ID of owner, -1 if unknown. */
+    int64_t group_id;                     /**< Group ID of owner, -1 if unknown. */
+    int64_t filemode;                     /**< Unix file mode, -1 if unknown. */
+} AVIODirEntry;
+
+typedef struct AVIODirContext {
+    struct URLContext *url_context;
+} AVIODirContext;
+
+/**
+ * Different data types that can be returned via the AVIO
+ * write_data_type callback.
+ */
+enum AVIODataMarkerType {
+    /**
+     * Header data; this needs to be present for the stream to be decodeable.
+     */
+    AVIO_DATA_MARKER_HEADER,
+    /**
+     * A point in the output bytestream where a decoder can start decoding
+     * (i.e. a keyframe). A demuxer/decoder given the data flagged with
+     * AVIO_DATA_MARKER_HEADER, followed by any AVIO_DATA_MARKER_SYNC_POINT,
+     * should give decodeable results.
+     */
+    AVIO_DATA_MARKER_SYNC_POINT,
+    /**
+     * A point in the output bytestream where a demuxer can start parsing
+     * (for non self synchronizing bytestream formats). That is, any
+     * non-keyframe packet start point.
+     */
+    AVIO_DATA_MARKER_BOUNDARY_POINT,
+    /**
+     * This is any, unlabelled data. It can either be a muxer not marking
+     * any positions at all, it can be an actual boundary/sync point
+     * that the muxer chooses not to mark, or a later part of a packet/fragment
+     * that is cut into multiple write callbacks due to limited IO buffer size.
+     */
+    AVIO_DATA_MARKER_UNKNOWN,
+    /**
+     * Trailer data, which doesn't contain actual content, but only for
+     * finalizing the output file.
+     */
+    AVIO_DATA_MARKER_TRAILER,
+    /**
+     * A point in the output bytestream where the underlying AVIOContext might
+     * flush the buffer depending on latency or buffering requirements. Typically
+     * means the end of a packet.
+     */
+    AVIO_DATA_MARKER_FLUSH_POINT,
+};
+
+/**
+ * Bytestream IO Context.
+ * New fields can be added to the end with minor version bumps.
+ * Removal, reordering and changes to existing fields require a major
+ * version bump.
+ * sizeof(AVIOContext) must not be used outside libav*.
+ *
+ * @note None of the function pointers in AVIOContext should be called
+ *       directly, they should only be set by the client application
+ *       when implementing custom I/O. Normally these are set to the
+ *       function pointers specified in avio_alloc_context()
+ */
+typedef struct AVIOContext {
+    /**
+     * A class for private options.
+     *
+     * If this AVIOContext is created by avio_open2(), av_class is set and
+     * passes the options down to protocols.
+     *
+     * If this AVIOContext is manually allocated, then av_class may be set by
+     * the caller.
+     *
+     * warning -- this field can be NULL, be sure to not pass this AVIOContext
+     * to any av_opt_* functions in that case.
+     */
+    const AVClass *av_class;
+
+    /*
+     * The following shows the relationship between buffer, buf_ptr,
+     * buf_ptr_max, buf_end, buf_size, and pos, when reading and when writing
+     * (since AVIOContext is used for both):
+     *
+     **********************************************************************************
+     *                                   READING
+     **********************************************************************************
+     *
+     *                            |              buffer_size              |
+     *                            |---------------------------------------|
+     *                            |                                       |
+     *
+     *                         buffer          buf_ptr       buf_end
+     *                            +---------------+-----------------------+
+     *                            |/ / / / / / / /|/ / / / / / /|         |
+     *  read buffer:              |/ / consumed / | to be read /|         |
+     *                            |/ / / / / / / /|/ / / / / / /|         |
+     *                            +---------------+-----------------------+
+     *
+     *                                                         pos
+     *              +-------------------------------------------+-----------------+
+     *  input file: |                                           |                 |
+     *              +-------------------------------------------+-----------------+
+     *
+     *
+     **********************************************************************************
+     *                                   WRITING
+     **********************************************************************************
+     *
+     *                             |          buffer_size                 |
+     *                             |--------------------------------------|
+     *                             |                                      |
+     *
+     *                                                buf_ptr_max
+     *                          buffer                 (buf_ptr)       buf_end
+     *                             +-----------------------+--------------+
+     *                             |/ / / / / / / / / / / /|              |
+     *  write buffer:              | / / to be flushed / / |              |
+     *                             |/ / / / / / / / / / / /|              |
+     *                             +-----------------------+--------------+
+     *                               buf_ptr can be in this
+     *                               due to a backward seek
+     *
+     *                            pos
+     *               +-------------+----------------------------------------------+
+     *  output file: |             |                                              |
+     *               +-------------+----------------------------------------------+
+     *
+     */
+    unsigned char *buffer;  /**< Start of the buffer. */
+    int buffer_size;        /**< Maximum buffer size */
+    unsigned char *buf_ptr; /**< Current position in the buffer */
+    unsigned char *buf_end; /**< End of the data, may be less than
+                                 buffer+buffer_size if the read function returned
+                                 less data than requested, e.g. for streams where
+                                 no more data has been received yet. */
+    void *opaque;           /**< A private pointer, passed to the read/write/seek/...
+                                 functions. */
+    int (*read_packet)(void *opaque, uint8_t *buf, int buf_size);
+    int (*write_packet)(void *opaque, uint8_t *buf, int buf_size);
+    int64_t (*seek)(void *opaque, int64_t offset, int whence);
+    int64_t pos;            /**< position in the file of the current buffer */
+    int eof_reached;        /**< true if was unable to read due to error or eof */
+    int write_flag;         /**< true if open for writing */
+    int max_packet_size;
+    unsigned long checksum;
+    unsigned char *checksum_ptr;
+    unsigned long (*update_checksum)(unsigned long checksum, const uint8_t *buf, unsigned int size);
+    int error;              /**< contains the error code or 0 if no error happened */
+    /**
+     * Pause or resume playback for network streaming protocols - e.g. MMS.
+     */
+    int (*read_pause)(void *opaque, int pause);
+    /**
+     * Seek to a given timestamp in stream with the specified stream_index.
+     * Needed for some network streaming protocols which don't support seeking
+     * to byte position.
+     */
+    int64_t (*read_seek)(void *opaque, int stream_index,
+                         int64_t timestamp, int flags);
+    /**
+     * A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
+     */
+    int seekable;
+
+    /**
+     * max filesize, used to limit allocations
+     * This field is internal to libavformat and access from outside is not allowed.
+     */
+    int64_t maxsize;
+
+    /**
+     * avio_read and avio_write should if possible be satisfied directly
+     * instead of going through a buffer, and avio_seek will always
+     * call the underlying seek function directly.
+     */
+    int direct;
+
+    /**
+     * Bytes read statistic
+     * This field is internal to libavformat and access from outside is not allowed.
+     */
+    int64_t bytes_read;
+
+    /**
+     * seek statistic
+     * This field is internal to libavformat and access from outside is not allowed.
+     */
+    int seek_count;
+
+    /**
+     * writeout statistic
+     * This field is internal to libavformat and access from outside is not allowed.
+     */
+    int writeout_count;
+
+    /**
+     * Original buffer size
+     * used internally after probing and ensure seekback to reset the buffer size
+     * This field is internal to libavformat and access from outside is not allowed.
+     */
+    int orig_buffer_size;
+
+    /**
+     * Threshold to favor readahead over seek.
+     * This is current internal only, do not use from outside.
+     */
+    int short_seek_threshold;
+
+    /**
+     * ',' separated list of allowed protocols.
+     */
+    const char *protocol_whitelist;
+
+    /**
+     * ',' separated list of disallowed protocols.
+     */
+    const char *protocol_blacklist;
+
+    /**
+     * A callback that is used instead of write_packet.
+     */
+    int (*write_data_type)(void *opaque, uint8_t *buf, int buf_size,
+                           enum AVIODataMarkerType type, int64_t time);
+    /**
+     * If set, don't call write_data_type separately for AVIO_DATA_MARKER_BOUNDARY_POINT,
+     * but ignore them and treat them as AVIO_DATA_MARKER_UNKNOWN (to avoid needlessly
+     * small chunks of data returned from the callback).
+     */
+    int ignore_boundary_point;
+
+    /**
+     * Internal, not meant to be used from outside of AVIOContext.
+     */
+    enum AVIODataMarkerType current_type;
+    int64_t last_time;
+
+    /**
+     * A callback that is used instead of short_seek_threshold.
+     * This is current internal only, do not use from outside.
+     */
+    int (*short_seek_get)(void *opaque);
+
+    int64_t written;
+
+    /**
+     * Maximum reached position before a backward seek in the write buffer,
+     * used keeping track of already written data for a later flush.
+     */
+    unsigned char *buf_ptr_max;
+
+    /**
+     * Try to buffer at least this amount of data before flushing it
+     */
+    int min_packet_size;
+} AVIOContext;
+
+/**
+ * Return the name of the protocol that will handle the passed URL.
+ *
+ * NULL is returned if no protocol could be found for the given URL.
+ *
+ * @return Name of the protocol or NULL.
+ */
+const char *avio_find_protocol_name(const char *url);
+
+/**
+ * Return AVIO_FLAG_* access flags corresponding to the access permissions
+ * of the resource in url, or a negative value corresponding to an
+ * AVERROR code in case of failure. The returned access flags are
+ * masked by the value in flags.
+ *
+ * @note This function is intrinsically unsafe, in the sense that the
+ * checked resource may change its existence or permission status from
+ * one call to another. Thus you should not trust the returned value,
+ * unless you are sure that no other processes are accessing the
+ * checked resource.
+ */
+int avio_check(const char *url, int flags);
+
+/**
+ * Move or rename a resource.
+ *
+ * @note url_src and url_dst should share the same protocol and authority.
+ *
+ * @param url_src url to resource to be moved
+ * @param url_dst new url to resource if the operation succeeded
+ * @return >=0 on success or negative on error.
+ */
+int avpriv_io_move(const char *url_src, const char *url_dst);
+
+/**
+ * Delete a resource.
+ *
+ * @param url resource to be deleted.
+ * @return >=0 on success or negative on error.
+ */
+int avpriv_io_delete(const char *url);
+
+/**
+ * Open directory for reading.
+ *
+ * @param s       directory read context. Pointer to a NULL pointer must be passed.
+ * @param url     directory to be listed.
+ * @param options A dictionary filled with protocol-private options. On return
+ *                this parameter will be destroyed and replaced with a dictionary
+ *                containing options that were not found. May be NULL.
+ * @return >=0 on success or negative on error.
+ */
+int avio_open_dir(AVIODirContext **s, const char *url, AVDictionary **options);
+
+/**
+ * Get next directory entry.
+ *
+ * Returned entry must be freed with avio_free_directory_entry(). In particular
+ * it may outlive AVIODirContext.
+ *
+ * @param s         directory read context.
+ * @param[out] next next entry or NULL when no more entries.
+ * @return >=0 on success or negative on error. End of list is not considered an
+ *             error.
+ */
+int avio_read_dir(AVIODirContext *s, AVIODirEntry **next);
+
+/**
+ * Close directory.
+ *
+ * @note Entries created using avio_read_dir() are not deleted and must be
+ * freeded with avio_free_directory_entry().
+ *
+ * @param s         directory read context.
+ * @return >=0 on success or negative on error.
+ */
+int avio_close_dir(AVIODirContext **s);
+
+/**
+ * Free entry allocated by avio_read_dir().
+ *
+ * @param entry entry to be freed.
+ */
+void avio_free_directory_entry(AVIODirEntry **entry);
+
+/**
+ * Allocate and initialize an AVIOContext for buffered I/O. It must be later
+ * freed with avio_context_free().
+ *
+ * @param buffer Memory block for input/output operations via AVIOContext.
+ *        The buffer must be allocated with av_malloc() and friends.
+ *        It may be freed and replaced with a new buffer by libavformat.
+ *        AVIOContext.buffer holds the buffer currently in use,
+ *        which must be later freed with av_free().
+ * @param buffer_size The buffer size is very important for performance.
+ *        For protocols with fixed blocksize it should be set to this blocksize.
+ *        For others a typical size is a cache page, e.g. 4kb.
+ * @param write_flag Set to 1 if the buffer should be writable, 0 otherwise.
+ * @param opaque An opaque pointer to user-specific data.
+ * @param read_packet  A function for refilling the buffer, may be NULL.
+ *                     For stream protocols, must never return 0 but rather
+ *                     a proper AVERROR code.
+ * @param write_packet A function for writing the buffer contents, may be NULL.
+ *        The function may not change the input buffers content.
+ * @param seek A function for seeking to specified byte position, may be NULL.
+ *
+ * @return Allocated AVIOContext or NULL on failure.
+ */
+AVIOContext *avio_alloc_context(
+                  unsigned char *buffer,
+                  int buffer_size,
+                  int write_flag,
+                  void *opaque,
+                  int (*read_packet)(void *opaque, uint8_t *buf, int buf_size),
+                  int (*write_packet)(void *opaque, uint8_t *buf, int buf_size),
+                  int64_t (*seek)(void *opaque, int64_t offset, int whence));
+
+/**
+ * Free the supplied IO context and everything associated with it.
+ *
+ * @param s Double pointer to the IO context. This function will write NULL
+ * into s.
+ */
+void avio_context_free(AVIOContext **s);
+
+void avio_w8(AVIOContext *s, int b);
+void avio_write(AVIOContext *s, const unsigned char *buf, int size);
+void avio_wl64(AVIOContext *s, uint64_t val);
+void avio_wb64(AVIOContext *s, uint64_t val);
+void avio_wl32(AVIOContext *s, unsigned int val);
+void avio_wb32(AVIOContext *s, unsigned int val);
+void avio_wl24(AVIOContext *s, unsigned int val);
+void avio_wb24(AVIOContext *s, unsigned int val);
+void avio_wl16(AVIOContext *s, unsigned int val);
+void avio_wb16(AVIOContext *s, unsigned int val);
+
+/**
+ * Write a NULL-terminated string.
+ * @return number of bytes written.
+ */
+int avio_put_str(AVIOContext *s, const char *str);
+
+/**
+ * Convert an UTF-8 string to UTF-16LE and write it.
+ * @param s the AVIOContext
+ * @param str NULL-terminated UTF-8 string
+ *
+ * @return number of bytes written.
+ */
+int avio_put_str16le(AVIOContext *s, const char *str);
+
+/**
+ * Convert an UTF-8 string to UTF-16BE and write it.
+ * @param s the AVIOContext
+ * @param str NULL-terminated UTF-8 string
+ *
+ * @return number of bytes written.
+ */
+int avio_put_str16be(AVIOContext *s, const char *str);
+
+/**
+ * Mark the written bytestream as a specific type.
+ *
+ * Zero-length ranges are omitted from the output.
+ *
+ * @param time the stream time the current bytestream pos corresponds to
+ *             (in AV_TIME_BASE units), or AV_NOPTS_VALUE if unknown or not
+ *             applicable
+ * @param type the kind of data written starting at the current pos
+ */
+void avio_write_marker(AVIOContext *s, int64_t time, enum AVIODataMarkerType type);
+
+/**
+ * ORing this as the "whence" parameter to a seek function causes it to
+ * return the filesize without seeking anywhere. Supporting this is optional.
+ * If it is not supported then the seek function will return <0.
+ */
+#define AVSEEK_SIZE 0x10000
+
+/**
+ * Passing this flag as the "whence" parameter to a seek function causes it to
+ * seek by any means (like reopening and linear reading) or other normally unreasonable
+ * means that can be extremely slow.
+ * This may be ignored by the seek code.
+ */
+#define AVSEEK_FORCE 0x20000
+
+/**
+ * fseek() equivalent for AVIOContext.
+ * @return new position or AVERROR.
+ */
+int64_t avio_seek(AVIOContext *s, int64_t offset, int whence);
+
+/**
+ * Skip given number of bytes forward
+ * @return new position or AVERROR.
+ */
+int64_t avio_skip(AVIOContext *s, int64_t offset);
+
+/**
+ * ftell() equivalent for AVIOContext.
+ * @return position or AVERROR.
+ */
+static av_always_inline int64_t avio_tell(AVIOContext *s)
+{
+    return avio_seek(s, 0, SEEK_CUR);
+}
+
+/**
+ * Get the filesize.
+ * @return filesize or AVERROR
+ */
+int64_t avio_size(AVIOContext *s);
+
+/**
+ * Similar to feof() but also returns nonzero on read errors.
+ * @return non zero if and only if at end of file or a read error happened when reading.
+ */
+int avio_feof(AVIOContext *s);
+
+/**
+ * Writes a formatted string to the context.
+ * @return number of bytes written, < 0 on error.
+ */
+int avio_printf(AVIOContext *s, const char *fmt, ...) av_printf_format(2, 3);
+
+/**
+ * Write a NULL terminated array of strings to the context.
+ * Usually you don't need to use this function directly but its macro wrapper,
+ * avio_print.
+ */
+void avio_print_string_array(AVIOContext *s, const char *strings[]);
+
+/**
+ * Write strings (const char *) to the context.
+ * This is a convenience macro around avio_print_string_array and it
+ * automatically creates the string array from the variable argument list.
+ * For simple string concatenations this function is more performant than using
+ * avio_printf since it does not need a temporary buffer.
+ */
+#define avio_print(s, ...) \
+    avio_print_string_array(s, (const char*[]){__VA_ARGS__, NULL})
+
+/**
+ * Force flushing of buffered data.
+ *
+ * For write streams, force the buffered data to be immediately written to the output,
+ * without to wait to fill the internal buffer.
+ *
+ * For read streams, discard all currently buffered data, and advance the
+ * reported file position to that of the underlying stream. This does not
+ * read new data, and does not perform any seeks.
+ */
+void avio_flush(AVIOContext *s);
+
+/**
+ * Read size bytes from AVIOContext into buf.
+ * @return number of bytes read or AVERROR
+ */
+int avio_read(AVIOContext *s, unsigned char *buf, int size);
+
+/**
+ * Read size bytes from AVIOContext into buf. Unlike avio_read(), this is allowed
+ * to read fewer bytes than requested. The missing bytes can be read in the next
+ * call. This always tries to read at least 1 byte.
+ * Useful to reduce latency in certain cases.
+ * @return number of bytes read or AVERROR
+ */
+int avio_read_partial(AVIOContext *s, unsigned char *buf, int size);
+
+/**
+ * @name Functions for reading from AVIOContext
+ * @{
+ *
+ * @note return 0 if EOF, so you cannot use it if EOF handling is
+ *       necessary
+ */
+int          avio_r8  (AVIOContext *s);
+unsigned int avio_rl16(AVIOContext *s);
+unsigned int avio_rl24(AVIOContext *s);
+unsigned int avio_rl32(AVIOContext *s);
+uint64_t     avio_rl64(AVIOContext *s);
+unsigned int avio_rb16(AVIOContext *s);
+unsigned int avio_rb24(AVIOContext *s);
+unsigned int avio_rb32(AVIOContext *s);
+uint64_t     avio_rb64(AVIOContext *s);
+/**
+ * @}
+ */
+
+/**
+ * Read a string from pb into buf. The reading will terminate when either
+ * a NULL character was encountered, maxlen bytes have been read, or nothing
+ * more can be read from pb. The result is guaranteed to be NULL-terminated, it
+ * will be truncated if buf is too small.
+ * Note that the string is not interpreted or validated in any way, it
+ * might get truncated in the middle of a sequence for multi-byte encodings.
+ *
+ * @return number of bytes read (is always <= maxlen).
+ * If reading ends on EOF or error, the return value will be one more than
+ * bytes actually read.
+ */
+int avio_get_str(AVIOContext *pb, int maxlen, char *buf, int buflen);
+
+/**
+ * Read a UTF-16 string from pb and convert it to UTF-8.
+ * The reading will terminate when either a null or invalid character was
+ * encountered or maxlen bytes have been read.
+ * @return number of bytes read (is always <= maxlen)
+ */
+int avio_get_str16le(AVIOContext *pb, int maxlen, char *buf, int buflen);
+int avio_get_str16be(AVIOContext *pb, int maxlen, char *buf, int buflen);
+
+
+/**
+ * @name URL open modes
+ * The flags argument to avio_open must be one of the following
+ * constants, optionally ORed with other flags.
+ * @{
+ */
+#define AVIO_FLAG_READ  1                                      /**< read-only */
+#define AVIO_FLAG_WRITE 2                                      /**< write-only */
+#define AVIO_FLAG_READ_WRITE (AVIO_FLAG_READ|AVIO_FLAG_WRITE)  /**< read-write pseudo flag */
+/**
+ * @}
+ */
+
+/**
+ * Use non-blocking mode.
+ * If this flag is set, operations on the context will return
+ * AVERROR(EAGAIN) if they can not be performed immediately.
+ * If this flag is not set, operations on the context will never return
+ * AVERROR(EAGAIN).
+ * Note that this flag does not affect the opening/connecting of the
+ * context. Connecting a protocol will always block if necessary (e.g. on
+ * network protocols) but never hang (e.g. on busy devices).
+ * Warning: non-blocking protocols is work-in-progress; this flag may be
+ * silently ignored.
+ */
+#define AVIO_FLAG_NONBLOCK 8
+
+/**
+ * Use direct mode.
+ * avio_read and avio_write should if possible be satisfied directly
+ * instead of going through a buffer, and avio_seek will always
+ * call the underlying seek function directly.
+ */
+#define AVIO_FLAG_DIRECT 0x8000
+
+/**
+ * Create and initialize a AVIOContext for accessing the
+ * resource indicated by url.
+ * @note When the resource indicated by url has been opened in
+ * read+write mode, the AVIOContext can be used only for writing.
+ *
+ * @param s Used to return the pointer to the created AVIOContext.
+ * In case of failure the pointed to value is set to NULL.
+ * @param url resource to access
+ * @param flags flags which control how the resource indicated by url
+ * is to be opened
+ * @return >= 0 in case of success, a negative value corresponding to an
+ * AVERROR code in case of failure
+ */
+int avio_open(AVIOContext **s, const char *url, int flags);
+
+/**
+ * Create and initialize a AVIOContext for accessing the
+ * resource indicated by url.
+ * @note When the resource indicated by url has been opened in
+ * read+write mode, the AVIOContext can be used only for writing.
+ *
+ * @param s Used to return the pointer to the created AVIOContext.
+ * In case of failure the pointed to value is set to NULL.
+ * @param url resource to access
+ * @param flags flags which control how the resource indicated by url
+ * is to be opened
+ * @param int_cb an interrupt callback to be used at the protocols level
+ * @param options  A dictionary filled with protocol-private options. On return
+ * this parameter will be destroyed and replaced with a dict containing options
+ * that were not found. May be NULL.
+ * @return >= 0 in case of success, a negative value corresponding to an
+ * AVERROR code in case of failure
+ */
+int avio_open2(AVIOContext **s, const char *url, int flags,
+               const AVIOInterruptCB *int_cb, AVDictionary **options);
+
+/**
+ * Close the resource accessed by the AVIOContext s and free it.
+ * This function can only be used if s was opened by avio_open().
+ *
+ * The internal buffer is automatically flushed before closing the
+ * resource.
+ *
+ * @return 0 on success, an AVERROR < 0 on error.
+ * @see avio_closep
+ */
+int avio_close(AVIOContext *s);
+
+/**
+ * Close the resource accessed by the AVIOContext *s, free it
+ * and set the pointer pointing to it to NULL.
+ * This function can only be used if s was opened by avio_open().
+ *
+ * The internal buffer is automatically flushed before closing the
+ * resource.
+ *
+ * @return 0 on success, an AVERROR < 0 on error.
+ * @see avio_close
+ */
+int avio_closep(AVIOContext **s);
+
+
+/**
+ * Open a write only memory stream.
+ *
+ * @param s new IO context
+ * @return zero if no error.
+ */
+int avio_open_dyn_buf(AVIOContext **s);
+
+/**
+ * Return the written size and a pointer to the buffer.
+ * The AVIOContext stream is left intact.
+ * The buffer must NOT be freed.
+ * No padding is added to the buffer.
+ *
+ * @param s IO context
+ * @param pbuffer pointer to a byte buffer
+ * @return the length of the byte buffer
+ */
+int avio_get_dyn_buf(AVIOContext *s, uint8_t **pbuffer);
+
+/**
+ * Return the written size and a pointer to the buffer. The buffer
+ * must be freed with av_free().
+ * Padding of AV_INPUT_BUFFER_PADDING_SIZE is added to the buffer.
+ *
+ * @param s IO context
+ * @param pbuffer pointer to a byte buffer
+ * @return the length of the byte buffer
+ */
+int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer);
+
+/**
+ * Iterate through names of available protocols.
+ *
+ * @param opaque A private pointer representing current protocol.
+ *        It must be a pointer to NULL on first iteration and will
+ *        be updated by successive calls to avio_enum_protocols.
+ * @param output If set to 1, iterate over output protocols,
+ *               otherwise over input protocols.
+ *
+ * @return A static string containing the name of current protocol or NULL
+ */
+const char *avio_enum_protocols(void **opaque, int output);
+
+/**
+ * Get AVClass by names of available protocols.
+ *
+ * @return A AVClass of input protocol name or NULL
+ */
+const AVClass *avio_protocol_get_class(const char *name);
+
+/**
+ * Pause and resume playing - only meaningful if using a network streaming
+ * protocol (e.g. MMS).
+ *
+ * @param h     IO context from which to call the read_pause function pointer
+ * @param pause 1 for pause, 0 for resume
+ */
+int     avio_pause(AVIOContext *h, int pause);
+
+/**
+ * Seek to a given timestamp relative to some component stream.
+ * Only meaningful if using a network streaming protocol (e.g. MMS.).
+ *
+ * @param h IO context from which to call the seek function pointers
+ * @param stream_index The stream index that the timestamp is relative to.
+ *        If stream_index is (-1) the timestamp should be in AV_TIME_BASE
+ *        units from the beginning of the presentation.
+ *        If a stream_index >= 0 is used and the protocol does not support
+ *        seeking based on component streams, the call will fail.
+ * @param timestamp timestamp in AVStream.time_base units
+ *        or if there is no stream specified then in AV_TIME_BASE units.
+ * @param flags Optional combination of AVSEEK_FLAG_BACKWARD, AVSEEK_FLAG_BYTE
+ *        and AVSEEK_FLAG_ANY. The protocol may silently ignore
+ *        AVSEEK_FLAG_BACKWARD and AVSEEK_FLAG_ANY, but AVSEEK_FLAG_BYTE will
+ *        fail if used and not supported.
+ * @return >= 0 on success
+ * @see AVInputFormat::read_seek
+ */
+int64_t avio_seek_time(AVIOContext *h, int stream_index,
+                       int64_t timestamp, int flags);
+
+/* Avoid a warning. The header can not be included because it breaks c++. */
+struct AVBPrint;
+
+/**
+ * Read contents of h into print buffer, up to max_size bytes, or up to EOF.
+ *
+ * @return 0 for success (max_size bytes read or EOF reached), negative error
+ * code otherwise
+ */
+int avio_read_to_bprint(AVIOContext *h, struct AVBPrint *pb, size_t max_size);
+
+/**
+ * Accept and allocate a client context on a server context.
+ * @param  s the server context
+ * @param  c the client context, must be unallocated
+ * @return   >= 0 on success or a negative value corresponding
+ *           to an AVERROR on failure
+ */
+int avio_accept(AVIOContext *s, AVIOContext **c);
+
+/**
+ * Perform one step of the protocol handshake to accept a new client.
+ * This function must be called on a client returned by avio_accept() before
+ * using it as a read/write context.
+ * It is separate from avio_accept() because it may block.
+ * A step of the handshake is defined by places where the application may
+ * decide to change the proceedings.
+ * For example, on a protocol with a request header and a reply header, each
+ * one can constitute a step because the application may use the parameters
+ * from the request to change parameters in the reply; or each individual
+ * chunk of the request can constitute a step.
+ * If the handshake is already finished, avio_handshake() does nothing and
+ * returns 0 immediately.
+ *
+ * @param  c the client context to perform the handshake on
+ * @return   0   on a complete and successful handshake
+ *           > 0 if the handshake progressed, but is not complete
+ *           < 0 for an AVERROR code
+ */
+int avio_handshake(AVIOContext *c);
+#endif /* AVFORMAT_AVIO_H */

ffmpeg-n4.3.2-win64-gpl-shared-4.3/include/libavformat/version.h

@@ -0,0 +1,114 @@
+/*
+ * Version macros.
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVFORMAT_VERSION_H
+#define AVFORMAT_VERSION_H
+
+/**
+ * @file
+ * @ingroup libavf
+ * Libavformat version macros
+ */
+
+#include "libavutil/version.h"
+
+// Major bumping may affect Ticket5467, 5421, 5451(compatibility with Chromium)
+// Also please add any ticket numbers that you believe might be affected here
+#define LIBAVFORMAT_VERSION_MAJOR  58
+#define LIBAVFORMAT_VERSION_MINOR  45
+#define LIBAVFORMAT_VERSION_MICRO 100
+
+#define LIBAVFORMAT_VERSION_INT AV_VERSION_INT(LIBAVFORMAT_VERSION_MAJOR, \
+                                               LIBAVFORMAT_VERSION_MINOR, \
+                                               LIBAVFORMAT_VERSION_MICRO)
+#define LIBAVFORMAT_VERSION     AV_VERSION(LIBAVFORMAT_VERSION_MAJOR,   \
+                                           LIBAVFORMAT_VERSION_MINOR,   \
+                                           LIBAVFORMAT_VERSION_MICRO)
+#define LIBAVFORMAT_BUILD       LIBAVFORMAT_VERSION_INT
+
+#define LIBAVFORMAT_IDENT       "Lavf" AV_STRINGIFY(LIBAVFORMAT_VERSION)
+
+/**
+ * FF_API_* defines may be placed below to indicate public API that will be
+ * dropped at a future version bump. The defines themselves are not part of
+ * the public API and may change, break or disappear at any time.
+ *
+ * @note, when bumping the major version it is recommended to manually
+ * disable each FF_API_* in its own commit instead of disabling them all
+ * at once through the bump. This improves the git bisect-ability of the change.
+ *
+ */
+#ifndef FF_API_COMPUTE_PKT_FIELDS2
+#define FF_API_COMPUTE_PKT_FIELDS2      (LIBAVFORMAT_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_OLD_OPEN_CALLBACKS
+#define FF_API_OLD_OPEN_CALLBACKS       (LIBAVFORMAT_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_LAVF_AVCTX
+#define FF_API_LAVF_AVCTX               (LIBAVFORMAT_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_HTTP_USER_AGENT
+#define FF_API_HTTP_USER_AGENT          (LIBAVFORMAT_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_HLS_WRAP
+#define FF_API_HLS_WRAP                 (LIBAVFORMAT_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_HLS_USE_LOCALTIME
+#define FF_API_HLS_USE_LOCALTIME        (LIBAVFORMAT_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_LAVF_KEEPSIDE_FLAG
+#define FF_API_LAVF_KEEPSIDE_FLAG       (LIBAVFORMAT_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_OLD_ROTATE_API
+#define FF_API_OLD_ROTATE_API           (LIBAVFORMAT_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_FORMAT_GET_SET
+#define FF_API_FORMAT_GET_SET           (LIBAVFORMAT_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_OLD_AVIO_EOF_0
+#define FF_API_OLD_AVIO_EOF_0           (LIBAVFORMAT_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_LAVF_FFSERVER
+#define FF_API_LAVF_FFSERVER            (LIBAVFORMAT_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_FORMAT_FILENAME
+#define FF_API_FORMAT_FILENAME          (LIBAVFORMAT_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_OLD_RTSP_OPTIONS
+#define FF_API_OLD_RTSP_OPTIONS         (LIBAVFORMAT_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_NEXT
+#define FF_API_NEXT                     (LIBAVFORMAT_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_DASH_MIN_SEG_DURATION
+#define FF_API_DASH_MIN_SEG_DURATION    (LIBAVFORMAT_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_LAVF_MP4A_LATM
+#define FF_API_LAVF_MP4A_LATM           (LIBAVFORMAT_VERSION_MAJOR < 59)
+#endif
+#ifndef FF_API_AVIOFORMAT
+#define FF_API_AVIOFORMAT               (LIBAVFORMAT_VERSION_MAJOR < 59)
+#endif
+
+
+#ifndef FF_API_R_FRAME_RATE
+#define FF_API_R_FRAME_RATE            1
+#endif
+#endif /* AVFORMAT_VERSION_H */

ffmpeg-n4.3.2-win64-gpl-shared-4.3/include/libavutil/adler32.h

@@ -0,0 +1,60 @@
+/*
+ * copyright (c) 2006 Mans Rullgard
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/**
+ * @file
+ * @ingroup lavu_adler32
+ * Public header for Adler-32 hash function implementation.
+ */
+
+#ifndef AVUTIL_ADLER32_H
+#define AVUTIL_ADLER32_H
+
+#include <stdint.h>
+#include "attributes.h"
+
+/**
+ * @defgroup lavu_adler32 Adler-32
+ * @ingroup lavu_hash
+ * Adler-32 hash function implementation.
+ *
+ * @{
+ */
+
+/**
+ * Calculate the Adler32 checksum of a buffer.
+ *
+ * Passing the return value to a subsequent av_adler32_update() call
+ * allows the checksum of multiple buffers to be calculated as though
+ * they were concatenated.
+ *
+ * @param adler initial checksum value
+ * @param buf   pointer to input buffer
+ * @param len   size of input buffer
+ * @return      updated checksum
+ */
+unsigned long av_adler32_update(unsigned long adler, const uint8_t *buf,
+                                unsigned int len) av_pure;
+
+/**
+ * @}
+ */
+
+#endif /* AVUTIL_ADLER32_H */

ffmpeg-n4.3.2-win64-gpl-shared-4.3/include/libavutil/aes.h

@@ -0,0 +1,65 @@
+/*
+ * copyright (c) 2007 Michael Niedermayer <michaelni@gmx.at>
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVUTIL_AES_H
+#define AVUTIL_AES_H
+
+#include <stdint.h>
+
+#include "attributes.h"
+#include "version.h"
+
+/**
+ * @defgroup lavu_aes AES
+ * @ingroup lavu_crypto
+ * @{
+ */
+
+extern const int av_aes_size;
+
+struct AVAES;
+
+/**
+ * Allocate an AVAES context.
+ */
+struct AVAES *av_aes_alloc(void);
+
+/**
+ * Initialize an AVAES context.
+ * @param key_bits 128, 192 or 256
+ * @param decrypt 0 for encryption, 1 for decryption
+ */
+int av_aes_init(struct AVAES *a, const uint8_t *key, int key_bits, int decrypt);
+
+/**
+ * Encrypt or decrypt a buffer using a previously initialized context.
+ * @param count number of 16 byte blocks
+ * @param dst destination array, can be equal to src
+ * @param src source array, can be equal to dst
+ * @param iv initialization vector for CBC mode, if NULL then ECB will be used
+ * @param decrypt 0 for encryption, 1 for decryption
+ */
+void av_aes_crypt(struct AVAES *a, uint8_t *dst, const uint8_t *src, int count, uint8_t *iv, int decrypt);
+
+/**
+ * @}
+ */
+
+#endif /* AVUTIL_AES_H */

ffmpeg-n4.3.2-win64-gpl-shared-4.3/include/libavutil/aes_ctr.h

@@ -0,0 +1,88 @@
+/*
+ * AES-CTR cipher
+ * Copyright (c) 2015 Eran Kornblau <erankor at gmail dot com>
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVUTIL_AES_CTR_H
+#define AVUTIL_AES_CTR_H
+
+#include <stdint.h>
+
+#include "attributes.h"
+#include "version.h"
+
+#define AES_CTR_KEY_SIZE (16)
+#define AES_CTR_IV_SIZE (8)
+
+struct AVAESCTR;
+
+/**
+ * Allocate an AVAESCTR context.
+ */
+struct AVAESCTR *av_aes_ctr_alloc(void);
+
+/**
+ * Initialize an AVAESCTR context.
+ * @param key encryption key, must have a length of AES_CTR_KEY_SIZE
+ */
+int av_aes_ctr_init(struct AVAESCTR *a, const uint8_t *key);
+
+/**
+ * Release an AVAESCTR context.
+ */
+void av_aes_ctr_free(struct AVAESCTR *a);
+
+/**
+ * Process a buffer using a previously initialized context.
+ * @param dst destination array, can be equal to src
+ * @param src source array, can be equal to dst
+ * @param size the size of src and dst
+ */
+void av_aes_ctr_crypt(struct AVAESCTR *a, uint8_t *dst, const uint8_t *src, int size);
+
+/**
+ * Get the current iv
+ */
+const uint8_t* av_aes_ctr_get_iv(struct AVAESCTR *a);
+
+/**
+ * Generate a random iv
+ */
+void av_aes_ctr_set_random_iv(struct AVAESCTR *a);
+
+/**
+ * Forcefully change the 8-byte iv
+ */
+void av_aes_ctr_set_iv(struct AVAESCTR *a, const uint8_t* iv);
+
+/**
+ * Forcefully change the "full" 16-byte iv, including the counter
+ */
+void av_aes_ctr_set_full_iv(struct AVAESCTR *a, const uint8_t* iv);
+
+/**
+ * Increment the top 64 bit of the iv (performed after each frame)
+ */
+void av_aes_ctr_increment_iv(struct AVAESCTR *a);
+
+/**
+ * @}
+ */
+
+#endif /* AVUTIL_AES_CTR_H */