falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
44689 Commits
32 Branches
824MB
Tree: c5714b51aa
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'c5714b51aa'
${ noResults }
FFmpeg/libavcodec/escape130.c

358 lines
10KB
Raw Blame History 

  1. /*

  2.  * Escape 130 video decoder

  3.  * Copyright (C) 2008 Eli Friedman (eli.friedman <at> gmail.com)

  4.  *

  5.  * This file is part of Libav.

  6.  *

  7.  * Libav is free software; you can redistribute it and/or

  8.  * modify it under the terms of the GNU Lesser General Public

  9.  * License as published by the Free Software Foundation; either

  10.  * version 2.1 of the License, or (at your option) any later version.

  11.  *

  12.  * Libav is distributed in the hope that it will be useful,

  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  15.  * Lesser General Public License for more details.

  16.  *

  17.  * You should have received a copy of the GNU Lesser General Public

  18.  * License along with Libav; if not, write to the Free Software

  19.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  20.  */

  21. 

  22. #include "libavutil/attributes.h"

  23. #include "libavutil/mem.h"

  24. 

  25. #define BITSTREAM_READER_LE

  26. #include "avcodec.h"

  27. #include "bitstream.h"

  28. #include "internal.h"

  29. 

  30. typedef struct Escape130Context {

  31.     uint8_t *old_y_avg;

  32. 

  33.     uint8_t *new_y, *old_y;

  34.     uint8_t *new_u, *old_u;

  35.     uint8_t *new_v, *old_v;

  36. 

  37.     uint8_t *buf1, *buf2;

  38.     int     linesize[3];

  39. } Escape130Context;

  40. 

  41. static const uint8_t offset_table[] = { 2, 4, 10, 20 };

  42. static const int8_t sign_table[64][4] = {

  43.     {  0,  0,  0,  0 },

  44.     { -1,  1,  0,  0 },

  45.     {  1, -1,  0,  0 },

  46.     { -1,  0,  1,  0 },

  47.     { -1,  1,  1,  0 },

  48.     {  0, -1,  1,  0 },

  49.     {  1, -1,  1,  0 },

  50.     { -1, -1,  1,  0 },

  51.     {  1,  0, -1,  0 },

  52.     {  0,  1, -1,  0 },

  53.     {  1,  1, -1,  0 },

  54.     { -1,  1, -1,  0 },

  55.     {  1, -1, -1,  0 },

  56.     { -1,  0,  0,  1 },

  57.     { -1,  1,  0,  1 },

  58.     {  0, -1,  0,  1 },

  59. 

  60.     {  0,  0,  0,  0 },

  61.     {  1, -1,  0,  1 },

  62.     { -1, -1,  0,  1 },

  63.     { -1,  0,  1,  1 },

  64.     { -1,  1,  1,  1 },

  65.     {  0, -1,  1,  1 },

  66.     {  1, -1,  1,  1 },

  67.     { -1, -1,  1,  1 },

  68.     {  0,  0, -1,  1 },

  69.     {  1,  0, -1,  1 },

  70.     { -1,  0, -1,  1 },

  71.     {  0,  1, -1,  1 },

  72.     {  1,  1, -1,  1 },

  73.     { -1,  1, -1,  1 },

  74.     {  0, -1, -1,  1 },

  75.     {  1, -1, -1,  1 },

  76. 

  77.     {  0,  0,  0,  0 },

  78.     { -1, -1, -1,  1 },

  79.     {  1,  0,  0, -1 },

  80.     {  0,  1,  0, -1 },

  81.     {  1,  1,  0, -1 },

  82.     { -1,  1,  0, -1 },

  83.     {  1, -1,  0, -1 },

  84.     {  0,  0,  1, -1 },

  85.     {  1,  0,  1, -1 },

  86.     { -1,  0,  1, -1 },

  87.     {  0,  1,  1, -1 },

  88.     {  1,  1,  1, -1 },

  89.     { -1,  1,  1, -1 },

  90.     {  0, -1,  1, -1 },

  91.     {  1, -1,  1, -1 },

  92.     { -1, -1,  1, -1 },

  93. 

  94.     {  0,  0,  0,  0 },

  95.     {  1,  0, -1, -1 },

  96.     {  0,  1, -1, -1 },

  97.     {  1,  1, -1, -1 },

  98.     { -1,  1, -1, -1 },

  99.     {  1, -1, -1, -1 }

  100. };

  101. 

  102. static const int8_t luma_adjust[] = { -4, -3, -2, -1, 1, 2, 3, 4 };

  103. 

  104. static const int8_t chroma_adjust[2][8] = {

  105.     { 1, 1, 0, -1, -1, -1,  0,  1 },

  106.     { 0, 1, 1,  1,  0, -1, -1, -1 }

  107. };

  108. 

  109. static const uint8_t chroma_vals[] = {

  110.      20,  28,  36,  44,  52,  60,  68,  76,

  111.      84,  92, 100, 106, 112, 116, 120, 124,

  112.     128, 132, 136, 140, 144, 150, 156, 164,

  113.     172, 180, 188, 196, 204, 212, 220, 228

  114. };

  115. 

  116. static av_cold int escape130_decode_init(AVCodecContext *avctx)

  117. {

  118.     Escape130Context *s = avctx->priv_data;

  119.     avctx->pix_fmt = AV_PIX_FMT_YUV420P;

  120. 

  121.     if ((avctx->width & 1) || (avctx->height & 1)) {

  122.         av_log(avctx, AV_LOG_ERROR,

  123.                "Dimensions should be a multiple of two.\n");

  124.         return AVERROR_INVALIDDATA;

  125.     }

  126. 

  127.     s->old_y_avg = av_malloc(avctx->width * avctx->height / 4);

  128.     s->buf1      = av_malloc(avctx->width * avctx->height * 3 / 2);

  129.     s->buf2      = av_malloc(avctx->width * avctx->height * 3 / 2);

  130.     if (!s->old_y_avg || !s->buf1 || !s->buf2) {

  131.         av_freep(&s->old_y_avg);

  132.         av_freep(&s->buf1);

  133.         av_freep(&s->buf2);

  134.         av_log(avctx, AV_LOG_ERROR, "Could not allocate buffer.\n");

  135.         return AVERROR(ENOMEM);

  136.     }

  137. 

  138.     s->linesize[0] = avctx->width;

  139.     s->linesize[1] =

  140.     s->linesize[2] = avctx->width / 2;

  141. 

  142.     s->new_y = s->buf1;

  143.     s->new_u = s->new_y + avctx->width * avctx->height;

  144.     s->new_v = s->new_u + avctx->width * avctx->height / 4;

  145.     s->old_y = s->buf2;

  146.     s->old_u = s->old_y + avctx->width * avctx->height;

  147.     s->old_v = s->old_u + avctx->width * avctx->height / 4;

  148.     memset(s->old_y, 0,    avctx->width * avctx->height);

  149.     memset(s->old_u, 0x10, avctx->width * avctx->height / 4);

  150.     memset(s->old_v, 0x10, avctx->width * avctx->height / 4);

  151. 

  152.     return 0;

  153. }

  154. 

  155. static av_cold int escape130_decode_close(AVCodecContext *avctx)

  156. {

  157.     Escape130Context *s = avctx->priv_data;

  158. 

  159.     av_freep(&s->old_y_avg);

  160.     av_freep(&s->buf1);

  161.     av_freep(&s->buf2);

  162. 

  163.     return 0;

  164. }

  165. 

  166. static int decode_skip_count(BitstreamContext *bc)

  167. {

  168.     int value;

  169. 

  170.     value = bitstream_read_bit(bc);

  171.     if (value)

  172.         return 0;

  173. 

  174.     value = bitstream_read(bc, 3);

  175.     if (value)

  176.         return value;

  177. 

  178.     value = bitstream_read(bc, 8);

  179.     if (value)

  180.         return value + 7;

  181. 

  182.     value = bitstream_read(bc, 15);

  183.     if (value)

  184.         return value + 262;

  185. 

  186.     return -1;

  187. }

  188. 

  189. static int escape130_decode_frame(AVCodecContext *avctx, void *data,

  190.                                   int *got_frame, AVPacket *avpkt)

  191. {

  192.     const uint8_t *buf  = avpkt->data;

  193.     int buf_size        = avpkt->size;

  194.     Escape130Context *s = avctx->priv_data;

  195.     AVFrame *pic        = data;

  196.     BitstreamContext bc;

  197.     int ret;

  198. 

  199.     uint8_t *old_y, *old_cb, *old_cr,

  200.             *new_y, *new_cb, *new_cr;

  201.     uint8_t *dstY, *dstU, *dstV;

  202.     unsigned old_y_stride, old_cb_stride, old_cr_stride,

  203.              new_y_stride, new_cb_stride, new_cr_stride;

  204.     unsigned total_blocks = avctx->width * avctx->height / 4,

  205.              block_index, block_x = 0;

  206.     unsigned y[4] = { 0 }, cb = 0x10, cr = 0x10;

  207.     int skip = -1, y_avg = 0, i, j;

  208.     uint8_t *ya = s->old_y_avg;

  209. 

  210.     // first 16 bytes are header; no useful information in here

  211.     if (buf_size <= 16) {

  212.         av_log(avctx, AV_LOG_ERROR, "Insufficient frame data\n");

  213.         return AVERROR_INVALIDDATA;

  214.     }

  215. 

  216.     if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)

  217.         return ret;

  218. 

  219.     bitstream_init8(&bc, buf + 16, buf_size - 16);

  220. 

  221.     new_y  = s->new_y;

  222.     new_cb = s->new_u;

  223.     new_cr = s->new_v;

  224.     new_y_stride  = s->linesize[0];

  225.     new_cb_stride = s->linesize[1];

  226.     new_cr_stride = s->linesize[2];

  227.     old_y  = s->old_y;

  228.     old_cb = s->old_u;

  229.     old_cr = s->old_v;

  230.     old_y_stride  = s->linesize[0];

  231.     old_cb_stride = s->linesize[1];

  232.     old_cr_stride = s->linesize[2];

  233. 

  234.     for (block_index = 0; block_index < total_blocks; block_index++) {

  235.         // Note that this call will make us skip the rest of the blocks

  236.         // if the frame ends prematurely.

  237.         if (skip == -1)

  238.             skip = decode_skip_count(&bc);

  239.         if (skip == -1) {

  240.             av_log(avctx, AV_LOG_ERROR, "Error decoding skip value\n");

  241.             return AVERROR_INVALIDDATA;

  242.         }

  243. 

  244.         if (skip) {

  245.             y[0] = old_y[0];

  246.             y[1] = old_y[1];

  247.             y[2] = old_y[old_y_stride];

  248.             y[3] = old_y[old_y_stride + 1];

  249.             y_avg = ya[0];

  250.             cb = old_cb[0];

  251.             cr = old_cr[0];

  252.         } else {

  253.             if (bitstream_read_bit(&bc)) {

  254.                 unsigned sign_selector       = bitstream_read(&bc, 6);

  255.                 unsigned difference_selector = bitstream_read(&bc, 2);

  256.                 y_avg = 2 * bitstream_read(&bc, 5);

  257.                 for (i = 0; i < 4; i++) {

  258.                     y[i] = av_clip(y_avg + offset_table[difference_selector] *

  259.                                    sign_table[sign_selector][i], 0, 63);

  260.                 }

  261.             } else if (bitstream_read_bit(&bc)) {

  262.                 if (bitstream_read_bit(&bc)) {

  263.                     y_avg = bitstream_read(&bc, 6);

  264.                 } else {

  265.                     unsigned adjust_index = bitstream_read(&bc, 3);

  266.                     y_avg = (y_avg + luma_adjust[adjust_index]) & 63;

  267.                 }

  268.                 for (i = 0; i < 4; i++)

  269.                     y[i] = y_avg;

  270.             }

  271. 

  272.             if (bitstream_read_bit(&bc)) {

  273.                 if (bitstream_read_bit(&bc)) {

  274.                     cb = bitstream_read(&bc, 5);

  275.                     cr = bitstream_read(&bc, 5);

  276.                 } else {

  277.                     unsigned adjust_index = bitstream_read(&bc, 3);

  278.                     cb = (cb + chroma_adjust[0][adjust_index]) & 31;

  279.                     cr = (cr + chroma_adjust[1][adjust_index]) & 31;

  280.                 }

  281.             }

  282.         }

  283.         *ya++ = y_avg;

  284. 

  285.         new_y[0]                = y[0];

  286.         new_y[1]                = y[1];

  287.         new_y[new_y_stride]     = y[2];

  288.         new_y[new_y_stride + 1] = y[3];

  289.         *new_cb = cb;

  290.         *new_cr = cr;

  291. 

  292.         old_y += 2;

  293.         old_cb++;

  294.         old_cr++;

  295.         new_y += 2;

  296.         new_cb++;

  297.         new_cr++;

  298.         block_x++;

  299.         if (block_x * 2 == avctx->width) {

  300.             block_x = 0;

  301.             old_y  += old_y_stride * 2  - avctx->width;

  302.             old_cb += old_cb_stride     - avctx->width / 2;

  303.             old_cr += old_cr_stride     - avctx->width / 2;

  304.             new_y  += new_y_stride * 2  - avctx->width;

  305.             new_cb += new_cb_stride     - avctx->width / 2;

  306.             new_cr += new_cr_stride     - avctx->width / 2;

  307.         }

  308. 

  309.         skip--;

  310.     }

  311. 

  312.     new_y  = s->new_y;

  313.     new_cb = s->new_u;

  314.     new_cr = s->new_v;

  315.     dstY   = pic->data[0];

  316.     dstU   = pic->data[1];

  317.     dstV   = pic->data[2];

  318.     for (j = 0; j < avctx->height; j++) {

  319.         for (i = 0; i < avctx->width; i++)

  320.             dstY[i] = new_y[i] << 2;

  321.         dstY  += pic->linesize[0];

  322.         new_y += new_y_stride;

  323.     }

  324.     for (j = 0; j < avctx->height / 2; j++) {

  325.         for (i = 0; i < avctx->width / 2; i++) {

  326.             dstU[i] = chroma_vals[new_cb[i]];

  327.             dstV[i] = chroma_vals[new_cr[i]];

  328.         }

  329.         dstU   += pic->linesize[1];

  330.         dstV   += pic->linesize[2];

  331.         new_cb += new_cb_stride;

  332.         new_cr += new_cr_stride;

  333.     }

  334. 

  335.     ff_dlog(avctx, "Frame data: provided %d bytes, used %d bytes\n",

  336.             buf_size, bitstream_tell(&bc) >> 3);

  337. 

  338.     FFSWAP(uint8_t*, s->old_y, s->new_y);

  339.     FFSWAP(uint8_t*, s->old_u, s->new_u);

  340.     FFSWAP(uint8_t*, s->old_v, s->new_v);

  341. 

  342.     *got_frame = 1;

  343. 

  344.     return buf_size;

  345. }

  346. 

  347. AVCodec ff_escape130_decoder = {

  348.     .name           = "escape130",

  349.     .long_name      = NULL_IF_CONFIG_SMALL("Escape 130"),

  350.     .type           = AVMEDIA_TYPE_VIDEO,

  351.     .id             = AV_CODEC_ID_ESCAPE130,

  352.     .priv_data_size = sizeof(Escape130Context),

  353.     .init           = escape130_decode_init,

  354.     .close          = escape130_decode_close,

  355.     .decode         = escape130_decode_frame,

  356.     .capabilities   = AV_CODEC_CAP_DR1,

  357. };