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

shane007

; T0 P' x- I$ _; l& h# n最近找到了一些和幽魂系列Phantasmagoria 有关的资料，
9 h; o6 H& K7 i$ A7 L5 j( M, p也许将来可以用于汉化。

和日文版有关的信息
) z, m7 \  M6 u; |1 i5 @3 Uhttp://anthonylarme.tripod.com/phantas/phintgtp.html
6 d" E9 }) g7 a! f' _
相关工具
http://anthonylarme.tripod.com/phantas/phcheats.html
-----------------------------------------------------------------------
2012/1/2  更新
关于幽魂游戏的字幕
Phantasmagoria subtitles function discovered - ScummVM :: Forums
; k6 o+ @3 t3 P2 n
VMD文件
, E1 D. B) F; V2 s7 q9 r( K$ q* USubtitling Sierra VMD Files | Breaking Eggs And Making Omelettes (multimedia.cx)VMD - MultimediaWiki

字幕
Subtitling Sierra RBT Files | Breaking Eggs And Making Omelettes (multimedia.cx)
! F7 r- G8 q, R: s4 h+ F
FFmpeg/subtitle-rbt.c at feature/VMD_encoder · multimediamike/FFmpeg · GitHub
0 v5 h9 x5 a' z+ c1 ^0 e" ]6 J

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

复制代码

5 [% i& Z8 T- @) ~

0 U* S; u5 K, V: Z; n
- d- d, x5 ^% N  @3 E

soring123

这游戏有字幕吗？

shane007

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

4 C* V: a% V: ]! n7 K好像没有字幕，我说的是给视频外挂字幕方式的汉化。
! m8 F  p$ C  G& k9 }就像syberia2汉化版下面那行字一样。

soring123

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

shane007

引用第3楼soring123于2009-11-19 17:07发表的  :
我记得是没字幕的 比较麻烦 都是视频的

给视频外挂字幕方式汉化也许能行。
要结合dosbox和代理dll技术。

宿矢

求汉化啊！

shane007

顶上来