Packman Build Service PMBS

Changes of Revision 26

makemkv.spec Changed

makemkv-bin-1.8.5.tar.gz/bin/amd64/makemkvcon -> makemkv-bin-1.8.6.tar.gz/bin/amd64/makemkvcon Changed

makemkv-bin-1.8.5.tar.gz/bin/i386/makemkvcon -> makemkv-bin-1.8.6.tar.gz/bin/i386/makemkvcon Changed

makemkv-bin-1.8.5.tar.gz/bin/i386/mmdtsdec -> makemkv-bin-1.8.6.tar.gz/bin/i386/mmdtsdec Changed

makemkv-bin-1.8.5.tar.gz/src/share/makemkv_chi.mo.gz -> makemkv-bin-1.8.6.tar.gz/src/share/makemkv_chi.mo.gz Changed

makemkv-bin-1.8.5.tar.gz/src/share/makemkv_ita.mo.gz -> makemkv-bin-1.8.6.tar.gz/src/share/makemkv_ita.mo.gz Changed

makemkv-bin-1.8.5.tar.gz/src/share/makemkv_pol.mo.gz -> makemkv-bin-1.8.6.tar.gz/src/share/makemkv_pol.mo.gz Changed

makemkv-oss-1.8.5.tar.gz/libffcodec Deleted

makemkv-oss-1.8.5.tar.gz/libffcodec/inc Deleted

makemkv-oss-1.8.5.tar.gz/libffcodec/inc/ffcodec Deleted

makemkv-oss-1.8.5.tar.gz/libffcodec/inc/ffcodec/ffcodec.h Deleted

makemkv-oss-1.8.5.tar.gz/libffcodec/src Deleted

makemkv-oss-1.8.5.tar.gz/libffcodec/src/audioconvert.c Deleted

@@ -1,171 +0,0 @@
-/*
- * Copyright (c) 2006 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
- */
-
-/**
- * @file
- * audio conversion routines
- */
-
-#include "avstring.h"
-#include "avutil.h"
-#include "audioconvert.h"
-
-static const char * const channel_names[] = {
-    [0]  = "FL",        /* front left */
-    [1]  = "FR",        /* front right */
-    [2]  = "FC",        /* front center */
-    [3]  = "LFE",       /* low frequency */
-    [4]  = "BL",        /* back left */
-    [5]  = "BR",        /* back right */
-    [6]  = "FLC",       /* front left-of-center  */
-    [7]  = "FRC",       /* front right-of-center */
-    [8]  = "BC",        /* back-center */
-    [9]  = "SL",        /* side left */
-    [10] = "SR",        /* side right */
-    [11] = "TC",        /* top center */
-    [12] = "TFL",       /* top front left */
-    [13] = "TFC",       /* top front center */
-    [14] = "TFR",       /* top front right */
-    [15] = "TBL",       /* top back left */
-    [16] = "TBC",       /* top back center */
-    [17] = "TBR",       /* top back right */
-    [29] = "DL",        /* downmix left */
-    [30] = "DR",        /* downmix right */
-};
-
-static const char *get_channel_name(int channel_id)
-{
-    if (channel_id < 0 || channel_id >= FF_ARRAY_ELEMS(channel_names))
-        return NULL;
-    return channel_names[channel_id];
-}
-
-static const struct {
-    const char *name;
-    int         nb_channels;
-    uint64_t     layout;
-} channel_layout_map[] = {
-    { "mono",        1,  AV_CH_LAYOUT_MONO },
-    { "stereo",      2,  AV_CH_LAYOUT_STEREO },
-    { "2.1",         3,  AV_CH_LAYOUT_2POINT1 },
-    { "4.0",         4,  AV_CH_LAYOUT_4POINT0 },
-    { "quad",        4,  AV_CH_LAYOUT_QUAD },
-    { "5.0",         5,  AV_CH_LAYOUT_5POINT0_BACK },
-    { "5.0(side)",   5,  AV_CH_LAYOUT_5POINT0 },
-    { "5.1",         6,  AV_CH_LAYOUT_5POINT1_BACK },
-    { "5.1(side)",   6,  AV_CH_LAYOUT_5POINT1 },
-    { "7.1",         8,  AV_CH_LAYOUT_7POINT1 },
-    { "7.1(wide)",   8,  AV_CH_LAYOUT_7POINT1_WIDE },
-    { "downmix",     2,  AV_CH_LAYOUT_STEREO_DOWNMIX, },
-    { 0 }
-};
-
-static uint64_t get_channel_layout_single(const char *name, int name_len)
-{
-    int i;
-    char *end;
-    int64_t layout;
-
-    for (i = 0; i < FF_ARRAY_ELEMS(channel_layout_map) - 1; i++) {
-        if (strlen(channel_layout_map[i].name) == name_len &&
-            !memcmp(channel_layout_map[i].name, name, name_len))
-            return channel_layout_map[i].layout;
-    }
-    for (i = 0; i < FF_ARRAY_ELEMS(channel_names); i++)
-        if (channel_names[i] &&
-            strlen(channel_names[i]) == name_len &&
-            !memcmp(channel_names[i], name, name_len))
-            return (int64_t)1 << i;
-    i = strtol(name, &end, 10);
-    if (end - name == name_len ||
-        (end + 1 - name == name_len && *end  == 'c'))
-        return av_get_default_channel_layout(i);
-    layout = strtoll(name, &end, 0);
-    if (end - name == name_len)
-        return FFMAX(layout, 0);
-    return 0;
-}
-
-uint64_t av_get_channel_layout(const char *name)
-{
-    const char *n, *e;
-    const char *name_end = name + strlen(name);
-    int64_t layout = 0, layout_single;
-
-    for (n = name; n < name_end; n = e + 1) {
-        for (e = n; e < name_end && *e != '+' && *e != '|'; e++);
-        layout_single = get_channel_layout_single(n, e - n);
-        if (!layout_single)
-            return 0;
-        layout |= layout_single;
-    }
-    return layout;
-}
-
-void av_get_channel_layout_string(char *buf, int buf_size,
-                                  int nb_channels, uint64_t channel_layout)
-{
-    int i;
-
-    if (nb_channels <= 0)
-        nb_channels = av_get_channel_layout_nb_channels(channel_layout);
-
-    for (i = 0; channel_layout_map[i].name; i++)
-        if (nb_channels    == channel_layout_map[i].nb_channels &&
-            channel_layout == channel_layout_map[i].layout) {
-            av_strlcpy(buf, channel_layout_map[i].name, buf_size);
-            return;
-        }
-
-    snprintf(buf, buf_size, "%d channels", nb_channels);
-    if (channel_layout) {
-        int i, ch;
-        av_strlcat(buf, " (", buf_size);
-        for (i = 0, ch = 0; i < 64; i++) {
-            if ((channel_layout & (UINT64_C(1) << i))) {
-                const char *name = get_channel_name(i);
-                if (name) {
-                    if (ch > 0)
-                        av_strlcat(buf, "+", buf_size);
-                    av_strlcat(buf, name, buf_size);
-                }
-                ch++;
-            }
-        }
-        av_strlcat(buf, ")", buf_size);
-    }
-}
-
-int av_get_channel_layout_nb_channels(uint64_t channel_layout)
-{
-    int count;
-    uint64_t x = channel_layout;
-    for (count = 0; x; count++)
-        x &= x-1; // unset lowest set bit
-    return count;
-}
-
-int64_t av_get_default_channel_layout(int nb_channels) {
-    int i;
-    for (i = 0; channel_layout_map[i].name; i++)
-        if (nb_channels == channel_layout_map[i].nb_channels)
-            return channel_layout_map[i].layout;
-    return 0;
-}

makemkv-oss-1.8.5.tar.gz/libffcodec/src/audioconvert.h Deleted

@@ -1,147 +0,0 @@
-/*
- * Copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
- * Copyright (c) 2008 Peter Ross
- *
- * 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_AUDIOCONVERT_H
-#define AVUTIL_AUDIOCONVERT_H
-
-#include <stdint.h>
-
-/**
- * @file
- * audio conversion routines
- */
-
-/**
- * @addtogroup lavu_audio
- * @{
- */
-
-/**
- * @defgroup channel_masks Audio channel masks
- * @{
- */
-#define AV_CH_FRONT_LEFT             0x00000001
-#define AV_CH_FRONT_RIGHT            0x00000002
-#define AV_CH_FRONT_CENTER           0x00000004
-#define AV_CH_LOW_FREQUENCY          0x00000008
-#define AV_CH_BACK_LEFT              0x00000010
-#define AV_CH_BACK_RIGHT             0x00000020
-#define AV_CH_FRONT_LEFT_OF_CENTER   0x00000040
-#define AV_CH_FRONT_RIGHT_OF_CENTER  0x00000080
-#define AV_CH_BACK_CENTER            0x00000100
-#define AV_CH_SIDE_LEFT              0x00000200
-#define AV_CH_SIDE_RIGHT             0x00000400
-#define AV_CH_TOP_CENTER             0x00000800
-#define AV_CH_TOP_FRONT_LEFT         0x00001000
-#define AV_CH_TOP_FRONT_CENTER       0x00002000
-#define AV_CH_TOP_FRONT_RIGHT        0x00004000
-#define AV_CH_TOP_BACK_LEFT          0x00008000
-#define AV_CH_TOP_BACK_CENTER        0x00010000
-#define AV_CH_TOP_BACK_RIGHT         0x00020000
-#define AV_CH_STEREO_LEFT            0x20000000  ///< Stereo downmix.
-#define AV_CH_STEREO_RIGHT           0x40000000  ///< See AV_CH_STEREO_LEFT.
-#define AV_CH_WIDE_LEFT              0x0000000080000000ULL
-#define AV_CH_WIDE_RIGHT             0x0000000100000000ULL
-#define AV_CH_SURROUND_DIRECT_LEFT   0x0000000200000000ULL
-#define AV_CH_SURROUND_DIRECT_RIGHT  0x0000000400000000ULL
-
-/** Channel mask value used for AVCodecContext.request_channel_layout
-    to indicate that the user requests the channel order of the decoder output
-    to be the native codec channel order. */
-#define AV_CH_LAYOUT_NATIVE          0x8000000000000000ULL
-
-/**
- * @}
- * @defgroup channel_mask_c Audio channel convenience macros
- * @{
- * */
-#define AV_CH_LAYOUT_MONO              (AV_CH_FRONT_CENTER)
-#define AV_CH_LAYOUT_STEREO            (AV_CH_FRONT_LEFT|AV_CH_FRONT_RIGHT)
-#define AV_CH_LAYOUT_2POINT1           (AV_CH_LAYOUT_STEREO|AV_CH_LOW_FREQUENCY)
-#define AV_CH_LAYOUT_2_1               (AV_CH_LAYOUT_STEREO|AV_CH_BACK_CENTER)
-#define AV_CH_LAYOUT_SURROUND          (AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER)
-#define AV_CH_LAYOUT_3POINT1           (AV_CH_LAYOUT_SURROUND|AV_CH_LOW_FREQUENCY)
-#define AV_CH_LAYOUT_4POINT0           (AV_CH_LAYOUT_SURROUND|AV_CH_BACK_CENTER)
-#define AV_CH_LAYOUT_4POINT1           (AV_CH_LAYOUT_4POINT0|AV_CH_LOW_FREQUENCY)
-#define AV_CH_LAYOUT_2_2               (AV_CH_LAYOUT_STEREO|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT)
-#define AV_CH_LAYOUT_QUAD              (AV_CH_LAYOUT_STEREO|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT)
-#define AV_CH_LAYOUT_5POINT0           (AV_CH_LAYOUT_SURROUND|AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT)
-#define AV_CH_LAYOUT_5POINT1           (AV_CH_LAYOUT_5POINT0|AV_CH_LOW_FREQUENCY)
-#define AV_CH_LAYOUT_5POINT0_BACK      (AV_CH_LAYOUT_SURROUND|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT)
-#define AV_CH_LAYOUT_5POINT1_BACK      (AV_CH_LAYOUT_5POINT0_BACK|AV_CH_LOW_FREQUENCY)
-#define AV_CH_LAYOUT_6POINT0           (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_CENTER)
-#define AV_CH_LAYOUT_6POINT0_FRONT     (AV_CH_LAYOUT_2_2|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER)
-#define AV_CH_LAYOUT_HEXAGONAL         (AV_CH_LAYOUT_5POINT0_BACK|AV_CH_BACK_CENTER)
-#define AV_CH_LAYOUT_6POINT1           (AV_CH_LAYOUT_5POINT1|AV_CH_BACK_CENTER)
-#define AV_CH_LAYOUT_6POINT1_BACK      (AV_CH_LAYOUT_5POINT1_BACK|AV_CH_BACK_CENTER)
-#define AV_CH_LAYOUT_6POINT1_FRONT     (AV_CH_LAYOUT_6POINT0_FRONT|AV_CH_LOW_FREQUENCY)
-#define AV_CH_LAYOUT_7POINT0           (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT)
-#define AV_CH_LAYOUT_7POINT0_FRONT     (AV_CH_LAYOUT_5POINT0|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER)
-#define AV_CH_LAYOUT_7POINT1           (AV_CH_LAYOUT_5POINT1|AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT)
-#define AV_CH_LAYOUT_7POINT1_WIDE      (AV_CH_LAYOUT_5POINT1|AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER)
-#define AV_CH_LAYOUT_OCTAGONAL         (AV_CH_LAYOUT_5POINT0|AV_CH_BACK_LEFT|AV_CH_BACK_CENTER|AV_CH_BACK_RIGHT)
-#define AV_CH_LAYOUT_STEREO_DOWNMIX    (AV_CH_STEREO_LEFT|AV_CH_STEREO_RIGHT)
-
-/**
- * @}
- */
-
-/**
- * Return a channel layout id that matches name, 0 if no match.
- * name can be one or several of the following notations,
- * separated by '+' or '|':
- * - the name of an usual channel layout (mono, stereo, 4.0, quad, 5.0,
- *   5.0(side), 5.1, 5.1(side), 7.1, 7.1(wide), downmix);
- * - the name of a single channel (FL, FR, FC, LFE, BL, BR, FLC, FRC, BC,
- *   SL, SR, TC, TFL, TFC, TFR, TBL, TBC, TBR, DL, DR);
- * - a number of channels, in decimal, optionnally followed by 'c', yielding
- *   the default channel layout for that number of channels (@see
- *   av_get_default_channel_layout);
- * - a channel layout mask, in hexadecimal starting with "0x" (see the
- *   AV_CH_* macros).
- + Example: "stereo+FC" = "2+FC" = "2c+1c" = "0x7"
- */
-uint64_t av_get_channel_layout(const char *name);
-
-/**
- * Return a description of a channel layout.
- * If nb_channels is <= 0, it is guessed from the channel_layout.
- *
- * @param buf put here the string containing the channel layout
- * @param buf_size size in bytes of the buffer
- */
-void av_get_channel_layout_string(char *buf, int buf_size, int nb_channels, uint64_t channel_layout);
-
-/**
- * Return the number of channels in the channel layout.
- */
-int av_get_channel_layout_nb_channels(uint64_t channel_layout);
-
-/**
- * Return default channel layout for a given number of channels.
- */
-int64_t av_get_default_channel_layout(int nb_channels);
-
-/**
- * @}
- */
-
-#endif /* AVUTIL_AUDIOCONVERT_H */

makemkv-oss-1.8.5.tar.gz/libffcodec/src/aviobuf.c Deleted

@@ -1,225 +0,0 @@
-/*
- * buffered I/O
- * Copyright (c) 2000,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
- */
-
-#include "misc.h"
-
-void avio_wl32(AVIOContext *s, unsigned int val)
-{
-    avio_w8(s, val);
-    avio_w8(s, val >> 8);
-    avio_w8(s, val >> 16);
-    avio_w8(s, val >> 24);
-}
-
-void avio_wb32(AVIOContext *s, unsigned int val)
-{
-    avio_w8(s, val >> 24);
-    avio_w8(s, val >> 16);
-    avio_w8(s, val >> 8);
-    avio_w8(s, val);
-}
-
-#define GET(name, type) \
-    type get_be ##name(AVIOContext *s) \
-{\
-    return avio_rb ##name(s);\
-}\
-    type get_le ##name(AVIOContext *s) \
-{\
-    return avio_rl ##name(s);\
-}
-
-GET(16, unsigned int)
-GET(24, unsigned int)
-GET(32, unsigned int)
-GET(64, uint64_t)
-
-#undef GET
-
-#define PUT(name, type ) \
-    void put_le ##name(AVIOContext *s, type val)\
-{\
-        avio_wl ##name(s, val);\
-}\
-    void put_be ##name(AVIOContext *s, type val)\
-{\
-        avio_wb ##name(s, val);\
-}
-
-PUT(16, unsigned int)
-PUT(24, unsigned int)
-PUT(32, unsigned int)
-PUT(64, uint64_t)
-#undef PUT
-
-int get_byte(AVIOContext *s)
-{
-   return avio_r8(s);
-}
-int get_buffer(AVIOContext *s, unsigned char *buf, int size)
-{
-    return avio_read(s, buf, size);
-}
-void put_byte(AVIOContext *s, int val)
-{
-    avio_w8(s, val);
-}
-void put_buffer(AVIOContext *s, const unsigned char *buf, int size)
-{
-    avio_write(s, buf, size);
-}
-
-int avio_put_str(AVIOContext *s, const char *str)
-{
-    int len = 1;
-    if (str) {
-        len += strlen(str);
-        avio_write(s, (const unsigned char *) str, len);
-    } else
-        avio_w8(s, 0);
-    return len;
-}
-
-void avio_wl64(AVIOContext *s, uint64_t val)
-{
-    avio_wl32(s, (uint32_t)(val & 0xffffffff));
-    avio_wl32(s, (uint32_t)(val >> 32));
-}
-
-void avio_wb64(AVIOContext *s, uint64_t val)
-{
-    avio_wb32(s, (uint32_t)(val >> 32));
-    avio_wb32(s, (uint32_t)(val & 0xffffffff));
-}
-
-void avio_wl16(AVIOContext *s, unsigned int val)
-{
-    avio_w8(s, val);
-    avio_w8(s, val >> 8);
-}
-
-void avio_wb16(AVIOContext *s, unsigned int val)
-{
-    avio_w8(s, val >> 8);
-    avio_w8(s, val);
-}
-
-void avio_wl24(AVIOContext *s, unsigned int val)
-{
-    avio_wl16(s, val & 0xffff);
-    avio_w8(s, val >> 16);
-}
-
-void avio_wb24(AVIOContext *s, unsigned int val)
-{
-    avio_wb16(s, val >> 8);
-    avio_w8(s, val);
-}
-
-unsigned int avio_rl16(AVIOContext *s)
-{
-    unsigned int val;
-    val = avio_r8(s);
-    val |= avio_r8(s) << 8;
-    return val;
-}
-
-unsigned int avio_rl24(AVIOContext *s)
-{
-    unsigned int val;
-    val = avio_rl16(s);
-    val |= avio_r8(s) << 16;
-    return val;
-}
-
-unsigned int avio_rl32(AVIOContext *s)
-{
-    unsigned int val;
-    val = avio_rl16(s);
-    val |= avio_rl16(s) << 16;
-    return val;
-}
-
-uint64_t avio_rl64(AVIOContext *s)
-{
-    uint64_t val;
-    val = (uint64_t)avio_rl32(s);
-    val |= (uint64_t)avio_rl32(s) << 32;
-    return val;
-}
-
-unsigned int avio_rb16(AVIOContext *s)
-{
-    unsigned int val;
-    val = avio_r8(s) << 8;
-    val |= avio_r8(s);
-    return val;
-}
-
-unsigned int avio_rb24(AVIOContext *s)
-{
-    unsigned int val;
-    val = avio_rb16(s) << 8;
-    val |= avio_r8(s);
-    return val;
-}
-unsigned int avio_rb32(AVIOContext *s)
-{
-    unsigned int val;
-    val = avio_rb16(s) << 16;
-    val |= avio_rb16(s);
-    return val;
-}
-
-int ff_get_line(AVIOContext *s, char *buf, int maxlen)
-{
-    int i = 0;
-    char c;
-
-    do {
-        c = avio_r8(s);
-        if (c && i < maxlen-1)
-            buf[i++] = c;
-    } while (c != '\n' && c);
-
-    buf[i] = 0;
-    return i;
-}
-
-uint64_t avio_rb64(AVIOContext *s)
-{
-    uint64_t val;
-    val = (uint64_t)avio_rb32(s) << 32;
-    val |= (uint64_t)avio_rb32(s);
-    return val;
-}
-
-uint64_t ffio_read_varlen(AVIOContext *bc){
-    uint64_t val = 0;
-    int tmp;
-
-    do{
-        tmp = avio_r8(bc);
-        val= (val<<7) + (tmp&127);
-    }while(tmp&128);
-    return val;
-}
-

makemkv-oss-1.8.5.tar.gz/libffcodec/src/crc.c Deleted

@@ -1,165 +0,0 @@
-/*
- * copyright (c) 2006 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
- */
-
-#include "misc.h"
-#include "crc.h"
-
-#if CONFIG_HARDCODED_TABLES
-/*#include "crc_data.h"*/
-#else
-static struct {
-    uint8_t  le;
-    uint8_t  bits;
-    uint32_t poly;
-} av_crc_table_params[AV_CRC_MAX] = {
-    [AV_CRC_8_ATM]      = { 0,  8,       0x07 },
-    [AV_CRC_16_ANSI]    = { 0, 16,     0x8005 },
-    [AV_CRC_16_CCITT]   = { 0, 16,     0x1021 },
-    [AV_CRC_32_IEEE]    = { 0, 32, 0x04C11DB7 },
-    [AV_CRC_32_IEEE_LE] = { 1, 32, 0xEDB88320 },
-};
-static AVCRC av_crc_table[AV_CRC_MAX][257];
-#endif
-
-/**
- * Initialize a CRC table.
- * @param ctx must be an array of size sizeof(AVCRC)*257 or sizeof(AVCRC)*1024
- * @param le If 1, the lowest bit represents the coefficient for the highest
- *           exponent of the corresponding polynomial (both for poly and
- *           actual CRC).
- *           If 0, you must swap the CRC parameter and the result of av_crc
- *           if you need the standard representation (can be simplified in
- *           most cases to e.g. bswap16):
- *           av_bswap32(crc << (32-bits))
- * @param bits number of bits for the CRC
- * @param poly generator polynomial without the x**bits coefficient, in the
- *             representation as specified by le
- * @param ctx_size size of ctx in bytes
- * @return <0 on failure
- */
-int av_crc_init(AVCRC *ctx, int le, int bits, uint32_t poly, int ctx_size)
-{
-    unsigned i, j;
-    uint32_t c;
-
-    if (bits < 8 || bits > 32 || poly >= (1LL << bits))
-        return -1;
-    if (ctx_size != sizeof(AVCRC) * 257 && ctx_size != sizeof(AVCRC) * 1024)
-        return -1;
-
-    for (i = 0; i < 256; i++) {
-        if (le) {
-            for (c = i, j = 0; j < 8; j++)
-                c = (c >> 1) ^ (poly & (-(c & 1)));
-            ctx[i] = c;
-        } else {
-            for (c = i << 24, j = 0; j < 8; j++)
-                c = (c << 1) ^ ((poly << (32 - bits)) & (((int32_t) c) >> 31));
-            ctx[i] = av_bswap32(c);
-        }
-    }
-    ctx[256] = 1;
-#if !CONFIG_SMALL
-    if (ctx_size >= sizeof(AVCRC) * 1024)
-        for (i = 0; i < 256; i++)
-            for (j = 0; j < 3; j++)
-                ctx[256 *(j + 1) + i] =
-                    (ctx[256 * j + i] >> 8) ^ ctx[ctx[256 * j + i] & 0xFF];
-#endif
-
-    return 0;
-}
-
-/**
- * Get an initialized standard CRC table.
- * @param crc_id ID of a standard CRC
- * @return a pointer to the CRC table or NULL on failure
- */
-/*
-const AVCRC *av_crc_get_table(AVCRCId crc_id)
-{
-#if !CONFIG_HARDCODED_TABLES
-    if (!av_crc_table[crc_id][FF_ARRAY_ELEMS(av_crc_table[crc_id]) - 1])
-        if (av_crc_init(av_crc_table[crc_id],
-                        av_crc_table_params[crc_id].le,
-                        av_crc_table_params[crc_id].bits,
-                        av_crc_table_params[crc_id].poly,
-                        sizeof(av_crc_table[crc_id])) < 0)
-            return NULL;
-#endif
-    return av_crc_table[crc_id];
-}
-*/
-
-/**
- * Calculate the CRC of a block.
- * @param crc CRC of previous blocks if any or initial value for CRC
- * @return CRC updated with the data from the given block
- *
- * @see av_crc_init() "le" parameter
- */
-uint32_t av_crc(const AVCRC *ctx, uint32_t crc,
-                const uint8_t *buffer, size_t length)
-{
-    const uint8_t *end = buffer + length;
-
-#if !CONFIG_SMALL
-    if (!ctx[256]) {
-        while (((intptr_t) buffer & 3) && buffer < end)
-            crc = ctx[((uint8_t) crc) ^ *buffer++] ^ (crc >> 8);
-
-        while (buffer < end - 3) {
-            crc ^= av_le2ne32(*(const uint32_t *) buffer); buffer += 4;
-            crc = ctx[3 * 256 + ( crc        & 0xFF)] ^
-                  ctx[2 * 256 + ((crc >> 8 ) & 0xFF)] ^
-                  ctx[1 * 256 + ((crc >> 16) & 0xFF)] ^
-                  ctx[0 * 256 + ((crc >> 24)       )];
-        }
-    }
-#endif
-    while (buffer < end)
-        crc = ctx[((uint8_t) crc) ^ *buffer++] ^ (crc >> 8);
-
-    return crc;
-}
-
-#ifdef TEST
-#undef printf
-int main(void)
-{
-    uint8_t buf[1999];
-    int i;
-    int p[4][3] = { { AV_CRC_32_IEEE_LE, 0xEDB88320, 0x3D5CDD04 },
-                    { AV_CRC_32_IEEE   , 0x04C11DB7, 0xC0F5BAE0 },
-                    { AV_CRC_16_ANSI   , 0x8005    , 0x1FBB     },
-                    { AV_CRC_8_ATM     , 0x07      , 0xE3       }
-    };
-    const AVCRC *ctx;
-
-    for (i = 0; i < sizeof(buf); i++)
-        buf[i] = i + i * i;
-
-    for (i = 0; i < 4; i++) {
-        ctx = av_crc_get_table(p[i][0]);
-        printf("crc %08X = %X\n", p[i][1], av_crc(ctx, 0, buf, sizeof(buf)));
-    }
-    return 0;
-}
-#endif

makemkv-oss-1.8.5.tar.gz/libffcodec/src/crc.h Deleted

@@ -1,44 +0,0 @@
-/*
- * copyright (c) 2006 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_CRC_H
-#define AVUTIL_CRC_H
-
-#include <stdint.h>
-#include <stddef.h>
-#include "misc.h"
-
-typedef uint32_t AVCRC;
-
-typedef enum {
-    AV_CRC_8_ATM,
-    AV_CRC_16_ANSI,
-    AV_CRC_16_CCITT,
-    AV_CRC_32_IEEE,
-    AV_CRC_32_IEEE_LE,  /*< reversed bitorder version of AV_CRC_32_IEEE */
-    AV_CRC_MAX,         /*< Not part of public API! Do not use outside libavutil. */
-}AVCRCId;
-
-int av_crc_init(AVCRC *ctx, int le, int bits, uint32_t poly, int ctx_size);
-const AVCRC *av_crc_get_table(AVCRCId crc_id);
-uint32_t av_crc(const AVCRC *ctx, uint32_t start_crc, const uint8_t *buffer, size_t length) av_pure;
-
-#endif /* AVUTIL_CRC_H */
-

makemkv-oss-1.8.5.tar.gz/libffcodec/src/ffcodec.c Deleted

@@ -1,183 +0,0 @@
-/*
-    libMakeMKV - MKV multiplexer library
-
-    Copyright (C) 2007-2013 GuinpinSoft inc <libmkv@makemkv.com>
-
-    This library 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.
-
-    This library 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 this library; if not, write to the Free Software
-    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-
-*/
-#include "ffcodec.h"
-#include "get_bits.h"
-#include "mlp.h"
-#include "mpegaudiodecheader.h"
-#include <stdlib.h>
-
-int ffm_read_header(AVFormatContext *s);
-int ffm_read_packet(AVFormatContext *s, AVPacket *pkt);
-int ffm_write_header(AVFormatContext *s);
-int ffm_write_packet(AVFormatContext *s, AVPacket *pkt);
-int ffm_write_trailer(AVFormatContext *s);
-
-int ffcdecl ffcodec_ff_mlp_read_major_sync(MLPHeaderInfo *mh, const uint8_t* data, unsigned int size)
-{
-    GetBitContext   gb;
-
-    init_get_bits(&gb,data,size*8);
-
-    ff_mlp_init_crc();
-
-    return ff_mlp_read_major_sync(NULL,mh,&gb);
-}
-
-int ffcdecl ffcodec_ff_mpegaudio_decode_header(MPADecodeHeader *s, const uint8_t* data, unsigned int size)
-{
-    uint32_t header;
-
-    if (size<4) return -2;
-
-    header = AV_RB32(data);
-
-    return avpriv_mpegaudio_decode_header(s,header);
-}
-
-int ffcdecl ffcodec_ff_mpa_check_header( const uint8_t* data, unsigned int size)
-{
-    uint32_t header;
-
-    if (size<4) return -2;
-
-    header = AV_RB32(data);
-
-    return ff_mpa_check_header(header);
-}
-
-int ffcdecl ffcodec_ffm_init_context_r(FFCFFMContextR *s,uintptr_t fd,AVIOReadProc read)
-{
-    memset(s,0,sizeof(*s));
-    s->avio.fd=fd;
-    s->avio.read=read;
-    s->fmt.pb=&s->avio;
-    s->fmt.priv_data=&s->ffm;
-    return 0;
-}
-
-int ffcdecl ffcodec_ffm_init_context_w(FFCFFMContextW *s,uintptr_t fd,AVIOWriteProc write)
-{
-    ffcodec_ffm_init_context_r(&s->ctx,fd,NULL);
-    s->ctx.avio.write=write;
-    s->ctx.avio.buffer=s->avio_buffer;
-    s->ctx.avio.buffer_max_size=8*FFM_PACKET_SIZE;
-    return 0;
-}
-
-
-int ffcdecl ffcodec_ffm_read_header(FFCFFMContextR *s)
-{
-    return ffm_read_header(&s->fmt);
-}
-
-int ffcdecl ffcodec_ffm_read_packet_header(FFCFFMContextR *s, uint32_t *size)
-{
-    int err;
-
-    if (s->ffm.read_state!=READ_HEADER) return -1;
-    if ((err=ffm_read_packet(&s->fmt,NULL))<0) return err;
-
-    *size = AV_RB24(s->ffm.header + 2);
-
-    return 0;
-}
-
-int ffcdecl ffcodec_ffm_read_packet_data(FFCFFMContextR *s, AVPacket *pkt)
-{
-    if (s->ffm.read_state!=READ_DATA) return -1;
-
-    return ffm_read_packet(&s->fmt,pkt);
-}
-
-int ffcdecl ffcodec_ffm_write_header(FFCFFMContextW *s)
-{
-    return ffm_write_header(&s->ctx.fmt);
-}
-
-int ffcdecl ffcodec_ffm_write_packet(FFCFFMContextW *s, AVPacket *pkt)
-{
-    return ffm_write_packet(&s->ctx.fmt,pkt);
-}
-
-int ffcdecl ffcodec_ffm_write_trailer(FFCFFMContextW *s)
-{
-    return ffm_write_trailer(&s->ctx.fmt);
-}
-
-void avio_flush(AVIOContext *s)
-{
-    if (s->buffer_size)
-    {
-        (*s->write)(s->fd,s->buffer,s->buffer_size);
-        s->buffer_size = 0;
-    }
-}
-
-int64_t avio_tell(AVIOContext *s)
-{
-    return s->pos;
-}
-
-int avio_read(AVIOContext *s, unsigned char *buf, int size)
-{
-    int err = (*s->read)(s->fd,buf,size);
-    if (err>=0)
-    {
-        s->pos += err;
-    }
-    return err;
-}
-
-void avio_write(AVIOContext *s, const unsigned char *buf, int size)
-{
-    int err;
-
-    if ((size+s->buffer_size)<=s->buffer_max_size)
-    {
-        memcpy(s->buffer+s->buffer_size,buf,size);
-        s->buffer_size += size;
-        s->pos += size;
-    } else {
-        avio_flush(s);
-
-        err = (*s->write)(s->fd,buf,size);
-        if (err>=0)
-        {
-            s->pos += err;
-        }
-    }
-}
-
-int avio_r8(AVIOContext *s)
-{
-    unsigned char buf=0;
-
-    avio_read(s,&buf,1);
-
-    return buf;
-}
-
-void avio_w8(AVIOContext *s, int b)
-{
-    unsigned char buf=(unsigned char)b;
-    avio_write(s,&buf,1);
-}
-

makemkv-oss-1.8.5.tar.gz/libffcodec/src/ffcodec.h Deleted

@@ -1,69 +0,0 @@
-/*
-    libMakeMKV - MKV multiplexer library
-
-    Copyright (C) 2007-2013 GuinpinSoft inc <libmkv@makemkv.com>
-
-    This library 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.
-
-    This library 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 this library; if not, write to the Free Software
-    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-
-*/
-#ifndef FFCODEC_H
-#define FFCODEC_H
-
-#include <stdint.h>
-#include "mlp_parser.h"
-#include "mpegaudiodecheader.h"
-#include "mpegaudiomisc.h"
-#include "ffm.h"
-
-typedef struct FFCFFMContextR
-{
-    AVFormatContext     fmt;
-    AVIOContext         avio;
-    FFMContext          ffm;
-} FFCFFMContextR;
-
-typedef struct FFCFFMContextW
-{
-    FFCFFMContextR      ctx;
-    uint8_t             avio_buffer[8*FFM_PACKET_SIZE];
-} FFCFFMContextW;
-
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-int ffcdecl ffcodec_ff_mlp_read_major_sync(MLPHeaderInfo *mh, const uint8_t* data, unsigned int size);
-int ffcdecl ffcodec_ff_mlp_get_audio_info(const MLPHeaderInfo *mh,AVAudioInfo* avctx);
-
-
-int ffcdecl ffcodec_ff_mpegaudio_decode_header(MPADecodeHeader *s, const uint8_t* data, unsigned int size);
-int ffcdecl ffcodec_ff_mpa_check_header( const uint8_t* data, unsigned int size);
-
-int ffcdecl ffcodec_ffm_init_context_r(FFCFFMContextR *s,uintptr_t fd,AVIOReadProc read);
-int ffcdecl ffcodec_ffm_init_context_w(FFCFFMContextW *s,uintptr_t fd,AVIOWriteProc write);
-int ffcdecl ffcodec_ffm_read_header(FFCFFMContextR *s);
-int ffcdecl ffcodec_ffm_read_packet_header(FFCFFMContextR *s, uint32_t *size);
-int ffcdecl ffcodec_ffm_read_packet_data(FFCFFMContextR *s, AVPacket *pkt);
-int ffcdecl ffcodec_ffm_write_header(FFCFFMContextW *s);
-int ffcdecl ffcodec_ffm_write_packet(FFCFFMContextW *s, AVPacket *pkt);
-int ffcdecl ffcodec_ffm_write_trailer(FFCFFMContextW *s);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* FFCODEC_H */
-

makemkv-oss-1.8.5.tar.gz/libffcodec/src/ffm.h Deleted

@@ -1,62 +0,0 @@
-/*
- * FFM (ffserver live feed) common header
- * 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_FFM_H
-#define AVFORMAT_FFM_H
-
-#include <stdint.h>
-#include "misc.h"
-
-/* The FFM file is made of blocks of fixed size */
-#define FFM_HEADER_SIZE 14
-#define FFM_PACKET_SIZE 4096
-#define PACKET_ID       0x666d
-
-/* each packet contains frames (which can span several packets */
-#define FRAME_HEADER_SIZE    16
-#define FLAG_KEY_FRAME       0x01
-#define FLAG_DTS             0x02
-
-enum {
-    READ_HEADER,
-    READ_DATA,
-};
-
-typedef struct FFMContext {
-    /* only reading mode */
-    int64_t write_index, file_size;
-    int read_state;
-    uint8_t header[FRAME_HEADER_SIZE+4];
-
-    /* read and write */
-    int first_packet; /* true if first packet, needed to set the discontinuity tag */
-    int packet_size;
-    int frame_offset;
-    int64_t dts;
-    uint8_t *packet_ptr, *packet_end;
-    uint8_t packet[FFM_PACKET_SIZE];
-} FFMContext;
-
-int64_t ffm_read_write_index(int fd);
-int ffm_write_write_index(int fd, int64_t pos);
-void ffm_set_write_index(AVFormatContext *s, int64_t pos, int64_t file_size);
-
-#endif /* AVFORMAT_FFM_H */

makemkv-oss-1.8.5.tar.gz/libffcodec/src/ffmdec.c Deleted

@@ -1,243 +0,0 @@
-/*
- * FFM (ffserver live feed) demuxer
- * 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
- */
-
-#include "ffm.h"
-#if CONFIG_FFSERVER
-#include <unistd.h>
-
-int64_t ffm_read_write_index(int fd)
-{
-    uint8_t buf[8];
-
-    lseek(fd, 8, SEEK_SET);
-    if (read(fd, buf, 8) != 8)
-        return AVERROR(EIO);
-    return AV_RB64(buf);
-}
-
-int ffm_write_write_index(int fd, int64_t pos)
-{
-    uint8_t buf[8];
-    int i;
-
-    for(i=0;i<8;i++)
-        buf[i] = (pos >> (56 - i * 8)) & 0xff;
-    lseek(fd, 8, SEEK_SET);
-    if (write(fd, buf, 8) != 8)
-        return AVERROR(EIO);
-    return 8;
-}
-
-void ffm_set_write_index(AVFormatContext *s, int64_t pos, int64_t file_size)
-{
-    FFMContext *ffm = s->priv_data;
-    ffm->write_index = pos;
-    ffm->file_size = file_size;
-}
-#endif // CONFIG_FFSERVER
-
-static int ffm_is_avail_data(AVFormatContext *s, int size)
-{
-    return 1;
-}
-
-static int ffm_resync(AVFormatContext *s, int state)
-{
-    return -1;
-}
-
-/* first is true if we read the frame header */
-static int ffm_read_data(AVFormatContext *s,
-                         uint8_t *buf, int size, int header)
-{
-    FFMContext *ffm = s->priv_data;
-    AVIOContext *pb = s->pb;
-    int len, fill_size, size1, frame_offset, id;
-
-    size1 = size;
-    while (size > 0) {
-    redo:
-        len = ffm->packet_end - ffm->packet_ptr;
-        if (len < 0)
-            return -1;
-        if (len > size)
-            len = size;
-        if (len == 0) {
-            /*if (avio_tell(pb) == ffm->file_size)
-                avio_seek(pb, ffm->packet_size, SEEK_SET);
-    retry_read:
-              if (pb->buffer_size != ffm->packet_size) {
-                int64_t tell = avio_tell(pb);
-                url_setbufsize(pb, ffm->packet_size);
-                avio_seek(pb, tell, SEEK_SET);
-            }*/
-            id = avio_rb16(pb); /* PACKET_ID */
-            if (id != PACKET_ID)
-                if (ffm_resync(s, id) < 0)
-                    return -1;
-            fill_size = avio_rb16(pb);
-            ffm->dts = avio_rb64(pb);
-            frame_offset = avio_rb16(pb);
-            if (avio_read(pb, ffm->packet, ffm->packet_size - FFM_HEADER_SIZE) < 0)
-                return -1;
-            ffm->packet_end = ffm->packet + (ffm->packet_size - FFM_HEADER_SIZE - fill_size);
-            if (ffm->packet_end < ffm->packet || frame_offset < 0)
-                return -1;
-            /* if first packet or resynchronization packet, we must
-               handle it specifically */
-            if (ffm->first_packet || (frame_offset & 0x8000)) {
-                if (!frame_offset) {
-                    /* This packet has no frame headers in it */
-                    /*if (avio_tell(pb) >= ffm->packet_size * 3) {
-                        avio_seek(pb, -ffm->packet_size * 2, SEEK_CUR);
-                        goto retry_read;
-                    }*/
-                    /* This is bad, we cannot find a valid frame header */
-                    return 0;
-                }
-                ffm->first_packet = 0;
-                if ((frame_offset & 0x7fff) < FFM_HEADER_SIZE)
-                    return -1;
-                ffm->packet_ptr = ffm->packet + (frame_offset & 0x7fff) - FFM_HEADER_SIZE;
-                if (!header)
-                    break;
-            } else {
-                ffm->packet_ptr = ffm->packet;
-            }
-            goto redo;
-        }
-        memcpy(buf, ffm->packet_ptr, len);
-        buf += len;
-        ffm->packet_ptr += len;
-        size -= len;
-        header = 0;
-    }
-    return size1 - size;
-}
-
-int ffm_read_header(AVFormatContext *s)
-{
-    FFMContext *ffm = s->priv_data;
-    AVIOContext *pb = s->pb;
-    int i, nb_streams;
-    uint32_t tag;
-
-    /* header */
-    tag = avio_rl32(pb);
-    if (tag != MKTAG('F', 'F', 'M', '1'))
-        goto fail;
-    ffm->packet_size = avio_rb32(pb);
-    if (ffm->packet_size != FFM_PACKET_SIZE)
-        goto fail;
-    ffm->write_index = avio_rb64(pb);
-    /* get also filesize */
-    /*if (pb->seekable) {
-        ffm->file_size = avio_size(pb);
-        if (ffm->write_index)
-            adjust_write_index(s);
-    } else*/ {
-        ffm->file_size = (UINT64_C(1) << 63) - 1;
-    }
-
-    nb_streams = avio_rb32(pb);
-    avio_rb32(pb); /* total bitrate */
-
-    if (nb_streams !=1 )
-        goto fail;
-
-    if (avio_read(pb, s->stream0_data, FFM_STREAM_HEADER_SIZE) < 0)
-        return -1;
-
-    /* get until end of block reached */
-    while ((avio_tell(pb) % ffm->packet_size) != 0)
-        avio_r8(pb);
-
-    /* init packet demux */
-    ffm->packet_ptr = ffm->packet;
-    ffm->packet_end = ffm->packet;
-    ffm->frame_offset = 0;
-    ffm->dts = 0;
-    ffm->read_state = READ_HEADER;
-    ffm->first_packet = 1;
-    return 0;
- fail:
-    //ffm_close(s);
-    return -1;
-}
-
-/* return < 0 if eof */
-int ffm_read_packet(AVFormatContext *s, AVPacket *pkt)
-{
-    int size;
-    FFMContext *ffm = s->priv_data;
-    int duration, ret;
-
-    switch(ffm->read_state) {
-    case READ_HEADER:
-        if ((ret = ffm_is_avail_data(s, FRAME_HEADER_SIZE+4)) < 0)
-            return ret;
-
-        /*av_dlog(s, "pos=%08"PRIx64" spos=%"PRIx64", write_index=%"PRIx64" size=%"PRIx64"\n",
-               avio_tell(s->pb), s->pb->pos, ffm->write_index, ffm->file_size);*/
-        if (ffm_read_data(s, ffm->header, FRAME_HEADER_SIZE, 1) !=
-            FRAME_HEADER_SIZE)
-            return -1;
-        if (ffm->header[1] & FLAG_DTS)
-            if (ffm_read_data(s, ffm->header+16, 4, 1) != 4)
-                return -1;
-        ffm->read_state = READ_DATA;
-        return 0;
-    case READ_DATA:
-        size = AV_RB24(ffm->header + 2);
-        if ((ret = ffm_is_avail_data(s, size)) < 0)
-            return ret;
-
-        duration = AV_RB24(ffm->header + 5);
-
-        //av_new_packet(pkt, size);
-        pkt->stream_index = ffm->header[0];
-        if ((unsigned)pkt->stream_index != 0) {
-            //av_log(s, AV_LOG_ERROR, "invalid stream index %d\n", pkt->stream_index);
-            //av_free_packet(pkt);
-            ffm->read_state = READ_HEADER;
-            return -1;
-        }
-        pkt->pos = avio_tell(s->pb);
-        if (ffm->header[1] & FLAG_KEY_FRAME)
-            pkt->flags |= AV_PKT_FLAG_KEY;
-
-        ffm->read_state = READ_HEADER;
-        if (ffm_read_data(s, pkt->data, size, 0) != size) {
-            /* bad case: desynchronized packet. we cancel all the packet loading */
-            //av_free_packet(pkt);
-            return -1;
-        }
-        pkt->pts = AV_RB64(ffm->header+8);
-        if (ffm->header[1] & FLAG_DTS)
-            pkt->dts = pkt->pts - AV_RB32(ffm->header+16);
-        else
-            pkt->dts = pkt->pts;
-        pkt->duration = duration;
-        break;
-    }
-    return 0;
-}
-

makemkv-oss-1.8.5.tar.gz/libffcodec/src/ffmenc.c Deleted

@@ -1,169 +0,0 @@
-/*
- * FFM (ffserver live feed) muxer
- * 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
- */
-
-#include "ffm.h"
-
-static void flush_packet(AVFormatContext *s)
-{
-    FFMContext *ffm = s->priv_data;
-    int fill_size, h;
-    AVIOContext *pb = s->pb;
-
-    fill_size = ffm->packet_end - ffm->packet_ptr;
-    memset(ffm->packet_ptr, 0, fill_size);
-
-    /*if (avio_tell(pb) % ffm->packet_size)
-        av_abort();*/
-
-    /* put header */
-    avio_wb16(pb, PACKET_ID);
-    avio_wb16(pb, fill_size);
-    avio_wb64(pb, ffm->dts);
-    h = ffm->frame_offset;
-    if (ffm->first_packet)
-        h |= 0x8000;
-    avio_wb16(pb, h);
-    avio_write(pb, ffm->packet, ffm->packet_end - ffm->packet);
-    avio_flush(pb);
-
-    /* prepare next packet */
-    ffm->frame_offset = 0; /* no key frame */
-    ffm->packet_ptr = ffm->packet;
-    ffm->first_packet = 0;
-}
-
-/* 'first' is true if first data of a frame */
-static void ffm_write_data(AVFormatContext *s,
-                           const uint8_t *buf, int size,
-                           int64_t dts, int header)
-{
-    FFMContext *ffm = s->priv_data;
-    int len;
-
-    if (header && ffm->frame_offset == 0) {
-        ffm->frame_offset = ffm->packet_ptr - ffm->packet + FFM_HEADER_SIZE;
-        ffm->dts = dts;
-    }
-
-    /* write as many packets as needed */
-    while (size > 0) {
-        len = ffm->packet_end - ffm->packet_ptr;
-        if (len > size)
-            len = size;
-        memcpy(ffm->packet_ptr, buf, len);
-
-        ffm->packet_ptr += len;
-        buf += len;
-        size -= len;
-        if (ffm->packet_ptr >= ffm->packet_end)
-            flush_packet(s);
-    }
-}
-
-int ffm_write_header(AVFormatContext *s)
-{
-    FFMContext *ffm = s->priv_data;
-    AVIOContext *pb = s->pb;
-    int bit_rate, i;
-
-    ffm->packet_size = FFM_PACKET_SIZE;
-
-    /* header */
-    avio_wl32(pb, MKTAG('F', 'F', 'M', '1'));
-    avio_wb32(pb, ffm->packet_size);
-    avio_wb64(pb, 0); /* current write position */
-
-    avio_wb32(pb, 1);
-    bit_rate = 0;
-    avio_wb32(pb, bit_rate);
-
-    avio_write(pb, s->stream0_data, FFM_STREAM_HEADER_SIZE);
-
-    /* flush until end of block reached */
-    while ((avio_tell(pb) % ffm->packet_size) != 0)
-        avio_w8(pb, 0);
-
-    avio_flush(pb);
-
-    /* init packet mux */
-    ffm->packet_ptr = ffm->packet;
-    ffm->packet_end = ffm->packet + ffm->packet_size - FFM_HEADER_SIZE;
-    //assert(ffm->packet_end >= ffm->packet);
-    ffm->frame_offset = 0;
-    ffm->dts = 0;
-    ffm->first_packet = 1;
-
-    return 0;
-}
-
-int ffm_write_packet(AVFormatContext *s, AVPacket *pkt)
-{
-    int64_t dts;
-    uint8_t header[FRAME_HEADER_SIZE+4];
-    int header_size = FRAME_HEADER_SIZE;
-
-    dts = pkt->dts;
-    /* packet size & key_frame */
-    header[0] = pkt->stream_index;
-    header[1] = 0;
-    if (pkt->flags & AV_PKT_FLAG_KEY)
-        header[1] |= FLAG_KEY_FRAME;
-    AV_WB24(header+2, pkt->size);
-    AV_WB24(header+5, pkt->duration);
-    AV_WB64(header+8, pkt->pts);
-    if (pkt->pts != pkt->dts) {
-        header[1] |= FLAG_DTS;
-        AV_WB32(header+16, pkt->pts - pkt->dts);
-        header_size += 4;
-    }
-    ffm_write_data(s, header, header_size, dts, 1);
-    ffm_write_data(s, pkt->data, pkt->size, dts, 0);
-
-    return 0;
-}
-
-/*static*/ int ffm_write_trailer(AVFormatContext *s)
-{
-    AVIOContext *pb = s->pb;
-    FFMContext *ffm = s->priv_data;
-
-    /* flush packets */
-    if (ffm->packet_ptr > ffm->packet)
-        flush_packet(s);
-
-    avio_flush(pb);
-
-    return 0;
-}
-
-#if 0
-AVOutputFormat ff_ffm_muxer = {
-    .name              = "ffm",
-    .long_name         = NULL_IF_CONFIG_SMALL("FFM (FFserver live feed) format"),
-    .extensions        = "ffm",
-    .priv_data_size    = sizeof(FFMContext),
-    .audio_codec       = CODEC_ID_MP2,
-    .video_codec       = CODEC_ID_MPEG1VIDEO,
-    .write_header      = ffm_write_header,
-    .write_packet      = ffm_write_packet,
-    .write_trailer     = ffm_write_trailer,
-};
-#endif

makemkv-oss-1.8.5.tar.gz/libffcodec/src/ffmisc.h Deleted

@@ -1,136 +0,0 @@
-/*
- * Bytestream functions
- * copyright (c) 2006 Baptiste Coudurier <baptiste.coudurier@free.fr>
- *
- * simple math operations
- * Copyright (c) 2001, 2002 Fabrice Bellard
- * Copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at> et al
- *
- * copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
- *
- * 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 FFCODEC_FFMISC_H
-#define FFCODEC_FFMISC_H
-
-
-#ifndef AV_RL16
-#   define AV_RL16(x)                           \
-    ((((const uint8_t*)(x))[1] << 8) |          \
-      ((const uint8_t*)(x))[0])
-#endif
-#ifndef AV_RB24
-#   define AV_RB24(x)                           \
-    ((((const uint8_t*)(x))[0] << 16) |         \
-     (((const uint8_t*)(x))[1] <<  8) |         \
-      ((const uint8_t*)(x))[2])
-#endif
-#ifndef AV_RB32
-#   define AV_RB32(x)                           \
-    ((((const uint8_t*)(x))[0] << 24) |         \
-     (((const uint8_t*)(x))[1] << 16) |         \
-     (((const uint8_t*)(x))[2] <<  8) |         \
-      ((const uint8_t*)(x))[3])
-#endif
-#ifndef AV_RB64
-#   define AV_RB64(x)                                   \
-    (((uint64_t)((const uint8_t*)(x))[0] << 56) |       \
-     ((uint64_t)((const uint8_t*)(x))[1] << 48) |       \
-     ((uint64_t)((const uint8_t*)(x))[2] << 40) |       \
-     ((uint64_t)((const uint8_t*)(x))[3] << 32) |       \
-     ((uint64_t)((const uint8_t*)(x))[4] << 24) |       \
-     ((uint64_t)((const uint8_t*)(x))[5] << 16) |       \
-     ((uint64_t)((const uint8_t*)(x))[6] <<  8) |       \
-      (uint64_t)((const uint8_t*)(x))[7])
-#endif
-
-#ifndef AV_WB32
-#   define AV_WB32(p, d) do {                   \
-        ((uint8_t*)(p))[3] = (d);               \
-        ((uint8_t*)(p))[2] = (d)>>8;            \
-        ((uint8_t*)(p))[1] = (d)>>16;           \
-        ((uint8_t*)(p))[0] = (d)>>24;           \
-    } while(0)
-#endif
-#ifndef AV_WB24
-#   define AV_WB24(p, d) do {                   \
-        ((uint8_t*)(p))[2] = (d);               \
-        ((uint8_t*)(p))[1] = (d)>>8;            \
-        ((uint8_t*)(p))[0] = (d)>>16;           \
-    } while(0)
-#endif
-#ifndef AV_WB64
-#   define AV_WB64(p, d) do {                   \
-        ((uint8_t*)(p))[7] = (d);               \
-        ((uint8_t*)(p))[6] = (d)>>8;            \
-        ((uint8_t*)(p))[5] = (d)>>16;           \
-        ((uint8_t*)(p))[4] = (d)>>24;           \
-        ((uint8_t*)(p))[3] = (d)>>32;           \
-        ((uint8_t*)(p))[2] = (d)>>40;           \
-        ((uint8_t*)(p))[1] = (d)>>48;           \
-        ((uint8_t*)(p))[0] = (d)>>56;           \
-    } while(0)
-#endif
-
-
-#ifndef NEG_USR32
-#   define NEG_USR32(a,s) (((uint32_t)(a))>>(32-(s)))
-#endif
-#ifndef NEG_SSR32
-#   define NEG_SSR32(a,s) ((( int32_t)(a))>>(32-(s)))
-#endif
-
-#define MKTAG(a,b,c,d) ((a) | ((b) << 8) | ((c) << 16) | ((unsigned)(d) << 24))
-#define MKBETAG(a,b,c,d) ((d) | ((c) << 8) | ((b) << 16) | ((unsigned)(a) << 24))
-
-#define AVERROR_EOF                (-MKTAG( 'E','O','F',' ')) ///< End of file
-#define AVERROR_INVALIDDATA        (-MKTAG( 'I','N','D','A')) ///< Invalid data found when processing input
-
-int64_t avio_tell(AVIOContext *s);
-int avio_read(AVIOContext *s, unsigned char *buf, int size);
-void avio_flush(AVIOContext *s);
-
-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);
-
-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);
-
-#define AV_PKT_FLAG_KEY     0x0001 ///< The packet contains a keyframe
-#define AV_PKT_FLAG_CORRUPT 0x0002 ///< The packet content is corrupted
-
-#define CODEC_FLAG_GLOBAL_HEADER  0x00400000 ///< Place global headers in extradata instead of every keyframe.
-
-#endif /* FFCODEC_FFMISC_H */
-

makemkv-oss-1.8.5.tar.gz/libffcodec/src/get_bits.h Deleted

@@ -1,565 +0,0 @@
-/*
- * copyright (c) 2004 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
- */
-
-/**
- * @file
- * bitstream reader API header.
- */
-
-#ifndef AVCODEC_GET_BITS_H
-#define AVCODEC_GET_BITS_H
-
-#include <stdint.h>
-#include "misc.h"
-/*
-#include "libavutil/bswap.h"
-#include "libavutil/common.h"
-#include "libavutil/intreadwrite.h"
-#include "libavutil/log.h"
-#include "mathops.h"
-*/
-
-/*
- * Safe bitstream reading:
- * optionally, the get_bits API can check to ensure that we
- * don't read past input buffer boundaries. This is protected
- * with CONFIG_SAFE_BITSTREAM_READER at the global level, and
- * then below that with UNCHECKED_BITSTREAM_READER at the per-
- * decoder level. This means that decoders that check internally
- * can "#define UNCHECKED_BITSTREAM_READER 1" to disable
- * overread checks.
- * Boundary checking causes a minor performance penalty so for
- * applications that won't want/need this, it can be disabled
- * globally using "#define CONFIG_SAFE_BITSTREAM_READER 0".
- */
-#ifndef UNCHECKED_BITSTREAM_READER
-#define UNCHECKED_BITSTREAM_READER !CONFIG_SAFE_BITSTREAM_READER
-#endif
-
-typedef struct GetBitContext {
-    const uint8_t *buffer, *buffer_end;
-    int index;
-    int size_in_bits;
-    int size_in_bits_plus8;
-} GetBitContext;
-
-#define VLC_TYPE int16_t
-
-typedef struct VLC {
-    int bits;
-    VLC_TYPE (*table)[2]; ///< code, bits
-    int table_size, table_allocated;
-} VLC;
-
-typedef struct RL_VLC_ELEM {
-    int16_t level;
-    int8_t len;
-    uint8_t run;
-} RL_VLC_ELEM;
-
-/* Bitstream reader API docs:
-name
-    arbitrary name which is used as prefix for the internal variables
-
-gb
-    getbitcontext
-
-OPEN_READER(name, gb)
-    load gb into local variables
-
-CLOSE_READER(name, gb)
-    store local vars in gb
-
-UPDATE_CACHE(name, gb)
-    refill the internal cache from the bitstream
-    after this call at least MIN_CACHE_BITS will be available,
-
-GET_CACHE(name, gb)
-    will output the contents of the internal cache, next bit is MSB of 32 or 64 bit (FIXME 64bit)
-
-SHOW_UBITS(name, gb, num)
-    will return the next num bits
-
-SHOW_SBITS(name, gb, num)
-    will return the next num bits and do sign extension
-
-SKIP_BITS(name, gb, num)
-    will skip over the next num bits
-    note, this is equivalent to SKIP_CACHE; SKIP_COUNTER
-
-SKIP_CACHE(name, gb, num)
-    will remove the next num bits from the cache (note SKIP_COUNTER MUST be called before UPDATE_CACHE / CLOSE_READER)
-
-SKIP_COUNTER(name, gb, num)
-    will increment the internal bit counter (see SKIP_CACHE & SKIP_BITS)
-
-LAST_SKIP_BITS(name, gb, num)
-    like SKIP_BITS, to be used if next call is UPDATE_CACHE or CLOSE_READER
-
-for examples see get_bits, show_bits, skip_bits, get_vlc
-*/
-
-#ifdef LONG_BITSTREAM_READER
-#   define MIN_CACHE_BITS 32
-#else
-#   define MIN_CACHE_BITS 25
-#endif
-
-#define OPEN_READER(name, gb)                   \
-    unsigned int name##_index = (gb)->index;    \
-    av_unused unsigned int name##_cache
-
-#define CLOSE_READER(name, gb) (gb)->index = name##_index
-
-#ifdef BITSTREAM_READER_LE
-
-# ifdef LONG_BITSTREAM_READER
-#   define UPDATE_CACHE(name, gb) name##_cache = \
-        AV_RL64((gb)->buffer + (name##_index >> 3)) >> (name##_index & 7)
-# else
-#   define UPDATE_CACHE(name, gb) name##_cache = \
-        AV_RL32((gb)->buffer + (name##_index >> 3)) >> (name##_index & 7)
-# endif
-
-# define SKIP_CACHE(name, gb, num) name##_cache >>= (num)
-
-#else
-
-# ifdef LONG_BITSTREAM_READER
-#   define UPDATE_CACHE(name, gb) name##_cache = \
-        AV_RB64((gb)->buffer + (name##_index >> 3)) >> (32 - (name##_index & 7))
-# else
-#   define UPDATE_CACHE(name, gb) name##_cache = \
-        AV_RB32((gb)->buffer + (name##_index >> 3)) << (name##_index & 7)
-# endif
-
-# define SKIP_CACHE(name, gb, num) name##_cache <<= (num)
-
-#endif
-
-#if UNCHECKED_BITSTREAM_READER
-#   define SKIP_COUNTER(name, gb, num) name##_index += (num)
-#else
-#   define SKIP_COUNTER(name, gb, num) \
-    name##_index = FFMIN((gb)->size_in_bits_plus8, name##_index + (num))
-#endif
-
-#define SKIP_BITS(name, gb, num) do {           \
-        SKIP_CACHE(name, gb, num);              \
-        SKIP_COUNTER(name, gb, num);            \
-    } while (0)
-
-#define LAST_SKIP_BITS(name, gb, num) SKIP_COUNTER(name, gb, num)
-
-#ifdef BITSTREAM_READER_LE
-#   define SHOW_UBITS(name, gb, num) zero_extend(name##_cache, num)
-#   define SHOW_SBITS(name, gb, num) sign_extend(name##_cache, num)
-#else
-#   define SHOW_UBITS(name, gb, num) NEG_USR32(name##_cache, num)
-#   define SHOW_SBITS(name, gb, num) NEG_SSR32(name##_cache, num)
-#endif
-
-#define GET_CACHE(name, gb) ((uint32_t)name##_cache)
-
-static inline int get_bits_count(const GetBitContext *s)
-{
-    return s->index;
-}
-
-static inline void skip_bits_long(GetBitContext *s, int n){
-#if UNCHECKED_BITSTREAM_READER
-    s->index += n;
-#else
-    s->index += av_clip(n, -s->index, s->size_in_bits_plus8 - s->index);
-#endif
-}
-
-/**
- * read mpeg1 dc style vlc (sign bit + mantisse with no MSB).
- * if MSB not set it is negative
- * @param n length in bits
- */
-static inline int get_xbits(GetBitContext *s, int n)
-{
-    register int sign;
-    register int32_t cache;
-    OPEN_READER(re, s);
-    UPDATE_CACHE(re, s);
-    cache = GET_CACHE(re, s);
-    sign = ~cache >> 31;
-    LAST_SKIP_BITS(re, s, n);
-    CLOSE_READER(re, s);
-    return (NEG_USR32(sign ^ cache, n) ^ sign) - sign;
-}
-
-static inline int get_sbits(GetBitContext *s, int n)
-{
-    register int tmp;
-    OPEN_READER(re, s);
-    UPDATE_CACHE(re, s);
-    tmp = SHOW_SBITS(re, s, n);
-    LAST_SKIP_BITS(re, s, n);
-    CLOSE_READER(re, s);
-    return tmp;
-}
-
-/**
- * Read 1-25 bits.
- */
-static inline unsigned int get_bits(GetBitContext *s, int n)
-{
-    register int tmp;
-    OPEN_READER(re, s);
-    UPDATE_CACHE(re, s);
-    tmp = SHOW_UBITS(re, s, n);
-    LAST_SKIP_BITS(re, s, n);
-    CLOSE_READER(re, s);
-    return tmp;
-}
-
-/**
- * Show 1-25 bits.
- */
-static inline unsigned int show_bits(GetBitContext *s, int n)
-{
-    register int tmp;
-    OPEN_READER(re, s);
-    UPDATE_CACHE(re, s);
-    tmp = SHOW_UBITS(re, s, n);
-    return tmp;
-}
-
-static inline void skip_bits(GetBitContext *s, int n)
-{
-    OPEN_READER(re, s);
-    UPDATE_CACHE(re, s);
-    LAST_SKIP_BITS(re, s, n);
-    CLOSE_READER(re, s);
-}
-
-static inline unsigned int get_bits1(GetBitContext *s)
-{
-    unsigned int index = s->index;
-    uint8_t result = s->buffer[index>>3];
-#ifdef BITSTREAM_READER_LE
-    result >>= index & 7;
-    result &= 1;
-#else
-    result <<= index & 7;
-    result >>= 8 - 1;
-#endif
-#if !UNCHECKED_BITSTREAM_READER
-    if (s->index < s->size_in_bits_plus8)
-#endif
-        index++;
-    s->index = index;
-
-    return result;
-}
-
-static inline unsigned int show_bits1(GetBitContext *s)
-{
-    return show_bits(s, 1);
-}
-
-static inline void skip_bits1(GetBitContext *s)
-{
-    skip_bits(s, 1);
-}
-
-/**
- * Read 0-32 bits.
- */
-static inline unsigned int get_bits_long(GetBitContext *s, int n)
-{
-    if (n <= MIN_CACHE_BITS)
-        return get_bits(s, n);
-    else {
-#ifdef BITSTREAM_READER_LE
-        int ret = get_bits(s, 16);
-        return ret | (get_bits(s, n-16) << 16);
-#else
-        int ret = get_bits(s, 16) << (n-16);
-        return ret | get_bits(s, n-16);
-#endif
-    }
-}
-
-/**
- * Read 0-32 bits as a signed integer.
- */
-/*
-static inline int get_sbits_long(GetBitContext *s, int n)
-{
-    return sign_extend(get_bits_long(s, n), n);
-}
-*/
-
-/**
- * Show 0-32 bits.
- */
-static inline unsigned int show_bits_long(GetBitContext *s, int n)
-{
-    if (n <= MIN_CACHE_BITS)
-        return show_bits(s, n);
-    else {
-        GetBitContext gb = *s;
-        return get_bits_long(&gb, n);
-    }
-}
-
-/*
-static inline int check_marker(GetBitContext *s, const char *msg)
-{
-    int bit = get_bits1(s);
-    if (!bit)
-        av_log(NULL, AV_LOG_INFO, "Marker bit missing %s\n", msg);
-
-    return bit;
-}
-*/
-
-/**
- * Inititalize GetBitContext.
- * @param buffer bitstream buffer, must be FF_INPUT_BUFFER_PADDING_SIZE bytes larger than the actual read bits
- * because some optimized bitstream readers read 32 or 64 bit at once and could read over the end
- * @param bit_size the size of the buffer in bits
- */
-static inline void init_get_bits(GetBitContext *s, const uint8_t *buffer,
-                                 int bit_size)
-{
-    int buffer_size = (bit_size+7)>>3;
-    if (buffer_size < 0 || bit_size < 0) {
-        buffer_size = bit_size = 0;
-        buffer = NULL;
-    }
-
-    s->buffer       = buffer;
-    s->size_in_bits = bit_size;
-    s->size_in_bits_plus8 = bit_size + 8;
-    s->buffer_end   = buffer + buffer_size;
-    s->index        = 0;
-}
-
-static inline void align_get_bits(GetBitContext *s)
-{
-    int n = -get_bits_count(s) & 7;
-    if (n) skip_bits(s, n);
-}
-
-#define init_vlc(vlc, nb_bits, nb_codes,                \
-                 bits, bits_wrap, bits_size,            \
-                 codes, codes_wrap, codes_size,         \
-                 flags)                                 \
-        init_vlc_sparse(vlc, nb_bits, nb_codes,         \
-                        bits, bits_wrap, bits_size,     \
-                        codes, codes_wrap, codes_size,  \
-                        NULL, 0, 0, flags)
-
-int init_vlc_sparse(VLC *vlc, int nb_bits, int nb_codes,
-             const void *bits, int bits_wrap, int bits_size,
-             const void *codes, int codes_wrap, int codes_size,
-             const void *symbols, int symbols_wrap, int symbols_size,
-             int flags);
-#define INIT_VLC_LE         2
-#define INIT_VLC_USE_NEW_STATIC 4
-void free_vlc(VLC *vlc);
-
-#define INIT_VLC_STATIC(vlc, bits, a,b,c,d,e,f,g, static_size) do {     \
-        static VLC_TYPE table[static_size][2];                          \
-        (vlc)->table = table;                                           \
-        (vlc)->table_allocated = static_size;                           \
-        init_vlc(vlc, bits, a,b,c,d,e,f,g, INIT_VLC_USE_NEW_STATIC);    \
-    } while (0)
-
-
-/**
- * If the vlc code is invalid and max_depth=1, then no bits will be removed.
- * If the vlc code is invalid and max_depth>1, then the number of bits removed
- * is undefined.
- */
-#define GET_VLC(code, name, gb, table, bits, max_depth)         \
-    do {                                                        \
-        int n, nb_bits;                                         \
-        unsigned int index;                                     \
-                                                                \
-        index = SHOW_UBITS(name, gb, bits);                     \
-        code  = table[index][0];                                \
-        n     = table[index][1];                                \
-                                                                \
-        if (max_depth > 1 && n < 0) {                           \
-            LAST_SKIP_BITS(name, gb, bits);                     \
-            UPDATE_CACHE(name, gb);                             \
-                                                                \
-            nb_bits = -n;                                       \
-                                                                \
-            index = SHOW_UBITS(name, gb, nb_bits) + code;       \
-            code  = table[index][0];                            \
-            n     = table[index][1];                            \
-            if (max_depth > 2 && n < 0) {                       \
-                LAST_SKIP_BITS(name, gb, nb_bits);              \
-                UPDATE_CACHE(name, gb);                         \
-                                                                \
-                nb_bits = -n;                                   \
-                                                                \
-                index = SHOW_UBITS(name, gb, nb_bits) + code;   \
-                code  = table[index][0];                        \
-                n     = table[index][1];                        \
-            }                                                   \
-        }                                                       \
-        SKIP_BITS(name, gb, n);                                 \
-    } while (0)
-
-#define GET_RL_VLC(level, run, name, gb, table, bits, max_depth, need_update) \
-    do {                                                                \
-        int n, nb_bits;                                                 \
-        unsigned int index;                                             \
-                                                                        \
-        index = SHOW_UBITS(name, gb, bits);                             \
-        level = table[index].level;                                     \
-        n     = table[index].len;                                       \
-                                                                        \
-        if (max_depth > 1 && n < 0) {                                   \
-            SKIP_BITS(name, gb, bits);                                  \
-            if (need_update) {                                          \
-                UPDATE_CACHE(name, gb);                                 \
-            }                                                           \
-                                                                        \
-            nb_bits = -n;                                               \
-                                                                        \
-            index = SHOW_UBITS(name, gb, nb_bits) + level;              \
-            level = table[index].level;                                 \
-            n     = table[index].len;                                   \
-        }                                                               \
-        run = table[index].run;                                         \
-        SKIP_BITS(name, gb, n);                                         \
-    } while (0)
-
-
-/**
- * Parse a vlc code.
- * @param bits is the number of bits which will be read at once, must be
- *             identical to nb_bits in init_vlc()
- * @param max_depth is the number of times bits bits must be read to completely
- *                  read the longest vlc code
- *                  = (max_vlc_length + bits - 1) / bits
- */
-static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE (*table)[2],
-                                     int bits, int max_depth)
-{
-    int code;
-
-    OPEN_READER(re, s);
-    UPDATE_CACHE(re, s);
-
-    GET_VLC(code, re, s, table, bits, max_depth);
-
-    CLOSE_READER(re, s);
-    return code;
-}
-
-static inline int decode012(GetBitContext *gb)
-{
-    int n;
-    n = get_bits1(gb);
-    if (n == 0)
-        return 0;
-    else
-        return get_bits1(gb) + 1;
-}
-
-static inline int decode210(GetBitContext *gb)
-{
-    if (get_bits1(gb))
-        return 0;
-    else
-        return 2 - get_bits1(gb);
-}
-
-static inline int get_bits_left(GetBitContext *gb)
-{
-    return gb->size_in_bits - get_bits_count(gb);
-}
-
-//#define TRACE
-
-#ifdef TRACE
-static inline void print_bin(int bits, int n)
-{
-    int i;
-
-    for (i = n-1; i >= 0; i--) {
-        av_log(NULL, AV_LOG_DEBUG, "%d", (bits>>i)&1);
-    }
-    for (i = n; i < 24; i++)
-        av_log(NULL, AV_LOG_DEBUG, " ");
-}
-
-static inline int get_bits_trace(GetBitContext *s, int n, char *file,
-                                 const char *func, int line)
-{
-    int r = get_bits(s, n);
-
-    print_bin(r, n);
-    av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d bit @%5d in %s %s:%d\n",
-           r, n, r, get_bits_count(s)-n, file, func, line);
-    return r;
-}
-static inline int get_vlc_trace(GetBitContext *s, VLC_TYPE (*table)[2],
-                                int bits, int max_depth, char *file,
-                                const char *func, int line)
-{
-    int show  = show_bits(s, 24);
-    int pos   = get_bits_count(s);
-    int r     = get_vlc2(s, table, bits, max_depth);
-    int len   = get_bits_count(s) - pos;
-    int bits2 = show >> (24-len);
-
-    print_bin(bits2, len);
-
-    av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d vlc @%5d in %s %s:%d\n",
-           bits2, len, r, pos, file, func, line);
-    return r;
-}
-static inline int get_xbits_trace(GetBitContext *s, int n, char *file,
-                                  const char *func, int line)
-{
-    int show = show_bits(s, n);
-    int r    = get_xbits(s, n);
-
-    print_bin(show, n);
-    av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d xbt @%5d in %s %s:%d\n",
-           show, n, r, get_bits_count(s)-n, file, func, line);
-    return r;
-}
-
-#define get_bits(s, n)  get_bits_trace(s, n, __FILE__, __PRETTY_FUNCTION__, __LINE__)
-#define get_bits1(s)    get_bits_trace(s, 1, __FILE__, __PRETTY_FUNCTION__, __LINE__)
-#define get_xbits(s, n) get_xbits_trace(s, n, __FILE__, __PRETTY_FUNCTION__, __LINE__)
-#define get_vlc(s, vlc)            get_vlc_trace(s, (vlc)->table, (vlc)->bits, 3, __FILE__, __PRETTY_FUNCTION__, __LINE__)
-#define get_vlc2(s, tab, bits, max) get_vlc_trace(s, tab, bits, max, __FILE__, __PRETTY_FUNCTION__, __LINE__)
-
-#define tprintf(p, ...) av_log(p, AV_LOG_DEBUG, __VA_ARGS__)
-
-#else //TRACE
-#define tprintf(p, ...) {}
-#endif
-
-#endif /* AVCODEC_GET_BITS_H */

makemkv-oss-1.8.5.tar.gz/libffcodec/src/misc.h Deleted

@@ -1,105 +0,0 @@
-/*
-    libMakeMKV - MKV multiplexer library
-
-    Copyright (C) 2007-2013 GuinpinSoft inc <libmkv@makemkv.com>
-
-    This library 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.
-
-    This library 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 this library; if not, write to the Free Software
-    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-
-*/
-#ifndef FFCODEC_MISC_H
-#define FFCODEC_MISC_H
-
-#include <stdint.h>
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-
-#define CONFIG_HARDCODED_TABLES     1
-#define CONFIG_SMALL                1
-#define CONFIG_FFSERVER             0
-#define ALT_BITSTREAM_READER        1
-
-#define av_pure
-#define av_cold
-#define av_unused
-
-#ifdef _MSC_VER
-#define inline              __inline
-#define av_always_inline    __inline
-#define ffcdecl             __cdecl
-#else
-#define inline              __inline__
-#define av_always_inline    __inline__
-#define ffcdecl
-#endif
-
-static uint32_t av_bswap32(uint32_t i)
-{
-    uint32_t j;
-    j =  (i << 24);
-    j |= (i <<  8) & 0x00FF0000;
-    j |= (i >>  8) & 0x0000FF00;
-    j |= (i >> 24);
-    return j;
-}
-
-#define AVERROR(x)          -4
-
-typedef int (ffcdecl *AVIOReadProc)(uintptr_t fd, unsigned char *buf, unsigned int size);
-typedef int (ffcdecl *AVIOWriteProc)(uintptr_t fd, const unsigned char *buf, unsigned int size);
-
-typedef struct AVIOContext
-{
-    uintptr_t       fd;
-    uint64_t        pos;
-    AVIOReadProc    read;
-    AVIOWriteProc   write;
-    uint8_t*        buffer;
-    int             buffer_size;
-    int             buffer_max_size;
-} AVIOContext;
-
-#define FFM_STREAM_HEADER_SIZE     0x0100 ///< Stream header size
-
-typedef struct AVFormatContext
-{
-    void*           priv_data;
-    AVIOContext*    pb;
-    uint8_t         stream0_data[FFM_STREAM_HEADER_SIZE];
-} AVFormatContext;
-
-typedef struct AVPacket
-{
-    uint8_t*        data;
-    uint32_t        size;
-    uint64_t        pos;
-    uint32_t        flags;
-    uint8_t         stream_index;
-    uint64_t        pts;
-    uint64_t        dts;
-    uint32_t        duration;
-} AVPacket;
-
-typedef struct AVAudioInfo
-{
-    int             channels;
-    uint64_t        channel_layout;
-} AVAudioInfo;
-
-#include "ffmisc.h"
-
-
-#endif /* FFCODEC_MISC_H */
-

makemkv-oss-1.8.5.tar.gz/libffcodec/src/mlp.c Deleted

@@ -1,115 +0,0 @@
-/*
- * MLP codec common code
- * Copyright (c) 2007-2008 Ian Caulfield
- *
- * 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
- */
-
-#include <stdint.h>
-
-#include "crc.h"
-#include "mlp.h"
-#include "misc.h"
-
-const uint8_t ff_mlp_huffman_tables[3][18][2] = {
-    {    /* Huffman table 0, -7 - +10 */
-        {0x01, 9}, {0x01, 8}, {0x01, 7}, {0x01, 6}, {0x01, 5}, {0x01, 4}, {0x01, 3},
-        {0x04, 3}, {0x05, 3}, {0x06, 3}, {0x07, 3},
-        {0x03, 3}, {0x05, 4}, {0x09, 5}, {0x11, 6}, {0x21, 7}, {0x41, 8}, {0x81, 9},
-    }, { /* Huffman table 1, -7 - +8 */
-        {0x01, 9}, {0x01, 8}, {0x01, 7}, {0x01, 6}, {0x01, 5}, {0x01, 4}, {0x01, 3},
-        {0x02, 2}, {0x03, 2},
-        {0x03, 3}, {0x05, 4}, {0x09, 5}, {0x11, 6}, {0x21, 7}, {0x41, 8}, {0x81, 9},
-    }, { /* Huffman table 2, -7 - +7 */
-        {0x01, 9}, {0x01, 8}, {0x01, 7}, {0x01, 6}, {0x01, 5}, {0x01, 4}, {0x01, 3},
-        {0x01, 1},
-        {0x03, 3}, {0x05, 4}, {0x09, 5}, {0x11, 6}, {0x21, 7}, {0x41, 8}, {0x81, 9},
-    }
-};
-
-static int crc_init = 0;
-#if CONFIG_SMALL
-#define CRC_TABLE_SIZE 257
-#else
-#define CRC_TABLE_SIZE 1024
-#endif
-static AVCRC crc_63[CRC_TABLE_SIZE];
-static AVCRC crc_1D[CRC_TABLE_SIZE];
-static AVCRC crc_2D[CRC_TABLE_SIZE];
-
-av_cold void ff_mlp_init_crc(void)
-{
-    if (!crc_init) {
-        av_crc_init(crc_63, 0,  8,   0x63, sizeof(crc_63));
-        av_crc_init(crc_1D, 0,  8,   0x1D, sizeof(crc_1D));
-        av_crc_init(crc_2D, 0, 16, 0x002D, sizeof(crc_2D));
-        crc_init = 1;
-    }
-}
-
-uint16_t ff_mlp_checksum16(const uint8_t *buf, unsigned int buf_size)
-{
-    uint16_t crc;
-
-    crc = av_crc(crc_2D, 0, buf, buf_size - 2);
-    crc ^= AV_RL16(buf + buf_size - 2);
-    return crc;
-}
-
-uint8_t ff_mlp_checksum8(const uint8_t *buf, unsigned int buf_size)
-{
-    uint8_t checksum = av_crc(crc_63, 0x3c, buf, buf_size - 1); // crc_63[0xa2] == 0x3c
-    checksum ^= buf[buf_size-1];
-    return checksum;
-}
-
-uint8_t ff_mlp_restart_checksum(const uint8_t *buf, unsigned int bit_size)
-{
-    int i;
-    int num_bytes = (bit_size + 2) / 8;
-
-    int crc = crc_1D[buf[0] & 0x3f];
-    crc = av_crc(crc_1D, crc, buf + 1, num_bytes - 2);
-    crc ^= buf[num_bytes - 1];
-
-    for (i = 0; i < ((bit_size + 2) & 7); i++) {
-        crc <<= 1;
-        if (crc & 0x100)
-            crc ^= 0x11D;
-        crc ^= (buf[num_bytes] >> (7 - i)) & 1;
-    }
-
-    return crc;
-}
-
-uint8_t ff_mlp_calculate_parity(const uint8_t *buf, unsigned int buf_size)
-{
-    uint32_t scratch = 0;
-    const uint8_t *buf_end = buf + buf_size;
-
-    for (; ((intptr_t) buf & 3) && buf < buf_end; buf++)
-        scratch ^= *buf;
-    for (; buf < buf_end - 3; buf += 4)
-        scratch ^= *((const uint32_t*)buf);
-
-    scratch = xor_32_to_8(scratch);
-
-    for (; buf < buf_end; buf++)
-        scratch ^= *buf;
-
-    return scratch;
-}

makemkv-oss-1.8.5.tar.gz/libffcodec/src/mlp.h Deleted

@@ -1,125 +0,0 @@
-/*
- * MLP codec common header file
- * Copyright (c) 2007-2008 Ian Caulfield
- *
- * 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_MLP_H
-#define AVCODEC_MLP_H
-
-#include <stdint.h>
-
-/** Last possible matrix channel for each codec */
-#define MAX_MATRIX_CHANNEL_MLP      5
-#define MAX_MATRIX_CHANNEL_TRUEHD   7
-/** Maximum number of channels in a valid stream.
- *  MLP   : 5.1 + 2 noise channels -> 8 channels
- *  TrueHD: 7.1                    -> 8 channels
- */
-#define MAX_CHANNELS                8
-
-/** Maximum number of matrices used in decoding; most streams have one matrix
- *  per output channel, but some rematrix a channel (usually 0) more than once.
- */
-#define MAX_MATRICES_MLP            6
-#define MAX_MATRICES_TRUEHD         8
-#define MAX_MATRICES                8
-
-/** Maximum number of substreams that can be decoded.
- *  MLP's limit is 2. TrueHD supports at least up to 3.
- */
-#define MAX_SUBSTREAMS      3
-
-/** which multiple of 48000 the maximum sample rate is */
-#define MAX_RATEFACTOR      4
-/** maximum sample frequency seen in files */
-#define MAX_SAMPLERATE      (MAX_RATEFACTOR * 48000)
-
-/** maximum number of audio samples within one access unit */
-#define MAX_BLOCKSIZE       (40 * MAX_RATEFACTOR)
-/** next power of two greater than MAX_BLOCKSIZE */
-#define MAX_BLOCKSIZE_POW2  (64 * MAX_RATEFACTOR)
-
-/** number of allowed filters */
-#define NUM_FILTERS         2
-
-/** The maximum number of taps in IIR and FIR filters. */
-#define MAX_FIR_ORDER       8
-#define MAX_IIR_ORDER       4
-
-/** Code that signals end of a stream. */
-#define END_OF_STREAM       0xd234d234
-
-#define FIR 0
-#define IIR 1
-
-/** filter data */
-typedef struct {
-    uint8_t     order; ///< number of taps in filter
-    uint8_t     shift; ///< Right shift to apply to output of filter.
-
-    int32_t     state[MAX_FIR_ORDER];
-} FilterParams;
-
-/** sample data coding information */
-typedef struct {
-    FilterParams filter_params[NUM_FILTERS];
-    int32_t     coeff[NUM_FILTERS][MAX_FIR_ORDER];
-
-    int16_t     huff_offset;      ///< Offset to apply to residual values.
-    int32_t     sign_huff_offset; ///< sign/rounding-corrected version of huff_offset
-    uint8_t     codebook;         ///< Which VLC codebook to use to read residuals.
-    uint8_t     huff_lsbs;        ///< Size of residual suffix not encoded using VLC.
-} ChannelParams;
-
-/** Tables defining the Huffman codes.
- *  There are three entropy coding methods used in MLP (four if you count
- *  "none" as a method). These use the same sequences for codes starting with
- *  00 or 01, but have different codes starting with 1.
- */
-extern const uint8_t ff_mlp_huffman_tables[3][18][2];
-
-/** MLP uses checksums that seem to be based on the standard CRC algorithm, but
- *  are not (in implementation terms, the table lookup and XOR are reversed).
- *  We can implement this behavior using a standard av_crc on all but the
- *  last element, then XOR that with the last element.
- */
-uint8_t  ff_mlp_checksum8 (const uint8_t *buf, unsigned int buf_size);
-uint16_t ff_mlp_checksum16(const uint8_t *buf, unsigned int buf_size);
-
-/** Calculate an 8-bit checksum over a restart header -- a non-multiple-of-8
- *  number of bits, starting two bits into the first byte of buf.
- */
-uint8_t ff_mlp_restart_checksum(const uint8_t *buf, unsigned int bit_size);
-
-/** XOR together all the bytes of a buffer.
- *  Does this belong in dspcontext?
- */
-uint8_t ff_mlp_calculate_parity(const uint8_t *buf, unsigned int buf_size);
-
-void ff_mlp_init_crc(void);
-
-/** XOR four bytes into one. */
-static inline uint8_t xor_32_to_8(uint32_t value)
-{
-    value ^= value >> 16;
-    value ^= value >>  8;
-    return value;
-}
-
-#endif /* AVCODEC_MLP_H */

makemkv-oss-1.8.5.tar.gz/libffcodec/src/mlp_parser.c Deleted

@@ -1,210 +0,0 @@
-/*
- * MLP parser
- * Copyright (c) 2007 Ian Caulfield
- *
- * 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
- * MLP parser
- */
-
-#include <stdint.h>
-
-#include "misc.h"
-#include "crc.h"
-#include "get_bits.h"
-#include "mlp_parser.h"
-#include "mlp.h"
-#include "audioconvert.h"
-
-static const uint8_t mlp_quants[16] = {
-    16, 20, 24, 0, 0, 0, 0, 0,
-     0,  0,  0, 0, 0, 0, 0, 0,
-};
-
-static const uint8_t mlp_channels[32] = {
-    1, 2, 3, 4, 3, 4, 5, 3, 4, 5, 4, 5, 6, 4, 5, 4,
-    5, 6, 5, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-};
-
-const uint64_t ff_mlp_layout[32] = {
-    AV_CH_LAYOUT_MONO,
-    AV_CH_LAYOUT_STEREO,
-    AV_CH_LAYOUT_2_1,
-    AV_CH_LAYOUT_QUAD,
-    AV_CH_LAYOUT_STEREO|AV_CH_LOW_FREQUENCY,
-    AV_CH_LAYOUT_2_1|AV_CH_LOW_FREQUENCY,
-    AV_CH_LAYOUT_QUAD|AV_CH_LOW_FREQUENCY,
-    AV_CH_LAYOUT_SURROUND,
-    AV_CH_LAYOUT_4POINT0,
-    AV_CH_LAYOUT_5POINT0_BACK,
-    AV_CH_LAYOUT_SURROUND|AV_CH_LOW_FREQUENCY,
-    AV_CH_LAYOUT_4POINT0|AV_CH_LOW_FREQUENCY,
-    AV_CH_LAYOUT_5POINT1_BACK,
-    AV_CH_LAYOUT_4POINT0,
-    AV_CH_LAYOUT_5POINT0_BACK,
-    AV_CH_LAYOUT_SURROUND|AV_CH_LOW_FREQUENCY,
-    AV_CH_LAYOUT_4POINT0|AV_CH_LOW_FREQUENCY,
-    AV_CH_LAYOUT_5POINT1_BACK,
-    AV_CH_LAYOUT_QUAD|AV_CH_LOW_FREQUENCY,
-    AV_CH_LAYOUT_5POINT0_BACK,
-    AV_CH_LAYOUT_5POINT1_BACK,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-};
-
-static const uint8_t thd_chancount[13] = {
-//  LR    C   LFE  LRs LRvh  LRc LRrs  Cs   Ts  LRsd  LRw  Cvh  LFE2
-     2,   1,   1,   2,   2,   2,   2,   1,   1,   2,   2,   1,   1
-};
-
-static const uint64_t thd_layout[13] = {
-    AV_CH_FRONT_LEFT|AV_CH_FRONT_RIGHT,                     // LR
-    AV_CH_FRONT_CENTER,                                     // C
-    AV_CH_LOW_FREQUENCY,                                    // LFE
-    AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT,                       // LRs
-    AV_CH_TOP_FRONT_LEFT|AV_CH_TOP_FRONT_RIGHT,             // LRvh
-    AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER, // LRc
-    AV_CH_BACK_LEFT|AV_CH_BACK_RIGHT,                       // LRrs
-    AV_CH_BACK_CENTER,                                      // Cs
-    AV_CH_TOP_CENTER,                                       // Ts
-    AV_CH_SIDE_LEFT|AV_CH_SIDE_RIGHT,                       // LRsd - TODO: Surround Direct
-    AV_CH_FRONT_LEFT_OF_CENTER|AV_CH_FRONT_RIGHT_OF_CENTER, // LRw  - TODO: Wide
-    AV_CH_TOP_FRONT_CENTER,                                 // Cvh
-    AV_CH_LOW_FREQUENCY                                     // LFE2
-};
-
-static int mlp_samplerate(int in)
-{
-    if (in == 0xF)
-        return 0;
-
-    return (in & 8 ? 44100 : 48000) << (in & 7) ;
-}
-
-static int truehd_channels(int chanmap)
-{
-    int channels = 0, i;
-
-    for (i = 0; i < 13; i++)
-        channels += thd_chancount[i] * ((chanmap >> i) & 1);
-
-    return channels;
-}
-
-uint64_t ff_truehd_layout(int chanmap)
-{
-    int layout = 0, i;
-
-    for (i = 0; i < 13; i++)
-        layout |= thd_layout[i] * ((chanmap >> i) & 1);
-
-    return layout;
-}
-
-/** Read a major sync info header - contains high level information about
- *  the stream - sample rate, channel arrangement etc. Most of this
- *  information is not actually necessary for decoding, only for playback.
- *  gb must be a freshly initialized GetBitContext with no bits read.
- */
-
-int ff_mlp_read_major_sync(void *log, MLPHeaderInfo *mh, GetBitContext *gb)
-{
-    int ratebits;
-    uint16_t checksum;
-
-    //assert(get_bits_count(gb) == 0);
-
-    if (gb->size_in_bits < 28 << 3) {
-        return -1;
-    }
-
-    checksum = ff_mlp_checksum16(gb->buffer, 26);
-    if (checksum != AV_RL16(gb->buffer+26)) {
-        return AVERROR_INVALIDDATA;
-    }
-
-    if (get_bits_long(gb, 24) != 0xf8726f) /* Sync words */
-        return AVERROR_INVALIDDATA;
-
-    mh->stream_type = get_bits(gb, 8);
-
-    if (mh->stream_type == 0xbb) {
-        mh->group1_bits = mlp_quants[get_bits(gb, 4)];
-        mh->group2_bits = mlp_quants[get_bits(gb, 4)];
-
-        ratebits = get_bits(gb, 4);
-        mh->group1_samplerate = mlp_samplerate(ratebits);
-        mh->group2_samplerate = mlp_samplerate(get_bits(gb, 4));
-
-        skip_bits(gb, 11);
-
-        mh->channels_mlp = get_bits(gb, 5);
-    } else if (mh->stream_type == 0xba) {
-        mh->group1_bits = 24; // TODO: Is this information actually conveyed anywhere?
-        mh->group2_bits = 0;
-
-        ratebits = get_bits(gb, 4);
-        mh->group1_samplerate = mlp_samplerate(ratebits);
-        mh->group2_samplerate = 0;
-
-        skip_bits(gb, 8);
-
-        mh->channels_thd_stream1 = get_bits(gb, 5);
-
-        skip_bits(gb, 2);
-
-        mh->channels_thd_stream2 = get_bits(gb, 13);
-    } else
-        return AVERROR_INVALIDDATA;
-
-    mh->access_unit_size = 40 << (ratebits & 7);
-    mh->access_unit_size_pow2 = 64 << (ratebits & 7);
-
-    skip_bits_long(gb, 48);
-
-    mh->is_vbr = get_bits1(gb);
-
-    mh->peak_bitrate = (get_bits(gb, 15) * mh->group1_samplerate + 8) >> 4;
-
-    mh->num_substreams = get_bits(gb, 4);
-
-    skip_bits_long(gb, 4 + 11 * 8);
-
-    return 0;
-}
-
-int ffcdecl ffcodec_ff_mlp_get_audio_info(const MLPHeaderInfo *mh,AVAudioInfo* avctx)
-{
-    if (mh->stream_type == 0xbb) {
-        /* MLP stream */
-        avctx->channels = mlp_channels[mh->channels_mlp];
-        avctx->channel_layout = ff_mlp_layout[mh->channels_mlp];
-    } else { /* mh.stream_type == 0xba */
-        /* TrueHD stream */
-        if (mh->channels_thd_stream2) {
-            avctx->channels = truehd_channels(mh->channels_thd_stream2);
-            avctx->channel_layout = ff_truehd_layout(mh->channels_thd_stream2);
-        } else {
-            avctx->channels = truehd_channels(mh->channels_thd_stream1);
-            avctx->channel_layout = ff_truehd_layout(mh->channels_thd_stream1);
-        }
-    }
-    return 0;
-}
-

makemkv-oss-1.8.5.tar.gz/libffcodec/src/mlp_parser.h Deleted

@@ -1,62 +0,0 @@
-/*
- * MLP parser prototypes
- * Copyright (c) 2007 Ian Caulfield
- *
- * 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
- * MLP parser prototypes
- */
-
-#ifndef AVCODEC_MLP_PARSER_H
-#define AVCODEC_MLP_PARSER_H
-
-#include "get_bits.h"
-
-typedef struct MLPHeaderInfo
-{
-    int stream_type;            ///< 0xBB for MLP, 0xBA for TrueHD
-
-    int group1_bits;            ///< The bit depth of the first substream
-    int group2_bits;            ///< Bit depth of the second substream (MLP only)
-
-    int group1_samplerate;      ///< Sample rate of first substream
-    int group2_samplerate;      ///< Sample rate of second substream (MLP only)
-
-    int channels_mlp;           ///< Channel arrangement for MLP streams
-    int channels_thd_stream1;   ///< Channel arrangement for substream 1 of TrueHD streams (5.1)
-    int channels_thd_stream2;   ///< Channel arrangement for substream 2 of TrueHD streams (7.1)
-
-    int access_unit_size;       ///< Number of samples per coded frame
-    int access_unit_size_pow2;  ///< Next power of two above number of samples per frame
-
-    int is_vbr;                 ///< Stream is VBR instead of CBR
-    int peak_bitrate;           ///< Peak bitrate for VBR, actual bitrate (==peak) for CBR
-
-    int num_substreams;         ///< Number of substreams within stream
-} MLPHeaderInfo;
-
-
-int ff_mlp_read_major_sync(void *log, MLPHeaderInfo *mh, GetBitContext *gb);
-uint64_t ff_truehd_layout(int chanmap);
-
-extern const uint64_t ff_mlp_layout[32];
-
-#endif /* AVCODEC_MLP_PARSER_H */
-

makemkv-oss-1.8.5.tar.gz/libffcodec/src/mpegaudio.h Deleted

@@ -1,75 +0,0 @@
-/*
- * 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
- */
-
-/**
- * @file
- * mpeg audio declarations for both encoder and decoder.
- */
-
-#ifndef AVCODEC_MPEGAUDIO_H
-#define AVCODEC_MPEGAUDIO_H
-
-#ifndef CONFIG_FLOAT
-#   define CONFIG_FLOAT 0
-#endif
-
-#include <stdint.h>
-
-/* max frame size, in samples */
-#define MPA_FRAME_SIZE 1152
-
-/* max compressed frame size */
-#define MPA_MAX_CODED_FRAME_SIZE 1792
-
-#define MPA_MAX_CHANNELS 2
-
-#define SBLIMIT 32 /* number of subbands */
-
-#define MPA_STEREO  0
-#define MPA_JSTEREO 1
-#define MPA_DUAL    2
-#define MPA_MONO    3
-
-#ifndef FRAC_BITS
-#define FRAC_BITS   23   /* fractional bits for sb_samples and dct */
-#define WFRAC_BITS  16   /* fractional bits for window */
-#endif
-
-#define FRAC_ONE    (1 << FRAC_BITS)
-
-#define FIX(a)   ((int)((a) * FRAC_ONE))
-
-#if CONFIG_FLOAT
-#   define INTFLOAT float
-typedef float MPA_INT;
-typedef float OUT_INT;
-#elif FRAC_BITS <= 15
-#   define INTFLOAT int
-typedef int16_t MPA_INT;
-typedef int16_t OUT_INT;
-#else
-#   define INTFLOAT int
-typedef int32_t MPA_INT;
-typedef int16_t OUT_INT;
-#endif
-
-int ff_mpa_l2_select_table(int bitrate, int nb_channels, int freq, int lsf);
-
-#endif /* AVCODEC_MPEGAUDIO_H */

makemkv-oss-1.8.5.tar.gz/libffcodec/src/mpegaudiodata.c Deleted

@@ -1,188 +0,0 @@
-/*
- * MPEG Audio common tables
- * copyright (c) 2002 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
- */
-
-/**
- * @file
- * mpeg audio layer common tables.
- */
-
-#include "mpegaudiodata.h"
-
-
-const uint16_t avpriv_mpa_bitrate_tab[2][3][15] = {
-    { {0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448 },
-      {0, 32, 48, 56,  64,  80,  96, 112, 128, 160, 192, 224, 256, 320, 384 },
-      {0, 32, 40, 48,  56,  64,  80,  96, 112, 128, 160, 192, 224, 256, 320 } },
-    { {0, 32, 48, 56,  64,  80,  96, 112, 128, 144, 160, 176, 192, 224, 256},
-      {0,  8, 16, 24,  32,  40,  48,  56,  64,  80,  96, 112, 128, 144, 160},
-      {0,  8, 16, 24,  32,  40,  48,  56,  64,  80,  96, 112, 128, 144, 160}
-    }
-};
-
-const uint16_t avpriv_mpa_freq_tab[3] = { 44100, 48000, 32000 };
-
-#if 0
-
-/*******************************************************/
-/* half mpeg encoding window (full precision) */
-const int32_t ff_mpa_enwindow[257] = {
-     0,    -1,    -1,    -1,    -1,    -1,    -1,    -2,
-    -2,    -2,    -2,    -3,    -3,    -4,    -4,    -5,
-    -5,    -6,    -7,    -7,    -8,    -9,   -10,   -11,
-   -13,   -14,   -16,   -17,   -19,   -21,   -24,   -26,
-   -29,   -31,   -35,   -38,   -41,   -45,   -49,   -53,
-   -58,   -63,   -68,   -73,   -79,   -85,   -91,   -97,
-  -104,  -111,  -117,  -125,  -132,  -139,  -147,  -154,
-  -161,  -169,  -176,  -183,  -190,  -196,  -202,  -208,
-   213,   218,   222,   225,   227,   228,   228,   227,
-   224,   221,   215,   208,   200,   189,   177,   163,
-   146,   127,   106,    83,    57,    29,    -2,   -36,
-   -72,  -111,  -153,  -197,  -244,  -294,  -347,  -401,
-  -459,  -519,  -581,  -645,  -711,  -779,  -848,  -919,
-  -991, -1064, -1137, -1210, -1283, -1356, -1428, -1498,
- -1567, -1634, -1698, -1759, -1817, -1870, -1919, -1962,
- -2001, -2032, -2057, -2075, -2085, -2087, -2080, -2063,
-  2037,  2000,  1952,  1893,  1822,  1739,  1644,  1535,
-  1414,  1280,  1131,   970,   794,   605,   402,   185,
-   -45,  -288,  -545,  -814, -1095, -1388, -1692, -2006,
- -2330, -2663, -3004, -3351, -3705, -4063, -4425, -4788,
- -5153, -5517, -5879, -6237, -6589, -6935, -7271, -7597,
- -7910, -8209, -8491, -8755, -8998, -9219, -9416, -9585,
- -9727, -9838, -9916, -9959, -9966, -9935, -9863, -9750,
- -9592, -9389, -9139, -8840, -8492, -8092, -7640, -7134,
-  6574,  5959,  5288,  4561,  3776,  2935,  2037,  1082,
-    70,  -998, -2122, -3300, -4533, -5818, -7154, -8540,
- -9975,-11455,-12980,-14548,-16155,-17799,-19478,-21189,
--22929,-24694,-26482,-28289,-30112,-31947,-33791,-35640,
--37489,-39336,-41176,-43006,-44821,-46617,-48390,-50137,
--51853,-53534,-55178,-56778,-58333,-59838,-61289,-62684,
--64019,-65290,-66494,-67629,-68692,-69679,-70590,-71420,
--72169,-72835,-73415,-73908,-74313,-74630,-74856,-74992,
- 75038,
-};
-
-/*******************************************************/
-/* layer 2 tables */
-
-const int ff_mpa_sblimit_table[5] = { 27 , 30 , 8, 12 , 30 };
-
-const int ff_mpa_quant_steps[17] = {
-    3,     5,    7,    9,    15,
-    31,    63,  127,  255,   511,
-    1023,  2047, 4095, 8191, 16383,
-    32767, 65535
-};
-
-/* we use a negative value if grouped */
-const int ff_mpa_quant_bits[17] = {
-    -5,  -7,  3, -10, 4,
-     5,  6,  7,  8,  9,
-    10, 11, 12, 13, 14,
-    15, 16
-};
-
-/* encoding tables which give the quantization index. Note how it is
-   possible to store them efficiently ! */
-static const unsigned char alloc_table_1[] = {
- 4,  0,  2,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
- 4,  0,  2,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
- 4,  0,  2,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
- 4,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 16,
- 4,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 16,
- 4,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 16,
- 4,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 16,
- 4,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 16,
- 4,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 16,
- 4,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 16,
- 4,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 16,
- 3,  0,  1,  2,  3,  4,  5, 16,
- 3,  0,  1,  2,  3,  4,  5, 16,
- 3,  0,  1,  2,  3,  4,  5, 16,
- 3,  0,  1,  2,  3,  4,  5, 16,
- 3,  0,  1,  2,  3,  4,  5, 16,
- 3,  0,  1,  2,  3,  4,  5, 16,
- 3,  0,  1,  2,  3,  4,  5, 16,
- 3,  0,  1,  2,  3,  4,  5, 16,
- 3,  0,  1,  2,  3,  4,  5, 16,
- 3,  0,  1,  2,  3,  4,  5, 16,
- 3,  0,  1,  2,  3,  4,  5, 16,
- 3,  0,  1,  2,  3,  4,  5, 16,
- 2,  0,  1, 16,
- 2,  0,  1, 16,
- 2,  0,  1, 16,
- 2,  0,  1, 16,
- 2,  0,  1, 16,
- 2,  0,  1, 16,
- 2,  0,  1, 16,
-};
-
-static const unsigned char alloc_table_3[] = {
- 4,  0,  1,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
- 4,  0,  1,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
- 3,  0,  1,  3,  4,  5,  6,  7,
- 3,  0,  1,  3,  4,  5,  6,  7,
- 3,  0,  1,  3,  4,  5,  6,  7,
- 3,  0,  1,  3,  4,  5,  6,  7,
- 3,  0,  1,  3,  4,  5,  6,  7,
- 3,  0,  1,  3,  4,  5,  6,  7,
- 3,  0,  1,  3,  4,  5,  6,  7,
- 3,  0,  1,  3,  4,  5,  6,  7,
- 3,  0,  1,  3,  4,  5,  6,  7,
- 3,  0,  1,  3,  4,  5,  6,  7,
-};
-
-static const unsigned char alloc_table_4[] = {
- 4,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
- 4,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
- 4,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
- 4,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
- 3,  0,  1,  3,  4,  5,  6,  7,
- 3,  0,  1,  3,  4,  5,  6,  7,
- 3,  0,  1,  3,  4,  5,  6,  7,
- 3,  0,  1,  3,  4,  5,  6,  7,
- 3,  0,  1,  3,  4,  5,  6,  7,
- 3,  0,  1,  3,  4,  5,  6,  7,
- 3,  0,  1,  3,  4,  5,  6,  7,
- 2,  0,  1,  3,
- 2,  0,  1,  3,
- 2,  0,  1,  3,
- 2,  0,  1,  3,
- 2,  0,  1,  3,
- 2,  0,  1,  3,
- 2,  0,  1,  3,
- 2,  0,  1,  3,
- 2,  0,  1,  3,
- 2,  0,  1,  3,
- 2,  0,  1,  3,
- 2,  0,  1,  3,
- 2,  0,  1,  3,
- 2,  0,  1,  3,
- 2,  0,  1,  3,
- 2,  0,  1,  3,
- 2,  0,  1,  3,
- 2,  0,  1,  3,
- 2,  0,  1,  3,
-};
-
-const unsigned char * const ff_mpa_alloc_tables[5] =
-{ alloc_table_1, alloc_table_1, alloc_table_3, alloc_table_3, alloc_table_4, };
-
-#endif

makemkv-oss-1.8.5.tar.gz/libffcodec/src/mpegaudiodata.h Deleted

@@ -1,43 +0,0 @@
-/*
- * MPEG Audio common tables
- * copyright (c) 2002 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
- */
-
-/**
- * @file
- * mpeg audio layer common tables.
- */
-
-#ifndef AVCODEC_MPEGAUDIODATA_H
-#define AVCODEC_MPEGAUDIODATA_H
-
-#include <stdint.h>
-
-#define MODE_EXT_MS_STEREO 2
-#define MODE_EXT_I_STEREO  1
-
-extern const uint16_t avpriv_mpa_bitrate_tab[2][3][15];
-extern const uint16_t avpriv_mpa_freq_tab[3];
-extern const int32_t ff_mpa_enwindow[257];
-extern const int ff_mpa_sblimit_table[5];
-extern const int ff_mpa_quant_steps[17];
-extern const int ff_mpa_quant_bits[17];
-extern const unsigned char * const ff_mpa_alloc_tables[5];
-
-#endif /* AVCODEC_MPEGAUDIODATA_H */

makemkv-oss-1.8.5.tar.gz/libffcodec/src/mpegaudiodecheader.c Deleted

@@ -1,149 +0,0 @@
-/*
- * MPEG Audio header decoder
- * Copyright (c) 2001, 2002 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
- */
-
-/**
- * @file
- * MPEG Audio header decoder.
- */
-
-//#define DEBUG
-#include "misc.h"
-#include "mpegaudio.h"
-#include "mpegaudiodata.h"
-#include "mpegaudiodecheader.h"
-
-
-int avpriv_mpegaudio_decode_header(MPADecodeHeader *s, uint32_t header)
-{
-    int sample_rate, frame_size, mpeg25, padding;
-    int sample_rate_index, bitrate_index;
-    if (header & (1<<20)) {
-        s->lsf = (header & (1<<19)) ? 0 : 1;
-        mpeg25 = 0;
-    } else {
-        s->lsf = 1;
-        mpeg25 = 1;
-    }
-
-    s->layer = 4 - ((header >> 17) & 3);
-    /* extract frequency */
-    sample_rate_index = (header >> 10) & 3;
-    sample_rate = avpriv_mpa_freq_tab[sample_rate_index] >> (s->lsf + mpeg25);
-    sample_rate_index += 3 * (s->lsf + mpeg25);
-    s->sample_rate_index = sample_rate_index;
-    s->error_protection = ((header >> 16) & 1) ^ 1;
-    s->sample_rate = sample_rate;
-
-    bitrate_index = (header >> 12) & 0xf;
-    padding = (header >> 9) & 1;
-    //extension = (header >> 8) & 1;
-    s->mode = (header >> 6) & 3;
-    s->mode_ext = (header >> 4) & 3;
-    //copyright = (header >> 3) & 1;
-    //original = (header >> 2) & 1;
-    //emphasis = header & 3;
-
-    if (s->mode == MPA_MONO)
-        s->nb_channels = 1;
-    else
-        s->nb_channels = 2;
-
-    if (bitrate_index != 0) {
-        frame_size = avpriv_mpa_bitrate_tab[s->lsf][s->layer - 1][bitrate_index];
-        s->bit_rate = frame_size * 1000;
-        switch(s->layer) {
-        case 1:
-            frame_size = (frame_size * 12000) / sample_rate;
-            frame_size = (frame_size + padding) * 4;
-            break;
-        case 2:
-            frame_size = (frame_size * 144000) / sample_rate;
-            frame_size += padding;
-            break;
-        default:
-        case 3:
-            frame_size = (frame_size * 144000) / (sample_rate << s->lsf);
-            frame_size += padding;
-            break;
-        }
-        s->frame_size = frame_size;
-    } else {
-        /* if no frame size computed, signal it */
-        return 1;
-    }
-
-#if defined(DEBUG)
-    av_dlog(NULL, "layer%d, %d Hz, %d kbits/s, ",
-           s->layer, s->sample_rate, s->bit_rate);
-    if (s->nb_channels == 2) {
-        if (s->layer == 3) {
-            if (s->mode_ext & MODE_EXT_MS_STEREO)
-                av_dlog(NULL, "ms-");
-            if (s->mode_ext & MODE_EXT_I_STEREO)
-                av_dlog(NULL, "i-");
-        }
-        av_dlog(NULL, "stereo");
-    } else {
-        av_dlog(NULL, "mono");
-    }
-    av_dlog(NULL, "\n");
-#endif
-    return 0;
-}
-
-#if 0
-int avpriv_mpa_decode_header(AVCodecContext *avctx, uint32_t head, int *sample_rate, int *channels, int *frame_size, int *bit_rate)
-{
-    MPADecodeHeader s1, *s = &s1;
-
-    if (ff_mpa_check_header(head) != 0)
-        return -1;
-
-    if (avpriv_mpegaudio_decode_header(s, head) != 0) {
-        return -1;
-    }
-
-    switch(s->layer) {
-    case 1:
-        avctx->codec_id = CODEC_ID_MP1;
-        *frame_size = 384;
-        break;
-    case 2:
-        avctx->codec_id = CODEC_ID_MP2;
-        *frame_size = 1152;
-        break;
-    default:
-    case 3:
-        avctx->codec_id = CODEC_ID_MP3;
-        if (s->lsf)
-            *frame_size = 576;
-        else
-            *frame_size = 1152;
-        break;
-    }
-
-    *sample_rate = s->sample_rate;
-    *channels = s->nb_channels;
-    *bit_rate = s->bit_rate;
-    avctx->sub_id = s->layer;
-    return s->frame_size;
-}
-#endif

makemkv-oss-1.8.5.tar.gz/libffcodec/src/mpegaudiodecheader.h Deleted

@@ -1,76 +0,0 @@
-/*
- * MPEG Audio header decoder
- * Copyright (c) 2001, 2002 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
- */
-
-/**
- * @file
- * MPEG Audio header decoder.
- */
-
-#ifndef AVCODEC_MPEGAUDIODECHEADER_H
-#define AVCODEC_MPEGAUDIODECHEADER_H
-
-#include "misc.h"
-
-#define MP3_MASK 0xFFFE0CCF
-
-#define MPA_DECODE_HEADER \
-    int frame_size; \
-    int error_protection; \
-    int layer; \
-    int sample_rate; \
-    int sample_rate_index; /* between 0 and 8 */ \
-    int bit_rate; \
-    int nb_channels; \
-    int mode; \
-    int mode_ext; \
-    int lsf;
-
-typedef struct MPADecodeHeader {
-  MPA_DECODE_HEADER
-} MPADecodeHeader;
-
-/* header decoding. MUST check the header before because no
-   consistency check is done there. Return 1 if free format found and
-   that the frame size must be computed externally */
-int avpriv_mpegaudio_decode_header(MPADecodeHeader *s, uint32_t header);
-
-/* useful helper to get mpeg audio stream infos. Return -1 if error in
-   header, otherwise the coded frame size in bytes */
-//int avpriv_mpa_decode_header(AVCodecContext *avctx, uint32_t head, int *sample_rate, int *channels, int *frame_size, int *bitrate);
-
-/* fast header check for resync */
-static inline int ff_mpa_check_header(uint32_t header){
-    /* header */
-    if ((header & 0xffe00000) != 0xffe00000)
-        return -1;
-    /* layer check */
-    if ((header & (3<<17)) == 0)
-        return -1;
-    /* bit rate */
-    if ((header & (0xf<<12)) == 0xf<<12)
-        return -1;
-    /* frequency */
-    if ((header & (3<<10)) == 3<<10)
-        return -1;
-    return 0;
-}
-
-#endif /* AVCODEC_MPEGAUDIODECHEADER_H */

makemkv-oss-1.8.5.tar.gz/libffcodec/src/mpegaudiomisc.h Deleted

@@ -1,35 +0,0 @@
-/*
- * MPEG Audio parser
- * 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 FFCODEC_MPEGAUDIOMISC_H
-#define FFCODEC_MPEGAUDIOMISC_H
-
-#include <stdint.h>
-
-#define MPA_HEADER_SIZE 4
-
-/* header + layer + bitrate + freq + lsf/mpeg25 */
-#define SAME_HEADER_MASK \
-   (0xffe00000 | (3 << 17) | (3 << 10) | (3 << 19))
-
-
-#endif /* FFCODEC_MPEGAUDIOMISC_H */
-

makemkv-oss-1.8.6.tar.gz/libffabi Added

makemkv-oss-1.8.6.tar.gz/libffabi/inc Added

makemkv-oss-1.8.6.tar.gz/libffabi/inc/lgpl Added

makemkv-oss-1.8.6.tar.gz/libffabi/inc/lgpl/ffabi.h Added

@@ -0,0 +1,130 @@
+/*
+    libMakeMKV - MKV multiplexer library
+
+    Copyright (C) 2007-2013 GuinpinSoft inc <libmkv@makemkv.com>
+
+    This library 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.
+
+    This library 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 this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+*/
+#ifndef LGPL_FFABI_H_INCLUDED
+#define LGPL_FFABI_H_INCLUDED
+
+#include <stddef.h>
+#include <stdint.h>
+
+#if !defined(_MSC_VER) && !defined(__cdecl)
+#define __cdecl
+#endif
+
+typedef enum _FFM_CodecID {
+    FFM_CODEC_ID_AC3        = 0x15003,
+    FFM_CODEC_ID_DTS        = 0x15004,
+    FFM_CODEC_ID_FLAC       = 0x1500e,
+    FFM_CODEC_ID_MLP        = 0x1501f,
+    FFM_CODEC_ID_EAC3       = 0x1502b,
+    FFM_CODEC_ID_TRUEHD     = 0x1502f,
+    FFM_CODEC_ID_MAX_VALUE
+} FFM_CodecID;
+
+#define FFM_INPUT_BUFFER_PADDING_SIZE 16
+
+typedef enum _FFM_AudioFormat {
+    FFM_AUDIO_FMT_UNKNOWN,
+    FFM_AUDIO_FMT_PCM_U8,
+    FFM_AUDIO_FMT_PCM_S16,
+    FFM_AUDIO_FMT_PCM_S32,
+    FFM_AUDIO_FMT_PCM_FLT,
+    FFM_AUDIO_FMT_PCM_DBL,
+    FFM_AUDIO_FMT_PCM_U8P,
+    FFM_AUDIO_FMT_PCM_S16P,
+    FFM_AUDIO_FMT_PCM_S32P,
+    FFM_AUDIO_FMT_PCM_FLTP,
+    FFM_AUDIO_FMT_PCM_DBLP,
+    FFM_AUDIO_FMT_PCM_S24,
+    FFM_AUDIO_FMT_MAX_VALUE
+} FFM_AudioFormat;
+
+#ifdef _MSC_VER
+#define ALIGN_PACKED
+#pragma pack(1)
+#endif
+
+#ifdef __GNUC__
+#define ALIGN_PACKED __attribute((packed))
+#endif
+
+typedef struct _FFM_AudioInfo {
+    uint32_t    sample_rate;
+    uint32_t    channels;
+    uint32_t    bits_per_sample;
+    uint32_t    frame_size;
+    uint64_t    channel_layout;
+} ALIGN_PACKED FFM_AudioInfo;
+
+
+#ifdef _MSC_VER
+#pragma pack()
+#endif
+
+struct _FFM_AudioDecodeContext;
+typedef struct _FFM_AudioDecodeContext FFM_AudioDecodeContext;
+
+struct _FFM_AudioEncodeContext;
+typedef struct _FFM_AudioEncodeContext FFM_AudioEncodeContext;
+
+struct _FFM_AudioConvert;
+typedef struct _FFM_AudioConvert FFM_AudioConvert;
+
+typedef void  (__cdecl *ffm_log_callback_t)(void* ctx,void* ctx2,int level,char* text);
+typedef void* (__cdecl *ffm_memalign_t)(uintptr_t align, uintptr_t size);
+typedef void* (__cdecl *ffm_realloc_t)(void *ptr, uintptr_t size);
+typedef void  (__cdecl *ffm_free_t)(void *ptr);
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int __cdecl ffm_init(ffm_log_callback_t log_proc,void* log_context,ffm_memalign_t memalign_proc,ffm_realloc_t realloc_proc,ffm_free_t free_proc);
+uint32_t __cdecl ffm_avcodec_version(void);
+
+FFM_AudioDecodeContext* __cdecl ffm_audio_decode_init(void* logctx,FFM_CodecID id,FFM_AudioFormat fmt,const char* argp[],const uint8_t* CodecData,unsigned int CodecDataSize,unsigned int time_base);
+int __cdecl ffm_audio_decode_close(FFM_AudioDecodeContext* ctx);
+int __cdecl ffm_audio_decode_put_data(FFM_AudioDecodeContext* ctx,const uint8_t* data,unsigned int size,int64_t pts);
+unsigned int __cdecl ffm_audio_decode_get_frame(FFM_AudioDecodeContext* ctx,int64_t* pts,const uint8_t* data[]);
+int __cdecl ffm_audio_decode_get_info(FFM_AudioDecodeContext* ctx,FFM_AudioInfo* info);
+
+FFM_AudioEncodeContext* __cdecl ffm_audio_encode_init(void* logctx,FFM_CodecID id,FFM_AudioFormat fmt,FFM_AudioInfo* info,const char* argp[],unsigned int time_base);
+int __cdecl ffm_audio_encode_close(FFM_AudioEncodeContext* ctx);
+int __cdecl ffm_audio_encode_put_frame(FFM_AudioEncodeContext* ctx,const uint8_t* frame_data[],unsigned int frame_size,unsigned int nb_samples,uint64_t pts);
+const uint8_t* __cdecl ffm_audio_encode_get_data(FFM_AudioEncodeContext* ctx,unsigned int *size,int64_t *pts);
+const uint8_t* __cdecl ffm_audio_encode_get_info(FFM_AudioEncodeContext* ctx,unsigned int *size);
+
+int __cdecl ffm_audio_check_codec_format(FFM_CodecID id,FFM_AudioFormat fmt,int encode);
+
+FFM_AudioConvert* __cdecl ffm_audio_convert_alloc(FFM_AudioFormat out_fmt,FFM_AudioFormat in_fmt,int channels);
+void __cdecl ffm_audio_convert_free(FFM_AudioConvert **ac);
+void __cdecl ffm_audio_convert(FFM_AudioConvert *ac, uint8_t *data_out[], const uint8_t* data_in[], int nb_samples);
+
+int __cdecl ffm_mlp_read_syncframe(const uint8_t* data,unsigned int size,FFM_AudioInfo* info,uint32_t* bitrate);
+uint16_t __cdecl ffm_mlp_checksum16(const uint8_t *buf, unsigned int buf_size);
+
+int __cdecl ffm_mpa_decode_header(uint32_t hdr,FFM_AudioInfo* info,uint32_t* layer,uint32_t* frame_size,uint32_t* bitrate);
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif // LGPL_FFABI_H_INCLUDED
+

makemkv-oss-1.8.6.tar.gz/libffabi/src Added

makemkv-oss-1.8.6.tar.gz/libffabi/src/audio_convert.c Added

@@ -0,0 +1,535 @@
+/*
+ * Copyright (c) 2006 Michael Niedermayer <michaelni@gmx.at>
+ * Copyright (c) 2012 Justin Ruggles <justin.ruggles@gmail.com>
+ *
+ * This file is part of Libav.
+ *
+ * Libav 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.
+ *
+ * Libav 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 Libav; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <stdint.h>
+#include <lgpl/ffabi.h>
+
+//#include "config.h"
+#include <libavutil/common.h>
+//#include "libavutil/libm.h"
+//#include "libavutil/log.h"
+//#include "libavutil/mem.h"
+//#include <libavutil/samplefmt.h>
+//#include "audio_convert.h"
+//#include "audio_data.h"
+//#include "dither.h"
+#include "internal.h"
+
+
+enum ConvFuncType {
+    CONV_FUNC_TYPE_FLAT,
+    CONV_FUNC_TYPE_INTERLEAVE,
+    CONV_FUNC_TYPE_DEINTERLEAVE,
+};
+
+typedef void (conv_func_flat)(uint8_t *out, const uint8_t *in, int len);
+
+typedef void (conv_func_interleave)(uint8_t *out, const uint8_t *const *in,
+                                    int len, int channels);
+
+typedef void (conv_func_deinterleave)(uint8_t **out, const uint8_t *in, int len,
+                                      int channels);
+
+struct _FFM_AudioConvert {
+    //AVAudioResampleContext *avr;
+    //DitherContext *dc;
+    enum AVSampleFormat in_fmt;
+    enum AVSampleFormat out_fmt;
+    //int apply_map;
+    int channels;
+    int planes;
+    int in_planar;
+    //int ptr_align;
+    //int samples_align;
+    //int has_optimized_func;
+    //const char *func_descr;
+    //const char *func_descr_generic;
+    enum ConvFuncType func_type;
+    conv_func_flat         *conv_flat;
+    //conv_func_flat         *conv_flat_generic;
+    conv_func_interleave   *conv_interleave;
+    //conv_func_interleave   *conv_interleave_generic;
+    conv_func_deinterleave *conv_deinterleave;
+    //conv_func_deinterleave *conv_deinterleave_generic;
+};
+
+static inline enum AVSampleFormat ac_get_packed_sample_fmt(enum AVSampleFormat fmt)
+{
+    if (fmt == AV_SAMPLE_FMT_S24) return AV_SAMPLE_FMT_S24;
+
+#if (LIBAVCODEC_VERSION_MAJOR == 53)
+    if ( (fmt>=AV_SAMPLE_FMT_U8P) && (fmt<=AV_SAMPLE_FMT_DBLP) ) {
+        return (fmt-5);
+    }
+    return fmt;
+#else
+    return av_get_packed_sample_fmt(fmt);
+#endif
+}
+
+static void ff_audio_convert_set_func(FFM_AudioConvert *ac, enum AVSampleFormat out_fmt,
+                               enum AVSampleFormat in_fmt, int channels,
+                               int ptr_align, int samples_align,
+                               const char *descr, void *conv)
+{
+    //int found = 0;
+
+    switch (ac->func_type) {
+    case CONV_FUNC_TYPE_FLAT:
+        if (ac_get_packed_sample_fmt(ac->in_fmt)  == in_fmt &&
+            ac_get_packed_sample_fmt(ac->out_fmt) == out_fmt) {
+            ac->conv_flat     = conv;
+            /*ac->func_descr    = descr;
+            ac->ptr_align     = ptr_align;
+            ac->samples_align = samples_align;
+            if (ptr_align == 1 && samples_align == 1) {
+                ac->conv_flat_generic  = conv;
+                ac->func_descr_generic = descr;
+            } else {
+                ac->has_optimized_func = 1;
+            }
+            found = 1;*/
+        }
+        break;
+    case CONV_FUNC_TYPE_INTERLEAVE:
+        if (ac->in_fmt == in_fmt && ac->out_fmt == out_fmt &&
+            (!channels || ac->channels == channels)) {
+            ac->conv_interleave = conv;
+            /*ac->func_descr      = descr;
+            ac->ptr_align       = ptr_align;
+            ac->samples_align   = samples_align;
+            if (ptr_align == 1 && samples_align == 1) {
+                ac->conv_interleave_generic = conv;
+                ac->func_descr_generic      = descr;
+            } else {
+                ac->has_optimized_func = 1;
+            }
+            found = 1;*/
+        }
+        break;
+    case CONV_FUNC_TYPE_DEINTERLEAVE:
+        if (ac->in_fmt == in_fmt && ac->out_fmt == out_fmt &&
+            (!channels || ac->channels == channels)) {
+            ac->conv_deinterleave = conv;
+            /*ac->func_descr        = descr;
+            ac->ptr_align         = ptr_align;
+            ac->samples_align     = samples_align;
+            if (ptr_align == 1 && samples_align == 1) {
+                ac->conv_deinterleave_generic = conv;
+                ac->func_descr_generic        = descr;
+            } else {
+                ac->has_optimized_func = 1;
+            }
+            found = 1;*/
+        }
+        break;
+    }
+    /*if (found) {
+        av_log(ac->avr, AV_LOG_DEBUG, "audio_convert: found function: %-4s "
+               "to %-4s (%s)\n", av_get_sample_fmt_name(ac->in_fmt),
+               av_get_sample_fmt_name(ac->out_fmt), descr);
+    }*/
+}
+
+//        *(otype *)po = expr;                                                
+
+
+#define ac_sizeof(type) AC_SIZE_OF_##type
+
+#define AC_SIZE_OF_uint8_t              1
+#define AC_SIZE_OF_int16_t              2
+#define AC_SIZE_OF_act24_t              3
+#define AC_SIZE_OF_int32_t              4
+#define AC_SIZE_OF_float                sizeof(float)
+#define AC_SIZE_OF_double               sizeof(double)
+
+static av_always_inline void ac_put_uint8_t(uint8_t* dst,uint8_t value)
+{
+    *dst = value;
+}
+
+static av_always_inline void ac_put_int16_t(uint8_t* dst,int16_t value)
+{
+    *(int16_t*)dst = value;
+}
+
+static av_always_inline void ac_put_int32_t(uint8_t* dst,int32_t value)
+{
+    *(int32_t*)dst = value;
+}
+
+static av_always_inline void ac_put_float(uint8_t* dst,float value)
+{
+    *(float*)dst = value;
+}
+
+static av_always_inline void ac_put_double(uint8_t* dst,double value)
+{
+    *(double*)dst = value;
+}
+
+static av_always_inline void ac_put_act24_t(uint8_t* dst,int32_t value)
+{
+    dst[0] = (uint32_t)(value>>8);
+    dst[1] = (uint32_t)(value>>16);
+    dst[2] = (uint32_t)(value>>24);
+}
+
+static av_always_inline int32_t ac_get_act24(const uint8_t* src)
+{
+    int32_t value;
+
+    value  = ((int32_t)(src[0])) << 8;
+    value |= ((int32_t)(src[1])) << 16;
+    value |= ((int32_t)(src[2])) << 24;
+
+    return value;
+}
+
+#define CONV_FUNC_NAME(dst_fmt, src_fmt) conv_ ## src_fmt ## _to_ ## dst_fmt
+
+#define CONV_LOOP(otype, expr)                                              \
+    do {                                                                    \
+        ac_put_##otype (po,(expr));                                         \
+        pi += is;                                                           \
+        po += os;                                                           \
+    } while (po < end);                                                     \
+
+#define CONV_FUNC_FLAT(ofmt, otype, ifmt, itype, expr)                      \
+static void CONV_FUNC_NAME(ofmt, ifmt)(uint8_t *out, const uint8_t *in,     \
+                                       int len)                             \
+{                                                                           \
+    int is       = ac_sizeof(itype);                                        \
+    int os       = ac_sizeof(otype);                                        \
+    const uint8_t *pi = in;                                                 \
+    uint8_t       *po = out;                                                \
+    uint8_t *end = out + os * len;                                          \
+    CONV_LOOP(otype, expr)                                                  \
+}
+
+#define CONV_FUNC_INTERLEAVE(ofmt, otype, ifmt, itype, expr)                \
+static void CONV_FUNC_NAME(ofmt, ifmt)(uint8_t *out, const uint8_t **in,    \
+                                       int len, int channels)               \
+{                                                                           \
+    int ch;                                                                 \
+    int out_bps = ac_sizeof(otype);                                         \
+    int is      = ac_sizeof(itype);                                         \
+    int os      = channels * out_bps;                                       \
+    for (ch = 0; ch < channels; ch++) {                                     \
+        const uint8_t *pi = in[ch];                                         \
+        uint8_t       *po = out + ch * out_bps;                             \
+        uint8_t      *end = po + os * len;                                  \
+        CONV_LOOP(otype, expr)                                              \
+    }                                                                       \
+}
+
+#define CONV_FUNC_DEINTERLEAVE(ofmt, otype, ifmt, itype, expr)              \
+static void CONV_FUNC_NAME(ofmt, ifmt)(uint8_t **out, const uint8_t *in,    \
+                                       int len, int channels)               \
+{                                                                           \
+    int ch;                                                                 \
+    int in_bps = ac_sizeof(itype);                                          \
+    int is     = channels * in_bps;                                         \
+    int os     = ac_sizeof(otype);                                          \
+    for (ch = 0; ch < channels; ch++) {                                     \
+        const uint8_t *pi = in  + ch * in_bps;                              \
+        uint8_t       *po = out[ch];                                        \
+        uint8_t      *end = po + os * len;                                  \
+        CONV_LOOP(otype, expr)                                              \
+    }                                                                       \
+}
+
+#define CONV_FUNC_GROUP_ALL(ofmt, otype, ifmt, itype, expr) \
+CONV_FUNC_FLAT(        ofmt,      otype, ifmt,      itype, expr) \
+CONV_FUNC_INTERLEAVE(  ofmt,      otype, ifmt ## P, itype, expr) \
+CONV_FUNC_DEINTERLEAVE(ofmt ## P, otype, ifmt,      itype, expr)
+
+#define CONV_FUNC_GROUP_ID(ofmt, otype, ifmt, itype, expr) \
+CONV_FUNC_INTERLEAVE(  ofmt,      otype, ifmt ## P, itype, expr) \
+CONV_FUNC_DEINTERLEAVE(ofmt ## P, otype, ifmt,      itype, expr)
+
+#define CONV_FUNC_GROUP_FI(ofmt, otype, ifmt, itype, expr) \
+CONV_FUNC_FLAT(        ofmt,      otype, ifmt,      itype, expr) \
+CONV_FUNC_INTERLEAVE(  ofmt,      otype, ifmt ## P, itype, expr) \
+
+#define CONV_FUNC_GROUP_FD(ofmt, otype, ifmt, itype, expr) \
+CONV_FUNC_FLAT(        ofmt,      otype, ifmt,      itype, expr) \
+CONV_FUNC_DEINTERLEAVE(ofmt ## P, otype, ifmt,      itype, expr)
+
+CONV_FUNC_GROUP_ID (AV_SAMPLE_FMT_U8,  uint8_t, AV_SAMPLE_FMT_U8,  uint8_t,  *(const uint8_t *)pi)
+CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_U8,  uint8_t, (*(const uint8_t *)pi - 0x80) <<  8)
+CONV_FUNC_GROUP_FI (AV_SAMPLE_FMT_S24, act24_t, AV_SAMPLE_FMT_U8,  uint8_t, (*(const uint8_t *)pi - 0x80) << 24)
+CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_U8,  uint8_t, (*(const uint8_t *)pi - 0x80) << 24)
+CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_FLT, float,   AV_SAMPLE_FMT_U8,  uint8_t, (*(const uint8_t *)pi - 0x80) * (1.0f / (1 << 7)))
+CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_DBL, double,  AV_SAMPLE_FMT_U8,  uint8_t, (*(const uint8_t *)pi - 0x80) * (1.0  / (1 << 7)))
+CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_U8,  uint8_t, AV_SAMPLE_FMT_S16, int16_t, (*(const int16_t *)pi >> 8) + 0x80)
+CONV_FUNC_GROUP_ID (AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_S16, int16_t,  *(const int16_t *)pi)
+CONV_FUNC_GROUP_FI (AV_SAMPLE_FMT_S24, act24_t, AV_SAMPLE_FMT_S16, int16_t,  *(const int16_t *)pi << 16)
+CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_S16, int16_t,  *(const int16_t *)pi << 16)
+CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_FLT, float,   AV_SAMPLE_FMT_S16, int16_t,  *(const int16_t *)pi * (1.0f / (1 << 15)))
+CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_DBL, double,  AV_SAMPLE_FMT_S16, int16_t,  *(const int16_t *)pi * (1.0  / (1 << 15)))
+CONV_FUNC_GROUP_FD (AV_SAMPLE_FMT_U8,  uint8_t, AV_SAMPLE_FMT_S24, act24_t, (ac_get_act24(pi) >> 24) + 0x80)
+CONV_FUNC_GROUP_FD (AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_S24, act24_t,  ac_get_act24(pi) >> 16)
+CONV_FUNC_GROUP_FD (AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_S24, act24_t,  ac_get_act24(pi))
+CONV_FUNC_GROUP_FD (AV_SAMPLE_FMT_FLT, float,   AV_SAMPLE_FMT_S24, act24_t,  ac_get_act24(pi) * (1.0f / (1U << 31)))
+CONV_FUNC_GROUP_FD (AV_SAMPLE_FMT_DBL, double,  AV_SAMPLE_FMT_S24, act24_t,  ac_get_act24(pi) * (1.0  / (1U << 31)))
+CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_U8,  uint8_t, AV_SAMPLE_FMT_S32, int32_t, (*(const int32_t *)pi >> 24) + 0x80)
+CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_S32, int32_t,  *(const int32_t *)pi >> 16)
+CONV_FUNC_GROUP_FI (AV_SAMPLE_FMT_S24, act24_t, AV_SAMPLE_FMT_S32, int32_t,  *(const int32_t *)pi)
+CONV_FUNC_GROUP_ID (AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_S32, int32_t,  *(const int32_t *)pi)
+CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_FLT, float,   AV_SAMPLE_FMT_S32, int32_t,  *(const int32_t *)pi * (1.0f / (1U << 31)))
+CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_DBL, double,  AV_SAMPLE_FMT_S32, int32_t,  *(const int32_t *)pi * (1.0  / (1U << 31)))
+CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_U8,  uint8_t, AV_SAMPLE_FMT_FLT, float,   av_clip_uint8(  lrintf(*(const float *)pi * (1  <<  7)) + 0x80))
+CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float,   av_clip_int16(  lrintf(*(const float *)pi * (1  << 15))))
+CONV_FUNC_GROUP_FI (AV_SAMPLE_FMT_S24, act24_t, AV_SAMPLE_FMT_FLT, float,   av_clipl_int32(llrintf(*(const float *)pi * (1U << 31))))
+CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float,   av_clipl_int32(llrintf(*(const float *)pi * (1U << 31))))
+CONV_FUNC_GROUP_ID (AV_SAMPLE_FMT_FLT, float,   AV_SAMPLE_FMT_FLT, float,   *(const float *)pi)
+CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_DBL, double,  AV_SAMPLE_FMT_FLT, float,   *(const float *)pi)
+CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_U8,  uint8_t, AV_SAMPLE_FMT_DBL, double,  av_clip_uint8(  lrint(*(const double *)pi * (1  <<  7)) + 0x80))
+CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double,  av_clip_int16(  lrint(*(const double *)pi * (1  << 15))))
+CONV_FUNC_GROUP_FI (AV_SAMPLE_FMT_S24, act24_t, AV_SAMPLE_FMT_DBL, double,  av_clipl_int32(llrint(*(const double *)pi * (1U << 31))))
+CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double,  av_clipl_int32(llrint(*(const double *)pi * (1U << 31))))
+CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_FLT, float,   AV_SAMPLE_FMT_DBL, double,  *(const double *)pi)
+CONV_FUNC_GROUP_ID (AV_SAMPLE_FMT_DBL, double,  AV_SAMPLE_FMT_DBL, double,  *(const double *)pi)
+
+#define SET_CONV_FUNC_GROUP_ALL(ofmt, ifmt)                                                         \
+ff_audio_convert_set_func(ac, ofmt,      ifmt,      0, 1, 1, "C", CONV_FUNC_NAME(ofmt,      ifmt)); \
+ff_audio_convert_set_func(ac, ofmt ## P, ifmt,      0, 1, 1, "C", CONV_FUNC_NAME(ofmt ## P, ifmt)); \
+ff_audio_convert_set_func(ac, ofmt,      ifmt ## P, 0, 1, 1, "C", CONV_FUNC_NAME(ofmt,      ifmt ## P));
+
+#define SET_CONV_FUNC_GROUP_ID(ofmt, ifmt)                                                          \
+ff_audio_convert_set_func(ac, ofmt ## P, ifmt,      0, 1, 1, "C", CONV_FUNC_NAME(ofmt ## P, ifmt)); \
+ff_audio_convert_set_func(ac, ofmt,      ifmt ## P, 0, 1, 1, "C", CONV_FUNC_NAME(ofmt,      ifmt ## P));
+
+#define SET_CONV_FUNC_GROUP_FI(ofmt, ifmt)                                                         \
+ff_audio_convert_set_func(ac, ofmt,      ifmt,      0, 1, 1, "C", CONV_FUNC_NAME(ofmt,      ifmt)); \
+ff_audio_convert_set_func(ac, ofmt,      ifmt ## P, 0, 1, 1, "C", CONV_FUNC_NAME(ofmt,      ifmt ## P));
+
+#define SET_CONV_FUNC_GROUP_FD(ofmt, ifmt)                                                         \
+ff_audio_convert_set_func(ac, ofmt,      ifmt,      0, 1, 1, "C", CONV_FUNC_NAME(ofmt,      ifmt)); \
+ff_audio_convert_set_func(ac, ofmt ## P, ifmt,      0, 1, 1, "C", CONV_FUNC_NAME(ofmt ## P, ifmt));
+
+static void set_generic_function(FFM_AudioConvert *ac)
+{
+    SET_CONV_FUNC_GROUP_ID (AV_SAMPLE_FMT_U8,  AV_SAMPLE_FMT_U8)
+    SET_CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8)
+    SET_CONV_FUNC_GROUP_FI (AV_SAMPLE_FMT_S24, AV_SAMPLE_FMT_U8)
+    SET_CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8)
+    SET_CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8)
+    SET_CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8)
+    SET_CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_U8,  AV_SAMPLE_FMT_S16)
+    SET_CONV_FUNC_GROUP_ID (AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16)
+    SET_CONV_FUNC_GROUP_FI (AV_SAMPLE_FMT_S24, AV_SAMPLE_FMT_S16)
+    SET_CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16)
+    SET_CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16)
+    SET_CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16)
+    SET_CONV_FUNC_GROUP_FD (AV_SAMPLE_FMT_U8,  AV_SAMPLE_FMT_S24)
+    SET_CONV_FUNC_GROUP_FD (AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S24)
+    SET_CONV_FUNC_GROUP_FD (AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S24)
+    SET_CONV_FUNC_GROUP_FD (AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S24)
+    SET_CONV_FUNC_GROUP_FD (AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S24)
+    SET_CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_U8,  AV_SAMPLE_FMT_S32)
+    SET_CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32)
+    SET_CONV_FUNC_GROUP_FI (AV_SAMPLE_FMT_S24, AV_SAMPLE_FMT_S32)
+    SET_CONV_FUNC_GROUP_ID (AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32)
+    SET_CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32)
+    SET_CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32)
+    SET_CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_U8,  AV_SAMPLE_FMT_FLT)
+    SET_CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT)
+    SET_CONV_FUNC_GROUP_FI (AV_SAMPLE_FMT_S24, AV_SAMPLE_FMT_FLT)
+    SET_CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT)
+    SET_CONV_FUNC_GROUP_ID (AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT)
+    SET_CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT)
+    SET_CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_U8,  AV_SAMPLE_FMT_DBL)
+    SET_CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL)
+    SET_CONV_FUNC_GROUP_FI (AV_SAMPLE_FMT_S24, AV_SAMPLE_FMT_DBL)
+    SET_CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL)
+    SET_CONV_FUNC_GROUP_ALL(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL)
+    SET_CONV_FUNC_GROUP_ID (AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL)
+}
+
+void ffm_audio_convert_free(FFM_AudioConvert **ac)
+{
+    if (!*ac)
+        return;
+    //ff_dither_free(&(*ac)->dc);
+    av_freep(ac);
+}
+
+FFM_AudioConvert *ff_ffm_audio_convert_alloc(//AVAudioResampleContext *avr,
+                                     enum AVSampleFormat out_fmt,
+                                     enum AVSampleFormat in_fmt,
+                                     int channels)//, int sample_rate,
+                                     //int apply_map)
+{
+    FFM_AudioConvert *ac;
+    int in_planar, out_planar;
+
+    ac = av_mallocz(sizeof(*ac));
+    if (!ac)
+        return NULL;
+
+    //ac->avr      = avr;
+    ac->out_fmt  = out_fmt;
+    ac->in_fmt   = in_fmt;
+    ac->channels = channels;
+    //ac->apply_map = apply_map;
+
+    /*if (avr->dither_method != AV_RESAMPLE_DITHER_NONE          &&
+        av_get_packed_sample_fmt(out_fmt) == AV_SAMPLE_FMT_S16 &&
+        av_get_bytes_per_sample(in_fmt) > 2) {
+        ac->dc = ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate,
+                                 apply_map);
+        if (!ac->dc) {
+            av_free(ac);
+            return NULL;
+        }
+        return ac;
+    }*/
+
+    in_planar  = av_sample_fmt_is_planar(in_fmt);
+    ac->in_planar = in_planar;
+    out_planar = av_sample_fmt_is_planar(out_fmt);
+
+    if (in_planar == out_planar) {
+        ac->func_type = CONV_FUNC_TYPE_FLAT;
+        ac->planes    = in_planar ? ac->channels : 1;
+    } else if (in_planar)
+        ac->func_type = CONV_FUNC_TYPE_INTERLEAVE;
+    else
+        ac->func_type = CONV_FUNC_TYPE_DEINTERLEAVE;
+
+    set_generic_function(ac);
+
+    /*if (ARCH_ARM)
+        ff_audio_convert_init_arm(ac);
+    if (ARCH_X86)
+        ff_audio_convert_init_x86(ac);*/
+
+    return ac;
+}
+
+void ffm_audio_convert(FFM_AudioConvert *ac, uint8_t *out_data[], const uint8_t* in_data[], int nb_samples)
+{
+    //int use_generic = 1;
+    int len         = nb_samples;
+    int p;
+
+#if 0
+    if (ac->dc) {
+        /* dithered conversion */
+        av_dlog(ac->avr, "%d samples - audio_convert: %s to %s (dithered)\n",
+                len, av_get_sample_fmt_name(ac->in_fmt),
+                av_get_sample_fmt_name(ac->out_fmt));
+
+        return ff_convert_dither(ac->dc, out, in);
+    }
+
+    /* determine whether to use the optimized function based on pointer and
+       samples alignment in both the input and output */
+    if (ac->has_optimized_func) {
+        int ptr_align     = FFMIN(in->ptr_align,     out->ptr_align);
+        int samples_align = FFMIN(in->samples_align, out->samples_align);
+        int aligned_len   = FFALIGN(len, ac->samples_align);
+        if (!(ptr_align % ac->ptr_align) && samples_align >= aligned_len) {
+            len = aligned_len;
+            use_generic = 0;
+        }
+    }
+    av_dlog(ac->avr, "%d samples - audio_convert: %s to %s (%s)\n", len,
+            av_get_sample_fmt_name(ac->in_fmt),
+            av_get_sample_fmt_name(ac->out_fmt),
+            use_generic ? ac->func_descr_generic : ac->func_descr);
+
+    if (ac->apply_map) {
+        ChannelMapInfo *map = &ac->avr->ch_map_info;
+
+        if (!av_sample_fmt_is_planar(ac->out_fmt)) {
+            av_log(ac->avr, AV_LOG_ERROR, "cannot remap packed format during conversion\n");
+            return AVERROR(EINVAL);
+        }
+
+        if (map->do_remap) {
+            if (av_sample_fmt_is_planar(ac->in_fmt)) {
+                conv_func_flat *convert = use_generic ? ac->conv_flat_generic :
+                                                        ac->conv_flat;
+
+                for (p = 0; p < ac->planes; p++)
+                    if (map->channel_map[p] >= 0)
+                        convert(out->data[p], in->data[map->channel_map[p]], len);
+            } else {
+                uint8_t *data[AVRESAMPLE_MAX_CHANNELS];
+                conv_func_deinterleave *convert = use_generic ?
+                                                  ac->conv_deinterleave_generic :
+                                                  ac->conv_deinterleave;
+
+                for (p = 0; p < ac->channels; p++)
+                    data[map->input_map[p]] = out->data[p];
+
+                convert(data, in->data[0], len, ac->channels);
+            }
+        }
+        if (map->do_copy || map->do_zero) {
+            for (p = 0; p < ac->planes; p++) {
+                if (map->channel_copy[p])
+                    memcpy(out->data[p], out->data[map->channel_copy[p]],
+                           len * out->stride);
+                else if (map->channel_zero[p])
+                    av_samples_set_silence(&out->data[p], 0, len, 1, ac->out_fmt);
+            }
+        }
+    } else {
+#endif
+    {
+        switch (ac->func_type) {
+        case CONV_FUNC_TYPE_FLAT: {
+            if (!ac->in_planar)
+                len *= ac->channels;
+            /*if (use_generic) {
+                for (p = 0; p < ac->planes; p++)
+                    ac->conv_flat_generic(out->data[p], in->data[p], len);
+            } else*/ {
+                for (p = 0; p < ac->planes; p++)
+                    ac->conv_flat(out_data[p], in_data[p], len);
+            }
+            break;
+        }
+        case CONV_FUNC_TYPE_INTERLEAVE:
+            /*if (use_generic)
+                ac->conv_interleave_generic(out->data[0], in->data, len,
+                                            ac->channels);
+            else*/
+                ac->conv_interleave(out_data[0], in_data, len, ac->channels);
+            break;
+        case CONV_FUNC_TYPE_DEINTERLEAVE:
+            /*if (use_generic)
+                ac->conv_deinterleave_generic(out->data, in->data[0], len,
+                                              ac->channels);
+            else*/
+                ac->conv_deinterleave(out_data, in_data[0], len,
+                                      ac->channels);
+            break;
+        }
+    }
+
+    //out->nb_samples = in->nb_samples;
+    //return 0;
+}

makemkv-oss-1.8.6.tar.gz/libffabi/src/ffabi.c Added

@@ -0,0 +1,565 @@
+/*
+    libMakeMKV - MKV multiplexer library
+
+    Copyright (C) 2007-2013 GuinpinSoft inc <libmkv@makemkv.com>
+
+    This library 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.
+
+    This library 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 this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+*/
+#include <lgpl/ffabi.h>
+#include <libavcodec/avcodec.h>
+#include "mpegaudiodecheader.h"
+#include <libavutil/samplefmt.h>
+#include <libavutil/opt.h>
+#include <string.h>
+#include "internal.h"
+
+static int                  log_print_prefix = 1;
+static void*                log_context = NULL;
+static ffm_log_callback_t   log_callback = NULL;
+static ffm_memalign_t       proc_memalign = NULL;
+static ffm_realloc_t        proc_realloc = NULL;
+static ffm_free_t           proc_free = NULL;
+
+void *ffabi_memalign(size_t align, size_t size)
+{
+    return (*proc_memalign)(align,size);
+}
+
+void *ffabi_realloc(void *ptr, size_t size)
+{
+    return (*proc_realloc)(ptr,size);
+}
+
+void ffabi_free(void *ptr)
+{
+    (*proc_free)(ptr);
+}
+
+static void static_log_callback(void* ptr, int level, const char* fmt, va_list vl)
+{
+    char line[1024];
+    void* ctx2 = NULL;
+
+    av_log_format_line(ptr, level, fmt, vl, line, sizeof(line), &log_print_prefix);
+
+    line[sizeof(line)-1]=0;
+
+    if (ptr) {
+        struct AVClass* pclass = *((struct AVClass**)ptr);
+        if (pclass) {
+            if (!strcmp(pclass->class_name,"AVCodecContext")) {
+                ctx2 = ((AVCodecContext*)ptr)->opaque;
+            }
+        }
+    }
+
+    if (log_callback) {
+        (*log_callback)(log_context,ctx2,level,line);
+    }
+}
+
+int __cdecl ffm_init(ffm_log_callback_t log_proc,void* log_ctx,ffm_memalign_t memalign_proc,ffm_realloc_t realloc_proc,ffm_free_t free_proc)
+{
+    log_context = log_ctx;
+    log_callback = log_proc;
+    proc_memalign = memalign_proc;
+    proc_realloc = realloc_proc;
+    proc_free = free_proc;
+
+    av_log_set_callback(static_log_callback);
+    avcodec_register_all();
+
+    ffabi_ff_mlp_init_crc();
+
+    return 0;
+}
+
+uint32_t __cdecl ffm_avcodec_version(void)
+{
+    return avcodec_version();
+}
+
+static enum AVCodecID translate_codec_id(FFM_CodecID id)
+{
+    enum AVCodecID r;
+
+    switch(id) {
+    case FFM_CODEC_ID_AC3 : r = AV_CODEC_ID_AC3; break;
+    case FFM_CODEC_ID_DTS : r = AV_CODEC_ID_DTS; break;
+    case FFM_CODEC_ID_FLAC : r = AV_CODEC_ID_FLAC; break;
+    case FFM_CODEC_ID_MLP : r = AV_CODEC_ID_MLP; break;
+    case FFM_CODEC_ID_TRUEHD : r = AV_CODEC_ID_TRUEHD; break;
+    default : r=AV_CODEC_ID_NONE; break;
+    }
+    return r;
+}
+
+static enum AVSampleFormat translate_sample_fmt(FFM_AudioFormat fmt)
+{
+    enum AVSampleFormat r;
+
+    switch(fmt) {
+    case FFM_AUDIO_FMT_PCM_U8 : r = AV_SAMPLE_FMT_U8; break;
+    case FFM_AUDIO_FMT_PCM_S16: r = AV_SAMPLE_FMT_S16; break;
+    case FFM_AUDIO_FMT_PCM_S24: r = AV_SAMPLE_FMT_S24; break;
+    case FFM_AUDIO_FMT_PCM_S32: r = AV_SAMPLE_FMT_S32; break;
+    case FFM_AUDIO_FMT_PCM_FLT: r = AV_SAMPLE_FMT_FLT; break;
+    case FFM_AUDIO_FMT_PCM_DBL: r = AV_SAMPLE_FMT_DBL; break;
+    case FFM_AUDIO_FMT_PCM_U8P : r = AV_SAMPLE_FMT_U8P; break;
+    case FFM_AUDIO_FMT_PCM_S16P: r = AV_SAMPLE_FMT_S16P; break;
+    case FFM_AUDIO_FMT_PCM_S32P: r = AV_SAMPLE_FMT_S32P; break;
+    case FFM_AUDIO_FMT_PCM_FLTP: r = AV_SAMPLE_FMT_FLTP; break;
+    case FFM_AUDIO_FMT_PCM_DBLP: r = AV_SAMPLE_FMT_DBLP; break;
+    default : r = AV_SAMPLE_FMT_NONE; break;
+    }
+    return r;
+}
+
+struct _FFM_AudioDecodeContext
+{
+    AVCodec*                codec;
+    AVCodecContext*         avctx;
+    AVFrame*                frame;
+    unsigned int            nb_samples;
+    int                     have_frame;
+};
+
+FFM_AudioDecodeContext* __cdecl ffm_audio_decode_init(void* logctx,FFM_CodecID id,FFM_AudioFormat fmt,const char* argp[],const uint8_t* CodecData,unsigned int CodecDataSize,unsigned int time_base)
+{
+    AVDictionary *opts = NULL;
+    FFM_AudioDecodeContext* ctx;
+    int i;
+
+    ctx = av_mallocz(sizeof(FFM_AudioDecodeContext));
+    if (!ctx) {
+        return NULL;
+    }
+
+    ctx->codec = avcodec_find_decoder(translate_codec_id(id));
+    if (!ctx->codec) {
+        ffm_audio_decode_close(ctx);
+        return NULL;
+    }
+
+    ctx->avctx = avcodec_alloc_context3(ctx->codec);
+    if (!ctx->avctx) {
+        ffm_audio_decode_close(ctx);
+        return NULL;
+    }
+    ctx->avctx->opaque = logctx;
+    ctx->avctx->time_base.num = 1;
+    ctx->avctx->time_base.den = time_base;
+#if (LIBAVCODEC_VERSION_MAJOR >= 54)
+    ctx->avctx->refcounted_frames = 1;
+#endif
+
+    if (CodecData) {
+        ctx->avctx->extradata = (uint8_t*) CodecData;
+        ctx->avctx->extradata_size = CodecDataSize;
+    }
+
+    ctx->avctx->request_sample_fmt = translate_sample_fmt(fmt);
+
+    if (argp) {
+        for (i=0;argp[i];i+=2) {
+            av_dict_set(&opts, argp[i], argp[i+1], 0);
+        }
+    }
+
+    if (avcodec_open2(ctx->avctx,ctx->codec,&opts)) {
+        av_dict_free(&opts);
+        ffm_audio_decode_close(ctx);
+        return NULL;
+    }
+    av_dict_free(&opts);
+
+    ctx->frame = avcodec_alloc_frame();
+    if (!ctx->frame) {
+        ffm_audio_decode_close(ctx);
+        return NULL;
+    }
+
+    return ctx;
+}
+
+int __cdecl ffm_audio_decode_close(FFM_AudioDecodeContext* ctx)
+{
+    if (ctx->frame) {
+        av_frame_unref(ctx->frame);
+        avcodec_free_frame(&ctx->frame);
+    }
+
+    if (ctx->avctx) {
+        avcodec_close(ctx->avctx);
+        av_free(ctx->avctx);
+    }
+
+    av_free(ctx);
+
+    return 0;
+}
+
+static void av_cold cold(void)
+{
+}
+
+int __cdecl ffm_audio_decode_put_data(FFM_AudioDecodeContext* ctx,const uint8_t* data,unsigned int size,int64_t pts)
+{
+    int                 r=-1;
+    struct AVPacket     avpkt;
+
+    av_init_packet(&avpkt);
+    avpkt.pts = pts;
+    avpkt.dts = pts;
+    avpkt.data = (uint8_t*)data;
+    avpkt.size = size;
+
+    av_frame_unref(ctx->frame);
+    ctx->have_frame = 0;
+
+    r = avcodec_decode_audio4(ctx->avctx,ctx->frame,&ctx->have_frame,&avpkt);
+
+    if (ctx->have_frame) {
+#if (LIBAVCODEC_VERSION_MAJOR >= 54)
+        if (av_frame_get_channels(ctx->frame) != ctx->avctx->channels) { cold(); return -1; }
+        if (av_frame_get_sample_rate(ctx->frame) != ctx->avctx->sample_rate) { cold(); return -1; }
+#endif
+        if (ctx->frame->format != ctx->avctx->sample_fmt) { cold(); return -1; }
+        if (ctx->frame->format != ctx->avctx->request_sample_fmt) { cold(); return -1; }
+        if (ctx->nb_samples) {
+            if (ctx->nb_samples != ctx->frame->nb_samples) { cold(); return -1; }
+        } else {
+            cold();
+            ctx->nb_samples = ctx->frame->nb_samples;
+        }
+    } else {
+        cold();
+    }
+
+    return r;
+}
+
+unsigned int __cdecl ffm_audio_decode_get_frame(FFM_AudioDecodeContext* ctx,int64_t* pts,const uint8_t* data[])
+{
+    int i;
+
+    if (!ctx->have_frame) { cold(); return 0; }
+
+    *pts = ctx->frame->pts;
+
+    data[0]=ctx->frame->data[0];
+
+    if (av_sample_fmt_is_planar(ctx->avctx->sample_fmt)) {
+        for (i=1;i<ctx->avctx->channels;i++) {
+            data[i] = ctx->frame->data[i];
+        }
+    }
+
+    return ctx->frame->linesize[0];
+}
+
+int __cdecl ffm_audio_decode_get_info(FFM_AudioDecodeContext* ctx,FFM_AudioInfo* info)
+{
+    info->sample_rate = ctx->avctx->sample_rate;
+    info->channels = ctx->avctx->channels;
+    info->channel_layout = ctx->avctx->channel_layout;
+    info->frame_size = ctx->nb_samples;
+    info->bits_per_sample = ctx->avctx->bits_per_raw_sample;
+    return 0;
+}
+
+struct _FFM_AudioEncodeContext
+{
+    AVCodec*                codec;
+    AVCodecContext*         avctx;
+    AVFrame*                frame;
+    AVPacket                pck;
+    int                     have_packet;
+};
+
+
+FFM_AudioEncodeContext* __cdecl ffm_audio_encode_init(void* logctx,FFM_CodecID id,FFM_AudioFormat fmt,FFM_AudioInfo* info,const char* argp[],unsigned int time_base)
+{
+    AVDictionary *opts = NULL;
+    FFM_AudioEncodeContext* ctx;
+    int i;
+
+    ctx = av_mallocz(sizeof(FFM_AudioEncodeContext));
+    if (!ctx) {
+        return NULL;
+    }
+
+    av_init_packet(&ctx->pck);
+    ctx->pck.data=NULL;
+    ctx->pck.size=0;
+
+    ctx->codec = avcodec_find_encoder(translate_codec_id(id));
+    if (!ctx->codec) {
+        ffm_audio_encode_close(ctx);
+        return NULL;
+    }
+
+    ctx->avctx = avcodec_alloc_context3(ctx->codec);
+    if (!ctx->avctx) {
+        ffm_audio_encode_close(ctx);
+        return NULL;
+    }
+#if (LIBAVCODEC_VERSION_MAJOR >= 54)
+    ctx->avctx->refcounted_frames = 1;
+#endif
+    ctx->avctx->opaque = logctx;
+    ctx->avctx->time_base.num = 1;
+    ctx->avctx->time_base.den = time_base;
+
+    ctx->avctx->sample_fmt = translate_sample_fmt(fmt);
+    ctx->avctx->sample_rate = info->sample_rate;
+    ctx->avctx->channels = info->channels;
+    ctx->avctx->bits_per_raw_sample = info->bits_per_sample;
+    ctx->avctx->channel_layout = info->channel_layout;
+
+    if (argp) {
+        for (i=0;argp[i];i+=2) {
+            av_dict_set(&opts, argp[i], argp[i+1], 0);
+        }
+    }
+
+    if (avcodec_open2(ctx->avctx,ctx->codec,&opts)) {
+        av_dict_free(&opts);
+        ffm_audio_encode_close(ctx);
+        return NULL;
+    }
+    av_dict_free(&opts);
+
+    ctx->avctx->delay = 0;
+    info->frame_size = ctx->avctx->frame_size;
+
+    ctx->frame = avcodec_alloc_frame();
+    if (!ctx->frame) {
+        ffm_audio_encode_close(ctx);
+        return NULL;
+    }
+
+    return ctx;
+}
+
+int __cdecl ffm_audio_encode_close(FFM_AudioEncodeContext* ctx)
+{
+    av_free_packet(&ctx->pck);
+
+    if (ctx->frame) {
+        av_frame_unref(ctx->frame);
+        avcodec_free_frame(&ctx->frame);
+    }
+
+    if (ctx->avctx) {
+        avcodec_close(ctx->avctx);
+        av_free(ctx->avctx);
+    }
+
+    av_free(ctx);
+
+    return 0;
+}
+
+int __cdecl ffm_audio_encode_put_frame(FFM_AudioEncodeContext* ctx,const uint8_t* frame_data[],unsigned int frame_size,unsigned int nb_samples,uint64_t pts)
+{
+    AVFrame* frame;
+
+    av_free_packet(&ctx->pck);
+    av_init_packet(&ctx->pck);
+    ctx->pck.data=NULL;
+    ctx->pck.size=0;
+    ctx->have_packet = 0;
+
+    av_frame_unref(ctx->frame);
+
+    if (frame_data) {
+        frame = ctx->frame;
+        frame->format = ctx->avctx->sample_fmt;
+#if (LIBAVCODEC_VERSION_MAJOR >= 54)
+        av_frame_set_channels(frame,ctx->avctx->channels);
+        av_frame_set_channel_layout(frame,ctx->avctx->channel_layout);
+#endif
+
+        frame->data[0] = (uint8_t*)frame_data[0];
+        frame->linesize[0] = frame_size;
+
+        if (av_sample_fmt_is_planar(ctx->avctx->sample_fmt)) {
+            int i;
+            for (i=1;i<ctx->avctx->channels;i++) {
+                frame->data[i] = (uint8_t*)frame_data[i];
+            }
+        }
+
+        frame->nb_samples = nb_samples;
+        frame->pts = pts;
+    } else { cold();
+        frame = NULL;
+        if ((ctx->avctx->codec->capabilities&CODEC_CAP_DELAY)==0) {
+            return 0;
+        }
+    }
+
+    return avcodec_encode_audio2(ctx->avctx,&ctx->pck,frame,&ctx->have_packet);
+}
+
+const uint8_t* __cdecl ffm_audio_encode_get_data(FFM_AudioEncodeContext* ctx,unsigned int *size,int64_t *pts)
+{
+    if (!ctx->have_packet) { return NULL; };
+
+    *size = ctx->pck.size;
+    *pts = ctx->pck.pts;
+
+    return ctx->pck.data;
+}
+
+const uint8_t* __cdecl ffm_audio_encode_get_info(FFM_AudioEncodeContext* ctx,unsigned int *size)
+{
+    *size = ctx->avctx->extradata_size;
+    return ctx->avctx->extradata;
+}
+
+int __cdecl ffm_audio_check_codec_format(FFM_CodecID id,FFM_AudioFormat fmt,int encode)
+{
+    AVCodec* codec;
+    enum AVSampleFormat sfmt = translate_sample_fmt(fmt);
+    int i = 0;
+
+    if (encode) {
+        codec = avcodec_find_encoder(translate_codec_id(id));
+    } else {
+        codec = avcodec_find_decoder(translate_codec_id(id));
+    }
+
+    if (!codec) {
+        return -1;
+    }
+
+    if (!codec->sample_fmts) {
+        return -2;
+    }
+
+    while(codec->sample_fmts[i]>0) {
+        if (codec->sample_fmts[i++] == sfmt) return 0;
+    }
+
+    return -3;
+}
+
+FFM_AudioConvert *ffm_audio_convert_alloc(FFM_AudioFormat out_fmt,FFM_AudioFormat in_fmt,int channels)
+{
+    return ff_ffm_audio_convert_alloc(
+        translate_sample_fmt(out_fmt),
+        translate_sample_fmt(in_fmt),
+        channels);
+}
+
+int __cdecl ffm_mlp_read_syncframe(const uint8_t* data,unsigned int size,FFM_AudioInfo* info,uint32_t* bitrate)
+{
+    AVCodec*                codec;
+    AVCodecParserContext*   pctx=NULL;
+    AVCodecContext*         avctx=NULL;
+    int                     err,outbuf_size,rest;
+    uint8_t                 *outbuf;
+
+    codec = avcodec_find_decoder(AV_CODEC_ID_MLP);
+    if (!codec) {
+        err=-1; goto ret;
+    }
+
+    avctx = avcodec_alloc_context3(codec);
+    if (!avctx) {
+        err=-2; goto ret;
+    }
+
+    pctx = av_parser_init(AV_CODEC_ID_MLP);
+    if (!pctx) {
+        err=-3; goto ret;
+    }
+
+    rest = size;
+    while(rest) {
+        err = av_parser_parse2(pctx,avctx,&outbuf,&outbuf_size,
+            data,rest,0,0,0);
+        if ( (err<0) || (err>rest) ) {
+            err=-4; goto ret;
+        }
+        rest -= err;
+        data += err;
+    }
+
+    if (outbuf_size!=size) {
+        err=-5; goto ret;
+    }
+
+    info->sample_rate = avctx->sample_rate;
+    info->channels = avctx->channels;
+    info->bits_per_sample = avctx->bits_per_raw_sample;
+    info->channel_layout = avctx->channel_layout;
+    *bitrate = avctx->bit_rate;
+
+#if (LIBAVCODEC_VERSION_MAJOR < 54)
+    info->frame_size = avctx->frame_size;
+#else
+    info->frame_size = pctx->duration;
+#endif
+
+    err = 0;
+
+ret:
+    if (pctx) {
+        av_parser_close(pctx);
+    }
+
+    if (avctx) {
+        avcodec_close(avctx);
+        av_free(avctx);
+    }
+    return err;
+}
+
+int __cdecl ffm_mpa_decode_header(uint32_t hdr,FFM_AudioInfo* info,uint32_t* layer,uint32_t* frame_size,uint32_t* bitrate)
+{
+    MPADecodeHeader s;
+    AVCodecContext  a;
+    int tmp,fsize;
+
+    if (ff_mpa_check_header(hdr)) {
+        return -1;
+    }
+
+    if (avpriv_mpegaudio_decode_header(&s, hdr) != 0) {
+        cold();
+        return -1;
+    }
+
+    info->bits_per_sample = 0;
+    info->channel_layout = 0;
+
+    info->sample_rate = s.sample_rate;
+    info->channels = s.nb_channels;
+    *bitrate = s.bit_rate;
+    *frame_size = s.frame_size;
+    *layer = s.layer;
+
+    avpriv_mpa_decode_header(&a,hdr,&tmp,&tmp,&fsize,&tmp);
+
+    info->frame_size = fsize;
+
+    return 0;
+}
+
+

makemkv-oss-1.8.6.tar.gz/libffabi/src/internal.h Added

@@ -0,0 +1,51 @@
+#ifndef FFABI_INTERNAL_H
+#define FFABI_INTERNAL_H
+
+#include <libavutil/samplefmt.h>
+#include <libavcodec/avcodec.h>
+#include <libavcodec/version.h>
+
+static const enum AVSampleFormat AV_SAMPLE_FMT_S24 = AV_SAMPLE_FMT_NB + 1;
+
+FFM_AudioConvert *ff_ffm_audio_convert_alloc(
+                                     enum AVSampleFormat out_fmt,
+                                     enum AVSampleFormat in_fmt,
+                                     int channels);
+
+void ffabi_ff_mlp_init_crc(void);
+
+void *ffabi_memalign(size_t align, size_t size);
+void *ffabi_realloc(void *ptr, size_t size);
+void ffabi_free(void *ptr);
+
+#if (LIBAVCODEC_VERSION_MAJOR < 53)
+#error "Can't use an ancient ffmpeg or libav"
+#endif
+
+#if (LIBAVCODEC_VERSION_MAJOR == 53)
+
+#define AVCodecID CodecID
+#define AV_CODEC_ID_NONE CODEC_ID_NONE
+#define AV_CODEC_ID_AC3 CODEC_ID_AC3
+#define AV_CODEC_ID_DTS CODEC_ID_DTS
+#define AV_CODEC_ID_FLAC CODEC_ID_FLAC
+#define AV_CODEC_ID_MLP CODEC_ID_MLP
+#define AV_CODEC_ID_TRUEHD CODEC_ID_TRUEHD
+
+static inline void avcodec_free_frame(AVFrame **frame)
+{
+    av_freep(frame);
+}
+
+static inline void av_frame_unref(AVFrame *frame)
+{
+}
+
+#if (LIBAVCODEC_VERSION_MINOR < 40)
+void av_log_format_line(void *ptr, int level, const char *fmt, va_list vl,
+                        char *line, int line_size, int *print_prefix);
+#endif
+
+#endif
+
+#endif /* FFABI_INTERNAL_H */

makemkv-oss-1.8.6.tar.gz/libffabi/src/log.c Added

@@ -0,0 +1,58 @@
+/*
+ * log functions
+ * Copyright (c) 2003 Michel Bardiaux
+ *
+ * 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
+ * logging functions
+ */
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <libavutil/log.h>
+#include <libavcodec/version.h>
+
+#if (LIBAVCODEC_VERSION_MAJOR == 53) && (LIBAVCODEC_VERSION_MINOR < 40)
+
+void av_log_format_line(void *ptr, int level, const char *fmt, va_list vl,
+                        char *line, int line_size, int *print_prefix)
+{
+    AVClass* avc = ptr ? *(AVClass **) ptr : NULL;
+    line[0] = 0;
+    if (*print_prefix && avc) {
+        if (avc->parent_log_context_offset) {
+            AVClass** parent = *(AVClass ***) (((uint8_t *) ptr) +
+                                   avc->parent_log_context_offset);
+            if (parent && *parent) {
+                snprintf(line, line_size, "[%s @ %p] ",
+                         (*parent)->item_name(parent), parent);
+            }
+        }
+        snprintf(line + strlen(line), line_size - strlen(line), "[%s @ %p] ",
+                 avc->item_name(ptr), ptr);
+    }
+
+    vsnprintf(line + strlen(line), line_size - strlen(line), fmt, vl);
+
+    *print_prefix = strlen(line) && line[strlen(line) - 1] == '\n';
+}
+
+#endif
+

makemkv-oss-1.8.6.tar.gz/libffabi/src/mlp.c Added

@@ -0,0 +1,46 @@
+/*
+ * MLP codec common code
+ * Copyright (c) 2007-2008 Ian Caulfield
+ *
+ * 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
+ */
+
+#include <stdint.h>
+
+#include <libavutil/crc.h>
+#include <libavutil/intreadwrite.h>
+#include <lgpl/ffabi.h>
+#include "internal.h"
+
+#define CRC_TABLE_SIZE 1024
+
+static AVCRC crc_2D[CRC_TABLE_SIZE];
+
+av_cold void ffabi_ff_mlp_init_crc(void)
+{
+    av_crc_init(crc_2D, 0, 16, 0x002D, sizeof(crc_2D));
+}
+
+uint16_t ffm_mlp_checksum16(const uint8_t *buf, unsigned int buf_size)
+{
+    uint16_t crc;
+
+    crc = av_crc(crc_2D, 0, buf, buf_size - 2);
+    crc ^= AV_RL16(buf + buf_size - 2);
+    return crc;
+}
+

makemkv-oss-1.8.6.tar.gz/libffabi/src/mpegaudiodecheader.h Added

@@ -0,0 +1,76 @@
+/*
+ * MPEG Audio header decoder
+ * Copyright (c) 2001, 2002 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
+ */
+
+/**
+ * @file
+ * MPEG Audio header decoder.
+ */
+
+#ifndef FFABI_AVCODEC_MPEGAUDIODECHEADER_H
+#define FFABI_AVCODEC_MPEGAUDIODECHEADER_H
+
+#include <libavcodec/avcodec.h>
+
+#define MP3_MASK 0xFFFE0CCF
+
+#define MPA_DECODE_HEADER \
+    int frame_size; \
+    int error_protection; \
+    int layer; \
+    int sample_rate; \
+    int sample_rate_index; /* between 0 and 8 */ \
+    int bit_rate; \
+    int nb_channels; \
+    int mode; \
+    int mode_ext; \
+    int lsf;
+
+typedef struct MPADecodeHeader {
+  MPA_DECODE_HEADER
+} MPADecodeHeader;
+
+/* header decoding. MUST check the header before because no
+   consistency check is done there. Return 1 if free format found and
+   that the frame size must be computed externally */
+int avpriv_mpegaudio_decode_header(MPADecodeHeader *s, uint32_t header);
+
+/* useful helper to get mpeg audio stream infos. Return -1 if error in
+   header, otherwise the coded frame size in bytes */
+int avpriv_mpa_decode_header(AVCodecContext *avctx, uint32_t head, int *sample_rate, int *channels, int *frame_size, int *bitrate);
+
+/* fast header check for resync */
+static inline int ff_mpa_check_header(uint32_t header){
+    /* header */
+    if ((header & 0xffe00000) != 0xffe00000)
+        return -1;
+    /* layer check */
+    if ((header & (3<<17)) == 0)
+        return -1;
+    /* bit rate */
+    if ((header & (0xf<<12)) == 0xf<<12)
+        return -1;
+    /* frequency */
+    if ((header & (3<<10)) == 3<<10)
+        return -1;
+    return 0;
+}
+
+#endif /* FFABI_AVCODEC_MPEGAUDIODECHEADER_H */

makemkv-oss-1.8.5.tar.gz/libmakemkv/src/libmakemkv.def -> makemkv-oss-1.8.6.tar.gz/libmakemkv/src/libmakemkv.def Changed

makemkv-oss-1.8.5.tar.gz/libmakemkv/src/libmakemkv.vers -> makemkv-oss-1.8.6.tar.gz/libmakemkv/src/libmakemkv.vers Changed

@@ -1,18 +1,6 @@
 { global:
   set_world;
   MkvCreateFile;
-  ffcodec_ff_mlp_read_major_sync;
-  ffcodec_ff_mlp_get_audio_info;
-  ffcodec_ff_mpegaudio_decode_header;
-  ffcodec_ff_mpa_check_header;
-  ffcodec_ffm_init_context_r;
-  ffcodec_ffm_init_context_w;
-  ffcodec_ffm_read_header;
-  ffcodec_ffm_read_packet_header;
-  ffcodec_ffm_read_packet_data;
-  ffcodec_ffm_write_header;
-  ffcodec_ffm_write_packet;
-  ffcodec_ffm_write_trailer;
   HTTP_Download;
   OSSL_sizeof_AES_KEY;
   OSSL_AES_set_encrypt_key;
@@ -98,5 +86,24 @@
   XPAT_GetCurrentByteIndex;
   XPAT_ErrorString;
   XPAT_ExpatVersion;
+  ffm_init;
+  ffm_avcodec_version;
+  ffm_audio_decode_init;
+  ffm_audio_decode_close;
+  ffm_audio_decode_put_data;
+  ffm_audio_decode_get_frame;
+  ffm_audio_decode_get_info;
+  ffm_audio_encode_init;
+  ffm_audio_encode_close;
+  ffm_audio_encode_put_frame;
+  ffm_audio_encode_get_data;
+  ffm_audio_encode_get_info;
+  ffm_audio_check_codec_format;
+  ffm_audio_convert_alloc;
+  ffm_audio_convert_free;
+  ffm_audio_convert;
+  ffm_mlp_read_syncframe;
+  ffm_mlp_checksum16;
+  ffm_mpa_decode_header;
   local: *;
 };

makemkv-oss-1.8.5.tar.gz/libmakemkv/src/libmkv.cpp -> makemkv-oss-1.8.6.tar.gz/libmakemkv/src/libmkv.cpp Changed

@@ -317,6 +317,7 @@
     unsigned int    frame_count;
     unsigned int    compression_type;
     unsigned int    compression_level;
+    EbmlBinary*     codec_private;
 };
 
 class MyDataBuffer : public DataBuffer
@@ -525,7 +526,10 @@
 
         if (0!=ti->codec_private_size)
         {
-            GetChild<EbmlBinary,KaxCodecPrivate>(cur_track).CopyBuffer(ti->codec_private,ti->codec_private_size);
+            track_info[i].codec_private = & GetChild<EbmlBinary,KaxCodecPrivate>(cur_track);
+            track_info[i].codec_private->CopyBuffer(ti->codec_private,ti->codec_private_size);
+        } else {
+            track_info[i].codec_private = NULL;
         }
 
         if (0!=ti->default_duration)
@@ -1062,12 +1066,40 @@
 
     Chapters.Finalize(File,seek_chap,max_duration);
 
-    // delete empty tracks
-    for (unsigned int i=0;i<Input->MkvGetStreamCount();i++)
+    for (unsigned int i=1;i<Input->MkvGetStreamCount();i++)
     {
-        if (track_info[i].frame_count>0) continue;
-        VoidElement(tracks[i],File);
-        my_world()->uc_emptytrack(Input,i,&track_info[i].info);
+
+        if (track_info[i].frame_count==0)
+        {
+            VoidElement(tracks[i],File);
+            my_world()->uc_emptytrack(Input,i,&track_info[i].info);
+            continue;
+        }
+
+        if (track_info[i].codec_private)
+        {
+            MkvTrackInfo ti;
+
+
+            memset(&ti,0,sizeof(ti));
+            if (false==Input->MkvGetStream(i)->UpdateTrackInfo(&ti))
+            {
+                throw mkv_error_exception("UpdateTrackInfo failed");
+            }
+
+            if (track_info[i].codec_private->GetSize()==ti.codec_private_size)
+            {
+                if (0!=memcmp(track_info[i].codec_private->GetBuffer(),
+                    ti.codec_private,ti.codec_private_size))
+                {
+
+                    memcpy(track_info[i].codec_private->GetBuffer(),
+                        ti.codec_private,ti.codec_private_size);
+
+                    track_info[i].codec_private->OverwriteData(File,true);
+                }
+            }
+        }
     }
 
     // end

makemkv-oss-1.8.5.tar.gz/libmakemkv/src/world.cpp -> makemkv-oss-1.8.6.tar.gz/libmakemkv/src/world.cpp Changed

makemkv-oss-1.8.5.tar.gz/libmmbd/src/aacs.cpp -> makemkv-oss-1.8.6.tar.gz/libmmbd/src/aacs.cpp Changed

makemkv-oss-1.8.5.tar.gz/libmmbd/src/aacs.h -> makemkv-oss-1.8.6.tar.gz/libmmbd/src/aacs.h Changed

makemkv-oss-1.8.5.tar.gz/libmmbd/src/bdplus.cpp -> makemkv-oss-1.8.6.tar.gz/libmmbd/src/bdplus.cpp Changed

@@ -32,6 +32,9 @@
     Specifically, assumptions are made on how the functions
     in this library are called from libbluray.
     Do not use this API.
+    This library emulates both "old" and "new" libbdplus API
+    and for this reason BDPLUS_CTX and BDPLUS_ST handles are
+    interchangeable.
 */
 
 typedef struct _BDPLUS_CTX
@@ -59,39 +62,84 @@
     return ctx;
 }
 
-AACS_PUBLIC void __cdecl bdplus_free(BDPLUS_CTX* ctx)
+AACS_PUBLIC int __cdecl bdplus_free(BDPLUS_CTX* ctx)
 {
     free(ctx);
+    return 0;
 }
 
-AACS_PUBLIC void __cdecl bdplus_set_title(BDPLUS_CTX* ctx,uint32_t clip_id)
+AACS_PUBLIC int __cdecl bdplus_set_title(BDPLUS_CTX* ctx,uint32_t clip_id)
 {
     ctx->clip_id = clip_id;
     ctx->offset = 0;
+    return 0;
 }
 
-AACS_PUBLIC void __cdecl bdplus_seek(BDPLUS_CTX* ctx,uint64_t offset)
+AACS_PUBLIC int __cdecl bdplus_seek(BDPLUS_CTX* ctx,uint64_t offset)
 {
     ctx->offset = offset;
+    return 0;
 }
 
-AACS_PUBLIC uint32_t __cdecl bdplus_fixup(BDPLUS_CTX* ctx,size_t len,uint8_t* buffer)
+AACS_PUBLIC int __cdecl bdplus_fixup(BDPLUS_CTX* ctx,size_t len,uint8_t* buffer)
 {
+    int r,count=0;
+
     if ((ctx->offset%6144)!=0) {
         ctx->mmbd->error_message(101,"bdplus_fixup: offset is not aligned");
-        return 0;
+        return -1;
     }
     if ((len%6144)!=0) {
         ctx->mmbd->error_message(102,"bdplus_fixup: length is not aligned");
-        return 0;
+        return -2;
     }
 
     for (size_t i=0;i<len;i+=6144) {
-        if (ctx->mmbd->decrypt_unit(ctx->clip_id|MMBD_FILE_M2TS|MMBD_FLAG_BDPLUS_ONLY,ctx->offset,buffer+i)) {
+        r = ctx->mmbd->decrypt_unit(ctx->clip_id|MMBD_FILE_M2TS|MMBD_FLAG_BDPLUS_ONLY,ctx->offset,buffer+i);
+        if (r<0) {
             ctx->mmbd->error_message(103,"bdplus_fixup: mmbd_decrypt_unit failed");
+        } else {
+            count += r;
         }
         ctx->offset+=6144;
     }
-    return 1;
+    if (ctx->mmbd->mmbdipc_version()<2) count=1;
+    return count;
+}
+
+AACS_PUBLIC BDPLUS_ST* __cdecl bdplus_m2ts(BDPLUS_CTX* ctx,uint32_t clip_id)
+{
+    BDPLUS_CTX* st = (BDPLUS_CTX*)malloc(sizeof(BDPLUS_CTX));
+    if (!st) return NULL;
+
+    st->mmbd = ctx->mmbd;
+    st->clip_id = clip_id;
+    st->offset = 0;
+    return st;
+}
+
+AACS_PUBLIC int __cdecl bdplus_m2ts_close(BDPLUS_ST* st)
+{
+    return bdplus_free(st);
+}
+
+AACS_PUBLIC int __cdecl bdplus_mmap(BDPLUS_CTX* ctx,uint32_t region_id,void *mem)
+{
+    return 0;
+}
+
+AACS_PUBLIC int __cdecl bdplus_psr(BDPLUS_CTX* ctx,void *regs,void *read,void *write)
+{
+    return 0;
+}
+
+AACS_PUBLIC int __cdecl bdplus_event(BDPLUS_CTX* ctx,uint32_t event,uint32_t param1,uint32_t param2)
+{
+    return 0;
+}
+
+AACS_PUBLIC int __cdecl bdplus_start(BDPLUS_CTX* ctx)
+{
+    return 0;
 }

makemkv-oss-1.8.5.tar.gz/libmmbd/src/bdplus.h -> makemkv-oss-1.8.6.tar.gz/libmmbd/src/bdplus.h Changed

@@ -23,16 +23,27 @@
 
 struct _BDPLUS_CTX;
 typedef struct _BDPLUS_CTX BDPLUS_CTX;
+typedef struct _BDPLUS_CTX BDPLUS_ST;
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 AACS_PUBLIC BDPLUS_CTX* __cdecl bdplus_init(const char *path, const char *keyfile_path,const uint8_t* aacs_vid);
-AACS_PUBLIC void __cdecl bdplus_free(BDPLUS_CTX* ctx);
-AACS_PUBLIC void __cdecl bdplus_set_title(BDPLUS_CTX* ctx,uint32_t clip_id);
-AACS_PUBLIC void __cdecl bdplus_seek(BDPLUS_CTX* ctx,uint64_t offset);
-AACS_PUBLIC uint32_t __cdecl bdplus_fixup(BDPLUS_CTX* ctx,size_t len,uint8_t* buffer);
+AACS_PUBLIC int __cdecl bdplus_free(BDPLUS_CTX* ctx);
+
+// old API
+AACS_PUBLIC int __cdecl bdplus_set_title(BDPLUS_CTX* ctx,uint32_t clip_id);
+AACS_PUBLIC int __cdecl bdplus_seek(BDPLUS_CTX* ctx,uint64_t offset);
+AACS_PUBLIC int __cdecl bdplus_fixup(BDPLUS_CTX* ctx,size_t len,uint8_t* buffer);
+
+// new API
+AACS_PUBLIC int __cdecl bdplus_mmap(BDPLUS_CTX* ctx,uint32_t region_id,void *mem);
+AACS_PUBLIC int __cdecl bdplus_psr(BDPLUS_CTX* ctx,void *regs,void *read,void *write);
+AACS_PUBLIC int __cdecl bdplus_event(BDPLUS_CTX* ctx,uint32_t event,uint32_t param1,uint32_t param2);
+AACS_PUBLIC int __cdecl bdplus_start(BDPLUS_CTX* ctx);
+AACS_PUBLIC BDPLUS_ST* __cdecl bdplus_m2ts(BDPLUS_CTX* ctx,uint32_t clip_id);
+AACS_PUBLIC int __cdecl bdplus_m2ts_close(BDPLUS_ST* st);
 
 #ifdef __cplusplus
 }

makemkv-oss-1.8.5.tar.gz/libmmbd/src/libmmbd.def -> makemkv-oss-1.8.6.tar.gz/libmmbd/src/libmmbd.def Changed

makemkv-oss-1.8.5.tar.gz/libmmbd/src/libmmbd.vers -> makemkv-oss-1.8.6.tar.gz/libmmbd/src/libmmbd.vers Changed

makemkv-oss-1.8.5.tar.gz/libmmbd/src/mmbd.cpp -> makemkv-oss-1.8.6.tar.gz/libmmbd/src/mmbd.cpp Changed

makemkv-oss-1.8.5.tar.gz/libmmbd/src/mmconn.cpp -> makemkv-oss-1.8.6.tar.gz/libmmbd/src/mmconn.cpp Changed

makemkv-oss-1.8.5.tar.gz/makefile.common -> makemkv-oss-1.8.6.tar.gz/makefile.common Changed

makemkv-oss-1.8.5.tar.gz/makefile.linux -> makemkv-oss-1.8.6.tar.gz/makefile.linux Changed

@@ -22,7 +22,7 @@
 clean:
 	-rm -rf out tmp
 
-install: out/libdriveio.so.0 out/libmakemkv.so.1 out/makemkv
+install: out/libdriveio.so.0 out/libmakemkv.so.1 out/makemkv out/libmmbd.so.0
 	install -D -m 644 out/libdriveio.so.0 $(DESTDIR)$(LIBDIR)/libdriveio.so.0
 	install -D -m 644 out/libmakemkv.so.1 $(DESTDIR)$(LIBDIR)/libmakemkv.so.1
 	install -D -m 644 out/libmmbd.so.0 $(DESTDIR)$(LIBDIR)/libmmbd.so.0
@@ -49,12 +49,12 @@
 out/libmakemkv.so.1.full: tmp/gen_buildinfo.h
 	mkdir -p out
 	$(GCC) $(CXXOPTS) -D_REENTRANT -shared -Wl,-z,defs -o$@ $(LIBEBML_INC) $(LIBEBML_DEF) $(LIBMATROSKA_INC) \
-	$(LIBMAKEMKV_INC) $(SSTRING_INC) $(MAKEMKVGUI_INC) $(LIBABI_INC) $(LIBFFCODEC_INC) \
+	$(LIBMAKEMKV_INC) $(SSTRING_INC) $(MAKEMKVGUI_INC) $(LIBABI_INC) $(LIBFFABI_INC) \
 	$(LIBEBML_SRC) $(LIBMATROSKA_SRC) $(LIBMAKEMKV_SRC) $(GLIBC_SRC) $(SSTRING_SRC) \
-	$(LIBABI_SRC) $(LIBABI_SRC_LINUX) $(LIBFFCODEC_SRC) \
+	$(LIBABI_SRC) $(LIBABI_SRC_LINUX) $(LIBFFABI_SRC) \
 	-DHAVE_BUILDINFO_H -Itmp \
 	-fPIC -Xlinker -dy -Xlinker --version-script=libmakemkv/src/libmakemkv.vers \
-	-Xlinker -soname=libmakemkv.so.1 -lc -lstdc++ -lcrypto -lz -lexpat
+	-Xlinker -soname=libmakemkv.so.1 -lc -lstdc++ -lcrypto -lz -lexpat -lavcodec -lavutil -lm
 
 out/libmmbd.so.0.full:
 	mkdir -p out

makemkv-oss-1.8.5.tar.gz/makemkvgui/inc/lgpl/apdefs.h -> makemkv-oss-1.8.6.tar.gz/makemkvgui/inc/lgpl/apdefs.h Changed

makemkv-oss-1.8.5.tar.gz/makemkvgui/inc/ver_num.h -> makemkv-oss-1.8.6.tar.gz/makemkvgui/inc/ver_num.h Changed

makemkv-oss-1.8.5.tar.gz/makemkvgui/src/image.cpp -> makemkv-oss-1.8.6.tar.gz/makemkvgui/src/image.cpp Changed

makemkv-oss-1.8.5.tar.gz/makemkvgui/src/settingdlg.cpp -> makemkv-oss-1.8.6.tar.gz/makemkvgui/src/settingdlg.cpp Changed

@@ -205,7 +205,6 @@
     }
     advancedTab->lineEditSelection->setText(QStringFromUtf16(defaultSelection));
 
-    advancedTab->ffmpegDir->setText(QStringFromUtf16( client->GetSettingString(apset_app_ffmpeg)));
     advancedTab->dtshddecDir->setText(QStringFromUtf16( client->GetSettingString(apset_app_dtshddec)));
 
     toggleAdvanced(expert_mode!=0);
@@ -272,7 +271,6 @@
     } else {
         client->SetSettingString(apset_app_DefaultSelectionString,Utf16FromQString(advancedTab->lineEditSelection->text()));
     }
-    client->SetSettingString(apset_app_ffmpeg,Utf16FromQString(advancedTab->ffmpegDir->text()));
     client->SetSettingString(apset_app_dtshddec,Utf16FromQString(advancedTab->dtshddecDir->text()));
 
     restartRequired = (NULL!=client->GetAppString(AP_vastr_RestartRequired));
@@ -620,13 +618,11 @@
     b_lay->addWidget(lineEditSelection,1,1);
     box->setLayout(b_lay);
 
-    ffmpegDir = new CDirSelectBox(CDirSelectBox::DirBoxFile,UI_QSTRING(APP_IFACE_SETTINGS_ADV_FFMPEG_PATH));
     dtshddecDir = new CDirSelectBox(CDirSelectBox::DirBoxFile,UI_QSTRING(APP_IFACE_SETTINGS_ADV_DTSHDDEC_PATH));
 
     QBoxLayout *lay = new QVBoxLayout();
 
     lay->addWidget(box);
-    lay->addWidget(ffmpegDir);
     lay->addWidget(dtshddecDir);
 
     lay->addStretch(2);

makemkv-oss-1.8.5.tar.gz/makemkvgui/src/settingdlg.h -> makemkv-oss-1.8.6.tar.gz/makemkvgui/src/settingdlg.h Changed

makemkv-oss-1.8.5.tar.gz/makemkvgui/src/str/en_utf16.cpp -> makemkv-oss-1.8.6.tar.gz/makemkvgui/src/str/en_utf16.cpp Changed

@@ -13,7 +13,7 @@
 
 */
 
-static const unsigned short en_po_str[20187]={
+static const unsigned short en_po_str[20202]={
 'e','n','g',':','E','n','g','l','i','s','h',0,
 'D','B','G',' ','A','S','S','E','R','T',':',' ','%','1',' ','a','t',' ','%','2',':','%','3',0,
 'L','I','B','M','K','V','_','T','R','A','C','E',':',' ','%','1',0,
@@ -327,6 +327,7 @@
 'L','P','C','M',' ','a','u','d','i','o',' ','i','n',' ','W','A','V',' ','c','o','n','t','a','i','n','e','r',' ','w','i','t','h',' ','c','h','a','n','n','e','l',' ','c','o','n','f','i','g','u','r','a','t','i','o','n',' ','m','e','t','a','d','a','t','a',0,
 'F','L','A','C',' ','a','u','d','i','o',0,
 'V','O','B','S','U','B',' ','s','u','b','t','i','t','l','e','s',0,
+'A','C','3',' ','a','u','d','i','o',0,
 'D','e','f','a','u','l','t',0,
 'F','o','r','c','e','d',0,
 'M','a','k','e','M','K','V',' ','B','E','T','A',0,
@@ -482,7 +483,7 @@
 'D','e','f','a','u','l','t',' ','p','r','o','f','i','l','e',' ',':',0,
 'D','e','f','a','u','l','t',' ','s','e','l','e','c','t','i','o','n',' ','r','u','l','e',' ',':',0,
 'F','F','M','P','E','G',' ','l','o','c','a','t','i','o','n',0,
-'d','t','s','h','d','d','e','c','.','d','l','l',' ','l','o','c','a','t','i','o','n',0,
+'d','t','s','d','e','c','o','d','e','r','d','l','l','.','d','l','l',' ','l','o','c','a','t','i','o','n',0,
 'P','r','o','f','i','l','e',0,
 'P','r','o','p','e','r','t','i','e','s',0,
 'T','i','t','l','e',0,
@@ -525,7 +526,7 @@
 'O','S',' ','d','e','v','i','c','e',' ','n','a','m','e',':',' ',0,
 0};
 
-static const unsigned int en_po_off[1019]={
+static const unsigned int en_po_off[1021]={
 1000,0,1001,12,1002,36,1003,53,1004,77,1005,124,1006,135,1007,136,1008,226,1009,275,2001,301,
 2002,350,2003,436,2004,490,2005,558,2006,668,2007,785,2008,940,2009,1063,2010,1191,2011,1236,2012,1380,
 2013,1491,2014,1604,2015,1652,2016,1734,2017,1897,2018,2012,2019,2074,2020,2114,2021,2281,2022,2404,2200,2538,
@@ -554,25 +555,25 @@
 5085,15681,5086,15745,5087,15753,5088,15774,5089,15798,5201,15809,5202,15814,5203,15819,5204,15828,5207,15837,5208,15843,
 5209,15858,5210,15867,5214,15872,5215,15881,5216,15887,5217,15904,5218,15916,5219,15932,5220,15943,5221,15956,5222,15967,
 5223,15973,5224,15983,5225,15999,5226,16013,5227,16025,5228,16035,5233,16053,5234,16066,5235,16080,5238,16099,5239,16109,
-5301,16119,5302,16130,5303,16184,5304,16248,5305,16259,5380,16276,5381,16284,6000,16291,6001,16304,6002,16323,6003,16342,
-6005,16376,6006,16397,6007,16411,6008,16493,6010,16507,6011,16519,6012,16526,6013,16570,6014,16577,6015,16602,6016,16620,
-6017,16667,6018,16688,6019,16709,6020,16715,6021,16722,6022,16739,6023,16746,6030,16779,6031,16785,6032,16791,6034,16797,
-6035,16805,6036,16815,6037,16823,6038,16848,6039,16860,6040,16872,6041,16901,6042,16956,6043,16969,6044,16997,6045,17010,
-6046,17023,6047,17045,6048,17055,6050,17079,6051,17124,6052,17217,6053,17229,6054,17245,6055,17261,6056,17276,6057,17289,
-6058,17310,6059,17316,6060,17323,6061,17330,6062,17343,6063,17357,6064,17374,6065,17392,6066,17408,6067,17421,6068,17433,
-6069,17447,6070,17452,6071,17461,6072,17468,6073,17475,6074,17483,6075,17496,6076,17501,6077,17525,6078,17556,6079,17611,
-6080,17681,6081,17689,6082,17694,6083,17713,6085,17737,6086,17742,6087,17775,6088,17817,6089,17837,6090,17842,6091,17847,
-6092,17856,6093,17863,6094,17883,6095,17897,6096,17918,6097,17926,6098,17950,6099,18012,6100,18033,6101,18044,6102,18056,
-6103,18064,6104,18069,6105,18094,6106,18101,6107,18126,6108,18147,6109,18188,6110,18205,6111,18216,6112,18233,6119,18247,
-6120,18277,6121,18306,6122,18335,6123,18369,6124,18400,6125,18432,6126,18452,6127,18482,6128,18510,6129,18532,6130,18546,
-6131,18572,6132,18580,6133,18603,6134,18614,6135,18626,6136,18646,6137,18666,6138,18678,6139,18943,6142,18975,6143,18998,
-6144,19009,6145,19026,6146,19036,6147,19061,6148,19069,6149,19089,6150,19131,6151,19155,6152,19195,6153,19204,6154,19225,
-6156,19246,6157,19251,6158,19256,6161,19282,6162,19296,6163,19322,6164,19340,6165,19343,6166,19353,6167,19364,6169,19387,
-6170,19401,6171,19436,6172,19469,6173,19478,6174,19496,6175,19521,6176,19537,6180,19559,6181,19567,6200,19578,6201,19584,
-6202,19590,6203,19596,6204,19606,6205,19611,6206,19623,6207,19632,6209,19646,6210,19659,6211,19670,6212,19685,6213,19697,
-6214,19706,6215,19717,6216,19726,6300,19734,6301,19763,6302,19781,6303,19796,6304,19806,6305,19817,6306,19833,6307,19852,
-6308,19868,6309,19891,6320,19914,6321,19946,6322,19978,6323,20003,6324,20019,6325,20031,6326,20043,6327,20063,6329,20082,
-6330,20103,6331,20136,6332,20169,0};
+5301,16119,5302,16130,5303,16184,5304,16248,5305,16259,5306,16276,5380,16286,5381,16294,6000,16301,6001,16314,6002,16333,
+6003,16352,6005,16386,6006,16407,6007,16421,6008,16503,6010,16517,6011,16529,6012,16536,6013,16580,6014,16587,6015,16612,
+6016,16630,6017,16677,6018,16698,6019,16719,6020,16725,6021,16732,6022,16749,6023,16756,6030,16789,6031,16795,6032,16801,
+6034,16807,6035,16815,6036,16825,6037,16833,6038,16858,6039,16870,6040,16882,6041,16911,6042,16966,6043,16979,6044,17007,
+6045,17020,6046,17033,6047,17055,6048,17065,6050,17089,6051,17134,6052,17227,6053,17239,6054,17255,6055,17271,6056,17286,
+6057,17299,6058,17320,6059,17326,6060,17333,6061,17340,6062,17353,6063,17367,6064,17384,6065,17402,6066,17418,6067,17431,
+6068,17443,6069,17457,6070,17462,6071,17471,6072,17478,6073,17485,6074,17493,6075,17506,6076,17511,6077,17535,6078,17566,
+6079,17621,6080,17691,6081,17699,6082,17704,6083,17723,6085,17747,6086,17752,6087,17785,6088,17827,6089,17847,6090,17852,
+6091,17857,6092,17866,6093,17873,6094,17893,6095,17907,6096,17928,6097,17936,6098,17960,6099,18022,6100,18043,6101,18054,
+6102,18066,6103,18074,6104,18079,6105,18104,6106,18111,6107,18136,6108,18157,6109,18198,6110,18215,6111,18226,6112,18243,
+6119,18257,6120,18287,6121,18316,6122,18345,6123,18379,6124,18410,6125,18442,6126,18462,6127,18492,6128,18520,6129,18542,
+6130,18556,6131,18582,6132,18590,6133,18613,6134,18624,6135,18636,6136,18656,6137,18676,6138,18688,6139,18953,6142,18985,
+6143,19008,6144,19019,6145,19036,6146,19046,6147,19071,6148,19079,6149,19099,6150,19141,6151,19165,6152,19205,6153,19214,
+6154,19235,6156,19256,6157,19261,6158,19266,6161,19292,6162,19306,6163,19332,6164,19350,6165,19353,6166,19363,6167,19374,
+6169,19397,6170,19411,6171,19446,6172,19479,6173,19488,6174,19506,6175,19531,6176,19547,6180,19574,6181,19582,6200,19593,
+6201,19599,6202,19605,6203,19611,6204,19621,6205,19626,6206,19638,6207,19647,6209,19661,6210,19674,6211,19685,6212,19700,
+6213,19712,6214,19721,6215,19732,6216,19741,6300,19749,6301,19778,6302,19796,6303,19811,6304,19821,6305,19832,6306,19848,
+6307,19867,6308,19883,6309,19906,6320,19929,6321,19961,6322,19993,6323,20018,6324,20034,6325,20046,6326,20058,6327,20078,
+6329,20097,6330,20118,6331,20151,6332,20184,0};
 
 extern "C" const unsigned short * en_po_getstr_utf16(unsigned int code)
 {