From patchwork Wed Feb 22 17:38:38 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Devin Heitmueller X-Patchwork-Id: 2642 Delivered-To: ffmpegpatchwork@gmail.com Received: by 10.103.65.149 with SMTP id x21csp991901vsf; Wed, 22 Feb 2017 09:46:18 -0800 (PST) X-Received: by 10.223.160.114 with SMTP id l47mr24195122wrl.73.1487785578251; Wed, 22 Feb 2017 09:46:18 -0800 (PST) Return-Path: Received: from ffbox0-bg.mplayerhq.hu (ffbox0-bg.ffmpeg.org. [79.124.17.100]) by mx.google.com with ESMTP id m73si3439258wmg.161.2017.02.22.09.46.17; Wed, 22 Feb 2017 09:46:18 -0800 (PST) Received-SPF: pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) client-ip=79.124.17.100; Authentication-Results: mx.google.com; dkim=neutral (body hash did not verify) header.i=@kernellabs-com.20150623.gappssmtp.com; spf=pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) smtp.mailfrom=ffmpeg-devel-bounces@ffmpeg.org Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 5B84868837E; Wed, 22 Feb 2017 19:46:07 +0200 (EET) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from mail-qk0-f171.google.com (mail-qk0-f171.google.com [209.85.220.171]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 729376882B7 for ; Wed, 22 Feb 2017 19:46:00 +0200 (EET) Received: by mail-qk0-f171.google.com with SMTP id u188so9710359qkc.2 for ; Wed, 22 Feb 2017 09:46:08 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernellabs-com.20150623.gappssmtp.com; s=20150623; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=8pGmhwMVpn/yPtmzoX298RimjruN6vbY8bEBqF3NqIA=; b=DehgnPoOsaMeV6khMSDNeEe4fXwWKjvHAKVciQ5jvivI0Sxckh9s2S2WIboBZbkKEX Bhu7lf5wrCWKZna+ouEX72JupUKRs/E7cPiQaAPjMP3Wsl3tjB13usUOjLCwFtpZ5Wns JSQAZ5j1wBaAYDLYaWJ0yIQ1TnD1Gi4sOQ8n66uEZRuki6qoaU2Ij1toxwwKoGv/ksK9 VIf/gpKgDjN2YnGqonpM1huxpIWiqKOwRJMPiR1CksLYsbbCtLnjgv0TqVZD1Vr5EJoH dP9RQYsDg8ee+ROncalbyOm+HDmOtZHBAlk+HnaIZ4kGmnBvlf08HzP2+6vdXddqMgQ0 6Ibg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=8pGmhwMVpn/yPtmzoX298RimjruN6vbY8bEBqF3NqIA=; b=A2c+H2B0wlWaD9Yvxbrhze25OSrzdEF0XdMBcJosX6aK+ANgyNRWlbq2Of5n6mOqQ1 bl+VRpjIfNXaA6S1bgSxJERoeI0ft2dw7rKOOtQyDZPyqScyO7Sz0ePVrA45DGy9au3u CuhsO4mUhwrJmULJYJbnhK6xzP0J8vpYor05QHygiwC0p4XToEB6OSy6kLtzuMrBvQql 6x993407NRo22Ej/y8l2ca1gpiXeFB9xTV5t/G9Kcr0YVUWzE8IMuhfxaIpWBtcfkfBR gl27OuDNx934fMskBEbCUpKZPMED4MCeZQ0cNsJarvDLPQswNuS8KdEfq48i/e3fHLSo 5FRg== X-Gm-Message-State: AMke39nDu8qay3soJDv/GYzVORY2/En6nmh+drTcAn8IrXbhK1+GFGMTeaoMVSOSj77veyZ7 X-Received: by 10.55.157.131 with SMTP id g125mr31638723qke.294.1487785152384; Wed, 22 Feb 2017 09:39:12 -0800 (PST) Received: from localhost.localdomain (cpe-74-71-86-100.nyc.res.rr.com. [74.71.86.100]) by smtp.gmail.com with ESMTPSA id 63sm1086608qta.37.2017.02.22.09.39.11 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Wed, 22 Feb 2017 09:39:11 -0800 (PST) From: Devin Heitmueller To: ffmpeg-devel@ffmpeg.org Date: Wed, 22 Feb 2017 12:38:38 -0500 Message-Id: <1487785118-21649-2-git-send-email-dheitmueller@kernellabs.com> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1487785118-21649-1-git-send-email-dheitmueller@kernellabs.com> References: <1487785118-21649-1-git-send-email-dheitmueller@kernellabs.com> Subject: [FFmpeg-devel] [PATCH 1/1] Add support for Ericsson Texture Compression 1 (ETC1) X-BeenThere: ffmpeg-devel@ffmpeg.org X-Mailman-Version: 2.1.20 Precedence: list List-Id: FFmpeg development discussions and patches List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: FFmpeg development discussions and patches Cc: Devin Heitmueller , cphealy@gmail.com MIME-Version: 1.0 Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" This patch adds support for encoding/decoding ETC1 compressed textures. This includes support for the PKM file format. Example usage: ./ffmpeg -i input_image.jpg new.pkm ./ffmpeg -i new.pkm foo.jpg Signed-off-by: Devin Heitmueller --- libavcodec/Makefile | 2 + libavcodec/allcodecs.c | 1 + libavcodec/avcodec.h | 1 + libavcodec/codec_desc.c | 7 + libavcodec/etc1.c | 707 ++++++++++++++++++++++++++++++++++++++++++++++++ libavcodec/etc1.h | 114 ++++++++ libavcodec/etc1dec.c | 81 ++++++ libavcodec/etc1enc.c | 90 ++++++ libavcodec/utils.c | 3 +- libavformat/img2.c | 1 + libavformat/img2enc.c | 2 +- 11 files changed, 1007 insertions(+), 2 deletions(-) create mode 100644 libavcodec/etc1.c create mode 100644 libavcodec/etc1.h create mode 100644 libavcodec/etc1dec.c create mode 100644 libavcodec/etc1enc.c diff --git a/libavcodec/Makefile b/libavcodec/Makefile index a1ce264..f5eec15 100644 --- a/libavcodec/Makefile +++ b/libavcodec/Makefile @@ -280,6 +280,8 @@ OBJS-$(CONFIG_EIGHTSVX_EXP_DECODER) += 8svx.o OBJS-$(CONFIG_EIGHTSVX_FIB_DECODER) += 8svx.o OBJS-$(CONFIG_ESCAPE124_DECODER) += escape124.o OBJS-$(CONFIG_ESCAPE130_DECODER) += escape130.o +OBJS-$(CONFIG_ETC1_ENCODER) += etc1enc.o etc1.o +OBJS-$(CONFIG_ETC1_DECODER) += etc1dec.o etc1.o OBJS-$(CONFIG_EVRC_DECODER) += evrcdec.o acelp_vectors.o lsp.o OBJS-$(CONFIG_EXR_DECODER) += exr.o OBJS-$(CONFIG_FFV1_DECODER) += ffv1dec.o ffv1.o diff --git a/libavcodec/allcodecs.c b/libavcodec/allcodecs.c index f12a54d..cd3a662 100644 --- a/libavcodec/allcodecs.c +++ b/libavcodec/allcodecs.c @@ -184,6 +184,7 @@ void avcodec_register_all(void) REGISTER_DECODER(EIGHTSVX_FIB, eightsvx_fib); REGISTER_DECODER(ESCAPE124, escape124); REGISTER_DECODER(ESCAPE130, escape130); + REGISTER_ENCDEC (ETC1, etc1); REGISTER_DECODER(EXR, exr); REGISTER_ENCDEC (FFV1, ffv1); REGISTER_ENCDEC (FFVHUFF, ffvhuff); diff --git a/libavcodec/avcodec.h b/libavcodec/avcodec.h index 5616fb0..bf86210 100644 --- a/libavcodec/avcodec.h +++ b/libavcodec/avcodec.h @@ -388,6 +388,7 @@ enum AVCodecID { AV_CODEC_ID_DXV, AV_CODEC_ID_SCREENPRESSO, AV_CODEC_ID_RSCC, + AV_CODEC_ID_ETC1, AV_CODEC_ID_Y41P = 0x8000, AV_CODEC_ID_AVRP, diff --git a/libavcodec/codec_desc.c b/libavcodec/codec_desc.c index 35846c0..de7695d 100644 --- a/libavcodec/codec_desc.c +++ b/libavcodec/codec_desc.c @@ -1199,6 +1199,13 @@ static const AVCodecDescriptor codec_descriptors[] = { }, { + .id = AV_CODEC_ID_ETC1, + .type = AVMEDIA_TYPE_VIDEO, + .name = "etc1", + .long_name = NULL_IF_CONFIG_SMALL("ETC1 (Ericsson Texture Compression) image"), + .props = AV_CODEC_PROP_LOSSY, + }, + { .id = AV_CODEC_ID_G2M, .type = AVMEDIA_TYPE_VIDEO, .name = "g2m", diff --git a/libavcodec/etc1.c b/libavcodec/etc1.c new file mode 100644 index 0000000..e28d83c --- /dev/null +++ b/libavcodec/etc1.c @@ -0,0 +1,707 @@ +// Copyright 2009 Google Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +////////////////////////////////////////////////////////////////////////////////////////// + +// This is a fork of the AOSP project ETC1 codec. The original code can be found +// at the following web site: +// https://android.googlesource.com/platform/frameworks/native/+/master/opengl/include/ETC1/ + +////////////////////////////////////////////////////////////////////////////////////////// + +#include "etc1.h" + +//#include +#include + +/* From http://www.khronos.org/registry/gles/extensions/OES/OES_compressed_ETC1_RGB8_texture.txt + + The number of bits that represent a 4x4 texel block is 64 bits if + is given by ETC1_RGB8_OES. + + The data for a block is a number of bytes, + + {q0, q1, q2, q3, q4, q5, q6, q7} + + where byte q0 is located at the lowest memory address and q7 at + the highest. The 64 bits specifying the block is then represented + by the following 64 bit integer: + + int64bit = 256*(256*(256*(256*(256*(256*(256*q0+q1)+q2)+q3)+q4)+q5)+q6)+q7; + + ETC1_RGB8_OES: + + a) bit layout in bits 63 through 32 if diffbit = 0 + + 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 + ----------------------------------------------- + | base col1 | base col2 | base col1 | base col2 | + | R1 (4bits)| R2 (4bits)| G1 (4bits)| G2 (4bits)| + ----------------------------------------------- + + 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 + --------------------------------------------------- + | base col1 | base col2 | table | table |diff|flip| + | B1 (4bits)| B2 (4bits)| cw 1 | cw 2 |bit |bit | + --------------------------------------------------- + + + b) bit layout in bits 63 through 32 if diffbit = 1 + + 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 + ----------------------------------------------- + | base col1 | dcol 2 | base col1 | dcol 2 | + | R1' (5 bits) | dR2 | G1' (5 bits) | dG2 | + ----------------------------------------------- + + 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 + --------------------------------------------------- + | base col 1 | dcol 2 | table | table |diff|flip| + | B1' (5 bits) | dB2 | cw 1 | cw 2 |bit |bit | + --------------------------------------------------- + + + c) bit layout in bits 31 through 0 (in both cases) + + 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 + ----------------------------------------------- + | most significant pixel index bits | + | p| o| n| m| l| k| j| i| h| g| f| e| d| c| b| a| + ----------------------------------------------- + + 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 + -------------------------------------------------- + | least significant pixel index bits | + | p| o| n| m| l| k| j| i| h| g| f| e| d| c | b | a | + -------------------------------------------------- + + + Add table 3.17.2: Intensity modifier sets for ETC1 compressed textures: + + table codeword modifier table + ------------------ ---------------------- + 0 -8 -2 2 8 + 1 -17 -5 5 17 + 2 -29 -9 9 29 + 3 -42 -13 13 42 + 4 -60 -18 18 60 + 5 -80 -24 24 80 + 6 -106 -33 33 106 + 7 -183 -47 47 183 + + + Add table 3.17.3 Mapping from pixel index values to modifier values for + ETC1 compressed textures: + + pixel index value + --------------- + msb lsb resulting modifier value + ----- ----- ------------------------- + 1 1 -b (large negative value) + 1 0 -a (small negative value) + 0 0 a (small positive value) + 0 1 b (large positive value) + + + */ + +static const int kModifierTable[] = { +/* 0 */2, 8, -2, -8, +/* 1 */5, 17, -5, -17, +/* 2 */9, 29, -9, -29, +/* 3 */13, 42, -13, -42, +/* 4 */18, 60, -18, -60, +/* 5 */24, 80, -24, -80, +/* 6 */33, 106, -33, -106, +/* 7 */47, 183, -47, -183 }; + +static const int kLookup[8] = { 0, 1, 2, 3, -4, -3, -2, -1 }; + +static inline etc1_byte clamp(int x) { + return (etc1_byte) (x >= 0 ? (x < 255 ? x : 255) : 0); +} + +static +inline int convert4To8(int b) { + int c = b & 0xf; + return (c << 4) | c; +} + +static +inline int convert5To8(int b) { + int c = b & 0x1f; + return (c << 3) | (c >> 2); +} + +static +inline int convert6To8(int b) { + int c = b & 0x3f; + return (c << 2) | (c >> 4); +} + +static +inline int divideBy255(int d) { + return (d + 128 + (d >> 8)) >> 8; +} + +static +inline int convert8To4(int b) { + int c = b & 0xff; + return divideBy255(c * 15); +} + +static +inline int convert8To5(int b) { + int c = b & 0xff; + return divideBy255(c * 31); +} + +static +inline int convertDiff(int base, int diff) { + return convert5To8((0x1f & base) + kLookup[0x7 & diff]); +} + +static +void decode_subblock(etc1_byte* pOut, int r, int g, int b, const int* table, + etc1_uint32 low, int second, int flipped) { + int baseX = 0; + int baseY = 0; + int k; + int offset; + int delta; + etc1_byte *q; + + if (second) { + if (flipped) { + baseY = 2; + } else { + baseX = 2; + } + } + for (int i = 0; i < 8; i++) { + int x, y; + if (flipped) { + x = baseX + (i >> 1); + y = baseY + (i & 1); + } else { + x = baseX + (i >> 2); + y = baseY + (i & 3); + } + k = y + (x * 4); + offset = ((low >> k) & 1) | ((low >> (k + 15)) & 2); + delta = table[offset]; + q = pOut + 3 * (x + 4 * y); + *q++ = clamp(r + delta); + *q++ = clamp(g + delta); + *q++ = clamp(b + delta); + } +} + +// Input is an ETC1 compressed version of the data. +// Output is a 4 x 4 square of 3-byte pixels in form R, G, B + +void etc1_decode_block(const etc1_byte* pIn, etc1_byte* pOut) { + etc1_uint32 high = (pIn[0] << 24) | (pIn[1] << 16) | (pIn[2] << 8) | pIn[3]; + etc1_uint32 low = (pIn[4] << 24) | (pIn[5] << 16) | (pIn[6] << 8) | pIn[7]; + int tableIndexA; + int tableIndexB; + const int* tableA; + const int* tableB; + int flipped; + int r1, r2, g1, g2, b1, b2; + if (high & 2) { + // differential + int rBase = high >> 27; + int gBase = high >> 19; + int bBase = high >> 11; + r1 = convert5To8(rBase); + r2 = convertDiff(rBase, high >> 24); + g1 = convert5To8(gBase); + g2 = convertDiff(gBase, high >> 16); + b1 = convert5To8(bBase); + b2 = convertDiff(bBase, high >> 8); + } else { + // not differential + r1 = convert4To8(high >> 28); + r2 = convert4To8(high >> 24); + g1 = convert4To8(high >> 20); + g2 = convert4To8(high >> 16); + b1 = convert4To8(high >> 12); + b2 = convert4To8(high >> 8); + } + tableIndexA = 7 & (high >> 5); + tableIndexB = 7 & (high >> 2); + tableA = kModifierTable + tableIndexA * 4; + tableB = kModifierTable + tableIndexB * 4; + flipped = (high & 1) != 0; + decode_subblock(pOut, r1, g1, b1, tableA, low, 0, flipped); + decode_subblock(pOut, r2, g2, b2, tableB, low, 1, flipped); +} + +typedef struct { + etc1_uint32 high; + etc1_uint32 low; + etc1_uint32 score; // Lower is more accurate +} etc_compressed; + +static +inline void take_best(etc_compressed* a, const etc_compressed* b) { + if (a->score > b->score) { + *a = *b; + } +} + +static +void etc_average_colors_subblock(const etc1_byte* pIn, etc1_uint32 inMask, + etc1_byte* pColors, int flipped, int second) { + int r = 0; + int g = 0; + int b = 0; + + if (flipped) { + int by = 0; + if (second) { + by = 2; + } + for (int y = 0; y < 2; y++) { + int yy = by + y; + for (int x = 0; x < 4; x++) { + int i = x + 4 * yy; + if (inMask & (1 << i)) { + const etc1_byte* p = pIn + i * 3; + r += *(p++); + g += *(p++); + b += *(p++); + } + } + } + } else { + int bx = 0; + if (second) { + bx = 2; + } + for (int y = 0; y < 4; y++) { + for (int x = 0; x < 2; x++) { + int xx = bx + x; + int i = xx + 4 * y; + if (inMask & (1 << i)) { + const etc1_byte* p = pIn + i * 3; + r += *(p++); + g += *(p++); + b += *(p++); + } + } + } + } + pColors[0] = (etc1_byte)((r + 4) >> 3); + pColors[1] = (etc1_byte)((g + 4) >> 3); + pColors[2] = (etc1_byte)((b + 4) >> 3); +} + +static +inline int square(int x) { + return x * x; +} + +static etc1_uint32 chooseModifier(const etc1_byte* pBaseColors, + const etc1_byte* pIn, etc1_uint32 *pLow, int bitIndex, + const int* pModifierTable) { + etc1_uint32 bestScore = ~0; + int bestIndex = 0; + int pixelR = pIn[0]; + int pixelG = pIn[1]; + int pixelB = pIn[2]; + int r = pBaseColors[0]; + int g = pBaseColors[1]; + int b = pBaseColors[2]; + etc1_uint32 lowMask; + for (int i = 0; i < 4; i++) { + int modifier = pModifierTable[i]; + int decodedR, decodedG, decodedB; + etc1_uint32 score; + decodedG = clamp(g + modifier); + score = (etc1_uint32) (6 * square(decodedG - pixelG)); + if (score >= bestScore) { + continue; + } + decodedR = clamp(r + modifier); + score += (etc1_uint32) (3 * square(decodedR - pixelR)); + if (score >= bestScore) { + continue; + } + decodedB = clamp(b + modifier); + score += (etc1_uint32) square(decodedB - pixelB); + if (score < bestScore) { + bestScore = score; + bestIndex = i; + } + } + lowMask = (((bestIndex >> 1) << 16) | (bestIndex & 1)) + << bitIndex; + *pLow |= lowMask; + return bestScore; +} + +static +void etc_encode_subblock_helper(const etc1_byte* pIn, etc1_uint32 inMask, + etc_compressed* pCompressed, int flipped, int second, + const etc1_byte* pBaseColors, const int* pModifierTable) { + int score = pCompressed->score; + if (flipped) { + int by = 0; + if (second) { + by = 2; + } + for (int y = 0; y < 2; y++) { + int yy = by + y; + for (int x = 0; x < 4; x++) { + int i = x + 4 * yy; + if (inMask & (1 << i)) { + score += chooseModifier(pBaseColors, pIn + i * 3, + &pCompressed->low, yy + x * 4, pModifierTable); + } + } + } + } else { + int bx = 0; + if (second) { + bx = 2; + } + for (int y = 0; y < 4; y++) { + for (int x = 0; x < 2; x++) { + int xx = bx + x; + int i = xx + 4 * y; + if (inMask & (1 << i)) { + score += chooseModifier(pBaseColors, pIn + i * 3, + &pCompressed->low, y + xx * 4, pModifierTable); + } + } + } + } + pCompressed->score = score; +} + +static int inRange4bitSigned(int color) { + return color >= -4 && color <= 3; +} + +static void etc_encodeBaseColors(etc1_byte* pBaseColors, + const etc1_byte* pColors, etc_compressed* pCompressed) { + int r1, g1, b1, r2, g2, b2; // 8 bit base colors for sub-blocks + int differential; + { + int r51 = convert8To5(pColors[0]); + int g51 = convert8To5(pColors[1]); + int b51 = convert8To5(pColors[2]); + int r52 = convert8To5(pColors[3]); + int g52 = convert8To5(pColors[4]); + int b52 = convert8To5(pColors[5]); + int dr, dg, db; + + r1 = convert5To8(r51); + g1 = convert5To8(g51); + b1 = convert5To8(b51); + + dr = r52 - r51; + dg = g52 - g51; + db = b52 - b51; + + differential = inRange4bitSigned(dr) && inRange4bitSigned(dg) + && inRange4bitSigned(db); + if (differential) { + r2 = convert5To8(r51 + dr); + g2 = convert5To8(g51 + dg); + b2 = convert5To8(b51 + db); + pCompressed->high |= (r51 << 27) | ((7 & dr) << 24) | (g51 << 19) + | ((7 & dg) << 16) | (b51 << 11) | ((7 & db) << 8) | 2; + } + } + + if (!differential) { + int r41 = convert8To4(pColors[0]); + int g41 = convert8To4(pColors[1]); + int b41 = convert8To4(pColors[2]); + int r42 = convert8To4(pColors[3]); + int g42 = convert8To4(pColors[4]); + int b42 = convert8To4(pColors[5]); + r1 = convert4To8(r41); + g1 = convert4To8(g41); + b1 = convert4To8(b41); + r2 = convert4To8(r42); + g2 = convert4To8(g42); + b2 = convert4To8(b42); + pCompressed->high |= (r41 << 28) | (r42 << 24) | (g41 << 20) | (g42 + << 16) | (b41 << 12) | (b42 << 8); + } + pBaseColors[0] = r1; + pBaseColors[1] = g1; + pBaseColors[2] = b1; + pBaseColors[3] = r2; + pBaseColors[4] = g2; + pBaseColors[5] = b2; +} + +static +void etc_encode_block_helper(const etc1_byte* pIn, etc1_uint32 inMask, + const etc1_byte* pColors, etc_compressed* pCompressed, int flipped) { + etc1_byte pBaseColors[6]; + int originalHigh; + const int* pModifierTable; + etc_compressed firstHalf; + + pCompressed->score = ~0; + pCompressed->high = (flipped ? 1 : 0); + pCompressed->low = 0; + + etc_encodeBaseColors(pBaseColors, pColors, pCompressed); + + originalHigh = pCompressed->high; + + pModifierTable = kModifierTable; + for (int i = 0; i < 8; i++, pModifierTable += 4) { + etc_compressed temp; + temp.score = 0; + temp.high = originalHigh | (i << 5); + temp.low = 0; + etc_encode_subblock_helper(pIn, inMask, &temp, flipped, 0, + pBaseColors, pModifierTable); + take_best(pCompressed, &temp); + } + pModifierTable = kModifierTable; + firstHalf = *pCompressed; + for (int i = 0; i < 8; i++, pModifierTable += 4) { + etc_compressed temp; + temp.score = firstHalf.score; + temp.high = firstHalf.high | (i << 2); + temp.low = firstHalf.low; + etc_encode_subblock_helper(pIn, inMask, &temp, flipped, 1, + pBaseColors + 3, pModifierTable); + if (i == 0) { + *pCompressed = temp; + } else { + take_best(pCompressed, &temp); + } + } +} + +static void writeBigEndian(etc1_byte* pOut, etc1_uint32 d) { + pOut[0] = (etc1_byte)(d >> 24); + pOut[1] = (etc1_byte)(d >> 16); + pOut[2] = (etc1_byte)(d >> 8); + pOut[3] = (etc1_byte) d; +} + +// Input is a 4 x 4 square of 3-byte pixels in form R, G, B +// inmask is a 16-bit mask where bit (1 << (x + y * 4)) tells whether the corresponding (x,y) +// pixel is valid or not. Invalid pixel color values are ignored when compressing. +// Output is an ETC1 compressed version of the data. + +void etc1_encode_block(const etc1_byte* pIn, etc1_uint32 inMask, + etc1_byte* pOut) { + etc1_byte colors[6]; + etc1_byte flippedColors[6]; + etc_compressed a, b; + etc_average_colors_subblock(pIn, inMask, colors, 0, 0); + etc_average_colors_subblock(pIn, inMask, colors + 3, 0, 1); + etc_average_colors_subblock(pIn, inMask, flippedColors, 1, 0); + etc_average_colors_subblock(pIn, inMask, flippedColors + 3, 1, 1); + + etc_encode_block_helper(pIn, inMask, colors, &a, 0); + etc_encode_block_helper(pIn, inMask, flippedColors, &b, 1); + take_best(&a, &b); + writeBigEndian(pOut, a.high); + writeBigEndian(pOut + 4, a.low); +} + +// Return the size of the encoded image data (does not include size of PKM header). + +etc1_uint32 etc1_get_encoded_data_size(etc1_uint32 width, etc1_uint32 height) { + return (((width + 3) & ~3) * ((height + 3) & ~3)) >> 1; +} + +// Encode an entire image. +// pIn - pointer to the image data. Formatted such that the Red component of +// pixel (x,y) is at pIn + pixelSize * x + stride * y + redOffset; +// pOut - pointer to encoded data. Must be large enough to store entire encoded image. + +int etc1_encode_image(const etc1_byte* pIn, etc1_uint32 width, etc1_uint32 height, + etc1_uint32 pixelSize, etc1_uint32 stride, etc1_byte* pOut) { + static const unsigned short kYMask[] = { 0x0, 0xf, 0xff, 0xfff, 0xffff }; + static const unsigned short kXMask[] = { 0x0, 0x1111, 0x3333, 0x7777, + 0xffff }; + etc1_byte block[ETC1_DECODED_BLOCK_SIZE]; + etc1_byte encoded[ETC1_ENCODED_BLOCK_SIZE]; + etc1_uint32 encodedWidth = (width + 3) & ~3; + etc1_uint32 encodedHeight = (height + 3) & ~3; + + if (pixelSize < 2 || pixelSize > 3) { + return -1; + } + + for (etc1_uint32 y = 0; y < encodedHeight; y += 4) { + etc1_uint32 yEnd = height - y; + int ymask; + if (yEnd > 4) { + yEnd = 4; + } + ymask = kYMask[yEnd]; + for (etc1_uint32 x = 0; x < encodedWidth; x += 4) { + etc1_uint32 xEnd = width - x; + int mask; + if (xEnd > 4) { + xEnd = 4; + } + mask = ymask & kXMask[xEnd]; + for (etc1_uint32 cy = 0; cy < yEnd; cy++) { + etc1_byte* q = block + (cy * 4) * 3; + const etc1_byte* p = pIn + pixelSize * x + stride * (y + cy); + if (pixelSize == 3) { + memcpy(q, p, xEnd * 3); + } else { + for (etc1_uint32 cx = 0; cx < xEnd; cx++) { + int pixel = (p[1] << 8) | p[0]; + *q++ = convert5To8(pixel >> 11); + *q++ = convert6To8(pixel >> 5); + *q++ = convert5To8(pixel); + p += pixelSize; + } + } + } + etc1_encode_block(block, mask, encoded); + memcpy(pOut, encoded, sizeof(encoded)); + pOut += sizeof(encoded); + } + } + return 0; +} + +// Decode an entire image. +// pIn - pointer to encoded data. +// pOut - pointer to the image data. Will be written such that the Red component of +// pixel (x,y) is at pIn + pixelSize * x + stride * y + redOffset. Must be +// large enough to store entire image. + + +int etc1_decode_image(const etc1_byte* pIn, etc1_byte* pOut, + etc1_uint32 width, etc1_uint32 height, + etc1_uint32 pixelSize, etc1_uint32 stride) { + etc1_byte block[ETC1_DECODED_BLOCK_SIZE]; + etc1_uint32 encodedWidth = (width + 3) & ~3; + etc1_uint32 encodedHeight = (height + 3) & ~3; + + if (pixelSize < 2 || pixelSize > 3) { + return -1; + } + + for (etc1_uint32 y = 0; y < encodedHeight; y += 4) { + etc1_uint32 yEnd = height - y; + if (yEnd > 4) { + yEnd = 4; + } + for (etc1_uint32 x = 0; x < encodedWidth; x += 4) { + etc1_uint32 xEnd = width - x; + if (xEnd > 4) { + xEnd = 4; + } + etc1_decode_block(pIn, block); + pIn += ETC1_ENCODED_BLOCK_SIZE; + for (etc1_uint32 cy = 0; cy < yEnd; cy++) { + const etc1_byte* q = block + (cy * 4) * 3; + etc1_byte* p = pOut + pixelSize * x + stride * (y + cy); + if (pixelSize == 3) { + memcpy(p, q, xEnd * 3); + } else { + for (etc1_uint32 cx = 0; cx < xEnd; cx++) { + etc1_byte r = *q++; + etc1_byte g = *q++; + etc1_byte b = *q++; + etc1_uint32 pixel = ((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3); + *p++ = (etc1_byte) pixel; + *p++ = (etc1_byte) (pixel >> 8); + } + } + } + } + } + return 0; +} + +static const char kMagic[] = { 'P', 'K', 'M', ' ', '1', '0' }; + +static const etc1_uint32 ETC1_PKM_FORMAT_OFFSET = 6; +static const etc1_uint32 ETC1_PKM_ENCODED_WIDTH_OFFSET = 8; +static const etc1_uint32 ETC1_PKM_ENCODED_HEIGHT_OFFSET = 10; +static const etc1_uint32 ETC1_PKM_WIDTH_OFFSET = 12; +static const etc1_uint32 ETC1_PKM_HEIGHT_OFFSET = 14; + +static const etc1_uint32 ETC1_RGB_NO_MIPMAPS = 0; + +static void writeBEUint16(etc1_byte* pOut, etc1_uint32 data) { + pOut[0] = (etc1_byte) (data >> 8); + pOut[1] = (etc1_byte) data; +} + +static etc1_uint32 readBEUint16(const etc1_byte* pIn) { + return (pIn[0] << 8) | pIn[1]; +} + +// Format a PKM header + +void etc1_pkm_format_header(etc1_byte* pHeader, etc1_uint32 width, etc1_uint32 height) { + etc1_uint32 encodedWidth; + etc1_uint32 encodedHeight; + + memcpy(pHeader, kMagic, sizeof(kMagic)); + encodedWidth = (width + 3) & ~3; + encodedHeight = (height + 3) & ~3; + writeBEUint16(pHeader + ETC1_PKM_FORMAT_OFFSET, ETC1_RGB_NO_MIPMAPS); + writeBEUint16(pHeader + ETC1_PKM_ENCODED_WIDTH_OFFSET, encodedWidth); + writeBEUint16(pHeader + ETC1_PKM_ENCODED_HEIGHT_OFFSET, encodedHeight); + writeBEUint16(pHeader + ETC1_PKM_WIDTH_OFFSET, width); + writeBEUint16(pHeader + ETC1_PKM_HEIGHT_OFFSET, height); +} + +// Check if a PKM header is correctly formatted. + +etc1_bool etc1_pkm_is_valid(const etc1_byte* pHeader) { + etc1_uint32 format; + etc1_uint32 encodedWidth; + etc1_uint32 encodedHeight; + etc1_uint32 width; + etc1_uint32 height; + + if (memcmp(pHeader, kMagic, sizeof(kMagic))) { + return 0; + } + format = readBEUint16(pHeader + ETC1_PKM_FORMAT_OFFSET); + encodedWidth = readBEUint16(pHeader + ETC1_PKM_ENCODED_WIDTH_OFFSET); + encodedHeight = readBEUint16(pHeader + ETC1_PKM_ENCODED_HEIGHT_OFFSET); + width = readBEUint16(pHeader + ETC1_PKM_WIDTH_OFFSET); + height = readBEUint16(pHeader + ETC1_PKM_HEIGHT_OFFSET); + return format == ETC1_RGB_NO_MIPMAPS && + encodedWidth >= width && encodedWidth - width < 4 && + encodedHeight >= height && encodedHeight - height < 4; +} + +// Read the image width from a PKM header + +etc1_uint32 etc1_pkm_get_width(const etc1_byte* pHeader) { + return readBEUint16(pHeader + ETC1_PKM_WIDTH_OFFSET); +} + +// Read the image height from a PKM header + +etc1_uint32 etc1_pkm_get_height(const etc1_byte* pHeader){ + return readBEUint16(pHeader + ETC1_PKM_HEIGHT_OFFSET); +} diff --git a/libavcodec/etc1.h b/libavcodec/etc1.h new file mode 100644 index 0000000..d66ca9d --- /dev/null +++ b/libavcodec/etc1.h @@ -0,0 +1,114 @@ +// Copyright 2009 Google Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +////////////////////////////////////////////////////////////////////////////////////////// + +// This is a fork of the AOSP project ETC1 codec. The original code can be found +// at the following web site: +// https://android.googlesource.com/platform/frameworks/native/+/master/opengl/libs/ETC1/ + +////////////////////////////////////////////////////////////////////////////////////////// + +#ifndef __etc1_h__ +#define __etc1_h__ + +#define ETC1_ENCODED_BLOCK_SIZE 8 +#define ETC1_DECODED_BLOCK_SIZE 48 + +#ifndef ETC1_RGB8_OES +#define ETC1_RGB8_OES 0x8D64 +#endif + +typedef unsigned char etc1_byte; +typedef int etc1_bool; +typedef unsigned int etc1_uint32; + +#ifdef __cplusplus +extern "C" { +#endif + +// Encode a block of pixels. +// +// pIn is a pointer to a ETC_DECODED_BLOCK_SIZE array of bytes that represent a +// 4 x 4 square of 3-byte pixels in form R, G, B. Byte (3 * (x + 4 * y) is the R +// value of pixel (x, y). +// +// validPixelMask is a 16-bit mask where bit (1 << (x + y * 4)) indicates whether +// the corresponding (x,y) pixel is valid. Invalid pixel color values are ignored when compressing. +// +// pOut is an ETC1 compressed version of the data. + +void etc1_encode_block(const etc1_byte* pIn, etc1_uint32 validPixelMask, etc1_byte* pOut); + +// Decode a block of pixels. +// +// pIn is an ETC1 compressed version of the data. +// +// pOut is a pointer to a ETC_DECODED_BLOCK_SIZE array of bytes that represent a +// 4 x 4 square of 3-byte pixels in form R, G, B. Byte (3 * (x + 4 * y) is the R +// value of pixel (x, y). + +void etc1_decode_block(const etc1_byte* pIn, etc1_byte* pOut); + +// Return the size of the encoded image data (does not include size of PKM header). + +etc1_uint32 etc1_get_encoded_data_size(etc1_uint32 width, etc1_uint32 height); + +// Encode an entire image. +// pIn - pointer to the image data. Formatted such that +// pixel (x,y) is at pIn + pixelSize * x + stride * y; +// pOut - pointer to encoded data. Must be large enough to store entire encoded image. +// pixelSize can be 2 or 3. 2 is an GL_UNSIGNED_SHORT_5_6_5 image, 3 is a GL_BYTE RGB image. +// returns non-zero if there is an error. + +int etc1_encode_image(const etc1_byte* pIn, etc1_uint32 width, etc1_uint32 height, + etc1_uint32 pixelSize, etc1_uint32 stride, etc1_byte* pOut); + +// Decode an entire image. +// pIn - pointer to encoded data. +// pOut - pointer to the image data. Will be written such that +// pixel (x,y) is at pIn + pixelSize * x + stride * y. Must be +// large enough to store entire image. +// pixelSize can be 2 or 3. 2 is an GL_UNSIGNED_SHORT_5_6_5 image, 3 is a GL_BYTE RGB image. +// returns non-zero if there is an error. + +int etc1_decode_image(const etc1_byte* pIn, etc1_byte* pOut, + etc1_uint32 width, etc1_uint32 height, + etc1_uint32 pixelSize, etc1_uint32 stride); + +// Size of a PKM header, in bytes. + +#define ETC_PKM_HEADER_SIZE 16 + +// Format a PKM header + +void etc1_pkm_format_header(etc1_byte* pHeader, etc1_uint32 width, etc1_uint32 height); + +// Check if a PKM header is correctly formatted. + +etc1_bool etc1_pkm_is_valid(const etc1_byte* pHeader); + +// Read the image width from a PKM header + +etc1_uint32 etc1_pkm_get_width(const etc1_byte* pHeader); + +// Read the image height from a PKM header + +etc1_uint32 etc1_pkm_get_height(const etc1_byte* pHeader); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/libavcodec/etc1dec.c b/libavcodec/etc1dec.c new file mode 100644 index 0000000..72151cd --- /dev/null +++ b/libavcodec/etc1dec.c @@ -0,0 +1,81 @@ +/* + * ETC1 image format + * Copyright (c) 2017 Devin Heitmueller + * + * This file is part of FFmpeg. + * + * 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 "avcodec.h" +#include "internal.h" +#include "etc1.h" + +static int decode_frame(AVCodecContext *avctx, + void *data, int *got_frame, + AVPacket *avpkt) +{ + const uint8_t *buf = avpkt->data; + AVFrame *p = data; + int ret; + + /* check signature */ + if (avpkt->size < ETC_PKM_HEADER_SIZE) { + av_log(avctx, AV_LOG_ERROR, "Not enough data %d\n", + avpkt->size); + return AVERROR_INVALIDDATA; + } + + if (etc1_pkm_is_valid(buf) == 0) { + av_log(avctx, AV_LOG_ERROR, "PKM header invalid\n"); + return AVERROR_INVALIDDATA; + } + + avctx->pix_fmt = AV_PIX_FMT_RGB24; + avctx->width = etc1_pkm_get_width(buf); + avctx->height = etc1_pkm_get_height(buf); + + if (ff_get_buffer(avctx, p, AV_GET_BUFFER_FLAG_REF) < 0) { + av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); + goto fail; + } + + p->pict_type = AV_PICTURE_TYPE_I; + p->key_frame = 1; + p->interlaced_frame = 0; + + ret = etc1_decode_image(buf + ETC_PKM_HEADER_SIZE, p->data[0], + avctx->width, avctx->height, 3, p->linesize[0]); + if (ret != 0) { + av_log(avctx, AV_LOG_ERROR, "ETC1 decode failure: %d\n", ret); + return AVERROR_INVALIDDATA; + } + *got_frame = 1; + +the_end: + return ret; +fail: + ret = -1; + goto the_end; +} + +AVCodec ff_etc1_decoder = { + .name = "etc1", + .long_name = NULL_IF_CONFIG_SMALL("ETC1 (Ericsson Texture Compression) image"), + .type = AVMEDIA_TYPE_VIDEO, + .id = AV_CODEC_ID_ETC1, + .decode = decode_frame, + .capabilities = AV_CODEC_CAP_DR1, +}; diff --git a/libavcodec/etc1enc.c b/libavcodec/etc1enc.c new file mode 100644 index 0000000..f40b363 --- /dev/null +++ b/libavcodec/etc1enc.c @@ -0,0 +1,90 @@ +/* + * ETC1 image format + * Copyright (c) 2017 Devin Heitmueller + * + * This file is part of FFmpeg. + * + * 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 "avcodec.h" +#include "etc1.h" + +static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, + const AVFrame *pict, int *got_packet) +{ + const AVFrame *const p = pict; + int max_packet_size, ret; + + /* ETC1 has a well-defined compressed output size */ + max_packet_size = etc1_get_encoded_data_size(p->width, p->height) + ETC_PKM_HEADER_SIZE; + + if (!pkt->data && + (ret = av_new_packet(pkt, max_packet_size)) < 0) { + av_log(avctx, AV_LOG_ERROR, "Could not allocate output packet of size %d.\n", + max_packet_size); + return ret; + } + pkt->size = max_packet_size; + + etc1_pkm_format_header(pkt->data, p->width, p->height); + + /* For the moment only support RGB24 (i.e. pixelsize=3) */ + ret = etc1_encode_image(p->data[0], p->width, p->height, 3, p->linesize[0], + pkt->data + ETC_PKM_HEADER_SIZE); + if (ret != 0) { + av_log(avctx, AV_LOG_ERROR, "Encode failure error=%d.\n", ret); + goto fail; + } + + pkt->flags |= AV_PKT_FLAG_KEY; + *got_packet = 1; + +the_end: + return ret; +fail: + ret = -1; + goto the_end; +} + +static av_cold int etc1_enc_init(AVCodecContext *avctx) +{ +#if FF_API_CODED_FRAME +FF_DISABLE_DEPRECATION_WARNINGS + avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I; + avctx->coded_frame->key_frame = 1; +FF_ENABLE_DEPRECATION_WARNINGS +#endif + return 0; +} + +static const AVClass etc1_class = { + .class_name = "etc1", + .item_name = av_default_item_name, + .version = LIBAVUTIL_VERSION_INT, +}; + +AVCodec ff_etc1_encoder = { + .name = "etc1", + .long_name = NULL_IF_CONFIG_SMALL("ETC1 (Ericsson Texture Compression) image"), + .type = AVMEDIA_TYPE_VIDEO, + .id = AV_CODEC_ID_ETC1, + .priv_class = &etc1_class, + .init = etc1_enc_init, + .encode2 = encode_frame, + .pix_fmts = (const enum AVPixelFormat[]) { + AV_PIX_FMT_RGB24, AV_PIX_FMT_NONE + }, +}; diff --git a/libavcodec/utils.c b/libavcodec/utils.c index f4085bf..6bf751d 100644 --- a/libavcodec/utils.c +++ b/libavcodec/utils.c @@ -397,7 +397,8 @@ void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height, break; case AV_PIX_FMT_BGR24: if ((s->codec_id == AV_CODEC_ID_MSZH) || - (s->codec_id == AV_CODEC_ID_ZLIB)) { + (s->codec_id == AV_CODEC_ID_ZLIB) || + (s->codec_id == AV_CODEC_ID_ETC1)) { w_align = 4; h_align = 4; } diff --git a/libavformat/img2.c b/libavformat/img2.c index f9f53ff..e6e061a 100644 --- a/libavformat/img2.c +++ b/libavformat/img2.c @@ -77,6 +77,7 @@ const IdStrMap ff_img_tags[] = { { AV_CODEC_ID_XBM, "xbm" }, { AV_CODEC_ID_XFACE, "xface" }, { AV_CODEC_ID_XWD, "xwd" }, + { AV_CODEC_ID_ETC1, "pkm" }, { AV_CODEC_ID_NONE, NULL } }; diff --git a/libavformat/img2enc.c b/libavformat/img2enc.c index 1297b1a..5a254c1 100644 --- a/libavformat/img2enc.c +++ b/libavformat/img2enc.c @@ -221,7 +221,7 @@ static const AVClass img2mux_class = { AVOutputFormat ff_image2_muxer = { .name = "image2", .long_name = NULL_IF_CONFIG_SMALL("image2 sequence"), - .extensions = "bmp,dpx,jls,jpeg,jpg,ljpg,pam,pbm,pcx,pgm,pgmyuv,png," + .extensions = "bmp,dpx,jls,jpeg,jpg,ljpg,pam,pbm,pcx,pgm,pgmyuv,png,pkm," "ppm,sgi,tga,tif,tiff,jp2,j2c,j2k,xwd,sun,ras,rs,im1,im8,im24," "sunras,xbm,xface,pix,y", .priv_data_size = sizeof(VideoMuxData),