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

shane007

, n! p- I- k9 i* n% F6 ]$ W* q# m最近找到了一些和幽魂系列Phantasmagoria 有关的资料，
也许将来可以用于汉化。
) t) F4 s$ C6 v% b2 H' a
和日文版有关的信息
http://anthonylarme.tripod.com/phantas/phintgtp.html
% B- [# B4 C9 R& s
相关工具
http://anthonylarme.tripod.com/phantas/phcheats.html
-----------------------------------------------------------------------
2012/1/2  更新
2 ?8 m/ t$ Q! ~( @+ K' Z" s' o关于幽魂游戏的字幕
Phantasmagoria subtitles function discovered - ScummVM :: Forums

. {$ o# ]  r2 s. c6 B' V3 Y$ UVMD文件
% c1 Q/ U0 D# Z3 R2 L9 }5 DSubtitling Sierra VMD Files | Breaking Eggs And Making Omelettes (multimedia.cx)VMD - MultimediaWiki
2 E+ ]+ n0 J  L6 A/ P
字幕
% i( ?5 r! x6 ]6 C7 [$ pSubtitling Sierra RBT Files | Breaking Eggs And Making Omelettes (multimedia.cx)

7 O" n4 {5 ^  `' n: r' UFFmpeg/subtitle-rbt.c at feature/VMD_encoder · multimediamike/FFmpeg · GitHub

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

复制代码

2 ?4 N6 y* d% ]% l" h2 t3 }( ~

- j& ~3 `) k: `3 Y( [

soring123

这游戏有字幕吗？

shane007

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

好像没有字幕，我说的是给视频外挂字幕方式的汉化。
就像syberia2汉化版下面那行字一样。

soring123

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

shane007

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

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

宿矢

求汉化啊！

shane007

顶上来