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.
100354 Commits
32 Branches
981MB
Tree: 103e8edd5e
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '103e8edd5e'
${ noResults }
FFmpeg/libavcodec/asvdec.c

357 lines
11KB
Raw Blame History 

  1. /*

  2.  * Copyright (c) 2003 Michael Niedermayer

  3.  *

  4.  * This file is part of FFmpeg.

  5.  *

  6.  * FFmpeg is free software; you can redistribute it and/or

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

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

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

  10.  *

  11.  * FFmpeg is distributed in the hope that it will be useful,

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

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

  14.  * Lesser General Public License for more details.

  15.  *

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

  17.  * License along with FFmpeg; if not, write to the Free Software

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

  19.  */

  20. 

  21. /**

  22.  * @file

  23.  * ASUS V1/V2 decoder.

  24.  */

  25. 

  26. #include "libavutil/attributes.h"

  27. #include "libavutil/mem.h"

  28. #include "libavutil/thread.h"

  29. 

  30. #include "asv.h"

  31. #include "avcodec.h"

  32. #include "blockdsp.h"

  33. #include "idctdsp.h"

  34. #include "internal.h"

  35. #include "mpeg12data.h"

  36. 

  37. #define CCP_VLC_BITS         5

  38. #define DC_CCP_VLC_BITS      4

  39. #define AC_CCP_VLC_BITS      6

  40. #define ASV1_LEVEL_VLC_BITS  4

  41. #define ASV2_LEVEL_VLC_BITS 10

  42. 

  43. static VLC ccp_vlc;

  44. static VLC level_vlc;

  45. static VLC dc_ccp_vlc;

  46. static VLC ac_ccp_vlc;

  47. static VLC asv2_level_vlc;

  48. 

  49. static av_cold void init_vlcs(void)

  50. {

  51.         INIT_VLC_STATIC(&ccp_vlc, CCP_VLC_BITS, 17,

  52.                         &ff_asv_ccp_tab[0][1], 2, 1,

  53.                         &ff_asv_ccp_tab[0][0], 2, 1, 32);

  54.         INIT_LE_VLC_STATIC(&dc_ccp_vlc, DC_CCP_VLC_BITS, 8,

  55.                            &ff_asv_dc_ccp_tab[0][1], 2, 1,

  56.                            &ff_asv_dc_ccp_tab[0][0], 2, 1, 16);

  57.         INIT_LE_VLC_STATIC(&ac_ccp_vlc, AC_CCP_VLC_BITS, 16,

  58.                            &ff_asv_ac_ccp_tab[0][1], 2, 1,

  59.                            &ff_asv_ac_ccp_tab[0][0], 2, 1, 64);

  60.         INIT_VLC_STATIC(&level_vlc,      ASV1_LEVEL_VLC_BITS, 7,

  61.                         &ff_asv_level_tab[0][1], 2, 1,

  62.                         &ff_asv_level_tab[0][0], 2, 1, 16);

  63.         INIT_LE_VLC_STATIC(&asv2_level_vlc, ASV2_LEVEL_VLC_BITS, 63,

  64.                            &ff_asv2_level_tab[0][1], 4, 2,

  65.                            &ff_asv2_level_tab[0][0], 4, 2, 1024);

  66. }

  67. 

  68. static inline int asv1_get_level(GetBitContext *gb)

  69. {

  70.     int code = get_vlc2(gb, level_vlc.table, ASV1_LEVEL_VLC_BITS, 1);

  71. 

  72.     if (code == 3)

  73.         return get_sbits(gb, 8);

  74.     else

  75.         return code - 3;

  76. }

  77. 

  78. // get_vlc2() is big-endian in this file

  79. static inline int asv2_get_vlc2(GetBitContext *gb, VLC_TYPE (*table)[2], int bits)

  80. {

  81.     unsigned int index;

  82.     int code, n;

  83. 

  84.     OPEN_READER(re, gb);

  85.     UPDATE_CACHE_LE(re, gb);

  86. 

  87.     index = SHOW_UBITS_LE(re, gb, bits);

  88.     code  = table[index][0];

  89.     n     = table[index][1];

  90.     LAST_SKIP_BITS(re, gb, n);

  91. 

  92.     CLOSE_READER(re, gb);

  93. 

  94.     return code;

  95. }

  96. 

  97. static inline int asv2_get_level(GetBitContext *gb)

  98. {

  99.     int code = asv2_get_vlc2(gb, asv2_level_vlc.table, ASV2_LEVEL_VLC_BITS);

  100. 

  101.     if (code == 31)

  102.         return (int8_t) get_bits_le(gb, 8);

  103.     else

  104.         return code - 31;

  105. }

  106. 

  107. static inline int asv1_decode_block(ASV1Context *a, int16_t block[64])

  108. {

  109.     int i;

  110. 

  111.     block[0] = 8 * get_bits(&a->gb, 8);

  112. 

  113.     for (i = 0; i < 11; i++) {

  114.         const int ccp = get_vlc2(&a->gb, ccp_vlc.table, CCP_VLC_BITS, 1);

  115. 

  116.         if (ccp) {

  117.             if (ccp == 16)

  118.                 break;

  119.             if (ccp < 0 || i >= 10) {

  120.                 av_log(a->avctx, AV_LOG_ERROR, "coded coeff pattern damaged\n");

  121.                 return AVERROR_INVALIDDATA;

  122.             }

  123. 

  124.             if (ccp & 8)

  125.                 block[a->scantable.permutated[4 * i + 0]] = (asv1_get_level(&a->gb) * a->intra_matrix[4 * i + 0]) >> 4;

  126.             if (ccp & 4)

  127.                 block[a->scantable.permutated[4 * i + 1]] = (asv1_get_level(&a->gb) * a->intra_matrix[4 * i + 1]) >> 4;

  128.             if (ccp & 2)

  129.                 block[a->scantable.permutated[4 * i + 2]] = (asv1_get_level(&a->gb) * a->intra_matrix[4 * i + 2]) >> 4;

  130.             if (ccp & 1)

  131.                 block[a->scantable.permutated[4 * i + 3]] = (asv1_get_level(&a->gb) * a->intra_matrix[4 * i + 3]) >> 4;

  132.         }

  133.     }

  134. 

  135.     return 0;

  136. }

  137. 

  138. static inline int asv2_decode_block(ASV1Context *a, int16_t block[64])

  139. {

  140.     int i, count, ccp;

  141. 

  142.     count = get_bits_le(&a->gb, 4);

  143. 

  144.     block[0] = 8 * get_bits_le(&a->gb, 8);

  145. 

  146.     ccp = asv2_get_vlc2(&a->gb, dc_ccp_vlc.table, DC_CCP_VLC_BITS);

  147.     if (ccp) {

  148.         if (ccp & 4)

  149.             block[a->scantable.permutated[1]] = (asv2_get_level(&a->gb) * a->intra_matrix[1]) >> 4;

  150.         if (ccp & 2)

  151.             block[a->scantable.permutated[2]] = (asv2_get_level(&a->gb) * a->intra_matrix[2]) >> 4;

  152.         if (ccp & 1)

  153.             block[a->scantable.permutated[3]] = (asv2_get_level(&a->gb) * a->intra_matrix[3]) >> 4;

  154.     }

  155. 

  156.     for (i = 1; i < count + 1; i++) {

  157.         const int ccp = asv2_get_vlc2(&a->gb, ac_ccp_vlc.table, AC_CCP_VLC_BITS);

  158. 

  159.         if (ccp) {

  160.             if (ccp & 8)

  161.                 block[a->scantable.permutated[4 * i + 0]] = (asv2_get_level(&a->gb) * a->intra_matrix[4 * i + 0]) >> 4;

  162.             if (ccp & 4)

  163.                 block[a->scantable.permutated[4 * i + 1]] = (asv2_get_level(&a->gb) * a->intra_matrix[4 * i + 1]) >> 4;

  164.             if (ccp & 2)

  165.                 block[a->scantable.permutated[4 * i + 2]] = (asv2_get_level(&a->gb) * a->intra_matrix[4 * i + 2]) >> 4;

  166.             if (ccp & 1)

  167.                 block[a->scantable.permutated[4 * i + 3]] = (asv2_get_level(&a->gb) * a->intra_matrix[4 * i + 3]) >> 4;

  168.         }

  169.     }

  170. 

  171.     return 0;

  172. }

  173. 

  174. static inline int decode_mb(ASV1Context *a, int16_t block[6][64])

  175. {

  176.     int i, ret;

  177. 

  178.     a->bdsp.clear_blocks(block[0]);

  179. 

  180.     if (a->avctx->codec_id == AV_CODEC_ID_ASV1) {

  181.         for (i = 0; i < 6; i++) {

  182.             if ((ret = asv1_decode_block(a, block[i])) < 0)

  183.                 return ret;

  184.         }

  185.     } else {

  186.         for (i = 0; i < 6; i++) {

  187.             if ((ret = asv2_decode_block(a, block[i])) < 0)

  188.                 return ret;

  189.         }

  190.     }

  191.     return 0;

  192. }

  193. 

  194. static inline void idct_put(ASV1Context *a, AVFrame *frame, int mb_x, int mb_y)

  195. {

  196.     int16_t(*block)[64] = a->block;

  197.     int linesize = frame->linesize[0];

  198. 

  199.     uint8_t *dest_y  = frame->data[0] + (mb_y * 16 * linesize)           + mb_x * 16;

  200.     uint8_t *dest_cb = frame->data[1] + (mb_y *  8 * frame->linesize[1]) + mb_x *  8;

  201.     uint8_t *dest_cr = frame->data[2] + (mb_y *  8 * frame->linesize[2]) + mb_x *  8;

  202. 

  203.     a->idsp.idct_put(dest_y,                    linesize, block[0]);

  204.     a->idsp.idct_put(dest_y + 8,                linesize, block[1]);

  205.     a->idsp.idct_put(dest_y + 8 * linesize,     linesize, block[2]);

  206.     a->idsp.idct_put(dest_y + 8 * linesize + 8, linesize, block[3]);

  207. 

  208.     if (!(a->avctx->flags & AV_CODEC_FLAG_GRAY)) {

  209.         a->idsp.idct_put(dest_cb, frame->linesize[1], block[4]);

  210.         a->idsp.idct_put(dest_cr, frame->linesize[2], block[5]);

  211.     }

  212. }

  213. 

  214. static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,

  215.                         AVPacket *avpkt)

  216. {

  217.     ASV1Context *const a = avctx->priv_data;

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

  219.     int buf_size       = avpkt->size;

  220.     AVFrame *const p = data;

  221.     int mb_x, mb_y, ret;

  222. 

  223.     if (buf_size * 8LL < a->mb_height * a->mb_width * 13LL)

  224.         return AVERROR_INVALIDDATA;

  225. 

  226.     if ((ret = ff_get_buffer(avctx, p, 0)) < 0)

  227.         return ret;

  228.     p->pict_type = AV_PICTURE_TYPE_I;

  229.     p->key_frame = 1;

  230. 

  231.     if (avctx->codec_id == AV_CODEC_ID_ASV1) {

  232.         av_fast_padded_malloc(&a->bitstream_buffer, &a->bitstream_buffer_size,

  233.                               buf_size);

  234.         if (!a->bitstream_buffer)

  235.             return AVERROR(ENOMEM);

  236. 

  237.         a->bbdsp.bswap_buf((uint32_t *) a->bitstream_buffer,

  238.                            (const uint32_t *) buf, buf_size / 4);

  239.         ret = init_get_bits8(&a->gb, a->bitstream_buffer, buf_size);

  240.     } else {

  241.         ret = init_get_bits8_le(&a->gb, buf, buf_size);

  242.     }

  243.     if (ret < 0)

  244.         return ret;

  245. 

  246.     for (mb_y = 0; mb_y < a->mb_height2; mb_y++) {

  247.         for (mb_x = 0; mb_x < a->mb_width2; mb_x++) {

  248.             if ((ret = decode_mb(a, a->block)) < 0)

  249.                 return ret;

  250. 

  251.             idct_put(a, p, mb_x, mb_y);

  252.         }

  253.     }

  254. 

  255.     if (a->mb_width2 != a->mb_width) {

  256.         mb_x = a->mb_width2;

  257.         for (mb_y = 0; mb_y < a->mb_height2; mb_y++) {

  258.             if ((ret = decode_mb(a, a->block)) < 0)

  259.                 return ret;

  260. 

  261.             idct_put(a, p, mb_x, mb_y);

  262.         }

  263.     }

  264. 

  265.     if (a->mb_height2 != a->mb_height) {

  266.         mb_y = a->mb_height2;

  267.         for (mb_x = 0; mb_x < a->mb_width; mb_x++) {

  268.             if ((ret = decode_mb(a, a->block)) < 0)

  269.                 return ret;

  270. 

  271.             idct_put(a, p, mb_x, mb_y);

  272.         }

  273.     }

  274. 

  275.     *got_frame = 1;

  276. 

  277.     emms_c();

  278. 

  279.     return (get_bits_count(&a->gb) + 31) / 32 * 4;

  280. }

  281. 

  282. static av_cold int decode_init(AVCodecContext *avctx)

  283. {

  284.     static AVOnce init_static_once = AV_ONCE_INIT;

  285.     ASV1Context *const a = avctx->priv_data;

  286.     const int scale      = avctx->codec_id == AV_CODEC_ID_ASV1 ? 1 : 2;

  287.     int i;

  288. 

  289.     if (avctx->extradata_size < 1) {

  290.         av_log(avctx, AV_LOG_WARNING, "No extradata provided\n");

  291.     }

  292. 

  293.     ff_asv_common_init(avctx);

  294.     ff_blockdsp_init(&a->bdsp, avctx);

  295.     ff_idctdsp_init(&a->idsp, avctx);

  296.     ff_init_scantable(a->idsp.idct_permutation, &a->scantable, ff_asv_scantab);

  297.     avctx->pix_fmt = AV_PIX_FMT_YUV420P;

  298. 

  299.     if (avctx->extradata_size < 1 || (a->inv_qscale = avctx->extradata[0]) == 0) {

  300.         av_log(avctx, AV_LOG_ERROR, "illegal qscale 0\n");

  301.         if (avctx->codec_id == AV_CODEC_ID_ASV1)

  302.             a->inv_qscale = 6;

  303.         else

  304.             a->inv_qscale = 10;

  305.     }

  306. 

  307.     for (i = 0; i < 64; i++) {

  308.         int index = ff_asv_scantab[i];

  309. 

  310.         a->intra_matrix[i] = 64 * scale * ff_mpeg1_default_intra_matrix[index] /

  311.                              a->inv_qscale;

  312.     }

  313. 

  314.     ff_thread_once(&init_static_once, init_vlcs);

  315. 

  316.     return 0;

  317. }

  318. 

  319. static av_cold int decode_end(AVCodecContext *avctx)

  320. {

  321.     ASV1Context *const a = avctx->priv_data;

  322. 

  323.     av_freep(&a->bitstream_buffer);

  324.     a->bitstream_buffer_size = 0;

  325. 

  326.     return 0;

  327. }

  328. 

  329. #if CONFIG_ASV1_DECODER

  330. AVCodec ff_asv1_decoder = {

  331.     .name           = "asv1",

  332.     .long_name      = NULL_IF_CONFIG_SMALL("ASUS V1"),

  333.     .type           = AVMEDIA_TYPE_VIDEO,

  334.     .id             = AV_CODEC_ID_ASV1,

  335.     .priv_data_size = sizeof(ASV1Context),

  336.     .init           = decode_init,

  337.     .close          = decode_end,

  338.     .decode         = decode_frame,

  339.     .capabilities   = AV_CODEC_CAP_DR1,

  340.     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,

  341. };

  342. #endif

  343. 

  344. #if CONFIG_ASV2_DECODER

  345. AVCodec ff_asv2_decoder = {

  346.     .name           = "asv2",

  347.     .long_name      = NULL_IF_CONFIG_SMALL("ASUS V2"),

  348.     .type           = AVMEDIA_TYPE_VIDEO,

  349.     .id             = AV_CODEC_ID_ASV2,

  350.     .priv_data_size = sizeof(ASV1Context),

  351.     .init           = decode_init,

  352.     .decode         = decode_frame,

  353.     .capabilities   = AV_CODEC_CAP_DR1,

  354.     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,

  355. };

  356. #endif