[第4波]幽魂系列汉化的有关资料

shane007

最近找到了一些和幽魂系列Phantasmagoria 有关的资料，
也许将来可以用于汉化。

/ e, k0 [  l4 f* y1 j和日文版有关的信息
http://anthonylarme.tripod.com/phantas/phintgtp.html
) X, T4 |0 F( h- ]4 F  S7 u9 v
相关工具
http://anthonylarme.tripod.com/phantas/phcheats.html
+ ]% `# Y2 R! H-----------------------------------------------------------------------
% A: W/ ]3 |: s9 @4 R( W2 F! F; g2012/1/2  更新
关于幽魂游戏的字幕
Phantasmagoria subtitles function discovered - ScummVM :: Forums

7 m- u9 H/ g, P4 {VMD文件
  M; F7 w: k. M% c, d; lSubtitling Sierra VMD Files | Breaking Eggs And Making Omelettes (multimedia.cx)VMD - MultimediaWiki

- m1 t& O8 `) @" S字幕
Subtitling Sierra RBT Files | Breaking Eggs And Making Omelettes (multimedia.cx)

1 ]" \4 V  ^  |% F9 V3 NFFmpeg/subtitle-rbt.c at feature/VMD_encoder · multimediamike/FFmpeg · GitHub
8 h# m7 i5 o. F  z! D

1. /*
   
2. * subtitle-rbt.c
   1 ^3 G  N  M8 u( t! q4 x; ^
3. *  by Mike Melanson (mike -at- multimedia.cx)
     ^1 o' ]3 {: r# T# |! r3 u
4. *
   % g1 M) o/ M( s1 D
5. * build with this command:
   / i( Y  ]0 Z' F  Y5 E) L$ i" g: O
6. *   gcc -g -Wall subtitle-rbt.c -o subtitle-rbt -lm -lass
   
7. */
   2 U& }( K  F/ s2 g4 Z8 x* L
8. 
   
9. #include <inttypes.h>
   4 a; Y) D+ H4 Y0 E5 v
10. #include <math.h>
    
11. #include <stdio.h>
    8 t( i1 N' L2 ?, J+ e
12. #include <stdlib.h>
    : K* o8 L$ d0 U4 v- g2 }
13. #include <string.h>
    
14. 
    2 ]; H4 n8 m( c) I3 T0 i! ^; B& z+ s
15. #include <ass/ass.h>
    ! N) m8 S& W$ t% P& M& Q5 M
16. 
    
17. #define LE_16(x) ((((uint8_t*)(x))[1] <<  8) | ((uint8_t*)(x))[0])
    
18. 
    
19. #define LE_32(x) (((uint32_t)(((uint8_t*)(x))[3]) << 24) |  \
    
20.                              (((uint8_t*)(x))[2]  << 16) |  \
    6 G8 v3 @7 @. @  J0 F2 R* B
21.                              (((uint8_t*)(x))[1]  <<  8) |  \
    
22.                               ((uint8_t*)(x))[0])
    
23. 
    . ]; z; R+ X7 N, m4 ]# y% e. O2 i
24. /*********************************************************************/
    
25. 
    . A( N# w4 ~0 z" @; D
26. /* Bit reader stuff */
    7 I8 I9 o  Z6 `+ F
27. 
    + |4 E- p& a* [& n
28. typedef struct
    
29. {
    
30.     uint8_t *bytestream;
    
31.     int bytestream_size;
    
32.     int index;
    
33.     uint32_t bits;
    
34.     int bits_in_buffer;
    
35. } get_bits_context;
    # @+ ?1 F1 i, y% r# r- A
36. 
    7 f) V$ p) ?5 d, U& f
37. static inline void reload_bits(get_bits_context *gb)
    ( ?5 S6 P" G9 w; x. C; ^
38. {
    
39.     while (gb->bits_in_buffer <= 24)
    ) o% Y9 _  {! S
40.     {
    
41.         if (gb->index < gb->bytestream_size)
    
42.             gb->bits |= (gb->bytestream[gb->index++] << (24 - gb->bits_in_buffer));
    ( N6 z* A5 l; s
43.         gb->bits_in_buffer += 8;
    
44.     }
    ) o# ?: y! D4 z5 v- h
45. }
    
46. 
    
47. static void init_get_bits(get_bits_context *gb, uint8_t *bytestream, int size)
    # m  }9 S* T; v* m4 P8 h& k
48. {
    ( V: E" a: j7 l8 I' z2 h$ X
49.     gb->bytestream = malloc(size);
    , F' V+ O/ @9 \+ g& q* M" E
50.     memcpy(gb->bytestream, bytestream, size);
    . ?8 j! H# j% |( q; S3 c; a/ [
51.     gb->bytestream_size = size;
    
52.     gb->index = 0;
    
53.     gb->bits = 0;
    
54.     gb->bits_in_buffer = 0;
    
55. 
    % P# D$ T8 [1 P' [$ i! E% S5 B
56.     reload_bits(gb);
    
57. }
    / b  R# G+ g# t  y4 e! P
58. 
    
59. /* read bits without consuming them from the stream */
    ; ~0 {6 v  Q9 h) f6 h0 s" h$ r
60. static int view_bits(get_bits_context *gb, int count)
    
61. {
    1 J/ u, ]$ T/ p5 n) F% S3 C( o
62.     if (count >= 24)
    2 W! @6 s7 o2 H4 d
63.         return -1;
    $ q# |6 U& G) F8 \4 g
64.     if (gb->bits_in_buffer < count)
    
65.         reload_bits(gb);
    
66.     return (gb->bits >> (32 - count));
    
67. }
    6 G* Q! g9 [; b- Q( j
68. 
    2 W8 R: Y3 [% Q* {# Y. h$ A8 q" I
69. /* read and consume bits from the stream */
      D0 `; D! x, f/ M. Z- i7 p
70. static int read_bits(get_bits_context *gb, int count)
    2 q: S' c7 Y8 o7 N, _( w
71. {
    ' a" f1 s* t$ E. N; z( T5 T/ @
72.     int value;
    
73. 
    
74.     if (count >= 24)
    & w1 {  p" {0 f% ]
75.         return -1;
    
76. 
    
77.     value = view_bits(gb, count);
    " C/ e$ V: l% g) k- W1 F- R$ l
78.     gb->bits <<= count;
    
79.     gb->bits_in_buffer -= count;
    
80. 
    
81.     return value;
    
82. }
    
83. 
    # W; B- Y7 z- I7 c3 D; v
84. static void delete_get_bits(get_bits_context *gb)
    
85. {
    4 a& Q' _: I% t, I7 p4 S( i4 c
86.     free(gb->bytestream);
    , c8 ^" O7 U- i6 N; M4 G2 I2 e
87. }
    ! G: _! l2 J0 ?' v
88. 
    7 `* ]( y- C- Z5 V  l1 d
89. /*********************************************************************/
    
90. 
    1 G- u* S. C) _1 J1 W( n! a
91. /* Bit writer stuff */
    9 m2 m& [1 a2 ~5 t
92. 
    / r( x6 \: l( {7 y" A
93. #define MAX_PUT_BITS_BYTES 63000
    ) _# ]+ e4 b+ n: q/ H3 B' }
94. typedef struct
    - m7 V/ m9 W, c# l! \
95. {
    4 o. H( G( _% s) e  m
96.     uint8_t bytes[MAX_PUT_BITS_BYTES];
    
97.     int byte_index;
    $ d' p* w2 J4 Y+ e
98.     uint32_t bit_buffer;
    4 O0 _  V) I4 C9 O2 b( `0 X8 o5 w
99.     int bits_buffered;
    5 [% P5 p7 d# S
100. } put_bits_context;
     - p$ `: k% C: G/ v4 |
101. 
     
102. static void reset_put_bits(put_bits_context *pb)
     
103. {
     
104.     memset(pb->bytes, 0, MAX_PUT_BITS_BYTES);
     # ?7 v4 H) B; d! O! }2 Y8 m# e
105.     pb->byte_index = 0;
     
106.     pb->bit_buffer = 0;
     8 d# c" m8 p7 C, q5 E1 S) g$ D
107.     pb->bits_buffered = 0;
     
108. }
     
109. 
     
110. static put_bits_context *init_put_bits()
     
111. {
     . f  V0 n: H: K* y- K+ A8 R
112.     put_bits_context *pb;
     , q' n0 a% M8 Z  Q7 c
113. 
     * v( v6 j8 V# a  O3 {" H; b
114.     pb = malloc(sizeof(put_bits_context));
     8 j" j1 Z6 z/ X" K8 s) |. m7 k9 ]
115.     reset_put_bits(pb);
     + P! A% R' C) r4 z% b5 y
116. 
     
117.     return pb;
     
118. }
     
119. 
     6 ~: d/ h7 D  r/ T, \
120. static void put_bits(put_bits_context *pb, int bits, int count)
     ( |# T) a7 [& S. V6 ~9 Y
121. {
     
122.     pb->bit_buffer <<= count;
     
123.     pb->bit_buffer |= (bits & (~(0xFFFFFFFF << count)));
     7 o3 ~2 s- s/ _. o$ M& Z
124.     pb->bits_buffered += count;
     0 }" f  B3 S) N0 B5 R" _
125. 
     
126.     while (pb->bits_buffered >= 8)
     * ~% r  a, ]7 Z/ E, e
127.     {
     
128.         pb->bytes[pb->byte_index++] = pb->bit_buffer >> (pb->bits_buffered - 8);
     
129.         pb->bit_buffer &= (~(0xFFFFFFFF << (pb->bits_buffered - 8)));
     
130.         pb->bits_buffered -= 8;
     5 ?& a# w( b! v8 X: V
131.     }
     
132. 
     
133.     if (pb->byte_index >= MAX_PUT_BITS_BYTES)
     
134.     {
     " w7 e/ y* ]& \4 F
135.         printf("HELP! Bit overflow\n");
     
136.         exit(1);
     8 S  S9 E8 ]4 a8 M- T
137.     }
     
138. }
     ' {) q3 E. S0 e+ }0 b( v. f
139. 
     7 k! L2 y' f' p, m0 [# ~
140. static void put_bits_flush(put_bits_context *pb)
     % R& I- T# y  h) v+ l& G9 V
141. {
     
142.     if (pb->bits_buffered > 0)
     
143.         pb->bytes[pb->byte_index++] = pb->bit_buffer << (8 - pb->bits_buffered);
     
144. }
     - R2 S6 l, [# p/ b, F: T4 O
145. 
     * ~$ r& H$ u* ~; a  b
146. static void delete_put_bits(put_bits_context *pb)
     : Y" ?" Q( Z7 r7 ?
147. {
     
148.     free(pb->bytes);
     
149. }
     
150. 
     
151. /*********************************************************************/
     
152. 
     9 o) d2 x* f9 |  D+ e6 `) v
153. /* RBT functions */
     1 Y' T: t/ h" d) S9 G; y  e3 n+ g) K& F
154. 
     % N7 F0 k+ e4 L* n2 g
155. #define PALETTE_COUNT 256
     . T% y2 l$ o$ S+ e1 i
156. #define RBT_HEADER_SIZE 60
     $ l2 y% a* l5 Q7 t
157. #define UNKNOWN_TABLE_SIZE (1024+512)
     1 o& X! p0 a5 j; ~5 Z
158. #define SUBTITLE_THRESHOLD 0x70
     $ K$ ~) Z/ R6 `5 q7 G( B1 K4 b. g
159. #define MILLISECONDS_PER_FRAME 100
     1 |+ {) J0 \3 U$ V" Q0 E3 t5 C
160. 
     
161. /* VLC table */
     
162. #define VLC_SIZE 4
     
163. static struct
     $ L$ B: E7 h2 y) I
164. {
     - Q9 {' J1 W3 m0 O
165.     int count;
     7 O% `" e" r# v
166.     int value;
     
167. } lzs_vlc_table[] =
     8 \8 H! P, ~" i; b- |
168. {
     
169.     /* code length = 2 bits; value = 2 */
     
170.     /* 0000 */ { 2, 2 },
     
171.     /* 0001 */ { 2, 2 },
     - i" I$ r7 R4 `# U8 M
172.     /* 0010 */ { 2, 2 },
     
173.     /* 0011 */ { 2, 2 },
     ( L& b8 |3 z9 U' h+ z" @
174. 
     
175.     /* code length = 2 bits; value = 3 */
     
176.     /* 0100 */ { 2, 3 },
     % E5 l0 Y! L* `
177.     /* 0101 */ { 2, 3 },
     - f3 o2 V- n4 `2 A5 s5 h4 E+ V
178.     /* 0110 */ { 2, 3 },
     8 s; _6 a$ c5 {) b
179.     /* 0111 */ { 2, 3 },
     
180. 
     + x2 {$ d/ o5 A
181.     /* code length = 2 bits; value = 4 */
     ) g$ D  T9 T0 ^- _/ Q9 J
182.     /* 1000 */ { 2, 4 },
     
183.     /* 1001 */ { 2, 4 },
     
184.     /* 1010 */ { 2, 4 },
     
185.     /* 1011 */ { 2, 4 },
     
186. 
     6 `+ j+ L5 d, W& [, W/ c6 F3 _, ]: C
187.     /* code length = 4 bits; value = 5 */
     . b4 @/ @; d& q8 \5 c. U
188.     /* 1100 */ { 4, 5 },
     
189. 
     ; V1 J9 ^& @' o* j( h$ A; C6 y1 ^( s6 v
190.     /* code length = 4 bits; value = 6 */
     ! w( S7 O- E. s+ e' F
191.     /* 1101 */ { 4, 6 },
     
192. 
     / ^# g. s2 [. d8 m1 n4 n
193.     /* code length = 4 bits; value = 7 */
     . C+ X% O8 j: H! ?
194.     /* 1110 */ { 4, 7 },
     
195. 
     & l' m8 F8 s# ^4 b) V
196.     /* special case */
     
197.     /* 1111 */ { 4, 8 }
     * a' ]% A+ n+ e! L
198. };
     ) f+ H8 C  Z" ~; o% M( q" m9 |9 [. x
199. 
     
200. typedef struct
     8 z! S- m9 e/ R! r7 _# q
201. {
     
202.     int version;
       a) F- h3 l! y3 W& ?, a
203.     int width;
     
204.     int height;
     , Z. l' c# p8 O- V5 M5 i# i7 w
205.     int frame_count;
     ; H" X- ^3 T( i/ {+ V. y2 k
206.     int audio_chunk_size;
     
207.     uint8_t palette[PALETTE_COUNT * 3];
     ( l( b9 [/ q; Q1 }
208.     off_t video_frame_size_table_offset;
     
209.     uint8_t *video_frame_size_table;
     0 @- Y3 W, y  I0 y: |3 ]
210.     off_t frame_size_table_offset;
     
211.     uint8_t *frame_size_table;
     
212.     uint8_t *frame_load_buffer;
     : A) Y: T, K% i
213.     int dump_frames;
     
214. 
     ! ], \' o( Y8 P) [$ o7 e3 o' [/ g; F
215.     /* subtitle library */
     ! [9 M3 {; r6 h) q3 `
216.     ASS_Library *ass_lib;
     
217.     ASS_Renderer *ass_renderer;
       C7 k  _( m& M$ }- j# H
218.     ASS_Track *ass_track;
     8 p3 o* r2 c/ W* |& w  x; a
219. } rbt_dec_context;
     . {3 r  x, [2 h( S- v
220. 
     
221. static void dump_pnm_file(char *filename, rbt_dec_context *rbt,
     
222.     uint8_t *image, int width, int height)
     
223. {
     7 X: h  l, A! X7 N! _$ I2 j
224.     FILE *outfile;
     9 f( P% |$ N  B' j; m/ U+ C! r
225.     uint8_t bytes[3];
       b, u5 I/ N: _/ A" }: b
226.     int p;
     . V! @8 c8 _* w0 b
227.     uint8_t pixel;
     $ b$ v( B+ k; E
228. 
     
229.     outfile = fopen(filename, "wb");
     
230.     fprintf(outfile, "P6\n%d %d\n255\n", width, height);
     4 X' d/ |* i6 @
231.     for (p = 0; p < width * height; p++)
     + x! X. |6 c$ i. z- H
232.     {
     ! O( y' ?4 `: |- |
233.         pixel = image[p];
     
234.         bytes[0] = rbt->palette[pixel*3+0];
     
235.         bytes[1] = rbt->palette[pixel*3+1];
     
236.         bytes[2] = rbt->palette[pixel*3+2];
     % T; v& w& _, }1 y3 P% m) K" g
237.         fwrite(bytes, 3, 1, outfile);
     3 V4 b: Y$ U0 m7 }+ M
238.     }
     
239.     fclose(outfile);
     
240. }
     
241. 
     % t% G: C" E+ R1 L/ K" r2 b
242. static int load_and_copy_rbt_header(rbt_dec_context *rbt, FILE *inrbt_file, FILE *outrbt_file)
     
243. {
     
244.     uint8_t header[RBT_HEADER_SIZE];
     " G) |3 p, _1 L3 G) ^9 r
245.     int palette_data_size;
     3 t5 c2 y4 j$ {5 q5 y7 L; p- G. N
246.     uint8_t *palette_chunk;
     + r$ U" C& ^5 c* i' K  D
247.     int unknown_chunk_size;
     
248.     uint8_t *unknown_chunk;
     0 R8 Z0 x" l0 z( {+ N9 b
249.     uint8_t unknown_table[UNKNOWN_TABLE_SIZE];
     " m* M: n- g6 I/ P5 W) S
250.     off_t padding_size;
     $ V; x/ M  ~5 u: E* r' ^7 Y' v
251.     uint8_t *padding;
     
252.     int i;
     
253.     int frame_size;
     
254.     int max_frame_size;
     
255.     int first_palette_index;
     , E) D8 @" ]0 b& _) |" l% N$ Z
256.     int palette_count;
     
257.     int palette_type;
     
258.     int palette_index;
     ) s( S7 n. [/ N/ L6 x- ]4 F1 ~
259. 
     
260.     fseek(inrbt_file, 0, SEEK_SET);
     
261.     fseek(outrbt_file, 0, SEEK_SET);
     3 e, P2 G( O( p  s
262. 
     2 W4 L$ V: A. q2 M2 ^
263.     /* load the header */
     
264.     if (fread(header, RBT_HEADER_SIZE, 1, inrbt_file) != 1)
     , Y4 j. \2 o- p2 `# m% {
265.     {
     / ?& z% b* d/ _. M# D/ D- s
266.         printf("problem reading initial RBT header\n");
     
267.         return 0;
     % b2 L8 j2 u2 Q" M- z% \
268.     }
     
269. 
     1 ?# \. m7 g& c2 n
270.     /* copy header to the output */
     : y# N2 `0 F0 |( @8 c  Y
271.     if (fwrite(header, RBT_HEADER_SIZE, 1, outrbt_file) != 1)
     
272.     {
     
273.         printf("problem writing initial RBT header\n");
     7 l7 F$ s6 S( i2 m3 s0 B) _; c. q- q* D
274.         return 0;
     
275.     }
     
276. 
     8 V+ h, r( o  R- ~5 w" ]0 D
277.     rbt->version = LE_16(&header[6]);
     
278.     rbt->audio_chunk_size = LE_16(&header[8]);
     1 S" A; h) ?! s& x
279.     rbt->frame_count = LE_16(&header[14]);
     - K* h( C" n8 r* o) A
280. 
     6 m* w; j; G" _
281.     /* transfer the unknown data, if it's there */
     7 s* b( E* T) _2 J
282.     unknown_chunk_size = LE_16(&header[18]);
     
283.     if (unknown_chunk_size > 0)
     / u: v: A) r6 ~& L$ L, |
284.     {
     
285.         unknown_chunk = malloc(unknown_chunk_size);
     / v4 O% V% Y/ R7 k% r& k
286.         if (fread(unknown_chunk, unknown_chunk_size, 1, inrbt_file) != 1)
     
287.         {
     2 n/ w: f. ~# M9 k2 J' ~
288.             printf("problem reading unknown data\n");
     8 m( K' f6 e. P2 i  P6 O
289.             return 0;
     ! X# d  J. ]) X8 ^4 [
290.         }
     
291.         if (fwrite(unknown_chunk, unknown_chunk_size, 1, outrbt_file) != 1)
     
292.         {
     ( u* L0 e3 M# K# Q
293.             printf("problem writing unknown data\n");
     $ R5 x& b8 b+ t) D1 _
294.             return 0;
     % ~0 G/ j! U4 m/ N+ p0 ?
295.         }
     
296.         free(unknown_chunk);
     & U; \% h* [$ K- O8 j; j
297.     }
     % ^( W% |1 ^  p6 H
298. 
     7 \3 W  m* |0 l* r; T. R
299.     /* transfer the palette chunk */
     
300.     palette_data_size = LE_16(&header[16]);
     
301.     palette_chunk = malloc(palette_data_size);
     & B9 m6 c7 A* N0 ~: }9 o; B6 m. a
302.     if (fread(palette_chunk, palette_data_size, 1, inrbt_file) != 1)
     
303.     {
     
304.         printf("problem reading palette\n");
     " X3 a9 C6 @: R+ x, V
305.         return 0;
     - x3 I; e( P& r* F
306.     }
     
307.     if (fwrite(palette_chunk, palette_data_size, 1, outrbt_file) != 1)
     ; T$ D2 X" x( H8 M( T+ {
308.     {
     8 Z! N/ W1 V( l9 b( }2 @
309.         printf("problem writing palette\n");
     
310.         return 0;
     
311.     }
     3 B: P3 H$ H$ {
312.     /* load the palette into the internal context */
     ! s) B/ ]' G' U" ?
313.     memset(rbt->palette, 0, PALETTE_COUNT * 3);
     
314.     first_palette_index = palette_chunk[25];
     
315.     palette_count = LE_16(&palette_chunk[29]);
     
316.     palette_type = palette_chunk[32];
     2 O) d* V; p3 H! ~: T4 H
317.     palette_index = (palette_type == 0) ? 38 : 37;
     
318.     for (i = first_palette_index; i < first_palette_index + palette_count; i++)
     
319.     {
     9 z9 a9 t) p9 k+ |# ]
320.         rbt->palette[i*3+0] = palette_chunk[palette_index++];
     
321.         rbt->palette[i*3+1] = palette_chunk[palette_index++];
     
322.         rbt->palette[i*3+2] = palette_chunk[palette_index++];
     
323.     }
     
324.     free(palette_chunk);
     
325. 
     
326.     /* copy the video frame size table (2 bytes per frame), as a placeholder */
     
327.     rbt->video_frame_size_table = malloc(rbt->frame_count * sizeof(uint16_t));
     / g: ~* p2 j: m( d* o  V
328.     if (fread(rbt->video_frame_size_table, rbt->frame_count * sizeof(uint16_t), 1, inrbt_file) != 1)
     - b: B& G0 [  o* j7 ]: p7 b
329.     {
     ( m# S0 }' O% \. ?% u% j
330.         printf("problem reading frame table\n");
     ! ^+ Q1 z9 k, \8 Q4 X
331.         return 0;
     : N4 Q2 E* C& ]# Y9 f; K" v5 x
332.     }
     0 r8 N) b# g6 N- Y( M( _+ N
333.     rbt->video_frame_size_table_offset = ftell(outrbt_file);
     
334.     if (fwrite(rbt->video_frame_size_table, rbt->frame_count * sizeof(uint16_t), 1, outrbt_file) != 1)
     ! \# A7 j& `6 b- I, h" l  A
335.     {
     ) E% ?* ^3 ]' I
336.         printf("problem writing frame table\n");
     4 E8 J3 }* I/ Y3 l5 Z
337.         return 0;
     
338.     }
     $ M  `% E& P  J! o( @' M2 z9 I
339. 
     
340.     /* copy the frame size table (2 bytes per frame), as a placeholder */
     
341.     rbt->frame_size_table = malloc(rbt->frame_count * sizeof(uint16_t));
     
342.     if (fread(rbt->frame_size_table, rbt->frame_count * sizeof(uint16_t), 1, inrbt_file) != 1)
     
343.     {
     4 k/ A1 ~4 l- U, l9 Z! o. `/ ]! r
344.         printf("problem reading frame table\n");
     
345.         return 0;
     / P6 a  G% T+ S0 F' D
346.     }
     
347.     rbt->frame_size_table_offset = ftell(outrbt_file);
     & ?6 q# z1 D0 L
348.     if (fwrite(rbt->frame_size_table, rbt->frame_count * sizeof(uint16_t), 1, outrbt_file) != 1)
     & J: Z! U) b5 z% c& k& [
349.     {
     2 j$ C/ [6 N8 e/ e8 B" @8 ^: y
350.         printf("problem writing frame table\n");
     ' v$ {8 q7 K7 E) _  p
351.         return 0;
     
352.     }
     
353. 
     ) k, ?: w6 j" {1 o
354.     /* find the max frame size */
     , N* G; ^! o, x6 W0 r
355.     max_frame_size = 0;
     ) j" h- @+ w9 K& t: f; L8 n3 B
356.     for (i = 0; i < rbt->frame_count; i++)
     
357.     {
     
358.         frame_size = LE_16(&rbt->frame_size_table[i*2]);
     * R! d3 Z+ d: J# U
359.         if (frame_size > max_frame_size)
     
360.             max_frame_size = frame_size;
     $ w5 z+ `: L, V% U6 Z- q' y
361.     }
     
362.     rbt->frame_load_buffer = malloc(max_frame_size);
     
363. 
     9 g( M3 h1 P- _$ _4 q. R4 S7 P  t4 k0 C# y
364.     /* transfer the unknown table(s) */
     
365.     if (fread(unknown_table, UNKNOWN_TABLE_SIZE, 1, inrbt_file) != 1)
     & P3 O. b% L( [( g* Q# D
366.     {
     ! p* }" @: k* u, }' o, }. N) e
367.         printf("problem reading unknown table\n");
     
368.         return 0;
     
369.     }
     
370.     if (fwrite(unknown_table, UNKNOWN_TABLE_SIZE, 1, outrbt_file) != 1)
     ( A: C2 ?1 C) d" g2 r
371.     {
     
372.         printf("problem writing unknown table\n");
     5 y( l$ y) s' J/ n
373.         return 0;
     
374.     }
     . ?  F# T7 [6 e* [6 f" G6 S
375. 
     
376.     /* copy over padding */
     
377.     padding_size = 0x800 - (ftell(inrbt_file) & 0x7FF);
     ) ~# o8 S6 Q' l2 g) D! J
378.     if (padding_size)
     
379.     {
     
380.         padding = malloc(padding_size);
     0 _- N1 J/ H7 F% L1 _
381.         if (fread(padding, padding_size, 1, inrbt_file) != 1)
     9 Y' p9 U- k9 R* Z7 I' d/ D
382.         {
     3 [" q+ f: J; l* Z9 Q  ]
383.             printf("problem reading padding\n");
     3 ?2 ^: s/ G! k; M
384.             return 0;
       e# s! P4 M$ G9 _
385.         }
     
386.         if (fwrite(padding, padding_size, 1, outrbt_file) != 1)
     
387.         {
     , f6 P2 O- b0 Z# Y0 ]
388.             printf("problem writing padding\n");
     ; m0 d# j) L6 [7 {+ Q  r7 L
389.             return 0;
     
390.         }
     . R- L& ?' B: J, D8 {7 D
391.         free(padding);
     . g  p; I1 Q7 e
392.     }
     , B6 T# {) m2 p1 t' K
393. 
     ' I$ \' s& }% v9 E  P
394.     return 1;
     
395. }
     
396. 
     / y/ R8 _7 d4 J* e4 \4 G/ L
397. static int get_lzs_back_ref_length(get_bits_context *gb)
     
398. {
     
399.     int vlc;
     : o- l9 I/ r8 u  P) v9 Q4 G
400.     int count;
     3 c( P) q0 I: D" I3 l% S
401.     int value;
     
402. 
     3 i1 o! Z. \3 K0 ^6 I" ^
403.     vlc = view_bits(gb, VLC_SIZE);
     4 W: Y5 D# M6 u# a" h" c
404.     count = lzs_vlc_table[vlc].count;
     
405.     value = lzs_vlc_table[vlc].value;
     
406. 
     
407.     read_bits(gb, count);
     ) e9 i/ d" O0 C
408.     if (value == 8)
     
409.     {
     
410.         do
     & a" H1 H* |% G+ x# b$ T
411.         {
     
412.             vlc = read_bits(gb, VLC_SIZE);
     / p4 z5 [4 L6 P# o2 ?, M
413.             value += vlc;
     # E" `( J+ o! _$ [2 i; M% j- u
414.         }
     . v2 n: P) \; O( ?0 |6 t& d9 B
415.         while (vlc == 0xF);
     
416.     }
     % Y3 U9 S  x: T' C, {; [
417. 
     
418.     return value;
     ! @  m0 v- I( n
419. }
     
420. 
     
421. static void compress_window(put_bits_context *pb, uint8_t *full_window,
     
422.     int full_window_stride,
     ! l( Y& R7 D* @: m) G
423.     int window_top, int window_bottom, int window_left, int window_right)
     
424. {
     
425.     int last_pixel;
     6 u" A4 f. t8 k$ B' ]
426.     int run_size;
     ( R( q3 {$ [/ c2 }
427.     int x;
     # A  D4 W8 \. I" r/ M+ h
428.     int y;
     
429.     int start_index;
     1 a" p" p5 z7 Z% j4 J& e
430.     int end_index;
     " H! {3 |; V) b2 z0 Z: J$ ^
431.     int encode_last_run;
     
432. 
     
433.     last_pixel = full_window[0];
     8 ^9 u* p( S7 j* b6 m
434.     run_size = 1;
     8 ]2 E7 U4 F7 T. ?
435.     for (y = window_top; y <= window_bottom; y++)
     / E3 E' j( X1 a( n6 s8 z6 _
436.     {
     2 I/ G* o) o& l- u  s9 w
437.         start_index = y * full_window_stride + window_left;
     + v% N$ C* i( j( }( @) P
438.         if (y == window_top)
     
439.             start_index += 1;
     
440.         end_index = y * full_window_stride + window_right;
     9 r6 }1 U* b5 z
441.         if (y == window_bottom)
     . C- H$ \3 K, x3 h7 S
442.             encode_last_run = 1;
     & F6 @3 @) `  ^( @/ h
443.         else
     
444.             encode_last_run = 0;
     
445.         for (x = start_index; x < end_index; x++)
     
446.         {
     5 G5 @' O* U$ c& S0 d: {' l+ g
447.             if (!encode_last_run && full_window[x] == last_pixel)
     ' M: p9 z! r3 v; h
448.                 run_size++;
     
449.             else
     7 f/ e4 n- _' |+ I: W
450.             {
     
451.                 if (run_size == 1)
     
452.                 {
     9 S  H0 R) b6 x, O8 E
453.                     /* encode a 0 bit followed by raw pixel byte */
     " y; G7 h  ~0 W4 m% i
454.                     put_bits(pb, 0, 1);
     
455.                     put_bits(pb, last_pixel, 8);
     
456.                 }
     
457.                 else if (run_size == 2)
     & ~' ?/ |' x  A  E4 s
458.                 {
     4 m: f/ g7 L9 F5 z0 C7 R
459.                     /* encode a 0 bit followed by raw pixel byte */
     
460.                     put_bits(pb, 0, 1);
     
461.                     put_bits(pb, last_pixel, 8);
     4 B3 q* x& D1 U6 R# |) g  G. L2 I5 u
462.                     put_bits(pb, 0, 1);
     / ?  y! x( ^& B! q- H. e6 H3 P3 F
463.                     put_bits(pb, last_pixel, 8);
     
464.                 }
     
465.                 else
     . d; g8 O3 L/ [5 L
466.                 {
     0 r. Q7 _5 [. o8 {& D5 o4 U6 u
467.                     /* encode a 0 bit followed by raw pixel byte */
     
468.                     put_bits(pb, 0, 1);
     - z  Y* C* |9 H1 U
469.                     put_bits(pb, last_pixel, 8);
     & u4 A1 w4 b: `2 t- Z4 {) U9 D
470.                     run_size--;
     
471.                     /* encode a run: a 1 bit, followed by a back reference
     
472.                      * offset (-1), followed by a length */
     - C1 V8 ^6 v& a2 _$ R* H
473.                     put_bits(pb, 1, 1);
     3 u8 y3 O/ A' C% |
474.                     put_bits(pb, 1, 1);  /* 1 = 7-bit offset */
     
475.                     put_bits(pb, 1, 7);
     
476.                     if (run_size <= 4)
     
477.                     {
     
478.                         /* lengths 2, 3, and 4 are 2 bits */
     ' n# b7 z4 r. P) H
479.                         put_bits(pb, run_size - 2, 2);
     * o+ U, e5 p7 t
480.                     }
     
481.                     else if (run_size <= 7)
     ' K4 z* `+ n& Y/ l
482.                     {
     
483.                         /* lengths 5, 6, and 7 are 4 bits */
     
484.                         put_bits(pb, run_size + 7, 4);
     5 w6 |' Y* m9 ~5 U9 n1 c- I  U
485.                     }
     $ @7 a* e8 y, g) a& v- l4 j
486.                     else
     - k( z3 J. \, }+ I* w+ v
487.                     {
     1 c2 `! ~- X: R' p! `1 w+ C$ n
488.                         /* arbitrary length; start by encoding 0xF which
     " G/ q* O/ R6 [8 m2 R# B
489.                          * stands in for an initial version of 8 */
     # {& ^( y7 J5 ?& r$ Z1 N* Z
490.                         put_bits(pb, 0xF, 4);
     & C7 F8 C7 Q: t9 ^" d
491.                         run_size -= 8;
     ( j) J# ~6 K5 j) h% L# @# v; z
492. 
     : W. z: j) J, U' U) M
493.                         /* encode blocks of 4 bits until run_size is 0 */
     
494.                         while (run_size >= 0)
     7 R4 H% A$ u& M4 z+ B
495.                         {
     ( D/ [/ z5 u' x3 z* N" Y
496.                             if (run_size >= 15)
     
497.                             {
     - P3 G: Y( z' C2 d5 d5 S
498.                                 put_bits(pb, 0xF, 4);
     
499.                                 run_size -= 0xF;
     " o0 l4 h; b- Z  Q3 z2 g
500.                             }
     : {( K1 G/ E! S; `
501.                             else
     & ?5 E, P$ N5 S+ A. T
502.                             {
     7 u% k' ~- G0 A- G& i
503.                                 put_bits(pb, run_size, 4);
     
504.                                 run_size = -1;
     
505.                             }
     + \* p) x/ }4 Y; m9 V9 R
506.                         }
     ' X3 ]+ T# X& u: b' A# u
507.                     }
     ) Y3 n. W4 e) x( K1 @" x1 }
508.                 }
     1 N) ?; n3 L, d; @+ v
509. 
     # a9 h# I& ~3 U) m
510.                 last_pixel = full_window[x];
     * r2 _. z; V' |( i
511.                 run_size = 1;
     
512. 
     5 r7 x- [2 d) g  V% x4 e
513.                 /* this single x iteration was only here to close the final run */
     
514.                 if (y == window_bottom)
     9 j. ]) O8 ]6 C3 r
515.                     break;
     
516.             }
     
517.         }
     
518.     }
     6 f7 ~1 d+ Z* m1 n
519. 
     
520.     /* close the bitstream by encoding a back reference with length 0 */
     
521.     put_bits(pb, 1, 1);  /* back reference run */
     $ K& s& A/ e# @0 ?& C1 g
522.     put_bits(pb, 1, 1);  /* 1 = 7-bit offset */
     
523.     put_bits(pb, 0, 7);  /* length 0 */
     
524. 
     - ?' c1 C) d- T+ z. {, L4 F
525.     put_bits_flush(pb);
     , w6 f# i/ b# y
526. }
     ; n6 f: {. g0 ^- D% n) ^- s- B3 M% v, i! `
527. 
     5 f! \4 c  ]( J0 n% S7 |
528. /* compute Euclidean distance between an RGB color and the desired target */
     0 H/ P( u1 s9 `+ s3 N3 v6 H
529. static int compute_rgb_distance(int r1, int r2, int g1, int g2, int b1, int b2)
     
530. {
     7 i( k3 }, P3 J' T' z
531.     return sqrt((r1 - r2) * (r1 - r2) +
     
532.                 (g1 - g2) * (g1 - g2) +
     # M( T; |/ f) g
533.                 (b1 - b2) * (b1 - b2));
     
534. }
     : X. C8 ~% K9 S: x- m% f) |/ C
535. 
     " a/ P- Q, S; M$ Q
536. static uint8_t find_nearest_color(rbt_dec_context *rbt, int r, int g, int b)
     
537. {
     
538.     int i;
     : H- s. b+ R, P
539.     int nearest_distance;
     ( O" f1 V) p$ H5 E& o7 y" g
540.     int distance;
     8 b7 G; B" J% N' E6 t- n& {  ^: |
541.     int rp;
     * U5 u# @8 ?) h
542.     int gp;
     - {+ v- S9 d- W* `% p3 G' N
543.     int bp;
     
544.     uint8_t palette_index;
     ; \4 r7 o; U# H1 F5 E# k+ {8 I
545. 
     
546.     nearest_distance = 999999999;
     
547.     palette_index = 0;
     ' w- |8 |9 t9 M4 ?1 J* @& u
548.     for (i = 0; i < 256; i++)
     # O/ Z+ [' c2 M$ t
549.     {
     
550.         rp = rbt->palette[i * 3 + 0];
     
551.         gp = rbt->palette[i * 3 + 1];
     
552.         bp = rbt->palette[i * 3 + 2];
     ( G: Q2 ]5 r3 m4 i8 s# u) T
553.         distance = compute_rgb_distance(r, rp, g, gp, b, bp);
     3 M2 X& j4 C7 q" t
554.         if (distance < nearest_distance)
     2 T) K+ s! A/ T3 c) c: b3 F# L
555.         {
     
556.             nearest_distance = distance;
     
557.             palette_index = i;
     
558.         }
     7 Q( y5 J5 {9 y! L# V3 u
559.         /* can't get closer than 0; break early */
     & A8 \3 z, }# ~: y* c. M3 G
560.         if (distance == 0)
     
561.             break;
     
562.     }
     & P0 p, z. V3 n* l: w
563. 
     % L" u: p5 H, J) s& W% T! |
564.     return palette_index;
     1 ]' N) g" M4 ?3 z3 ~9 ]) @
565. }
     * Q2 x* p1 |' ?! r. V: x2 g
566. 
     7 a. V+ v) G' ^
567. static void subtitle_frame(rbt_dec_context *rbt, uint8_t *frame,
     
568.     int width, int height, int timestamp)
     
569. {
     2 [5 h/ ?1 t( `0 O2 x% r
570.     ASS_Image *subtitles;
     
571.     int detect_change;
     
572.     uint8_t subtitle_pixel;
     
573.     int x, y;
     ' W" ]5 X  a# J' F* x0 j. v* N
574.     uint8_t *frame_ptr;
     ! U2 Z9 f0 M% F* g
575.     uint8_t *subtitle_ptr;
     ; A- a$ L, ?# _( w9 k5 q' H6 f" z
576. 
     & {, `- v* S9 J/ k! T6 R2 G( L4 p
577.     /* ask library for the subtitle for this timestamp */
     
578.     subtitles = ass_render_frame(rbt->ass_renderer, rbt->ass_track,
     
579.         timestamp, &detect_change);
     
580. 
     5 }$ n2 e+ H7 S. Z  L1 M1 J0 y' e
581.     /* render the list of subtitles onto the decoded frame */
     4 l2 q# E5 t/ f- a2 K5 I
582.     while (subtitles)
     * a' z# h  U6 g  ~, c, [% c5 U
583.     {
     " n0 u$ F" ^7 v
584.         /* palette components are only 6 bits, so shift an extra 2
     
585.          * bits off each component */
     8 y' [9 N6 P9 r6 d
586.         subtitle_pixel = find_nearest_color(rbt,
     
587.             (subtitles->color >> 10) & 0xFF,
     
588.             (subtitles->color >> 18) & 0xFF,
     5 I5 M' ^/ }) I/ G# P
589.             (subtitles->color >> 26) & 0xFF);
     - A) w" |7 _' i+ v
590.         for (y = 0; y < subtitles->h; y++)
     
591.         {
     
592.             subtitle_ptr = &subtitles->bitmap[y * subtitles->stride];
     
593.             frame_ptr = &frame[(subtitles->dst_y + y) * width + subtitles->dst_x];
     . s( p; e1 h2 R5 E
594.             for (x = 0; x < subtitles->w; x++, frame_ptr++, subtitle_ptr++)
     : y8 J9 f: c5 `" E  p5 H0 M: J
595.             {
     
596.                 if (*subtitle_ptr >= SUBTITLE_THRESHOLD)
     - G# H4 L) L4 ?! K9 Z- H
597.                     *frame_ptr = subtitle_pixel;
     
598.             }
     ) I1 L0 f9 E* I& x+ e) m
599.         }
     
600.         subtitles = subtitles->next;
     4 ]2 m" _1 Y: b  C- A
601.     }
     
602. }
     
603. 
     ; I8 C) R+ y7 ?. P) u% o* B& ?
604. static int copy_frames(rbt_dec_context *rbt, FILE *inrbt_file, FILE *outrbt_file,
     
605.     int origin_x, int origin_y, int window_width, int window_height)
     : {& }; |3 v! Y& m# @: M1 s
606. {
     
607.     int i;
     6 y) O3 W  l: t0 n, i) E
608.     int j;
     
609.     int scale;
       Y3 p, D& A8 }0 d# `$ c" E
610.     int width;
     
611.     int height;
     
612.     int max_width;
     1 ]% F. L! R' w
613.     int max_height;
     
614.     int frame_x;
     " i" `1 E% n6 M) q! U! ^6 f* W/ z; }
615.     int frame_y;
     1 i! r( `4 d# \; F# D
616.     int fragment_count;
     . Q( h3 ~& H( D6 f( r- i# a) P
617.     int decoded_size;
     
618.     uint8_t *decoded_frame;
     
619.     int fragment;
     
620.     int fragment_compressed_size;
     
621.     int fragment_decompressed_size;
     * D+ {9 P- T; A  o
622.     int compression_type;
     % j( `0 I+ y% i3 v
623.     int index;
     1 v9 ]. e! {0 `. S+ _
624.     int out_index;
     # V6 X, V+ c+ N. R( W$ O$ i
625.     get_bits_context gb;
     
626.     int frame_size;
     
627.     int video_frame_size;
     : D( `) k& u! @4 V* O+ `9 E
628.     int audio_frame_size;
     
629. 
     
630.     int back_ref_offset_type;
     
631.     int back_ref_offset;
     . J6 W0 D! o: a# d
632.     int back_ref_length;
     
633.     int back_ref_start;
     5 S) c% g' Z( a) q+ s( I0 N
634.     int back_ref_end;
     
635. 
     
636.     uint8_t *full_window;
     & I$ U4 f) q7 a/ E2 w
637.     int full_window_size;
     
638.     int y;
     5 h% s: E& J1 n7 P$ f
639.     int window_top;
     4 {" S; ~$ ]1 m& A2 `& R
640.     int window_bottom;
     7 f- I3 k( m: j0 v) P. R
641.     int window_left;
     , J2 M; F  U0 o2 L: s* k
642.     int window_right;
     
643.     int window_size;
     
644. 
     
645.     char filename[30];
     9 F6 r" z) c' J1 C$ N* Y. S
646. 
     " `9 ^+ k& q' u  m0 G+ u( z
647.     put_bits_context *pb;
     ! y0 P6 o$ G+ W2 e. D. w7 o
648. 
     
649.     full_window_size = window_width * window_height;
     & f9 c( l7 x9 {0 [/ ]$ j
650.     full_window = malloc(full_window_size);
     ! Y$ N9 j9 U, t/ g
651.     pb = init_put_bits();
     
652. 
     
653.     max_width = 0;
     
654.     max_height = 0;
     ' T- i, K  N2 y1 {6 J* N
655. 
       _5 e8 F& m. I: i- A) I
656.     for (i = 0; i < rbt->frame_count; i++)
     
657.     {
     
658.         /* read the entire frame (includes audio and video) */
     7 h9 j8 K; S- X1 n' s6 K- W
659.         frame_size = LE_16(&rbt->frame_size_table[i*2]);
     / o9 A8 F; Z0 F2 J
660.         video_frame_size = LE_16(&rbt->video_frame_size_table[i*2]);
     
661.         audio_frame_size = frame_size - video_frame_size;
     + Z/ N, |2 n6 N; ~2 H* k6 k
662.         if (fread(rbt->frame_load_buffer, frame_size, 1, inrbt_file) != 1)
     
663.         {
     3 l4 d( a! d" T# H" N; g( T) D: O, T
664.             printf("problem reading frame %d\n", i);
     
665.             return 0;
     
666.         }
     
667. 
     2 ]  U2 P" g& s/ I
668.         scale = rbt->frame_load_buffer[3];
     ! V4 h9 k+ F7 d0 i# k
669.         width = LE_16(&rbt->frame_load_buffer[4]);
     
670.         if (max_width < width)
     
671.             max_width = width;
     2 G+ ?3 l5 H: }5 @8 z
672.         if (max_height < height)
     
673.             max_height = height;
     8 _' z7 |4 n7 P. W2 ?6 I
674.         height = LE_16(&rbt->frame_load_buffer[6]);
     6 C% c9 y) ?! M! e% w- X
675.         frame_x = LE_16(&rbt->frame_load_buffer[12]);
     
676.         frame_y = LE_16(&rbt->frame_load_buffer[14]);
     5 {. V$ J3 o- a8 F/ J7 |
677.         fragment_count = LE_16(&rbt->frame_load_buffer[18]);
     0 p6 m8 b* i% q/ S
678.         decoded_size = width * height;
     
679. 
     2 T. c+ ?, d. V6 j* }0 A' _
680.         printf("processing frame %d: %d%%, %dx%d, origin @ (%d, %d), %d fragments\n", i, scale, width, height, frame_x, frame_y, fragment_count);
     ( j3 Q+ f4 n5 x5 f/ [6 O
681. 
     ( S4 P7 A8 U+ B$ J! y+ {3 S
682.         /* decode the frame */
     / E3 k  a8 B7 k6 P! r
683.         decoded_frame = malloc(decoded_size);
     
684.         index = 24;
     $ }$ [1 O, H7 H2 [
685.         out_index = 0;
     ; s7 g5 G, M1 P& V6 w; s
686.         for (fragment = 0; fragment < fragment_count; fragment++)
     ; ]* j1 R, n6 F! h$ G
687.         {
     
688.             fragment_compressed_size = LE_32(&rbt->frame_load_buffer[index]);
     , R' Q" E0 C# F: x# W! Q( _
689.             index += 4;
     % b, ~: u* m  t; H
690.             fragment_decompressed_size = LE_32(&rbt->frame_load_buffer[index]);
     - U. V2 g: l4 e. V4 U: y. r* p
691.             index += 4;
     
692.             compression_type = LE_16(&rbt->frame_load_buffer[index]);
     
693.             index += 2;
     
694. 
     . w) y7 E7 t* @+ ^) W% k( F
695.             if (compression_type == 0)
     ( s% v$ U% V7 B3 ~
696.             {
       M! `7 Z& M; ]9 X/ t
697.                 init_get_bits(&gb, &rbt->frame_load_buffer[index],
     $ n  ^. D0 G; x7 M9 D$ t
698.                     fragment_compressed_size);
     0 h  K% e! z; _$ K9 {
699. 
     
700.                 while (out_index < fragment_decompressed_size)
     
701.                 {
     8 ~. G( U) F. F* u; {( p
702.                     if (read_bits(&gb, 1))
     
703.                     {
     6 F' G+ i; y9 m
704.                         /* decode back reference offset type */
     
705.                         back_ref_offset_type = read_bits(&gb, 1);
     5 g% a9 {5 C" }: E* i- f" z) H* ^' d
706. 
     
707.                         /* back reference offset is 7 or 11 bits */
     & D) [1 F/ v$ O$ c& z$ l
708.                         back_ref_offset = read_bits(&gb,
     
709.                             (back_ref_offset_type) ? 7 : 11);
     
710. 
     " e; _& P' C8 V) s/ E
711.                         /* get the length of the back reference */
     
712.                         back_ref_length = get_lzs_back_ref_length(&gb);
     
713.                         back_ref_start = out_index - back_ref_offset;
     
714.                         back_ref_end = back_ref_start + back_ref_length;
     7 l2 B- H$ a' X8 I9 L' G8 i
715. 
     
716.                         /* copy the back reference, byte by byte */
     6 l! w3 ?. y4 z
717.                         for (j = back_ref_start; j < back_ref_end; j++)
     ! h7 d/ {& L, l9 k4 C* [8 ~  _& P: D
718.                             decoded_frame[out_index++] = decoded_frame[j];
     
719.                     }
     
720.                     else
     3 d6 z( P; H& b4 T2 u2 |6 A; O
721.                     {
     1 U. c1 N2 J# _+ _" l  x' J6 F" d
722.                         /* read raw pixel byte */
     ! g, O  o% u3 H  J$ s' z7 T
723.                         decoded_frame[out_index++] = read_bits(&gb, 8) & 0xFF;
     
724.                     }
     3 I% O  f) N* W' z
725.                 }
     ; L0 W% a# U. Y/ E: u' }
726. 
     
727.                 delete_get_bits(&gb);
     7 |0 Q% [  [% t; e* x6 W4 h
728.             }
     9 l$ O+ l) a* M
729. 
     
730.             /* next fragment */
     # {  q. r# G# l" q8 A4 Z' `
731.             index += fragment_compressed_size;
     
732.         }
     7 H' y5 U: b" @3 ^9 V  w8 Y
733. 
     
734.         if (rbt->dump_frames)
     
735.         {
     
736.             /* dump the original frame */
     
737.             sprintf(filename, "original-frame-%03d.pnm", i);
     . z+ q9 b. V' v
738.             dump_pnm_file(filename, rbt, decoded_frame, width, height);
     1 |6 ]0 y: ~! _" Q, y7 v5 R
739.         }
     
740. 
     
741.         /* transfer the image onto the frame window */
     3 O1 O) z5 I. I) L" i
742.         memset(full_window, 0xFF, full_window_size);
     
743.         index = 0;
     & A* ^+ Y% Z7 ?  M% x. i
744.         for (y = 0; y < height; y++)
       g1 X! E* {- O2 F+ o& s  R
745.         {
     0 _2 s7 r8 y: ^( `. d' [# x
746.             out_index = window_width * (frame_y + y) + frame_x;
     : L/ E& L4 h. u" w1 ?
747.             memcpy(&full_window[out_index], &decoded_frame[index], width);
     
748.             index += width;
     
749.         }
     - g6 V3 {0 j9 U0 K
750. 
     
751.         /* write the subtitle */
     
752.         subtitle_frame(rbt, full_window, window_width, window_height,
     ( w. U' p1 j+ C5 c
753.             i * MILLISECONDS_PER_FRAME);
     % x* J& }1 i# d
754. 
     
755.         /* figure out the smallest change window */
     
756.         window_top = frame_y;
     " O8 ]. \' e; Z9 I9 m7 ?
757.         window_bottom = window_height;
     
758.         window_left = 0;
     7 W( U# g9 K$ H8 ?3 r8 j8 f: g! X
759.         window_right = window_width;
     6 p6 M1 u$ U. z, ]
760.         window_size = (window_right - window_left) * (window_bottom - window_top);
     / h! q: w; l6 @- _
761. 
     ( K# `( C- h9 V, i% |( o; ?" f( l# m
762.         /* compress the frame */
     
763.         reset_put_bits(pb);
     : m+ g8 m9 k7 X1 D
764.         compress_window(pb, full_window, window_width, window_top,
     
765.             window_bottom, window_left, window_right);
     
766. 
     & [3 |' b1 e( x1 ~' w9 A: m0 `5 p+ @
767.         if (rbt->dump_frames)
     3 i$ B2 |2 t' B, h' V% e
768.         {
     : ]8 B- E/ X0 i4 p
769.             /* dump the frame plotted onto the full window prior to encoding,
     
770.              * with subtitle */
     
771.             sprintf(filename, "pre-encoding-frame-%03d.pnm", i);
     
772.             dump_pnm_file(filename, rbt, full_window, window_width, window_height);
     
773.         }
     3 k9 I- R; w, b3 C  r  [0 G2 q+ M
774. 
     
775.         free(decoded_frame);
     ( E7 y# s8 [$ p1 y$ J: i; `7 G
776. 
     
777.         /* update the frame header */
     # t0 g( G" \: x- V. L
778.         /* width */
     8 U& s3 O0 Q$ Y) E. Q6 S
779.         rbt->frame_load_buffer[4] = (window_right - window_left) & 0xFF;
     0 h" ~  v1 g0 B, N$ v+ `5 k2 ?
780.         rbt->frame_load_buffer[5] = (window_right - window_left) >> 8;
     
781.         /* height */
     
782.         rbt->frame_load_buffer[6] = (window_bottom - window_top) & 0xFF;
     5 e+ n: p5 c- N: w: t7 s
783.         rbt->frame_load_buffer[7] = (window_bottom - window_top) >> 8;
     
784.         /* origin X */
     
785.         rbt->frame_load_buffer[12] = window_left & 0xFF;
     
786.         rbt->frame_load_buffer[13] = window_left >> 8;
     
787.         /* origin Y */
     . b) W/ M& e% [1 o3 R
788.         rbt->frame_load_buffer[14] = window_top & 0xFF;
     
789.         rbt->frame_load_buffer[15] = window_top >> 8;
     1 e8 w: o! ~" w0 g; p- Y2 A, D
790.         /* fragment payload size */
     # [) e$ L% i- q/ \# r0 G- j! L
791.         rbt->frame_load_buffer[16] = (pb->byte_index + 10) & 0xFF;
     
792.         rbt->frame_load_buffer[17] = (pb->byte_index + 10) >> 8;
     6 }9 ?2 ~: Y( V5 p' l' V
793.         /* fragment count (1) */
     
794.         rbt->frame_load_buffer[18] = 1;
     . h, Z- u/ V8 S4 x- ?5 r
795.         rbt->frame_load_buffer[19] = 0;
     # g3 S! p% z! N6 r! E# B
796. 
     
797.         /* update the fragment header */
     ( g% ~# e6 x( x3 E" {! S: a
798.         /* compressed size */
     & C- p$ _+ N% b2 j' w5 q( w
799.         rbt->frame_load_buffer[24 + 0] = (pb->byte_index >>  0) & 0xFF;
     
800.         rbt->frame_load_buffer[24 + 1] = (pb->byte_index >>  8) & 0xFF;
     
801.         rbt->frame_load_buffer[24 + 2] = (pb->byte_index >> 16) & 0xFF;
     1 D4 E) n  q" K6 s
802.         rbt->frame_load_buffer[24 + 3] = (pb->byte_index >> 24) & 0xFF;
     9 E. V6 Y; I# o  U! }' f
803.         /* decompressed size */
     
804.         rbt->frame_load_buffer[24 + 4] = (window_size >>  0) & 0xFF;
     ! E' K  m3 q  g* `% O; [
805.         rbt->frame_load_buffer[24 + 5] = (window_size >>  8) & 0xFF;
     2 T6 X- u7 A2 W4 f7 i  v. G
806.         rbt->frame_load_buffer[24 + 6] = (window_size >> 16) & 0xFF;
     
807.         rbt->frame_load_buffer[24 + 7] = (window_size >> 24) & 0xFF;
     
808.         /* compression format 0 */
     9 P- @/ n" C2 w2 j  d
809.         rbt->frame_load_buffer[24 + 8] = 0;
     
810.         rbt->frame_load_buffer[24 + 9] = 0;
     7 B% G$ t1 s! h% O1 @- j
811. 
     % t- F; o( {. T2 j
812.         /* write the 24-byte frame header and the 10-byte fragment header */
     
813.         if (fwrite(rbt->frame_load_buffer, 24 + 10, 1, outrbt_file) != 1)
     
814.         {
     
815.             printf("problem writing frame %d\n", i);
     / @, J- j- Q6 F5 ?, X
816.             return 0;
     
817.         }
     
818. 
     % z- W% L8 h2 n
819.         /* write the new compressed frame data */
     ( O8 O5 c; T* s3 h
820.         if (fwrite(pb->bytes, pb->byte_index, 1, outrbt_file) != 1)
     
821.         {
     
822.             printf("problem writing frame %d\n", i);
     2 \! d5 q* ?( I' ^
823.             return 0;
     
824.         }
     , g9 B0 W! h6 o) C4 P
825. 
     
826.         /* write the audio data */
     $ {5 N2 C" E3 L) l" T. F! v& [2 X
827.         if (fwrite(&rbt->frame_load_buffer[video_frame_size], frame_size - video_frame_size, 1, outrbt_file) != 1)
     9 d. V6 ?+ J$ S+ L) b
828.         {
     
829.             printf("problem writing frame %d\n", i);
     & L3 C8 ]( @& R9 S5 b1 P
830.             return 0;
     
831.         }
     ! \5 P% g* e5 j
832. 
     6 X; m$ u; i" c* ~% [" A
833.         /* update the table entries */
     
834.         video_frame_size = pb->byte_index + 24 + 10;
     % r8 |) o. t: |, e( \% k! Z
835.         frame_size = video_frame_size + audio_frame_size;
     % \& n7 N8 O8 u5 W
836.         rbt->frame_size_table[i*2+0] = frame_size & 0xFF;
     , D3 [, e( o/ {3 E3 H  A
837.         rbt->frame_size_table[i*2+1] = frame_size >> 8;
     * z1 L" u$ m; W1 |
838.         rbt->video_frame_size_table[i*2+0] = video_frame_size & 0xFF;
     
839.         rbt->video_frame_size_table[i*2+1] = video_frame_size >> 8;
     ! {8 ^0 X9 A: R3 G
840.     }
     4 O; z) q1 e0 j  J
841. 
     
842.     printf("maximum dimensions seen are %dx%d\n", max_width, max_height);
     
843. 
     
844.     delete_put_bits(pb);
     
845.     free(full_window);
     
846. 
     * M% d" c! [7 \0 g6 A" Z/ I7 E
847.     return 1;
     6 ?, F) X* e  {
848. }
     8 q* }2 v" [- T: }+ ?% x- E( ~/ }  l
849. 
     ; n2 m! t6 V9 c! l) S" l
850. int main(int argc, char *argv[])
     
851. {
     ; O, _: [5 C1 U1 Z4 z/ R- A
852.     char *subtitle_filename;
     
853.     FILE *subtitle_file;
     ' {9 V, J5 ~9 ~. J( Q
854.     char *inrbt_filename;
     3 q5 E; F, }' I" i! c6 y3 ^9 G
855.     FILE *inrbt_file;
     $ b; m* u$ Y7 F# |) o4 V7 }
856.     char *outrbt_filename;
     
857.     FILE *outrbt_file;
     ( H/ K( ?' |  X2 o6 Q. m3 w
858.     rbt_dec_context rbt;
     . T# V' b8 c  Y, N) {/ c' v
859.     int origin_x;
     $ y! W9 T. G# B- d( v1 u# H% m
860.     int origin_y;
     
861.     int window_width;
     
862.     int window_height;
     * X# F' e5 h$ |% `0 z& j
863. 
     ! a5 U9 ^' x  c  S4 C0 U& \/ Y
864.     /* testing the bit functions */
     1 \; B- q& G  ^
865. #if 0
     
866.     int i;
     ! }* \# ~$ ~6 n- }% E9 q: k8 w6 E) T, K+ V
867.     uint8_t bytestream[] = { 0x55, 0xAA, 0x00, 0xAA, 0x55, 0x77, 0xFF, 0x1B, 0x70, 0x8F };
     3 u( I2 t% |0 _& a
868.     int bytestream_size = 10;
     
869.     get_bits_context gb;
     0 ^* }/ n  }7 Q; v* \0 D& {" [
870.     put_bits_context *pb;
     
871.     int bits;
     1 B# U/ ^3 R) r. s+ [6 R# E
872. 
     4 d5 i' |. v2 L' S% @, J$ q9 V
873.     init_get_bits(&gb, bytestream, bytestream_size);
     
874.     pb = init_put_bits();
     
875. 
     : ^% f# o6 U2 g
876.     for (i = 1; i <= 12; i++)
     
877.     {
     
878.         bits = view_bits(&gb, i);
     1 s5 L0 K1 r% N. T4 x
879.         printf("view %d bits: %d\n", i, bits);
     
880.         printf("read %d bits: %d\n", i, read_bits(&gb, i));
     
881.         put_bits(pb, bits, i);
     . ~% A' g4 {7 Z! x. p
882.     }
     
883.     put_bits_flush(pb);
     
884. 
     . F/ Y3 }+ ^; J# `* z0 S
885.     printf("original bytestream:\n");
     0 U7 k5 I- o+ z0 m
886.     for (i = 0; i < bytestream_size; i++)
     
887.         printf(" %02X", bytestream[i]);
     ) j& r) K" j! Z" N- z! J
888.     printf("\nnewbytestream:\n");
     3 J, C8 Z; b- H! \& C4 z
889.     for (i = 0; i < pb->byte_index; i++)
     ; l1 \, i$ p; x
890.         printf(" %02X", pb->bytes[i]);
     , E  z) L) [/ N5 ]
891.     printf("\n");
     
892. 
     
893.     delete_get_bits(&gb);
     9 ~7 h+ G# l5 K7 G( E& w( f" _) t
894.     free(pb);
     + R4 h, w* U/ }$ y5 D7 H$ K- h
895. #endif
     " Y0 g3 k3 Z$ l# a+ L4 v
896. 
     ! N/ c$ z: K8 b* M3 \: t. O' ]) @
897.     /* validate the number of arguments */
     
898.     if (argc != 8 && argc != 9)
     
899.     {
     ' V: K7 v5 @- W
900.         printf("USAGE: subtitle-rbt <subtitles.ass> <in.rbt> <out.rbt> <origin X> <origin Y> <width> <height> [dump_frames]\n");
     : ?2 R0 n/ J8 n3 u
901.         return 1;
     
902.     }
     * N, E; o" `2 C+ d4 e6 j7 z
903.     subtitle_filename = argv[1];
     ( J: Q$ |0 O6 K* h
904.     inrbt_filename = argv[2];
     
905.     outrbt_filename = argv[3];
     
906.     origin_x = atoi(argv[4]);
     
907.     origin_y = atoi(argv[5]);
     
908.     window_width = atoi(argv[6]);
     / ?7 Q% [( n/ i% ~
909.     window_height = atoi(argv[7]);
     
910.     rbt.dump_frames = 0;
     4 ~4 }7 T; @9 o7 i; r/ }! r
911.     if (argc == 9)
     # c* b: Z, ?, \# a
912.         rbt.dump_frames = 1;
     
913. 
     % I" y5 O& E7 w* _( }: \7 i& L
914.     /* verify that the specified input files are valid */
     ) E, A" Q6 F+ z
915.     subtitle_file = fopen(subtitle_filename, "r");
     # d& e) F) J; k- {
916.     if (!subtitle_file)
     $ `. N) r% t6 C- k# ^- o
917.     {
     
918.         perror(subtitle_filename);
     
919.         return 1;
     2 _- `1 F4 M, T$ |& A" k' d
920.     }
     . {& _* m- f3 B$ {$ @* u0 y, ?
921.     fclose(subtitle_file);
     2 s/ M' e! R- a% Y2 l$ R
922.     inrbt_file = fopen(inrbt_filename, "rb");
     
923.     if (!inrbt_file)
     
924.     {
     
925.         perror(inrbt_filename);
     
926.         return 1;
     2 K4 x: `9 o1 z, P
927.     }
     . Y( B5 ~8 g9 f3 U, a; I( M7 V
928. 
     : j8 c7 H9 P1 R8 B6 z
929.     /* initialize the subtitle support */
     / _4 Z6 j/ _5 L1 p3 z* t
930.     rbt.ass_lib = ass_library_init();
     
931.     rbt.ass_renderer = ass_renderer_init(rbt.ass_lib);
     ( H: m' g, ~; u4 g  b( U% t( L8 Z
932.     rbt.ass_track = ass_read_file(rbt.ass_lib, subtitle_filename, "UTF-8");
     / P- x4 Z) H2 [
933.     ass_set_frame_size(rbt.ass_renderer, window_width, window_height);
     
934.     ass_set_fonts(rbt.ass_renderer, NULL, NULL, 1, NULL, 1);
     
935. 
     
936.     /* open the output file */
     4 N/ }' M, d. Q0 [9 c% R  m$ Z
937.     outrbt_file = fopen(outrbt_filename, "wb");
     3 W8 l: v; S+ J5 s8 S
938.     if (!outrbt_file)
     
939.     {
     
940.         perror(outrbt_filename);
     
941.         return 1;
     
942.     }
     " L8 i9 o* \7 ^- h4 l. k# R
943. 
     
944.     /* transfer header from input to output */
     
945.     if (!load_and_copy_rbt_header(&rbt, inrbt_file, outrbt_file))
     
946.         return 1;
     9 ?! M$ j+ d6 n$ _
947. 
     
948.     /* rewrite the frames */
     9 ?7 z4 ]" F+ _$ J; Y
949.     if (!copy_frames(&rbt, inrbt_file, outrbt_file, origin_x, origin_y,
     0 j1 n, p" J& G; \5 g4 ?
950.         window_width, window_height))
     
951.         return 1;
     8 z6 s! D; _3 P2 T
952. 
     
953.     /* write the modified frame size tables back to the file */
     ; C2 Z4 ]9 ~  ^# n9 C4 l: @
954.     fseek(outrbt_file, rbt.video_frame_size_table_offset, SEEK_SET);
     
955.     fwrite(rbt.video_frame_size_table, rbt.frame_count * sizeof(uint16_t), 1, outrbt_file);
     
956.     fseek(outrbt_file, rbt.frame_size_table_offset, SEEK_SET);
     
957.     fwrite(rbt.frame_size_table, rbt.frame_count * sizeof(uint16_t), 1, outrbt_file);
     5 v: |* S2 G2 V! j# \7 n+ f
958. 
     
959.     /* finished with files */
     
960.     fclose(inrbt_file);
     
961.     fclose(outrbt_file);
     
962. 
     
963.     /* clean up subtitle library */
     % M7 T9 }! Q6 w5 l5 B' l2 T
964.     ass_free_track(rbt.ass_track);
     
965.     ass_renderer_done(rbt.ass_renderer);
     ' B: g( t! p* t
966.     ass_library_done(rbt.ass_lib);
     
967. 
     : n; `) @  Z/ T/ ~
968.     /* clean up */
     % g7 N8 f  c! `; i
969.     free(rbt.frame_load_buffer);
     * N, f9 U9 i9 q. T! H
970.     free(rbt.video_frame_size_table);
     2 l% \4 [% M4 i  o2 p$ ?, v
971.     free(rbt.frame_size_table);
     
972. 
     & h4 ?6 M) n/ w
973.     return 0;
     
974. }

复制代码

$ f( n# y- e& n
; w6 D' N' {# X) O# j$ N- X
8 p" ^4 o& [6 J" x- V

shane007

顶上来

宿矢

求汉化啊！

shane007

引用第3楼soring123于2009-11-19 17:07发表的  :
+ Z( t. P9 H" A- V2 q我记得是没字幕的 比较麻烦 都是视频的

2 ~1 D$ k: ?6 B- ~0 n给视频外挂字幕方式汉化也许能行。
要结合dosbox和代理dll技术。

soring123

我记得是没字幕的 比较麻烦 都是视频的

shane007

引用第1楼soring123于2009-11-19 11:09发表的  :
这游戏有字幕吗？

4 V3 C% N3 c( t2 b好像没有字幕，我说的是给视频外挂字幕方式的汉化。
就像syberia2汉化版下面那行字一样。

soring123

这游戏有字幕吗？