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.
101019 Commits
32 Branches
1.9GB
Tree: 483cf7a183
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '483cf7a183'
${ noResults }
FFmpeg/libavcodec/argo.c

741 lines
24KB
Raw Blame History 

  1. /*

  2.  * Argonaut Games Video decoder

  3.  * Copyright (c) 2020 Paul B Mahol

  4.  *

  5.  * This file is part of FFmpeg.

  6.  *

  7.  * FFmpeg 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.  * FFmpeg 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 FFmpeg; if not, write to the Free Software

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

  20.  */

  21. 

  22. #include <stdio.h>

  23. #include <stdlib.h>

  24. #include <string.h>

  25. 

  26. #include "libavutil/imgutils.h"

  27. #include "libavutil/internal.h"

  28. #include "libavutil/intreadwrite.h"

  29. #include "libavutil/mem.h"

  30. 

  31. #include "avcodec.h"

  32. #include "bytestream.h"

  33. #include "internal.h"

  34. 

  35. typedef struct ArgoContext {

  36.     GetByteContext gb;

  37. 

  38.     int bpp;

  39.     int key;

  40.     int mv0[128][2];

  41.     int mv1[16][2];

  42.     uint32_t pal[256];

  43.     AVFrame *frame;

  44. } ArgoContext;

  45. 

  46. static int decode_pal8(AVCodecContext *avctx, uint32_t *pal)

  47. {

  48.     ArgoContext *s = avctx->priv_data;

  49.     GetByteContext *gb = &s->gb;

  50.     int start, count;

  51. 

  52.     start = bytestream2_get_le16(gb);

  53.     count = bytestream2_get_le16(gb);

  54. 

  55.     if (start + count > 256)

  56.         return AVERROR_INVALIDDATA;

  57. 

  58.     if (bytestream2_get_bytes_left(gb) < 3 * count)

  59.         return AVERROR_INVALIDDATA;

  60. 

  61.     for (int i = 0; i < count; i++)

  62.         pal[start + i] = (0xFF << 24U) | bytestream2_get_be24u(gb);

  63. 

  64.     return 0;

  65. }

  66. 

  67. static int decode_avcf(AVCodecContext *avctx, AVFrame *frame)

  68. {

  69.     ArgoContext *s = avctx->priv_data;

  70.     GetByteContext *gb = &s->gb;

  71.     const int l = frame->linesize[0];

  72.     const uint8_t *map = gb->buffer;

  73.     uint8_t *dst = frame->data[0];

  74. 

  75.     if (bytestream2_get_bytes_left(gb) < 1024 + (frame->width / 2) * (frame->height / 2))

  76.         return AVERROR_INVALIDDATA;

  77. 

  78.     bytestream2_skipu(gb, 1024);

  79.     for (int y = 0; y < frame->height; y += 2) {

  80.         for (int x = 0; x < frame->width; x += 2) {

  81.             int index = bytestream2_get_byteu(gb);

  82.             const uint8_t *block = map + index * 4;

  83. 

  84.             dst[x+0]   = block[0];

  85.             dst[x+1]   = block[1];

  86.             dst[x+l]   = block[2];

  87.             dst[x+l+1] = block[3];

  88.         }

  89. 

  90.         dst += frame->linesize[0] * 2;

  91.     }

  92. 

  93.     return 0;

  94. }

  95. 

  96. static int decode_alcd(AVCodecContext *avctx, AVFrame *frame)

  97. {

  98.     ArgoContext *s = avctx->priv_data;

  99.     GetByteContext *gb = &s->gb;

  100.     GetByteContext sb;

  101.     const int l = frame->linesize[0];

  102.     const uint8_t *map = gb->buffer;

  103.     uint8_t *dst = frame->data[0];

  104.     uint8_t codes = 0;

  105.     int count = 0;

  106. 

  107.     if (bytestream2_get_bytes_left(gb) < 1024 + (((frame->width / 2) * (frame->height / 2) + 7) >> 3))

  108.         return AVERROR_INVALIDDATA;

  109. 

  110.     bytestream2_skipu(gb, 1024);

  111.     sb = *gb;

  112.     bytestream2_skipu(gb, ((frame->width / 2) * (frame->height / 2) + 7) >> 3);

  113. 

  114.     for (int y = 0; y < frame->height; y += 2) {

  115.         for (int x = 0; x < frame->width; x += 2) {

  116.             const uint8_t *block;

  117.             int index;

  118. 

  119.             if (count == 0) {

  120.                 codes = bytestream2_get_byteu(&sb);

  121.                 count = 8;

  122.             }

  123. 

  124.             if (codes & 0x80) {

  125.                 index = bytestream2_get_byte(gb);

  126.                 block = map + index * 4;

  127. 

  128.                 dst[x+0]   = block[0];

  129.                 dst[x+1]   = block[1];

  130.                 dst[x+l]   = block[2];

  131.                 dst[x+l+1] = block[3];

  132.             }

  133. 

  134.             codes <<= 1;

  135.             count--;

  136.         }

  137. 

  138.         dst += frame->linesize[0] * 2;

  139.     }

  140. 

  141.     return 0;

  142. }

  143. 

  144. static int decode_mad1(AVCodecContext *avctx, AVFrame *frame)

  145. {

  146.     ArgoContext *s = avctx->priv_data;

  147.     GetByteContext *gb = &s->gb;

  148.     const int w = frame->width;

  149.     const int h = frame->height;

  150.     const int l = frame->linesize[0];

  151. 

  152.     while (bytestream2_get_bytes_left(gb) > 0) {

  153.         int size, type, pos, dy;

  154.         uint8_t *dst;

  155. 

  156.         type = bytestream2_get_byte(gb);

  157.         if (type == 0xFF)

  158.             break;

  159. 

  160.         switch (type) {

  161.         case 8:

  162.             dst = frame->data[0];

  163.             for (int y = 0; y < h; y += 8) {

  164.                 for (int x = 0; x < w; x += 8) {

  165.                     int fill = bytestream2_get_byte(gb);

  166.                     uint8_t *ddst = dst + x;

  167. 

  168.                     for (int by = 0; by < 8; by++) {

  169.                         memset(ddst, fill, 8);

  170.                         ddst += l;

  171.                     }

  172.                 }

  173. 

  174.                 dst += 8 * l;

  175.             }

  176.             break;

  177.         case 7:

  178.             while (bytestream2_get_bytes_left(gb) > 0) {

  179.                 int bsize = bytestream2_get_byte(gb);

  180.                 uint8_t *src;

  181.                 int count;

  182. 

  183.                 if (!bsize)

  184.                     break;

  185. 

  186.                 count = bytestream2_get_be16(gb);

  187.                 while (count > 0) {

  188.                     int mvx, mvy, a, b, c, mx, my;

  189.                     int bsize_w, bsize_h;

  190. 

  191.                     bsize_w = bsize_h = bsize;

  192.                     if (bytestream2_get_bytes_left(gb) < 4)

  193.                         return AVERROR_INVALIDDATA;

  194.                     mvx = bytestream2_get_byte(gb) * bsize;

  195.                     mvy = bytestream2_get_byte(gb) * bsize;

  196.                     a = bytestream2_get_byte(gb);

  197.                     b = bytestream2_get_byte(gb);

  198.                     c = ((a & 0x3F) << 8) + b;

  199.                     mx = mvx + (c  & 0x7F) - 64;

  200.                     my = mvy + (c >>    7) - 64;

  201. 

  202.                     if (mvy < 0 || mvy >= h)

  203.                         return AVERROR_INVALIDDATA;

  204. 

  205.                     if (mvx < 0 || mvx >= w)

  206.                         return AVERROR_INVALIDDATA;

  207. 

  208.                     if (my < 0 || my >= h)

  209.                         return AVERROR_INVALIDDATA;

  210. 

  211.                     if (mx < 0 || mx >= w)

  212.                         return AVERROR_INVALIDDATA;

  213. 

  214.                     dst = frame->data[0] + mvx + l * mvy;

  215.                     src = frame->data[0] + mx  + l * my;

  216. 

  217.                     bsize_w = FFMIN3(bsize_w, w - mvx, w - mx);

  218.                     bsize_h = FFMIN3(bsize_h, h - mvy, h - my);

  219. 

  220.                     if (mvy >= my && (mvy != my || mvx >= mx)) {

  221.                         src += (bsize_h - 1) * l;

  222.                         dst += (bsize_h - 1) * l;

  223.                         for (int by = 0; by < bsize_h; by++) {

  224.                             memmove(dst, src, bsize_w);

  225.                             src -= l;

  226.                             dst -= l;

  227.                         }

  228.                     } else {

  229.                         for (int by = 0; by < bsize_h; by++) {

  230.                             memmove(dst, src, bsize_w);

  231.                             src += l;

  232.                             dst += l;

  233.                         }

  234.                     }

  235. 

  236.                     count--;

  237.                 }

  238.             }

  239.             break;

  240.         case 6:

  241.             dst = frame->data[0];

  242.             if (bytestream2_get_bytes_left(gb) < w * h)

  243.                 return AVERROR_INVALIDDATA;

  244.             for (int y = 0; y < h; y++) {

  245.                 bytestream2_get_bufferu(gb, dst, w);

  246.                 dst += l;

  247.             }

  248.             break;

  249.         case 5:

  250.             dst = frame->data[0];

  251.             for (int y = 0; y < h; y += 2) {

  252.                 for (int x = 0; x < w; x += 2) {

  253.                     int fill = bytestream2_get_byte(gb);

  254.                     uint8_t *ddst = dst + x;

  255. 

  256.                     fill = (fill << 8) | fill;

  257.                     for (int by = 0; by < 2; by++) {

  258.                             AV_WN16(ddst, fill);

  259. 

  260.                         ddst += l;

  261.                     }

  262.                 }

  263. 

  264.                 dst += 2 * l;

  265.             }

  266.             break;

  267.         case 3:

  268.             size = bytestream2_get_le16(gb);

  269.             if (size > 0) {

  270.                 int x = bytestream2_get_byte(gb) * 4;

  271.                 int y = bytestream2_get_byte(gb) * 4;

  272.                 int count = bytestream2_get_byte(gb);

  273.                 int fill = bytestream2_get_byte(gb);

  274. 

  275.                 av_log(avctx, AV_LOG_DEBUG, "%d %d %d %d\n", x, y, count, fill);

  276.                 for (int i = 0; i < count; i++)

  277.                     ;

  278.                 return AVERROR_PATCHWELCOME;

  279.             }

  280.             break;

  281.         case 2:

  282.             dst = frame->data[0];

  283.             pos = 0;

  284.             dy  = 0;

  285.             while (bytestream2_get_bytes_left(gb) > 0) {

  286.                 int count = bytestream2_get_byteu(gb);

  287.                 int skip = count & 0x3F;

  288. 

  289.                 count = count >> 6;

  290.                 if (skip == 0x3F) {

  291.                     pos += 0x3E;

  292.                     while (pos >= w) {

  293.                         pos -= w;

  294.                         dst += l;

  295.                         dy++;

  296.                         if (dy >= h)

  297.                             return 0;

  298.                     }

  299.                 } else {

  300.                     pos += skip;

  301.                     while (pos >= w) {

  302.                         pos -= w;

  303.                         dst += l;

  304.                         dy++;

  305.                         if (dy >= h)

  306.                             return 0;

  307.                     }

  308.                     while (count >= 0) {

  309.                         int bits = bytestream2_get_byte(gb);

  310. 

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

  312.                             switch (bits & 3) {

  313.                             case 0:

  314.                                 break;

  315.                             case 1:

  316.                                 if (dy < 1 && !pos)

  317.                                     return AVERROR_INVALIDDATA;

  318.                                 else

  319.                                     dst[pos] = pos ? dst[pos - 1] : dst[-l + w - 1];

  320.                                 break;

  321.                             case 2:

  322.                                 if (dy < 1)

  323.                                     return AVERROR_INVALIDDATA;

  324.                                 dst[pos] = dst[pos - l];

  325.                                 break;

  326.                             case 3:

  327.                                 dst[pos] = bytestream2_get_byte(gb);

  328.                                 break;

  329.                             }

  330. 

  331.                             pos++;

  332.                             if (pos >= w) {

  333.                                 pos -= w;

  334.                                 dst += l;

  335.                                 dy++;

  336.                                 if (dy >= h)

  337.                                     return 0;

  338.                             }

  339.                             bits >>= 2;

  340.                         }

  341.                         count--;

  342.                     }

  343.                 }

  344.             }

  345.             break;

  346.         default:

  347.             return AVERROR_INVALIDDATA;

  348.         }

  349.     }

  350. 

  351.     return 0;

  352. }

  353. 

  354. static int decode_mad1_24(AVCodecContext *avctx, AVFrame *frame)

  355. {

  356.     ArgoContext *s = avctx->priv_data;

  357.     GetByteContext *gb = &s->gb;

  358.     const int w = frame->width;

  359.     const int h = frame->height;

  360.     const int l = frame->linesize[0] / 4;

  361. 

  362.     while (bytestream2_get_bytes_left(gb) > 0) {

  363.         int osize, type, pos, dy, di, bcode, value, v14;

  364.         const uint8_t *bits;

  365.         uint32_t *dst;

  366. 

  367.         type = bytestream2_get_byte(gb);

  368.         if (type == 0xFF)

  369.             return 0;

  370. 

  371.         switch (type) {

  372.         case 8:

  373.             dst = (uint32_t *)frame->data[0];

  374.             for (int y = 0; y + 12 <= h; y += 12) {

  375.                 for (int x = 0; x + 12 <= w; x += 12) {

  376.                     int fill = bytestream2_get_be24(gb);

  377.                     uint32_t *dstp = dst + x;

  378. 

  379.                     for (int by = 0; by < 12; by++) {

  380.                         for (int bx = 0; bx < 12; bx++)

  381.                             dstp[bx] = fill;

  382. 

  383.                         dstp += l;

  384.                     }

  385.                 }

  386. 

  387.                 dst += 12 * l;

  388.             }

  389.             break;

  390.         case 7:

  391.             while (bytestream2_get_bytes_left(gb) > 0) {

  392.                 int bsize = bytestream2_get_byte(gb);

  393.                 uint32_t *src;

  394.                 int count;

  395. 

  396.                 if (!bsize)

  397.                     break;

  398. 

  399.                 count = bytestream2_get_be16(gb);

  400.                 while (count > 0) {

  401.                     int mvx, mvy, a, b, c, mx, my;

  402.                     int bsize_w, bsize_h;

  403. 

  404.                     bsize_w = bsize_h = bsize;

  405.                     if (bytestream2_get_bytes_left(gb) < 4)

  406.                         return AVERROR_INVALIDDATA;

  407.                     mvx = bytestream2_get_byte(gb) * bsize;

  408.                     mvy = bytestream2_get_byte(gb) * bsize;

  409.                     a = bytestream2_get_byte(gb);

  410.                     b = bytestream2_get_byte(gb);

  411.                     c = ((a & 0x3F) << 8) + b;

  412.                     mx = mvx + (c  & 0x7F) - 64;

  413.                     my = mvy + (c >>    7) - 64;

  414. 

  415.                     if (mvy < 0 || mvy >= h)

  416.                         return AVERROR_INVALIDDATA;

  417. 

  418.                     if (mvx < 0 || mvx >= w)

  419.                         return AVERROR_INVALIDDATA;

  420. 

  421.                     if (my < 0 || my >= h)

  422.                         return AVERROR_INVALIDDATA;

  423. 

  424.                     if (mx < 0 || mx >= w)

  425.                         return AVERROR_INVALIDDATA;

  426. 

  427.                     dst = (uint32_t *)frame->data[0] + mvx + l * mvy;

  428.                     src = (uint32_t *)frame->data[0] + mx  + l * my;

  429. 

  430.                     bsize_w = FFMIN3(bsize_w, w - mvx, w - mx);

  431.                     bsize_h = FFMIN3(bsize_h, h - mvy, h - my);

  432. 

  433.                     if (mvy >= my && (mvy != my || mvx >= mx)) {

  434.                         src += (bsize_h - 1) * l;

  435.                         dst += (bsize_h - 1) * l;

  436.                         for (int by = 0; by < bsize_h; by++) {

  437.                             memmove(dst, src, bsize_w * 4);

  438.                             src -= l;

  439.                             dst -= l;

  440.                         }

  441.                     } else {

  442.                         for (int by = 0; by < bsize_h; by++) {

  443.                             memmove(dst, src, bsize_w * 4);

  444.                             src += l;

  445.                             dst += l;

  446.                         }

  447.                     }

  448. 

  449.                     count--;

  450.                 }

  451.             }

  452.             break;

  453.         case 12:

  454.             osize = ((h + 3) / 4) * ((w + 3) / 4) + 7;

  455.             bits = gb->buffer;

  456.             di   = 0;

  457.             bcode = v14 = 0;

  458.             if (bytestream2_get_bytes_left(gb) < osize >> 3)

  459.                 return AVERROR_INVALIDDATA;

  460.             bytestream2_skip(gb, osize >> 3);

  461.             for (int x = 0; x < w; x += 4) {

  462.                 for (int y = 0; y < h; y += 4) {

  463.                     int astate = 0;

  464. 

  465.                     if (bits[di >> 3] & (1 << (di & 7))) {

  466.                         int codes = bytestream2_get_byte(gb);

  467. 

  468.                         for (int count = 0; count < 4; count++) {

  469.                             uint32_t *src = (uint32_t *)frame->data[0];

  470.                             size_t src_size = l * (h - 1) + (w - 1);

  471.                             int nv, v, code = codes & 3;

  472. 

  473.                             pos = x;

  474.                             dy  = y + count;

  475.                             dst = (uint32_t *)frame->data[0] + pos + dy * l;

  476.                             if (code & 1)

  477.                                 bcode = bytestream2_get_byte(gb);

  478.                             if (code == 3) {

  479.                                 for (int j = 0; j < 4; j++) {

  480.                                     switch (bcode & 3) {

  481.                                     case 0:

  482.                                         break;

  483.                                     case 1:

  484.                                         if (dy < 1 && !pos)

  485.                                             return AVERROR_INVALIDDATA;

  486.                                         dst[0] = dst[-1];

  487.                                         break;

  488.                                     case 2:

  489.                                         if (dy < 1)

  490.                                             return AVERROR_INVALIDDATA;

  491.                                         dst[0] = dst[-l];

  492.                                         break;

  493.                                     case 3:

  494.                                         if (astate) {

  495.                                             nv = value >> 4;

  496.                                         } else {

  497.                                             value = bytestream2_get_byte(gb);

  498.                                             nv = value & 0xF;

  499.                                         }

  500.                                         astate ^= 1;

  501.                                         dst[0] = src[av_clip(l * (dy + s->mv1[nv][1]) + pos +

  502.                                                              s->mv1[nv][0], 0, src_size)];

  503.                                         break;

  504.                                     }

  505. 

  506.                                     bcode >>= 2;

  507.                                     dst++;

  508.                                     pos++;

  509.                                 }

  510.                             } else if (code) {

  511.                                 if (code == 1)

  512.                                     v14 = bcode;

  513.                                 else

  514.                                     bcode = v14;

  515.                                 for (int j = 0; j < 4; j++) {

  516.                                     switch (bcode & 3) {

  517.                                     case 0:

  518.                                         break;

  519.                                     case 1:

  520.                                         if (dy < 1 && !pos)

  521.                                             return AVERROR_INVALIDDATA;

  522.                                         dst[0] = dst[-1];

  523.                                         break;

  524.                                     case 2:

  525.                                         if (dy < 1)

  526.                                             return AVERROR_INVALIDDATA;

  527.                                         dst[0] = dst[-l];

  528.                                         break;

  529.                                     case 3:

  530.                                         v = bytestream2_get_byte(gb);

  531.                                         if (v < 128) {

  532.                                             dst[0] = src[av_clip(l * (dy + s->mv0[v][1]) + pos +

  533.                                                                  s->mv0[v][0], 0, src_size)];

  534.                                         } else {

  535.                                             dst[0] = ((v & 0x7F) << 17) | bytestream2_get_be16(gb);

  536.                                         }

  537.                                         break;

  538.                                     }

  539. 

  540.                                     bcode >>= 2;

  541.                                     dst++;

  542.                                     pos++;

  543.                                 }

  544.                             }

  545. 

  546.                             codes >>= 2;

  547.                         }

  548.                     }

  549. 

  550.                     di++;

  551.                 }

  552.             }

  553.             break;

  554.         default:

  555.             return AVERROR_INVALIDDATA;

  556.         }

  557.     }

  558. 

  559.     return AVERROR_INVALIDDATA;

  560. }

  561. 

  562. static int decode_rle(AVCodecContext *avctx, AVFrame *frame)

  563. {

  564.     ArgoContext *s = avctx->priv_data;

  565.     GetByteContext *gb = &s->gb;

  566.     const int w = frame->width;

  567.     const int h = frame->height;

  568.     const int l = frame->linesize[0];

  569.     uint8_t *dst = frame->data[0];

  570.     int pos = 0, y = 0;

  571. 

  572.     while (bytestream2_get_bytes_left(gb) > 0) {

  573.         int count = bytestream2_get_byte(gb);

  574.         int pixel = bytestream2_get_byte(gb);

  575. 

  576.         if (!count) {

  577.             pos += pixel;

  578.             while (pos >= w) {

  579.                 pos -= w;

  580.                 y++;

  581.                 if (y >= h)

  582.                     return 0;

  583.             }

  584.         } else {

  585.             while (count > 0) {

  586.                 dst[pos + y * l] = pixel;

  587.                 count--;

  588.                 pos++;

  589.                 if (pos >= w) {

  590.                     pos = 0;

  591.                     y++;

  592.                     if (y >= h)

  593.                         return 0;

  594.                 }

  595.             }

  596.         }

  597.     }

  598. 

  599.     return 0;

  600. }

  601. 

  602. static int decode_frame(AVCodecContext *avctx, void *data,

  603.                         int *got_frame, AVPacket *avpkt)

  604. {

  605.     ArgoContext *s = avctx->priv_data;

  606.     GetByteContext *gb = &s->gb;

  607.     AVFrame *frame = s->frame;

  608.     uint32_t chunk;

  609.     int ret;

  610. 

  611.     bytestream2_init(gb, avpkt->data, avpkt->size);

  612. 

  613.     if ((ret = ff_reget_buffer(avctx, frame, 0)) < 0)

  614.         return ret;

  615. 

  616.     chunk = bytestream2_get_be32(gb);

  617.     switch (chunk) {

  618.     case MKBETAG('P', 'A', 'L', '8'):

  619.         for (int y = 0; y < frame->height; y++)

  620.             memset(frame->data[0] + y * frame->linesize[0], 0, frame->width * s->bpp);

  621.         if (avctx->pix_fmt == AV_PIX_FMT_PAL8)

  622.             memset(frame->data[1], 0, AVPALETTE_SIZE);

  623.         return decode_pal8(avctx, s->pal);

  624.     case MKBETAG('M', 'A', 'D', '1'):

  625.         if (avctx->pix_fmt == AV_PIX_FMT_PAL8)

  626.             ret = decode_mad1(avctx, frame);

  627.         else

  628.             ret = decode_mad1_24(avctx, frame);

  629.         break;

  630.     case MKBETAG('A', 'V', 'C', 'F'):

  631.         if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {

  632.             s->key = 1;

  633.             ret = decode_avcf(avctx, frame);

  634.             break;

  635.         }

  636.     case MKBETAG('A', 'L', 'C', 'D'):

  637.         if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {

  638.             s->key = 0;

  639.             ret = decode_alcd(avctx, frame);

  640.             break;

  641.         }

  642.     case MKBETAG('R', 'L', 'E', 'F'):

  643.         if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {

  644.             s->key = 1;

  645.             ret = decode_rle(avctx, frame);

  646.             break;

  647.         }

  648.     case MKBETAG('R', 'L', 'E', 'D'):

  649.         if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {

  650.             s->key = 0;

  651.             ret = decode_rle(avctx, frame);

  652.             break;

  653.         }

  654.     default:

  655.         av_log(avctx, AV_LOG_DEBUG, "unknown chunk 0x%X\n", chunk);

  656.         break;

  657.     }

  658. 

  659.     if (ret < 0)

  660.         return ret;

  661. 

  662.     if (avctx->pix_fmt == AV_PIX_FMT_PAL8)

  663.         memcpy(frame->data[1], s->pal, AVPALETTE_SIZE);

  664. 

  665.     if ((ret = av_frame_ref(data, s->frame)) < 0)

  666.         return ret;

  667. 

  668.     frame->pict_type = s->key ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;

  669.     frame->key_frame = s->key;

  670.     *got_frame = 1;

  671. 

  672.     return avpkt->size;

  673. }

  674. 

  675. static av_cold int decode_init(AVCodecContext *avctx)

  676. {

  677.     ArgoContext *s = avctx->priv_data;

  678. 

  679.     switch (avctx->bits_per_raw_sample) {

  680.     case  8: s->bpp = 1;

  681.              avctx->pix_fmt = AV_PIX_FMT_PAL8; break;

  682.     case 24: s->bpp = 4;

  683.              avctx->pix_fmt = AV_PIX_FMT_BGR0; break;

  684.     default: avpriv_request_sample(s, "depth == %u", avctx->bits_per_raw_sample);

  685.              return AVERROR_PATCHWELCOME;

  686.     }

  687. 

  688.     s->frame = av_frame_alloc();

  689.     if (!s->frame)

  690.         return AVERROR(ENOMEM);

  691. 

  692.     for (int n = 0, i = -4; i < 4; i++) {

  693.         for (int j = -14; j < 2; j++) {

  694.             s->mv0[n][0] = j;

  695.             s->mv0[n++][1] = i;

  696.         }

  697.     }

  698. 

  699.     for (int n = 0, i = -5; i <= 1; i += 2) {

  700.         int j = -5;

  701. 

  702.         while (j <= 1) {

  703.             s->mv1[n][0] = j;

  704.             s->mv1[n++][1] = i;

  705.             j += 2;

  706.         }

  707.     }

  708. 

  709.     return 0;

  710. }

  711. 

  712. static void decode_flush(AVCodecContext *avctx)

  713. {

  714.     ArgoContext *s = avctx->priv_data;

  715. 

  716.     av_frame_unref(s->frame);

  717. }

  718. 

  719. static av_cold int decode_close(AVCodecContext *avctx)

  720. {

  721.     ArgoContext *s = avctx->priv_data;

  722. 

  723.     av_frame_free(&s->frame);

  724. 

  725.     return 0;

  726. }

  727. 

  728. AVCodec ff_argo_decoder = {

  729.     .name           = "argo",

  730.     .long_name      = NULL_IF_CONFIG_SMALL("Argonaut Games Video"),

  731.     .type           = AVMEDIA_TYPE_VIDEO,

  732.     .id             = AV_CODEC_ID_ARGO,

  733.     .priv_data_size = sizeof(ArgoContext),

  734.     .init           = decode_init,

  735.     .decode         = decode_frame,

  736.     .flush          = decode_flush,

  737.     .close          = decode_close,

  738.     .capabilities   = AV_CODEC_CAP_DR1,

  739.     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,

  740. };