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.
49674 Commits
32 Branches
283MB
Tree: b5884db437
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b5884db437'
${ noResults }
FFmpeg/libavcodec/roqvideodec.c

246 lines
9.1KB
Raw Blame History 

  1. /*

  2.  * Copyright (C) 2003 the ffmpeg project

  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.  * id RoQ Video Decoder by Dr. Tim Ferguson

  24.  * For more information about the id RoQ format, visit:

  25.  *   http://www.csse.monash.edu.au/~timf/

  26.  */

  27. 

  28. #include "libavutil/avassert.h"

  29. #include "avcodec.h"

  30. #include "bytestream.h"

  31. #include "roqvideo.h"

  32. 

  33. static void roqvideo_decode_frame(RoqContext *ri)

  34. {

  35.     unsigned int chunk_id = 0, chunk_arg = 0;

  36.     unsigned long chunk_size = 0;

  37.     int i, j, k, nv1, nv2, vqflg = 0, vqflg_pos = -1;

  38.     int vqid, xpos, ypos, xp, yp, x, y, mx, my;

  39.     int frame_stats[2][4] = {{0},{0}};

  40.     roq_qcell *qcell;

  41.     int64_t chunk_start;

  42. 

  43.     while (bytestream2_get_bytes_left(&ri->gb) >= 8) {

  44.         chunk_id   = bytestream2_get_le16(&ri->gb);

  45.         chunk_size = bytestream2_get_le32(&ri->gb);

  46.         chunk_arg  = bytestream2_get_le16(&ri->gb);

  47. 

  48.         if(chunk_id == RoQ_QUAD_VQ)

  49.             break;

  50.         if(chunk_id == RoQ_QUAD_CODEBOOK) {

  51.             if((nv1 = chunk_arg >> 8) == 0)

  52.                 nv1 = 256;

  53.             if((nv2 = chunk_arg & 0xff) == 0 && nv1 * 6 < chunk_size)

  54.                 nv2 = 256;

  55.             for(i = 0; i < nv1; i++) {

  56.                 ri->cb2x2[i].y[0] = bytestream2_get_byte(&ri->gb);

  57.                 ri->cb2x2[i].y[1] = bytestream2_get_byte(&ri->gb);

  58.                 ri->cb2x2[i].y[2] = bytestream2_get_byte(&ri->gb);

  59.                 ri->cb2x2[i].y[3] = bytestream2_get_byte(&ri->gb);

  60.                 ri->cb2x2[i].u    = bytestream2_get_byte(&ri->gb);

  61.                 ri->cb2x2[i].v    = bytestream2_get_byte(&ri->gb);

  62.             }

  63.             for(i = 0; i < nv2; i++)

  64.                 for(j = 0; j < 4; j++)

  65.                     ri->cb4x4[i].idx[j] = bytestream2_get_byte(&ri->gb);

  66.         }

  67.     }

  68. 

  69.     chunk_start = bytestream2_tell(&ri->gb);

  70.     xpos = ypos = 0;

  71. 

  72.     if (chunk_size > bytestream2_get_bytes_left(&ri->gb)) {

  73.         av_log(ri->avctx, AV_LOG_ERROR, "Chunk does not fit in input buffer\n");

  74.         chunk_size = bytestream2_get_bytes_left(&ri->gb);

  75.     }

  76. 

  77.     while (bytestream2_tell(&ri->gb) < chunk_start + chunk_size) {

  78.         for (yp = ypos; yp < ypos + 16; yp += 8)

  79.             for (xp = xpos; xp < xpos + 16; xp += 8) {

  80.                 if (bytestream2_tell(&ri->gb) >= chunk_start + chunk_size) {

  81.                     av_log(ri->avctx, AV_LOG_ERROR, "Input buffer too small\n");

  82.                     return;

  83.                 }

  84.                 if (vqflg_pos < 0) {

  85.                     vqflg = bytestream2_get_le16(&ri->gb);

  86.                     vqflg_pos = 7;

  87.                 }

  88.                 vqid = (vqflg >> (vqflg_pos * 2)) & 0x3;

  89.                 frame_stats[0][vqid]++;

  90.                 vqflg_pos--;

  91. 

  92.                 switch(vqid) {

  93.                 case RoQ_ID_MOT:

  94.                     break;

  95.                 case RoQ_ID_FCC: {

  96.                     int byte = bytestream2_get_byte(&ri->gb);

  97.                     mx = 8 - (byte >> 4) - ((signed char) (chunk_arg >> 8));

  98.                     my = 8 - (byte & 0xf) - ((signed char) chunk_arg);

  99.                     ff_apply_motion_8x8(ri, xp, yp, mx, my);

  100.                     break;

  101.                 }

  102.                 case RoQ_ID_SLD:

  103.                     qcell = ri->cb4x4 + bytestream2_get_byte(&ri->gb);

  104.                     ff_apply_vector_4x4(ri, xp,     yp,     ri->cb2x2 + qcell->idx[0]);

  105.                     ff_apply_vector_4x4(ri, xp + 4, yp,     ri->cb2x2 + qcell->idx[1]);

  106.                     ff_apply_vector_4x4(ri, xp,     yp + 4, ri->cb2x2 + qcell->idx[2]);

  107.                     ff_apply_vector_4x4(ri, xp + 4, yp + 4, ri->cb2x2 + qcell->idx[3]);

  108.                     break;

  109.                 case RoQ_ID_CCC:

  110.                     for (k = 0; k < 4; k++) {

  111.                         x = xp; y = yp;

  112.                         if(k & 0x01) x += 4;

  113.                         if(k & 0x02) y += 4;

  114. 

  115.                         if (bytestream2_tell(&ri->gb) >= chunk_start + chunk_size) {

  116.                             av_log(ri->avctx, AV_LOG_ERROR, "Input buffer too small\n");

  117.                             return;

  118.                         }

  119.                         if (vqflg_pos < 0) {

  120.                             vqflg = bytestream2_get_le16(&ri->gb);

  121.                             vqflg_pos = 7;

  122.                         }

  123.                         vqid = (vqflg >> (vqflg_pos * 2)) & 0x3;

  124.                         frame_stats[1][vqid]++;

  125.                         vqflg_pos--;

  126.                         switch(vqid) {

  127.                         case RoQ_ID_MOT:

  128.                             break;

  129.                         case RoQ_ID_FCC: {

  130.                             int byte = bytestream2_get_byte(&ri->gb);

  131.                             mx = 8 - (byte >> 4) - ((signed char) (chunk_arg >> 8));

  132.                             my = 8 - (byte & 0xf) - ((signed char) chunk_arg);

  133.                             ff_apply_motion_4x4(ri, x, y, mx, my);

  134.                             break;

  135.                         }

  136.                         case RoQ_ID_SLD:

  137.                             qcell = ri->cb4x4 + bytestream2_get_byte(&ri->gb);

  138.                             ff_apply_vector_2x2(ri, x,     y,     ri->cb2x2 + qcell->idx[0]);

  139.                             ff_apply_vector_2x2(ri, x + 2, y,     ri->cb2x2 + qcell->idx[1]);

  140.                             ff_apply_vector_2x2(ri, x,     y + 2, ri->cb2x2 + qcell->idx[2]);

  141.                             ff_apply_vector_2x2(ri, x + 2, y + 2, ri->cb2x2 + qcell->idx[3]);

  142.                             break;

  143.                         case RoQ_ID_CCC:

  144.                             ff_apply_vector_2x2(ri, x,     y,     ri->cb2x2 + bytestream2_get_byte(&ri->gb));

  145.                             ff_apply_vector_2x2(ri, x + 2, y,     ri->cb2x2 + bytestream2_get_byte(&ri->gb));

  146.                             ff_apply_vector_2x2(ri, x,     y + 2, ri->cb2x2 + bytestream2_get_byte(&ri->gb));

  147.                             ff_apply_vector_2x2(ri, x + 2, y + 2, ri->cb2x2 + bytestream2_get_byte(&ri->gb));

  148.                             break;

  149.                         }

  150.                     }

  151.                     break;

  152.                 default:

  153.                     av_assert2(0);

  154.             }

  155.         }

  156. 

  157.         xpos += 16;

  158.         if (xpos >= ri->width) {

  159.             xpos -= ri->width;

  160.             ypos += 16;

  161.         }

  162.         if(ypos >= ri->height)

  163.             break;

  164.     }

  165. }

  166. 

  167. 

  168. static av_cold int roq_decode_init(AVCodecContext *avctx)

  169. {

  170.     RoqContext *s = avctx->priv_data;

  171. 

  172.     s->avctx = avctx;

  173. 

  174.     if (avctx->width%16 || avctx->height%16) {

  175.          av_log_ask_for_sample(avctx, "dimensions not being a multiple of 16 are unsupported\n");

  176.          return AVERROR_PATCHWELCOME;

  177.     }

  178. 

  179.     s->width = avctx->width;

  180.     s->height = avctx->height;

  181.     avcodec_get_frame_defaults(&s->frames[0]);

  182.     avcodec_get_frame_defaults(&s->frames[1]);

  183.     s->last_frame    = &s->frames[0];

  184.     s->current_frame = &s->frames[1];

  185.     avctx->pix_fmt = AV_PIX_FMT_YUV444P;

  186. 

  187.     return 0;

  188. }

  189. 

  190. static int roq_decode_frame(AVCodecContext *avctx,

  191.                             void *data, int *got_frame,

  192.                             AVPacket *avpkt)

  193. {

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

  195.     int buf_size = avpkt->size;

  196.     RoqContext *s = avctx->priv_data;

  197.     int copy= !s->current_frame->data[0];

  198.     int ret;

  199. 

  200.     s->current_frame->reference = 3;

  201.     if ((ret = avctx->reget_buffer(avctx, s->current_frame)) < 0) {

  202.         av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");

  203.         return ret;

  204.     }

  205. 

  206.     if(copy)

  207.         av_picture_copy((AVPicture*)s->current_frame, (AVPicture*)s->last_frame,

  208.                         avctx->pix_fmt, avctx->width, avctx->height);

  209. 

  210.     bytestream2_init(&s->gb, buf, buf_size);

  211.     roqvideo_decode_frame(s);

  212. 

  213.     *got_frame      = 1;

  214.     *(AVFrame*)data = *s->current_frame;

  215. 

  216.     /* shuffle frames */

  217.     FFSWAP(AVFrame *, s->current_frame, s->last_frame);

  218. 

  219.     return buf_size;

  220. }

  221. 

  222. static av_cold int roq_decode_end(AVCodecContext *avctx)

  223. {

  224.     RoqContext *s = avctx->priv_data;

  225. 

  226.     /* release the last frame */

  227.     if (s->last_frame->data[0])

  228.         avctx->release_buffer(avctx, s->last_frame);

  229.     if (s->current_frame->data[0])

  230.         avctx->release_buffer(avctx, s->current_frame);

  231. 

  232.     return 0;

  233. }

  234. 

  235. AVCodec ff_roq_decoder = {

  236.     .name           = "roqvideo",

  237.     .type           = AVMEDIA_TYPE_VIDEO,

  238.     .id             = AV_CODEC_ID_ROQ,

  239.     .priv_data_size = sizeof(RoqContext),

  240.     .init           = roq_decode_init,

  241.     .close          = roq_decode_end,

  242.     .decode         = roq_decode_frame,

  243.     .capabilities   = CODEC_CAP_DR1,

  244.     .long_name      = NULL_IF_CONFIG_SMALL("id RoQ video"),

  245. };